[Bf-blender-cvs] [28f99dda6c6] temp-experimental-cpp-math-refactor: Merge branch 'master' into math-refactor
Jacques Lucke
noreply at git.blender.org
Mon Jan 11 18:40:53 CET 2021
Commit: 28f99dda6c6273a69f9926806ee255db605e0a61
Author: Jacques Lucke
Date: Mon Jan 11 15:04:19 2021 +0100
Branches: temp-experimental-cpp-math-refactor
https://developer.blender.org/rB28f99dda6c6273a69f9926806ee255db605e0a61
Merge branch 'master' into math-refactor
===================================================================
===================================================================
diff --cc source/blender/blenlib/BLI_double3.hh
index 0d60148e1de,ab258c9121b..5f7b0f330b9
--- a/source/blender/blenlib/BLI_double3.hh
+++ b/source/blender/blenlib/BLI_double3.hh
@@@ -65,185 -65,182 +65,186 @@@ struct double3
static double3 cross_poly(Span<double3> poly);
};
-} // namespace blender
+inline double normalize_and_get_length(double3 &a)
+{
+ return normalize_v3_db(a);
+}
+
+inline double3 normalized(const double3 &a)
+{
+ double3 result;
+ normalize_v3_v3_db(result, a);
+ return result;
+}
+
+inline double length(const double3 &a)
+{
+ return len_v3_db(a);
+}
+
+inline double length_squared(const double3 &a)
+{
+ return len_squared_v3_db(a);
+}
+
+inline double3 reflected(const double3 &a, const double3 &normal)
+{
+ double3 result;
+ reflect_v3_v3v3_db(result, a, normal);
+ return result;
+}
+
+inline void reflect(double3 &a, const double3 &normal)
+{
+ a = reflected(a, normal);
+}
+
+inline double3 safe_divide(const double3 &a, const double3 &b)
+{
+ double3 result;
+ result.x = (b.x == 0.0) ? 0.0 : a.x / b.x;
+ result.y = (b.y == 0.0) ? 0.0 : a.y / b.y;
+ result.z = (b.z == 0.0) ? 0.0 : a.z / b.z;
+ return result;
+}
+
+inline void negate(double3 &a)
+{
+ a.x = -a.x;
+ a.y = -a.y;
+ a.z = -a.z;
+}
+
+inline double3 operator+(const double3 &a, const double3 &b)
+{
+ return {a.x + b.x, a.y + b.y, a.z + b.z};
+}
+
+inline void operator+=(double3 &a, const double3 &b)
+{
+ a.x += b.x;
+ a.y += b.y;
+ a.z += b.z;
+}
+
+inline double3 operator-(const double3 &a, const double3 &b)
+{
+ return {a.x - b.x, a.y - b.y, a.z - b.z};
+}
+
+inline double3 operator-(const double3 &a)
+{
+ return {-a.x, -a.y, -a.z};
+}
+
+inline void operator-=(double3 &a, const double3 &b)
+{
+ a.x -= b.x;
+ a.y -= b.y;
+ a.z -= b.z;
+}
+
+inline void operator*=(double3 &a, const double &scalar)
+{
+ a.x *= scalar;
+ a.y *= scalar;
+ a.z *= scalar;
+}
+
+inline void operator*=(double3 &a, const double3 &other)
+{
+ a.x *= other.x;
+ a.y *= other.y;
+ a.z *= other.z;
+}
+
+inline double3 operator*(const double3 &a, const double3 &b)
+{
+ return {a.x * b.x, a.y * b.y, a.z * b.z};
+}
+
+inline double3 operator*(const double3 &a, const double &b)
+{
+ return {a.x * b, a.y * b, a.z * b};
+}
+
+inline double3 operator*(const double &a, const double3 &b)
+{
+ return b * a;
+}
+
+inline double3 operator/(const double3 &a, const double &b)
+{
+ BLI_assert(b != 0.0);
+ return {a.x / b, a.y / b, a.z / b};
+}
+
+inline bool operator==(const double3 &a, const double3 &b)
+{
+ return a.x == b.x && a.y == b.y && a.z == b.z;
+}
+
+inline bool operator!=(const double3 &a, const double3 &b)
+{
+ return a.x != b.x || a.y != b.y || a.z != b.z;
+}
+
+inline std::ostream &operator<<(std::ostream &stream, const double3 &v)
+{
+ stream << "(" << v.x << ", " << v.y << ", " << v.z << ")";
+ return stream;
+}
+
+inline double dot(const double3 &a, const double3 &b)
+{
+ return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+
+inline double3 cross_high_precision(const double3 &a, const double3 &b)
+{
+ double3 result;
+ cross_v3_v3v3_db(result, a, b);
+ return result;
+}
+
+inline double3 project(const double3 &a, const double3 &b)
+{
+ double3 result;
+ project_v3_v3v3_db(result, a, b);
+ return result;
+}
+
+inline double distance(const double3 &a, const double3 &b)
+{
+ return length(a - b);
+}
+
+inline double distance_squared(const double3 &a, const double3 &b)
+{
- return dot(a, b);
++ const double3 diff = a - b;
++ return dot(diff, diff);
+}
+
+inline double3 lerp(const double3 &a, const double3 &b, double t)
+{
+ return a * (1 - t) + b * t;
+}
+
+inline double3 abs(const double3 &a)
+{
+ return double3(fabs(a.x), fabs(a.y), fabs(a.z));
+}
+
+inline int dominant_axis(const double3 &a)
+{
+ double x = (a.x >= 0) ? a.x : -a.x;
+ double y = (a.y >= 0) ? a.y : -a.y;
+ double z = (a.z >= 0) ? a.z : -a.z;
+ return ((x > y) ? ((x > z) ? 0 : 2) : ((y > z) ? 1 : 2));
+}
+
+} // namespace blender::math
+
+namespace blender {
+using math::double3;
+}
diff --cc source/blender/blenlib/BLI_float2.hh
index 40cbc272102,2a5320e4c35..77173aaa0d2
--- a/source/blender/blenlib/BLI_float2.hh
+++ b/source/blender/blenlib/BLI_float2.hh
@@@ -69,110 -160,16 +69,111 @@@ struct float2
const float2 &v2,
const float2 &v3,
const float2 &v4);
-
- friend bool operator==(const float2 &a, const float2 &b)
- {
- return a.x == b.x && a.y == b.y;
- }
-
- friend bool operator!=(const float2 &a, const float2 &b)
- {
- return !(a == b);
- }
};
-} // namespace blender
+inline bool operator==(const float2 &a, const float2 &b)
+{
+ return a.x == b.x && a.y == b.y;
+}
+
+inline bool operator!=(const float2 &a, const float2 &b)
+{
+ return !(a == b);
+}
+
+inline float2 &operator+=(float2 &a, const float2 &other)
+{
+ a.x += other.x;
+ a.y += other.y;
+ return a;
+}
+
+inline float2 &operator-=(float2 &a, const float2 &other)
+{
+ a.x -= other.x;
+ a.y -= other.y;
+ return a;
+}
+
+inline float2 &operator*=(float2 &a, float factor)
+{
+ a.x *= factor;
+ a.y *= factor;
+ return a;
+}
+
+inline float2 &operator/=(float2 &a, float divisor)
+{
+ a.x /= divisor;
+ a.y /= divisor;
+ return a;
+}
+
+inline float2 operator+(const float2 &a, const float2 &b)
+{
+ return {a.x + b.x, a.y + b.y};
+}
+
+inline float2 operator-(const float2 &a, const float2 &b)
+{
+ return {a.x - b.x, a.y - b.y};
+}
+
+inline float2 operator*(const float2 &a, float b)
+{
+ return {a.x * b, a.y * b};
+}
+
+inline float2 operator/(const float2 &a, float b)
+{
+ BLI_assert(b != 0.0f);
+ return {a.x / b, a.y / b};
+}
+
+inline float2 operator*(float a, const float2 &b)
+{
+ return b * a;
+}
+
+inline std::ostream &operator<<(std::ostream &stream, const float2 &v)
+{
+ stream << "(" << v.x << ", " << v.y << ")";
+ return stream;
+}
+
+inline float length(const float2 &a)
+{
+ return len_v2(a);
+}
+
+inline float dot(const float2 &a, const float2 &b)
+{
+ return a.x * b.x + a.y * b.y;
+}
+
+inline float2 lerp(const float2 &a, const float2 &b, float t)
+{
+ return a * (1 - t) + b * t;
+}
+
+inline float2 abs(const float2 &a)
+{
+ return float2(fabsf(a.x), fabsf(a.y));
+}
+
+inline float distance(const float2 &a, const float2 &b)
+{
+ return length(a - b);
+}
+
+inline float distance_squared(const float2 &a, const float2 &b)
+{
- return dot(a, b);
++ const float2 diff = a - b;
++ return dot(diff, diff);
+}
+
+} // namespace blender::math
+
+namespace blender {
+using math::float2;
+}
diff --cc source/blender/blenlib/BLI_float3.hh
index dcbc462cab4,9a8870963bf..2f78be2bc35
--- a/source/blender/blenlib/BLI_float3.hh
+++ b/source/blender/blenlib/BLI_float3.hh
@@@ -64,188 -209,46 +64,189 @@@ struct float3
uint64_t x3 = *reinterpret_cast<const uint32_t *>(&z);
return (x1 * 435109) ^ (x2 * 380867) ^ (x3 * 1059217);
}
-
- static float dot(const float3 &a, const float3 &b)
- {
- return a.x * b.x + a.y * b.y + a.z * b.z;
- }
-
- static float3 cross_high_precision(const float3 &a, const float3 &b)
- {
- float3 result;
- cross_v3_v3v3_hi_prec(result, a, b);
- return result;
- }
-
- static float3 project(const float3 &a, const float3 &b)
- {
- float3 result;
- project_v3_v3v3(result, a, b);
- return result;
- }
-
- static float distance(const float3 &a, const float3 &b)
- {
- return (a - b).length();
- }
-
- static float distance_squared(const float3 &a, const float3 &b)
- {
- float3 diff = a - b;
- return float3::dot(diff, diff);
- }
-
- static float3 interpolate(const float3 &a, const float3 &b, float t)
- {
- return a * (1 - t) + b * t;
- }
-
- static float3 abs(const float3 &a)
- {
- return float3(fabsf(a.x), fabsf(a.y), fabsf(a.z));
- }
};
-} // namespace blender
+inline float3 operator+(const float3 &a, const float3 &b)
+{
+ return {a.x + b.x, a.y + b.y, a.z + b.z};
+}
+
+inline float3 &operator+=(float3 &a, const float3 &b)
+{
+ a.x += b.x;
+ a.y += b.y;
+ a.z += b.z;
+ return a;
+}
+
+inline float3 operator-(const float3 &a, const float3 &b)
+{
+ return {a.x - b.x, a.y - b.y, a.z - b.z};
+}
+
+inline float3 &operator-=(float3 &a, const float3 &b)
+{
+ a.x -= b.x;
+ a.y -= b.y;
+ a.z -= b.z;
+ return a;
+}
+
+inline float3 &operator*=(float3 &a, float scalar)
+{
+ a.x *= scalar;
+ a.y *= scalar;
+ a.z *= scalar;
+ return a;
+}
+
+inline float3 &operator*=(float3 &a, const float3 &other)
+{
+ a.x *= other.x;
+ a.y *= other.y;
+ a.z *= other.z;
+ return a;
+}
+
+inline float3 operator*(const float3 &a, const float3 &b)
+{
+ return {a.x * b.x, a.y * b.y, a.z * b.z};
+}
+
+inline float3 operator/(const float3 &a, float b)
+{
+ BLI_assert(b != 0.0f);
+ return {a.x / b, a.y / b, a.z / b};
+}
+
+inline std::ostream &operator<<(std::ostream &stream, const float3 &v)
+{
+ stream << "(" << v.x << ", " << v.y << ", " << v.z << ")";
+ return stream;
+}
+
+inline float3 operator-(const float3 &a)
+{
+ return {-a.x, -a.y, -a.z};
+}
+
+inline bool operator==(const float3 &a, const float3 &b)
+{
+ return a.x == b.x && a.y == b.y && a.z == b.z;
+}
+
+inline bool operator!=(const float3 &a, const float3 &b)
+{
+ return !(a == b);
+}
+
+inline float3 operator*(const float3 &a, float b)
+{
+ return {a.x * b, a.y * b, a.z * b};
+}
+
+inline float3 operator*(float a, const float3 &b)
+{
+ return b * a;
+}
+
+inline float normalize_and_get_length(float3 &a)
+{
+ return normalize_v3(a);
+}
+
+inline void normalize(float3 &a)
+{
+ normalize_v3(a);
+}
+
+inline float3 normalized(const float3 &a)
+{
+ float3 result;
+ normalize_v3_v3(result, a);
+ return result;
+}
+
+inline float length(const float3 &a)
+{
+ return len_v3(a);
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list