mirror of
https://github.com/korenkonder/ReDIVA.git
synced 2026-10-05 05:07:56 +03:00
2413 lines
73 KiB
C++
2413 lines
73 KiB
C++
/*
|
|
by korenkonder
|
|
GitHub/GitLab: korenkonder
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "default.hpp"
|
|
#include "half_t.hpp"
|
|
#include <xmmintrin.h>
|
|
#include <emmintrin.h>
|
|
|
|
struct vec2i8 {
|
|
int8_t x;
|
|
int8_t y;
|
|
|
|
inline vec2i8() : x(), y() {
|
|
|
|
}
|
|
|
|
inline vec2i8(int8_t value) : x(value), y(value) {
|
|
|
|
}
|
|
|
|
inline vec2i8(int8_t x, int8_t y) : x(x), y(y) {
|
|
|
|
}
|
|
};
|
|
|
|
struct vec3i8 {
|
|
int8_t x;
|
|
int8_t y;
|
|
int8_t z;
|
|
|
|
inline vec3i8() : x(), y(), z() {
|
|
|
|
}
|
|
|
|
inline vec3i8(int8_t value) : x(value), y(value), z(value) {
|
|
|
|
}
|
|
|
|
inline vec3i8(int8_t x, int8_t y, int8_t z) : x(x), y(y), z(z) {
|
|
|
|
}
|
|
};
|
|
|
|
struct vec4i8 {
|
|
int8_t x;
|
|
int8_t y;
|
|
int8_t z;
|
|
int8_t w;
|
|
|
|
inline vec4i8() : x(), y(), z(), w() {
|
|
|
|
}
|
|
|
|
inline vec4i8(int8_t value) : x(value), y(value), z(value), w(value) {
|
|
|
|
}
|
|
|
|
inline vec4i8(int8_t x, int8_t y, int8_t z, int8_t w) : x(x), y(y), z(z), w(w) {
|
|
|
|
}
|
|
};
|
|
|
|
struct vec2u8 {
|
|
uint8_t x;
|
|
uint8_t y;
|
|
|
|
inline vec2u8() : x(), y() {
|
|
|
|
}
|
|
|
|
inline vec2u8(uint8_t value) : x(value), y(value) {
|
|
|
|
}
|
|
|
|
inline vec2u8(uint8_t x, uint8_t y) : x(x), y(y) {
|
|
|
|
}
|
|
};
|
|
|
|
struct vec3u8 {
|
|
uint8_t x;
|
|
uint8_t y;
|
|
uint8_t z;
|
|
|
|
inline vec3u8() : x(), y(), z() {
|
|
|
|
}
|
|
|
|
inline vec3u8(uint8_t value) : x(value), y(value), z(value) {
|
|
|
|
}
|
|
|
|
inline vec3u8(uint8_t x, uint8_t y, uint8_t z) : x(x), y(y), z(z) {
|
|
|
|
}
|
|
};
|
|
|
|
struct vec4u8 {
|
|
uint8_t x;
|
|
uint8_t y;
|
|
uint8_t z;
|
|
uint8_t w;
|
|
|
|
inline vec4u8() : x(), y(), z(), w() {
|
|
|
|
}
|
|
|
|
inline vec4u8(uint8_t value) : x(value), y(value), z(value), w(value) {
|
|
|
|
}
|
|
|
|
inline vec4u8(uint8_t x, uint8_t y, uint8_t z, uint8_t w) : x(x), y(y), z(z), w(w) {
|
|
|
|
}
|
|
};
|
|
|
|
struct vec2i16 {
|
|
int16_t x;
|
|
int16_t y;
|
|
|
|
inline vec2i16() : x(), y() {
|
|
|
|
}
|
|
|
|
inline vec2i16(int16_t value) : x(value), y(value) {
|
|
|
|
}
|
|
|
|
inline vec2i16(int16_t x, int16_t y) : x(x), y(y) {
|
|
|
|
}
|
|
};
|
|
|
|
struct vec3i16 {
|
|
int16_t x;
|
|
int16_t y;
|
|
int16_t z;
|
|
|
|
inline vec3i16() : x(), y(), z() {
|
|
|
|
}
|
|
|
|
inline vec3i16(int16_t value) : x(value), y(value), z(value) {
|
|
|
|
}
|
|
|
|
inline vec3i16(int16_t x, int16_t y, int16_t z) : x(x), y(y), z(z) {
|
|
|
|
}
|
|
};
|
|
|
|
struct vec4i16 {
|
|
int16_t x;
|
|
int16_t y;
|
|
int16_t z;
|
|
int16_t w;
|
|
|
|
inline vec4i16() : x(), y(), z(), w() {
|
|
|
|
}
|
|
|
|
inline vec4i16(int16_t value) : x(value), y(value), z(value), w(value) {
|
|
|
|
}
|
|
|
|
inline vec4i16(int16_t x, int16_t y, int16_t z, int16_t w) : x(x), y(y), z(z), w(w) {
|
|
|
|
}
|
|
};
|
|
|
|
struct vec2u16 {
|
|
uint16_t x;
|
|
uint16_t y;
|
|
|
|
inline vec2u16() : x(), y() {
|
|
|
|
}
|
|
|
|
inline vec2u16(uint16_t value) : x(value), y(value) {
|
|
|
|
}
|
|
|
|
inline vec2u16(uint16_t x, uint16_t y) : x(x), y(y) {
|
|
|
|
}
|
|
};
|
|
|
|
struct vec3u16 {
|
|
uint16_t x;
|
|
uint16_t y;
|
|
uint16_t z;
|
|
|
|
inline vec3u16() : x(), y(), z() {
|
|
|
|
}
|
|
|
|
inline vec3u16(uint16_t value) : x(value), y(value), z(value) {
|
|
|
|
}
|
|
|
|
inline vec3u16(uint16_t x, uint16_t y, uint16_t z) : x(x), y(y), z(z) {
|
|
|
|
}
|
|
};
|
|
|
|
struct vec4u16 {
|
|
uint16_t x;
|
|
uint16_t y;
|
|
uint16_t z;
|
|
uint16_t w;
|
|
|
|
inline vec4u16() : x(), y(), z(), w() {
|
|
|
|
}
|
|
|
|
inline vec4u16(uint16_t value) : x(value), y(value), z(value), w(value) {
|
|
|
|
}
|
|
|
|
inline vec4u16(uint16_t x, uint16_t y, uint16_t z, uint16_t w) : x(x), y(y), z(z), w(w) {
|
|
|
|
}
|
|
};
|
|
|
|
struct vec2h {
|
|
half_t x;
|
|
half_t y;
|
|
|
|
inline vec2h() : x(), y() {
|
|
|
|
}
|
|
|
|
inline vec2h(half_t value) : x(value), y(value) {
|
|
|
|
}
|
|
|
|
inline vec2h(half_t x, half_t y) : x(x), y(y) {
|
|
|
|
}
|
|
};
|
|
|
|
struct vec3h {
|
|
half_t x;
|
|
half_t y;
|
|
half_t z;
|
|
|
|
inline vec3h() : x(), y(), z() {
|
|
|
|
}
|
|
|
|
inline vec3h(half_t value) : x(value), y(value), z(value) {
|
|
|
|
}
|
|
|
|
inline vec3h(half_t x, half_t y, half_t z) : x(x), y(y), z(z) {
|
|
|
|
}
|
|
};
|
|
|
|
struct vec4h {
|
|
half_t x;
|
|
half_t y;
|
|
half_t z;
|
|
half_t w;
|
|
|
|
inline vec4h() : x(), y(), z(), w() {
|
|
|
|
}
|
|
|
|
inline vec4h(half_t value) : x(value), y(value), z(value), w(value) {
|
|
|
|
}
|
|
|
|
inline vec4h(half_t x, half_t y, half_t z, half_t w) : x(x), y(y), z(z), w(w) {
|
|
|
|
}
|
|
};
|
|
|
|
struct vec2 {
|
|
float_t x;
|
|
float_t y;
|
|
|
|
vec2();
|
|
vec2(float_t value);
|
|
vec2(float_t x, float_t y);
|
|
|
|
static __m128 load_xmm(const float_t data);
|
|
static __m128 load_xmm(const vec2& data);
|
|
static __m128 load_xmm(const vec2&& data);
|
|
static vec2 store_xmm(const __m128& data);
|
|
static vec2 store_xmm(const __m128&& data);
|
|
|
|
static float_t angle(const vec2& left, const vec2& right);
|
|
static float_t dot(const vec2& left, const vec2& right);
|
|
static float_t length(const vec2& left);
|
|
static float_t length_squared(const vec2& left);
|
|
static float_t distance(const vec2& left, const vec2& right);
|
|
static float_t distance_squared(const vec2& left, const vec2& right);
|
|
static vec2 abs(const vec2& left);
|
|
static vec2 lerp(const vec2& left, const vec2& right, const vec2& blend);
|
|
static vec2 lerp(const vec2& left, const vec2& right, const float_t blend);
|
|
static vec2 normalize(const vec2& left);
|
|
static vec2 normalize_rcp(const vec2& left);
|
|
static vec2 rcp(const vec2& left);
|
|
static vec2 min(const vec2& left, const vec2& right);
|
|
static vec2 max(const vec2& left, const vec2& right);
|
|
static vec2 clamp(const vec2& left, const vec2& min, const vec2& max);
|
|
static vec2 clamp(const vec2& left, const float_t min, const float_t max);
|
|
static vec2 mult_min_max(const vec2& left, const vec2& min, const vec2& max);
|
|
static vec2 mult_min_max(const vec2& left, const float_t min, const float_t max);
|
|
static vec2 div_min_max(const vec2& left, const vec2& min, const vec2& max);
|
|
static vec2 div_min_max(const vec2& left, const float_t min, const float_t max);
|
|
};
|
|
|
|
struct vec3 {
|
|
float_t x;
|
|
float_t y;
|
|
float_t z;
|
|
|
|
vec3();
|
|
vec3(float_t value);
|
|
vec3(float_t x, float_t y, float_t z);
|
|
|
|
static __m128 load_xmm(const float_t data);
|
|
static __m128 load_xmm(const vec3& data);
|
|
static __m128 load_xmm(const vec3&& data);
|
|
static vec3 store_xmm(const __m128& data);
|
|
static vec3 store_xmm(const __m128&& data);
|
|
|
|
static float_t angle(const vec3& left, const vec3& right);
|
|
static float_t dot(const vec3& left, const vec3& right);
|
|
static float_t length(const vec3& left);
|
|
static float_t length_squared(const vec3& left);
|
|
static float_t distance(const vec3& left, const vec3& right);
|
|
static float_t distance_squared(const vec3& left, const vec3& right);
|
|
static vec3 abs(const vec3& left);
|
|
static vec3 lerp(const vec3& left, const vec3& right, const vec3& blend);
|
|
static vec3 lerp(const vec3& left, const vec3& right, const float_t blend);
|
|
static vec3 normalize(const vec3& left);
|
|
static vec3 normalize_rcp(const vec3& left);
|
|
static vec3 rcp(const vec3& left);
|
|
static vec3 min(const vec3& left, const vec3& right);
|
|
static vec3 max(const vec3& left, const vec3& right);
|
|
static vec3 clamp(const vec3& left, const vec3& min, const vec3& max);
|
|
static vec3 clamp(const vec3& left, const float_t min, const float_t max);
|
|
static vec3 mult_min_max(const vec3& left, const vec3& min, const vec3& max);
|
|
static vec3 mult_min_max(const vec3& left, const float_t min, const float_t max);
|
|
static vec3 div_min_max(const vec3& left, const vec3& min, const vec3& max);
|
|
static vec3 div_min_max(const vec3& left, const float_t min, const float_t max);
|
|
static vec3 cross(const vec3& left, const vec3& right);
|
|
};
|
|
|
|
struct vec4 {
|
|
float_t x;
|
|
float_t y;
|
|
float_t z;
|
|
float_t w;
|
|
|
|
vec4();
|
|
vec4(float_t value);
|
|
vec4(float_t x, float_t y, float_t z, float_t w);
|
|
|
|
static __m128 load_xmm(const float_t data);
|
|
static __m128 load_xmm(const vec4& data);
|
|
static __m128 load_xmm(const vec4&& data);
|
|
static vec4 store_xmm(const __m128& data);
|
|
static vec4 store_xmm(const __m128&& data);
|
|
|
|
static float_t angle(const vec4& left, const vec4& right);
|
|
static float_t dot(const vec4& left, const vec4& right);
|
|
static float_t length(const vec4& left);
|
|
static float_t length_squared(const vec4& left);
|
|
static float_t distance(const vec4& left, const vec4& right);
|
|
static float_t distance_squared(const vec4& left, const vec4& right);
|
|
static vec4 abs(const vec4& left);
|
|
static vec4 lerp(const vec4& left, const vec4& right, const vec4& blend);
|
|
static vec4 lerp(const vec4& left, const vec4& right, const float_t blend);
|
|
static vec4 normalize(const vec4& left);
|
|
static vec4 normalize_rcp(const vec4& left);
|
|
static vec4 rcp(const vec4& left);
|
|
static vec4 min(const vec4& min, const vec4& max);
|
|
static vec4 max(const vec4& min, const vec4& max);
|
|
static vec4 clamp(const vec4& left, const vec4& min, const vec4& max);
|
|
static vec4 clamp(const vec4& left, const float_t min, const float_t max);
|
|
static vec4 mult_min_max(const vec4& left, const vec4& min, const vec4& max);
|
|
static vec4 mult_min_max(const vec4& left, const float_t min, const float_t max);
|
|
static vec4 div_min_max(const vec4& left, const vec4& min, const vec4& max);
|
|
static vec4 div_min_max(const vec4& left, const float_t min, const float_t max);
|
|
};
|
|
|
|
struct vec2i {
|
|
int32_t x;
|
|
int32_t y;
|
|
|
|
vec2i();
|
|
vec2i(int32_t value);
|
|
vec2i(int32_t x, int32_t y);
|
|
|
|
static __m128i load_xmm(const int32_t data);
|
|
static __m128i load_xmm(const vec2i& data);
|
|
static __m128i load_xmm(const vec2i&& data);
|
|
static vec2i store_xmm(const __m128i& data);
|
|
static vec2i store_xmm(const __m128i&& data);
|
|
|
|
static vec2i min(const vec2i& left, const vec2i& right);
|
|
static vec2i max(const vec2i& left, const vec2i& right);
|
|
static vec2i clamp(const vec2i& left, const vec2i& min, const vec2i& max);
|
|
static vec2i clamp(const vec2i& left, const int32_t min, const int32_t max);
|
|
};
|
|
|
|
struct vec3i {
|
|
int32_t x;
|
|
int32_t y;
|
|
int32_t z;
|
|
|
|
vec3i();
|
|
vec3i(int32_t value);
|
|
vec3i(int32_t x, int32_t y, int32_t z);
|
|
|
|
static __m128i load_xmm(const int32_t data);
|
|
static __m128i load_xmm(const vec3i& data);
|
|
static __m128i load_xmm(const vec3i&& data);
|
|
static vec3i store_xmm(const __m128i& data);
|
|
static vec3i store_xmm(const __m128i&& data);
|
|
|
|
static vec3i min(const vec3i& left, const vec3i& right);
|
|
static vec3i max(const vec3i& left, const vec3i& right);
|
|
static vec3i clamp(const vec3i& left, const vec3i& min, const vec3i& max);
|
|
static vec3i clamp(const vec3i& left, const int32_t min, const int32_t max);
|
|
};
|
|
|
|
struct vec4i {
|
|
int32_t x;
|
|
int32_t y;
|
|
int32_t z;
|
|
int32_t w;
|
|
|
|
vec4i();
|
|
vec4i(int32_t value);
|
|
vec4i(int32_t x, int32_t y, int32_t z, int32_t w);
|
|
|
|
static __m128i load_xmm(const int32_t data);
|
|
static __m128i load_xmm(const vec4i& data);
|
|
static __m128i load_xmm(const vec4i&& data);
|
|
static vec4i store_xmm(const __m128i& data);
|
|
static vec4i store_xmm(const __m128i&& data);
|
|
|
|
static vec4i min(const vec4i& left, const vec4i& right);
|
|
static vec4i max(const vec4i& left, const vec4i& right);
|
|
static vec4i clamp(const vec4i& left, const vec4i& min, const vec4i& max);
|
|
static vec4i clamp(const vec4i& left, const int32_t min, const int32_t max);
|
|
};
|
|
|
|
struct vec2d {
|
|
double_t x;
|
|
double_t y;
|
|
|
|
vec2d();
|
|
vec2d(double_t value);
|
|
vec2d(double_t x, double_t y);
|
|
|
|
static __m128d load_xmm(const double_t data);
|
|
static __m128d load_xmm(const vec2d& data);
|
|
static __m128d load_xmm(const vec2d&& data);
|
|
static vec2d store_xmm(const __m128d& data);
|
|
static vec2d store_xmm(const __m128d&& data);
|
|
|
|
static double_t angle(const vec2d& left, const vec2d& right);
|
|
static double_t dot(const vec2d& left, const vec2d& right);
|
|
static double_t length(const vec2d& left);
|
|
static double_t length_squared(const vec2d& left);
|
|
static double_t distance(const vec2d& left, const vec2d& right);
|
|
static double_t distance_squared(const vec2d& left, const vec2d& right);
|
|
static vec2d abs(const vec2d& left);
|
|
static vec2d lerp(const vec2d& left, const vec2d& right, const vec2d& blend);
|
|
static vec2d lerp(const vec2d& left, const vec2d& right, const double_t blend);
|
|
static vec2d normalize(const vec2d& left);
|
|
static vec2d normalize_rcp(const vec2d& left);
|
|
static vec2d rcp(const vec2d& left);
|
|
static vec2d min(const vec2d& left, const vec2d& right);
|
|
static vec2d max(const vec2d& left, const vec2d& right);
|
|
static vec2d clamp(const vec2d& left, const vec2d& min, const vec2d& max);
|
|
static vec2d clamp(const vec2d& left, const double_t min, const double_t max);
|
|
static vec2d mult_min_max(const vec2d& left, const vec2d& min, const vec2d& max);
|
|
static vec2d mult_min_max(const vec2d& left, const double_t min, const double_t max);
|
|
static vec2d div_min_max(const vec2d& left, const vec2d& min, const vec2d& max);
|
|
static vec2d div_min_max(const vec2d& left, const double_t min, const double_t max);
|
|
};
|
|
|
|
extern const __m128 vec2_neg;
|
|
extern const __m128 vec3_neg;
|
|
extern const __m128 vec4_neg;
|
|
|
|
extern const __m128d vec2d_neg;
|
|
|
|
extern const __m128i vec2i_abs;
|
|
extern const __m128i vec3i_abs;
|
|
extern const __m128i vec4i_abs;
|
|
|
|
extern const __m128i vec2i64_abs;
|
|
|
|
inline vec2::vec2() : x(), y() {
|
|
|
|
}
|
|
|
|
inline vec2::vec2(float_t value) : x(value), y(value) {
|
|
|
|
}
|
|
|
|
inline vec2::vec2(float_t x, float_t y) : x(x), y(y) {
|
|
|
|
}
|
|
|
|
inline __m128 vec2::load_xmm(const float_t data) {
|
|
__m128 _data = _mm_load_ss(&data);
|
|
return _mm_shuffle_ps(_data, _data, 0x50);
|
|
}
|
|
|
|
inline __m128 vec2::load_xmm(const vec2& data) {
|
|
return _mm_castsi128_ps(_mm_loadl_epi64((const __m128i*) & data));
|
|
}
|
|
|
|
inline __m128 vec2::load_xmm(const vec2&& data) {
|
|
return _mm_castsi128_ps(_mm_loadl_epi64((const __m128i*) & data));
|
|
}
|
|
|
|
inline vec2 vec2::store_xmm(const __m128& data) {
|
|
vec2 _data;
|
|
_mm_storel_epi64((__m128i*) & _data, _mm_castps_si128(data));
|
|
return _data;
|
|
}
|
|
|
|
inline vec2 vec2::store_xmm(const __m128&& data) {
|
|
vec2 _data;
|
|
_mm_storel_epi64((__m128i*) & _data, _mm_castps_si128(data));
|
|
return _data;
|
|
}
|
|
|
|
inline vec2 operator+(const vec2& left, const vec2& right) {
|
|
return vec2::store_xmm(_mm_add_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 operator+(const vec2& left, const float_t right) {
|
|
return vec2::store_xmm(_mm_add_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 operator+(const float_t left, const vec2& right) {
|
|
return vec2::store_xmm(_mm_add_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator+=(vec2& left, const vec2& right) {
|
|
left = vec2::store_xmm(_mm_add_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator+=(vec2& left, const float_t right) {
|
|
left = vec2::store_xmm(_mm_add_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 operator-(const vec2& left, const vec2& right) {
|
|
return vec2::store_xmm(_mm_sub_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 operator-(const vec2& left, const float_t right) {
|
|
return vec2::store_xmm(_mm_sub_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 operator-(const float_t left, const vec2& right) {
|
|
return vec2::store_xmm(_mm_sub_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator-=(vec2& left, const vec2& right) {
|
|
left = vec2::store_xmm(_mm_sub_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator-=(vec2& left, const float_t right) {
|
|
left = vec2::store_xmm(_mm_sub_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 operator*(const vec2& left, const vec2& right) {
|
|
return vec2::store_xmm(_mm_mul_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 operator*(const vec2& left, const float_t right) {
|
|
return vec2::store_xmm(_mm_mul_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 operator*(const float_t left, const vec2& right) {
|
|
return vec2::store_xmm(_mm_mul_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator*=(vec2& left, const vec2& right) {
|
|
left = vec2::store_xmm(_mm_mul_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator*=(vec2& left, const float_t right) {
|
|
left = vec2::store_xmm(_mm_mul_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 operator/(const vec2& left, const vec2& right) {
|
|
return vec2::store_xmm(_mm_div_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 operator/(const vec2& left, const float_t right) {
|
|
return vec2::store_xmm(_mm_div_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 operator/(const float_t left, const vec2& right) {
|
|
return vec2::store_xmm(_mm_div_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator/=(vec2& left, const vec2& right) {
|
|
left = vec2::store_xmm(_mm_div_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator/=(vec2& left, const float_t right) {
|
|
left = vec2::store_xmm(_mm_div_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 operator&(const vec2& left, const vec2& right) {
|
|
return vec2::store_xmm(_mm_and_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 operator&(const vec2& left, const float_t right) {
|
|
return vec2::store_xmm(_mm_and_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 operator&(const float_t left, const vec2& right) {
|
|
return vec2::store_xmm(_mm_and_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator&=(vec2& left, const vec2& right) {
|
|
left = vec2::store_xmm(_mm_and_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator&=(vec2& left, const float_t right) {
|
|
left = vec2::store_xmm(_mm_and_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 operator^(const vec2& left, const vec2& right) {
|
|
return vec2::store_xmm(_mm_xor_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 operator^(const vec2& left, const float_t right) {
|
|
return vec2::store_xmm(_mm_xor_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 operator^(const float_t left, const vec2& right) {
|
|
return vec2::store_xmm(_mm_xor_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator^=(vec2& left, const vec2& right) {
|
|
left = vec2::store_xmm(_mm_xor_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator^=(vec2& left, const float_t right) {
|
|
left = vec2::store_xmm(_mm_xor_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 operator-(const vec2& left) {
|
|
return vec2::store_xmm(_mm_xor_ps(vec2::load_xmm(left), vec2_neg));
|
|
}
|
|
|
|
inline bool operator==(const vec2& left, const vec2& right) {
|
|
return !memcmp(&left, &right, sizeof(vec2));
|
|
}
|
|
|
|
inline bool operator!=(const vec2& left, const vec2& right) {
|
|
return !(left == right);
|
|
}
|
|
|
|
inline float_t vec2::angle(const vec2& left, const vec2& right) {
|
|
return acosf(vec2::dot(left, right) / (vec2::length(left) * vec2::length(right)));
|
|
}
|
|
|
|
inline float_t vec2::dot(const vec2& left, const vec2& right) {
|
|
__m128 zt;
|
|
zt = _mm_mul_ps(vec2::load_xmm(left), vec2::load_xmm(right));
|
|
return _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
|
|
}
|
|
|
|
inline float_t vec2::length(const vec2& left) {
|
|
__m128 xt;
|
|
__m128 zt;
|
|
xt = vec2::load_xmm(left);
|
|
zt = _mm_mul_ps(xt, xt);
|
|
return _mm_cvtss_f32(_mm_sqrt_ss(_mm_hadd_ps(zt, zt)));
|
|
}
|
|
|
|
inline float_t vec2::length_squared(const vec2& left) {
|
|
__m128 xt;
|
|
__m128 zt;
|
|
xt = vec2::load_xmm(left);
|
|
zt = _mm_mul_ps(xt, xt);
|
|
return _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
|
|
}
|
|
|
|
inline float_t vec2::distance(const vec2& left, const vec2& right) {
|
|
__m128 zt;
|
|
zt = _mm_sub_ps(vec2::load_xmm(left), vec2::load_xmm(right));
|
|
zt = _mm_mul_ps(zt, zt);
|
|
return _mm_cvtss_f32(_mm_sqrt_ss(_mm_hadd_ps(zt, zt)));
|
|
}
|
|
|
|
inline float_t vec2::distance_squared(const vec2& left, const vec2& right) {
|
|
__m128 zt;
|
|
zt = _mm_sub_ps(vec2::load_xmm(left), vec2::load_xmm(right));
|
|
zt = _mm_mul_ps(zt, zt);
|
|
return _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
|
|
}
|
|
|
|
inline vec2 vec2::abs(const vec2& left) {
|
|
return vec2::store_xmm(_mm_castsi128_ps(_mm_and_si128(_mm_castps_si128(vec2::load_xmm(left)), vec2i_abs)));
|
|
}
|
|
|
|
inline vec2 vec2::lerp(const vec2& left, const vec2& right, const vec2& blend) {
|
|
__m128 b1;
|
|
__m128 b2;
|
|
b1 = vec2::load_xmm(blend);
|
|
b2 = _mm_sub_ps(vec2::load_xmm(1.0f), b1);
|
|
return vec2::store_xmm(_mm_add_ps(_mm_mul_ps(vec2::load_xmm(left), b2),
|
|
_mm_mul_ps(vec2::load_xmm(right), b1)));
|
|
}
|
|
|
|
inline vec2 vec2::lerp(const vec2& left, const vec2& right, const float_t blend) {
|
|
__m128 b1;
|
|
__m128 b2;
|
|
b1 = vec2::load_xmm(blend);
|
|
b2 = _mm_sub_ps(vec2::load_xmm(1.0f), b1);
|
|
return vec2::store_xmm(_mm_add_ps(_mm_mul_ps(vec2::load_xmm(left), b2),
|
|
_mm_mul_ps(vec2::load_xmm(right), b1)));
|
|
}
|
|
|
|
inline vec2 vec2::normalize(const vec2& left) {
|
|
__m128 xt;
|
|
__m128 zt;
|
|
xt = vec2::load_xmm(left);
|
|
zt = _mm_mul_ps(xt, xt);
|
|
zt = _mm_sqrt_ss(_mm_hadd_ps(zt, zt));
|
|
if (_mm_cvtss_f32(zt) != 0.0f)
|
|
return vec2::store_xmm(_mm_div_ps(xt, _mm_shuffle_ps(zt, zt, 0)));
|
|
return vec2::store_xmm(xt);
|
|
}
|
|
|
|
inline vec2 vec2::normalize_rcp(const vec2& left) {
|
|
__m128 xt;
|
|
__m128 zt;
|
|
xt = vec2::load_xmm(left);
|
|
zt = _mm_mul_ps(xt, xt);
|
|
zt = _mm_sqrt_ss(_mm_hadd_ps(zt, zt));
|
|
if (_mm_cvtss_f32(zt) != 0.0f)
|
|
return vec2::store_xmm(_mm_mul_ps(xt, _mm_div_ss(vec2::load_xmm(1.0f), _mm_shuffle_ps(zt, zt, 0))));
|
|
return vec2::store_xmm(xt);
|
|
}
|
|
|
|
inline vec2 vec2::rcp(const vec2& left) {
|
|
return vec2::store_xmm(_mm_div_ps(vec2::load_xmm(1.0f), vec2::load_xmm(left)));
|
|
}
|
|
|
|
inline vec2 vec2::min(const vec2& left, const vec2& right) {
|
|
return vec2::store_xmm(_mm_min_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 vec2::max(const vec2& left, const vec2& right) {
|
|
return vec2::store_xmm(_mm_max_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2 vec2::clamp(const vec2& left, const vec2& min, const vec2& max) {
|
|
return vec2::store_xmm(_mm_min_ps(_mm_max_ps(vec2::load_xmm(left),
|
|
vec2::load_xmm(min)), vec2::load_xmm(max)));
|
|
}
|
|
|
|
inline vec2 vec2::clamp(const vec2& left, const float_t min, const float_t max) {
|
|
return vec2::store_xmm(_mm_min_ps(_mm_max_ps(vec2::load_xmm(left),
|
|
vec2::load_xmm(min)), vec2::load_xmm(max)));
|
|
}
|
|
|
|
inline vec2 vec2::mult_min_max(const vec2& left, const vec2& min, const vec2& max) {
|
|
__m128 xt;
|
|
__m128 yt;
|
|
__m128 zt;
|
|
xt = vec2::load_xmm(left);
|
|
yt = _mm_and_ps(_mm_cmplt_ps(xt, vec4::load_xmm(0.0f)), vec2::load_xmm(-min));
|
|
zt = _mm_and_ps(_mm_cmpge_ps(xt, vec4::load_xmm(0.0f)), vec2::load_xmm(max));
|
|
return vec2::store_xmm(_mm_mul_ps(xt, _mm_or_ps(yt, zt)));
|
|
}
|
|
|
|
inline vec2 vec2::mult_min_max(const vec2& left, const float_t min, const float_t max) {
|
|
__m128 xt;
|
|
__m128 yt;
|
|
__m128 zt;
|
|
xt = vec2::load_xmm(left);
|
|
yt = _mm_and_ps(_mm_cmplt_ps(xt, vec4::load_xmm(0.0f)), vec2::load_xmm(-min));
|
|
zt = _mm_and_ps(_mm_cmpge_ps(xt, vec4::load_xmm(0.0f)), vec2::load_xmm(max));
|
|
return vec2::store_xmm(_mm_mul_ps(xt, _mm_or_ps(yt, zt)));
|
|
}
|
|
|
|
inline vec2 vec2::div_min_max(const vec2& left, const vec2& min, const vec2& max) {
|
|
__m128 xt;
|
|
__m128 yt;
|
|
__m128 zt;
|
|
xt = vec2::load_xmm(left);
|
|
yt = _mm_and_ps(_mm_cmplt_ps(xt, vec4::load_xmm(0.0f)), vec2::load_xmm(-min));
|
|
zt = _mm_and_ps(_mm_cmpge_ps(xt, vec4::load_xmm(0.0f)), vec2::load_xmm(max));
|
|
return vec2::store_xmm(_mm_div_ps(xt, _mm_or_ps(yt, zt)));
|
|
}
|
|
|
|
inline vec2 vec2::div_min_max(const vec2& left, const float_t min, const float_t max) {
|
|
__m128 xt;
|
|
__m128 yt;
|
|
__m128 zt;
|
|
xt = vec2::load_xmm(left);
|
|
yt = _mm_and_ps(_mm_cmplt_ps(xt, vec4::load_xmm(0.0f)), vec2::load_xmm(-min));
|
|
zt = _mm_and_ps(_mm_cmpge_ps(xt, vec4::load_xmm(0.0f)), vec2::load_xmm(max));
|
|
return vec2::store_xmm(_mm_div_ps(xt, _mm_or_ps(yt, zt)));
|
|
}
|
|
|
|
inline vec3::vec3() : x(), y(), z() {
|
|
|
|
}
|
|
|
|
inline vec3::vec3(float_t value) : x(value), y(value), z(value) {
|
|
|
|
}
|
|
|
|
inline vec3::vec3(float_t x, float_t y, float_t z) : x(x), y(y), z(z) {
|
|
|
|
}
|
|
|
|
inline vec3 operator+(const vec3& left, const vec3& right) {
|
|
return vec3::store_xmm(_mm_add_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 operator+(const vec3& left, const float_t right) {
|
|
return vec3::store_xmm(_mm_add_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 operator+(const float_t left, const vec3& right) {
|
|
return vec3::store_xmm(_mm_add_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator+=(vec3& left, const vec3& right) {
|
|
left = vec3::store_xmm(_mm_add_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator+=(vec3& left, const float_t right) {
|
|
left = vec3::store_xmm(_mm_add_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 operator-(const vec3& left, const vec3& right) {
|
|
return vec3::store_xmm(_mm_sub_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 operator-(const vec3& left, const float_t right) {
|
|
return vec3::store_xmm(_mm_sub_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 operator-(const float_t left, const vec3& right) {
|
|
return vec3::store_xmm(_mm_sub_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator-=(vec3& left, const vec3& right) {
|
|
left = vec3::store_xmm(_mm_sub_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator-=(vec3& left, const float_t right) {
|
|
left = vec3::store_xmm(_mm_sub_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 operator*(const vec3& left, const vec3& right) {
|
|
return vec3::store_xmm(_mm_mul_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 operator*(const vec3& left, const float_t right) {
|
|
return vec3::store_xmm(_mm_mul_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 operator*(const float_t left, const vec3& right) {
|
|
return vec3::store_xmm(_mm_mul_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator*=(vec3& left, const vec3& right) {
|
|
left = vec3::store_xmm(_mm_mul_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator*=(vec3& left, const float_t right) {
|
|
left = vec3::store_xmm(_mm_mul_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 operator/(const vec3& left, const vec3& right) {
|
|
return vec3::store_xmm(_mm_div_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 operator/(const vec3& left, const float_t right) {
|
|
return vec3::store_xmm(_mm_div_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 operator/(const float_t left, const vec3& right) {
|
|
return vec3::store_xmm(_mm_div_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator/=(vec3& left, const vec3& right) {
|
|
left = vec3::store_xmm(_mm_div_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator/=(vec3& left, const float_t right) {
|
|
left = vec3::store_xmm(_mm_div_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 operator&(const vec3& left, const vec3& right) {
|
|
return vec3::store_xmm(_mm_and_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 operator&(const vec3& left, const float_t right) {
|
|
return vec3::store_xmm(_mm_and_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 operator&(const float_t left, const vec3& right) {
|
|
return vec3::store_xmm(_mm_and_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator&=(vec3& left, const vec3& right) {
|
|
left = vec3::store_xmm(_mm_and_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator&=(vec3& left, const float_t right) {
|
|
left = vec3::store_xmm(_mm_and_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 operator^(const vec3& left, const vec3& right) {
|
|
return vec3::store_xmm(_mm_xor_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 operator^(const vec3& left, const float_t right) {
|
|
return vec3::store_xmm(_mm_xor_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 operator^(const float_t left, const vec3& right) {
|
|
return vec3::store_xmm(_mm_xor_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator^=(vec3& left, const vec3& right) {
|
|
left = vec3::store_xmm(_mm_xor_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator^=(vec3& left, const float_t right) {
|
|
left = vec3::store_xmm(_mm_xor_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 operator-(const vec3& left) {
|
|
return vec3::store_xmm(_mm_xor_ps(vec3::load_xmm(left), vec3_neg));
|
|
}
|
|
|
|
inline bool operator==(const vec3& left, const vec3& right) {
|
|
return !memcmp(&left, &right, sizeof(vec3));
|
|
}
|
|
|
|
inline bool operator!=(const vec3& left, const vec3& right) {
|
|
return !(left == right);
|
|
}
|
|
|
|
inline __m128 vec3::load_xmm(const float_t data) {
|
|
__m128 _data = _mm_load_ss(&data);
|
|
return _mm_shuffle_ps(_data, _data, 0x40);
|
|
}
|
|
|
|
inline __m128 vec3::load_xmm(const vec3& data) {
|
|
return _mm_movelh_ps(_mm_castsi128_ps(_mm_loadl_epi64((const __m128i*) & data)), _mm_load_ss(&data.z));
|
|
}
|
|
|
|
inline __m128 vec3::load_xmm(const vec3&& data) {
|
|
return _mm_movelh_ps(_mm_castsi128_ps(_mm_loadl_epi64((const __m128i*) & data)), _mm_load_ss(&data.z));
|
|
}
|
|
|
|
inline vec3 vec3::store_xmm(const __m128& data) {
|
|
vec3 _data;
|
|
_mm_storel_epi64((__m128i*) & _data, _mm_castps_si128(data));
|
|
_mm_store_ss(&_data.z, _mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(data), 8)));
|
|
return _data;
|
|
}
|
|
|
|
inline vec3 vec3::store_xmm(const __m128&& data) {
|
|
vec3 _data;
|
|
_mm_storel_epi64((__m128i*) & _data, _mm_castps_si128(data));
|
|
_mm_store_ss(&_data.z, _mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(data), 8)));
|
|
return _data;
|
|
}
|
|
|
|
inline float_t vec3::angle(const vec3& left, const vec3& right) {
|
|
return acosf(vec3::dot(left, right) / (vec3::length(left) * vec3::length(right)));
|
|
}
|
|
|
|
inline float_t vec3::dot(const vec3& left, const vec3& right) {
|
|
__m128 zt;
|
|
zt = _mm_mul_ps(vec3::load_xmm(left), vec3::load_xmm(right));
|
|
zt = _mm_hadd_ps(zt, zt);
|
|
return _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
|
|
}
|
|
|
|
inline float_t vec3::length(const vec3& left) {
|
|
__m128 xt;
|
|
__m128 zt;
|
|
xt = vec3::load_xmm(left);
|
|
zt = _mm_mul_ps(xt, xt);
|
|
zt = _mm_hadd_ps(zt, zt);
|
|
return _mm_cvtss_f32(_mm_sqrt_ss(_mm_hadd_ps(zt, zt)));
|
|
}
|
|
|
|
inline float_t vec3::length_squared(const vec3& left) {
|
|
__m128 xt;
|
|
__m128 zt;
|
|
xt = vec3::load_xmm(left);
|
|
zt = _mm_mul_ps(xt, xt);
|
|
zt = _mm_hadd_ps(zt, zt);
|
|
return _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
|
|
}
|
|
|
|
inline float_t vec3::distance(const vec3& left, const vec3& right) {
|
|
__m128 xt;
|
|
__m128 yt;
|
|
__m128 zt;
|
|
xt = vec3::load_xmm(left);
|
|
yt = vec3::load_xmm(right);
|
|
zt = _mm_sub_ps(xt, yt);
|
|
zt = _mm_mul_ps(zt, zt);
|
|
zt = _mm_hadd_ps(zt, zt);
|
|
return _mm_cvtss_f32(_mm_sqrt_ss(_mm_hadd_ps(zt, zt)));
|
|
}
|
|
|
|
inline float_t vec3::distance_squared(const vec3& left, const vec3& right) {
|
|
__m128 xt;
|
|
__m128 yt;
|
|
__m128 zt;
|
|
xt = vec3::load_xmm(left);
|
|
yt = vec3::load_xmm(right);
|
|
zt = _mm_sub_ps(xt, yt);
|
|
zt = _mm_mul_ps(zt, zt);
|
|
zt = _mm_hadd_ps(zt, zt);
|
|
return _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
|
|
}
|
|
|
|
inline vec3 vec3::abs(const vec3& left) {
|
|
return vec3::store_xmm(_mm_castsi128_ps(_mm_and_si128(_mm_castps_si128(vec3::load_xmm(left)), vec3i_abs)));
|
|
}
|
|
|
|
inline vec3 vec3::lerp(const vec3& left, const vec3& right, const vec3& blend) {
|
|
__m128 b1;
|
|
__m128 b2;
|
|
b1 = vec3::load_xmm(blend);
|
|
b2 = _mm_sub_ps(vec3::load_xmm(1.0f), b1);
|
|
return vec3::store_xmm(_mm_add_ps(_mm_mul_ps(vec3::load_xmm(left), b2),
|
|
_mm_mul_ps(vec3::load_xmm(right), b1)));
|
|
}
|
|
|
|
inline vec3 vec3::lerp(const vec3& left, const vec3& right, const float_t blend) {
|
|
__m128 b1;
|
|
__m128 b2;
|
|
b1 = vec3::load_xmm(blend);
|
|
b2 = _mm_sub_ps(vec3::load_xmm(1.0f), b1);
|
|
return vec3::store_xmm(_mm_add_ps(_mm_mul_ps(vec3::load_xmm(left), b2),
|
|
_mm_mul_ps(vec3::load_xmm(right), b1)));
|
|
}
|
|
|
|
inline vec3 vec3::normalize(const vec3& left) {
|
|
__m128 xt;
|
|
__m128 zt;
|
|
xt = vec3::load_xmm(left);
|
|
zt = _mm_mul_ps(xt, xt);
|
|
zt = _mm_hadd_ps(zt, zt);
|
|
zt = _mm_sqrt_ss(_mm_hadd_ps(zt, zt));
|
|
if (_mm_cvtss_f32(zt) != 0.0f)
|
|
return vec3::store_xmm(_mm_div_ps(xt, _mm_shuffle_ps(zt, zt, 0)));
|
|
return vec3::store_xmm(xt);
|
|
}
|
|
|
|
inline vec3 vec3::normalize_rcp(const vec3& left) {
|
|
__m128 xt;
|
|
__m128 zt;
|
|
xt = vec3::load_xmm(left);
|
|
zt = _mm_mul_ps(xt, xt);
|
|
zt = _mm_hadd_ps(zt, zt);
|
|
zt = _mm_sqrt_ss(_mm_hadd_ps(zt, zt));
|
|
if (_mm_cvtss_f32(zt) != 0.0f)
|
|
return vec3::store_xmm(_mm_mul_ps(xt, _mm_div_ss(vec3::load_xmm(1.0f), _mm_shuffle_ps(zt, zt, 0))));
|
|
return vec3::store_xmm(xt);
|
|
}
|
|
|
|
inline vec3 vec3::rcp(const vec3& left) {
|
|
return vec3::store_xmm(_mm_div_ps(vec3::load_xmm(1.0f), vec3::load_xmm(left)));
|
|
}
|
|
|
|
inline vec3 vec3::min(const vec3& left, const vec3& right) {
|
|
return vec3::store_xmm(_mm_min_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 vec3::max(const vec3& left, const vec3& right) {
|
|
return vec3::store_xmm(_mm_max_ps(vec3::load_xmm(left), vec3::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3 vec3::clamp(const vec3& left, const vec3& min, const vec3& max) {
|
|
return vec3::store_xmm(_mm_min_ps(_mm_max_ps(vec3::load_xmm(left),
|
|
vec3::load_xmm(min)), vec3::load_xmm(max)));
|
|
}
|
|
|
|
inline vec3 vec3::clamp(const vec3& left, const float_t min, const float_t max) {
|
|
return vec3::store_xmm(_mm_min_ps(_mm_max_ps(vec3::load_xmm(left),
|
|
vec3::load_xmm(min)), vec3::load_xmm(max)));
|
|
}
|
|
|
|
inline vec3 vec3::mult_min_max(const vec3& left, const vec3& min, const vec3& max) {
|
|
__m128 xt;
|
|
__m128 yt;
|
|
__m128 zt;
|
|
xt = vec3::load_xmm(left);
|
|
yt = _mm_and_ps(_mm_cmplt_ps(xt, vec4::load_xmm(0.0f)), vec3::load_xmm(-min));
|
|
zt = _mm_and_ps(_mm_cmpge_ps(xt, vec4::load_xmm(0.0f)), vec3::load_xmm(max));
|
|
return vec3::store_xmm(_mm_mul_ps(xt, _mm_or_ps(yt, zt)));
|
|
}
|
|
|
|
inline vec3 vec3::mult_min_max(const vec3& left, const float_t min, const float_t max) {
|
|
__m128 xt;
|
|
__m128 yt;
|
|
__m128 zt;
|
|
xt = vec3::load_xmm(left);
|
|
yt = _mm_and_ps(_mm_cmplt_ps(xt, vec4::load_xmm(0.0f)), vec3::load_xmm(-min));
|
|
zt = _mm_and_ps(_mm_cmpge_ps(xt, vec4::load_xmm(0.0f)), vec3::load_xmm(max));
|
|
return vec3::store_xmm(_mm_mul_ps(xt, _mm_or_ps(yt, zt)));
|
|
}
|
|
|
|
inline vec3 vec3::div_min_max(const vec3& left, const vec3& min, const vec3& max) {
|
|
__m128 xt;
|
|
__m128 yt;
|
|
__m128 zt;
|
|
xt = vec3::load_xmm(left);
|
|
yt = _mm_and_ps(_mm_cmplt_ps(xt, vec4::load_xmm(0.0f)), vec3::load_xmm(-min));
|
|
zt = _mm_and_ps(_mm_cmpge_ps(xt, vec4::load_xmm(0.0f)), vec3::load_xmm(max));
|
|
return vec3::store_xmm(_mm_div_ps(xt, _mm_or_ps(yt, zt)));
|
|
}
|
|
|
|
inline vec3 vec3::div_min_max(const vec3& left, const float_t min, const float_t max) {
|
|
__m128 xt;
|
|
__m128 yt;
|
|
__m128 zt;
|
|
xt = vec3::load_xmm(left);
|
|
yt = _mm_and_ps(_mm_cmplt_ps(xt, vec4::load_xmm(0.0f)), vec3::load_xmm(-min));
|
|
zt = _mm_and_ps(_mm_cmpge_ps(xt, vec4::load_xmm(0.0f)), vec3::load_xmm(max));
|
|
return vec3::store_xmm(_mm_div_ps(xt, _mm_or_ps(yt, zt)));
|
|
}
|
|
|
|
inline vec3 vec3::cross(const vec3& left, const vec3& right) {
|
|
__m128 xt;
|
|
__m128 yt;
|
|
__m128 zt;
|
|
xt = vec3::load_xmm(left);
|
|
yt = vec3::load_xmm(right);
|
|
zt = _mm_sub_ps(
|
|
_mm_mul_ps(xt, _mm_shuffle_ps(yt, yt, 0x09)),
|
|
_mm_mul_ps(yt, _mm_shuffle_ps(xt, xt, 0x09))
|
|
);
|
|
return vec3::store_xmm(_mm_shuffle_ps(zt, zt, 0x09));
|
|
}
|
|
|
|
inline vec4::vec4() : x(), y(), z(), w() {
|
|
|
|
}
|
|
|
|
inline vec4::vec4(float_t value) : x(value), y(value), z(value), w(value) {
|
|
|
|
}
|
|
|
|
inline vec4::vec4(float_t x, float_t y, float_t z, float_t w) : x(x), y(y), z(z), w(w) {
|
|
|
|
}
|
|
|
|
inline vec4 operator+(const vec4& left, const vec4& right) {
|
|
return vec4::store_xmm(_mm_add_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 operator+(const vec4& left, const float_t right) {
|
|
return vec4::store_xmm(_mm_add_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 operator+(const float_t left, const vec4& right) {
|
|
return vec4::store_xmm(_mm_add_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator+=(vec4& left, const vec4& right) {
|
|
left = vec4::store_xmm(_mm_add_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator+=(vec4& left, const float_t right) {
|
|
left = vec4::store_xmm(_mm_add_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 operator-(const vec4& left, const vec4& right) {
|
|
return vec4::store_xmm(_mm_sub_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 operator-(const vec4& left, const float_t right) {
|
|
return vec4::store_xmm(_mm_sub_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 operator-(const float_t left, const vec4& right) {
|
|
return vec4::store_xmm(_mm_sub_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator-=(vec4& left, const vec4& right) {
|
|
left = vec4::store_xmm(_mm_sub_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator-=(vec4& left, const float_t right) {
|
|
left = vec4::store_xmm(_mm_sub_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 operator*(const vec4& left, const vec4& right) {
|
|
return vec4::store_xmm(_mm_mul_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 operator*(const vec4& left, const float_t right) {
|
|
return vec4::store_xmm(_mm_mul_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 operator*(const float_t left, const vec4& right) {
|
|
return vec4::store_xmm(_mm_mul_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator*=(vec4& left, const vec4& right) {
|
|
left = vec4::store_xmm(_mm_mul_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator*=(vec4& left, const float_t right) {
|
|
left = vec4::store_xmm(_mm_mul_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 operator/(const vec4& left, const vec4& right) {
|
|
return vec4::store_xmm(_mm_div_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 operator/(const vec4& left, const float_t right) {
|
|
return vec4::store_xmm(_mm_div_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 operator/(const float_t left, const vec4& right) {
|
|
return vec4::store_xmm(_mm_div_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator/=(vec4& left, const vec4& right) {
|
|
left = vec4::store_xmm(_mm_div_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator/=(vec4& left, const float_t right) {
|
|
left = vec4::store_xmm(_mm_div_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 operator&(const vec4& left, const vec4& right) {
|
|
return vec4::store_xmm(_mm_and_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 operator&(const vec4& left, const float_t right) {
|
|
return vec4::store_xmm(_mm_and_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 operator&(const float_t left, const vec4& right) {
|
|
return vec4::store_xmm(_mm_and_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator&=(vec4& left, const vec4& right) {
|
|
left = vec4::store_xmm(_mm_and_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator&=(vec4& left, const float_t right) {
|
|
left = vec4::store_xmm(_mm_and_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 operator^(const vec4& left, const vec4& right) {
|
|
return vec4::store_xmm(_mm_xor_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 operator^(const vec4& left, const float_t right) {
|
|
return vec4::store_xmm(_mm_xor_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 operator^(const float_t left, const vec4& right) {
|
|
return vec4::store_xmm(_mm_xor_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator^=(vec4& left, const vec4& right) {
|
|
left = vec4::store_xmm(_mm_xor_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator^=(vec4& left, const float_t right) {
|
|
left = vec4::store_xmm(_mm_xor_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 operator-(const vec4& left) {
|
|
return vec4::store_xmm(_mm_xor_ps(vec4::load_xmm(left), vec4_neg));
|
|
}
|
|
|
|
inline bool operator==(const vec4& left, const vec4& right) {
|
|
return !memcmp(&left, &right, sizeof(vec4));
|
|
}
|
|
|
|
inline bool operator!=(const vec4& left, const vec4& right) {
|
|
return !(left == right);
|
|
}
|
|
|
|
inline __m128 vec4::load_xmm(const float_t data) {
|
|
__m128 _data = _mm_load_ss(&data);
|
|
return _mm_shuffle_ps(_data, _data, 0);
|
|
}
|
|
|
|
inline __m128 vec4::load_xmm(const vec4& data) {
|
|
return _mm_loadu_ps((const float*)&data);
|
|
}
|
|
|
|
inline __m128 vec4::load_xmm(const vec4&& data) {
|
|
return _mm_loadu_ps((const float*)&data);
|
|
}
|
|
|
|
inline vec4 vec4::store_xmm(const __m128& data) {
|
|
vec4 _data;
|
|
_mm_storeu_ps((float*)&_data, data);
|
|
return _data;
|
|
}
|
|
|
|
inline vec4 vec4::store_xmm(const __m128&& data) {
|
|
vec4 _data;
|
|
_mm_storeu_ps((float*)&_data, data);
|
|
return _data;
|
|
}
|
|
|
|
inline float_t vec4::angle(const vec4& left, const vec4& right) {
|
|
return acosf(vec4::dot(left, right) / (vec4::length(left) * vec4::length(right)));
|
|
}
|
|
|
|
inline float_t vec4::dot(const vec4& left, const vec4& right) {
|
|
__m128 zt;
|
|
zt = _mm_mul_ps(vec4::load_xmm(left), vec4::load_xmm(right));
|
|
zt = _mm_hadd_ps(zt, zt);
|
|
return _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
|
|
}
|
|
|
|
inline float_t vec4::length(const vec4& left) {
|
|
__m128 xt;
|
|
__m128 zt;
|
|
xt = vec4::load_xmm(left);
|
|
zt = _mm_mul_ps(xt, xt);
|
|
zt = _mm_hadd_ps(zt, zt);
|
|
return _mm_cvtss_f32(_mm_sqrt_ss(_mm_hadd_ps(zt, zt)));
|
|
}
|
|
|
|
inline float_t vec4::length_squared(const vec4& left) {
|
|
__m128 xt;
|
|
__m128 zt;
|
|
xt = vec4::load_xmm(left);
|
|
zt = _mm_mul_ps(xt, xt);
|
|
zt = _mm_hadd_ps(zt, zt);
|
|
return _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
|
|
}
|
|
|
|
inline float_t vec4::distance(const vec4& left, const vec4& right) {
|
|
__m128 zt;
|
|
zt = _mm_sub_ps(vec4::load_xmm(left), vec4::load_xmm(right));
|
|
zt = _mm_mul_ps(zt, zt);
|
|
zt = _mm_hadd_ps(zt, zt);
|
|
return _mm_cvtss_f32(_mm_sqrt_ss(_mm_hadd_ps(zt, zt)));
|
|
}
|
|
|
|
inline float_t vec4::distance_squared(const vec4& left, const vec4& right) {
|
|
__m128 zt;
|
|
zt = _mm_sub_ps(vec4::load_xmm(left), vec4::load_xmm(right));
|
|
zt = _mm_mul_ps(zt, zt);
|
|
zt = _mm_hadd_ps(zt, zt);
|
|
return _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
|
|
}
|
|
|
|
inline vec4 vec4::abs(const vec4& left) {
|
|
return vec4::store_xmm(_mm_castsi128_ps(_mm_and_si128(_mm_castps_si128(vec4::load_xmm(left)), vec4i_abs)));
|
|
}
|
|
|
|
inline vec4 vec4::lerp(const vec4& left, const vec4& right, const vec4& blend) {
|
|
__m128 b1;
|
|
__m128 b2;
|
|
b1 = vec4::load_xmm(blend);
|
|
b2 = _mm_sub_ps(vec4::load_xmm(1.0f), b1);
|
|
return vec4::store_xmm(_mm_add_ps(_mm_mul_ps(vec4::load_xmm(left), b2),
|
|
_mm_mul_ps(vec4::load_xmm(right), b1)));
|
|
}
|
|
|
|
inline vec4 vec4::lerp(const vec4& left, const vec4& right, const float_t blend) {
|
|
__m128 b1;
|
|
__m128 b2;
|
|
b1 = vec4::load_xmm(blend);
|
|
b2 = _mm_sub_ps(vec4::load_xmm(1.0f), b1);
|
|
return vec4::store_xmm(_mm_add_ps(_mm_mul_ps(vec4::load_xmm(left), b2),
|
|
_mm_mul_ps(vec4::load_xmm(right), b1)));
|
|
}
|
|
|
|
inline vec4 vec4::normalize(const vec4& left) {
|
|
__m128 xt;
|
|
__m128 zt;
|
|
xt = vec4::load_xmm(left);
|
|
zt = _mm_mul_ps(xt, xt);
|
|
zt = _mm_hadd_ps(zt, zt);
|
|
zt = _mm_sqrt_ss(_mm_hadd_ps(zt, zt));
|
|
if (_mm_cvtss_f32(zt) != 0.0f)
|
|
return vec4::store_xmm(_mm_div_ps(xt, _mm_shuffle_ps(zt, zt, 0)));
|
|
return vec4::store_xmm(xt);
|
|
}
|
|
|
|
inline vec4 vec4::normalize_rcp(const vec4& left) {
|
|
__m128 xt;
|
|
__m128 zt;
|
|
xt = vec4::load_xmm(left);
|
|
zt = _mm_mul_ps(xt, xt);
|
|
zt = _mm_hadd_ps(zt, zt);
|
|
zt = _mm_sqrt_ss(_mm_hadd_ps(zt, zt));
|
|
if (_mm_cvtss_f32(zt) != 0.0f)
|
|
return vec4::store_xmm(_mm_mul_ps(xt, _mm_div_ss(vec4::load_xmm(1.0f), _mm_shuffle_ps(zt, zt, 0))));
|
|
return vec4::store_xmm(xt);
|
|
}
|
|
|
|
inline vec4 vec4::rcp(const vec4& left) {
|
|
return vec4::store_xmm(_mm_div_ps(vec4::load_xmm(1.0f), vec4::load_xmm(left)));
|
|
}
|
|
|
|
inline vec4 vec4::min(const vec4& left, const vec4& right) {
|
|
return vec4::store_xmm(_mm_min_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 vec4::max(const vec4& left, const vec4& right) {
|
|
return vec4::store_xmm(_mm_max_ps(vec4::load_xmm(left), vec4::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4 vec4::clamp(const vec4& left, const vec4& min, const vec4& max) {
|
|
return vec4::store_xmm(_mm_min_ps(_mm_max_ps(vec4::load_xmm(left),
|
|
vec4::load_xmm(min)), vec4::load_xmm(max)));
|
|
}
|
|
|
|
inline vec4 vec4::clamp(const vec4& left, const float_t min, const float_t max) {
|
|
return vec4::store_xmm(_mm_min_ps(_mm_max_ps(vec4::load_xmm(left),
|
|
vec4::load_xmm(min)), vec4::load_xmm(max)));
|
|
}
|
|
|
|
inline vec4 vec4::mult_min_max(const vec4& left, const vec4& min, const vec4& max) {
|
|
__m128 xt;
|
|
__m128 yt;
|
|
__m128 zt;
|
|
xt = vec4::load_xmm(left);
|
|
yt = _mm_and_ps(_mm_cmplt_ps(xt, vec4::load_xmm(0.0f)), vec4::load_xmm(-min));
|
|
zt = _mm_and_ps(_mm_cmpge_ps(xt, vec4::load_xmm(0.0f)), vec4::load_xmm(max));
|
|
return vec4::store_xmm(_mm_mul_ps(xt, _mm_or_ps(yt, zt)));
|
|
}
|
|
|
|
inline vec4 vec4::mult_min_max(const vec4& left, const float_t min, const float_t max) {
|
|
__m128 xt;
|
|
__m128 yt;
|
|
__m128 zt;
|
|
xt = vec4::load_xmm(left);
|
|
yt = _mm_and_ps(_mm_cmplt_ps(xt, vec4::load_xmm(0.0f)), vec4::load_xmm(-min));
|
|
zt = _mm_and_ps(_mm_cmpge_ps(xt, vec4::load_xmm(0.0f)), vec4::load_xmm(max));
|
|
return vec4::store_xmm(_mm_mul_ps(xt, _mm_or_ps(yt, zt)));
|
|
}
|
|
|
|
inline vec4 vec4::div_min_max(const vec4& left, const vec4& min, const vec4& max) {
|
|
__m128 xt;
|
|
__m128 yt;
|
|
__m128 zt;
|
|
xt = vec4::load_xmm(left);
|
|
yt = _mm_and_ps(_mm_cmplt_ps(xt, vec4::load_xmm(0.0f)), vec4::load_xmm(-min));
|
|
zt = _mm_and_ps(_mm_cmpge_ps(xt, vec4::load_xmm(0.0f)), vec4::load_xmm(max));
|
|
return vec4::store_xmm(_mm_div_ps(xt, _mm_or_ps(yt, zt)));
|
|
}
|
|
|
|
inline vec4 vec4::div_min_max(const vec4& left, const float_t min, const float_t max) {
|
|
__m128 xt;
|
|
__m128 yt;
|
|
__m128 zt;
|
|
xt = vec4::load_xmm(left);
|
|
yt = _mm_and_ps(_mm_cmplt_ps(xt, vec4::load_xmm(0.0f)), vec4::load_xmm(-min));
|
|
zt = _mm_and_ps(_mm_cmpge_ps(xt, vec4::load_xmm(0.0f)), vec4::load_xmm(max));
|
|
return vec4::store_xmm(_mm_div_ps(xt, _mm_or_ps(yt, zt)));
|
|
}
|
|
|
|
inline vec2i::vec2i() : x(), y() {
|
|
|
|
}
|
|
|
|
inline vec2i::vec2i(int32_t value) : x(value), y(value) {
|
|
|
|
}
|
|
|
|
inline vec2i::vec2i(int32_t x, int32_t y) : x(x), y(y) {
|
|
|
|
}
|
|
|
|
inline vec2i operator+(const vec2i& left, const vec2i& right) {
|
|
return vec2i::store_xmm(_mm_add_epi32(vec2i::load_xmm(left), vec2i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2i operator+(const vec2i& left, const int32_t right) {
|
|
return vec2i::store_xmm(_mm_add_epi32(vec2i::load_xmm(left), vec2i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2i operator+(const int32_t left, const vec2i& right) {
|
|
return vec2i::store_xmm(_mm_add_epi32(vec2i::load_xmm(left), vec2i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2i operator-(const vec2i& left, const vec2i& right) {
|
|
return vec2i::store_xmm(_mm_sub_epi32(vec2i::load_xmm(left), vec2i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2i operator-(const vec2i& left, const int32_t right) {
|
|
return vec2i::store_xmm(_mm_sub_epi32(vec2i::load_xmm(left), vec2i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2i operator-(const int32_t left, const vec2i& right) {
|
|
return vec2i::store_xmm(_mm_sub_epi32(vec2i::load_xmm(left), vec2i::load_xmm(right)));
|
|
}
|
|
|
|
inline __m128i vec2i::load_xmm(const int32_t data) {
|
|
__m128i _data = _mm_cvtsi32_si128(data);
|
|
return _mm_shuffle_epi32(_data, 0);
|
|
}
|
|
|
|
inline __m128i vec2i::load_xmm(const vec2i& data) {
|
|
return _mm_loadl_epi64((const __m128i*) & data);
|
|
}
|
|
|
|
inline __m128i vec2i::load_xmm(const vec2i&& data) {
|
|
return _mm_loadl_epi64((const __m128i*) & data);
|
|
}
|
|
|
|
inline vec2i vec2i::store_xmm(const __m128i& data) {
|
|
vec2i _data;
|
|
_mm_storel_epi64((__m128i*) & _data, data);
|
|
return _data;
|
|
}
|
|
|
|
inline vec2i vec2i::store_xmm(const __m128i&& data) {
|
|
vec2i _data;
|
|
_mm_storel_epi64((__m128i*) & _data, data);
|
|
return _data;
|
|
}
|
|
|
|
inline vec2i vec2i::min(const vec2i& left, const vec2i& right) {
|
|
return vec2i::store_xmm(_mm_min_epi32(vec2i::load_xmm(left), vec2i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2i vec2i::max(const vec2i& left, const vec2i& right) {
|
|
return vec2i::store_xmm(_mm_max_epi32(vec2i::load_xmm(left), vec2i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2i vec2i::clamp(const vec2i& left, const vec2i& min, const vec2i& max) {
|
|
return vec2i::store_xmm(_mm_min_epi32(_mm_max_epi32(vec2i::load_xmm(left),
|
|
vec2i::load_xmm(min)), vec2i::load_xmm(max)));
|
|
}
|
|
|
|
inline vec2i vec2i::clamp(const vec2i& left, const int32_t min, const int32_t max) {
|
|
return vec2i::store_xmm(_mm_min_epi32(_mm_max_epi32(vec2i::load_xmm(left),
|
|
vec2i::load_xmm(min)), vec2i::load_xmm(max)));
|
|
}
|
|
|
|
inline vec3i::vec3i() : x(), y(), z() {
|
|
|
|
}
|
|
|
|
inline vec3i::vec3i(int32_t value) : x(value), y(value), z(value) {
|
|
|
|
}
|
|
|
|
inline vec3i::vec3i(int32_t x, int32_t y, int32_t z) : x(x), y(y), z(z) {
|
|
|
|
}
|
|
|
|
inline vec3i operator+(const vec3i& left, const vec3i& right) {
|
|
return vec3i::store_xmm(_mm_add_epi32(vec3i::load_xmm(left), vec3i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3i operator+(const vec3i& left, const int32_t right) {
|
|
return vec3i::store_xmm(_mm_add_epi32(vec3i::load_xmm(left), vec3i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3i operator+(const int32_t left, const vec3i& right) {
|
|
return vec3i::store_xmm(_mm_add_epi32(vec3i::load_xmm(left), vec3i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3i operator-(const vec3i& left, const vec3i& right) {
|
|
return vec3i::store_xmm(_mm_sub_epi32(vec3i::load_xmm(left), vec3i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3i operator-(const vec3i& left, const int32_t right) {
|
|
return vec3i::store_xmm(_mm_sub_epi32(vec3i::load_xmm(left), vec3i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3i operator-(const int32_t left, const vec3i& right) {
|
|
return vec3i::store_xmm(_mm_sub_epi32(vec3i::load_xmm(left), vec3i::load_xmm(right)));
|
|
}
|
|
|
|
inline __m128i vec3i::load_xmm(const int32_t data) {
|
|
__m128i _data = _mm_cvtsi32_si128(data);
|
|
return _mm_shuffle_epi32(_data, 0);
|
|
}
|
|
|
|
inline __m128i vec3i::load_xmm(const vec3i& data) {
|
|
return _mm_unpacklo_epi64(_mm_loadl_epi64((const __m128i*) & data), _mm_cvtsi32_si128(data.z));
|
|
}
|
|
|
|
inline __m128i vec3i::load_xmm(const vec3i&& data) {
|
|
return _mm_unpacklo_epi64(_mm_loadl_epi64((const __m128i*) & data), _mm_cvtsi32_si128(data.z));
|
|
}
|
|
|
|
inline vec3i vec3i::store_xmm(const __m128i& data) {
|
|
vec3i _data;
|
|
_mm_storel_epi64((__m128i*) & _data, data);
|
|
_data.z = _mm_cvtsi128_si32(_mm_srli_si128(data, 8));
|
|
return _data;
|
|
}
|
|
|
|
inline vec3i vec3i::store_xmm(const __m128i&& data) {
|
|
vec3i _data;
|
|
_mm_storel_epi64((__m128i*) & _data, data);
|
|
_data.z = _mm_cvtsi128_si32(_mm_srli_si128(data, 8));
|
|
return _data;
|
|
}
|
|
|
|
inline vec3i vec3i::min(const vec3i& left, const vec3i& right) {
|
|
return vec3i::store_xmm(_mm_min_epi32(vec3i::load_xmm(left), vec3i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3i vec3i::max(const vec3i& left, const vec3i& right) {
|
|
return vec3i::store_xmm(_mm_max_epi32(vec3i::load_xmm(left), vec3i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec3i vec3i::clamp(const vec3i& left, const vec3i& min, const vec3i& max) {
|
|
return vec3i::store_xmm(_mm_min_epi32(_mm_max_epi32(vec3i::load_xmm(left),
|
|
vec3i::load_xmm(min)), vec3i::load_xmm(max)));
|
|
}
|
|
|
|
inline vec3i vec3i::clamp(const vec3i& left, const int32_t min, const int32_t max) {
|
|
return vec3i::store_xmm(_mm_min_epi32(_mm_max_epi32(vec3i::load_xmm(left),
|
|
vec3i::load_xmm(min)), vec3i::load_xmm(max)));
|
|
}
|
|
|
|
inline vec4i::vec4i() : x(), y(), z(), w() {
|
|
|
|
}
|
|
|
|
inline vec4i::vec4i(int32_t value) : x(value), y(value), z(value), w(value) {
|
|
|
|
}
|
|
|
|
inline vec4i::vec4i(int32_t x, int32_t y, int32_t z, int32_t w) : x(x), y(y), z(z), w(w) {
|
|
|
|
}
|
|
|
|
inline vec4i operator+(const vec4i& left, const vec4i& right) {
|
|
return vec4i::store_xmm(_mm_add_epi32(vec4i::load_xmm(left), vec4i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4i operator+(const vec4i& left, const int32_t right) {
|
|
return vec4i::store_xmm(_mm_add_epi32(vec4i::load_xmm(left), vec4i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4i operator+(const int32_t left, const vec4i& right) {
|
|
return vec4i::store_xmm(_mm_add_epi32(vec4i::load_xmm(left), vec4i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4i operator-(const vec4i& left, const vec4i& right) {
|
|
return vec4i::store_xmm(_mm_sub_epi32(vec4i::load_xmm(left), vec4i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4i operator-(const vec4i& left, const int32_t right) {
|
|
return vec4i::store_xmm(_mm_sub_epi32(vec4i::load_xmm(left), vec4i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4i operator-(const int32_t left, const vec4i& right) {
|
|
return vec4i::store_xmm(_mm_sub_epi32(vec4i::load_xmm(left), vec4i::load_xmm(right)));
|
|
}
|
|
|
|
inline __m128i vec4i::load_xmm(const int32_t data) {
|
|
__m128i _data = _mm_cvtsi32_si128(data);
|
|
return _mm_shuffle_epi32(_data, 0);
|
|
}
|
|
|
|
inline __m128i vec4i::load_xmm(const vec4i& data) {
|
|
return _mm_loadu_si128((const __m128i*) & data);
|
|
}
|
|
|
|
inline __m128i vec4i::load_xmm(const vec4i&& data) {
|
|
return _mm_loadu_si128((const __m128i*) & data);
|
|
}
|
|
|
|
inline vec4i vec4i::store_xmm(const __m128i& data) {
|
|
vec4i _data;
|
|
_mm_storeu_si128((__m128i*) & _data, data);
|
|
return _data;
|
|
}
|
|
|
|
inline vec4i vec4i::store_xmm(const __m128i&& data) {
|
|
vec4i _data;
|
|
_mm_storeu_si128((__m128i*) & _data, data);
|
|
return _data;
|
|
}
|
|
|
|
inline vec4i vec4i::min(const vec4i& left, const vec4i& right) {
|
|
return vec4i::store_xmm(_mm_min_epi32(vec4i::load_xmm(left), vec4i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4i vec4i::max(const vec4i& left, const vec4i& right) {
|
|
return vec4i::store_xmm(_mm_max_epi32(vec4i::load_xmm(left), vec4i::load_xmm(right)));
|
|
}
|
|
|
|
inline vec4i vec4i::clamp(const vec4i& left, const vec4i& min, const vec4i& max) {
|
|
return vec4i::store_xmm(_mm_min_epi32(_mm_max_epi32(vec4i::load_xmm(left),
|
|
vec4i::load_xmm(min)), vec4i::load_xmm(max)));
|
|
}
|
|
|
|
inline vec4i vec4i::clamp(const vec4i& left, const int32_t min, const int32_t max) {
|
|
return vec4i::store_xmm(_mm_min_epi32(_mm_max_epi32(vec4i::load_xmm(left),
|
|
vec4i::load_xmm(min)), vec4i::load_xmm(max)));
|
|
}
|
|
|
|
inline vec2d::vec2d() : x(), y() {
|
|
|
|
}
|
|
|
|
inline vec2d::vec2d(double_t value) : x(value), y(value) {
|
|
|
|
}
|
|
|
|
inline vec2d::vec2d(double_t x, double_t y) : x(x), y(y) {
|
|
|
|
}
|
|
|
|
inline __m128d vec2d::load_xmm(const double_t data) {
|
|
__m128d _data = _mm_load_sd(&data);
|
|
return _mm_shuffle_pd(_data, _data, 0);
|
|
}
|
|
|
|
inline __m128d vec2d::load_xmm(const vec2d& data) {
|
|
return _mm_loadu_pd((const double_t*) & data);
|
|
}
|
|
|
|
inline __m128d vec2d::load_xmm(const vec2d&& data) {
|
|
return _mm_loadu_pd((const double_t*) & data);
|
|
}
|
|
|
|
inline vec2d vec2d::store_xmm(const __m128d& data) {
|
|
vec2d _data;
|
|
_mm_storeu_pd((double_t*) & _data, data);
|
|
return _data;
|
|
}
|
|
|
|
inline vec2d vec2d::store_xmm(const __m128d&& data) {
|
|
vec2d _data;
|
|
_mm_storeu_pd((double_t*) & _data, data);
|
|
return _data;
|
|
}
|
|
|
|
inline vec2d operator+(const vec2d& left, const vec2d& right) {
|
|
return vec2d::store_xmm(_mm_add_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d operator+(const vec2d& left, const double_t right) {
|
|
return vec2d::store_xmm(_mm_add_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d operator+(const double_t left, const vec2d& right) {
|
|
return vec2d::store_xmm(_mm_add_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator+=(vec2d& left, const vec2d& right) {
|
|
left = vec2d::store_xmm(_mm_add_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator+=(vec2d& left, const double_t right) {
|
|
left = vec2d::store_xmm(_mm_add_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d operator-(const vec2d& left, const vec2d& right) {
|
|
return vec2d::store_xmm(_mm_sub_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d operator-(const vec2d& left, const double_t right) {
|
|
return vec2d::store_xmm(_mm_sub_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d operator-(const double_t left, const vec2d& right) {
|
|
return vec2d::store_xmm(_mm_sub_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator-=(vec2d& left, const vec2d& right) {
|
|
left = vec2d::store_xmm(_mm_sub_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator-=(vec2d& left, const double_t right) {
|
|
left = vec2d::store_xmm(_mm_sub_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d operator*(const vec2d& left, const vec2d& right) {
|
|
return vec2d::store_xmm(_mm_mul_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d operator*(const vec2d& left, const double_t right) {
|
|
return vec2d::store_xmm(_mm_mul_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d operator*(const double_t left, const vec2d& right) {
|
|
return vec2d::store_xmm(_mm_mul_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator*=(vec2d& left, const vec2d& right) {
|
|
left = vec2d::store_xmm(_mm_mul_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator*=(vec2d& left, const double_t right) {
|
|
left = vec2d::store_xmm(_mm_mul_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d operator/(const vec2d& left, const vec2d& right) {
|
|
return vec2d::store_xmm(_mm_div_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d operator/(const vec2d& left, const double_t right) {
|
|
return vec2d::store_xmm(_mm_div_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d operator/(const double_t left, const vec2d& right) {
|
|
return vec2d::store_xmm(_mm_div_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator/=(vec2d& left, const vec2d& right) {
|
|
left = vec2d::store_xmm(_mm_div_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator/=(vec2d& left, const double_t right) {
|
|
left = vec2d::store_xmm(_mm_div_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d operator&(const vec2d& left, const vec2d& right) {
|
|
return vec2d::store_xmm(_mm_and_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d operator&(const vec2d& left, const double_t right) {
|
|
return vec2d::store_xmm(_mm_and_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d operator&(const double_t left, const vec2d& right) {
|
|
return vec2d::store_xmm(_mm_and_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator&=(vec2d& left, const vec2d& right) {
|
|
left = vec2d::store_xmm(_mm_and_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator&=(vec2d& left, const double_t right) {
|
|
left = vec2d::store_xmm(_mm_and_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d operator^(const vec2d& left, const vec2d& right) {
|
|
return vec2d::store_xmm(_mm_xor_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d operator^(const vec2d& left, const double_t right) {
|
|
return vec2d::store_xmm(_mm_xor_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d operator^(const double_t left, const vec2d& right) {
|
|
return vec2d::store_xmm(_mm_xor_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator^=(vec2d& left, const vec2d& right) {
|
|
left = vec2d::store_xmm(_mm_xor_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline void operator^=(vec2d& left, const double_t right) {
|
|
left = vec2d::store_xmm(_mm_xor_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d operator-(const vec2d& left) {
|
|
return vec2d::store_xmm(_mm_xor_pd(vec2d::load_xmm(left), vec2d_neg));
|
|
}
|
|
|
|
inline bool operator==(const vec2d& left, const vec2d& right) {
|
|
return !memcmp(&left, &right, sizeof(vec2d));
|
|
}
|
|
|
|
inline bool operator!=(const vec2d& left, const vec2d& right) {
|
|
return !(left == right);
|
|
}
|
|
|
|
inline double_t vec2d::angle(const vec2d& left, const vec2d& right) {
|
|
return acos(vec2d::dot(left, right) / (vec2d::length(left) * vec2d::length(right)));
|
|
}
|
|
|
|
inline double_t vec2d::dot(const vec2d& left, const vec2d& right) {
|
|
__m128d zt;
|
|
zt = _mm_mul_pd(vec2d::load_xmm(left), vec2d::load_xmm(right));
|
|
return _mm_cvtsd_f64(_mm_hadd_pd(zt, zt));
|
|
}
|
|
|
|
inline double_t vec2d::length(const vec2d& left) {
|
|
__m128d xt;
|
|
__m128d zt;
|
|
xt = vec2d::load_xmm(left);
|
|
zt = _mm_mul_pd(xt, xt);
|
|
return _mm_cvtsd_f64(_mm_sqrt_sd(_mm_hadd_pd(zt, zt), zt));
|
|
}
|
|
|
|
inline double_t vec2d::length_squared(const vec2d& left) {
|
|
__m128d xt;
|
|
__m128d zt;
|
|
xt = vec2d::load_xmm(left);
|
|
zt = _mm_mul_pd(xt, xt);
|
|
return _mm_cvtsd_f64(_mm_hadd_pd(zt, zt));
|
|
}
|
|
|
|
inline double_t vec2d::distance(const vec2d& left, const vec2d& right) {
|
|
__m128d zt;
|
|
zt = _mm_sub_pd(vec2d::load_xmm(left), vec2d::load_xmm(right));
|
|
zt = _mm_mul_pd(zt, zt);
|
|
return _mm_cvtsd_f64(_mm_sqrt_sd(_mm_hadd_pd(zt, zt), zt));
|
|
}
|
|
|
|
inline double_t vec2d::distance_squared(const vec2d& left, const vec2d& right) {
|
|
__m128d zt;
|
|
zt = _mm_sub_pd(vec2d::load_xmm(left), vec2d::load_xmm(right));
|
|
zt = _mm_mul_pd(zt, zt);
|
|
return _mm_cvtsd_f64(_mm_hadd_pd(zt, zt));
|
|
}
|
|
|
|
inline vec2d vec2d::abs(const vec2d& left) {
|
|
return vec2d::store_xmm(_mm_castsi128_pd(_mm_and_si128(_mm_castpd_si128(vec2d::load_xmm(left)), vec2i64_abs)));
|
|
}
|
|
|
|
inline vec2d vec2d::lerp(const vec2d& left, const vec2d& right, const vec2d& blend) {
|
|
__m128d b1;
|
|
__m128d b2;
|
|
b1 = vec2d::load_xmm(blend);
|
|
b2 = _mm_sub_pd(vec2d::load_xmm(1.0), b1);
|
|
return vec2d::store_xmm(_mm_add_pd(_mm_mul_pd(vec2d::load_xmm(left), b2),
|
|
_mm_mul_pd(vec2d::load_xmm(right), b1)));
|
|
}
|
|
|
|
inline vec2d vec2d::lerp(const vec2d& left, const vec2d& right, const double_t blend) {
|
|
__m128d b1;
|
|
__m128d b2;
|
|
b1 = vec2d::load_xmm(blend);
|
|
b2 = _mm_sub_pd(vec2d::load_xmm(1.0), b1);
|
|
return vec2d::store_xmm(_mm_add_pd(_mm_mul_pd(vec2d::load_xmm(left), b2),
|
|
_mm_mul_pd(vec2d::load_xmm(right), b1)));
|
|
}
|
|
|
|
inline vec2d vec2d::normalize(const vec2d& left) {
|
|
__m128d xt;
|
|
__m128d zt;
|
|
xt = vec2d::load_xmm(left);
|
|
zt = _mm_mul_pd(xt, xt);
|
|
zt = _mm_sqrt_sd(_mm_hadd_pd(zt, zt), zt);
|
|
if (_mm_cvtsd_f64(zt) != 0.0f)
|
|
return vec2d::store_xmm(_mm_div_pd(xt, _mm_shuffle_pd(zt, zt, 0)));
|
|
return vec2d::store_xmm(xt);
|
|
}
|
|
|
|
inline vec2d vec2d::normalize_rcp(const vec2d& left) {
|
|
__m128d xt;
|
|
__m128d zt;
|
|
xt = vec2d::load_xmm(left);
|
|
zt = _mm_mul_pd(xt, xt);
|
|
zt = _mm_sqrt_sd(_mm_hadd_pd(zt, zt), zt);
|
|
if (_mm_cvtsd_f64(zt) != 0.0f)
|
|
return vec2d::store_xmm(_mm_mul_pd(xt, _mm_div_sd(vec2d::load_xmm(1.0f), _mm_shuffle_pd(zt, zt, 0))));
|
|
return vec2d::store_xmm(xt);
|
|
}
|
|
|
|
inline vec2d vec2d::rcp(const vec2d& left) {
|
|
return vec2d::store_xmm(_mm_div_pd(vec2d::load_xmm(1.0), vec2d::load_xmm(left)));
|
|
}
|
|
|
|
inline vec2d vec2d::min(const vec2d& left, const vec2d& right) {
|
|
return vec2d::store_xmm(_mm_min_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d vec2d::max(const vec2d& left, const vec2d& right) {
|
|
return vec2d::store_xmm(_mm_max_pd(vec2d::load_xmm(left), vec2d::load_xmm(right)));
|
|
}
|
|
|
|
inline vec2d vec2d::clamp(const vec2d& left, const vec2d& min, const vec2d& max) {
|
|
return vec2d::store_xmm(_mm_min_pd(_mm_max_pd(vec2d::load_xmm(left),
|
|
vec2d::load_xmm(min)), vec2d::load_xmm(max)));
|
|
}
|
|
|
|
inline vec2d vec2d::clamp(const vec2d& left, const double_t min, const double_t max) {
|
|
return vec2d::store_xmm(_mm_min_pd(_mm_max_pd(vec2d::load_xmm(left),
|
|
vec2d::load_xmm(min)), vec2d::load_xmm(max)));
|
|
}
|
|
|
|
inline vec2d vec2d::mult_min_max(const vec2d& left, const vec2d& min, const vec2d& max) {
|
|
__m128d xt;
|
|
__m128d yt;
|
|
__m128d zt;
|
|
xt = vec2d::load_xmm(left);
|
|
yt = _mm_and_pd(_mm_cmplt_pd(xt, vec2d::load_xmm(0.0)), vec2d::load_xmm(-min));
|
|
zt = _mm_and_pd(_mm_cmpge_pd(xt, vec2d::load_xmm(0.0)), vec2d::load_xmm(max));
|
|
return vec2d::store_xmm(_mm_mul_pd(xt, _mm_or_pd(yt, zt)));
|
|
}
|
|
|
|
inline vec2d vec2d::mult_min_max(const vec2d& left, const double_t min, const double_t max) {
|
|
__m128d xt;
|
|
__m128d yt;
|
|
__m128d zt;
|
|
xt = vec2d::load_xmm(left);
|
|
yt = _mm_and_pd(_mm_cmplt_pd(xt, vec2d::load_xmm(0.0)), vec2d::load_xmm(-min));
|
|
zt = _mm_and_pd(_mm_cmpge_pd(xt, vec2d::load_xmm(0.0)), vec2d::load_xmm(max));
|
|
return vec2d::store_xmm(_mm_mul_pd(xt, _mm_or_pd(yt, zt)));
|
|
}
|
|
|
|
inline vec2d vec2d::div_min_max(const vec2d& left, const vec2d& min, const vec2d& max) {
|
|
__m128d xt;
|
|
__m128d yt;
|
|
__m128d zt;
|
|
xt = vec2d::load_xmm(left);
|
|
yt = _mm_and_pd(_mm_cmplt_pd(xt, vec2d::load_xmm(0.0)), vec2d::load_xmm(-min));
|
|
zt = _mm_and_pd(_mm_cmpge_pd(xt, vec2d::load_xmm(0.0)), vec2d::load_xmm(max));
|
|
return vec2d::store_xmm(_mm_div_pd(xt, _mm_or_pd(yt, zt)));
|
|
}
|
|
|
|
inline vec2d vec2d::div_min_max(const vec2d& left, const double_t min, const double_t max) {
|
|
__m128d xt;
|
|
__m128d yt;
|
|
__m128d zt;
|
|
xt = vec2d::load_xmm(left);
|
|
yt = _mm_and_pd(_mm_cmplt_pd(xt, vec2d::load_xmm(0.0)), vec2d::load_xmm(-min));
|
|
zt = _mm_and_pd(_mm_cmpge_pd(xt, vec2d::load_xmm(0.0)), vec2d::load_xmm(max));
|
|
return vec2d::store_xmm(_mm_div_pd(xt, _mm_or_pd(yt, zt)));
|
|
}
|
|
|
|
inline void vec2i8_to_vec2(const vec2i8& src, vec2& dst) {
|
|
dst.x = (float_t)src.x;
|
|
dst.y = (float_t)src.y;
|
|
}
|
|
|
|
inline void vec3i8_to_vec3(const vec3i8& src, vec3& dst) {
|
|
dst.x = (float_t)src.x;
|
|
dst.y = (float_t)src.y;
|
|
dst.z = (float_t)src.z;
|
|
}
|
|
|
|
inline void vec4i8_to_vec4(const vec4i8& src, vec4& dst) {
|
|
dst.x = (float_t)src.x;
|
|
dst.y = (float_t)src.y;
|
|
dst.z = (float_t)src.z;
|
|
dst.w = (float_t)src.w;
|
|
}
|
|
|
|
inline void vec2_to_vec2i8(const vec2& src, vec2i8& dst) {
|
|
dst.x = (int8_t)src.x;
|
|
dst.y = (int8_t)src.y;
|
|
}
|
|
|
|
inline void vec3_to_vec3i8(const vec3& src, vec3i8& dst) {
|
|
dst.x = (int8_t)src.x;
|
|
dst.y = (int8_t)src.y;
|
|
dst.z = (int8_t)src.z;
|
|
}
|
|
|
|
inline void vec4_to_vec4i8(const vec4& src, vec4i8& dst) {
|
|
dst.x = (int8_t)src.x;
|
|
dst.y = (int8_t)src.y;
|
|
dst.z = (int8_t)src.z;
|
|
dst.w = (int8_t)src.w;
|
|
}
|
|
|
|
inline void vec2u8_to_vec2(const vec2u8& src, vec2& dst) {
|
|
dst.x = (float_t)src.x;
|
|
dst.y = (float_t)src.y;
|
|
}
|
|
|
|
inline void vec3u8_to_vec3(const vec3u8& src, vec3& dst) {
|
|
dst.x = (float_t)src.x;
|
|
dst.y = (float_t)src.y;
|
|
dst.z = (float_t)src.z;
|
|
}
|
|
|
|
inline void vec4u8_to_vec4(const vec4u8& src, vec4& dst) {
|
|
dst.x = (float_t)src.x;
|
|
dst.y = (float_t)src.y;
|
|
dst.z = (float_t)src.z;
|
|
dst.w = (float_t)src.w;
|
|
}
|
|
|
|
inline void vec2_to_vec2u8(const vec2& src, vec2u8& dst) {
|
|
dst.x = (uint8_t)src.x;
|
|
dst.y = (uint8_t)src.y;
|
|
}
|
|
|
|
inline void vec3_to_vec3u8(const vec3& src, vec3u8& dst) {
|
|
dst.x = (uint8_t)src.x;
|
|
dst.y = (uint8_t)src.y;
|
|
dst.z = (uint8_t)src.z;
|
|
}
|
|
|
|
inline void vec4_to_vec4u8(const vec4& src, vec4u8& dst) {
|
|
dst.x = (uint8_t)src.x;
|
|
dst.y = (uint8_t)src.y;
|
|
dst.z = (uint8_t)src.z;
|
|
dst.w = (uint8_t)src.w;
|
|
}
|
|
|
|
inline void vec2i16_to_vec2(const vec2i16& src, vec2& dst) {
|
|
dst.x = (float_t)src.x;
|
|
dst.y = (float_t)src.y;
|
|
}
|
|
|
|
inline void vec3i16_to_vec3(const vec3i16& src, vec3& dst) {
|
|
dst.x = (float_t)src.x;
|
|
dst.y = (float_t)src.y;
|
|
dst.z = (float_t)src.z;
|
|
}
|
|
|
|
inline void vec4i16_to_vec4(const vec4i16& src, vec4& dst) {
|
|
dst.x = (float_t)src.x;
|
|
dst.y = (float_t)src.y;
|
|
dst.z = (float_t)src.z;
|
|
dst.w = (float_t)src.w;
|
|
}
|
|
|
|
inline void vec2_to_vec2i16(const vec2& src, vec2i16& dst) {
|
|
dst.x = (int16_t)src.x;
|
|
dst.y = (int16_t)src.y;
|
|
}
|
|
|
|
inline void vec3_to_vec3i16(const vec3& src, vec3i16& dst) {
|
|
dst.x = (int16_t)src.x;
|
|
dst.y = (int16_t)src.y;
|
|
dst.z = (int16_t)src.z;
|
|
}
|
|
|
|
inline void vec4_to_vec4i16(const vec4& src, vec4i16& dst) {
|
|
dst.x = (int16_t)src.x;
|
|
dst.y = (int16_t)src.y;
|
|
dst.z = (int16_t)src.z;
|
|
dst.w = (int16_t)src.w;
|
|
}
|
|
|
|
inline void vec2u16_to_vec2(const vec2u16& src, vec2& dst) {
|
|
dst.x = (float_t)src.x;
|
|
dst.y = (float_t)src.y;
|
|
}
|
|
|
|
inline void vec3u16_to_vec3(const vec3u16& src, vec3& dst) {
|
|
dst.x = (float_t)src.x;
|
|
dst.y = (float_t)src.y;
|
|
dst.z = (float_t)src.z;
|
|
}
|
|
|
|
inline void vec4u16_to_vec4(const vec4u16& src, vec4& dst) {
|
|
dst.x = (float_t)src.x;
|
|
dst.y = (float_t)src.y;
|
|
dst.z = (float_t)src.z;
|
|
dst.w = (float_t)src.w;
|
|
}
|
|
|
|
inline void vec2_to_vec2u16(const vec2& src, vec2u16& dst) {
|
|
dst.x = (uint16_t)src.x;
|
|
dst.y = (uint16_t)src.y;
|
|
}
|
|
|
|
inline void vec3_to_vec3u16(const vec3& src, vec3u16& dst) {
|
|
dst.x = (uint16_t)src.x;
|
|
dst.y = (uint16_t)src.y;
|
|
dst.z = (uint16_t)src.z;
|
|
}
|
|
|
|
inline void vec4_to_vec4u16(const vec4& src, vec4u16& dst) {
|
|
dst.x = (uint16_t)src.x;
|
|
dst.y = (uint16_t)src.y;
|
|
dst.z = (uint16_t)src.z;
|
|
dst.w = (uint16_t)src.w;
|
|
}
|
|
|
|
inline void vec2h_to_vec2(const vec2h& src, vec2& dst) {
|
|
extern bool cpu_caps_f16c;
|
|
if (cpu_caps_f16c) {
|
|
dst = vec2::store_xmm(_mm_cvtph_ps(_mm_cvtsi32_si128(*(int32_t*)&src)));
|
|
return;
|
|
}
|
|
|
|
dst.x = half_to_float_convert(src.x);
|
|
dst.y = half_to_float_convert(src.y);
|
|
}
|
|
|
|
inline void vec3h_to_vec3(const vec3h& src, vec3& dst) {
|
|
dst.x = half_to_float_convert(src.x);
|
|
dst.y = half_to_float_convert(src.y);
|
|
dst.z = half_to_float_convert(src.z);
|
|
}
|
|
|
|
inline void vec4h_to_vec4(const vec4h& src, vec4& dst) {
|
|
extern bool cpu_caps_f16c;
|
|
if (cpu_caps_f16c) {
|
|
dst = vec4::store_xmm(_mm_cvtph_ps(_mm_cvtsi64_si128(*(int64_t*)&src)));
|
|
return;
|
|
}
|
|
|
|
dst.x = half_to_float_convert(src.x);
|
|
dst.y = half_to_float_convert(src.y);
|
|
dst.z = half_to_float_convert(src.z);
|
|
dst.w = half_to_float_convert(src.w);
|
|
}
|
|
|
|
inline void vec2_to_vec2h(const vec2& src, vec2h& dst) {
|
|
extern bool cpu_caps_f16c;
|
|
if (cpu_caps_f16c) {
|
|
*(int32_t*)&dst = _mm_cvtsi128_si32(_mm_cvtps_ph(vec2::load_xmm(src), _MM_FROUND_CUR_DIRECTION));
|
|
return;
|
|
}
|
|
|
|
dst.x = float_to_half_convert(src.x);
|
|
dst.y = float_to_half_convert(src.y);
|
|
}
|
|
|
|
inline void vec3_to_vec3h(const vec3& src, vec3h& dst) {
|
|
dst.x = float_to_half_convert(src.x);
|
|
dst.y = float_to_half_convert(src.y);
|
|
dst.z = float_to_half_convert(src.z);
|
|
}
|
|
|
|
inline void vec4_to_vec4h(const vec4& src, vec4h& dst) {
|
|
extern bool cpu_caps_f16c;
|
|
if (cpu_caps_f16c) {
|
|
*(int64_t*)&dst = _mm_cvtsi128_si64(_mm_cvtps_ph(vec4::load_xmm(src), _MM_FROUND_CUR_DIRECTION));
|
|
return;
|
|
}
|
|
|
|
dst.x = float_to_half_convert(src.x);
|
|
dst.y = float_to_half_convert(src.y);
|
|
dst.z = float_to_half_convert(src.z);
|
|
dst.w = float_to_half_convert(src.w);
|
|
}
|
|
|
|
inline void vec2i8_to_vec2i(const vec2i8& src, vec2i& dst) {
|
|
dst.x = src.x;
|
|
dst.y = src.y;
|
|
}
|
|
|
|
inline void vec3i8_to_vec3i(const vec3i8& src, vec3i& dst) {
|
|
dst.x = src.x;
|
|
dst.y = src.y;
|
|
dst.z = src.z;
|
|
}
|
|
|
|
inline void vec4i8_to_vec4i(const vec4i8& src, vec4i& dst) {
|
|
dst.x = src.x;
|
|
dst.y = src.y;
|
|
dst.z = src.z;
|
|
dst.w = src.w;
|
|
}
|
|
|
|
inline void vec2i_to_vec2i8(const vec2i& src, vec2i8& dst) {
|
|
dst.x = (int8_t)src.x;
|
|
dst.y = (int8_t)src.y;
|
|
}
|
|
|
|
inline void vec3i_to_vec3i8(const vec3i& src, vec3i8& dst) {
|
|
dst.x = (int8_t)src.x;
|
|
dst.y = (int8_t)src.y;
|
|
dst.z = (int8_t)src.z;
|
|
}
|
|
|
|
inline void vec4i_to_vec4i8(const vec4i& src, vec4i8& dst) {
|
|
dst.x = (int8_t)src.x;
|
|
dst.y = (int8_t)src.y;
|
|
dst.z = (int8_t)src.z;
|
|
dst.w = (int8_t)src.w;
|
|
}
|
|
|
|
inline void vec2u8_to_vec2i(const vec2u8& src, vec2i& dst) {
|
|
dst.x = src.x;
|
|
dst.y = src.y;
|
|
}
|
|
|
|
inline void vec3u8_to_vec4i(const vec3u8& src, vec3i& dst) {
|
|
dst.x = src.x;
|
|
dst.y = src.y;
|
|
dst.z = src.z;
|
|
}
|
|
|
|
inline void vec4u8_to_vec4i(const vec4u8& src, vec4i& dst) {
|
|
dst.x = src.x;
|
|
dst.y = src.y;
|
|
dst.z = src.z;
|
|
dst.w = src.w;
|
|
}
|
|
|
|
inline void vec2i_to_vec2u8(const vec2i& src, vec2u8& dst) {
|
|
dst.x = (uint8_t)src.x;
|
|
dst.y = (uint8_t)src.y;
|
|
}
|
|
|
|
inline void vec3i_to_vec3u8(const vec3i& src, vec3u8& dst) {
|
|
dst.x = (uint8_t)src.x;
|
|
dst.y = (uint8_t)src.y;
|
|
dst.z = (uint8_t)src.z;
|
|
}
|
|
|
|
inline void vec4i_to_vec4u8(const vec4i& src, vec4u8& dst) {
|
|
dst.x = (uint8_t)src.x;
|
|
dst.y = (uint8_t)src.y;
|
|
dst.z = (uint8_t)src.z;
|
|
dst.w = (uint8_t)src.w;
|
|
}
|
|
|
|
inline void vec2i16_to_vec2i(const vec2i16& src, vec2i& dst) {
|
|
dst.x = src.x;
|
|
dst.y = src.y;
|
|
}
|
|
|
|
inline void vec3i16_to_vec4i(const vec3i16& src, vec3i& dst) {
|
|
dst.x = src.x;
|
|
dst.y = src.y;
|
|
dst.z = src.z;
|
|
}
|
|
|
|
inline void vec4i16_to_vec4i(const vec4i16& src, vec4i& dst) {
|
|
dst.x = src.x;
|
|
dst.y = src.y;
|
|
dst.z = src.z;
|
|
dst.w = src.w;
|
|
}
|
|
|
|
inline void vec2i_to_vec2i16(const vec2i& src, vec2i16& dst) {
|
|
dst.x = (int16_t)src.x;
|
|
dst.y = (int16_t)src.y;
|
|
}
|
|
|
|
inline void vec3i_to_vec3i16(const vec3i& src, vec3i16& dst) {
|
|
dst.x = (int16_t)src.x;
|
|
dst.y = (int16_t)src.y;
|
|
dst.z = (int16_t)src.z;
|
|
}
|
|
|
|
inline void vec4i_to_vec4i16(const vec4i& src, vec4i16& dst) {
|
|
dst.x = (int16_t)src.x;
|
|
dst.y = (int16_t)src.y;
|
|
dst.z = (int16_t)src.z;
|
|
dst.w = (int16_t)src.w;
|
|
}
|
|
|
|
inline void vec2u16_to_vec2i(const vec2u16& src, vec2i& dst) {
|
|
dst.x = src.x;
|
|
dst.y = src.y;
|
|
}
|
|
|
|
inline void vec3u16_to_vec4i(const vec3u16& src, vec3i& dst) {
|
|
dst.x = src.x;
|
|
dst.y = src.y;
|
|
dst.z = src.z;
|
|
}
|
|
|
|
inline void vec4u16_to_vec4i(const vec4u16& src, vec4i& dst) {
|
|
dst.x = src.x;
|
|
dst.y = src.y;
|
|
dst.z = src.z;
|
|
dst.w = src.w;
|
|
}
|
|
|
|
inline void vec2i_to_vec2u16(const vec2i& src, vec2u16& dst) {
|
|
dst.x = (uint16_t)src.x;
|
|
dst.y = (uint16_t)src.y;
|
|
}
|
|
|
|
inline void vec3i_to_vec3u16(const vec3i& src, vec3u16& dst) {
|
|
dst.x = (uint16_t)src.x;
|
|
dst.y = (uint16_t)src.y;
|
|
dst.z = (uint16_t)src.z;
|
|
}
|
|
|
|
inline void vec4i_to_vec4u16(const vec4i& src, vec4u16& dst) {
|
|
dst.x = (uint16_t)src.x;
|
|
dst.y = (uint16_t)src.y;
|
|
dst.z = (uint16_t)src.z;
|
|
dst.w = (uint16_t)src.w;
|
|
}
|
|
|
|
inline void vec2_to_vec2i(const vec2& x, vec2i& z) {
|
|
z = vec2i::store_xmm(_mm_cvtps_epi32(vec2::load_xmm(x)));
|
|
}
|
|
|
|
inline void vec2i_to_vec2(const vec2i& x, vec2& z) {
|
|
z = vec2::store_xmm(_mm_cvtepi32_ps(vec2i::load_xmm(x)));
|
|
}
|
|
|
|
inline void vec3_to_vec3i(const vec3& x, vec3i& z) {
|
|
z = vec3i::store_xmm(_mm_cvtps_epi32(vec3::load_xmm(x)));
|
|
}
|
|
|
|
inline void vec3i_to_vec3(const vec3i& x, vec3& z) {
|
|
z = vec3::store_xmm(_mm_cvtepi32_ps(vec3i::load_xmm(x)));
|
|
}
|
|
|
|
inline void vec4_to_vec4i(const vec4& x, vec4i& z) {
|
|
z = vec4i::store_xmm(_mm_cvtps_epi32(vec4::load_xmm(x)));
|
|
}
|
|
|
|
inline void vec4i_to_vec4(const vec4i& x, vec4& z) {
|
|
z = vec4::store_xmm(_mm_cvtepi32_ps(vec4i::load_xmm(x)));
|
|
}
|