Cleanup: BLI: Rename vec_base to VecBase
For consistency with our codestyle and matrix class. # Conflicts: # source/blender/blenlib/BLI_math_matrix_types.hh
This commit is contained in:
parent
8f44c37f5c
commit
73594f4c9c
|
|
@ -183,7 +183,7 @@ template<typename MatT> [[nodiscard]] MatT from_location(const typename MatT::ve
|
|||
* If vector dimension is lower than matrix diagonal, the missing terms are filled with ones.
|
||||
*/
|
||||
template<typename MatT, int ScaleDim>
|
||||
[[nodiscard]] MatT from_scale(const vec_base<typename MatT::base_type, ScaleDim> &scale);
|
||||
[[nodiscard]] MatT from_scale(const VecBase<typename MatT::base_type, ScaleDim> &scale);
|
||||
|
||||
/**
|
||||
* Create a rotation only matrix.
|
||||
|
|
@ -210,7 +210,7 @@ template<typename MatT, typename RotationT>
|
|||
template<typename MatT, typename RotationT, int ScaleDim>
|
||||
[[nodiscard]] MatT from_loc_rot_scale(const typename MatT::vec3_type &location,
|
||||
const RotationT &rotation,
|
||||
const vec_base<typename MatT::base_type, ScaleDim> &scale);
|
||||
const VecBase<typename MatT::base_type, ScaleDim> &scale);
|
||||
|
||||
/**
|
||||
* Create a rotation matrix from 2 basis vectors.
|
||||
|
|
@ -258,7 +258,7 @@ template<typename T, bool Normalized = false>
|
|||
* This is a costly operation so it is disabled by default.
|
||||
*/
|
||||
template<bool AllowNegativeScale = false, typename T, int NumCol, int NumRow>
|
||||
[[nodiscard]] inline vec_base<T, 3> to_scale(const MatBase<T, NumCol, NumRow> &mat);
|
||||
[[nodiscard]] inline VecBase<T, 3> to_scale(const MatBase<T, NumCol, NumRow> &mat);
|
||||
|
||||
/**
|
||||
* Decompose a matrix into location, rotation, and scale components.
|
||||
|
|
@ -269,12 +269,12 @@ template<bool AllowNegativeScale = false, typename T, int NumCol, int NumRow>
|
|||
template<bool AllowNegativeScale = false, typename T, typename RotationT>
|
||||
inline void to_rot_scale(const MatBase<T, 3, 3> &mat,
|
||||
RotationT &r_rotation,
|
||||
vec_base<T, 3> &r_scale);
|
||||
VecBase<T, 3> &r_scale);
|
||||
template<bool AllowNegativeScale = false, typename T, typename RotationT>
|
||||
inline void to_loc_rot_scale(const MatBase<T, 4, 4> &mat,
|
||||
vec_base<T, 3> &r_location,
|
||||
VecBase<T, 3> &r_location,
|
||||
RotationT &r_rotation,
|
||||
vec_base<T, 3> &r_scale);
|
||||
VecBase<T, 3> &r_scale);
|
||||
|
||||
/** \} */
|
||||
|
||||
|
|
@ -286,29 +286,29 @@ inline void to_loc_rot_scale(const MatBase<T, 4, 4> &mat,
|
|||
* Transform a 3d point using a 3x3 matrix (rotation & scale).
|
||||
*/
|
||||
template<typename T>
|
||||
[[nodiscard]] vec_base<T, 3> transform_point(const MatBase<T, 3, 3> &mat,
|
||||
const vec_base<T, 3> &point);
|
||||
[[nodiscard]] VecBase<T, 3> transform_point(const MatBase<T, 3, 3> &mat,
|
||||
const VecBase<T, 3> &point);
|
||||
|
||||
/**
|
||||
* Transform a 3d point using a 4x4 matrix (location & rotation & scale).
|
||||
*/
|
||||
template<typename T>
|
||||
[[nodiscard]] vec_base<T, 3> transform_point(const MatBase<T, 4, 4> &mat,
|
||||
const vec_base<T, 3> &point);
|
||||
[[nodiscard]] VecBase<T, 3> transform_point(const MatBase<T, 4, 4> &mat,
|
||||
const VecBase<T, 3> &point);
|
||||
|
||||
/**
|
||||
* Transform a 3d direction vector using a 3x3 matrix (rotation & scale).
|
||||
*/
|
||||
template<typename T>
|
||||
[[nodiscard]] vec_base<T, 3> transform_direction(const MatBase<T, 3, 3> &mat,
|
||||
const vec_base<T, 3> &direction);
|
||||
[[nodiscard]] VecBase<T, 3> transform_direction(const MatBase<T, 3, 3> &mat,
|
||||
const VecBase<T, 3> &direction);
|
||||
|
||||
/**
|
||||
* Transform a 3d direction vector using a 4x4 matrix (rotation & scale).
|
||||
*/
|
||||
template<typename T>
|
||||
[[nodiscard]] vec_base<T, 3> transform_direction(const MatBase<T, 4, 4> &mat,
|
||||
const vec_base<T, 3> &direction);
|
||||
[[nodiscard]] VecBase<T, 3> transform_direction(const MatBase<T, 4, 4> &mat,
|
||||
const VecBase<T, 3> &direction);
|
||||
|
||||
/**
|
||||
* Project a point using a matrix (location & rotation & scale & perspective divide).
|
||||
|
|
@ -513,8 +513,8 @@ template<typename T, int NumCol, int NumRow, typename VectorT>
|
|||
/* Avoid multiplying the last row if it exists.
|
||||
* Allows using non square matrices like float3x2 and saves computation. */
|
||||
using IntermediateVecT =
|
||||
vec_base<typename MatT::base_type,
|
||||
(MatT::row_len > MatT::col_len - 1) ? (MatT::col_len - 1) : MatT::row_len>;
|
||||
VecBase<typename MatT::base_type,
|
||||
(MatT::row_len > MatT::col_len - 1) ? (MatT::col_len - 1) : MatT::row_len>;
|
||||
|
||||
MatT result = mat;
|
||||
unroll<VectorT::type_length>([&](auto c) {
|
||||
|
|
@ -761,7 +761,7 @@ template<typename T> detail::Quaternion<T> normalized_to_quat_fast(const MatBase
|
|||
}
|
||||
|
||||
BLI_assert(!(q.x < 0.0f));
|
||||
BLI_assert(math::is_unit_scale(vec_base<T, 4>(q)));
|
||||
BLI_assert(math::is_unit_scale(VecBase<T, 4>(q)));
|
||||
return q;
|
||||
}
|
||||
|
||||
|
|
@ -898,8 +898,8 @@ template<typename T, bool Normalized>
|
|||
detail::normalized_to_eul2(normalize(mat), eul1, eul2);
|
||||
}
|
||||
/* Return best, which is just the one with lowest values it in. */
|
||||
return (length_manhattan(vec_base<T, 3>(eul1)) > length_manhattan(vec_base<T, 3>(eul2))) ? eul2 :
|
||||
eul1;
|
||||
return (length_manhattan(VecBase<T, 3>(eul1)) > length_manhattan(VecBase<T, 3>(eul2))) ? eul2 :
|
||||
eul1;
|
||||
}
|
||||
|
||||
template<typename T, bool Normalized>
|
||||
|
|
@ -929,9 +929,9 @@ template<typename T, bool Normalized>
|
|||
}
|
||||
|
||||
template<bool AllowNegativeScale, typename T, int NumCol, int NumRow>
|
||||
[[nodiscard]] inline vec_base<T, 3> to_scale(const MatBase<T, NumCol, NumRow> &mat)
|
||||
[[nodiscard]] inline VecBase<T, 3> to_scale(const MatBase<T, NumCol, NumRow> &mat)
|
||||
{
|
||||
vec_base<T, 3> result = {length(mat.x_axis()), length(mat.y_axis()), length(mat.z_axis())};
|
||||
VecBase<T, 3> result = {length(mat.x_axis()), length(mat.y_axis()), length(mat.z_axis())};
|
||||
if constexpr (AllowNegativeScale) {
|
||||
if (UNLIKELY(is_negative(mat))) {
|
||||
result = -result;
|
||||
|
|
@ -960,7 +960,7 @@ inline void to_rotation(const MatBase<T, 3, 3> &mat, detail::EulerXYZ<T> &r_rota
|
|||
template<bool AllowNegativeScale, typename T, typename RotationT>
|
||||
inline void to_rot_scale(const MatBase<T, 3, 3> &mat,
|
||||
RotationT &r_rotation,
|
||||
vec_base<T, 3> &r_scale)
|
||||
VecBase<T, 3> &r_scale)
|
||||
{
|
||||
MatBase<T, 3, 3> normalized_mat = normalize_and_get_size(mat, r_scale);
|
||||
if constexpr (AllowNegativeScale) {
|
||||
|
|
@ -974,9 +974,9 @@ inline void to_rot_scale(const MatBase<T, 3, 3> &mat,
|
|||
|
||||
template<bool AllowNegativeScale, typename T, typename RotationT>
|
||||
inline void to_loc_rot_scale(const MatBase<T, 4, 4> &mat,
|
||||
vec_base<T, 3> &r_location,
|
||||
VecBase<T, 3> &r_location,
|
||||
RotationT &r_rotation,
|
||||
vec_base<T, 3> &r_scale)
|
||||
VecBase<T, 3> &r_scale)
|
||||
{
|
||||
r_location = mat.location();
|
||||
to_rot_scale<AllowNegativeScale>(MatBase<T, 3, 3>(mat), r_rotation, r_scale);
|
||||
|
|
@ -990,7 +990,7 @@ template<typename MatT> [[nodiscard]] MatT from_location(const typename MatT::ve
|
|||
}
|
||||
|
||||
template<typename MatT, int ScaleDim>
|
||||
[[nodiscard]] MatT from_scale(const vec_base<typename MatT::base_type, ScaleDim> &scale)
|
||||
[[nodiscard]] MatT from_scale(const VecBase<typename MatT::base_type, ScaleDim> &scale)
|
||||
{
|
||||
BLI_STATIC_ASSERT(ScaleDim <= MatT::min_dim,
|
||||
"Scale dimension should fit the matrix diagonal length.");
|
||||
|
|
@ -1015,7 +1015,7 @@ template<typename MatT, typename RotationT, typename VectorT>
|
|||
template<typename MatT, typename RotationT, int ScaleDim>
|
||||
[[nodiscard]] MatT from_loc_rot_scale(const typename MatT::vec3_type &location,
|
||||
const RotationT &rotation,
|
||||
const vec_base<typename MatT::base_type, ScaleDim> &scale)
|
||||
const VecBase<typename MatT::base_type, ScaleDim> &scale)
|
||||
{
|
||||
using Mat3x3 = MatBase<typename MatT::base_type, 3, 3>;
|
||||
MatT mat = MatT(from_rot_scale<Mat3x3>(rotation, scale));
|
||||
|
|
@ -1060,36 +1060,36 @@ template<typename MatT, typename VectorT>
|
|||
}
|
||||
|
||||
template<typename T>
|
||||
vec_base<T, 3> transform_point(const MatBase<T, 3, 3> &mat, const vec_base<T, 3> &point)
|
||||
VecBase<T, 3> transform_point(const MatBase<T, 3, 3> &mat, const VecBase<T, 3> &point)
|
||||
{
|
||||
return mat * point;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
vec_base<T, 3> transform_point(const MatBase<T, 4, 4> &mat, const vec_base<T, 3> &point)
|
||||
VecBase<T, 3> transform_point(const MatBase<T, 4, 4> &mat, const VecBase<T, 3> &point)
|
||||
{
|
||||
return mat.template view<3, 3>() * point + mat.location();
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
vec_base<T, 3> transform_direction(const MatBase<T, 3, 3> &mat, const vec_base<T, 3> &direction)
|
||||
VecBase<T, 3> transform_direction(const MatBase<T, 3, 3> &mat, const VecBase<T, 3> &direction)
|
||||
{
|
||||
return mat * direction;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
vec_base<T, 3> transform_direction(const MatBase<T, 4, 4> &mat, const vec_base<T, 3> &direction)
|
||||
VecBase<T, 3> transform_direction(const MatBase<T, 4, 4> &mat, const VecBase<T, 3> &direction)
|
||||
{
|
||||
return mat.template view<3, 3>() * direction;
|
||||
}
|
||||
|
||||
template<typename T, int N, int NumRow>
|
||||
vec_base<T, N> project_point(const MatBase<T, N + 1, NumRow> &mat, const vec_base<T, N> &point)
|
||||
VecBase<T, N> project_point(const MatBase<T, N + 1, NumRow> &mat, const VecBase<T, N> &point)
|
||||
{
|
||||
vec_base<T, N + 1> tmp(point, T(1));
|
||||
VecBase<T, N + 1> tmp(point, T(1));
|
||||
tmp = mat * tmp;
|
||||
/* Absolute value to not flip the frustum upside down behind the camera. */
|
||||
return vec_base<T, N>(tmp) / math::abs(tmp[N]);
|
||||
return VecBase<T, N>(tmp) / math::abs(tmp[N]);
|
||||
}
|
||||
|
||||
extern template float3 transform_point(const float3x3 &mat, const float3 &point);
|
||||
|
|
|
|||
|
|
@ -71,12 +71,12 @@ template<
|
|||
/* Alignment in bytes. Do not align matrices whose size is not a multiple of 4 component.
|
||||
* This is in order to avoid padding when using arrays of matrices. */
|
||||
int Alignment = (((NumCol * NumRow) % 4 == 0) ? 4 : 1) * sizeof(T)>
|
||||
struct alignas(Alignment) MatBase : public vec_struct_base<vec_base<T, NumRow>, NumCol> {
|
||||
struct alignas(Alignment) MatBase : public vec_struct_base<VecBase<T, NumRow>, NumCol> {
|
||||
|
||||
using base_type = T;
|
||||
using vec3_type = vec_base<T, 3>;
|
||||
using col_type = vec_base<T, NumRow>;
|
||||
using row_type = vec_base<T, NumCol>;
|
||||
using vec3_type = VecBase<T, 3>;
|
||||
using col_type = VecBase<T, NumRow>;
|
||||
using row_type = VecBase<T, NumCol>;
|
||||
static constexpr int min_dim = (NumRow < NumCol) ? NumRow : NumCol;
|
||||
static constexpr int col_len = NumCol;
|
||||
static constexpr int row_len = NumRow;
|
||||
|
|
@ -523,8 +523,8 @@ template<typename T,
|
|||
struct MatView : NonCopyable, NonMovable {
|
||||
using MatT = MatBase<T, NumCol, NumRow>;
|
||||
using SrcMatT = MatBase<T, SrcNumCol, SrcNumRow, SrcAlignment>;
|
||||
using col_type = vec_base<T, NumRow>;
|
||||
using row_type = vec_base<T, NumCol>;
|
||||
using col_type = VecBase<T, NumRow>;
|
||||
using row_type = VecBase<T, NumCol>;
|
||||
|
||||
const SrcMatT &mat;
|
||||
|
||||
|
|
@ -759,8 +759,8 @@ struct MutableMatView
|
|||
using MatViewT =
|
||||
MatView<T, NumCol, NumRow, SrcNumCol, SrcNumRow, SrcStartCol, SrcStartRow, SrcAlignment>;
|
||||
using SrcMatT = MatBase<T, SrcNumCol, SrcNumRow, SrcAlignment>;
|
||||
using col_type = vec_base<T, NumRow>;
|
||||
using row_type = vec_base<T, NumCol>;
|
||||
using col_type = VecBase<T, NumRow>;
|
||||
using row_type = VecBase<T, NumCol>;
|
||||
|
||||
public:
|
||||
MutableMatView() = delete;
|
||||
|
|
|
|||
|
|
@ -20,13 +20,13 @@ namespace blender::math {
|
|||
* \param cosom: dot product from normalized vectors/quats.
|
||||
* \param r_w: calculated weights.
|
||||
*/
|
||||
template<typename T> inline vec_base<T, 2> interpolate_dot_slerp(const T t, const T cosom)
|
||||
template<typename T> inline VecBase<T, 2> interpolate_dot_slerp(const T t, const T cosom)
|
||||
{
|
||||
const T eps = T(1e-4);
|
||||
|
||||
BLI_assert(IN_RANGE_INCL(cosom, T(-1.0001), T(1.0001)));
|
||||
|
||||
vec_base<T, 2> w;
|
||||
VecBase<T, 2> w;
|
||||
/* Within [-1..1] range, avoid aligned axis. */
|
||||
if (LIKELY(math::abs(cosom) < (T(1) - eps))) {
|
||||
const T omega = math::acos(cosom);
|
||||
|
|
@ -48,7 +48,7 @@ inline detail::Quaternion<T> interpolate(const detail::Quaternion<T> &a,
|
|||
const detail::Quaternion<T> &b,
|
||||
T t)
|
||||
{
|
||||
using Vec4T = vec_base<T, 4>;
|
||||
using Vec4T = VecBase<T, 4>;
|
||||
BLI_assert(is_unit_scale(Vec4T(a)));
|
||||
BLI_assert(is_unit_scale(Vec4T(b)));
|
||||
|
||||
|
|
@ -60,7 +60,7 @@ inline detail::Quaternion<T> interpolate(const detail::Quaternion<T> &a,
|
|||
quat = -quat;
|
||||
}
|
||||
|
||||
vec_base<T, 2> w = interpolate_dot_slerp(t, cosom);
|
||||
VecBase<T, 2> w = interpolate_dot_slerp(t, cosom);
|
||||
|
||||
return detail::Quaternion<T>(w[0] * quat + w[1] * Vec4T(b));
|
||||
}
|
||||
|
|
@ -76,7 +76,7 @@ namespace blender::math::detail {
|
|||
#ifdef DEBUG
|
||||
# define BLI_ASSERT_UNIT_QUATERNION(_q) \
|
||||
{ \
|
||||
auto rot_vec = static_cast<vec_base<T, 4>>(_q); \
|
||||
auto rot_vec = static_cast<VecBase<T, 4>>(_q); \
|
||||
T quat_length = math::length_squared(rot_vec); \
|
||||
if (!(quat_length == 0 || (math::abs(quat_length - 1) < 0.0001))) { \
|
||||
std::cout << "Warning! " << __func__ << " called with non-normalized quaternion: size " \
|
||||
|
|
@ -87,7 +87,7 @@ namespace blender::math::detail {
|
|||
# define BLI_ASSERT_UNIT_QUATERNION(_q)
|
||||
#endif
|
||||
|
||||
template<typename T> AxisAngle<T>::AxisAngle(const vec_base<T, 3> &axis, T angle)
|
||||
template<typename T> AxisAngle<T>::AxisAngle(const VecBase<T, 3> &axis, T angle)
|
||||
{
|
||||
T length;
|
||||
axis_ = math::normalize_and_get_length(axis, length);
|
||||
|
|
@ -101,7 +101,7 @@ template<typename T> AxisAngle<T>::AxisAngle(const vec_base<T, 3> &axis, T angle
|
|||
}
|
||||
}
|
||||
|
||||
template<typename T> AxisAngle<T>::AxisAngle(const vec_base<T, 3> &from, const vec_base<T, 3> &to)
|
||||
template<typename T> AxisAngle<T>::AxisAngle(const VecBase<T, 3> &from, const VecBase<T, 3> &to)
|
||||
{
|
||||
BLI_assert(is_unit_scale(from));
|
||||
BLI_assert(is_unit_scale(to));
|
||||
|
|
@ -124,7 +124,7 @@ template<typename T> AxisAngle<T>::AxisAngle(const vec_base<T, 3> &from, const v
|
|||
}
|
||||
}
|
||||
template<typename T>
|
||||
AxisAngleNormalized<T>::AxisAngleNormalized(const vec_base<T, 3> &axis, T angle) : AxisAngle<T>()
|
||||
AxisAngleNormalized<T>::AxisAngleNormalized(const VecBase<T, 3> &axis, T angle) : AxisAngle<T>()
|
||||
{
|
||||
BLI_assert(is_unit_scale(axis));
|
||||
this->axis_ = axis;
|
||||
|
|
@ -183,7 +183,7 @@ template<typename T> Quaternion<T>::operator AxisAngle<T>() const
|
|||
si = 1.0f;
|
||||
}
|
||||
|
||||
vec_base<T, 3> axis = vec_base<T, 3>(quat.y, quat.z, quat.w) / si;
|
||||
VecBase<T, 3> axis = VecBase<T, 3>(quat.y, quat.z, quat.w) / si;
|
||||
if (math::is_zero(axis)) {
|
||||
axis[1] = 1.0f;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ template<typename T> struct EulerXYZ {
|
|||
this->z = z;
|
||||
}
|
||||
|
||||
EulerXYZ(const vec_base<T, 3> &vec) : EulerXYZ(UNPACK3(vec)){};
|
||||
EulerXYZ(const VecBase<T, 3> &vec) : EulerXYZ(UNPACK3(vec)){};
|
||||
|
||||
/** Static functions. */
|
||||
|
||||
|
|
@ -47,7 +47,7 @@ template<typename T> struct EulerXYZ {
|
|||
|
||||
/** Conversions. */
|
||||
|
||||
explicit operator vec_base<T, 3>() const
|
||||
explicit operator VecBase<T, 3>() const
|
||||
{
|
||||
return {this->x, this->y, this->z};
|
||||
}
|
||||
|
|
@ -60,7 +60,7 @@ template<typename T> struct EulerXYZ {
|
|||
|
||||
friend std::ostream &operator<<(std::ostream &stream, const EulerXYZ &rot)
|
||||
{
|
||||
return stream << "EulerXYZ" << static_cast<vec_base<T, 3>>(rot);
|
||||
return stream << "EulerXYZ" << static_cast<VecBase<T, 3>>(rot);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -77,7 +77,7 @@ template<typename T = float> struct Quaternion {
|
|||
this->w = w;
|
||||
}
|
||||
|
||||
Quaternion(const vec_base<T, 4> &vec) : Quaternion(UNPACK4(vec)){};
|
||||
Quaternion(const VecBase<T, 4> &vec) : Quaternion(UNPACK4(vec)){};
|
||||
|
||||
/** Static functions. */
|
||||
|
||||
|
|
@ -88,7 +88,7 @@ template<typename T = float> struct Quaternion {
|
|||
|
||||
/** Conversions. */
|
||||
|
||||
explicit operator vec_base<T, 4>() const
|
||||
explicit operator VecBase<T, 4>() const
|
||||
{
|
||||
return {this->x, this->y, this->z, this->w};
|
||||
}
|
||||
|
|
@ -107,12 +107,12 @@ template<typename T = float> struct Quaternion {
|
|||
|
||||
friend std::ostream &operator<<(std::ostream &stream, const Quaternion &rot)
|
||||
{
|
||||
return stream << "Quaternion" << static_cast<vec_base<T, 4>>(rot);
|
||||
return stream << "Quaternion" << static_cast<VecBase<T, 4>>(rot);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename T> struct AxisAngle {
|
||||
using vec3_type = vec_base<T, 3>;
|
||||
using vec3_type = VecBase<T, 3>;
|
||||
|
||||
protected:
|
||||
vec3_type axis_ = {0, 1, 0};
|
||||
|
|
@ -207,7 +207,7 @@ template<typename T> struct AxisAngle {
|
|||
* Implicitly cast back to AxisAngle.
|
||||
*/
|
||||
template<typename T> struct AxisAngleNormalized : public AxisAngle<T> {
|
||||
AxisAngleNormalized(const vec_base<T, 3> &axis, T angle);
|
||||
AxisAngleNormalized(const VecBase<T, 3> &axis, T angle);
|
||||
|
||||
operator AxisAngle<T>() const
|
||||
{
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@
|
|||
|
||||
namespace blender::math {
|
||||
|
||||
template<typename T, int Size> [[nodiscard]] inline bool is_zero(const vec_base<T, Size> &a)
|
||||
template<typename T, int Size> [[nodiscard]] inline bool is_zero(const VecBase<T, Size> &a)
|
||||
{
|
||||
for (int i = 0; i < Size; i++) {
|
||||
if (a[i] != T(0)) {
|
||||
|
|
@ -27,7 +27,7 @@ template<typename T, int Size> [[nodiscard]] inline bool is_zero(const vec_base<
|
|||
return true;
|
||||
}
|
||||
|
||||
template<typename T, int Size> [[nodiscard]] inline bool is_any_zero(const vec_base<T, Size> &a)
|
||||
template<typename T, int Size> [[nodiscard]] inline bool is_any_zero(const VecBase<T, Size> &a)
|
||||
{
|
||||
for (int i = 0; i < Size; i++) {
|
||||
if (a[i] == T(0)) {
|
||||
|
|
@ -38,8 +38,8 @@ template<typename T, int Size> [[nodiscard]] inline bool is_any_zero(const vec_b
|
|||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline bool almost_equal_relative(const vec_base<T, Size> &a,
|
||||
const vec_base<T, Size> &b,
|
||||
[[nodiscard]] inline bool almost_equal_relative(const VecBase<T, Size> &a,
|
||||
const VecBase<T, Size> &b,
|
||||
const T &epsilon_factor)
|
||||
{
|
||||
for (int i = 0; i < Size; i++) {
|
||||
|
|
@ -51,10 +51,9 @@ template<typename T, int Size>
|
|||
return true;
|
||||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> abs(const vec_base<T, Size> &a)
|
||||
template<typename T, int Size> [[nodiscard]] inline VecBase<T, Size> abs(const VecBase<T, Size> &a)
|
||||
{
|
||||
vec_base<T, Size> result;
|
||||
VecBase<T, Size> result;
|
||||
for (int i = 0; i < Size; i++) {
|
||||
result[i] = a[i] >= 0 ? a[i] : -a[i];
|
||||
}
|
||||
|
|
@ -62,9 +61,9 @@ template<typename T, int Size>
|
|||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> min(const vec_base<T, Size> &a, const vec_base<T, Size> &b)
|
||||
[[nodiscard]] inline VecBase<T, Size> min(const VecBase<T, Size> &a, const VecBase<T, Size> &b)
|
||||
{
|
||||
vec_base<T, Size> result;
|
||||
VecBase<T, Size> result;
|
||||
for (int i = 0; i < Size; i++) {
|
||||
result[i] = a[i] < b[i] ? a[i] : b[i];
|
||||
}
|
||||
|
|
@ -72,9 +71,9 @@ template<typename T, int Size>
|
|||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> max(const vec_base<T, Size> &a, const vec_base<T, Size> &b)
|
||||
[[nodiscard]] inline VecBase<T, Size> max(const VecBase<T, Size> &a, const VecBase<T, Size> &b)
|
||||
{
|
||||
vec_base<T, Size> result;
|
||||
VecBase<T, Size> result;
|
||||
for (int i = 0; i < Size; i++) {
|
||||
result[i] = a[i] > b[i] ? a[i] : b[i];
|
||||
}
|
||||
|
|
@ -82,11 +81,11 @@ template<typename T, int Size>
|
|||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> clamp(const vec_base<T, Size> &a,
|
||||
const vec_base<T, Size> &min,
|
||||
const vec_base<T, Size> &max)
|
||||
[[nodiscard]] inline VecBase<T, Size> clamp(const VecBase<T, Size> &a,
|
||||
const VecBase<T, Size> &min,
|
||||
const VecBase<T, Size> &max)
|
||||
{
|
||||
vec_base<T, Size> result = a;
|
||||
VecBase<T, Size> result = a;
|
||||
for (int i = 0; i < Size; i++) {
|
||||
result[i] = std::clamp(result[i], min[i], max[i]);
|
||||
}
|
||||
|
|
@ -94,11 +93,9 @@ template<typename T, int Size>
|
|||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> clamp(const vec_base<T, Size> &a,
|
||||
const T &min,
|
||||
const T &max)
|
||||
[[nodiscard]] inline VecBase<T, Size> clamp(const VecBase<T, Size> &a, const T &min, const T &max)
|
||||
{
|
||||
vec_base<T, Size> result = a;
|
||||
VecBase<T, Size> result = a;
|
||||
for (int i = 0; i < Size; i++) {
|
||||
result[i] = std::clamp(result[i], min, max);
|
||||
}
|
||||
|
|
@ -106,9 +103,9 @@ template<typename T, int Size>
|
|||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> mod(const vec_base<T, Size> &a, const vec_base<T, Size> &b)
|
||||
[[nodiscard]] inline VecBase<T, Size> mod(const VecBase<T, Size> &a, const VecBase<T, Size> &b)
|
||||
{
|
||||
vec_base<T, Size> result;
|
||||
VecBase<T, Size> result;
|
||||
for (int i = 0; i < Size; i++) {
|
||||
BLI_assert(b[i] != 0);
|
||||
result[i] = std::fmod(a[i], b[i]);
|
||||
|
|
@ -117,10 +114,10 @@ template<typename T, int Size>
|
|||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> mod(const vec_base<T, Size> &a, const T &b)
|
||||
[[nodiscard]] inline VecBase<T, Size> mod(const VecBase<T, Size> &a, const T &b)
|
||||
{
|
||||
BLI_assert(b != 0);
|
||||
vec_base<T, Size> result;
|
||||
VecBase<T, Size> result;
|
||||
for (int i = 0; i < Size; i++) {
|
||||
result[i] = std::fmod(a[i], b);
|
||||
}
|
||||
|
|
@ -128,10 +125,10 @@ template<typename T, int Size>
|
|||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> safe_mod(const vec_base<T, Size> &a,
|
||||
const vec_base<T, Size> &b)
|
||||
[[nodiscard]] inline VecBase<T, Size> safe_mod(const VecBase<T, Size> &a,
|
||||
const VecBase<T, Size> &b)
|
||||
{
|
||||
vec_base<T, Size> result;
|
||||
VecBase<T, Size> result;
|
||||
for (int i = 0; i < Size; i++) {
|
||||
result[i] = (b[i] != 0) ? std::fmod(a[i], b[i]) : 0;
|
||||
}
|
||||
|
|
@ -139,12 +136,12 @@ template<typename T, int Size>
|
|||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> safe_mod(const vec_base<T, Size> &a, const T &b)
|
||||
[[nodiscard]] inline VecBase<T, Size> safe_mod(const VecBase<T, Size> &a, const T &b)
|
||||
{
|
||||
if (b == 0) {
|
||||
return vec_base<T, Size>(0);
|
||||
return VecBase<T, Size>(0);
|
||||
}
|
||||
vec_base<T, Size> result;
|
||||
VecBase<T, Size> result;
|
||||
for (int i = 0; i < Size; i++) {
|
||||
result[i] = std::fmod(a[i], b);
|
||||
}
|
||||
|
|
@ -157,10 +154,10 @@ template<typename T, int Size>
|
|||
* It is undefined if \a a is negative or \b b is not strictly positive.
|
||||
*/
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> ceil_to_multiple(const vec_base<T, Size> &a,
|
||||
const vec_base<T, Size> &b)
|
||||
[[nodiscard]] inline VecBase<T, Size> ceil_to_multiple(const VecBase<T, Size> &a,
|
||||
const VecBase<T, Size> &b)
|
||||
{
|
||||
vec_base<T, Size> result;
|
||||
VecBase<T, Size> result;
|
||||
for (int i = 0; i < Size; i++) {
|
||||
BLI_assert(a[i] >= 0);
|
||||
BLI_assert(b[i] > 0);
|
||||
|
|
@ -174,10 +171,10 @@ template<typename T, int Size>
|
|||
* It is undefined if \a a is negative or \b b is not strictly positive.
|
||||
*/
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> divide_ceil(const vec_base<T, Size> &a,
|
||||
const vec_base<T, Size> &b)
|
||||
[[nodiscard]] inline VecBase<T, Size> divide_ceil(const VecBase<T, Size> &a,
|
||||
const VecBase<T, Size> &b)
|
||||
{
|
||||
vec_base<T, Size> result;
|
||||
VecBase<T, Size> result;
|
||||
for (int i = 0; i < Size; i++) {
|
||||
BLI_assert(a[i] >= 0);
|
||||
BLI_assert(b[i] > 0);
|
||||
|
|
@ -187,17 +184,17 @@ template<typename T, int Size>
|
|||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
void min_max(const vec_base<T, Size> &vector, vec_base<T, Size> &min, vec_base<T, Size> &max)
|
||||
void min_max(const VecBase<T, Size> &vector, VecBase<T, Size> &min, VecBase<T, Size> &max)
|
||||
{
|
||||
min = math::min(vector, min);
|
||||
max = math::max(vector, max);
|
||||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> safe_divide(const vec_base<T, Size> &a,
|
||||
const vec_base<T, Size> &b)
|
||||
[[nodiscard]] inline VecBase<T, Size> safe_divide(const VecBase<T, Size> &a,
|
||||
const VecBase<T, Size> &b)
|
||||
{
|
||||
vec_base<T, Size> result;
|
||||
VecBase<T, Size> result;
|
||||
for (int i = 0; i < Size; i++) {
|
||||
result[i] = (b[i] == 0) ? 0 : a[i] / b[i];
|
||||
}
|
||||
|
|
@ -205,15 +202,15 @@ template<typename T, int Size>
|
|||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> safe_divide(const vec_base<T, Size> &a, const T &b)
|
||||
[[nodiscard]] inline VecBase<T, Size> safe_divide(const VecBase<T, Size> &a, const T &b)
|
||||
{
|
||||
return (b != 0) ? a / b : vec_base<T, Size>(0.0f);
|
||||
return (b != 0) ? a / b : VecBase<T, Size>(0.0f);
|
||||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> floor(const vec_base<T, Size> &a)
|
||||
[[nodiscard]] inline VecBase<T, Size> floor(const VecBase<T, Size> &a)
|
||||
{
|
||||
vec_base<T, Size> result;
|
||||
VecBase<T, Size> result;
|
||||
for (int i = 0; i < Size; i++) {
|
||||
result[i] = std::floor(a[i]);
|
||||
}
|
||||
|
|
@ -221,9 +218,9 @@ template<typename T, int Size>
|
|||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> ceil(const vec_base<T, Size> &a)
|
||||
[[nodiscard]] inline VecBase<T, Size> ceil(const VecBase<T, Size> &a)
|
||||
{
|
||||
vec_base<T, Size> result;
|
||||
VecBase<T, Size> result;
|
||||
for (int i = 0; i < Size; i++) {
|
||||
result[i] = std::ceil(a[i]);
|
||||
}
|
||||
|
|
@ -231,9 +228,9 @@ template<typename T, int Size>
|
|||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> fract(const vec_base<T, Size> &a)
|
||||
[[nodiscard]] inline VecBase<T, Size> fract(const VecBase<T, Size> &a)
|
||||
{
|
||||
vec_base<T, Size> result;
|
||||
VecBase<T, Size> result;
|
||||
for (int i = 0; i < Size; i++) {
|
||||
result[i] = a[i] - std::floor(a[i]);
|
||||
}
|
||||
|
|
@ -241,7 +238,7 @@ template<typename T, int Size>
|
|||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline T dot(const vec_base<T, Size> &a, const vec_base<T, Size> &b)
|
||||
[[nodiscard]] inline T dot(const VecBase<T, Size> &a, const VecBase<T, Size> &b)
|
||||
{
|
||||
T result = a[0] * b[0];
|
||||
for (int i = 1; i < Size; i++) {
|
||||
|
|
@ -250,7 +247,7 @@ template<typename T, int Size>
|
|||
return result;
|
||||
}
|
||||
|
||||
template<typename T, int Size> [[nodiscard]] inline T length_manhattan(const vec_base<T, Size> &a)
|
||||
template<typename T, int Size> [[nodiscard]] inline T length_manhattan(const VecBase<T, Size> &a)
|
||||
{
|
||||
T result = std::abs(a[0]);
|
||||
for (int i = 1; i < Size; i++) {
|
||||
|
|
@ -259,17 +256,17 @@ template<typename T, int Size> [[nodiscard]] inline T length_manhattan(const vec
|
|||
return result;
|
||||
}
|
||||
|
||||
template<typename T, int Size> [[nodiscard]] inline T length_squared(const vec_base<T, Size> &a)
|
||||
template<typename T, int Size> [[nodiscard]] inline T length_squared(const VecBase<T, Size> &a)
|
||||
{
|
||||
return dot(a, a);
|
||||
}
|
||||
|
||||
template<typename T, int Size> [[nodiscard]] inline T length(const vec_base<T, Size> &a)
|
||||
template<typename T, int Size> [[nodiscard]] inline T length(const VecBase<T, Size> &a)
|
||||
{
|
||||
return std::sqrt(length_squared(a));
|
||||
}
|
||||
|
||||
template<typename T, int Size> [[nodiscard]] inline bool is_unit_scale(const vec_base<T, Size> &v)
|
||||
template<typename T, int Size> [[nodiscard]] inline bool is_unit_scale(const VecBase<T, Size> &v)
|
||||
{
|
||||
/* Checks are flipped so NAN doesn't assert because we're making sure the value was
|
||||
* normalized and in the case we don't want NAN to be raising asserts since there
|
||||
|
|
@ -280,57 +277,57 @@ template<typename T, int Size> [[nodiscard]] inline bool is_unit_scale(const vec
|
|||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline T distance_manhattan(const vec_base<T, Size> &a, const vec_base<T, Size> &b)
|
||||
[[nodiscard]] inline T distance_manhattan(const VecBase<T, Size> &a, const VecBase<T, Size> &b)
|
||||
{
|
||||
return length_manhattan(a - b);
|
||||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline T distance_squared(const vec_base<T, Size> &a, const vec_base<T, Size> &b)
|
||||
[[nodiscard]] inline T distance_squared(const VecBase<T, Size> &a, const VecBase<T, Size> &b)
|
||||
{
|
||||
return length_squared(a - b);
|
||||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline T distance(const vec_base<T, Size> &a, const vec_base<T, Size> &b)
|
||||
[[nodiscard]] inline T distance(const VecBase<T, Size> &a, const VecBase<T, Size> &b)
|
||||
{
|
||||
return length(a - b);
|
||||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> reflect(const vec_base<T, Size> &incident,
|
||||
const vec_base<T, Size> &normal)
|
||||
[[nodiscard]] inline VecBase<T, Size> reflect(const VecBase<T, Size> &incident,
|
||||
const VecBase<T, Size> &normal)
|
||||
{
|
||||
BLI_assert(is_unit_scale(normal));
|
||||
return incident - 2.0 * dot(normal, incident) * normal;
|
||||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> refract(const vec_base<T, Size> &incident,
|
||||
const vec_base<T, Size> &normal,
|
||||
const T &eta)
|
||||
[[nodiscard]] inline VecBase<T, Size> refract(const VecBase<T, Size> &incident,
|
||||
const VecBase<T, Size> &normal,
|
||||
const T &eta)
|
||||
{
|
||||
float dot_ni = dot(normal, incident);
|
||||
float k = 1.0f - eta * eta * (1.0f - dot_ni * dot_ni);
|
||||
if (k < 0.0f) {
|
||||
return vec_base<T, Size>(0.0f);
|
||||
return VecBase<T, Size>(0.0f);
|
||||
}
|
||||
return eta * incident - (eta * dot_ni + sqrt(k)) * normal;
|
||||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> project(const vec_base<T, Size> &p,
|
||||
const vec_base<T, Size> &v_proj)
|
||||
[[nodiscard]] inline VecBase<T, Size> project(const VecBase<T, Size> &p,
|
||||
const VecBase<T, Size> &v_proj)
|
||||
{
|
||||
if (UNLIKELY(is_zero(v_proj))) {
|
||||
return vec_base<T, Size>(0.0f);
|
||||
return VecBase<T, Size>(0.0f);
|
||||
}
|
||||
return v_proj * (dot(p, v_proj) / dot(v_proj, v_proj));
|
||||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> normalize_and_get_length(const vec_base<T, Size> &v,
|
||||
T &out_length)
|
||||
[[nodiscard]] inline VecBase<T, Size> normalize_and_get_length(const VecBase<T, Size> &v,
|
||||
T &out_length)
|
||||
{
|
||||
out_length = length_squared(v);
|
||||
/* A larger value causes normalize errors in a scaled down models with camera extreme close. */
|
||||
|
|
@ -341,40 +338,40 @@ template<typename T, int Size>
|
|||
}
|
||||
/* Either the vector is small or one of it's values contained `nan`. */
|
||||
out_length = 0.0;
|
||||
return vec_base<T, Size>(0.0);
|
||||
return VecBase<T, Size>(0.0);
|
||||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> normalize(const vec_base<T, Size> &v)
|
||||
[[nodiscard]] inline VecBase<T, Size> normalize(const VecBase<T, Size> &v)
|
||||
{
|
||||
T len;
|
||||
return normalize_and_get_length(v, len);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
[[nodiscard]] inline vec_base<T, 3> cross(const vec_base<T, 3> &a, const vec_base<T, 3> &b)
|
||||
[[nodiscard]] inline VecBase<T, 3> cross(const VecBase<T, 3> &a, const VecBase<T, 3> &b)
|
||||
{
|
||||
return {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x};
|
||||
}
|
||||
|
||||
[[nodiscard]] inline vec_base<float, 3> cross_high_precision(const vec_base<float, 3> &a,
|
||||
const vec_base<float, 3> &b)
|
||||
[[nodiscard]] inline VecBase<float, 3> cross_high_precision(const VecBase<float, 3> &a,
|
||||
const VecBase<float, 3> &b)
|
||||
{
|
||||
return {float(double(a.y) * double(b.z) - double(a.z) * double(b.y)),
|
||||
float(double(a.z) * double(b.x) - double(a.x) * double(b.z)),
|
||||
float(double(a.x) * double(b.y) - double(a.y) * double(b.x))};
|
||||
}
|
||||
|
||||
template<typename T> [[nodiscard]] inline vec_base<T, 3> cross_poly(Span<vec_base<T, 3>> poly)
|
||||
template<typename T> [[nodiscard]] inline VecBase<T, 3> cross_poly(Span<VecBase<T, 3>> poly)
|
||||
{
|
||||
/* Newell's Method. */
|
||||
int nv = int(poly.size());
|
||||
if (nv < 3) {
|
||||
return vec_base<T, 3>(0, 0, 0);
|
||||
return VecBase<T, 3>(0, 0, 0);
|
||||
}
|
||||
const vec_base<T, 3> *v_prev = &poly[nv - 1];
|
||||
const vec_base<T, 3> *v_curr = &poly[0];
|
||||
vec_base<T, 3> n(0, 0, 0);
|
||||
const VecBase<T, 3> *v_prev = &poly[nv - 1];
|
||||
const VecBase<T, 3> *v_curr = &poly[0];
|
||||
VecBase<T, 3> n(0, 0, 0);
|
||||
for (int i = 0; i < nv;) {
|
||||
n[0] = n[0] + ((*v_prev)[1] - (*v_curr)[1]) * ((*v_prev)[2] + (*v_curr)[2]);
|
||||
n[1] = n[1] + ((*v_prev)[2] - (*v_curr)[2]) * ((*v_prev)[0] + (*v_curr)[0]);
|
||||
|
|
@ -389,16 +386,16 @@ template<typename T> [[nodiscard]] inline vec_base<T, 3> cross_poly(Span<vec_bas
|
|||
}
|
||||
|
||||
template<typename T, typename FactorT, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> interpolate(const vec_base<T, Size> &a,
|
||||
const vec_base<T, Size> &b,
|
||||
const FactorT &t)
|
||||
[[nodiscard]] inline VecBase<T, Size> interpolate(const VecBase<T, Size> &a,
|
||||
const VecBase<T, Size> &b,
|
||||
const FactorT &t)
|
||||
{
|
||||
return a * (1 - t) + b * t;
|
||||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> midpoint(const vec_base<T, Size> &a,
|
||||
const vec_base<T, Size> &b)
|
||||
[[nodiscard]] inline VecBase<T, Size> midpoint(const VecBase<T, Size> &a,
|
||||
const VecBase<T, Size> &b)
|
||||
{
|
||||
return (a + b) * 0.5;
|
||||
}
|
||||
|
|
@ -407,16 +404,16 @@ template<typename T, int Size>
|
|||
* Return `vector` if `incident` and `reference` are pointing in the same direction.
|
||||
*/
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline vec_base<T, Size> faceforward(const vec_base<T, Size> &vector,
|
||||
const vec_base<T, Size> &incident,
|
||||
const vec_base<T, Size> &reference)
|
||||
[[nodiscard]] inline VecBase<T, Size> faceforward(const VecBase<T, Size> &vector,
|
||||
const VecBase<T, Size> &incident,
|
||||
const VecBase<T, Size> &reference)
|
||||
{
|
||||
return (dot(reference, incident) < 0) ? vector : -vector;
|
||||
}
|
||||
|
||||
template<typename T> [[nodiscard]] inline int dominant_axis(const vec_base<T, 3> &a)
|
||||
template<typename T> [[nodiscard]] inline int dominant_axis(const VecBase<T, 3> &a)
|
||||
{
|
||||
vec_base<T, 3> b = abs(a);
|
||||
VecBase<T, 3> b = abs(a);
|
||||
return ((b.x > b.y) ? ((b.x > b.z) ? 0 : 2) : ((b.y > b.z) ? 1 : 2));
|
||||
}
|
||||
|
||||
|
|
@ -425,7 +422,7 @@ template<typename T> [[nodiscard]] inline int dominant_axis(const vec_base<T, 3>
|
|||
* \note Returned vector can be in any perpendicular direction.
|
||||
* \note Returned vector might not the same length as \a v.
|
||||
*/
|
||||
template<typename T> [[nodiscard]] inline vec_base<T, 3> orthogonal(const vec_base<T, 3> &v)
|
||||
template<typename T> [[nodiscard]] inline VecBase<T, 3> orthogonal(const VecBase<T, 3> &v)
|
||||
{
|
||||
const int axis = dominant_axis(v);
|
||||
switch (axis) {
|
||||
|
|
@ -443,14 +440,14 @@ template<typename T> [[nodiscard]] inline vec_base<T, 3> orthogonal(const vec_ba
|
|||
* Calculates a perpendicular vector to \a v.
|
||||
* \note Returned vector can be in any perpendicular direction.
|
||||
*/
|
||||
template<typename T> [[nodiscard]] inline vec_base<T, 2> orthogonal(const vec_base<T, 2> &v)
|
||||
template<typename T> [[nodiscard]] inline VecBase<T, 2> orthogonal(const VecBase<T, 2> &v)
|
||||
{
|
||||
return {-v.y, v.x};
|
||||
}
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] inline bool is_equal(const vec_base<T, Size> &a,
|
||||
const vec_base<T, Size> &b,
|
||||
[[nodiscard]] inline bool is_equal(const VecBase<T, Size> &a,
|
||||
const VecBase<T, Size> &b,
|
||||
const T epsilon = T(0))
|
||||
{
|
||||
for (int i = 0; i < Size; i++) {
|
||||
|
|
@ -474,9 +471,9 @@ template<typename T> struct isect_result {
|
|||
};
|
||||
|
||||
template<typename T, int Size>
|
||||
[[nodiscard]] isect_result<vec_base<T, Size>> isect_seg_seg(const vec_base<T, Size> &v1,
|
||||
const vec_base<T, Size> &v2,
|
||||
const vec_base<T, Size> &v3,
|
||||
const vec_base<T, Size> &v4);
|
||||
[[nodiscard]] isect_result<VecBase<T, Size>> isect_seg_seg(const VecBase<T, Size> &v1,
|
||||
const VecBase<T, Size> &v2,
|
||||
const VecBase<T, Size> &v3,
|
||||
const VecBase<T, Size> &v4);
|
||||
|
||||
} // namespace blender::math
|
||||
|
|
|
|||
|
|
@ -14,8 +14,8 @@
|
|||
|
||||
namespace blender {
|
||||
|
||||
using mpq2 = vec_base<mpq_class, 2>;
|
||||
using mpq3 = vec_base<mpq_class, 3>;
|
||||
using mpq2 = VecBase<mpq_class, 2>;
|
||||
using mpq3 = VecBase<mpq_class, 3>;
|
||||
|
||||
namespace math {
|
||||
|
||||
|
|
|
|||
|
|
@ -77,16 +77,16 @@ template<typename T> uint64_t vector_hash(const T &vec)
|
|||
|
||||
} // namespace math
|
||||
|
||||
template<typename T, int Size> struct vec_base : public vec_struct_base<T, Size> {
|
||||
template<typename T, int Size> struct VecBase : public vec_struct_base<T, Size> {
|
||||
|
||||
static constexpr int type_length = Size;
|
||||
|
||||
using base_type = T;
|
||||
using uint_type = vec_base<as_uint_type<T>, Size>;
|
||||
using uint_type = VecBase<as_uint_type<T>, Size>;
|
||||
|
||||
vec_base() = default;
|
||||
VecBase() = default;
|
||||
|
||||
explicit vec_base(T value)
|
||||
explicit VecBase(T value)
|
||||
{
|
||||
for (int i = 0; i < Size; i++) {
|
||||
(*this)[i] = value;
|
||||
|
|
@ -94,27 +94,27 @@ template<typename T, int Size> struct vec_base : public vec_struct_base<T, Size>
|
|||
}
|
||||
|
||||
template<typename U, BLI_ENABLE_IF((std::is_convertible_v<U, T>))>
|
||||
explicit vec_base(U value) : vec_base(T(value))
|
||||
explicit VecBase(U value) : VecBase(T(value))
|
||||
{
|
||||
}
|
||||
|
||||
/* Workaround issue with template BLI_ENABLE_IF((Size == 2)) not working. */
|
||||
#define BLI_ENABLE_IF_VEC(_size, _test) int S = _size, BLI_ENABLE_IF((S _test))
|
||||
|
||||
template<BLI_ENABLE_IF_VEC(Size, == 2)> vec_base(T _x, T _y)
|
||||
template<BLI_ENABLE_IF_VEC(Size, == 2)> VecBase(T _x, T _y)
|
||||
{
|
||||
(*this)[0] = _x;
|
||||
(*this)[1] = _y;
|
||||
}
|
||||
|
||||
template<BLI_ENABLE_IF_VEC(Size, == 3)> vec_base(T _x, T _y, T _z)
|
||||
template<BLI_ENABLE_IF_VEC(Size, == 3)> VecBase(T _x, T _y, T _z)
|
||||
{
|
||||
(*this)[0] = _x;
|
||||
(*this)[1] = _y;
|
||||
(*this)[2] = _z;
|
||||
}
|
||||
|
||||
template<BLI_ENABLE_IF_VEC(Size, == 4)> vec_base(T _x, T _y, T _z, T _w)
|
||||
template<BLI_ENABLE_IF_VEC(Size, == 4)> VecBase(T _x, T _y, T _z, T _w)
|
||||
{
|
||||
(*this)[0] = _x;
|
||||
(*this)[1] = _y;
|
||||
|
|
@ -125,49 +125,49 @@ template<typename T, int Size> struct vec_base : public vec_struct_base<T, Size>
|
|||
/** Mixed scalar-vector constructors. */
|
||||
|
||||
template<typename U, BLI_ENABLE_IF_VEC(Size, == 3)>
|
||||
constexpr vec_base(const vec_base<U, 2> &xy, T z) : vec_base(T(xy.x), T(xy.y), z)
|
||||
constexpr VecBase(const VecBase<U, 2> &xy, T z) : VecBase(T(xy.x), T(xy.y), z)
|
||||
{
|
||||
}
|
||||
|
||||
template<typename U, BLI_ENABLE_IF_VEC(Size, == 3)>
|
||||
constexpr vec_base(T x, const vec_base<U, 2> &yz) : vec_base(x, T(yz.x), T(yz.y))
|
||||
constexpr VecBase(T x, const VecBase<U, 2> &yz) : VecBase(x, T(yz.x), T(yz.y))
|
||||
{
|
||||
}
|
||||
|
||||
template<typename U, BLI_ENABLE_IF_VEC(Size, == 4)>
|
||||
vec_base(vec_base<U, 3> xyz, T w) : vec_base(T(xyz.x), T(xyz.y), T(xyz.z), T(w))
|
||||
VecBase(VecBase<U, 3> xyz, T w) : VecBase(T(xyz.x), T(xyz.y), T(xyz.z), T(w))
|
||||
{
|
||||
}
|
||||
|
||||
template<typename U, BLI_ENABLE_IF_VEC(Size, == 4)>
|
||||
vec_base(T x, vec_base<U, 3> yzw) : vec_base(T(x), T(yzw.x), T(yzw.y), T(yzw.z))
|
||||
VecBase(T x, VecBase<U, 3> yzw) : VecBase(T(x), T(yzw.x), T(yzw.y), T(yzw.z))
|
||||
{
|
||||
}
|
||||
|
||||
template<typename U, typename V, BLI_ENABLE_IF_VEC(Size, == 4)>
|
||||
vec_base(vec_base<U, 2> xy, vec_base<V, 2> zw) : vec_base(T(xy.x), T(xy.y), T(zw.x), T(zw.y))
|
||||
VecBase(VecBase<U, 2> xy, VecBase<V, 2> zw) : VecBase(T(xy.x), T(xy.y), T(zw.x), T(zw.y))
|
||||
{
|
||||
}
|
||||
|
||||
template<typename U, BLI_ENABLE_IF_VEC(Size, == 4)>
|
||||
vec_base(vec_base<U, 2> xy, T z, T w) : vec_base(T(xy.x), T(xy.y), T(z), T(w))
|
||||
VecBase(VecBase<U, 2> xy, T z, T w) : VecBase(T(xy.x), T(xy.y), T(z), T(w))
|
||||
{
|
||||
}
|
||||
|
||||
template<typename U, BLI_ENABLE_IF_VEC(Size, == 4)>
|
||||
vec_base(T x, vec_base<U, 2> yz, T w) : vec_base(T(x), T(yz.x), T(yz.y), T(w))
|
||||
VecBase(T x, VecBase<U, 2> yz, T w) : VecBase(T(x), T(yz.x), T(yz.y), T(w))
|
||||
{
|
||||
}
|
||||
|
||||
template<typename U, BLI_ENABLE_IF_VEC(Size, == 4)>
|
||||
vec_base(T x, T y, vec_base<U, 2> zw) : vec_base(T(x), T(y), T(zw.x), T(zw.y))
|
||||
VecBase(T x, T y, VecBase<U, 2> zw) : VecBase(T(x), T(y), T(zw.x), T(zw.y))
|
||||
{
|
||||
}
|
||||
|
||||
/** Masking. */
|
||||
|
||||
template<typename U, int OtherSize, BLI_ENABLE_IF(OtherSize > Size)>
|
||||
explicit vec_base(const vec_base<U, OtherSize> &other)
|
||||
explicit VecBase(const VecBase<U, OtherSize> &other)
|
||||
{
|
||||
for (int i = 0; i < Size; i++) {
|
||||
(*this)[i] = T(other[i]);
|
||||
|
|
@ -178,24 +178,23 @@ template<typename T, int Size> struct vec_base : public vec_struct_base<T, Size>
|
|||
|
||||
/** Conversion from pointers (from C-style vectors). */
|
||||
|
||||
vec_base(const T *ptr)
|
||||
VecBase(const T *ptr)
|
||||
{
|
||||
unroll<Size>([&](auto i) { (*this)[i] = ptr[i]; });
|
||||
}
|
||||
|
||||
template<typename U, BLI_ENABLE_IF((std::is_convertible_v<U, T>))>
|
||||
explicit vec_base(const U *ptr)
|
||||
template<typename U, BLI_ENABLE_IF((std::is_convertible_v<U, T>))> explicit VecBase(const U *ptr)
|
||||
{
|
||||
unroll<Size>([&](auto i) { (*this)[i] = ptr[i]; });
|
||||
}
|
||||
|
||||
vec_base(const T (*ptr)[Size]) : vec_base(static_cast<const T *>(ptr[0]))
|
||||
VecBase(const T (*ptr)[Size]) : VecBase(static_cast<const T *>(ptr[0]))
|
||||
{
|
||||
}
|
||||
|
||||
/** Conversion from other vector types. */
|
||||
|
||||
template<typename U> explicit vec_base(const vec_base<U, Size> &vec)
|
||||
template<typename U> explicit VecBase(const VecBase<U, Size> &vec)
|
||||
{
|
||||
unroll<Size>([&](auto i) { (*this)[i] = T(vec[i]); });
|
||||
}
|
||||
|
|
@ -234,144 +233,144 @@ template<typename T, int Size> struct vec_base : public vec_struct_base<T, Size>
|
|||
|
||||
/** Arithmetic operators. */
|
||||
|
||||
friend vec_base operator+(const vec_base &a, const vec_base &b)
|
||||
friend VecBase operator+(const VecBase &a, const VecBase &b)
|
||||
{
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] + b[i]; });
|
||||
return result;
|
||||
}
|
||||
|
||||
friend vec_base operator+(const vec_base &a, const T &b)
|
||||
friend VecBase operator+(const VecBase &a, const T &b)
|
||||
{
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] + b; });
|
||||
return result;
|
||||
}
|
||||
|
||||
friend vec_base operator+(const T &a, const vec_base &b)
|
||||
friend VecBase operator+(const T &a, const VecBase &b)
|
||||
{
|
||||
return b + a;
|
||||
}
|
||||
|
||||
vec_base &operator+=(const vec_base &b)
|
||||
VecBase &operator+=(const VecBase &b)
|
||||
{
|
||||
unroll<Size>([&](auto i) { (*this)[i] += b[i]; });
|
||||
return *this;
|
||||
}
|
||||
|
||||
vec_base &operator+=(const T &b)
|
||||
VecBase &operator+=(const T &b)
|
||||
{
|
||||
unroll<Size>([&](auto i) { (*this)[i] += b; });
|
||||
return *this;
|
||||
}
|
||||
|
||||
friend vec_base operator-(const vec_base &a)
|
||||
friend VecBase operator-(const VecBase &a)
|
||||
{
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = -a[i]; });
|
||||
return result;
|
||||
}
|
||||
|
||||
friend vec_base operator-(const vec_base &a, const vec_base &b)
|
||||
friend VecBase operator-(const VecBase &a, const VecBase &b)
|
||||
{
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] - b[i]; });
|
||||
return result;
|
||||
}
|
||||
|
||||
friend vec_base operator-(const vec_base &a, const T &b)
|
||||
friend VecBase operator-(const VecBase &a, const T &b)
|
||||
{
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] - b; });
|
||||
return result;
|
||||
}
|
||||
|
||||
friend vec_base operator-(const T &a, const vec_base &b)
|
||||
friend VecBase operator-(const T &a, const VecBase &b)
|
||||
{
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a - b[i]; });
|
||||
return result;
|
||||
}
|
||||
|
||||
vec_base &operator-=(const vec_base &b)
|
||||
VecBase &operator-=(const VecBase &b)
|
||||
{
|
||||
unroll<Size>([&](auto i) { (*this)[i] -= b[i]; });
|
||||
return *this;
|
||||
}
|
||||
|
||||
vec_base &operator-=(const T &b)
|
||||
VecBase &operator-=(const T &b)
|
||||
{
|
||||
unroll<Size>([&](auto i) { (*this)[i] -= b; });
|
||||
return *this;
|
||||
}
|
||||
|
||||
friend vec_base operator*(const vec_base &a, const vec_base &b)
|
||||
friend VecBase operator*(const VecBase &a, const VecBase &b)
|
||||
{
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] * b[i]; });
|
||||
return result;
|
||||
}
|
||||
|
||||
template<typename FactorT> friend vec_base operator*(const vec_base &a, FactorT b)
|
||||
template<typename FactorT> friend VecBase operator*(const VecBase &a, FactorT b)
|
||||
{
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] * b; });
|
||||
return result;
|
||||
}
|
||||
|
||||
friend vec_base operator*(T a, const vec_base &b)
|
||||
friend VecBase operator*(T a, const VecBase &b)
|
||||
{
|
||||
return b * a;
|
||||
}
|
||||
|
||||
vec_base &operator*=(T b)
|
||||
VecBase &operator*=(T b)
|
||||
{
|
||||
unroll<Size>([&](auto i) { (*this)[i] *= b; });
|
||||
return *this;
|
||||
}
|
||||
|
||||
vec_base &operator*=(const vec_base &b)
|
||||
VecBase &operator*=(const VecBase &b)
|
||||
{
|
||||
unroll<Size>([&](auto i) { (*this)[i] *= b[i]; });
|
||||
return *this;
|
||||
}
|
||||
|
||||
friend vec_base operator/(const vec_base &a, const vec_base &b)
|
||||
friend VecBase operator/(const VecBase &a, const VecBase &b)
|
||||
{
|
||||
for (int i = 0; i < Size; i++) {
|
||||
BLI_assert(b[i] != T(0));
|
||||
}
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] / b[i]; });
|
||||
return result;
|
||||
}
|
||||
|
||||
friend vec_base operator/(const vec_base &a, T b)
|
||||
friend VecBase operator/(const VecBase &a, T b)
|
||||
{
|
||||
BLI_assert(b != T(0));
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] / b; });
|
||||
return result;
|
||||
}
|
||||
|
||||
friend vec_base operator/(T a, const vec_base &b)
|
||||
friend VecBase operator/(T a, const VecBase &b)
|
||||
{
|
||||
for (int i = 0; i < Size; i++) {
|
||||
BLI_assert(b[i] != T(0));
|
||||
}
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a / b[i]; });
|
||||
return result;
|
||||
}
|
||||
|
||||
vec_base &operator/=(T b)
|
||||
VecBase &operator/=(T b)
|
||||
{
|
||||
BLI_assert(b != T(0));
|
||||
unroll<Size>([&](auto i) { (*this)[i] /= b; });
|
||||
return *this;
|
||||
}
|
||||
|
||||
vec_base &operator/=(const vec_base &b)
|
||||
VecBase &operator/=(const VecBase &b)
|
||||
{
|
||||
BLI_assert(b != T(0));
|
||||
unroll<Size>([&](auto i) { (*this)[i] /= b[i]; });
|
||||
|
|
@ -380,155 +379,155 @@ template<typename T, int Size> struct vec_base : public vec_struct_base<T, Size>
|
|||
|
||||
/** Binary operators. */
|
||||
|
||||
BLI_INT_OP(T) friend vec_base operator&(const vec_base &a, const vec_base &b)
|
||||
BLI_INT_OP(T) friend VecBase operator&(const VecBase &a, const VecBase &b)
|
||||
{
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] & b[i]; });
|
||||
return result;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) friend vec_base operator&(const vec_base &a, T b)
|
||||
BLI_INT_OP(T) friend VecBase operator&(const VecBase &a, T b)
|
||||
{
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] & b; });
|
||||
return result;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) friend vec_base operator&(T a, const vec_base &b)
|
||||
BLI_INT_OP(T) friend VecBase operator&(T a, const VecBase &b)
|
||||
{
|
||||
return b & a;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) vec_base &operator&=(T b)
|
||||
BLI_INT_OP(T) VecBase &operator&=(T b)
|
||||
{
|
||||
unroll<Size>([&](auto i) { (*this)[i] &= b; });
|
||||
return *this;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) vec_base &operator&=(const vec_base &b)
|
||||
BLI_INT_OP(T) VecBase &operator&=(const VecBase &b)
|
||||
{
|
||||
unroll<Size>([&](auto i) { (*this)[i] &= b[i]; });
|
||||
return *this;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) friend vec_base operator|(const vec_base &a, const vec_base &b)
|
||||
BLI_INT_OP(T) friend VecBase operator|(const VecBase &a, const VecBase &b)
|
||||
{
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] | b[i]; });
|
||||
return result;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) friend vec_base operator|(const vec_base &a, T b)
|
||||
BLI_INT_OP(T) friend VecBase operator|(const VecBase &a, T b)
|
||||
{
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] | b; });
|
||||
return result;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) friend vec_base operator|(T a, const vec_base &b)
|
||||
BLI_INT_OP(T) friend VecBase operator|(T a, const VecBase &b)
|
||||
{
|
||||
return b | a;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) vec_base &operator|=(T b)
|
||||
BLI_INT_OP(T) VecBase &operator|=(T b)
|
||||
{
|
||||
unroll<Size>([&](auto i) { (*this)[i] |= b; });
|
||||
return *this;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) vec_base &operator|=(const vec_base &b)
|
||||
BLI_INT_OP(T) VecBase &operator|=(const VecBase &b)
|
||||
{
|
||||
unroll<Size>([&](auto i) { (*this)[i] |= b[i]; });
|
||||
return *this;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) friend vec_base operator^(const vec_base &a, const vec_base &b)
|
||||
BLI_INT_OP(T) friend VecBase operator^(const VecBase &a, const VecBase &b)
|
||||
{
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] ^ b[i]; });
|
||||
return result;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) friend vec_base operator^(const vec_base &a, T b)
|
||||
BLI_INT_OP(T) friend VecBase operator^(const VecBase &a, T b)
|
||||
{
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] ^ b; });
|
||||
return result;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) friend vec_base operator^(T a, const vec_base &b)
|
||||
BLI_INT_OP(T) friend VecBase operator^(T a, const VecBase &b)
|
||||
{
|
||||
return b ^ a;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) vec_base &operator^=(T b)
|
||||
BLI_INT_OP(T) VecBase &operator^=(T b)
|
||||
{
|
||||
unroll<Size>([&](auto i) { (*this)[i] ^= b; });
|
||||
return *this;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) vec_base &operator^=(const vec_base &b)
|
||||
BLI_INT_OP(T) VecBase &operator^=(const VecBase &b)
|
||||
{
|
||||
unroll<Size>([&](auto i) { (*this)[i] ^= b[i]; });
|
||||
return *this;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) friend vec_base operator~(const vec_base &a)
|
||||
BLI_INT_OP(T) friend VecBase operator~(const VecBase &a)
|
||||
{
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = ~a[i]; });
|
||||
return result;
|
||||
}
|
||||
|
||||
/** Bit-shift operators. */
|
||||
|
||||
BLI_INT_OP(T) friend vec_base operator<<(const vec_base &a, const vec_base &b)
|
||||
BLI_INT_OP(T) friend VecBase operator<<(const VecBase &a, const VecBase &b)
|
||||
{
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] << b[i]; });
|
||||
return result;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) friend vec_base operator<<(const vec_base &a, T b)
|
||||
BLI_INT_OP(T) friend VecBase operator<<(const VecBase &a, T b)
|
||||
{
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] << b; });
|
||||
return result;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) vec_base &operator<<=(T b)
|
||||
BLI_INT_OP(T) VecBase &operator<<=(T b)
|
||||
{
|
||||
unroll<Size>([&](auto i) { (*this)[i] <<= b; });
|
||||
return *this;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) vec_base &operator<<=(const vec_base &b)
|
||||
BLI_INT_OP(T) VecBase &operator<<=(const VecBase &b)
|
||||
{
|
||||
unroll<Size>([&](auto i) { (*this)[i] <<= b[i]; });
|
||||
return *this;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) friend vec_base operator>>(const vec_base &a, const vec_base &b)
|
||||
BLI_INT_OP(T) friend VecBase operator>>(const VecBase &a, const VecBase &b)
|
||||
{
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] >> b[i]; });
|
||||
return result;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) friend vec_base operator>>(const vec_base &a, T b)
|
||||
BLI_INT_OP(T) friend VecBase operator>>(const VecBase &a, T b)
|
||||
{
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] >> b; });
|
||||
return result;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) vec_base &operator>>=(T b)
|
||||
BLI_INT_OP(T) VecBase &operator>>=(T b)
|
||||
{
|
||||
unroll<Size>([&](auto i) { (*this)[i] >>= b; });
|
||||
return *this;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) vec_base &operator>>=(const vec_base &b)
|
||||
BLI_INT_OP(T) VecBase &operator>>=(const VecBase &b)
|
||||
{
|
||||
unroll<Size>([&](auto i) { (*this)[i] >>= b[i]; });
|
||||
return *this;
|
||||
|
|
@ -536,28 +535,28 @@ template<typename T, int Size> struct vec_base : public vec_struct_base<T, Size>
|
|||
|
||||
/** Modulo operators. */
|
||||
|
||||
BLI_INT_OP(T) friend vec_base operator%(const vec_base &a, const vec_base &b)
|
||||
BLI_INT_OP(T) friend VecBase operator%(const VecBase &a, const VecBase &b)
|
||||
{
|
||||
for (int i = 0; i < Size; i++) {
|
||||
BLI_assert(b[i] != T(0));
|
||||
}
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] % b[i]; });
|
||||
return result;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) friend vec_base operator%(const vec_base &a, T b)
|
||||
BLI_INT_OP(T) friend VecBase operator%(const VecBase &a, T b)
|
||||
{
|
||||
BLI_assert(b != 0);
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a[i] % b; });
|
||||
return result;
|
||||
}
|
||||
|
||||
BLI_INT_OP(T) friend vec_base operator%(T a, const vec_base &b)
|
||||
BLI_INT_OP(T) friend VecBase operator%(T a, const VecBase &b)
|
||||
{
|
||||
BLI_assert(b != T(0));
|
||||
vec_base result;
|
||||
VecBase result;
|
||||
unroll<Size>([&](auto i) { result[i] = a % b[i]; });
|
||||
return result;
|
||||
}
|
||||
|
|
@ -566,7 +565,7 @@ template<typename T, int Size> struct vec_base : public vec_struct_base<T, Size>
|
|||
|
||||
/** Compare. */
|
||||
|
||||
friend bool operator==(const vec_base &a, const vec_base &b)
|
||||
friend bool operator==(const VecBase &a, const VecBase &b)
|
||||
{
|
||||
for (int i = 0; i < Size; i++) {
|
||||
if (a[i] != b[i]) {
|
||||
|
|
@ -576,7 +575,7 @@ template<typename T, int Size> struct vec_base : public vec_struct_base<T, Size>
|
|||
return true;
|
||||
}
|
||||
|
||||
friend bool operator!=(const vec_base &a, const vec_base &b)
|
||||
friend bool operator!=(const VecBase &a, const VecBase &b)
|
||||
{
|
||||
return !(a == b);
|
||||
}
|
||||
|
|
@ -588,7 +587,7 @@ template<typename T, int Size> struct vec_base : public vec_struct_base<T, Size>
|
|||
return math::vector_hash(*this);
|
||||
}
|
||||
|
||||
friend std::ostream &operator<<(std::ostream &stream, const vec_base &v)
|
||||
friend std::ostream &operator<<(std::ostream &stream, const VecBase &v)
|
||||
{
|
||||
stream << "(";
|
||||
for (int i = 0; i < Size; i++) {
|
||||
|
|
@ -611,32 +610,32 @@ template<typename T> struct AssertUnitEpsilon {
|
|||
|
||||
} // namespace math
|
||||
|
||||
using char3 = blender::vec_base<int8_t, 3>;
|
||||
using char3 = blender::VecBase<int8_t, 3>;
|
||||
|
||||
using uchar3 = blender::vec_base<uint8_t, 3>;
|
||||
using uchar4 = blender::vec_base<uint8_t, 4>;
|
||||
using uchar3 = blender::VecBase<uint8_t, 3>;
|
||||
using uchar4 = blender::VecBase<uint8_t, 4>;
|
||||
|
||||
using int2 = vec_base<int32_t, 2>;
|
||||
using int3 = vec_base<int32_t, 3>;
|
||||
using int4 = vec_base<int32_t, 4>;
|
||||
using int2 = VecBase<int32_t, 2>;
|
||||
using int3 = VecBase<int32_t, 3>;
|
||||
using int4 = VecBase<int32_t, 4>;
|
||||
|
||||
using uint2 = vec_base<uint32_t, 2>;
|
||||
using uint3 = vec_base<uint32_t, 3>;
|
||||
using uint4 = vec_base<uint32_t, 4>;
|
||||
using uint2 = VecBase<uint32_t, 2>;
|
||||
using uint3 = VecBase<uint32_t, 3>;
|
||||
using uint4 = VecBase<uint32_t, 4>;
|
||||
|
||||
using short2 = blender::vec_base<int16_t, 2>;
|
||||
using short3 = blender::vec_base<int16_t, 3>;
|
||||
using short2 = blender::VecBase<int16_t, 2>;
|
||||
using short3 = blender::VecBase<int16_t, 3>;
|
||||
|
||||
using ushort2 = vec_base<uint16_t, 2>;
|
||||
using ushort3 = blender::vec_base<uint16_t, 3>;
|
||||
using ushort4 = blender::vec_base<uint16_t, 4>;
|
||||
using ushort2 = VecBase<uint16_t, 2>;
|
||||
using ushort3 = blender::VecBase<uint16_t, 3>;
|
||||
using ushort4 = blender::VecBase<uint16_t, 4>;
|
||||
|
||||
using float2 = vec_base<float, 2>;
|
||||
using float3 = vec_base<float, 3>;
|
||||
using float4 = vec_base<float, 4>;
|
||||
using float2 = VecBase<float, 2>;
|
||||
using float3 = VecBase<float, 3>;
|
||||
using float4 = VecBase<float, 4>;
|
||||
|
||||
using double2 = vec_base<double, 2>;
|
||||
using double3 = vec_base<double, 3>;
|
||||
using double4 = vec_base<double, 4>;
|
||||
using double2 = VecBase<double, 2>;
|
||||
using double3 = VecBase<double, 3>;
|
||||
using double4 = VecBase<double, 4>;
|
||||
|
||||
} // namespace blender
|
||||
|
|
|
|||
|
|
@ -214,7 +214,7 @@ MatBase<T, Size, Size> pseudo_invert(const MatBase<T, Size, Size> &mat, T epsilo
|
|||
* of `A` as `Ainv = V.Winv.transpose(U)`.
|
||||
*/
|
||||
MatBase<T, Size, Size> U, W, V;
|
||||
vec_base<T, Size> S_val;
|
||||
VecBase<T, Size> S_val;
|
||||
|
||||
{
|
||||
using namespace Eigen;
|
||||
|
|
@ -274,7 +274,7 @@ static void polar_decompose(const MatBase<T, 3, 3> &mat3,
|
|||
* P = VSV*
|
||||
*/
|
||||
MatBase<T, 3, 3> W, V;
|
||||
vec_base<T, 3> S_val;
|
||||
VecBase<T, 3> S_val;
|
||||
|
||||
{
|
||||
using namespace Eigen;
|
||||
|
|
|
|||
Loading…
Reference in New Issue