diff options
| author | Clément Foucault <foucault.clem@gmail.com> | 2022-01-12 14:57:07 +0300 |
|---|---|---|
| committer | Clément Foucault <foucault.clem@gmail.com> | 2022-01-12 14:57:07 +0300 |
| commit | d43b5791e0c1f6581a539c2663ec8200e107740a (patch) | |
| tree | 422c3f78cae6ca3560d8ebbbbd243235b5ea067f | |
| parent | fb6bd8864411ee27db05ceadcb80f690f44e48dd (diff) | |
BLI: Refactor vector types & functions to use templates
This patch implements the vector types (i.e:`float2`) by making heavy
usage of templating. All vector functions are now outside of the vector
classes (inside the `blender::math` namespace) and are not vector size
dependent for the most part.
In the ongoing effort to make shaders less GL centric, we are aiming
to share more code between GLSL and C++ to avoid code duplication.
####Motivations:
- We are aiming to share UBO and SSBO structures between GLSL and C++.
This means we will use many of the existing vector types and others
we currently don't have (uintX, intX). All these variations were
asking for many more code duplication.
- Deduplicate existing code which is duplicated for each vector size.
- We also want to share small functions. Which means that vector
functions should be static and not in the class namespace.
- Reduce friction to use these types in new projects due to their
incompleteness.
- The current state of the `BLI_(float|double|mpq)(2|3|4).hh` is a
bit of a let down. Most clases are incomplete, out of sync with each
others with different codestyles, and some functions that should be
static are not (i.e: `float3::reflect()`).
####Upsides:
- Still support `.x, .y, .z, .w` for readability.
- Compact, readable and easilly extendable.
- All of the vector functions are available for all the vectors types
and can be restricted to certain types. Also template specialization
let us define exception for special class (like mpq).
- With optimization ON, the compiler unroll the loops and performance
is the same.
####Downsides:
- Might impact debugability. Though I would arge that the bugs are
rarelly caused by the vector class itself (since the operations are
quite trivial) but by the type conversions.
- Might impact compile time. I did not saw a significant impact since
the usage is not really widespread.
- Functions needs to be rewritten to support arbitrary vector length.
For instance, one can't call `len_squared_v3v3` in
`math::length_squared()` and call it a day.
- Type cast does not work with the template version of the `math::`
vector functions. Meaning you need to manually cast `float *` and
`(float *)[3]` to `float3` for the function calls.
i.e: `math::distance_squared(float3(nearest.co), positions[i]);`
- Some parts might loose in readability:
`float3::dot(v1.normalized(), v2.normalized())`
becoming
`math::dot(math::normalize(v1), math::normalize(v2))`
But I propose, when appropriate, to use
`using namespace blender::math;` on function local or file scope to
increase readability.
`dot(normalize(v1), normalize(v2))`
####Consideration:
- Include back `.length()` method. It is quite handy and is more C++
oriented.
- I considered the GLM library as a candidate for replacement. It felt
like too much for what we need and would be difficult to extend / modify
to our needs.
- I used Macros to reduce code in operators declaration and potential
copy paste bugs. This could reduce debugability and could be reverted.
- This touches `delaunay_2d.cc` and the intersection code. I would like
to know @howardt opinion on the matter.
- The `noexcept` on the copy constructor of `mpq(2|3)` is being removed.
But according to @JacquesLucke it is not a real problem for now.
I would like to give a huge thanks to @JacquesLucke who helped during this
and pushed me to reduce the duplication further.
Reviewed By: brecht, sergey, JacquesLucke
Differential Revision: https://developer.blender.org/D13791
107 files changed, 1645 insertions, 2074 deletions
diff --git a/source/blender/blenkernel/BKE_attribute_access.hh b/source/blender/blenkernel/BKE_attribute_access.hh index f69ba79e23f..3ffdcee05eb 100644 --- a/source/blender/blenkernel/BKE_attribute_access.hh +++ b/source/blender/blenkernel/BKE_attribute_access.hh @@ -26,9 +26,8 @@ #include "BKE_attribute.h" #include "BLI_color.hh" -#include "BLI_float2.hh" -#include "BLI_float3.hh" #include "BLI_function_ref.hh" +#include "BLI_math_vec_types.hh" /** * This file defines classes that help to provide access to attribute data on a #GeometryComponent. diff --git a/source/blender/blenkernel/BKE_attribute_math.hh b/source/blender/blenkernel/BKE_attribute_math.hh index 802c744972c..a7bdca06790 100644 --- a/source/blender/blenkernel/BKE_attribute_math.hh +++ b/source/blender/blenkernel/BKE_attribute_math.hh @@ -18,8 +18,7 @@ #include "BLI_array.hh" #include "BLI_color.hh" -#include "BLI_float2.hh" -#include "BLI_float3.hh" +#include "BLI_math_vec_types.hh" #include "DNA_customdata_types.h" @@ -160,12 +159,12 @@ template<> inline float mix2(const float factor, const float &a, const float &b) template<> inline float2 mix2(const float factor, const float2 &a, const float2 &b) { - return float2::interpolate(a, b, factor); + return math::interpolate(a, b, factor); } template<> inline float3 mix2(const float factor, const float3 &a, const float3 &b) { - return float3::interpolate(a, b, factor); + return math::interpolate(a, b, factor); } template<> diff --git a/source/blender/blenkernel/BKE_geometry_set.hh b/source/blender/blenkernel/BKE_geometry_set.hh index acb89637f20..f92f33b2776 100644 --- a/source/blender/blenkernel/BKE_geometry_set.hh +++ b/source/blender/blenkernel/BKE_geometry_set.hh @@ -23,11 +23,11 @@ #include <atomic> #include <iostream> -#include "BLI_float3.hh" #include "BLI_float4x4.hh" #include "BLI_function_ref.hh" #include "BLI_hash.hh" #include "BLI_map.hh" +#include "BLI_math_vec_types.hh" #include "BLI_set.hh" #include "BLI_user_counter.hh" #include "BLI_vector_set.hh" diff --git a/source/blender/blenkernel/BKE_mesh_sample.hh b/source/blender/blenkernel/BKE_mesh_sample.hh index 238b6f4dcae..738b768d906 100644 --- a/source/blender/blenkernel/BKE_mesh_sample.hh +++ b/source/blender/blenkernel/BKE_mesh_sample.hh @@ -22,7 +22,7 @@ #include "FN_generic_virtual_array.hh" -#include "BLI_float3.hh" +#include "BLI_math_vec_types.hh" #include "BKE_attribute.h" diff --git a/source/blender/blenkernel/BKE_spline.hh b/source/blender/blenkernel/BKE_spline.hh index 2c14880978f..a87f76da8da 100644 --- a/source/blender/blenkernel/BKE_spline.hh +++ b/source/blender/blenkernel/BKE_spline.hh @@ -24,8 +24,8 @@ #include "FN_generic_virtual_array.hh" -#include "BLI_float3.hh" #include "BLI_float4x4.hh" +#include "BLI_math_vec_types.hh" #include "BLI_vector.hh" #include "BKE_attribute_access.hh" diff --git a/source/blender/blenkernel/BKE_volume.h b/source/blender/blenkernel/BKE_volume.h index 2b551a76d73..b40facc3572 100644 --- a/source/blender/blenkernel/BKE_volume.h +++ b/source/blender/blenkernel/BKE_volume.h @@ -163,8 +163,8 @@ bool BKE_volume_save(const struct Volume *volume, * file or copy shared grids to make them writeable. */ #ifdef __cplusplus -# include "BLI_float3.hh" # include "BLI_float4x4.hh" +# include "BLI_math_vec_types.hh" # include "BLI_string_ref.hh" bool BKE_volume_min_max(const Volume *volume, blender::float3 &r_min, blender::float3 &r_max); diff --git a/source/blender/blenkernel/intern/DerivedMesh.cc b/source/blender/blenkernel/intern/DerivedMesh.cc index 4bfd71ba932..73785e2ee2b 100644 --- a/source/blender/blenkernel/intern/DerivedMesh.cc +++ b/source/blender/blenkernel/intern/DerivedMesh.cc @@ -38,9 +38,9 @@ #include "BLI_array.h" #include "BLI_bitmap.h" #include "BLI_blenlib.h" -#include "BLI_float2.hh" #include "BLI_linklist.h" #include "BLI_math.h" +#include "BLI_math_vec_types.hh" #include "BLI_task.h" #include "BLI_task.hh" #include "BLI_utildefines.h" diff --git a/source/blender/blenkernel/intern/attribute_access.cc b/source/blender/blenkernel/intern/attribute_access.cc index 1a4265d936b..cc43a3e26a8 100644 --- a/source/blender/blenkernel/intern/attribute_access.cc +++ b/source/blender/blenkernel/intern/attribute_access.cc @@ -30,7 +30,7 @@ #include "DNA_pointcloud_types.h" #include "BLI_color.hh" -#include "BLI_float2.hh" +#include "BLI_math_vec_types.hh" #include "BLI_span.hh" #include "BLT_translation.h" diff --git a/source/blender/blenkernel/intern/geometry_component_mesh.cc b/source/blender/blenkernel/intern/geometry_component_mesh.cc index 2b4238d26bb..88a58220b23 100644 --- a/source/blender/blenkernel/intern/geometry_component_mesh.cc +++ b/source/blender/blenkernel/intern/geometry_component_mesh.cc @@ -217,9 +217,8 @@ VArray<float3> mesh_normals_varray(const MeshComponent &mesh_component, * calculating unnecessary values and to allow normalizing the result much more simply. */ for (const int i : mask) { const MEdge &edge = edges[i]; - edge_normals[i] = float3::interpolate( - vert_normals_span[edge.v1], vert_normals_span[edge.v2], 0.5f) - .normalized(); + edge_normals[i] = math::normalize( + math::interpolate(vert_normals_span[edge.v1], vert_normals_span[edge.v2], 0.5f)); } return VArray<float3>::ForContainer(std::move(edge_normals)); diff --git a/source/blender/blenkernel/intern/gpencil_geom.cc b/source/blender/blenkernel/intern/gpencil_geom.cc index f8681647a77..116d77f1a2a 100644 --- a/source/blender/blenkernel/intern/gpencil_geom.cc +++ b/source/blender/blenkernel/intern/gpencil_geom.cc @@ -33,10 +33,10 @@ #include "BLI_array_utils.h" #include "BLI_blenlib.h" -#include "BLI_float3.hh" #include "BLI_ghash.h" #include "BLI_hash.h" #include "BLI_heap.h" +#include "BLI_math_vec_types.hh" #include "BLI_math_vector.h" #include "BLI_polyfill_2d.h" #include "BLI_span.hh" diff --git a/source/blender/blenkernel/intern/hair.cc b/source/blender/blenkernel/intern/hair.cc index c5b154c9a4b..b7ba159f631 100644 --- a/source/blender/blenkernel/intern/hair.cc +++ b/source/blender/blenkernel/intern/hair.cc @@ -28,9 +28,9 @@ #include "DNA_material_types.h" #include "DNA_object_types.h" -#include "BLI_float3.hh" #include "BLI_listbase.h" #include "BLI_math_base.h" +#include "BLI_math_vec_types.hh" #include "BLI_rand.h" #include "BLI_string.h" #include "BLI_utildefines.h" diff --git a/source/blender/blenkernel/intern/mesh.cc b/source/blender/blenkernel/intern/mesh.cc index 12c63ab0523..8ceaced1972 100644 --- a/source/blender/blenkernel/intern/mesh.cc +++ b/source/blender/blenkernel/intern/mesh.cc @@ -36,13 +36,13 @@ #include "BLI_bitmap.h" #include "BLI_edgehash.h" #include "BLI_endian_switch.h" -#include "BLI_float3.hh" #include "BLI_ghash.h" #include "BLI_hash.h" #include "BLI_index_range.hh" #include "BLI_linklist.h" #include "BLI_listbase.h" #include "BLI_math.h" +#include "BLI_math_vec_types.hh" #include "BLI_memarena.h" #include "BLI_string.h" #include "BLI_task.hh" @@ -1597,16 +1597,16 @@ bool BKE_mesh_minmax(const Mesh *me, float r_min[3], float r_max[3]) [&](IndexRange range, const Result &init) { Result result = init; for (const int i : range) { - float3::min_max(me->mvert[i].co, result.min, result.max); + math::min_max(float3(me->mvert[i].co), result.min, result.max); } return result; }, [](const Result &a, const Result &b) { - return Result{float3::min(a.min, b.min), float3::max(a.max, b.max)}; + return Result{math::min(a.min, b.min), math::max(a.max, b.max)}; }); - copy_v3_v3(r_min, float3::min(minmax.min, r_min)); - copy_v3_v3(r_max, float3::max(minmax.max, r_max)); + copy_v3_v3(r_min, math::min(minmax.min, float3(r_min))); + copy_v3_v3(r_max, math::max(minmax.max, float3(r_max))); return true; } diff --git a/source/blender/blenkernel/intern/mesh_boolean_convert.cc b/source/blender/blenkernel/intern/mesh_boolean_convert.cc index 771d79a0445..a4a5fe2be2e 100644 --- a/source/blender/blenkernel/intern/mesh_boolean_convert.cc +++ b/source/blender/blenkernel/intern/mesh_boolean_convert.cc @@ -32,9 +32,9 @@ #include "BLI_alloca.h" #include "BLI_array.hh" -#include "BLI_float2.hh" #include "BLI_float4x4.hh" #include "BLI_math.h" +#include "BLI_math_vec_types.hh" #include "BLI_mesh_boolean.hh" #include "BLI_mesh_intersect.hh" #include "BLI_span.hh" diff --git a/source/blender/blenkernel/intern/mesh_remesh_voxel.cc b/source/blender/blenkernel/intern/mesh_remesh_voxel.cc index 3447185089d..50464da86e9 100644 --- a/source/blender/blenkernel/intern/mesh_remesh_voxel.cc +++ b/source/blender/blenkernel/intern/mesh_remesh_voxel.cc @@ -31,8 +31,8 @@ #include "MEM_guardedalloc.h" #include "BLI_array.hh" -#include "BLI_float3.hh" #include "BLI_index_range.hh" +#include "BLI_math_vec_types.hh" #include "BLI_span.hh" #include "DNA_mesh_types.h" diff --git a/source/blender/blenkernel/intern/object_dupli.cc b/source/blender/blenkernel/intern/object_dupli.cc index e682486390c..20fdda8bdc7 100644 --- a/source/blender/blenkernel/intern/object_dupli.cc +++ b/source/blender/blenkernel/intern/object_dupli.cc @@ -31,9 +31,9 @@ #include "BLI_string_utf8.h" #include "BLI_array.hh" -#include "BLI_float3.hh" #include "BLI_float4x4.hh" #include "BLI_math.h" +#include "BLI_math_vec_types.hh" #include "BLI_rand.h" #include "BLI_span.hh" #include "BLI_vector.hh" @@ -1026,6 +1026,8 @@ static void get_dupliface_transform_from_coords(Span<float3> coords, const float scale_fac, float r_mat[4][4]) { + using namespace blender::math; + /* Location. */ float3 location(0); for (const float3 &coord : coords) { @@ -1036,9 +1038,7 @@ static void get_dupliface_transform_from_coords(Span<float3> coords, /* Rotation. */ float quat[4]; - float3 f_no; - cross_poly_v3(f_no, (const float(*)[3])coords.data(), (uint)coords.size()); - f_no.normalize(); + float3 f_no = normalize(cross_poly(coords)); tri_to_quat_ex(quat, coords[0], coords[1], coords[2], f_no); /* Scale. */ diff --git a/source/blender/blenkernel/intern/pointcloud.cc b/source/blender/blenkernel/intern/pointcloud.cc index a041e04bf71..b5f016e4d76 100644 --- a/source/blender/blenkernel/intern/pointcloud.cc +++ b/source/blender/blenkernel/intern/pointcloud.cc @@ -25,9 +25,9 @@ #include "DNA_object_types.h" #include "DNA_pointcloud_types.h" -#include "BLI_float3.hh" #include "BLI_index_range.hh" #include "BLI_listbase.h" +#include "BLI_math_vec_types.hh" #include "BLI_rand.h" #include "BLI_span.hh" #include "BLI_string.h" @@ -275,6 +275,8 @@ struct MinMaxResult { static MinMaxResult min_max_no_radii(Span<float3> positions) { + using namespace blender::math; + return blender::threading::parallel_reduce( positions.index_range(), 1024, @@ -282,17 +284,19 @@ static MinMaxResult min_max_no_radii(Span<float3> positions) [&](IndexRange range, const MinMaxResult &init) { MinMaxResult result = init; for (const int i : range) { - float3::min_max(positions[i], result.min, result.max); + min_max(positions[i], result.min, result.max); } return result; }, [](const MinMaxResult &a, const MinMaxResult &b) { - return MinMaxResult{float3::min(a.min, b.min), float3::max(a.max, b.max)}; + return MinMaxResult{min(a.min, b.min), max(a.max, b.max)}; }); } static MinMaxResult min_max_with_radii(Span<float3> positions, Span<float> radii) { + using namespace blender::math; + return blender::threading::parallel_reduce( positions.index_range(), 1024, @@ -300,18 +304,20 @@ static MinMaxResult min_max_with_radii(Span<float3> positions, Span<float> radii [&](IndexRange range, const MinMaxResult &init) { MinMaxResult result = init; for (const int i : range) { - result.min = float3::min(positions[i] - radii[i], result.min); - result.max = float3::max(positions[i] + radii[i], result.max); + result.min = min(positions[i] - radii[i], result.min); + result.max = max(positions[i] + radii[i], result.max); } return result; }, [](const MinMaxResult &a, const MinMaxResult &b) { - return MinMaxResult{float3::min(a.min, b.min), float3::max(a.max, b.max)}; + return MinMaxResult{min(a.min, b.min), max(a.max, b.max)}; }); } bool BKE_pointcloud_minmax(const PointCloud *pointcloud, float r_min[3], float r_max[3]) { + using namespace blender::math; + if (!pointcloud->totpoint) { return false; } @@ -322,8 +328,8 @@ bool BKE_pointcloud_minmax(const PointCloud *pointcloud, float r_min[3], float r {pointcloud->radius, pointcloud->totpoint}) : min_max_no_radii(positions); - copy_v3_v3(r_min, float3::min(min_max.min, r_min)); - copy_v3_v3(r_max, float3::max(min_max.max, r_max)); + copy_v3_v3(r_min, min(min_max.min, float3(r_min))); + copy_v3_v3(r_max, max(min_max.max, float3(r_max))); return true; } @@ -340,7 +346,7 @@ BoundBox *BKE_pointcloud_boundbox_get(Object *ob) ob->runtime.bb = static_cast<BoundBox *>(MEM_callocN(sizeof(BoundBox), "pointcloud boundbox")); } - blender::float3 min, max; + float3 min, max; INIT_MINMAX(min, max); if (ob->runtime.geometry_set_eval != nullptr) { ob->runtime.geometry_set_eval->compute_boundbox_without_instances(&min, &max); diff --git a/source/blender/blenkernel/intern/simulation.cc b/source/blender/blenkernel/intern/simulation.cc index b0f9de5963a..ec4b0e8d51d 100644 --- a/source/blender/blenkernel/intern/simulation.cc +++ b/source/blender/blenkernel/intern/simulation.cc @@ -28,9 +28,9 @@ #include "DNA_simulation_types.h" #include "BLI_compiler_compat.h" -#include "BLI_float3.hh" #include "BLI_listbase.h" #include "BLI_math.h" +#include "BLI_math_vec_types.hh" #include "BLI_rand.h" #include "BLI_span.hh" #include "BLI_string.h" diff --git a/source/blender/blenkernel/intern/spline_base.cc b/source/blender/blenkernel/intern/spline_base.cc index 857022345f3..3262d768b6c 100644 --- a/source/blender/blenkernel/intern/spline_base.cc +++ b/source/blender/blenkernel/intern/spline_base.cc @@ -166,13 +166,15 @@ static void accumulate_lengths(Span<float3> positions, const bool is_cyclic, MutableSpan<float> lengths) { + using namespace blender::math; + float length = 0.0f; for (const int i : IndexRange(positions.size() - 1)) { - length += float3::distance(positions[i], positions[i + 1]); + length += distance(positions[i], positions[i + 1]); lengths[i] = length; } if (is_cyclic) { - lengths.last() = length + float3::distance(positions.last(), positions.first()); + lengths.last() = length + distance(positions.last(), positions.first()); } } @@ -200,11 +202,13 @@ Span<float> Spline::evaluated_lengths() const static float3 direction_bisect(const float3 &prev, const float3 &middle, const float3 &next) { - const float3 dir_prev = (middle - prev).normalized(); - const float3 dir_next = (next - middle).normalized(); + using namespace blender::math; + + const float3 dir_prev = normalize(middle - prev); + const float3 dir_next = normalize(next - middle); - const float3 result = (dir_prev + dir_next).normalized(); - if (UNLIKELY(result.is_zero())) { + const float3 result = normalize(dir_prev + dir_next); + if (UNLIKELY(is_zero(result))) { return float3(0.0f, 0.0f, 1.0f); } return result; @@ -214,6 +218,8 @@ static void calculate_tangents(Span<float3> positions, const bool is_cyclic, MutableSpan<float3> tangents) { + using namespace blender::math; + if (positions.size() == 1) { tangents.first() = float3(0.0f, 0.0f, 1.0f); return; @@ -232,8 +238,8 @@ static void calculate_tangents(Span<float3> positions, tangents.last() = direction_bisect(second_to_last, last, first); } else { - tangents.first() = (positions[1] - positions[0]).normalized(); - tangents.last() = (positions.last() - positions[positions.size() - 2]).normalized(); + tangents.first() = normalize(positions[1] - positions[0]); + tangents.last() = normalize(positions.last() - positions[positions.size() - 2]); } } @@ -264,18 +270,22 @@ static float3 rotate_direction_around_axis(const float3 &direction, const float3 &axis, const float angle) { + using namespace blender::math; + BLI_ASSERT_UNIT_V3(direction); BLI_ASSERT_UNIT_V3(axis); - const float3 axis_scaled = axis * float3::dot(direction, axis); + const float3 axis_scaled = axis * dot(direction, axis); const float3 diff = direction - axis_scaled; - const float3 cross = float3::cross(axis, diff); + const float3 cross = blender::math::cross(axis, diff); return axis_scaled + diff * std::cos(angle) + cross * std::sin(angle); } static void calculate_normals_z_up(Span<float3> tangents, MutableSpan<float3> r_normals) { + using namespace blender::math; + BLI_assert(r_normals.size() == tangents.size()); /* Same as in `vec_to_quat`. */ @@ -286,7 +296,7 @@ static void calculate_normals_z_up(Span<float3> tangents, MutableSpan<float3> r_ r_normals[i] = {1.0f, 0.0f, 0.0f}; } else { - r_normals[i] = float3(tangent.y, -tangent.x, 0.0f).normalized(); + r_normals[i] = normalize(float3(tangent.y, -tangent.x, 0.0f)); } } } @@ -298,12 +308,14 @@ static float3 calculate_next_normal(const float3 &last_normal, const float3 &last_tangent, const float3 ¤t_tangent) { - if (last_tangent.is_zero() || current_tangent.is_zero()) { + using namespace blender::math; + + if (is_zero(last_tangent) || is_zero(current_tangent)) { return last_normal; } const float angle = angle_normalized_v3v3(last_tangent, current_tangent); if (angle != 0.0) { - const float3 axis = float3::cross(last_tangent, current_tangent).normalized(); + const float3 axis = normalize(cross(last_tangent, current_tangent)); return rotate_direction_around_axis(last_normal, axis, angle); } return last_normal; @@ -313,6 +325,7 @@ static void calculate_normals_minimum(Span<float3> tangents, const bool cyclic, MutableSpan<float3> r_normals) { + using namespace blender::math; BLI_assert(r_normals.size() == tangents.size()); if (r_normals.is_empty()) { @@ -327,7 +340,7 @@ static void calculate_normals_minimum(Span<float3> tangents, r_normals[0] = {1.0f, 0.0f, 0.0f}; } else { - r_normals[0] = float3(first_tangent.y, -first_tangent.x, 0.0f).normalized(); + r_normals[0] = normalize(float3(first_tangent.y, -first_tangent.x, 0.0f)); } /* Forward normal with minimum twist along the entire spline. */ diff --git a/source/blender/blenkernel/intern/spline_bezier.cc b/source/blender/blenkernel/intern/spline_bezier.cc index b24c8960857..980437014b1 100644 --- a/source/blender/blenkernel/intern/spline_bezier.cc +++ b/source/blender/blenkernel/intern/spline_bezier.cc @@ -199,11 +199,13 @@ void BezierSpline::ensure_auto_handles() const } for (const int i : IndexRange(this->size())) { + using namespace blender; + if (ELEM(HandleType::Auto, handle_types_left_[i], handle_types_right_[i])) { const float3 prev_diff = positions_[i] - previous_position(positions_, is_cyclic_, i); const float3 next_diff = next_position(positions_, is_cyclic_, i) - positions_[i]; - float prev_len = prev_diff.length(); - float next_len = next_diff.length(); + float prev_len = math::length(prev_diff); + float next_len = math::length(next_diff); if (prev_len == 0.0f) { prev_len = 1.0f; } @@ -213,7 +215,7 @@ void BezierSpline::ensure_auto_handles() const const float3 dir = next_diff / next_len + prev_diff / prev_len; /* This magic number is unfortunate, but comes from elsewhere in Blender. */ - const float len = dir.length() * 2.5614f; + const float len = math::length(dir) * 2.5614f; if (len != 0.0f) { if (handle_types_left_[i] == HandleType::Auto) { const float prev_len_clamped = std::min(prev_len, next_len * 5.0f); @@ -228,12 +230,12 @@ void BezierSpline::ensure_auto_handles() const if (handle_types_left_[i] == HandleType::Vector) { const float3 prev = previous_position(positions_, is_cyclic_, i); - handle_positions_left_[i] = float3::interpolate(positions_[i], prev, 1.0f / 3.0f); + handle_positions_left_[i] = math::interpolate(positions_[i], prev, 1.0f / 3.0f); } if (handle_types_right_[i] == HandleType::Vector) { const float3 next = next_position(positions_, is_cyclic_, i); - handle_positions_right_[i] = float3::interpolate(positions_[i], next, 1.0f / 3.0f); + handle_positions_right_[i] = math::interpolate(positions_[i], next, 1.0f / 3.0f); } } @@ -275,6 +277,8 @@ static void set_handle_position(const float3 &position, float3 &handle, float3 &handle_other) { + using namespace blender::math; + /* Don't bother when the handle positions are calculated automatically anyway. */ if (ELEM(type, BezierSpline::HandleType::Auto, BezierSpline::HandleType::Vector)) { return; @@ -283,9 +287,9 @@ static void set_handle_position(const float3 &position, handle = new_value; if (type_other == BezierSpline::HandleType::Align) { /* Keep track of the old length of the opposite handle. */ - const float length = float3::distance(handle_other, position); + const float length = distance(handle_other, position); /* Set the other handle to directly opposite from the current handle. */ - const float3 dir = (handle - position).normalized(); + const float3 dir = normalize(handle - position); handle_other = position - dir * length; } } @@ -353,6 +357,7 @@ int BezierSpline::evaluated_points_size() const void BezierSpline::correct_end_tangents() const { + using namespace blender::math; if (is_cyclic_) { return; } @@ -360,10 +365,10 @@ void BezierSpline::correct_end_tangents() const MutableSpan<float3> tangents(evaluated_tangents_cache_); if (handle_positions_right_.first() != positions_.first()) { - tangents.first() = (handle_positions_right_.first() - positions_.first()).normalized(); + tangents.first() = normalize(handle_positions_right_.first() - positions_.first()); } if (handle_positions_left_.last() != positions_.last()) { - tangents.last() = (positions_.last() - handle_positions_left_.last()).normalized(); + tangents.last() = normalize(positions_.last() - handle_positions_left_.last()); } } @@ -371,20 +376,22 @@ BezierSpline::InsertResult BezierSpline::calculate_segment_insertion(const int i const int next_index, const float parameter) { + using namespace blender::math; + BLI_assert(parameter <= 1.0f && parameter >= 0.0f); BLI_assert(next_index == 0 || next_index == index + 1); const float3 &point_prev = positions_[index]; const float3 &handle_prev = handle_positions_right_[index]; const float3 &handle_next = handle_positions_left_[next_index]; const float3 &point_next = positions_[next_index]; - const float3 center_point = float3::interpolate(handle_prev, handle_next, parameter); + const float3 center_point = interpolate(handle_prev, handle_next, parameter); BezierSpline::InsertResult result; - result.handle_prev = float3::interpolate(point_prev, handle_prev, parameter); - result.handle_next = float3::interpolate(handle_next, point_next, parameter); - result.left_handle = float3::interpolate(result.handle_prev, center_point, parameter); - result.right_handle = float3::interpolate(center_point, result.handle_next, parameter); - result.position = float3::interpolate(result.left_handle, result.right_handle, parameter); + result.handle_prev = interpolate(point_prev, handle_prev, parameter); + result.handle_next = interpolate(handle_next, point_next, parameter); + result.left_handle = interpolate(result.handle_prev, center_point, parameter); + result.right_handle = interpolate(center_point, result.handle_next, parameter); + result.position = interpolate(result.left_handle, result.right_handle, parameter); return result; } diff --git a/source/blender/blenkernel/intern/tracking_test.cc b/source/blender/blenkernel/intern/tracking_test.cc index a3845dcad8f..d85d71b7c86 100644 --- a/source/blender/blenkernel/intern/tracking_test.cc +++ b/source/blender/blenkernel/intern/tracking_test.cc @@ -5,7 +5,7 @@ #include "DNA_tracking_types.h" #include "BKE_tracking.h" -#include "BLI_float2.hh" +#include "BLI_math_vec_types.hh" namespace blender { diff --git a/source/blender/blenkernel/intern/type_conversions.cc b/source/blender/blenkernel/intern/type_conversions.cc index b23220286e6..cb05337ef2a 100644 --- a/source/blender/blenkernel/intern/type_conversions.cc +++ b/source/blender/blenkernel/intern/type_conversions.cc @@ -19,8 +19,7 @@ #include "FN_multi_function_builder.hh" #include "BLI_color.hh" -#include "BLI_float2.hh" -#include "BLI_float3.hh" +#include "BLI_math_vec_types.hh" namespace blender::bke { diff --git a/source/blender/blenkernel/intern/volume.cc b/source/blender/blenkernel/intern/volume.cc index 4b71c98339b..c17706dc216 100644 --- a/source/blender/blenkernel/intern/volume.cc +++ b/source/blender/blenkernel/intern/volume.cc @@ -28,12 +28,12 @@ #include "BLI_compiler_compat.h" #include "BLI_fileops.h" -#include "BLI_float3.hh" #include "BLI_float4x4.hh" #include "BLI_ghash.h" #include "BLI_index_range.hh" #include "BLI_map.hh" #include "BLI_math.h" +#include "BLI_math_vec_types.hh" #include "BLI_path_util.h" #include "BLI_string.h" #include "BLI_string_ref.hh" diff --git a/source/blender/blenkernel/intern/volume_render.cc b/source/blender/blenkernel/intern/volume_render.cc index 6dc497bb616..c0a205b5673 100644 --- a/source/blender/blenkernel/intern/volume_render.cc +++ b/source/blender/blenkernel/intern/volume_render.cc @@ -21,8 +21,8 @@ #include "MEM_guardedalloc.h" #include "BLI_array.hh" -#include "BLI_float3.hh" #include "BLI_math_matrix.h" +#include "BLI_math_vec_types.hh" #include "BLI_math_vector.h" #include "BLI_vector.hh" diff --git a/source/blender/blenkernel/intern/volume_to_mesh.cc b/source/blender/blenkernel/intern/volume_to_mesh.cc index 6e465b2fdf0..733549c0022 100644 --- a/source/blender/blenkernel/intern/volume_to_mesh.cc +++ b/source/blender/blenkernel/intern/volume_to_mesh.cc @@ -16,7 +16,7 @@ #include <vector> -#include "BLI_float3.hh" +#include "BLI_math_vec_types.hh" #include "BLI_span.hh" #include "BLI_utildefines.h" diff --git a/source/blender/blenlib/BLI_delaunay_2d.h b/source/blender/blenlib/BLI_delaunay_2d.h index db0df95499f..1ee0be64cee 100644 --- a/source/blender/blenlib/BLI_delaunay_2d.h +++ b/source/blender/blenlib/BLI_delaunay_2d.h @@ -215,9 +215,9 @@ void BLI_delaunay_2d_cdt_free(CDT_result *result); /* C++ Interface. */ # include "BLI_array.hh" -# include "BLI_double2.hh" # include "BLI_math_mpq.hh" -# include "BLI_mpq2.hh" +# include "BLI_math_vec_mpq_types.hh" +# include "BLI_math_vec_types.hh" # include "BLI_vector.hh" namespace blender::meshintersect { diff --git a/source/blender/blenlib/BLI_double2.hh b/source/blender/blenlib/BLI_double2.hh deleted file mode 100644 index 0abff01ab2f..00000000000 --- a/source/blender/blenlib/BLI_double2.hh +++ /dev/null @@ -1,143 +0,0 @@ -/* - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ - -#pragma once - -/** \file - * \ingroup bli - */ - -#include "BLI_double3.hh" - -namespace blender { - -struct double2 { - double x, y; - - double2() = default; - - double2(const double *ptr) : x{ptr[0]}, y{ptr[1]} - { - } - - double2(double x, double y) : x(x), y(y) - { - } - - double2(const double3 &other) : x(other.x), y(other.y) - { - } - - operator double *() - { - return &x; - } - - operator const double *() const - { - return &x; - } - - double length() const - { - return len_v2_db(*this); - } - - friend double2 operator+(const double2 &a, const double2 &b) - { - return {a.x + b.x, a.y + b.y}; - } - - friend double2 operator-(const double2 &a, const double2 &b) - { - return {a.x - b.x, a.y - b.y}; - } - - friend double2 operator*(const double2 &a, double b) - { - return {a.x * b, a.y * b}; - } - - friend double2 operator/(const double2 &a, double b) - { - BLI_assert(b != 0.0); - return {a.x / b, a.y / b}; - } - - friend double2 operator*(double a, const double2 &b) - { - return b * a; - } - - friend bool operator==(const double2 &a, const double2 &b) - { - return a.x == b.x && a.y == b.y; - } - - friend bool operator!=(const double2 &a, const double2 &b) - { - return a.x != b.x || a.y != b.y; - } - - friend std::ostream &operator<<(std::ostream &stream, const double2 &v) - { - stream << "(" << v.x << ", " << v.y << ")"; - return stream; - } - - static double dot(const double2 &a, const double2 &b) - { - return a.x * b.x + a.y * b.y; - } - - static double2 interpolate(const double2 &a, const double2 &b, double t) - { - return a * (1 - t) + b * t; - } - - static double2 abs(const double2 &a) - { - return double2(fabs(a.x), fabs(a.y)); - } - - static double distance(const double2 &a, const double2 &b) - { - return (a - b).length(); - } - - static double distance_squared(const double2 &a, const double2 &b) - { - double2 diff = a - b; - return double2::dot(diff, diff); - } - - struct isect_result { - enum { - LINE_LINE_COLINEAR = -1, - LINE_LINE_NONE = 0, - LINE_LINE_EXACT = 1, - LINE_LINE_CROSS = 2, - } kind; - double lambda; - }; - - static isect_result isect_seg_seg(const double2 &v1, - const double2 &v2, - const double2 &v3, - const double2 &v4); -}; - -} // namespace blender diff --git a/source/blender/blenlib/BLI_double3.hh b/source/blender/blenlib/BLI_double3.hh deleted file mode 100644 index ab258c9121b..00000000000 --- a/source/blender/blenlib/BLI_double3.hh +++ /dev/null @@ -1,246 +0,0 @@ -/* - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ - -#pragma once - -/** \file - * \ingroup bli - */ - -#include <iostream> - -#include "BLI_math_vector.h" -#include "BLI_span.hh" - -namespace blender { - -struct double3 { - double x, y, z; - - double3() = default; - - double3(const double *ptr) : x{ptr[0]}, y{ptr[1]}, z{ptr[2]} - { - } - - double3(const double (*ptr)[3]) : double3((const double *)ptr) - { - } - - explicit double3(double value) : x(value), y(value), z(value) - { - } - - explicit double3(int value) : x(value), y(value), z(value) - { - } - - double3(double x, double y, double z) : x{x}, y{y}, z{z} - { - } - - operator const double *() const - { - return &x; - } - - operator double *() - { - return &x; - } - - double normalize_and_get_length() - { - return normalize_v3_db(*this); - } - - double3 normalized() const - { - double3 result; - normalize_v3_v3_db(result, *this); - return result; - } - - double length() const - { - return len_v3_db(*this); - } - - double length_squared() const - { - return len_squared_v3_db(*this); - } - - void reflect(const double3 &normal) - { - *this = this->reflected(normal); - } - - double3 reflected(const double3 &normal) const - { - double3 result; - reflect_v3_v3v3_db(result, *this, normal); - return result; - } - - static 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; - } - - void invert() - { - x = -x; - y = -y; - z = -z; - } - - friend double3 operator+(const double3 &a, const double3 &b) - { - return {a.x + b.x, a.y + b.y, a.z + b.z}; - } - - void operator+=(const double3 &b) - { - this->x += b.x; - this->y += b.y; - this->z += b.z; - } - - friend double3 operator-(const double3 &a, const double3 &b) - { - return {a.x - b.x, a.y - b.y, a.z - b.z}; - } - - friend double3 operator-(const double3 &a) - { - return {-a.x, -a.y, -a.z}; - } - - void operator-=(const double3 &b) - { - this->x -= b.x; - this->y -= b.y; - this->z -= b.z; - } - - void operator*=(const double &scalar) - { - this->x *= scalar; - this->y *= scalar; - this->z *= scalar; - } - - void operator*=(const double3 &other) - { - this->x *= other.x; - this->y *= other.y; - this->z *= other.z; - } - - friend double3 operator*(const double3 &a, const double3 &b) - { - return {a.x * b.x, a.y * b.y, a.z * b.z}; - } - - friend double3 operator*(const double3 &a, const double &b) - { - return {a.x * b, a.y * b, a.z * b}; - } - - friend double3 operator*(const double &a, const double3 &b) - { - return b * a; - } - - friend double3 operator/(const double3 &a, const double &b) - { - BLI_assert(b != 0.0); - return {a.x / b, a.y / b, a.z / b}; - } - - friend bool operator==(const double3 &a, const double3 &b) - { - return a.x == b.x && a.y == b.y && a.z == b.z; - } - - friend bool operator!=(const double3 &a, const double3 &b) - { - return a.x != b.x || a.y != b.y || a.z != b.z; - } - - friend std::ostream &operator<<(std::ostream &stream, const double3 &v) - { - stream << "(" << v.x << ", " << v.y << ", " << v.z << ")"; - return stream; - } - - static double dot(const double3 &a, const double3 &b) - { - return a.x * b.x + a.y * b.y + a.z * b.z; - } - - static double3 cross_high_precision(const double3 &a, const double3 &b) - { - double3 result; - cross_v3_v3v3_db(result, a, b); - return result; - } - - static double3 project(const double3 &a, const double3 &b) - { - double3 result; - project_v3_v3v3_db(result, a, b); - return result; - } - - static double distance(const double3 &a, const double3 &b) - { - return (a - b).length(); - } - - static double distance_squared(const double3 &a, const double3 &b) - { - double3 diff = a - b; - return double3::dot(diff, diff); - } - - static double3 interpolate(const double3 &a, const double3 &b, double t) - { - return a * (1 - t) + b * t; - } - - static double3 abs(const double3 &a) - { - return double3(fabs(a.x), fabs(a.y), fabs(a.z)); - } - - static 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)); - } - - static double3 cross_poly(Span<double3> poly); -}; - -} // namespace blender diff --git a/source/blender/blenlib/BLI_float2.hh b/source/blender/blenlib/BLI_float2.hh deleted file mode 100644 index bb4229db86e..00000000000 --- a/source/blender/blenlib/BLI_float2.hh +++ /dev/null @@ -1,218 +0,0 @@ -/* - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ - -#pragma once - -#include "BLI_float3.hh" - -namespace blender { - -struct float2 { - float x, y; - - float2() = default; - - float2(const float *ptr) : x{ptr[0]}, y{ptr[1]} - { - } - - explicit float2(float value) : x(value), y(value) - { - } - - explicit float2(int value) : x(value), y(value) - { - } - - float2(float x, float y) : x(x), y(y) - { - } - - float2(const float3 &other) : x(other.x), y(other.y) - { - } - - operator float *() - { - return &x; - } - - operator const float *() const - { - return &x; - } - - float length() const - { - return len_v2(*this); - } - - float length_squared() const - { - return len_squared_v2(*this); - } - - bool is_zero() const - { - return this->x == 0.0f && this->y == 0.0f; - } - - float2 &operator+=(const float2 &other) - { - x += other.x; - y += other.y; - return *this; - } - - float2 &operator-=(const float2 &other) - { - x -= other.x; - y -= other.y; - return *this; - } - - float2 &operator*=(float factor) - { - x *= factor; - y *= factor; - return *this; - } - - float2 &operator/=(float divisor) - { - x /= divisor; - y /= divisor; - return *this; - } - - uint64_t hash() const - { - uint64_t x1 = *reinterpret_cast<const uint32_t *>(&x); - uint64_t x2 = *reinterpret_cast<const uint32_t *>(&y); - return (x1 * 812519) ^ (x2 * 707951); - } - - friend float2 operator+(const float2 &a, const float2 &b) - { - return {a.x + b.x, a.y + b.y}; - } - - friend float2 operator-(const float2 &a, const float2 &b) - { - return {a.x - b.x, a.y - b.y}; - } - - friend float2 operator-(const float2 &a, const float &b) - { - return {a.x - b, a.y - b}; - } - - friend float2 operator*(const float2 &a, float b) - { - return {a.x * b, a.y * b}; - } - - friend float2 operator/(const float2 &a, float b) - { - BLI_assert(b != 0.0f); - return {a.x / b, a.y / b}; - } - - friend float2 operator*(float a, const float2 &b) - { - return b * a; - } - - friend std::ostream &operator<<(std::ostream &stream, const float2 &v) - { - stream << "(" << v.x << ", " << v.y << ")"; - return stream; - } - - static float2 safe_divide(const float2 &a, const float b) - { - return (b != 0.0f) ? a / b : float2(0.0f); - } - - static float2 floor(const float2 &a) - { - return float2(floorf(a.x), floorf(a.y)); - } - - /** - * Returns a normalized vector. The original vector is not changed. - */ - float2 normalized() const - { - float2 result; - normalize_v2_v2(result, *this); - return result; - } - - static float dot(const float2 &a, const float2 &b) - { - return a.x * b.x + a.y * b.y; - } - - static float2 interpolate(const float2 &a, const float2 &b, float t) - { - return a * (1 - t) + b * t; - } - - static float2 abs(const float2 &a) - { - return float2(fabsf(a.x), fabsf(a.y)); - } - - static float distance(const float2 &a, const float2 &b) - { - return (a - b).length(); - } - - static float distance_squared(const float2 &a, const float2 &b) - { - float2 diff = a - b; - return float2::dot(diff, diff); - } - - struct isect_result { - enum { - LINE_LINE_COLINEAR = -1, - LINE_LINE_NONE = 0, - LINE_LINE_EXACT = 1, - LINE_LINE_CROSS = 2, - } kind; - float lambda; - float mu; - }; - - static isect_result isect_seg_seg(const float2 &v1, - 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 diff --git a/source/blender/blenlib/BLI_float3.hh b/source/blender/blenlib/BLI_float3.hh deleted file mode 100644 index 765f524fb31..00000000000 --- a/source/blender/blenlib/BLI_float3.hh +++ /dev/null @@ -1,320 +0,0 @@ -/* - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ - -#pragma once - -#include <iostream> - -#include "BLI_math_vector.h" - -namespace blender { - -struct float3 { - float x, y, z; - - float3() = default; - - float3(const float *ptr) : x{ptr[0]}, y{ptr[1]}, z{ptr[2]} - { - } - - float3(const float (*ptr)[3]) : float3(static_cast<const float *>(ptr[0])) - { - } - - explicit float3(float value) : x(value), y(value), z(value) - { - } - - explicit float3(int value) : x(value), y(value), z(value) - { - } - - float3(float x, float y, float z) : x{x}, y{y}, z{z} - { - } - - operator const float *() const - { - return &x; - } - - operator float *() - { - return &x; - } - - friend float3 operator+(const float3 &a, const float3 &b) - { - return {a.x + b.x, a.y + b.y, a.z + b.z}; - } - - friend float3 operator+(const float3 &a, const float &b) - { - return {a.x + b, a.y + b, a.z + b}; - } - - float3 &operator+=(const float3 &b) - { - this->x += b.x; - this->y += b.y; - this->z += b.z; - return *this; - } - - friend float3 operator-(const float3 &a, const float3 &b) - { - return {a.x - b.x, a.y - b.y, a.z - b.z}; - } - - friend float3 operator-(const float3 &a) - { - return {-a.x, -a.y, -a.z}; - } - - friend float3 operator-(const float3 &a, const float &b) - { - return {a.x - b, a.y - b, a.z - b}; - } - - float3 &operator-=(const float3 &b) - { - this->x -= b.x; - this->y -= b.y; - this->z -= b.z; - return *this; - } - - float3 &operator*=(float scalar) - { - this->x *= scalar; - this->y *= scalar; - this->z *= scalar; - return *this; - } - - float3 &operator*=(const float3 &other) - { - this->x *= other.x; - this->y *= other.y; - this->z *= other.z; - return *this; - } - - friend float3 operator*(const float3 &a, const float3 &b) - { - return {a.x * b.x, a.y * b.y, a.z * b.z}; - } - - friend float3 operator*(const float3 &a, float b) - { - return {a.x * b, a.y * b, a.z * b}; - } - - friend float3 operator*(float a, const float3 &b) - { - return b * a; - } - - friend float3 operator/(const float3 &a, float b) - { - BLI_assert(b != 0.0f); - return {a.x / b, a.y / b, a.z / b}; - } - - friend std::ostream &operator<<(std::ostream &stream, const float3 &v) - { - stream << "(" << v.x << ", " << v.y << ", " << v.z << ")"; - return stream; - } - - friend bool operator==(const float3 &a, const float3 &b) - { - return a.x == b.x && a.y == b.y && a.z == b.z; - } - - friend bool operator!=(const float3 &a, const float3 &b) - { - return !(a == b); - } - - float normalize_and_get_length() - { - return normalize_v3(*this); - } - - /** - * Normalizes the vector in place. - */ - void normalize() - { - normalize_v3(*this); - } - - /** - * Returns a normalized vector. The original vector is not changed. - */ - float3 normalized() const - { - float3 result; - normalize_v3_v3(result, *this); - return result; - } - - float length() const - { - return len_v3(*this); - } - - float length_squared() const - { - return len_squared_v3(*this); - } - - bool is_zero() const - { - return this->x == 0.0f && this->y == 0.0f && this->z == 0.0f; - } - - void reflect(const float3 &normal) - { - *this = this->reflected(normal); - } - - float3 reflected(const float3 &normal) const - { - float3 result; - reflect_v3_v3v3(result, *this, normal); - return result; - } - - static float3 refract(const float3 &incident, const float3 &normal, const float eta) - { - float3 result; - float k = 1.0f - eta * eta * (1.0f - dot(normal, incident) * dot(normal, incident)); - if (k < 0.0f) { - result = float3(0.0f); - } - else { - result = eta * incident - (eta * dot(normal, incident) + sqrt(k)) * normal; - } - return result; - } - - static float3 faceforward(const float3 &vector, const float3 &incident, const float3 &reference) - { - return dot(reference, incident) < 0.0f ? vector : -vector; - } - - static float3 safe_divide(const float3 &a, const float3 &b) - { - float3 result; - result.x = (b.x == 0.0f) ? 0.0f : a.x / b.x; - result.y = (b.y == 0.0f) ? 0.0f : a.y / b.y; - result.z = (b.z == 0.0f) ? 0.0f : a.z / b.z; - return result; - } - - static float3 min(const float3 &a, const float3 &b) - { - return {a.x < b.x ? a.x : b.x, a.y < b.y ? a.y : b.y, a.z < b.z ? a.z : b.z}; - } - - static float3 max(const float3 &a, const float3 &b) - { - return {a.x > b.x ? a.x : b.x, a.y > b.y ? a.y : b.y, a.z > b.z ? a.z : b.z}; - } - - static void min_max(const float3 &vector, float3 &min, float3 &max) - { - min = float3::min(vector, min); - max = float3::max(vector, max); - } - - static float3 safe_divide(const float3 &a, const float b) - { - return (b != 0.0f) ? a / b : float3(0.0f); - } - - static float3 floor(const float3 &a) - { - return float3(floorf(a.x), floorf(a.y), floorf(a.z)); - } - - void invert() - { - x = -x; - y = -y; - z = -z; - } - - uint64_t hash() const - { - uint64_t x1 = *reinterpret_cast<const uint32_t *>(&x); - uint64_t x2 = *reinterpret_cast<const uint32_t *>(&y); - 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 cross(const float3 &a, const float3 &b) - { - float3 result; - cross_v3_v3v3(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 diff --git a/source/blender/blenlib/BLI_float4.hh b/source/blender/blenlib/BLI_float4.hh deleted file mode 100644 index 5b487f6d029..00000000000 --- a/source/blender/blenlib/BLI_float4.hh +++ /dev/null @@ -1,138 +0,0 @@ -/* - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ - -#pragma once - -namespace blender { - -struct float4 { - float x, y, z, w; - - float4() = default; - - float4(const float *ptr) : x{ptr[0]}, y{ptr[1]}, z{ptr[2]}, w{ptr[3]} - { - } - - explicit float4(float value) : x(value), y(value), z(value), w(value) - { - } - - explicit float4(int value) : x(value), y(value), z(value), w(value) - { - } - - float4(float x, float y, float z, float w) : x(x), y(y), z(z), w(w) - { - } - - operator float *() - { - return &x; - } - - friend float4 operator+(const float4 &a, const float &b) - { - return {a.x + b, a.y + b, a.z + b, a.w + b}; - } - - operator const float *() const - { - return &x; - } - - float4 &operator+=(const float4 &other) - { - x += other.x; - y += other.y; - z += other.z; - w += other.w; - return *this; - } - - friend float4 operator-(const float4 &a, const float4 &b) - { - return {a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w}; - } - - friend float4 operator-(const float4 &a, const float &b) - { - return {a.x - b, a.y - b, a.z - b, a.w - b}; - } - - friend float4 operator+(const float4 &a, const float4 &b) - { - return {a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w}; - } - - friend float4 operator/(const float4 &a, float f) - { - BLI_assert(f != 0.0f); - return a * (1.0f / f); - } - - float4 &operator*=(float factor) - { - x *= factor; - y *= factor; - z *= factor; - w *= factor; - return *this; - } - - friend float4 operator*(const float4 &a, float b) - { - return {a.x * b, a.y * b, a.z * b, a.w * b}; - } - - friend float4 operator*(float a, const float4 &b) - { - return b * a; - } - - float length() const - { - return len_v4(*this); - } - - static float distance(const float4 &a, const float4 &b) - { - return (a - b).length(); - } - - static float4 safe_divide(const float4 &a, const float b) - { - return (b != 0.0f) ? a / b : float4(0.0f); - } - - static float4 interpolate(const float4 &a, const float4 &b, float t) - { - return a * (1 - t) + b * t; - } - - static float4 floor(const float4 &a) - { - return float4(floorf(a.x), floorf(a.y), floorf(a.z), floorf(a.w)); - } - - static float4 normalize(const float4 &a) - { - const float t = len_v4(a); - return (t != 0.0f) ? a / t : float4(0.0f); - } -}; - -} // namespace blender diff --git a/source/blender/blenlib/BLI_float4x4.hh b/source/blender/blenlib/BLI_float4x4.hh index b7f839f4ddf..81c969d02d0 100644 --- a/source/blender/blenlib/BLI_float4x4.hh +++ b/source/blender/blenlib/BLI_float4x4.hh @@ -16,8 +16,9 @@ #pragma once -#include "BLI_float3.hh" #include "BLI_math_matrix.h" +#include "BLI_math_vec_types.hh" +#include "BLI_math_vector.h" namespace blender { @@ -63,7 +64,7 @@ struct float4x4 { * Without the negation, the result would be a so called improper rotation. That means it * contains a reflection. Such an improper rotation matrix could not be converted to another * representation of a rotation such as euler angles. */ - const float3 cross = -float3::cross(forward, up); + const float3 cross = -math::cross(forward, up); float4x4 matrix; matrix.values[0][0] = forward.x; diff --git a/source/blender/blenlib/BLI_math_boolean.hh b/source/blender/blenlib/BLI_math_boolean.hh index 20fd00b2aa4..8cf93c82dec 100644 --- a/source/blender/blenlib/BLI_math_boolean.hh +++ b/source/blender/blenlib/BLI_math_boolean.hh @@ -21,13 +21,11 @@ * \brief Math vector functions needed specifically for mesh intersect and boolean. */ -#include "BLI_double2.hh" -#include "BLI_double3.hh" +#include "BLI_math_vec_types.hh" #ifdef WITH_GMP # include "BLI_math_mpq.hh" -# include "BLI_mpq2.hh" -# include "BLI_mpq3.hh" +# include "BLI_math_vec_mpq_types.hh" #endif namespace blender { diff --git a/source/blender/blenlib/BLI_math_vec_mpq_types.hh b/source/blender/blenlib/BLI_math_vec_mpq_types.hh new file mode 100644 index 00000000000..36eb0cac83c --- /dev/null +++ b/source/blender/blenlib/BLI_math_vec_mpq_types.hh @@ -0,0 +1,91 @@ +/* + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#pragma once + +/** \file + * \ingroup bli + */ + +#ifdef WITH_GMP + +# include "BLI_math_mpq.hh" +# include "BLI_math_vec_types.hh" + +namespace blender { + +using mpq2 = vec_base<mpq_class, 2>; +using mpq3 = vec_base<mpq_class, 3>; + +namespace math { + +uint64_t hash_mpq_class(const mpq_class &value); + +template<> inline uint64_t vector_hash(const mpq2 &vec) +{ + return hash_mpq_class(vec.x) ^ (hash_mpq_class(vec.y) * 33); +} + +template<> inline uint64_t vector_hash(const mpq3 &vec) +{ + return hash_mpq_class(vec.x) ^ (hash_mpq_class(vec.y) * 33) ^ (hash_mpq_class(vec.z) * 33 * 37); +} + +/** + * Cannot do this exactly in rational arithmetic! + * Approximate by going in and out of doubles. + */ +template<> inline mpq_class length(const mpq2 &a) +{ + return mpq_class(sqrt(length_squared(a).get_d())); +} + +/** + * Cannot do this exactly in rational arithmetic! + * Approximate by going in and out of doubles. + */ +template<> inline mpq_class length(const mpq3 &a) +{ + return mpq_class(sqrt(length_squared(a).get_d())); +} + +/** + * The buffer avoids allocating a temporary variable. + */ +inline mpq_class distance_squared_with_buffer(const mpq3 &a, const mpq3 &b, mpq3 &buffer) +{ + buffer = a; + buffer -= b; + return dot(buffer, buffer); +} + +/** + * The buffer avoids allocating a temporary variable. + */ +inline mpq_class dot_with_buffer(const mpq3 &a, const mpq3 &b, mpq3 &buffer) +{ + buffer = a; + buffer *= b; + buffer.x += buffer.y; + buffer.x += buffer.z; + return buffer.x; +} + +} // namespace math + +} // namespace blender + +#endif /* WITH_GMP */ diff --git a/source/blender/blenlib/BLI_math_vec_types.hh b/source/blender/blenlib/BLI_math_vec_types.hh new file mode 100644 index 00000000000..52aacd294e4 --- /dev/null +++ b/source/blender/blenlib/BLI_math_vec_types.hh @@ -0,0 +1,566 @@ +/* + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Copyright 2022, Blender Foundation. + */ + +#pragma once + +/** \file + * \ingroup bli + */ + +#include <array> +#include <cmath> +#include <iostream> +#include <type_traits> + +#include "BLI_math_vector.hh" +#include "BLI_utildefines.h" + +namespace blender { + +/* clang-format off */ +template<typename T> +using as_uint_type = std::conditional_t<sizeof(T) == sizeof(uint8_t), uint8_t, + std::conditional_t<sizeof(T) == sizeof(uint16_t), uint16_t, + std::conditional_t<sizeof(T) == sizeof(uint32_t), uint32_t, + std::conditional_t<sizeof(T) == sizeof(uint64_t), uint64_t, void>>>>; +/* clang-format on */ + +template<typename T, int Size> struct vec_struct_base { + std::array<T, Size> values; +}; + +template<typename T> struct vec_struct_base<T, 2> { + T x, y; +}; + +template<typename T> struct vec_struct_base<T, 3> { + T x, y, z; +}; + +template<typename T> struct vec_struct_base<T, 4> { + T x, y, z, w; +}; + +template<typename T, int Size> struct vec_base : 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>; + + vec_base() = default; + + explicit vec_base(uint value) + { + for (int i = 0; i < Size; i++) { + (*this)[i] = static_cast<T>(value); + } + } + + explicit vec_base(int value) + { + for (int i = 0; i < Size; i++) { + (*this)[i] = static_cast<T>(value); + } + } + + explicit vec_base(float value) + { + for (int i = 0; i < Size; i++) { + (*this)[i] = static_cast<T>(value); + } + } + + explicit vec_base(double value) + { + for (int i = 0; i < Size; i++) { + (*this)[i] = static_cast<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) + { + (*this)[0] = _x; + (*this)[1] = _y; + } + + template<BLI_ENABLE_IF_VEC(Size, == 3)> vec_base(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) + { + (*this)[0] = _x; + (*this)[1] = _y; + (*this)[2] = _z; + (*this)[3] = _w; + } + + /** 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(static_cast<T>(xy.x), static_cast<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, static_cast<T>(yz.x), static_cast<T>(yz.y)) + { + } + + template<typename U, BLI_ENABLE_IF_VEC(Size, == 4)> + vec_base(vec_base<U, 3> xyz, T w) + : vec_base( + static_cast<T>(xyz.x), static_cast<T>(xyz.y), static_cast<T>(xyz.z), static_cast<T>(w)) + { + } + + template<typename U, BLI_ENABLE_IF_VEC(Size, == 4)> + vec_base(T x, vec_base<U, 3> yzw) + : vec_base( + static_cast<T>(x), static_cast<T>(yzw.x), static_cast<T>(yzw.y), static_cast<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( + static_cast<T>(xy.x), static_cast<T>(xy.y), static_cast<T>(zw.x), static_cast<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(static_cast<T>(xy.x), static_cast<T>(xy.y), static_cast<T>(z), static_cast<T>(w)) + { + } + + template<typename U, BLI_ENABLE_IF_VEC(Size, == 4)> + vec_base(T x, vec_base<U, 2> yz, T w) + : vec_base(static_cast<T>(x), static_cast<T>(yz.x), static_cast<T>(yz.y), static_cast<T>(w)) + { + } + + template<typename U, BLI_ENABLE_IF_VEC(Size, == 4)> + vec_base(T x, T y, vec_base<U, 2> zw) + : vec_base(static_cast<T>(x), static_cast<T>(y), static_cast<T>(zw.x), static_cast<T>(zw.y)) + { + } + + /** Masking. */ + + template<typename U, int OtherSize, BLI_ENABLE_IF(OtherSize > Size)> + explicit vec_base(const vec_base<U, OtherSize> &other) + { + for (int i = 0; i < Size; i++) { + (*this)[i] = static_cast<T>(other[i]); + } + } + +#undef BLI_ENABLE_IF_VEC + + /** Conversion from pointers (from C-style vectors). */ + + vec_base(const T *ptr) + { + for (int i = 0; i < Size; i++) { + (*this)[i] = ptr[i]; + } + } + + vec_base(const T (*ptr)[Size]) : vec_base(static_cast<const T *>(ptr[0])) + { + } + + /** Conversion from other vector types. */ + + template<typename U> explicit vec_base(const vec_base<U, Size> &vec) + { + for (int i = 0; i < Size; i++) { + (*this)[i] = static_cast<T>(vec[i]); + } + } + + /** C-style pointer dereference. */ + + operator const T *() const + { + return reinterpret_cast<const T *>(this); + } + + operator T *() + { + return reinterpret_cast<T *>(this); + } + + /** Array access. */ + + const T &operator[](int index) const + { + BLI_assert(index >= 0); + BLI_assert(index < Size); + return reinterpret_cast<const T *>(this)[index]; + } + + T &operator[](int index) + { + BLI_assert(index >= 0); + BLI_assert(index < Size); + return reinterpret_cast<T *>(this)[index]; + } + + /** Internal Operators Macro. */ + +#define BLI_INT_OP(_T) template<typename U = _T, BLI_ENABLE_IF((std::is_integral_v<U>))> + +#define BLI_VEC_OP_IMPL(_result, _i, _op) \ + vec_base _result; \ + for (int _i = 0; _i < Size; _i++) { \ + _op; \ + } \ + return _result; + +#define BLI_VEC_OP_IMPL_SELF(_i, _op) \ + for (int _i = 0; _i < Size; _i++) { \ + _op; \ + } \ + return *this; + + /** Arithmetic operators. */ + + friend vec_base operator+(const vec_base &a, const vec_base &b) + { + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] + b[i]); + } + + friend vec_base operator+(const vec_base &a, const T &b) + { + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] + b); + } + + friend vec_base operator+(const T &a, const vec_base &b) + { + return b + a; + } + + vec_base &operator+=(const vec_base &b) + { + BLI_VEC_OP_IMPL_SELF(i, (*this)[i] += b[i]); + } + + vec_base &operator+=(const T &b) + { + BLI_VEC_OP_IMPL_SELF(i, (*this)[i] += b); + } + + friend vec_base operator-(const vec_base &a) + { + BLI_VEC_OP_IMPL(ret, i, ret[i] = -a[i]); + } + + friend vec_base operator-(const vec_base &a, const vec_base &b) + { + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] - b[i]); + } + + friend vec_base operator-(const vec_base &a, const T &b) + { + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] - b); + } + + friend vec_base operator-(const T &a, const vec_base &b) + { + BLI_VEC_OP_IMPL(ret, i, ret[i] = a - b[i]); + } + + vec_base &operator-=(const vec_base &b) + { + BLI_VEC_OP_IMPL_SELF(i, (*this)[i] -= b[i]); + } + + vec_base &operator-=(const T &b) + { + BLI_VEC_OP_IMPL_SELF(i, (*this)[i] -= b); + } + + friend vec_base operator*(const vec_base &a, const vec_base &b) + { + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] * b[i]); + } + + friend vec_base operator*(const vec_base &a, T b) + { + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] * b); + } + + friend vec_base operator*(T a, const vec_base &b) + { + return b * a; + } + + vec_base &operator*=(T b) + { + BLI_VEC_OP_IMPL_SELF(i, (*this)[i] *= b); + } + + vec_base &operator*=(const vec_base &b) + { + BLI_VEC_OP_IMPL_SELF(i, (*this)[i] *= b[i]); + } + + friend vec_base operator/(const vec_base &a, const vec_base &b) + { + BLI_assert(!math::is_any_zero(b)); + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] / b[i]); + } + + friend vec_base operator/(const vec_base &a, T b) + { + BLI_assert(b != T(0)); + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] / b); + } + + friend vec_base operator/(T a, const vec_base &b) + { + BLI_assert(!math::is_any_zero(b)); + BLI_VEC_OP_IMPL(ret, i, ret[i] = a / b[i]); + } + + vec_base &operator/=(T b) + { + BLI_assert(b != T(0)); + BLI_VEC_OP_IMPL_SELF(i, (*this)[i] /= b); + } + + vec_base &operator/=(const vec_base &b) + { + BLI_assert(!math::is_any_zero(b)); + BLI_VEC_OP_IMPL_SELF(i, (*this)[i] /= b[i]); + } + + /** Binary operators. */ + + BLI_INT_OP(T) friend vec_base operator&(const vec_base &a, const vec_base &b) + { + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] & b[i]); + } + + BLI_INT_OP(T) friend vec_base operator&(const vec_base &a, T b) + { + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] & b); + } + + BLI_INT_OP(T) friend vec_base operator&(T a, const vec_base &b) + { + return b & a; + } + + BLI_INT_OP(T) vec_base &operator&=(T b) + { + BLI_VEC_OP_IMPL_SELF(i, (*this)[i] &= b); + } + + BLI_INT_OP(T) vec_base &operator&=(const vec_base &b) + { + BLI_VEC_OP_IMPL_SELF(i, (*this)[i] &= b[i]); + } + + BLI_INT_OP(T) friend vec_base operator|(const vec_base &a, const vec_base &b) + { + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] | b[i]); + } + + BLI_INT_OP(T) friend vec_base operator|(const vec_base &a, T b) + { + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] | b); + } + + BLI_INT_OP(T) friend vec_base operator|(T a, const vec_base &b) + { + return b | a; + } + + BLI_INT_OP(T) vec_base &operator|=(T b) + { + BLI_VEC_OP_IMPL_SELF(i, (*this)[i] |= b); + } + + BLI_INT_OP(T) vec_base &operator|=(const vec_base &b) + { + BLI_VEC_OP_IMPL_SELF(i, (*this)[i] |= b[i]); + } + + BLI_INT_OP(T) friend vec_base operator^(const vec_base &a, const vec_base &b) + { + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] ^ b[i]); + } + + BLI_INT_OP(T) friend vec_base operator^(const vec_base &a, T b) + { + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] ^ b); + } + + BLI_INT_OP(T) friend vec_base operator^(T a, const vec_base &b) + { + return b ^ a; + } + + BLI_INT_OP(T) vec_base &operator^=(T b) + { + BLI_VEC_OP_IMPL_SELF(i, (*this)[i] ^= b); + } + + BLI_INT_OP(T) vec_base &operator^=(const vec_base &b) + { + BLI_VEC_OP_IMPL_SELF(i, (*this)[i] ^= b[i]); + } + + BLI_INT_OP(T) friend vec_base operator~(const vec_base &a) + { + BLI_VEC_OP_IMPL(ret, i, ret[i] = ~a[i]); + } + + /** Bit-shift operators. */ + + BLI_INT_OP(T) friend vec_base operator<<(const vec_base &a, const vec_base &b) + { + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] << b[i]); + } + + BLI_INT_OP(T) friend vec_base operator<<(const vec_base &a, T b) + { + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] << b); + } + + BLI_INT_OP(T) vec_base &operator<<=(T b) + { + BLI_VEC_OP_IMPL_SELF(i, (*this)[i] <<= b); + } + + BLI_INT_OP(T) vec_base &operator<<=(const vec_base &b) + { + BLI_VEC_OP_IMPL_SELF(i, (*this)[i] <<= b[i]); + } + + BLI_INT_OP(T) friend vec_base operator>>(const vec_base &a, const vec_base &b) + { + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] >> b[i]); + } + + BLI_INT_OP(T) friend vec_base operator>>(const vec_base &a, T b) + { + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] >> b); + } + + BLI_INT_OP(T) vec_base &operator>>=(T b) + { + BLI_VEC_OP_IMPL_SELF(i, (*this)[i] >>= b); + } + + BLI_INT_OP(T) vec_base &operator>>=(const vec_base &b) + { + BLI_VEC_OP_IMPL_SELF(i, (*this)[i] >>= b[i]); + } + + /** Modulo operators. */ + + BLI_INT_OP(T) friend vec_base operator%(const vec_base &a, const vec_base &b) + { + BLI_assert(!math::is_any_zero(b)); + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] % b[i]); + } + + BLI_INT_OP(T) friend vec_base operator%(const vec_base &a, T b) + { + BLI_assert(b != 0); + BLI_VEC_OP_IMPL(ret, i, ret[i] = a[i] % b); + } + + BLI_INT_OP(T) friend vec_base operator%(T a, const vec_base &b) + { + BLI_assert(!math::is_any_zero(b)); + BLI_VEC_OP_IMPL(ret, i, ret[i] = a % b[i]); + } + +#undef BLI_INT_OP +#undef BLI_VEC_OP_IMPL +#undef BLI_VEC_OP_IMPL_SELF + + /** Compare. */ + + friend bool operator==(const vec_base &a, const vec_base &b) + { + for (int i = 0; i < Size; i++) { + if (a[i] != b[i]) { + return false; + } + } + return true; + } + + friend bool operator!=(const vec_base &a, const vec_base &b) + { + return !(a == b); + } + + /** Misc. */ + + uint64_t hash() const + { + return math::vector_hash(*this); + } + + friend std::ostream &operator<<(std::ostream &stream, const vec_base &v) + { + stream << "("; + for (int i = 0; i < Size; i++) { + stream << v[i]; + if (i != Size - 1) { + stream << ", "; + } + } + stream << ")"; + return stream; + } +}; + +using int2 = vec_base<int32_t, 2>; +using int3 = vec_base<int32_t, 3>; +using int4 = vec_base<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 float2 = vec_base<float, 2>; +using float3 = vec_base<float, 3>; +using float4 = vec_base<float, 4>; + +using double2 = vec_base<double, 2>; +using double3 = vec_base<double, 3>; +using double4 = vec_base<double, 4>; + +} // namespace blender diff --git a/source/blender/blenlib/BLI_math_vector.hh b/source/blender/blenlib/BLI_math_vector.hh new file mode 100644 index 00000000000..e7d765df842 --- /dev/null +++ b/source/blender/blenlib/BLI_math_vector.hh @@ -0,0 +1,399 @@ +/* + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Copyright 2022, Blender Foundation. + */ + +#pragma once + +/** \file + * \ingroup bli + */ + +#include <cmath> +#include <type_traits> + +#include "BLI_math_base_safe.h" +#include "BLI_math_vector.h" +#include "BLI_span.hh" +#include "BLI_utildefines.h" + +#ifdef WITH_GMP +# include "BLI_math_mpq.hh" +#endif + +namespace blender::math { + +#ifndef NDEBUG +# define BLI_ASSERT_UNIT(v) \ + { \ + const float _test_unit = length_squared(v); \ + BLI_assert(!(std::abs(_test_unit - 1.0f) >= BLI_ASSERT_UNIT_EPSILON) || \ + !(std::abs(_test_unit) >= BLI_ASSERT_UNIT_EPSILON)); \ + } \ + (void)0 +#else +# define BLI_ASSERT_UNIT(v) (void)(v) +#endif + +#define bT typename T::base_type + +#ifdef WITH_GMP +# define BLI_ENABLE_IF_FLT_VEC(T) \ + BLI_ENABLE_IF((std::is_floating_point_v<typename T::base_type> || \ + std::is_same_v<typename T::base_type, mpq_class>)) +#else +# define BLI_ENABLE_IF_FLT_VEC(T) BLI_ENABLE_IF((std::is_floating_point_v<typename T::base_type>)) +#endif + +#define BLI_ENABLE_IF_INT_VEC(T) BLI_ENABLE_IF((std::is_integral_v<typename T::base_type>)) + +template<typename T> inline bool is_zero(const T &a) +{ + for (int i = 0; i < T::type_length; i++) { + if (a[i] != bT(0)) { + return false; + } + } + return true; +} + +template<typename T> inline bool is_any_zero(const T &a) +{ + for (int i = 0; i < T::type_length; i++) { + if (a[i] == bT(0)) { + return true; + } + } + return false; +} + +template<typename T> inline T abs(const T &a) +{ + T result; + for (int i = 0; i < T::type_length; i++) { + result[i] = a[i] >= 0 ? a[i] : -a[i]; + } + return result; +} + +template<typename T> inline T min(const T &a, const T &b) +{ + T result; + for (int i = 0; i < T::type_length; i++) { + result[i] = a[i] < b[i] ? a[i] : b[i]; + } + return result; +} + +template<typename T> inline T max(const T &a, const T &b) +{ + T result; + for (int i = 0; i < T::type_length; i++) { + result[i] = a[i] > b[i] ? a[i] : b[i]; + } + return result; +} + +template<typename T> inline T clamp(const T &a, const T &min_v, const T &max_v) +{ + T result = a; + for (int i = 0; i < T::type_length; i++) { + CLAMP(result[i], min_v[i], max_v[i]); + } + return result; +} + +template<typename T> inline T clamp(const T &a, const bT &min_v, const bT &max_v) +{ + T result = a; + for (int i = 0; i < T::type_length; i++) { + CLAMP(result[i], min_v, max_v); + } + return result; +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> inline T mod(const T &a, const T &b) +{ + T result; + for (int i = 0; i < T::type_length; i++) { + BLI_assert(b[i] != 0); + result[i] = std::fmod(a[i], b[i]); + } + return result; +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> inline T mod(const T &a, bT b) +{ + BLI_assert(b != 0); + T result; + for (int i = 0; i < T::type_length; i++) { + result[i] = std::fmod(a[i], b); + } + return result; +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> inline T safe_mod(const T &a, const T &b) +{ + T result; + for (int i = 0; i < T::type_length; i++) { + result[i] = (b[i] != 0) ? std::fmod(a[i], b[i]) : 0; + } + return result; +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> inline T safe_mod(const T &a, bT b) +{ + if (b == 0) { + return T(0.0f); + } + T result; + for (int i = 0; i < T::type_length; i++) { + result[i] = std::fmod(a[i], b); + } + return result; +} + +template<typename T> inline void min_max(const T &vector, T &min_vec, T &max_vec) +{ + min_vec = min(vector, min_vec); + max_vec = max(vector, max_vec); +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> inline T safe_divide(const T &a, const T &b) +{ + T result; + for (int i = 0; i < T::type_length; i++) { + result[i] = (b[i] == 0) ? 0 : a[i] / b[i]; + } + return result; +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> inline T safe_divide(const T &a, const bT b) +{ + return (b != 0) ? a / b : T(0.0f); +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> inline T floor(const T &a) +{ + T result; + for (int i = 0; i < T::type_length; i++) { + result[i] = std::floor(a[i]); + } + return result; +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> inline T ceil(const T &a) +{ + T result; + for (int i = 0; i < T::type_length; i++) { + result[i] = std::ceil(a[i]); + } + return result; +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> inline T fract(const T &a) +{ + T result; + for (int i = 0; i < T::type_length; i++) { + result[i] = a[i] - std::floor(a[i]); + } + return result; +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> inline bT dot(const T &a, const T &b) +{ + bT result = a[0] * b[0]; + for (int i = 1; i < T::type_length; i++) { + result += a[i] * b[i]; + } + return result; +} + +template<typename T> inline bT length_manhattan(const T &a) +{ + bT result = std::abs(a[0]); + for (int i = 1; i < T::type_length; i++) { + result += std::abs(a[i]); + } + return result; +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> inline bT length_squared(const T &a) +{ + return dot(a, a); +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> inline bT length(const T &a) +{ + return std::sqrt(length_squared(a)); +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> inline bT distance_manhattan(const T &a, const T &b) +{ + return length_manhattan(a - b); +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> inline bT distance_squared(const T &a, const T &b) +{ + return length_squared(a - b); +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> inline bT distance(const T &a, const T &b) +{ + return length(a - b); +} + +template<typename T> uint64_t vector_hash(const T &vec) +{ + BLI_STATIC_ASSERT(T::type_length <= 4, "Longer types need to implement vector_hash themself."); + const typename T::uint_type &uvec = *reinterpret_cast<const typename T::uint_type *>(&vec); + uint64_t result; + result = uvec[0] * uint64_t(435109); + if constexpr (T::type_length > 1) { + result ^= uvec[1] * uint64_t(380867); + } + if constexpr (T::type_length > 2) { + result ^= uvec[2] * uint64_t(1059217); + } + if constexpr (T::type_length > 3) { + result ^= uvec[3] * uint64_t(2002613); + } + return result; +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> inline T reflect(const T &incident, const T &normal) +{ + BLI_ASSERT_UNIT(normal); + return incident - 2.0 * dot(normal, incident) * normal; +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> +inline T refract(const T &incident, const T &normal, const bT eta) +{ + float dot_ni = dot(normal, incident); + float k = 1.0f - eta * eta * (1.0f - dot_ni * dot_ni); + if (k < 0.0f) { + return T(0.0f); + } + return eta * incident - (eta * dot_ni + sqrt(k)) * normal; +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> inline T project(const T &p, const T &v_proj) +{ + if (UNLIKELY(is_zero(v_proj))) { + return T(0.0f); + } + return v_proj * (dot(p, v_proj) / dot(v_proj, v_proj)); +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> +inline T normalize_and_get_length(const T &v, bT &out_length) +{ + out_length = length_squared(v); + /* A larger value causes normalize errors in a scaled down models with camera extreme close. */ + constexpr bT threshold = std::is_same_v<bT, double> ? 1.0e-70 : 1.0e-35f; + if (out_length > threshold) { + out_length = sqrt(out_length); + return v / out_length; + } + /* Either the vector is small or one of it's values contained `nan`. */ + out_length = 0.0; + return T(0.0); +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> inline T normalize(const T &v) +{ + bT len; + return normalize_and_get_length(v, len); +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T), BLI_ENABLE_IF((T::type_length == 3))> +inline T cross(const T &a, const T &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}; +} + +template<typename T, + BLI_ENABLE_IF((std::is_same_v<bT, float>)), + BLI_ENABLE_IF((T::type_length == 3))> +inline T cross_high_precision(const T &a, const T &b) +{ + return {(float)((double)a.y * b.z - (double)a.z * b.y), + (float)((double)a.z * b.x - (double)a.x * b.z), + (float)((double)a.x * b.y - (double)a.y * b.x)}; +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T), BLI_ENABLE_IF((T::type_length == 3))> +inline T cross_poly(Span<T> poly) +{ + /* Newell's Method. */ + int nv = static_cast<int>(poly.size()); + if (nv < 3) { + return T(0, 0, 0); + } + const T *v_prev = &poly[nv - 1]; + const T *v_curr = &poly[0]; + T 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]); + n[2] = n[2] + ((*v_prev)[0] - (*v_curr)[0]) * ((*v_prev)[1] + (*v_curr)[1]); + v_prev = v_curr; + ++i; + if (i < nv) { + v_curr = &poly[i]; + } + } + return n; +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> inline T interpolate(const T &a, const T &b, bT t) +{ + return a * (1 - t) + b * t; +} + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> +inline T faceforward(const T &vector, const T &incident, const T &reference) +{ + return (dot(reference, incident) < 0) ? vector : -vector; +} + +template<typename T> inline int dominant_axis(const T &a) +{ + T b = abs(a); + return ((b.x > b.y) ? ((b.x > b.z) ? 0 : 2) : ((b.y > b.z) ? 1 : 2)); +} + +/** Intersections. */ + +template<typename T> struct isect_result { + enum { + LINE_LINE_COLINEAR = -1, + LINE_LINE_NONE = 0, + LINE_LINE_EXACT = 1, + LINE_LINE_CROSS = 2, + } kind; + bT lambda; +}; + +template<typename T, BLI_ENABLE_IF_FLT_VEC(T)> +isect_result<T> isect_seg_seg(const T &v1, const T &v2, const T &v3, const T &v4); + +#undef BLI_ENABLE_IF_FLT_VEC +#undef BLI_ENABLE_IF_INT_VEC +#undef bT + +} // namespace blender::math diff --git a/source/blender/blenlib/BLI_memory_utils.hh b/source/blender/blenlib/BLI_memory_utils.hh index 37691017c12..9a5be79b61e 100644 --- a/source/blender/blenlib/BLI_memory_utils.hh +++ b/source/blender/blenlib/BLI_memory_utils.hh @@ -557,13 +557,4 @@ Container &move_assign_container(Container &dst, Container &&src) noexcept( return dst; } -/** - * Utility macro that wraps `std::enable_if` to make it a bit easier to use and less verbose for - * SFINAE in common cases. - * - * \note Often one has to invoke this macro with double parenthesis. That's because the condition - * often contains a comma and angle brackets are not recognized as parenthesis by the preprocessor. - */ -#define BLI_ENABLE_IF(condition) typename std::enable_if_t<condition> * = nullptr - } // namespace blender diff --git a/source/blender/blenlib/BLI_mesh_intersect.hh b/source/blender/blenlib/BLI_mesh_intersect.hh index 71a8abb822f..0ebee6f16a8 100644 --- a/source/blender/blenlib/BLI_mesh_intersect.hh +++ b/source/blender/blenlib/BLI_mesh_intersect.hh @@ -28,12 +28,11 @@ # include <iostream> # include "BLI_array.hh" -# include "BLI_double3.hh" -# include "BLI_float3.hh" # include "BLI_index_range.hh" # include "BLI_map.hh" # include "BLI_math_mpq.hh" -# include "BLI_mpq3.hh" +# include "BLI_math_vec_mpq_types.hh" +# include "BLI_math_vec_types.hh" # include "BLI_span.hh" # include "BLI_utility_mixins.hh" # include "BLI_vector.hh" diff --git a/source/blender/blenlib/BLI_mpq2.hh b/source/blender/blenlib/BLI_mpq2.hh deleted file mode 100644 index 18bc8821d9c..00000000000 --- a/source/blender/blenlib/BLI_mpq2.hh +++ /dev/null @@ -1,184 +0,0 @@ -/* - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ - -#pragma once - -/** \file - * \ingroup bli - */ - -#ifdef WITH_GMP - -# include "BLI_math_mpq.hh" -# include "BLI_mpq3.hh" - -namespace blender { - -struct mpq2 { - mpq_class x, y; - - mpq2() = default; - - mpq2(const mpq_class *ptr) : x{ptr[0]}, y{ptr[1]} - { - } - - mpq2(mpq_class x, mpq_class y) : x(x), y(y) - { - } - - mpq2(const mpq2 &other) : x(other.x), y(other.y) - { - } - - mpq2(mpq2 &&other) noexcept : x(std::move(other.x)), y(std::move(other.y)) - { - } - - ~mpq2() = default; - - mpq2 &operator=(const mpq2 &other) - { - if (this != &other) { - x = other.x; - y = other.y; - } - return *this; - } - - mpq2 &operator=(mpq2 &&other) noexcept - { - x = std::move(other.x); - y = std::move(other.y); - return *this; - } - - mpq2(const mpq3 &other) : x(other.x), y(other.y) - { - } - - operator mpq_class *() - { - return &x; - } - - operator const mpq_class *() const - { - return &x; - } - - /** - * Cannot do this exactly in rational arithmetic! - * Approximate by going in and out of doubles. - */ - mpq_class length() const - { - mpq_class lsquared = dot(*this, *this); - return mpq_class(sqrt(lsquared.get_d())); - } - - friend mpq2 operator+(const mpq2 &a, const mpq2 &b) - { - return {a.x + b.x, a.y + b.y}; - } - - friend mpq2 operator-(const mpq2 &a, const mpq2 &b) - { - return {a.x - b.x, a.y - b.y}; - } - - friend mpq2 operator*(const mpq2 &a, mpq_class b) - { - return {a.x * b, a.y * b}; - } - - friend mpq2 operator/(const mpq2 &a, mpq_class b) - { - BLI_assert(b != 0); - return {a.x / b, a.y / b}; - } - - friend mpq2 operator*(mpq_class a, const mpq2 &b) - { - return b * a; - } - - friend bool operator==(const mpq2 &a, const mpq2 &b) - { - return a.x == b.x && a.y == b.y; - } - - friend bool operator!=(const mpq2 &a, const mpq2 &b) - { - return a.x != b.x || a.y != b.y; - } - - friend std::ostream &operator<<(std::ostream &stream, const mpq2 &v) - { - stream << "(" << v.x << ", " << v.y << ")"; - return stream; - } - - static mpq_class dot(const mpq2 &a, const mpq2 &b) - { - return a.x * b.x + a.y * b.y; - } - - static mpq2 interpolate(const mpq2 &a, const mpq2 &b, mpq_class t) - { - return a * (1 - t) + b * t; - } - - static mpq2 abs(const mpq2 &a) - { - mpq_class abs_x = (a.x >= 0) ? a.x : -a.x; - mpq_class abs_y = (a.y >= 0) ? a.y : -a.y; - return mpq2(abs_x, abs_y); - } - - static mpq_class distance(const mpq2 &a, const mpq2 &b) - { - return (a - b).length(); - } - - static mpq_class distance_squared(const mpq2 &a, const mpq2 &b) - { - mpq2 diff = a - b; - return dot(diff, diff); - } - - struct isect_result { - enum { - LINE_LINE_COLINEAR = -1, - LINE_LINE_NONE = 0, - LINE_LINE_EXACT = 1, - LINE_LINE_CROSS = 2, - } kind; - mpq_class lambda; - }; - - static isect_result isect_seg_seg(const mpq2 &v1, - const mpq2 &v2, - const mpq2 &v3, - const mpq2 &v4); - - /** There is a sensible use for hashing on exact arithmetic types. */ - uint64_t hash() const; -}; - -} // namespace blender - -#endif /* WITH_GMP */ diff --git a/source/blender/blenlib/BLI_mpq3.hh b/source/blender/blenlib/BLI_mpq3.hh deleted file mode 100644 index b9eda2ad7e1..00000000000 --- a/source/blender/blenlib/BLI_mpq3.hh +++ /dev/null @@ -1,297 +0,0 @@ -/* - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - */ - -#pragma once - -/** \file - * \ingroup bli - */ - -#ifdef WITH_GMP - -# include <iostream> - -# include "BLI_math.h" -# include "BLI_math_mpq.hh" -# include "BLI_span.hh" - -namespace blender { - -struct mpq3 { - mpq_class x, y, z; - - mpq3() = default; - - mpq3(const mpq_class *ptr) : x{ptr[0]}, y{ptr[1]}, z{ptr[2]} - { - } - - mpq3(const mpq_class (*ptr)[3]) : mpq3((const mpq_class *)ptr) - { - } - - explicit mpq3(mpq_class value) : x(value), y(value), z(value) - { - } - - explicit mpq3(int value) : x(value), y(value), z(value) - { - } - - mpq3(mpq_class x, mpq_class y, mpq_class z) : x{x}, y{y}, z{z} - { - } - - operator const mpq_class *() const - { - return &x; - } - - operator mpq_class *() - { - return &x; - } - - /* Cannot do this exactly in rational arithmetic! - * Approximate by going in and out of doubles. - */ - mpq_class normalize_and_get_length() - { - double dv[3] = {x.get_d(), y.get_d(), z.get_d()}; - double len = normalize_v3_db(dv); - this->x = mpq_class(dv[0]); - this->y = mpq_class(dv[1]); - this->z = mpq_class(dv[2]); - return len; - } - - mpq3 normalized() const - { - double dv[3] = {x.get_d(), y.get_d(), z.get_d()}; - double dr[3]; - normalize_v3_v3_db(dr, dv); - return mpq3(mpq_class(dr[0]), mpq_class(dr[1]), mpq_class(dr[2])); - } - - /* Cannot do this exactly in rational arithmetic! - * Approximate by going in and out of double. - */ - mpq_class length() const - { - mpq_class lsquared = this->length_squared(); - double dsquared = lsquared.get_d(); - double d = sqrt(dsquared); - return mpq_class(d); - } - - mpq_class length_squared() const - { - return x * x + y * y + z * z; - } - - void reflect(const mpq3 &normal) - { - *this = this->reflected(normal); - } - - mpq3 reflected(const mpq3 &normal) const - { - mpq3 result; - const mpq_class dot2 = 2 * dot(*this, normal); - result.x = this->x - (dot2 * normal.x); - result.y = this->y - (dot2 * normal.y); - result.z = this->z - (dot2 * normal.z); - return result; - } - - static mpq3 safe_divide(const mpq3 &a, const mpq3 &b) - { - mpq3 result; - result.x = (b.x == 0) ? mpq_class(0) : a.x / b.x; - result.y = (b.y == 0) ? mpq_class(0) : a.y / b.y; - result.z = (b.z == 0) ? mpq_class(0) : a.z / b.z; - return result; - } - - void invert() - { - x = -x; - y = -y; - z = -z; - } - - friend mpq3 operator+(const mpq3 &a, const mpq3 &b) - { - return mpq3(a.x + b.x, a.y + b.y, a.z + b.z); - } - - void operator+=(const mpq3 &b) - { - this->x += b.x; - this->y += b.y; - this->z += b.z; - } - - friend mpq3 operator-(const mpq3 &a, const mpq3 &b) - { - return mpq3(a.x - b.x, a.y - b.y, a.z - b.z); - } - - friend mpq3 operator-(const mpq3 &a) - { - return mpq3(-a.x, -a.y, -a.z); - } - - void operator-=(const mpq3 &b) - { - this->x -= b.x; - this->y -= b.y; - this->z -= b.z; - } - - void operator*=(mpq_class scalar) - { - this->x *= scalar; - this->y *= scalar; - this->z *= scalar; - } - - void operator*=(const mpq3 &other) - { - this->x *= other.x; - this->y *= other.y; - this->z *= other.z; - } - - friend mpq3 operator*(const mpq3 &a, const mpq3 &b) - { - return {a.x * b.x, a.y * b.y, a.z * b.z}; - } - - friend mpq3 operator*(const mpq3 &a, const mpq_class &b) - { - return mpq3(a.x * b, a.y * b, a.z * b); - } - - friend mpq3 operator*(const mpq_class &a, const mpq3 &b) - { - return mpq3(a * b.x, a * b.y, a * b.z); - } - - friend mpq3 operator/(const mpq3 &a, const mpq_class &b) - { - BLI_assert(b != 0); - return mpq3(a.x / b, a.y / b, a.z / b); - } - - friend bool operator==(const mpq3 &a, const mpq3 &b) - { - return a.x == b.x && a.y == b.y && a.z == b.z; - } - - friend bool operator!=(const mpq3 &a, const mpq3 &b) - { - return a.x != b.x || a.y != b.y || a.z != b.z; - } - - friend std::ostream &operator<<(std::ostream &stream, const mpq3 &v) - { - stream << "(" << v.x << ", " << v.y << ", " << v.z << ")"; - return stream; - } - - static mpq_class dot(const mpq3 &a, const mpq3 &b) - { - return a.x * b.x + a.y * b.y + a.z * b.z; - } - - static mpq_class dot_with_buffer(const mpq3 &a, const mpq3 &b, mpq3 &buffer) - { - buffer = a; - buffer *= b; - buffer.x += buffer.y; - buffer.x += buffer.z; - return buffer.x; - } - - static mpq3 cross(const mpq3 &a, const mpq3 &b) - { - return mpq3(a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]); - } - - static mpq3 cross_high_precision(const mpq3 &a, const mpq3 &b) - { - return cross(a, b); - } - - static mpq3 project(const mpq3 &a, const mpq3 &b) - { - const mpq_class mul = mpq3::dot(a, b) / mpq3::dot(b, b); - return mpq3(mul * b[0], mul * b[1], mul * b[2]); - } - - static mpq_class distance(const mpq3 &a, const mpq3 &b) - { - mpq3 diff(a.x - b.x, a.y - b.y, a.z - b.z); - return diff.length(); - } - - static mpq_class distance_squared(const mpq3 &a, const mpq3 &b) - { - mpq3 diff(a.x - b.x, a.y - b.y, a.z - b.z); - return mpq3::dot(diff, diff); - } - - static mpq_class distance_squared_with_buffer(const mpq3 &a, const mpq3 &b, mpq3 &buffer) - { - buffer = a; - buffer -= b; - return mpq3::dot(buffer, buffer); - } - - static mpq3 interpolate(const mpq3 &a, const mpq3 &b, mpq_class t) - { - mpq_class s = 1 - t; - return mpq3(a.x * s + b.x * t, a.y * s + b.y * t, a.z * s + b.z * t); - } - - static mpq3 abs(const mpq3 &a) - { - mpq_class abs_x = (a.x >= 0) ? a.x : -a.x; - mpq_class abs_y = (a.y >= 0) ? a.y : -a.y; - mpq_class abs_z = (a.z >= 0) ? a.z : -a.z; - return mpq3(abs_x, abs_y, abs_z); - } - - static int dominant_axis(const mpq3 &a) - { - mpq_class x = (a.x >= 0) ? a.x : -a.x; - mpq_class y = (a.y >= 0) ? a.y : -a.y; - mpq_class z = (a.z >= 0) ? a.z : -a.z; - return ((x > y) ? ((x > z) ? 0 : 2) : ((y > z) ? 1 : 2)); - } - - static mpq3 cross_poly(Span<mpq3> poly); - - /** There is a sensible use for hashing on exact arithmetic types. */ - uint64_t hash() const; -}; - -uint64_t hash_mpq_class(const mpq_class &value); - -} // namespace blender - -#endif /* WITH_GMP */ diff --git a/source/blender/blenlib/BLI_noise.hh b/source/blender/blenlib/BLI_noise.hh index 4f68ef17ca2..297c65c250a 100644 --- a/source/blender/blenlib/BLI_noise.hh +++ b/source/blender/blenlib/BLI_noise.hh @@ -16,9 +16,7 @@ #pragma once -#include "BLI_float2.hh" -#include "BLI_float3.hh" -#include "BLI_float4.hh" +#include "BLI_math_vec_types.hh" namespace blender::noise { diff --git a/source/blender/blenlib/BLI_rand.hh b/source/blender/blenlib/BLI_rand.hh index cc9e9b374d7..667d6df8996 100644 --- a/source/blender/blenlib/BLI_rand.hh +++ b/source/blender/blenlib/BLI_rand.hh @@ -20,9 +20,8 @@ #pragma once -#include "BLI_float2.hh" -#include "BLI_float3.hh" #include "BLI_math.h" +#include "BLI_math_vec_types.hh" #include "BLI_span.hh" #include "BLI_utildefines.h" diff --git a/source/blender/blenlib/BLI_utildefines.h b/source/blender/blenlib/BLI_utildefines.h index 35d4158de59..c4b31810669 100644 --- a/source/blender/blenlib/BLI_utildefines.h +++ b/source/blender/blenlib/BLI_utildefines.h @@ -840,6 +840,15 @@ extern bool BLI_memory_is_zero(const void *arr, size_t arr_size); /** No-op for expressions we don't want to instantiate, but must remain valid. */ #define EXPR_NOP(expr) (void)(0 ? ((void)(expr), 1) : 0) +/** + * Utility macro that wraps `std::enable_if` to make it a bit easier to use and less verbose for + * SFINAE in common cases. + * + * \note Often one has to invoke this macro with double parenthesis. That's because the condition + * often contains a comma and angle brackets are not recognized as parenthesis by the preprocessor. + */ +#define BLI_ENABLE_IF(condition) typename std::enable_if_t<(condition)> * = nullptr + /** \} */ #ifdef __cplusplus diff --git a/source/blender/blenlib/CMakeLists.txt b/source/blender/blenlib/CMakeLists.txt index 3958fd8e2d2..90c6760019a 100644 --- a/source/blender/blenlib/CMakeLists.txt +++ b/source/blender/blenlib/CMakeLists.txt @@ -192,8 +192,6 @@ set(SRC BLI_dlrbTree.h BLI_dot_export.hh BLI_dot_export_attribute_enums.hh - BLI_double2.hh - BLI_double3.hh BLI_dynlib.h BLI_dynstr.h BLI_easing.h @@ -207,9 +205,6 @@ set(SRC BLI_fileops.hh BLI_fileops_types.h BLI_filereader.h - BLI_float2.hh - BLI_float3.hh - BLI_float4.hh BLI_float4x4.hh BLI_fnmatch.h BLI_function_ref.hh @@ -258,6 +253,8 @@ set(SRC BLI_math_statistics.h BLI_math_time.h BLI_math_vector.h + BLI_math_vec_types.hh + BLI_math_vec_mpq_types.hh BLI_memarena.h BLI_memblock.h BLI_memiter.h @@ -267,8 +264,6 @@ set(SRC BLI_mesh_boolean.hh BLI_mesh_intersect.hh BLI_mmap.h - BLI_mpq2.hh - BLI_mpq3.hh BLI_multi_value_map.hh BLI_noise.h BLI_noise.hh @@ -444,6 +439,7 @@ if(WITH_GTESTS) tests/BLI_math_rotation_test.cc tests/BLI_math_solvers_test.cc tests/BLI_math_time_test.cc + tests/BLI_math_vec_types_test.cc tests/BLI_math_vector_test.cc tests/BLI_memiter_test.cc tests/BLI_memory_utils_test.cc diff --git a/source/blender/blenlib/intern/delaunay_2d.cc b/source/blender/blenlib/intern/delaunay_2d.cc index 53e881a9fc7..842e6cb6135 100644 --- a/source/blender/blenlib/intern/delaunay_2d.cc +++ b/source/blender/blenlib/intern/delaunay_2d.cc @@ -25,11 +25,10 @@ #include <sstream> #include "BLI_array.hh" -#include "BLI_double2.hh" #include "BLI_linklist.h" #include "BLI_math_boolean.hh" #include "BLI_math_mpq.hh" -#include "BLI_mpq2.hh" +#include "BLI_math_vec_mpq_types.hh" #include "BLI_set.hh" #include "BLI_task.hh" #include "BLI_vector.hh" @@ -38,6 +37,8 @@ namespace blender::meshintersect { +using namespace blender::math; + /* Throughout this file, template argument T will be an * arithmetic-like type, like float, double, or mpq_class. */ @@ -788,11 +789,11 @@ bool in_line<mpq_class>(const FatCo<mpq_class> &a, } vec2<mpq_class> exact_ab = b.exact - a.exact; vec2<mpq_class> exact_ac = c.exact - a.exact; - if (vec2<mpq_class>::dot(exact_ab, exact_ac) < 0) { + if (dot(exact_ab, exact_ac) < 0) { return false; } vec2<mpq_class> exact_bc = c.exact - b.exact; - return vec2<mpq_class>::dot(exact_bc, exact_ac) >= 0; + return dot(exact_bc, exact_ac) >= 0; } #endif @@ -801,11 +802,11 @@ bool in_line<double>(const FatCo<double> &a, const FatCo<double> &b, const FatCo { vec2<double> ab = b.approx - a.approx; vec2<double> ac = c.approx - a.approx; - if (vec2<double>::dot(ab, ac) < 0) { + if (dot(ab, ac) < 0) { return false; } vec2<double> bc = c.approx - b.approx; - return vec2<double>::dot(bc, ac) >= 0; + return dot(bc, ac) >= 0; } template<> CDTVert<double>::CDTVert(const vec2<double> &pt) @@ -1081,7 +1082,7 @@ template<typename T> CDTEdge<T> *CDTArrangement<T>::split_edge(SymEdge<T> *se, T SymEdge<T> *sesymprev = prev(sesym); SymEdge<T> *sesymprevsym = sym(sesymprev); SymEdge<T> *senext = se->next; - CDTVert<T> *v = this->add_vert(vec2<T>::interpolate(*a, *b, lambda)); + CDTVert<T> *v = this->add_vert(interpolate(*a, *b, lambda)); CDTEdge<T> *e = this->add_edge(v, se->next->vert, se->face, sesym->face); sesym->vert = v; SymEdge<T> *newse = &e->symedges[0]; @@ -1704,16 +1705,16 @@ void fill_crossdata_for_intersect(const FatCo<T> &curco, BLI_assert(se_vcva->vert == vc && se_vcva->next->vert == va); BLI_assert(se_vcvb->vert == vc && se_vcvb->next->vert == vb); UNUSED_VARS_NDEBUG(vc); - auto isect = vec2<T>::isect_seg_seg(va->co.exact, vb->co.exact, curco.exact, v2->co.exact); + auto isect = isect_seg_seg<vec2<T>>(va->co.exact, vb->co.exact, curco.exact, v2->co.exact); T &lambda = isect.lambda; switch (isect.kind) { - case vec2<T>::isect_result::LINE_LINE_CROSS: { + case isect_result<vec2<T>>::LINE_LINE_CROSS: { #ifdef WITH_GMP if (!std::is_same<T, mpq_class>::value) { #else if (true) { #endif - double len_ab = vec2<double>::distance(va->co.approx, vb->co.approx); + double len_ab = distance(va->co.approx, vb->co.approx); if (lambda * len_ab <= epsilon) { fill_crossdata_for_through_vert(va, se_vcva, cd, cd_next); } @@ -1735,7 +1736,7 @@ void fill_crossdata_for_intersect(const FatCo<T> &curco, } break; } - case vec2<T>::isect_result::LINE_LINE_EXACT: { + case isect_result<vec2<T>>::LINE_LINE_EXACT: { if (lambda == 0) { fill_crossdata_for_through_vert(va, se_vcva, cd, cd_next); } @@ -1750,7 +1751,7 @@ void fill_crossdata_for_intersect(const FatCo<T> &curco, } break; } - case vec2<T>::isect_result::LINE_LINE_NONE: { + case isect_result<vec2<T>>::LINE_LINE_NONE: { #ifdef WITH_GMP if (std::is_same<T, mpq_class>::value) { BLI_assert(false); @@ -1766,9 +1767,9 @@ void fill_crossdata_for_intersect(const FatCo<T> &curco, } break; } - case vec2<T>::isect_result::LINE_LINE_COLINEAR: { - if (vec2<double>::distance_squared(va->co.approx, v2->co.approx) <= - vec2<double>::distance_squared(vb->co.approx, v2->co.approx)) { + case isect_result<vec2<T>>::LINE_LINE_COLINEAR: { + if (distance_squared(va->co.approx, v2->co.approx) <= + distance_squared(vb->co.approx, v2->co.approx)) { fill_crossdata_for_through_vert(va, se_vcva, cd, cd_next); } else { @@ -1845,7 +1846,7 @@ void get_next_crossing_from_edge(CrossData<T> *cd, { CDTVert<T> *va = cd->in->vert; CDTVert<T> *vb = cd->in->next->vert; - vec2<T> curco = vec2<T>::interpolate(va->co.exact, vb->co.exact, cd->lambda); + vec2<T> curco = interpolate(va->co.exact, vb->co.exact, cd->lambda); FatCo<T> fat_curco(curco); SymEdge<T> *se_ac = sym(cd->in)->next; CDTVert<T> *vc = se_ac->next->vert; @@ -2386,7 +2387,7 @@ template<typename T> void remove_non_constraint_edges_leave_valid_bmesh(CDT_stat dissolvable_edges[i].e = e; const vec2<double> &co1 = e->symedges[0].vert->co.approx; const vec2<double> &co2 = e->symedges[1].vert->co.approx; - dissolvable_edges[i].len_squared = vec2<double>::distance_squared(co1, co2); + dissolvable_edges[i].len_squared = distance_squared(co1, co2); i++; } } @@ -2569,18 +2570,18 @@ template<typename T> void detect_holes(CDT_state<T> *cdt_state) if (e->symedges[0].face->visit_index == e->symedges[1].face->visit_index) { continue; /* Don't count hits on edges between faces in same region. */ } - auto isect = vec2<T>::isect_seg_seg(ray_end.exact, + auto isect = isect_seg_seg<vec2<T>>(ray_end.exact, mid.exact, e->symedges[0].vert->co.exact, e->symedges[1].vert->co.exact); switch (isect.kind) { - case vec2<T>::isect_result::LINE_LINE_CROSS: { + case isect_result<vec2<T>>::LINE_LINE_CROSS: { hits++; break; } - case vec2<T>::isect_result::LINE_LINE_EXACT: - case vec2<T>::isect_result::LINE_LINE_NONE: - case vec2<T>::isect_result::LINE_LINE_COLINEAR: + case isect_result<vec2<T>>::LINE_LINE_EXACT: + case isect_result<vec2<T>>::LINE_LINE_NONE: + case isect_result<vec2<T>>::LINE_LINE_COLINEAR: break; } } diff --git a/source/blender/blenlib/intern/math_boolean.cc b/source/blender/blenlib/intern/math_boolean.cc index c16755868aa..0bae3c23f79 100644 --- a/source/blender/blenlib/intern/math_boolean.cc +++ b/source/blender/blenlib/intern/math_boolean.cc @@ -18,15 +18,10 @@ * \ingroup bli */ -#include "BLI_double2.hh" -#include "BLI_double3.hh" -#include "BLI_float2.hh" -#include "BLI_float3.hh" #include "BLI_hash.hh" #include "BLI_math_boolean.hh" #include "BLI_math_mpq.hh" -#include "BLI_mpq2.hh" -#include "BLI_mpq3.hh" +#include "BLI_math_vec_types.hh" #include "BLI_span.hh" #include "BLI_utildefines.h" diff --git a/source/blender/blenlib/intern/math_vec.cc b/source/blender/blenlib/intern/math_vec.cc index 223c0e273f0..6fab6c9a383 100644 --- a/source/blender/blenlib/intern/math_vec.cc +++ b/source/blender/blenlib/intern/math_vec.cc @@ -18,89 +18,83 @@ * \ingroup bli */ -#include "BLI_double2.hh" -#include "BLI_double3.hh" -#include "BLI_float2.hh" -#include "BLI_float3.hh" #include "BLI_hash.hh" -#include "BLI_math_mpq.hh" -#include "BLI_mpq2.hh" -#include "BLI_mpq3.hh" +#include "BLI_math_vec_mpq_types.hh" +#include "BLI_math_vector.hh" #include "BLI_span.hh" #include "BLI_utildefines.h" -namespace blender { +namespace blender::math { -float2::isect_result float2::isect_seg_seg(const float2 &v1, - const float2 &v2, - const float2 &v3, - const float2 &v4) +template<> +isect_result<float2> isect_seg_seg(const float2 &v1, + const float2 &v2, + const float2 &v3, + const float2 &v4) { - float2::isect_result ans; + isect_result<float2> ans; float div = (v2[0] - v1[0]) * (v4[1] - v3[1]) - (v2[1] - v1[1]) * (v4[0] - v3[0]); if (div == 0.0f) { ans.lambda = 0.0f; - ans.mu = 0.0f; - ans.kind = float2::isect_result::LINE_LINE_COLINEAR; + ans.kind = isect_result<float2>::LINE_LINE_COLINEAR; } else { ans.lambda = ((v1[1] - v3[1]) * (v4[0] - v3[0]) - (v1[0] - v3[0]) * (v4[1] - v3[1])) / div; - ans.mu = ((v1[1] - v3[1]) * (v2[0] - v1[0]) - (v1[0] - v3[0]) * (v2[1] - v1[1])) / div; - if (ans.lambda >= 0.0f && ans.lambda <= 1.0f && ans.mu >= 0.0f && ans.mu <= 1.0f) { - if (ans.lambda == 0.0f || ans.lambda == 1.0f || ans.mu == 0.0f || ans.mu == 1.0f) { - ans.kind = float2::isect_result::LINE_LINE_EXACT; + float mu = ((v1[1] - v3[1]) * (v2[0] - v1[0]) - (v1[0] - v3[0]) * (v2[1] - v1[1])) / div; + if (ans.lambda >= 0.0f && ans.lambda <= 1.0f && mu >= 0.0f && mu <= 1.0f) { + if (ans.lambda == 0.0f || ans.lambda == 1.0f || mu == 0.0f || mu == 1.0f) { + ans.kind = isect_result<float2>::LINE_LINE_EXACT; } else { - ans.kind = float2::isect_result::LINE_LINE_CROSS; + ans.kind = isect_result<float2>::LINE_LINE_CROSS; } } else { - ans.kind = float2::isect_result::LINE_LINE_NONE; + ans.kind = isect_result<float2>::LINE_LINE_NONE; } } return ans; } -double2::isect_result double2::isect_seg_seg(const double2 &v1, - const double2 &v2, - const double2 &v3, - const double2 &v4) +template<> +isect_result<double2> isect_seg_seg(const double2 &v1, + const double2 &v2, + const double2 &v3, + const double2 &v4) { - double2::isect_result ans; + isect_result<double2> ans; double div = (v2[0] - v1[0]) * (v4[1] - v3[1]) - (v2[1] - v1[1]) * (v4[0] - v3[0]); if (div == 0.0) { ans.lambda = 0.0; - ans.kind = double2::isect_result::LINE_LINE_COLINEAR; + ans.kind = isect_result<double2>::LINE_LINE_COLINEAR; } else { ans.lambda = ((v1[1] - v3[1]) * (v4[0] - v3[0]) - (v1[0] - v3[0]) * (v4[1] - v3[1])) / div; double mu = ((v1[1] - v3[1]) * (v2[0] - v1[0]) - (v1[0] - v3[0]) * (v2[1] - v1[1])) / div; if (ans.lambda >= 0.0 && ans.lambda <= 1.0 && mu >= 0.0 && mu <= 1.0) { if (ans.lambda == 0.0 || ans.lambda == 1.0 || mu == 0.0 || mu == 1.0) { - ans.kind = double2::isect_result::LINE_LINE_EXACT; + ans.kind = isect_result<double2>::LINE_LINE_EXACT; } else { - ans.kind = double2::isect_result::LINE_LINE_CROSS; + ans.kind = isect_result<double2>::LINE_LINE_CROSS; } } else { - ans.kind = double2::isect_result::LINE_LINE_NONE; + ans.kind = isect_result<double2>::LINE_LINE_NONE; } } return ans; } #ifdef WITH_GMP -mpq2::isect_result mpq2::isect_seg_seg(const mpq2 &v1, - const mpq2 &v2, - const mpq2 &v3, - const mpq2 &v4) +template<> +isect_result<mpq2> isect_seg_seg(const mpq2 &v1, const mpq2 &v2, const mpq2 &v3, const mpq2 &v4) { - mpq2::isect_result ans; + isect_result<mpq2> ans; mpq_class div = (v2[0] - v1[0]) * (v4[1] - v3[1]) - (v2[1] - v1[1]) * (v4[0] - v3[0]); if (div == 0.0) { ans.lambda = 0.0; - ans.kind = mpq2::isect_result::LINE_LINE_COLINEAR; + ans.kind = isect_result<mpq2>::LINE_LINE_COLINEAR; } else { ans.lambda = ((v1[1] - v3[1]) * (v4[0] - v3[0]) - (v1[0] - v3[0]) * (v4[1] - v3[1])) / div; @@ -109,66 +103,21 @@ mpq2::isect_result mpq2::isect_seg_seg(const mpq2 &v1, if (ans.lambda >= 0 && ans.lambda <= 1 && ((div > 0 && mudiv >= 0 && mudiv <= div) || (div < 0 && mudiv <= 0 && mudiv >= div))) { if (ans.lambda == 0 || ans.lambda == 1 || mudiv == 0 || mudiv == div) { - ans.kind = mpq2::isect_result::LINE_LINE_EXACT; + ans.kind = isect_result<mpq2>::LINE_LINE_EXACT; } else { - ans.kind = mpq2::isect_result::LINE_LINE_CROSS; + ans.kind = isect_result<mpq2>::LINE_LINE_CROSS; } } else { - ans.kind = mpq2::isect_result::LINE_LINE_NONE; + ans.kind = isect_result<mpq2>::LINE_LINE_NONE; } } return ans; } #endif -double3 double3::cross_poly(Span<double3> poly) -{ - /* Newell's Method. */ - int nv = static_cast<int>(poly.size()); - if (nv < 3) { - return double3(0, 0, 0); - } - const double3 *v_prev = &poly[nv - 1]; - const double3 *v_curr = &poly[0]; - double3 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]); - n[2] = n[2] + ((*v_prev)[0] - (*v_curr)[0]) * ((*v_prev)[1] + (*v_curr)[1]); - v_prev = v_curr; - ++i; - if (i < nv) { - v_curr = &poly[i]; - } - } - return n; -} - #ifdef WITH_GMP -mpq3 mpq3::cross_poly(Span<mpq3> poly) -{ - /* Newell's Method. */ - int nv = static_cast<int>(poly.size()); - if (nv < 3) { - return mpq3(0); - } - const mpq3 *v_prev = &poly[nv - 1]; - const mpq3 *v_curr = &poly[0]; - mpq3 n(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]); - n[2] = n[2] + ((*v_prev)[0] - (*v_curr)[0]) * ((*v_prev)[1] + (*v_curr)[1]); - v_prev = v_curr; - ++i; - if (i < nv) { - v_curr = &poly[i]; - } - } - return n; -} uint64_t hash_mpq_class(const mpq_class &value) { @@ -176,20 +125,6 @@ uint64_t hash_mpq_class(const mpq_class &value) return get_default_hash(static_cast<float>(value.get_d())); } -uint64_t mpq2::hash() const -{ - uint64_t hashx = hash_mpq_class(this->x); - uint64_t hashy = hash_mpq_class(this->y); - return hashx ^ (hashy * 33); -} - -uint64_t mpq3::hash() const -{ - uint64_t hashx = hash_mpq_class(this->x); - uint64_t hashy = hash_mpq_class(this->y); - uint64_t hashz = hash_mpq_class(this->z); - return hashx ^ (hashy * 33) ^ (hashz * 33 * 37); -} #endif -} // namespace blender +} // namespace blender::math diff --git a/source/blender/blenlib/intern/mesh_boolean.cc b/source/blender/blenlib/intern/mesh_boolean.cc index ce4db0c6b9d..a3eae1896d3 100644 --- a/source/blender/blenlib/intern/mesh_boolean.cc +++ b/source/blender/blenlib/intern/mesh_boolean.cc @@ -28,8 +28,6 @@ # include "BLI_array.hh" # include "BLI_assert.h" # include "BLI_delaunay_2d.h" -# include "BLI_double3.hh" -# include "BLI_float3.hh" # include "BLI_hash.hh" # include "BLI_kdopbvh.h" # include "BLI_map.hh" @@ -37,8 +35,9 @@ # include "BLI_math_boolean.hh" # include "BLI_math_geom.h" # include "BLI_math_mpq.hh" +# include "BLI_math_vec_mpq_types.hh" +# include "BLI_math_vec_types.hh" # include "BLI_mesh_intersect.hh" -# include "BLI_mpq3.hh" # include "BLI_set.hh" # include "BLI_span.hh" # include "BLI_stack.hh" @@ -1633,13 +1632,13 @@ static Edge find_good_sorting_edge(const Vert *testp, ordinate[axis_next] = -abscissa[axis]; ordinate[axis_next_next] = 0; /* By construction, dot(abscissa, ordinate) == 0, so they are perpendicular. */ - mpq3 normal = mpq3::cross(abscissa, ordinate); + mpq3 normal = math::cross(abscissa, ordinate); if (dbg_level > 0) { std::cout << "abscissa = " << abscissa << "\n"; std::cout << "ordinate = " << ordinate << "\n"; std::cout << "normal = " << normal << "\n"; } - mpq_class nlen2 = normal.length_squared(); + mpq_class nlen2 = math::length_squared(normal); mpq_class max_abs_slope = -1; Edge esort; const Vector<Edge> &edges = tmtopo.vert_edges(closestp); @@ -1648,12 +1647,12 @@ static Edge find_good_sorting_edge(const Vert *testp, const mpq3 &co_other = v_other->co_exact; mpq3 evec = co_other - co_closest; /* Get projection of evec onto plane of abscissa and ordinate. */ - mpq3 proj_evec = evec - (mpq3::dot(evec, normal) / nlen2) * normal; + mpq3 proj_evec = evec - (math::dot(evec, normal) / nlen2) * normal; /* The projection calculations along the abscissa and ordinate should * be scaled by 1/abscissa and 1/ordinate respectively, * but we can skip: it won't affect which `evec` has the maximum slope. */ - mpq_class evec_a = mpq3::dot(proj_evec, abscissa); - mpq_class evec_o = mpq3::dot(proj_evec, ordinate); + mpq_class evec_a = math::dot(proj_evec, abscissa); + mpq_class evec_o = math::dot(proj_evec, ordinate); if (dbg_level > 0) { std::cout << "e = " << e << "\n"; std::cout << "v_other = " << v_other << "\n"; @@ -1791,8 +1790,8 @@ static mpq_class closest_on_tri_to_point(const mpq3 &p, ap = p; ap -= a; - mpq_class d1 = mpq3::dot_with_buffer(ab, ap, m); - mpq_class d2 = mpq3::dot_with_buffer(ac, ap, m); + mpq_class d1 = math::dot_with_buffer(ab, ap, m); + mpq_class d2 = math::dot_with_buffer(ac, ap, m); if (d1 <= 0 && d2 <= 0) { /* Barycentric coordinates (1,0,0). */ *r_edge = -1; @@ -1800,13 +1799,13 @@ static mpq_class closest_on_tri_to_point(const mpq3 &p, if (dbg_level > 0) { std::cout << " answer = a\n"; } - return mpq3::distance_squared_with_buffer(p, a, m); + return math::distance_squared_with_buffer(p, a, m); } /* Check if p in vertex region outside b. */ bp = p; bp -= b; - mpq_class d3 = mpq3::dot_with_buffer(ab, bp, m); - mpq_class d4 = mpq3::dot_with_buffer(ac, bp, m); + mpq_class d3 = math::dot_with_buffer(ab, bp, m); + mpq_class d4 = math::dot_with_buffer(ac, bp, m); if (d3 >= 0 && d4 <= d3) { /* Barycentric coordinates (0,1,0). */ *r_edge = -1; @@ -1814,7 +1813,7 @@ static mpq_class closest_on_tri_to_point(const mpq3 &p, if (dbg_level > 0) { std::cout << " answer = b\n"; } - return mpq3::distance_squared_with_buffer(p, b, m); + return math::distance_squared_with_buffer(p, b, m); } /* Check if p in region of ab. */ mpq_class vc = d1 * d4 - d3 * d2; @@ -1829,13 +1828,13 @@ static mpq_class closest_on_tri_to_point(const mpq3 &p, if (dbg_level > 0) { std::cout << " answer = on ab at " << r << "\n"; } - return mpq3::distance_squared_with_buffer(p, r, m); + return math::distance_squared_with_buffer(p, r, m); } /* Check if p in vertex region outside c. */ cp = p; cp -= c; - mpq_class d5 = mpq3::dot_with_buffer(ab, cp, m); - mpq_class d6 = mpq3::dot_with_buffer(ac, cp, m); + mpq_class d5 = math::dot_with_buffer(ab, cp, m); + mpq_class d6 = math::dot_with_buffer(ac, cp, m); if (d6 >= 0 && d5 <= d6) { /* Barycentric coordinates (0,0,1). */ *r_edge = -1; @@ -1843,7 +1842,7 @@ static mpq_class closest_on_tri_to_point(const mpq3 &p, if (dbg_level > 0) { std::cout << " answer = c\n"; } - return mpq3::distance_squared_with_buffer(p, c, m); + return math::distance_squared_with_buffer(p, c, m); } /* Check if p in edge region of ac. */ mpq_class vb = d5 * d2 - d1 * d6; @@ -1858,7 +1857,7 @@ static mpq_class closest_on_tri_to_point(const mpq3 &p, if (dbg_level > 0) { std::cout << " answer = on ac at " << r << "\n"; } - return mpq3::distance_squared_with_buffer(p, r, m); + return math::distance_squared_with_buffer(p, r, m); } /* Check if p in edge region of bc. */ mpq_class va = d3 * d6 - d5 * d4; @@ -1874,7 +1873,7 @@ static mpq_class closest_on_tri_to_point(const mpq3 &p, if (dbg_level > 0) { std::cout << " answer = on bc at " << r << "\n"; } - return mpq3::distance_squared_with_buffer(p, r, m); + return math::distance_squared_with_buffer(p, r, m); } /* p inside face region. Compute barycentric coordinates (u,v,w). */ mpq_class denom = 1 / (va + vb + vc); @@ -1890,7 +1889,7 @@ static mpq_class closest_on_tri_to_point(const mpq3 &p, if (dbg_level > 0) { std::cout << " answer = inside at " << r << "\n"; } - return mpq3::distance_squared_with_buffer(p, r, m); + return math::distance_squared_with_buffer(p, r, m); } static float closest_on_tri_to_point_float_dist_squared(const float3 &p, @@ -2610,7 +2609,7 @@ static void test_tri_inside_shapes(const IMesh &tm, double3 test_point = calc_point_inside_tri_db(tri_test); /* Offset the test point a tiny bit in the tri_test normal direction. */ tri_test.populate_plane(false); - double3 norm = tri_test.plane->norm.normalized(); + double3 norm = math::normalize(tri_test.plane->norm); const double offset_amount = 1e-5; double3 offset_test_point = test_point + offset_amount * norm; if (dbg_level > 0) { @@ -3002,7 +3001,7 @@ static void init_face_merge_state(FaceMergeState *fms, std::cout << "process tri = " << &tri << "\n"; } BLI_assert(tri.plane_populated()); - if (double3::dot(norm, tri.plane->norm) <= 0.0) { + if (math::dot(norm, tri.plane->norm) <= 0.0) { if (dbg_level > 0) { std::cout << "triangle has wrong orientation, skipping\n"; } @@ -3027,7 +3026,7 @@ static void init_face_merge_state(FaceMergeState *fms, } if (me_index == -1) { double3 vec = new_me.v2->co - new_me.v1->co; - new_me.len_squared = vec.length_squared(); + new_me.len_squared = math::length_squared(vec); new_me.orig = tri.edge_orig[i]; new_me.is_intersect = tri.is_intersect[i]; new_me.dissolvable = (new_me.orig == NO_INDEX && !new_me.is_intersect); @@ -3267,7 +3266,7 @@ static Vector<Face *> merge_tris_for_face(Vector<int> tris, bool done = false; double3 first_tri_normal = tm.face(tris[0])->plane->norm; double3 second_tri_normal = tm.face(tris[1])->plane->norm; - if (tris.size() == 2 && double3::dot(first_tri_normal, second_tri_normal) > 0.0) { + if (tris.size() == 2 && math::dot(first_tri_normal, second_tri_normal) > 0.0) { /* Is this a case where quad with one diagonal remained unchanged? * Worth special handling because this case will be very common. */ Face &tri1 = *tm.face(tris[0]); @@ -3332,7 +3331,7 @@ static bool approx_in_line(const double3 &a, const double3 &b, const double3 &c) { double3 vec1 = b - a; double3 vec2 = c - b; - double cos_ang = double3::dot(vec1.normalized(), vec2.normalized()); + double cos_ang = math::dot(math::normalize(vec1), math::normalize(vec2)); return fabs(cos_ang - 1.0) < 1e-4; } diff --git a/source/blender/blenlib/intern/mesh_intersect.cc b/source/blender/blenlib/intern/mesh_intersect.cc index 1f150137ba3..982759ffcff 100644 --- a/source/blender/blenlib/intern/mesh_intersect.cc +++ b/source/blender/blenlib/intern/mesh_intersect.cc @@ -30,15 +30,13 @@ # include "BLI_array.hh" # include "BLI_assert.h" # include "BLI_delaunay_2d.h" -# include "BLI_double3.hh" -# include "BLI_float3.hh" # include "BLI_hash.hh" # include "BLI_kdopbvh.h" # include "BLI_map.hh" # include "BLI_math_boolean.hh" # include "BLI_math_mpq.hh" -# include "BLI_mpq2.hh" -# include "BLI_mpq3.hh" +# include "BLI_math_vec_mpq_types.hh" +# include "BLI_math_vec_types.hh" # include "BLI_polyfill_2d.h" # include "BLI_set.hh" # include "BLI_span.hh" @@ -198,14 +196,14 @@ void Face::populate_plane(bool need_exact) for (int i : index_range()) { co[i] = vert[i]->co_exact; } - normal_exact = mpq3::cross_poly(co); + normal_exact = math::cross_poly(co.as_span()); } else { mpq3 tr02 = vert[0]->co_exact - vert[2]->co_exact; mpq3 tr12 = vert[1]->co_exact - vert[2]->co_exact; - normal_exact = mpq3::cross(tr02, tr12); + normal_exact = math::cross(tr02, tr12); } - mpq_class d_exact = -mpq3::dot(normal_exact, vert[0]->co_exact); + mpq_class d_exact = -math::dot(normal_exact, vert[0]->co_exact); plane = new Plane(normal_exact, d_exact); } else { @@ -215,14 +213,14 @@ void Face::populate_plane(bool need_exact) for (int i : index_range()) { co[i] = vert[i]->co; } - normal = double3::cross_poly(co); + normal = math::cross_poly(co.as_span()); } else { double3 tr02 = vert[0]->co - vert[2]->co; double3 tr12 = vert[1]->co - vert[2]->co; - normal = double3::cross_high_precision(tr02, tr12); + normal = math::cross(tr02, tr12); } - double d = -double3::dot(normal, vert[0]->co); + double d = -math::dot(normal, vert[0]->co); plane = new Plane(normal, d); } } @@ -1098,15 +1096,15 @@ static mpq2 project_3d_to_2d(const mpq3 &p3d, int proj_axis) */ static double supremum_dot_cross(const double3 &a, const double3 &b) { - double3 abs_a = double3::abs(a); - double3 abs_b = double3::abs(b); + double3 abs_a = math::abs(a); + double3 abs_b = math::abs(b); double3 c; /* This is dot(cross(a, b), cross(a,b)) but using absolute values for a and b * and always using + when operation is + or -. */ c[0] = abs_a[1] * abs_b[2] + abs_a[2] * abs_b[1]; c[1] = abs_a[2] * abs_b[0] + abs_a[0] * abs_b[2]; c[2] = abs_a[0] * abs_b[1] + abs_a[1] * abs_b[0]; - return double3::dot(c, c); + return math::dot(c, c); } /* The index of dot when inputs are plane_coords with index 1 is much higher. @@ -1143,11 +1141,11 @@ static int filter_plane_side(const double3 &p, const double3 &abs_plane_p, const double3 &abs_plane_no) { - double d = double3::dot(p - plane_p, plane_no); + double d = math::dot(p - plane_p, plane_no); if (d == 0.0) { return 0; } - double supremum = double3::dot(abs_p + abs_plane_p, abs_plane_no); + double supremum = math::dot(abs_p + abs_plane_p, abs_plane_no); double err_bound = supremum * index_plane_side * DBL_EPSILON; if (fabs(d) > err_bound) { return d > 0 ? 1 : -1; @@ -1178,9 +1176,9 @@ static inline mpq3 tti_interp( ab -= b; ac = a; ac -= c; - mpq_class den = mpq3::dot_with_buffer(ab, n, dotbuf); + mpq_class den = math::dot_with_buffer(ab, n, dotbuf); BLI_assert(den != 0); - mpq_class alpha = mpq3::dot_with_buffer(ac, n, dotbuf) / den; + mpq_class alpha = math::dot_with_buffer(ac, n, dotbuf) / den; return a - alpha * ab; } @@ -1209,7 +1207,7 @@ static inline int tti_above(const mpq3 &a, n.y = ba.z * ca.x - ba.x * ca.z; n.z = ba.x * ca.y - ba.y * ca.x; - return sgn(mpq3::dot_with_buffer(ad, n, dotbuf)); + return sgn(math::dot_with_buffer(ad, n, dotbuf)); } /** @@ -1428,11 +1426,11 @@ static ITT_value intersect_tri_tri(const IMesh &tm, int t1, int t2) const double3 &d_r2 = vr2->co; const double3 &d_n2 = tri2.plane->norm; - const double3 &abs_d_p1 = double3::abs(d_p1); - const double3 &abs_d_q1 = double3::abs(d_q1); - const double3 &abs_d_r1 = double3::abs(d_r1); - const double3 &abs_d_r2 = double3::abs(d_r2); - const double3 &abs_d_n2 = double3::abs(d_n2); + const double3 &abs_d_p1 = math::abs(d_p1); + const double3 &abs_d_q1 = math::abs(d_q1); + const double3 &abs_d_r1 = math::abs(d_r1); + const double3 &abs_d_r2 = math::abs(d_r2); + const double3 &abs_d_n2 = math::abs(d_n2); int sp1 = filter_plane_side(d_p1, d_r2, d_n2, abs_d_p1, abs_d_r2, abs_d_n2); int sq1 = filter_plane_side(d_q1, d_r2, d_n2, abs_d_q1, abs_d_r2, abs_d_n2); @@ -1448,9 +1446,9 @@ static ITT_value intersect_tri_tri(const IMesh &tm, int t1, int t2) } const double3 &d_n1 = tri1.plane->norm; - const double3 &abs_d_p2 = double3::abs(d_p2); - const double3 &abs_d_q2 = double3::abs(d_q2); - const double3 &abs_d_n1 = double3::abs(d_n1); + const double3 &abs_d_p2 = math::abs(d_p2); + const double3 &abs_d_q2 = math::abs(d_q2); + const double3 &abs_d_n1 = math::abs(d_n1); int sp2 = filter_plane_side(d_p2, d_r1, d_n1, abs_d_p2, abs_d_r1, abs_d_n1); int sq2 = filter_plane_side(d_q2, d_r1, d_n1, abs_d_q2, abs_d_r1, abs_d_n1); @@ -1477,17 +1475,17 @@ static ITT_value intersect_tri_tri(const IMesh &tm, int t1, int t2) if (sp1 == 0) { buf[0] = p1; buf[0] -= r2; - sp1 = sgn(mpq3::dot_with_buffer(buf[0], n2, buf[1])); + sp1 = sgn(math::dot_with_buffer(buf[0], n2, buf[1])); } if (sq1 == 0) { buf[0] = q1; buf[0] -= r2; - sq1 = sgn(mpq3::dot_with_buffer(buf[0], n2, buf[1])); + sq1 = sgn(math::dot_with_buffer(buf[0], n2, buf[1])); } if (sr1 == 0) { buf[0] = r1; buf[0] -= r2; - sr1 = sgn(mpq3::dot_with_buffer(buf[0], n2, buf[1])); + sr1 = sgn(math::dot_with_buffer(buf[0], n2, buf[1])); } if (dbg_level > 1) { @@ -1509,17 +1507,17 @@ static ITT_value intersect_tri_tri(const IMesh &tm, int t1, int t2) if (sp2 == 0) { buf[0] = p2; buf[0] -= r1; - sp2 = sgn(mpq3::dot_with_buffer(buf[0], n1, buf[1])); + sp2 = sgn(math::dot_with_buffer(buf[0], n1, buf[1])); } if (sq2 == 0) { buf[0] = q2; buf[0] -= r1; - sq2 = sgn(mpq3::dot_with_buffer(buf[0], n1, buf[1])); + sq2 = sgn(math::dot_with_buffer(buf[0], n1, buf[1])); } if (sr2 == 0) { buf[0] = r2; buf[0] -= r1; - sr2 = sgn(mpq3::dot_with_buffer(buf[0], n1, buf[1])); + sr2 = sgn(math::dot_with_buffer(buf[0], n1, buf[1])); } if (dbg_level > 1) { @@ -1721,7 +1719,7 @@ static CDT_data prepare_cdt_input(const IMesh &tm, int t, const Vector<ITT_value BLI_assert(tm.face(t)->plane_populated()); ans.t_plane = tm.face(t)->plane; BLI_assert(ans.t_plane->exact_populated()); - ans.proj_axis = mpq3::dominant_axis(ans.t_plane->norm_exact); + ans.proj_axis = math::dominant_axis(ans.t_plane->norm_exact); prepare_need_tri(ans, tm, t); for (const ITT_value &itt : itts) { switch (itt.kind) { @@ -1757,7 +1755,7 @@ static CDT_data prepare_cdt_input_for_cluster(const IMesh &tm, BLI_assert(tm.face(t0)->plane_populated()); ans.t_plane = tm.face(t0)->plane; BLI_assert(ans.t_plane->exact_populated()); - ans.proj_axis = mpq3::dominant_axis(ans.t_plane->norm_exact); + ans.proj_axis = math::dominant_axis(ans.t_plane->norm_exact); for (const int t : cl) { prepare_need_tri(ans, tm, t); } @@ -2004,9 +2002,9 @@ static bool is_quad_flip_first_third(const double3 &v1, const double3 &normal) { double3 dir_v3v1 = v3 - v1; - double3 tangent = double3::cross_high_precision(dir_v3v1, normal); - double dot = double3::dot(v1, tangent); - return (double3::dot(v4, tangent) >= dot) || (double3::dot(v2, tangent) <= dot); + double3 tangent = math::cross(dir_v3v1, normal); + double dot = math::dot(v1, tangent); + return (math::dot(v4, tangent) >= dot) || (math::dot(v2, tangent) <= dot); } /** @@ -2124,7 +2122,7 @@ static Array<Face *> exact_triangulate_poly(Face *f, IMeshArena *arena) f->populate_plane(false); } const double3 &poly_normal = f->plane->norm; - int axis = double3::dominant_axis(poly_normal); + int axis = math::dominant_axis(poly_normal); /* If project down y axis as opposed to x or z, the orientation * of the polygon will be reversed. * Yet another reversal happens if the poly normal in the dominant @@ -2203,15 +2201,15 @@ static bool face_is_degenerate(const Face *f) } double3 da = v2->co - v0->co; double3 db = v2->co - v1->co; - double3 dab = double3::cross_high_precision(da, db); - double dab_length_squared = dab.length_squared(); + double3 dab = math::cross(da, db); + double dab_length_squared = math::length_squared(dab); double err_bound = supremum_dot_cross(dab, dab) * index_dot_cross * DBL_EPSILON; if (dab_length_squared > err_bound) { return false; } mpq3 a = v2->co_exact - v0->co_exact; mpq3 b = v2->co_exact - v1->co_exact; - mpq3 ab = mpq3::cross(a, b); + mpq3 ab = math::cross(a, b); if (ab.x == 0 && ab.y == 0 && ab.z == 0) { return true; } @@ -2231,8 +2229,8 @@ static bool any_degenerate_tris_fast(const Array<Face *> triangulation) } double3 da = v2->co - v0->co; double3 db = v2->co - v1->co; - double da_length_squared = da.length_squared(); - double db_length_squared = db.length_squared(); + double da_length_squared = math::length_squared(da); + double db_length_squared = math::length_squared(db); if (da_length_squared == 0.0 || db_length_squared == 0.0) { return true; } @@ -2240,8 +2238,8 @@ static bool any_degenerate_tris_fast(const Array<Face *> triangulation) * The triangle is almost degenerate if sin t is almost 0. * sin^2 t = |da x db|^2 / (|da|^2 |db|^2) */ - double3 dab = double3::cross_high_precision(da, db); - double dab_length_squared = dab.length_squared(); + double3 dab = math::cross(da, db); + double dab_length_squared = math::length_squared(dab); double sin_squared_t = dab_length_squared / (da_length_squared * db_length_squared); if (sin_squared_t < 1e-8) { return true; diff --git a/source/blender/blenlib/intern/noise.cc b/source/blender/blenlib/intern/noise.cc index a6ad18801fd..3460c1284fc 100644 --- a/source/blender/blenlib/intern/noise.cc +++ b/source/blender/blenlib/intern/noise.cc @@ -50,9 +50,7 @@ #include <cmath> #include <cstdint> -#include "BLI_float2.hh" -#include "BLI_float3.hh" -#include "BLI_float4.hh" +#include "BLI_math_vec_types.hh" #include "BLI_math_base_safe.h" #include "BLI_noise.hh" #include "BLI_utildefines.h" @@ -1469,7 +1467,7 @@ void voronoi_smooth_f1(const float w, correctionFactor /= 1.0f + 3.0f * smoothness; if (r_color != nullptr) { const float3 cellColor = hash_float_to_float3(cellPosition + cellOffset); - smoothColor = float3::interpolate(smoothColor, cellColor, h) - correctionFactor; + smoothColor = math::interpolate(smoothColor, cellColor, h) - correctionFactor; } if (r_w != nullptr) { smoothPosition = mix(smoothPosition, pointPosition, h) - correctionFactor; @@ -1592,7 +1590,7 @@ static float voronoi_distance(const float2 a, { switch (metric) { case NOISE_SHD_VORONOI_EUCLIDEAN: - return float2::distance(a, b); + return math::distance(a, b); case NOISE_SHD_VORONOI_MANHATTAN: return fabsf(a.x - b.x) + fabsf(a.y - b.y); case NOISE_SHD_VORONOI_CHEBYCHEV: @@ -1615,7 +1613,7 @@ void voronoi_f1(const float2 coord, float3 *r_color, float2 *r_position) { - const float2 cellPosition = float2::floor(coord); + const float2 cellPosition = math::floor(coord); const float2 localPosition = coord - cellPosition; float minDistance = 8.0f; @@ -1654,7 +1652,7 @@ void voronoi_smooth_f1(const float2 coord, float3 *r_color, float2 *r_position) { - const float2 cellPosition = float2::floor(coord); + const float2 cellPosition = math::floor(coord); const float2 localPosition = coord - cellPosition; const float smoothness_clamped = max_ff(smoothness, FLT_MIN); @@ -1676,11 +1674,10 @@ void voronoi_smooth_f1(const float2 coord, correctionFactor /= 1.0f + 3.0f * smoothness; if (r_color != nullptr) { const float3 cellColor = hash_float_to_float3(cellPosition + cellOffset); - smoothColor = float3::interpolate(smoothColor, cellColor, h) - correctionFactor; + smoothColor = math::interpolate(smoothColor, cellColor, h) - correctionFactor; } if (r_position != nullptr) { - smoothPosition = float2::interpolate(smoothPosition, pointPosition, h) - - correctionFactor; + smoothPosition = math::interpolate(smoothPosition, pointPosition, h) - correctionFactor; } } } @@ -1704,7 +1701,7 @@ void voronoi_f2(const float2 coord, float3 *r_color, float2 *r_position) { - const float2 cellPosition = float2::floor(coord); + const float2 cellPosition = math::floor(coord); const float2 localPosition = coord - cellPosition; float distanceF1 = 8.0f; @@ -1748,7 +1745,7 @@ void voronoi_f2(const float2 coord, void voronoi_distance_to_edge(const float2 coord, const float randomness, float *r_distance) { - const float2 cellPosition = float2::floor(coord); + const float2 cellPosition = math::floor(coord); const float2 localPosition = coord - cellPosition; float2 vectorToClosest = float2(0.0f, 0.0f); @@ -1777,7 +1774,7 @@ void voronoi_distance_to_edge(const float2 coord, const float randomness, float const float2 perpendicularToEdge = vectorToPoint - vectorToClosest; if (dot_v2v2(perpendicularToEdge, perpendicularToEdge) > 0.0001f) { const float distanceToEdge = dot_v2v2((vectorToClosest + vectorToPoint) / 2.0f, - perpendicularToEdge.normalized()); + math::normalize(perpendicularToEdge)); minDistance = std::min(minDistance, distanceToEdge); } } @@ -1787,7 +1784,7 @@ void voronoi_distance_to_edge(const float2 coord, const float randomness, float void voronoi_n_sphere_radius(const float2 coord, const float randomness, float *r_radius) { - const float2 cellPosition = float2::floor(coord); + const float2 cellPosition = math::floor(coord); const float2 localPosition = coord - cellPosition; float2 closestPoint = float2(0.0f, 0.0f); @@ -1798,7 +1795,7 @@ void voronoi_n_sphere_radius(const float2 coord, const float randomness, float * const float2 cellOffset = float2(i, j); const float2 pointPosition = cellOffset + hash_float_to_float2(cellPosition + cellOffset) * randomness; - const float distanceToPoint = float2::distance(pointPosition, localPosition); + const float distanceToPoint = math::distance(pointPosition, localPosition); if (distanceToPoint < minDistance) { minDistance = distanceToPoint; closestPoint = pointPosition; @@ -1817,14 +1814,14 @@ void voronoi_n_sphere_radius(const float2 coord, const float randomness, float * const float2 cellOffset = float2(i, j) + closestPointOffset; const float2 pointPosition = cellOffset + hash_float_to_float2(cellPosition + cellOffset) * randomness; - const float distanceToPoint = float2::distance(closestPoint, pointPosition); + const float distanceToPoint = math::distance(closestPoint, pointPosition); if (distanceToPoint < minDistance) { minDistance = distanceToPoint; closestPointToClosestPoint = pointPosition; } } } - *r_radius = float2::distance(closestPointToClosestPoint, closestPoint) / 2.0f; + *r_radius = math::distance(closestPointToClosestPoint, closestPoint) / 2.0f; } /* **** 3D Voronoi **** */ @@ -1836,7 +1833,7 @@ static float voronoi_distance(const float3 a, { switch (metric) { case NOISE_SHD_VORONOI_EUCLIDEAN: - return float3::distance(a, b); + return math::distance(a, b); case NOISE_SHD_VORONOI_MANHATTAN: return fabsf(a.x - b.x) + fabsf(a.y - b.y) + fabsf(a.z - b.z); case NOISE_SHD_VORONOI_CHEBYCHEV: @@ -1860,7 +1857,7 @@ void voronoi_f1(const float3 coord, float3 *r_color, float3 *r_position) { - const float3 cellPosition = float3::floor(coord); + const float3 cellPosition = math::floor(coord); const float3 localPosition = coord - cellPosition; float minDistance = 8.0f; @@ -1902,7 +1899,7 @@ void voronoi_smooth_f1(const float3 coord, float3 *r_color, float3 *r_position) { - const float3 cellPosition = float3::floor(coord); + const float3 cellPosition = math::floor(coord); const float3 localPosition = coord - cellPosition; const float smoothness_clamped = max_ff(smoothness, FLT_MIN); @@ -1925,10 +1922,10 @@ void voronoi_smooth_f1(const float3 coord, correctionFactor /= 1.0f + 3.0f * smoothness; if (r_color != nullptr) { const float3 cellColor = hash_float_to_float3(cellPosition + cellOffset); - smoothColor = float3::interpolate(smoothColor, cellColor, h) - correctionFactor; + smoothColor = math::interpolate(smoothColor, cellColor, h) - correctionFactor; } if (r_position != nullptr) { - smoothPosition = float3::interpolate(smoothPosition, pointPosition, h) - + smoothPosition = math::interpolate(smoothPosition, pointPosition, h) - correctionFactor; } } @@ -1954,7 +1951,7 @@ void voronoi_f2(const float3 coord, float3 *r_color, float3 *r_position) { - const float3 cellPosition = float3::floor(coord); + const float3 cellPosition = math::floor(coord); const float3 localPosition = coord - cellPosition; float distanceF1 = 8.0f; @@ -2000,7 +1997,7 @@ void voronoi_f2(const float3 coord, void voronoi_distance_to_edge(const float3 coord, const float randomness, float *r_distance) { - const float3 cellPosition = float3::floor(coord); + const float3 cellPosition = math::floor(coord); const float3 localPosition = coord - cellPosition; float3 vectorToClosest = float3(0.0f, 0.0f, 0.0f); @@ -2032,7 +2029,7 @@ void voronoi_distance_to_edge(const float3 coord, const float randomness, float const float3 perpendicularToEdge = vectorToPoint - vectorToClosest; if (dot_v3v3(perpendicularToEdge, perpendicularToEdge) > 0.0001f) { const float distanceToEdge = dot_v3v3((vectorToClosest + vectorToPoint) / 2.0f, - perpendicularToEdge.normalized()); + math::normalize(perpendicularToEdge)); minDistance = std::min(minDistance, distanceToEdge); } } @@ -2043,7 +2040,7 @@ void voronoi_distance_to_edge(const float3 coord, const float randomness, float void voronoi_n_sphere_radius(const float3 coord, const float randomness, float *r_radius) { - const float3 cellPosition = float3::floor(coord); + const float3 cellPosition = math::floor(coord); const float3 localPosition = coord - cellPosition; float3 closestPoint = float3(0.0f, 0.0f, 0.0f); @@ -2055,7 +2052,7 @@ void voronoi_n_sphere_radius(const float3 coord, const float randomness, float * const float3 cellOffset = float3(i, j, k); const float3 pointPosition = cellOffset + hash_float_to_float3(cellPosition + cellOffset) * randomness; - const float distanceToPoint = float3::distance(pointPosition, localPosition); + const float distanceToPoint = math::distance(pointPosition, localPosition); if (distanceToPoint < minDistance) { minDistance = distanceToPoint; closestPoint = pointPosition; @@ -2076,7 +2073,7 @@ void voronoi_n_sphere_radius(const float3 coord, const float randomness, float * const float3 cellOffset = float3(i, j, k) + closestPointOffset; const float3 pointPosition = cellOffset + hash_float_to_float3(cellPosition + cellOffset) * randomness; - const float distanceToPoint = float3::distance(closestPoint, pointPosition); + const float distanceToPoint = math::distance(closestPoint, pointPosition); if (distanceToPoint < minDistance) { minDistance = distanceToPoint; closestPointToClosestPoint = pointPosition; @@ -2084,7 +2081,7 @@ void voronoi_n_sphere_radius(const float3 coord, const float randomness, float * } } } - *r_radius = float3::distance(closestPointToClosestPoint, closestPoint) / 2.0f; + *r_radius = math::distance(closestPointToClosestPoint, closestPoint) / 2.0f; } /* **** 4D Voronoi **** */ @@ -2096,7 +2093,7 @@ static float voronoi_distance(const float4 a, { switch (metric) { case NOISE_SHD_VORONOI_EUCLIDEAN: - return float4::distance(a, b); + return math::distance(a, b); case NOISE_SHD_VORONOI_MANHATTAN: return fabsf(a.x - b.x) + fabsf(a.y - b.y) + fabsf(a.z - b.z) + fabsf(a.w - b.w); case NOISE_SHD_VORONOI_CHEBYCHEV: @@ -2121,7 +2118,7 @@ void voronoi_f1(const float4 coord, float3 *r_color, float4 *r_position) { - const float4 cellPosition = float4::floor(coord); + const float4 cellPosition = math::floor(coord); const float4 localPosition = coord - cellPosition; float minDistance = 8.0f; @@ -2166,7 +2163,7 @@ void voronoi_smooth_f1(const float4 coord, float3 *r_color, float4 *r_position) { - const float4 cellPosition = float4::floor(coord); + const float4 cellPosition = math::floor(coord); const float4 localPosition = coord - cellPosition; const float smoothness_clamped = max_ff(smoothness, FLT_MIN); @@ -2191,10 +2188,10 @@ void voronoi_smooth_f1(const float4 coord, correctionFactor /= 1.0f + 3.0f * smoothness; if (r_color != nullptr) { const float3 cellColor = hash_float_to_float3(cellPosition + cellOffset); - smoothColor = float3::interpolate(smoothColor, cellColor, h) - correctionFactor; + smoothColor = math::interpolate(smoothColor, cellColor, h) - correctionFactor; } if (r_position != nullptr) { - smoothPosition = float4::interpolate(smoothPosition, pointPosition, h) - + smoothPosition = math::interpolate(smoothPosition, pointPosition, h) - correctionFactor; } } @@ -2221,7 +2218,7 @@ void voronoi_f2(const float4 coord, float3 *r_color, float4 *r_position) { - const float4 cellPosition = float4::floor(coord); + const float4 cellPosition = math::floor(coord); const float4 localPosition = coord - cellPosition; float distanceF1 = 8.0f; @@ -2270,7 +2267,7 @@ void voronoi_f2(const float4 coord, void voronoi_distance_to_edge(const float4 coord, const float randomness, float *r_distance) { - const float4 cellPosition = float4::floor(coord); + const float4 cellPosition = math::floor(coord); const float4 localPosition = coord - cellPosition; float4 vectorToClosest = float4(0.0f, 0.0f, 0.0f, 0.0f); @@ -2307,7 +2304,7 @@ void voronoi_distance_to_edge(const float4 coord, const float randomness, float const float4 perpendicularToEdge = vectorToPoint - vectorToClosest; if (dot_v4v4(perpendicularToEdge, perpendicularToEdge) > 0.0001f) { const float distanceToEdge = dot_v4v4((vectorToClosest + vectorToPoint) / 2.0f, - float4::normalize(perpendicularToEdge)); + math::normalize(perpendicularToEdge)); minDistance = std::min(minDistance, distanceToEdge); } } @@ -2319,7 +2316,7 @@ void voronoi_distance_to_edge(const float4 coord, const float randomness, float void voronoi_n_sphere_radius(const float4 coord, const float randomness, float *r_radius) { - const float4 cellPosition = float4::floor(coord); + const float4 cellPosition = math::floor(coord); const float4 localPosition = coord - cellPosition; float4 closestPoint = float4(0.0f, 0.0f, 0.0f, 0.0f); @@ -2333,7 +2330,7 @@ void voronoi_n_sphere_radius(const float4 coord, const float randomness, float * const float4 pointPosition = cellOffset + hash_float_to_float4(cellPosition + cellOffset) * randomness; - const float distanceToPoint = float4::distance(pointPosition, localPosition); + const float distanceToPoint = math::distance(pointPosition, localPosition); if (distanceToPoint < minDistance) { minDistance = distanceToPoint; closestPoint = pointPosition; @@ -2357,7 +2354,7 @@ void voronoi_n_sphere_radius(const float4 coord, const float randomness, float * const float4 pointPosition = cellOffset + hash_float_to_float4(cellPosition + cellOffset) * randomness; - const float distanceToPoint = float4::distance(closestPoint, pointPosition); + const float distanceToPoint = math::distance(closestPoint, pointPosition); if (distanceToPoint < minDistance) { minDistance = distanceToPoint; closestPointToClosestPoint = pointPosition; @@ -2366,7 +2363,7 @@ void voronoi_n_sphere_radius(const float4 coord, const float randomness, float * } } } - *r_radius = float4::distance(closestPointToClosestPoint, closestPoint) / 2.0f; + *r_radius = math::distance(closestPointToClosestPoint, closestPoint) / 2.0f; } /** \} */ diff --git a/source/blender/blenlib/tests/BLI_delaunay_2d_test.cc b/source/blender/blenlib/tests/BLI_delaunay_2d_test.cc index 70e3a99e57a..eac3faa6d15 100644 --- a/source/blender/blenlib/tests/BLI_delaunay_2d_test.cc +++ b/source/blender/blenlib/tests/BLI_delaunay_2d_test.cc @@ -21,10 +21,9 @@ extern "C" { #define DO_RANDOM_TESTS 0 #include "BLI_array.hh" -#include "BLI_double2.hh" #include "BLI_math_boolean.hh" #include "BLI_math_mpq.hh" -#include "BLI_mpq2.hh" +#include "BLI_math_vec_mpq_types.hh" #include "BLI_vector.hh" #include "BLI_delaunay_2d.h" diff --git a/source/blender/blenlib/tests/BLI_math_vec_types_test.cc b/source/blender/blenlib/tests/BLI_math_vec_types_test.cc new file mode 100644 index 00000000000..8aa1f90fde2 --- /dev/null +++ b/source/blender/blenlib/tests/BLI_math_vec_types_test.cc @@ -0,0 +1,149 @@ +/* Apache License, Version 2.0 */ + +#include "testing/testing.h" + +#include "BLI_math_vec_types.hh" + +namespace blender::tests { + +using namespace blender::math; + +TEST(math_vec_types, ScalarConstructorUnsigned) +{ + float2 u(5u); + EXPECT_EQ(u[0], 5.0f); + EXPECT_EQ(u[1], 5.0f); +} + +TEST(math_vec_types, ScalarConstructorInt) +{ + float2 i(-5); + EXPECT_EQ(i[0], -5.0f); + EXPECT_EQ(i[1], -5.0f); +} + +TEST(math_vec_types, ScalarConstructorFloat) +{ + float2 f(5.2f); + EXPECT_FLOAT_EQ(f[0], 5.2f); + EXPECT_FLOAT_EQ(f[1], 5.2f); +} + +TEST(math_vec_types, ScalarConstructorDouble) +{ + float2 d(5.2); + EXPECT_FLOAT_EQ(d[0], 5.2f); + EXPECT_FLOAT_EQ(d[1], 5.2f); +} + +TEST(math_vec_types, MultiScalarConstructorVec2) +{ + int2 i(5.5f, -1.8); + EXPECT_EQ(i[0], 5); + EXPECT_EQ(i[1], -1); +} + +TEST(math_vec_types, MultiScalarConstructorVec3) +{ + int3 i(5.5f, -1.8, 6u); + EXPECT_EQ(i[0], 5); + EXPECT_EQ(i[1], -1); + EXPECT_EQ(i[2], 6); +} + +TEST(math_vec_types, MultiScalarConstructorVec4) +{ + int4 i(5.5f, -1.8, 6u, 0.888f); + EXPECT_EQ(i[0], 5); + EXPECT_EQ(i[1], -1); + EXPECT_EQ(i[2], 6); + EXPECT_EQ(i[3], 0); +} + +TEST(math_vec_types, MixedScalarVectorConstructorVec3) +{ + float3 fl_v2(float2(5.5f), 1.8f); + EXPECT_FLOAT_EQ(fl_v2[0], 5.5f); + EXPECT_FLOAT_EQ(fl_v2[1], 5.5f); + EXPECT_FLOAT_EQ(fl_v2[2], 1.8f); + + float3 v2_fl(1.8f, float2(5.5f)); + EXPECT_FLOAT_EQ(v2_fl[0], 1.8f); + EXPECT_FLOAT_EQ(v2_fl[1], 5.5f); + EXPECT_FLOAT_EQ(v2_fl[2], 5.5f); +} + +TEST(math_vec_types, MixedScalarVectorConstructorVec4) +{ + int4 v2_fl_fl(float2(1), 2, 3); + EXPECT_EQ(v2_fl_fl[0], 1); + EXPECT_EQ(v2_fl_fl[1], 1); + EXPECT_EQ(v2_fl_fl[2], 2); + EXPECT_EQ(v2_fl_fl[3], 3); + + float4 fl_v2_fl(1, int2(2), 3); + EXPECT_EQ(fl_v2_fl[0], 1); + EXPECT_EQ(fl_v2_fl[1], 2); + EXPECT_EQ(fl_v2_fl[2], 2); + EXPECT_EQ(fl_v2_fl[3], 3); + + double4 fl_fl_v2(1, 2, double2(3)); + EXPECT_EQ(fl_fl_v2[0], 1); + EXPECT_EQ(fl_fl_v2[1], 2); + EXPECT_EQ(fl_fl_v2[2], 3); + EXPECT_EQ(fl_fl_v2[3], 3); + + int4 v2_v2(float2(1), uint2(2)); + EXPECT_EQ(v2_v2[0], 1); + EXPECT_EQ(v2_v2[1], 1); + EXPECT_EQ(v2_v2[2], 2); + EXPECT_EQ(v2_v2[3], 2); + + float4 v3_fl(uint3(1), 2); + EXPECT_EQ(v3_fl[0], 1); + EXPECT_EQ(v3_fl[1], 1); + EXPECT_EQ(v3_fl[2], 1); + EXPECT_EQ(v3_fl[3], 2); + + uint4 fl_v3(1, float3(2)); + EXPECT_EQ(fl_v3[0], 1); + EXPECT_EQ(fl_v3[1], 2); + EXPECT_EQ(fl_v3[2], 2); + EXPECT_EQ(fl_v3[3], 2); +} + +TEST(math_vec_types, ComponentMasking) +{ + int4 i(0, 1, 2, 3); + float2 f2 = float2(i); + EXPECT_EQ(f2[0], 0.0f); + EXPECT_EQ(f2[1], 1.0f); +} + +TEST(math_vec_types, PointerConversion) +{ + float array[3] = {1.0f, 2.0f, 3.0f}; + float3 farray(array); + EXPECT_EQ(farray[0], 1.0f); + EXPECT_EQ(farray[1], 2.0f); + EXPECT_EQ(farray[2], 3.0f); +} + +TEST(math_vec_types, PointerArrayConversion) +{ + float array[1][3] = {{1.0f, 2.0f, 3.0f}}; + float(*ptr)[3] = array; + float3 fptr(ptr); + EXPECT_EQ(fptr[0], 1.0f); + EXPECT_EQ(fptr[1], 2.0f); + EXPECT_EQ(fptr[2], 3.0f); +} + +TEST(math_vec_types, VectorTypeConversion) +{ + double2 d(int2(float2(5.75f, -1.57f))); + EXPECT_EQ(d[0], 5.0); + EXPECT_EQ(d[1], -1.0); +} + +} // namespace blender::tests diff --git a/source/blender/blenlib/tests/BLI_memory_utils_test.cc b/source/blender/blenlib/tests/BLI_memory_utils_test.cc index 207f310d902..74e54151a06 100644 --- a/source/blender/blenlib/tests/BLI_memory_utils_test.cc +++ b/source/blender/blenlib/tests/BLI_memory_utils_test.cc @@ -1,6 +1,6 @@ /* Apache License, Version 2.0 */ -#include "BLI_float3.hh" +#include "BLI_math_vec_types.hh" #include "BLI_memory_utils.hh" #include "BLI_strict_flags.h" #include "testing/testing.h" diff --git a/source/blender/blenlib/tests/BLI_mesh_boolean_test.cc b/source/blender/blenlib/tests/BLI_mesh_boolean_test.cc index d759f0c3be4..2b8fb3dbea4 100644 --- a/source/blender/blenlib/tests/BLI_mesh_boolean_test.cc +++ b/source/blender/blenlib/tests/BLI_mesh_boolean_test.cc @@ -11,8 +11,8 @@ #include "BLI_array.hh" #include "BLI_map.hh" #include "BLI_math_mpq.hh" +#include "BLI_math_vec_mpq_types.hh" #include "BLI_mesh_boolean.hh" -#include "BLI_mpq3.hh" #include "BLI_vector.hh" #ifdef WITH_GMP diff --git a/source/blender/blenlib/tests/BLI_mesh_intersect_test.cc b/source/blender/blenlib/tests/BLI_mesh_intersect_test.cc index 68111fb8eb1..d2d76593129 100644 --- a/source/blender/blenlib/tests/BLI_mesh_intersect_test.cc +++ b/source/blender/blenlib/tests/BLI_mesh_intersect_test.cc @@ -10,8 +10,8 @@ #include "BLI_array.hh" #include "BLI_math_mpq.hh" +#include "BLI_math_vec_mpq_types.hh" #include "BLI_mesh_intersect.hh" -#include "BLI_mpq3.hh" #include "BLI_task.h" #include "BLI_vector.hh" diff --git a/source/blender/compositor/COM_defines.h b/source/blender/compositor/COM_defines.h index 1c3a28670df..794bf1b23bc 100644 --- a/source/blender/compositor/COM_defines.h +++ b/source/blender/compositor/COM_defines.h @@ -18,7 +18,7 @@ #pragma once -#include "BLI_float2.hh" +#include "BLI_math_vec_types.hh" #include "DNA_vec_types.h" diff --git a/source/blender/draw/intern/draw_cache_impl_curve.cc b/source/blender/draw/intern/draw_cache_impl_curve.cc index 1108d40125b..33cf0e9a3cd 100644 --- a/source/blender/draw/intern/draw_cache_impl_curve.cc +++ b/source/blender/draw/intern/draw_cache_impl_curve.cc @@ -26,8 +26,8 @@ #include "MEM_guardedalloc.h" #include "BLI_array.hh" -#include "BLI_float3.hh" #include "BLI_listbase.h" +#include "BLI_math_vec_types.hh" #include "BLI_math_vector.h" #include "BLI_span.hh" #include "BLI_utildefines.h" diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_attributes.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_attributes.cc index ea702e5efdd..b846da3f016 100644 --- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_attributes.cc +++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_attributes.cc @@ -25,9 +25,7 @@ #include <functional> -#include "BLI_float2.hh" -#include "BLI_float3.hh" -#include "BLI_float4.hh" +#include "BLI_math_vec_types.hh" #include "BLI_string.h" #include "BKE_attribute.h" diff --git a/source/blender/editors/space_node/node_group.cc b/source/blender/editors/space_node/node_group.cc index 4834ca3174a..02d68189997 100644 --- a/source/blender/editors/space_node/node_group.cc +++ b/source/blender/editors/space_node/node_group.cc @@ -28,9 +28,9 @@ #include "DNA_anim_types.h" #include "DNA_node_types.h" -#include "BLI_float2.hh" #include "BLI_linklist.h" #include "BLI_listbase.h" +#include "BLI_math_vec_types.hh" #include "BLI_string.h" #include "BLI_vector.hh" diff --git a/source/blender/editors/space_node/node_intern.hh b/source/blender/editors/space_node/node_intern.hh index 0f542734f66..740d1fbb6f9 100644 --- a/source/blender/editors/space_node/node_intern.hh +++ b/source/blender/editors/space_node/node_intern.hh @@ -23,7 +23,7 @@ #pragma once -#include "BLI_float2.hh" +#include "BLI_math_vec_types.hh" #include "BLI_vector.hh" #include "BKE_node.h" @@ -43,9 +43,6 @@ struct bNodeLink; struct bNodeSocket; struct wmGizmoGroupType; struct wmKeyConfig; -namespace blender { -struct float2; -} struct wmWindow; /** Temporary data used in node link drag modal operator. */ diff --git a/source/blender/editors/space_node/node_select.cc b/source/blender/editors/space_node/node_select.cc index 334ca1f76ee..803cf38c53a 100644 --- a/source/blender/editors/space_node/node_select.cc +++ b/source/blender/editors/space_node/node_select.cc @@ -111,11 +111,13 @@ static bNode *node_under_mouse_select(bNodeTree &ntree, int mx, int my) static bNode *node_under_mouse_tweak(bNodeTree &ntree, const float2 &mouse) { + using namespace blender::math; + LISTBASE_FOREACH_BACKWARD (bNode *, node, &ntree.nodes) { if (node->type == NODE_REROUTE) { bNodeSocket *socket = (bNodeSocket *)node->inputs.first; const float2 location{socket->locx, socket->locy}; - if (float2::distance(mouse, location) < 24.0f) { + if (distance(mouse, location) < 24.0f) { return node; } } diff --git a/source/blender/editors/space_spreadsheet/spreadsheet_column.cc b/source/blender/editors/space_spreadsheet/spreadsheet_column.cc index ee623083db7..ede8756a9da 100644 --- a/source/blender/editors/space_spreadsheet/spreadsheet_column.cc +++ b/source/blender/editors/space_spreadsheet/spreadsheet_column.cc @@ -19,9 +19,8 @@ #include "MEM_guardedalloc.h" #include "BLI_color.hh" -#include "BLI_float2.hh" -#include "BLI_float3.hh" #include "BLI_hash.hh" +#include "BLI_math_vec_types.hh" #include "BLI_string.h" #include "BLI_string_ref.hh" diff --git a/source/blender/editors/space_spreadsheet/spreadsheet_layout.cc b/source/blender/editors/space_spreadsheet/spreadsheet_layout.cc index 7cc2d8d0b48..f4b5ff819ed 100644 --- a/source/blender/editors/space_spreadsheet/spreadsheet_layout.cc +++ b/source/blender/editors/space_spreadsheet/spreadsheet_layout.cc @@ -17,8 +17,7 @@ #include <iomanip> #include <sstream> -#include "BLI_float2.hh" -#include "BLI_float3.hh" +#include "BLI_math_vec_types.hh" #include "BKE_geometry_set.hh" diff --git a/source/blender/editors/space_spreadsheet/spreadsheet_row_filter.cc b/source/blender/editors/space_spreadsheet/spreadsheet_row_filter.cc index 36c7f1057df..556c0b0d5ca 100644 --- a/source/blender/editors/space_spreadsheet/spreadsheet_row_filter.cc +++ b/source/blender/editors/space_spreadsheet/spreadsheet_row_filter.cc @@ -123,9 +123,7 @@ static void apply_row_filter(const SpreadsheetRowFilter &row_filter, const float threshold_sq = row_filter.threshold; apply_filter_operation( column_data.typed<float2>(), - [&](const float2 cell) { - return float2::distance_squared(cell, value) > threshold_sq; - }, + [&](const float2 cell) { return math::distance_squared(cell, value) > threshold_sq; }, prev_mask, new_indices); break; @@ -155,9 +153,7 @@ static void apply_row_filter(const SpreadsheetRowFilter &row_filter, const float threshold_sq = row_filter.threshold; apply_filter_operation( column_data.typed<float3>(), - [&](const float3 cell) { - return float3::distance_squared(cell, value) > threshold_sq; - }, + [&](const float3 cell) { return math::distance_squared(cell, value) > threshold_sq; }, prev_mask, new_indices); break; diff --git a/source/blender/functions/intern/cpp_types.cc b/source/blender/functions/intern/cpp_types.cc index 058fb76af2b..0bbfbc8cb10 100644 --- a/source/blender/functions/intern/cpp_types.cc +++ b/source/blender/functions/intern/cpp_types.cc @@ -18,9 +18,8 @@ #include "FN_field_cpp_type.hh" #include "BLI_color.hh" -#include "BLI_float2.hh" -#include "BLI_float3.hh" #include "BLI_float4x4.hh" +#include "BLI_math_vec_types.hh" namespace blender::fn { diff --git a/source/blender/io/gpencil/intern/gpencil_io_base.cc b/source/blender/io/gpencil/intern/gpencil_io_base.cc index f031648d2ed..7868bade8c1 100644 --- a/source/blender/io/gpencil/intern/gpencil_io_base.cc +++ b/source/blender/io/gpencil/intern/gpencil_io_base.cc @@ -23,9 +23,8 @@ * \ingroup bgpencil */ -#include "BLI_float2.hh" -#include "BLI_float3.hh" #include "BLI_float4x4.hh" +#include "BLI_math_vec_types.hh" #include "BLI_path_util.h" #include "BLI_span.hh" @@ -283,7 +282,7 @@ float GpencilIO::stroke_point_radius_get(bGPDlayer *gpl, bGPDstroke *gps) const float2 screen_ex = gpencil_3D_point_to_2D(&pt->x); const float2 v1 = screen_co - screen_ex; - float radius = v1.length(); + float radius = math::length(v1); BKE_gpencil_free_stroke(gps_perimeter); return MAX2(radius, 1.0f); diff --git a/source/blender/io/gpencil/intern/gpencil_io_base.hh b/source/blender/io/gpencil/intern/gpencil_io_base.hh index 09557cd7a4d..ae54d5056dc 100644 --- a/source/blender/io/gpencil/intern/gpencil_io_base.hh +++ b/source/blender/io/gpencil/intern/gpencil_io_base.hh @@ -22,9 +22,8 @@ * \ingroup bgpencil */ -#include "BLI_float2.hh" -#include "BLI_float3.hh" #include "BLI_float4x4.hh" +#include "BLI_math_vec_types.hh" #include "BLI_vector.hh" #include "DNA_space_types.h" /* for FILE_MAX */ diff --git a/source/blender/io/gpencil/intern/gpencil_io_import_svg.cc b/source/blender/io/gpencil/intern/gpencil_io_import_svg.cc index 941d1137f4d..455ebb7c3cb 100644 --- a/source/blender/io/gpencil/intern/gpencil_io_import_svg.cc +++ b/source/blender/io/gpencil/intern/gpencil_io_import_svg.cc @@ -21,8 +21,8 @@ * \ingroup bgpencil */ -#include "BLI_float3.hh" #include "BLI_math.h" +#include "BLI_math_vec_types.hh" #include "BLI_span.hh" #include "DNA_gpencil_types.h" diff --git a/source/blender/io/wavefront_obj/exporter/obj_export_mesh.hh b/source/blender/io/wavefront_obj/exporter/obj_export_mesh.hh index 9a4dfe3efe3..e6d2853d040 100644 --- a/source/blender/io/wavefront_obj/exporter/obj_export_mesh.hh +++ b/source/blender/io/wavefront_obj/exporter/obj_export_mesh.hh @@ -22,7 +22,7 @@ #include <optional> -#include "BLI_float3.hh" +#include "BLI_math_vec_types.hh" #include "BLI_utility_mixins.hh" #include "BLI_vector.hh" diff --git a/source/blender/io/wavefront_obj/exporter/obj_export_mtl.cc b/source/blender/io/wavefront_obj/exporter/obj_export_mtl.cc index b99d41e0c72..5b710939e00 100644 --- a/source/blender/io/wavefront_obj/exporter/obj_export_mtl.cc +++ b/source/blender/io/wavefront_obj/exporter/obj_export_mtl.cc @@ -21,8 +21,8 @@ #include "BKE_image.h" #include "BKE_node.h" -#include "BLI_float3.hh" #include "BLI_map.hh" +#include "BLI_math_vec_types.hh" #include "BLI_path_util.h" #include "DNA_material_types.h" diff --git a/source/blender/io/wavefront_obj/exporter/obj_export_mtl.hh b/source/blender/io/wavefront_obj/exporter/obj_export_mtl.hh index 2f62d189bd1..a84dcb80a48 100644 --- a/source/blender/io/wavefront_obj/exporter/obj_export_mtl.hh +++ b/source/blender/io/wavefront_obj/exporter/obj_export_mtl.hh @@ -20,8 +20,8 @@ #pragma once -#include "BLI_float3.hh" #include "BLI_map.hh" +#include "BLI_math_vec_types.hh" #include "BLI_string_ref.hh" #include "BLI_vector.hh" diff --git a/source/blender/io/wavefront_obj/exporter/obj_export_nurbs.cc b/source/blender/io/wavefront_obj/exporter/obj_export_nurbs.cc index 91aabd8fa76..ec690115115 100644 --- a/source/blender/io/wavefront_obj/exporter/obj_export_nurbs.cc +++ b/source/blender/io/wavefront_obj/exporter/obj_export_nurbs.cc @@ -18,9 +18,9 @@ * \ingroup obj */ -#include "BLI_float3.hh" #include "BLI_listbase.h" #include "BLI_math.h" +#include "BLI_math_vec_types.hh" #include "DEG_depsgraph.h" #include "DEG_depsgraph_query.h" diff --git a/source/blender/modifiers/intern/MOD_mesh_to_volume.cc b/source/blender/modifiers/intern/MOD_mesh_to_volume.cc index 778b5746471..910b52dea67 100644 --- a/source/blender/modifiers/intern/MOD_mesh_to_volume.cc +++ b/source/blender/modifiers/intern/MOD_mesh_to_volume.cc @@ -197,8 +197,8 @@ static float compute_voxel_size(const ModifierEvalContext *ctx, /* Compute the voxel size based on the desired number of voxels and the approximated bounding box * of the volume. */ const BoundBox *bb = BKE_object_boundbox_get(mvmd->object); - const float diagonal = float3::distance(transform * float3(bb->vec[6]), - transform * float3(bb->vec[0])); + const float diagonal = math::distance(transform * float3(bb->vec[6]), + transform * float3(bb->vec[0])); const float approximate_volume_side_length = diagonal + mvmd->exterior_band_width * 2.0f; const float voxel_size = approximate_volume_side_length / mvmd->voxel_amount / volume_simplify; return voxel_size; diff --git a/source/blender/modifiers/intern/MOD_nodes.cc b/source/blender/modifiers/intern/MOD_nodes.cc index cee5d0be65d..49528845197 100644 --- a/source/blender/modifiers/intern/MOD_nodes.cc +++ b/source/blender/modifiers/intern/MOD_nodes.cc @@ -28,8 +28,8 @@ #include "MEM_guardedalloc.h" #include "BLI_array.hh" -#include "BLI_float3.hh" #include "BLI_listbase.h" +#include "BLI_math_vec_types.hh" #include "BLI_multi_value_map.hh" #include "BLI_set.hh" #include "BLI_string.h" diff --git a/source/blender/nodes/NOD_math_functions.hh b/source/blender/nodes/NOD_math_functions.hh index a0a2e6f81f8..6ea89beee2e 100644 --- a/source/blender/nodes/NOD_math_functions.hh +++ b/source/blender/nodes/NOD_math_functions.hh @@ -18,9 +18,9 @@ #include "DNA_node_types.h" -#include "BLI_float3.hh" #include "BLI_math_base_safe.h" #include "BLI_math_rotation.h" +#include "BLI_math_vec_types.hh" #include "BLI_string_ref.hh" namespace blender::nodes { @@ -240,6 +240,8 @@ template<typename Callback> inline bool try_dispatch_float_math_fl3_fl3_to_fl3(const NodeVectorMathOperation operation, Callback &&callback) { + using namespace blender::math; + const FloatMathOperationInfo *info = get_float3_math_operation_info(operation); if (info == nullptr) { return false; @@ -259,40 +261,21 @@ inline bool try_dispatch_float_math_fl3_fl3_to_fl3(const NodeVectorMathOperation case NODE_VECTOR_MATH_MULTIPLY: return dispatch([](float3 a, float3 b) { return a * b; }); case NODE_VECTOR_MATH_DIVIDE: - return dispatch([](float3 a, float3 b) { - return float3(safe_divide(a.x, b.x), safe_divide(a.y, b.y), safe_divide(a.z, b.z)); - }); + return dispatch([](float3 a, float3 b) { return safe_divide(a, b); }); case NODE_VECTOR_MATH_CROSS_PRODUCT: - return dispatch([](float3 a, float3 b) { return float3::cross_high_precision(a, b); }); + return dispatch([](float3 a, float3 b) { return cross_high_precision(a, b); }); case NODE_VECTOR_MATH_PROJECT: - return dispatch([](float3 a, float3 b) { - float length_squared = b.length_squared(); - return (length_squared != 0.0) ? (float3::dot(a, b) / length_squared) * b : float3(0.0f); - }); + return dispatch([](float3 a, float3 b) { return project(a, b); }); case NODE_VECTOR_MATH_REFLECT: - return dispatch([](float3 a, float3 b) { - b.normalize(); - return a.reflected(b); - }); + return dispatch([](float3 a, float3 b) { return reflect(a, normalize(b)); }); case NODE_VECTOR_MATH_SNAP: - return dispatch([](float3 a, float3 b) { - return float3(floor(safe_divide(a.x, b.x)), - floor(safe_divide(a.y, b.y)), - floor(safe_divide(a.z, b.z))) * - b; - }); + return dispatch([](float3 a, float3 b) { return floor(safe_divide(a, b)) * b; }); case NODE_VECTOR_MATH_MODULO: - return dispatch([](float3 a, float3 b) { - return float3(safe_modf(a.x, b.x), safe_modf(a.y, b.y), safe_modf(a.z, b.z)); - }); + return dispatch([](float3 a, float3 b) { return mod(a, b); }); case NODE_VECTOR_MATH_MINIMUM: - return dispatch([](float3 a, float3 b) { - return float3(min_ff(a.x, b.x), min_ff(a.y, b.y), min_ff(a.z, b.z)); - }); + return dispatch([](float3 a, float3 b) { return min(a, b); }); case NODE_VECTOR_MATH_MAXIMUM: - return dispatch([](float3 a, float3 b) { - return float3(max_ff(a.x, b.x), max_ff(a.y, b.y), max_ff(a.z, b.z)); - }); + return dispatch([](float3 a, float3 b) { return max(a, b); }); default: return false; } @@ -306,6 +289,8 @@ template<typename Callback> inline bool try_dispatch_float_math_fl3_fl3_to_fl(const NodeVectorMathOperation operation, Callback &&callback) { + using namespace blender::math; + const FloatMathOperationInfo *info = get_float3_math_operation_info(operation); if (info == nullptr) { return false; @@ -319,9 +304,9 @@ inline bool try_dispatch_float_math_fl3_fl3_to_fl(const NodeVectorMathOperation switch (operation) { case NODE_VECTOR_MATH_DOT_PRODUCT: - return dispatch([](float3 a, float3 b) { return float3::dot(a, b); }); + return dispatch([](float3 a, float3 b) { return dot(a, b); }); case NODE_VECTOR_MATH_DISTANCE: - return dispatch([](float3 a, float3 b) { return float3::distance(a, b); }); + return dispatch([](float3 a, float3 b) { return distance(a, b); }); default: return false; } @@ -335,6 +320,8 @@ template<typename Callback> inline bool try_dispatch_float_math_fl3_fl3_fl3_to_fl3(const NodeVectorMathOperation operation, Callback &&callback) { + using namespace blender::math; + const FloatMathOperationInfo *info = get_float3_math_operation_info(operation); if (info == nullptr) { return false; @@ -354,7 +341,7 @@ inline bool try_dispatch_float_math_fl3_fl3_fl3_to_fl3(const NodeVectorMathOpera return float3(wrapf(a.x, b.x, c.x), wrapf(a.y, b.y, c.y), wrapf(a.z, b.z, c.z)); }); case NODE_VECTOR_MATH_FACEFORWARD: - return dispatch([](float3 a, float3 b, float3 c) { return float3::faceforward(a, b, c); }); + return dispatch([](float3 a, float3 b, float3 c) { return faceforward(a, b, c); }); default: return false; } @@ -368,6 +355,8 @@ template<typename Callback> inline bool try_dispatch_float_math_fl3_fl3_fl_to_fl3(const NodeVectorMathOperation operation, Callback &&callback) { + using namespace blender::math; + const FloatMathOperationInfo *info = get_float3_math_operation_info(operation); if (info == nullptr) { return false; @@ -381,8 +370,7 @@ inline bool try_dispatch_float_math_fl3_fl3_fl_to_fl3(const NodeVectorMathOperat switch (operation) { case NODE_VECTOR_MATH_REFRACT: - return dispatch( - [](float3 a, float3 b, float c) { return float3::refract(a, b.normalized(), c); }); + return dispatch([](float3 a, float3 b, float c) { return refract(a, normalize(b), c); }); default: return false; } @@ -396,6 +384,8 @@ template<typename Callback> inline bool try_dispatch_float_math_fl3_to_fl(const NodeVectorMathOperation operation, Callback &&callback) { + using namespace blender::math; + const FloatMathOperationInfo *info = get_float3_math_operation_info(operation); if (info == nullptr) { return false; @@ -409,7 +399,7 @@ inline bool try_dispatch_float_math_fl3_to_fl(const NodeVectorMathOperation oper switch (operation) { case NODE_VECTOR_MATH_LENGTH: - return dispatch([](float3 in) { return in.length(); }); + return dispatch([](float3 in) { return length(in); }); default: return false; } @@ -450,6 +440,8 @@ template<typename Callback> inline bool try_dispatch_float_math_fl3_to_fl3(const NodeVectorMathOperation operation, Callback &&callback) { + using namespace blender::math; + const FloatMathOperationInfo *info = get_float3_math_operation_info(operation); if (info == nullptr) { return false; @@ -463,20 +455,15 @@ inline bool try_dispatch_float_math_fl3_to_fl3(const NodeVectorMathOperation ope switch (operation) { case NODE_VECTOR_MATH_NORMALIZE: - return dispatch([](float3 in) { - float3 out = in; - out.normalize(); - return out; - }); /* Should be safe. */ + return dispatch([](float3 in) { return normalize(in); }); /* Should be safe. */ case NODE_VECTOR_MATH_FLOOR: - return dispatch([](float3 in) { return float3(floor(in.x), floor(in.y), floor(in.z)); }); + return dispatch([](float3 in) { return floor(in); }); case NODE_VECTOR_MATH_CEIL: - return dispatch([](float3 in) { return float3(ceil(in.x), ceil(in.y), ceil(in.z)); }); + return dispatch([](float3 in) { return ceil(in); }); case NODE_VECTOR_MATH_FRACTION: - return dispatch( - [](float3 in) { return in - float3(floor(in.x), floor(in.y), floor(in.z)); }); + return dispatch([](float3 in) { return fract(in); }); case NODE_VECTOR_MATH_ABSOLUTE: - return dispatch([](float3 in) { return float3::abs(in); }); + return dispatch([](float3 in) { return abs(in); }); case NODE_VECTOR_MATH_SINE: return dispatch([](float3 in) { return float3(sinf(in.x), sinf(in.y), sinf(in.z)); }); case NODE_VECTOR_MATH_COSINE: diff --git a/source/blender/nodes/NOD_socket_declarations.hh b/source/blender/nodes/NOD_socket_declarations.hh index c0580a2c919..a1972c66ca2 100644 --- a/source/blender/nodes/NOD_socket_declarations.hh +++ b/source/blender/nodes/NOD_socket_declarations.hh @@ -21,7 +21,7 @@ #include "RNA_types.h" #include "BLI_color.hh" -#include "BLI_float3.hh" +#include "BLI_math_vec_types.hh" namespace blender::nodes::decl { diff --git a/source/blender/nodes/function/node_function_util.hh b/source/blender/nodes/function/node_function_util.hh index acde9c4b55b..69c617b4f01 100644 --- a/source/blender/nodes/function/node_function_util.hh +++ b/source/blender/nodes/function/node_function_util.hh @@ -18,7 +18,7 @@ #include <string.h> -#include "BLI_float3.hh" +#include "BLI_math_vec_types.hh" #include "BLI_utildefines.h" #include "MEM_guardedalloc.h" diff --git a/source/blender/nodes/function/nodes/node_fn_align_euler_to_vector.cc b/source/blender/nodes/function/nodes/node_fn_align_euler_to_vector.cc index f4ce8d2f35a..bcc035e6ede 100644 --- a/source/blender/nodes/function/nodes/node_fn_align_euler_to_vector.cc +++ b/source/blender/nodes/function/nodes/node_fn_align_euler_to_vector.cc @@ -69,14 +69,14 @@ static void align_rotations_auto_pivot(IndexMask mask, float3 old_axis; mul_v3_m3v3(old_axis, old_rotation, local_main_axis); - const float3 new_axis = vector.normalized(); - float3 rotation_axis = float3::cross_high_precision(old_axis, new_axis); + const float3 new_axis = math::normalize(vector); + float3 rotation_axis = math::cross_high_precision(old_axis, new_axis); if (is_zero_v3(rotation_axis)) { /* The vectors are linearly dependent, so we fall back to another axis. */ - rotation_axis = float3::cross_high_precision(old_axis, float3(1, 0, 0)); + rotation_axis = math::cross_high_precision(old_axis, float3(1, 0, 0)); if (is_zero_v3(rotation_axis)) { /* This is now guaranteed to not be zero. */ - rotation_axis = float3::cross_high_precision(old_axis, float3(0, 1, 0)); + rotation_axis = math::cross_high_precision(old_axis, float3(0, 1, 0)); } } diff --git a/source/blender/nodes/function/nodes/node_fn_compare.cc b/source/blender/nodes/function/nodes/node_fn_compare.cc index 3bb46511eeb..7c09bace756 100644 --- a/source/blender/nodes/function/nodes/node_fn_compare.cc +++ b/source/blender/nodes/function/nodes/node_fn_compare.cc @@ -265,7 +265,7 @@ static const fn::MultiFunction *get_multi_function(bNode &node) case NODE_COMPARE_MODE_DOT_PRODUCT: { static fn::CustomMF_SI_SI_SI_SO<float3, float3, float, bool> fn{ "Less Than - Dot Product", - [](float3 a, float3 b, float comp) { return float3::dot(a, b) < comp; }}; + [](float3 a, float3 b, float comp) { return math::dot(a, b) < comp; }}; return &fn; } case NODE_COMPARE_MODE_DIRECTION: { @@ -283,7 +283,7 @@ static const fn::MultiFunction *get_multi_function(bNode &node) case NODE_COMPARE_MODE_LENGTH: { static fn::CustomMF_SI_SI_SO<float3, float3, bool> fn{ "Less Than - Length", - [](float3 a, float3 b) { return a.length() < b.length(); }}; + [](float3 a, float3 b) { return math::length(a) < math::length(b); }}; return &fn; } } @@ -299,7 +299,7 @@ static const fn::MultiFunction *get_multi_function(bNode &node) case NODE_COMPARE_MODE_DOT_PRODUCT: { static fn::CustomMF_SI_SI_SI_SO<float3, float3, float, bool> fn{ "Less Equal - Dot Product", - [](float3 a, float3 b, float comp) { return float3::dot(a, b) <= comp; }}; + [](float3 a, float3 b, float comp) { return math::dot(a, b) <= comp; }}; return &fn; } case NODE_COMPARE_MODE_DIRECTION: { @@ -317,7 +317,7 @@ static const fn::MultiFunction *get_multi_function(bNode &node) case NODE_COMPARE_MODE_LENGTH: { static fn::CustomMF_SI_SI_SO<float3, float3, bool> fn{ "Less Equal - Length", - [](float3 a, float3 b) { return a.length() <= b.length(); }}; + [](float3 a, float3 b) { return math::length(a) <= math::length(b); }}; return &fn; } } @@ -333,7 +333,7 @@ static const fn::MultiFunction *get_multi_function(bNode &node) case NODE_COMPARE_MODE_DOT_PRODUCT: { static fn::CustomMF_SI_SI_SI_SO<float3, float3, float, bool> fn{ "Greater Than - Dot Product", - [](float3 a, float3 b, float comp) { return float3::dot(a, b) > comp; }}; + [](float3 a, float3 b, float comp) { return math::dot(a, b) > comp; }}; return &fn; } case NODE_COMPARE_MODE_DIRECTION: { @@ -351,7 +351,7 @@ static const fn::MultiFunction *get_multi_function(bNode &node) case NODE_COMPARE_MODE_LENGTH: { static fn::CustomMF_SI_SI_SO<float3, float3, bool> fn{ "Greater Than - Length", - [](float3 a, float3 b) { return a.length() > b.length(); }}; + [](float3 a, float3 b) { return math::length(a) > math::length(b); }}; return &fn; } } @@ -367,7 +367,7 @@ static const fn::MultiFunction *get_multi_function(bNode &node) case NODE_COMPARE_MODE_DOT_PRODUCT: { static fn::CustomMF_SI_SI_SI_SO<float3, float3, float, bool> fn{ "Greater Equal - Dot Product", - [](float3 a, float3 b, float comp) { return float3::dot(a, b) >= comp; }}; + [](float3 a, float3 b, float comp) { return math::dot(a, b) >= comp; }}; return &fn; } case NODE_COMPARE_MODE_DIRECTION: { @@ -385,7 +385,7 @@ static const fn::MultiFunction *get_multi_function(bNode &node) case NODE_COMPARE_MODE_LENGTH: { static fn::CustomMF_SI_SI_SO<float3, float3, bool> fn{ "Greater Equal - Length", - [](float3 a, float3 b) { return a.length() >= b.length(); }}; + [](float3 a, float3 b) { return math::length(a) >= math::length(b); }}; return &fn; } } @@ -402,7 +402,7 @@ static const fn::MultiFunction *get_multi_function(bNode &node) case NODE_COMPARE_MODE_DOT_PRODUCT: { static fn::CustomMF_SI_SI_SI_SI_SO<float3, float3, float, float, bool> fn{ "Equal - Dot Product", [](float3 a, float3 b, float comp, float epsilon) { - return abs(float3::dot(a, b) - comp) <= epsilon; + return abs(math::dot(a, b) - comp) <= epsilon; }}; return &fn; } @@ -424,7 +424,7 @@ static const fn::MultiFunction *get_multi_function(bNode &node) case NODE_COMPARE_MODE_LENGTH: { static fn::CustomMF_SI_SI_SI_SO<float3, float3, float, bool> fn{ "Equal - Length", [](float3 a, float3 b, float epsilon) { - return abs(a.length() - b.length()) <= epsilon; + return abs(math::length(a) - math::length(b)) <= epsilon; }}; return &fn; } @@ -442,7 +442,7 @@ static const fn::MultiFunction *get_multi_function(bNode &node) case NODE_COMPARE_MODE_DOT_PRODUCT: { static fn::CustomMF_SI_SI_SI_SI_SO<float3, float3, float, float, bool> fn{ "Not Equal - Dot Product", [](float3 a, float3 b, float comp, float epsilon) { - return abs(float3::dot(a, b) - comp) >= epsilon; + return abs(math::dot(a, b) - comp) >= epsilon; }}; return &fn; } @@ -464,7 +464,7 @@ static const fn::MultiFunction *get_multi_function(bNode &node) case NODE_COMPARE_MODE_LENGTH: { static fn::CustomMF_SI_SI_SI_SO<float3, float3, float, bool> fn{ "Not Equal - Length", [](float3 a, float3 b, float epsilon) { - return abs(a.length() - b.length()) > epsilon; + return abs(math::length(a) - math::length(b)) > epsilon; }}; return &fn; } diff --git a/source/blender/nodes/geometry/node_geometry_util.hh b/source/blender/nodes/geometry/node_geometry_util.hh index 1c2a8f521c0..dddc3527124 100644 --- a/source/blender/nodes/geometry/node_geometry_util.hh +++ b/source/blender/nodes/geometry/node_geometry_util.hh @@ -18,7 +18,7 @@ #include <string.h> -#include "BLI_float3.hh" +#include "BLI_math_vec_types.hh" #include "BLI_utildefines.h" #include "MEM_guardedalloc.h" diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_align_rotation_to_vector.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_align_rotation_to_vector.cc index 36ad4605a4b..1d064586238 100644 --- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_align_rotation_to_vector.cc +++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_align_rotation_to_vector.cc @@ -90,14 +90,14 @@ static void align_rotations_auto_pivot(const VArray<float3> &vectors, float3 old_axis; mul_v3_m3v3(old_axis, old_rotation, local_main_axis); - const float3 new_axis = vector.normalized(); - float3 rotation_axis = float3::cross_high_precision(old_axis, new_axis); + const float3 new_axis = math::normalize(vector); + float3 rotation_axis = math::cross_high_precision(old_axis, new_axis); if (is_zero_v3(rotation_axis)) { /* The vectors are linearly dependent, so we fall back to another axis. */ - rotation_axis = float3::cross_high_precision(old_axis, float3(1, 0, 0)); + rotation_axis = math::cross_high_precision(old_axis, float3(1, 0, 0)); if (is_zero_v3(rotation_axis)) { /* This is now guaranteed to not be zero. */ - rotation_axis = float3::cross_high_precision(old_axis, float3(0, 1, 0)); + rotation_axis = math::cross_high_precision(old_axis, float3(0, 1, 0)); } } diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_proximity.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_proximity.cc index 74dac73f255..20f500b1bd8 100644 --- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_proximity.cc +++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_proximity.cc @@ -81,7 +81,7 @@ static void calculate_mesh_proximity(const VArray<float3> &positions, for (int i : range) { /* Use the distance to the last found point as upper bound to speedup the bvh lookup. */ - nearest.dist_sq = float3::distance_squared(nearest.co, positions[i]); + nearest.dist_sq = math::distance_squared(float3(nearest.co), positions[i]); BLI_bvhtree_find_nearest( bvh_data.tree, positions[i], &nearest, bvh_data.nearest_callback, &bvh_data); diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_transfer.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_transfer.cc index b0210f2eb94..a85a7c56cb9 100644 --- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_transfer.cc +++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_attribute_transfer.cc @@ -229,7 +229,7 @@ static void get_closest_mesh_corners(const Mesh &mesh, const MLoop &loop = mesh.mloop[loop_index]; const int vertex_index = loop.v; const MVert &mvert = mesh.mvert[vertex_index]; - const float distance_sq = float3::distance_squared(position, mvert.co); + const float distance_sq = math::distance_squared(position, float3(mvert.co)); if (distance_sq < min_distance_sq) { min_distance_sq = distance_sq; closest_loop_index = loop_index; diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_to_points.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_to_points.cc index 8555d7cc8a3..1e6b7f92a77 100644 --- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_to_points.cc +++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_curve_to_points.cc @@ -241,13 +241,13 @@ static void copy_uniform_sample_point_attributes(Span<SplinePtr> splines, spline.sample_with_index_factors<float3>( spline.evaluated_tangents(), uniform_samples, data.tangents.slice(offset, size)); for (float3 &tangent : data.tangents) { - tangent.normalize(); + tangent = math::normalize(tangent); } spline.sample_with_index_factors<float3>( spline.evaluated_normals(), uniform_samples, data.normals.slice(offset, size)); for (float3 &normals : data.normals) { - normals.normalize(); + normals = math::normalize(normals); } } }); diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_points_to_volume.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_points_to_volume.cc index 7b1bbed8ae4..f54ffc53a6e 100644 --- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_points_to_volume.cc +++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_points_to_volume.cc @@ -161,7 +161,7 @@ static float compute_voxel_size(const GeoNodeExecParams ¶ms, } /* The voxel size adapts to the final size of the volume. */ - const float diagonal = float3::distance(min, max); + const float diagonal = math::distance(min, max); const float extended_diagonal = diagonal + 2.0f * radius; const float voxel_size = extended_diagonal / voxel_amount; return voxel_size; diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_raycast.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_raycast.cc index dd03092a594..cfae88e0625 100644 --- a/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_raycast.cc +++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_legacy_raycast.cc @@ -107,7 +107,7 @@ static void raycast_to_mesh(const Mesh &mesh, for (const int i : ray_origins.index_range()) { const float ray_length = ray_lengths[i]; const float3 ray_origin = ray_origins[i]; - const float3 ray_direction = ray_directions[i].normalized(); + const float3 ray_direction = math::normalize(ray_directions[i]); BVHTreeRayHit hit; hit.index = -1; diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc index 7e09721273a..929d9046f98 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc @@ -16,7 +16,7 @@ #include "BLI_array.hh" #include "BLI_delaunay_2d.h" -#include "BLI_double2.hh" +#include "BLI_math_vec_types.hh" #include "DNA_mesh_types.h" #include "DNA_meshdata_types.h" diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc index 1a44fce86a6..68b609f8045 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_fillet.cc @@ -122,9 +122,9 @@ static Array<float3> calculate_directions(const Span<float3> positions) Array<float3> directions(size); for (const int i : IndexRange(size - 1)) { - directions[i] = (positions[i + 1] - positions[i]).normalized(); + directions[i] = math::normalize(positions[i + 1] - positions[i]); } - directions[size - 1] = (positions[0] - positions[size - 1]).normalized(); + directions[size - 1] = math::normalize(positions[0] - positions[size - 1]); return directions; } @@ -135,9 +135,9 @@ static Array<float3> calculate_axes(const Span<float3> directions) const int size = directions.size(); Array<float3> axes(size); - axes[0] = float3::cross(-directions[size - 1], directions[0]).normalized(); + axes[0] = math::normalize(math::cross(-directions[size - 1], directions[0])); for (const int i : IndexRange(1, size - 1)) { - axes[i] = float3::cross(-directions[i - 1], directions[i]).normalized(); + axes[i] = math::normalize(math::cross(-directions[i - 1], directions[i])); } return axes; @@ -248,8 +248,8 @@ static void limit_radii(FilletData &fd, const bool cyclic) if (cyclic) { /* Calculate lengths between adjacent control points. */ - const float len_prev = float3::distance(positions[0], positions[size - 1]); - const float len_next = float3::distance(positions[0], positions[1]); + const float len_prev = math::distance(positions[0], positions[size - 1]); + const float len_next = math::distance(positions[0], positions[1]); /* Calculate tangent lengths of fillets in control points. */ const float tan_len = radii[0] * tan(angles[0] / 2.0f); @@ -271,16 +271,16 @@ static void limit_radii(FilletData &fd, const bool cyclic) } /* Initialize max_radii to largest possible radii. */ - float prev_dist = float3::distance(positions[1], positions[0]); + float prev_dist = math::distance(positions[1], positions[0]); for (const int i : IndexRange(1, size - 2)) { - const float temp_dist = float3::distance(positions[i], positions[i + 1]); + const float temp_dist = math::distance(positions[i], positions[i + 1]); max_radii[i] = std::min(prev_dist, temp_dist) / tan(angles[i] / 2.0f); prev_dist = temp_dist; } /* Max radii calculations for each index. */ for (const int i : IndexRange(start, fillet_count - 1)) { - const float len_next = float3::distance(positions[i], positions[i + 1]); + const float len_next = math::distance(positions[i], positions[i + 1]); const float tan_len = radii[i] * tan(angles[i] / 2.0f); const float tan_len_next = radii[i + 1] * tan(angles[i + 1] / 2.0f); @@ -415,7 +415,8 @@ static void update_bezier_positions(const FilletData &fd, const float3 center = get_center(dst_spline.positions()[i_dst] - positions[i_src], fd, i_src); /* Calculate the vector of the radius formed by the first vertex. */ float3 radius_vec = dst_spline.positions()[i_dst] - center; - const float radius = radius_vec.normalize_and_get_length(); + float radius; + radius_vec = math::normalize_and_get_length(radius_vec, radius); dst_spline.handle_types_right().slice(1, count - 2).fill(BezierSpline::HandleType::Align); dst_spline.handle_types_left().slice(1, count - 2).fill(BezierSpline::HandleType::Align); diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_circle.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_circle.cc index a7fb493c7d7..7b5d1a1dc80 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_circle.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_circle.cc @@ -101,8 +101,8 @@ static void node_update(bNodeTree *ntree, bNode *node) static bool colinear_f3_f3_f3(const float3 p1, const float3 p2, const float3 p3) { - const float3 a = (p2 - p1).normalized(); - const float3 b = (p3 - p1).normalized(); + const float3 a = math::normalize(p2 - p1); + const float3 b = math::normalize(p3 - p1); return (ELEM(a, b, b * -1.0f)); } @@ -122,18 +122,18 @@ static std::unique_ptr<CurveEval> create_point_circle_curve( float3 center; /* Midpoints of `P1->P2` and `P2->P3`. */ - const float3 q1 = float3::interpolate(p1, p2, 0.5f); - const float3 q2 = float3::interpolate(p2, p3, 0.5f); + const float3 q1 = math::interpolate(p1, p2, 0.5f); + const float3 q2 = math::interpolate(p2, p3, 0.5f); /* Normal Vectors of `P1->P2` and `P2->P3` */ - const float3 v1 = (p2 - p1).normalized(); - const float3 v2 = (p3 - p2).normalized(); + const float3 v1 = math::normalize(p2 - p1); + const float3 v2 = math::normalize(p3 - p2); /* Normal of plane of main 2 segments P1->P2 and `P2->P3`. */ - const float3 v3 = float3::cross(v1, v2).normalized(); + const float3 v3 = math::normalize(math::cross(v1, v2)); /* Normal of plane of first perpendicular bisector and `P1->P2`. */ - const float3 v4 = float3::cross(v3, v1).normalized(); + const float3 v4 = math::normalize(math::cross(v3, v1)); /* Determine Center-point from the intersection of 3 planes. */ float plane_1[4], plane_2[4], plane_3[4]; @@ -148,7 +148,7 @@ static std::unique_ptr<CurveEval> create_point_circle_curve( } /* Get the radius from the center-point to p1. */ - const float r = float3::distance(p1, center); + const float r = math::distance(p1, center); const float theta_step = ((2 * M_PI) / (float)resolution); for (const int i : IndexRange(resolution)) { diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_line.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_line.cc index ff9218b1ac2..d35fa0a2fdc 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_line.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_line.cc @@ -100,7 +100,7 @@ static std::unique_ptr<CurveEval> create_direction_line_curve(const float3 start spline->resize(2); MutableSpan<float3> positions = spline->positions(); positions[0] = start; - positions[1] = direction.normalized() * length + start; + positions[1] = math::normalize(direction) * length + start; spline->radii().fill(1.0f); spline->tilts().fill(0.0f); diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadratic_bezier.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadratic_bezier.cc index 084d27e9d24..885d92a111b 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadratic_bezier.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_primitive_quadratic_bezier.cc @@ -58,9 +58,9 @@ static std::unique_ptr<CurveEval> create_quadratic_bezier_curve(const float3 p1, const float step = 1.0f / resolution; for (const int i : IndexRange(resolution + 1)) { const float factor = step * i; - const float3 q1 = float3::interpolate(p1, p2, factor); - const float3 q2 = float3::interpolate(p2, p3, factor); - positions[i] = float3::interpolate(q1, q2, factor); + const float3 q1 = math::interpolate(p1, p2, factor); + const float3 q2 = math::interpolate(p2, p3, factor); + positions[i] = math::interpolate(q1, q2, factor); } curve->add_spline(std::move(spline)); diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_sample.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_sample.cc index 038f7625825..56fbc50f033 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_sample.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_sample.cc @@ -185,7 +185,7 @@ class SampleCurveFunction : public fn::MultiFunction { for (const int i : mask) { const Spline::LookupResult &lookup = lookups[i]; const Span<float3> evaluated_tangents = splines[spline_indices[i]]->evaluated_tangents(); - sampled_tangents[i] = sample_with_lookup(lookup, evaluated_tangents).normalized(); + sampled_tangents[i] = math::normalize(sample_with_lookup(lookup, evaluated_tangents)); } } @@ -193,7 +193,7 @@ class SampleCurveFunction : public fn::MultiFunction { for (const int i : mask) { const Spline::LookupResult &lookup = lookups[i]; const Span<float3> evaluated_normals = splines[spline_indices[i]]->evaluated_normals(); - sampled_normals[i] = sample_with_lookup(lookup, evaluated_normals).normalized(); + sampled_normals[i] = math::normalize(sample_with_lookup(lookup, evaluated_normals)); } } } diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_spline_parameter.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_spline_parameter.cc index 40dde645756..257a5b8df00 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_spline_parameter.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_spline_parameter.cc @@ -96,7 +96,7 @@ static void calculate_nurbs_lengths(const NURBSpline &spline, MutableSpan<float> float length = 0.0f; for (const int i : IndexRange(positions.size() - 1)) { lengths[i] = length; - length += float3::distance(positions[i], positions[i + 1]); + length += math::distance(positions[i], positions[i + 1]); } lengths.last() = length; } diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc index a8553b636a4..19efd4b7508 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc @@ -285,7 +285,7 @@ static void copy_uniform_sample_point_attributes(const Span<SplinePtr> splines, spline.sample_with_index_factors<float3>( spline.evaluated_tangents(), uniform_samples, data.tangents.slice(offset, size)); for (float3 &tangent : data.tangents) { - tangent.normalize(); + tangent = math::normalize(tangent); } } @@ -293,7 +293,7 @@ static void copy_uniform_sample_point_attributes(const Span<SplinePtr> splines, spline.sample_with_index_factors<float3>( spline.evaluated_normals(), uniform_samples, data.normals.slice(offset, size)); for (float3 &normals : data.normals) { - normals.normalize(); + normals = math::normalize(normals); } } } diff --git a/source/blender/nodes/geometry/nodes/node_geo_image_texture.cc b/source/blender/nodes/geometry/nodes/node_geo_image_texture.cc index 28a8fb80294..624a8b6b0f6 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_image_texture.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_image_texture.cc @@ -21,7 +21,7 @@ #include "BKE_image.h" -#include "BLI_float4.hh" +#include "BLI_math_vec_types.hh" #include "BLI_threads.h" #include "BLI_timeit.hh" diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_line.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_line.cc index 5116e78fdda..8a2b054ece0 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_line.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_line.cc @@ -155,8 +155,8 @@ static void node_geo_exec(GeoNodeExecParams params) if (count_mode == GEO_NODE_MESH_LINE_COUNT_RESOLUTION) { /* Don't allow asymptotic count increase for low resolution values. */ const float resolution = std::max(params.extract_input<float>("Resolution"), 0.0001f); - const int count = total_delta.length() / resolution + 1; - const float3 delta = total_delta.normalized() * resolution; + const int count = math::length(total_delta) / resolution + 1; + const float3 delta = math::normalize(total_delta) * resolution; mesh = create_line_mesh(start, delta, count); } else if (count_mode == GEO_NODE_MESH_LINE_COUNT_TOTAL) { @@ -204,7 +204,7 @@ Mesh *create_line_mesh(const float3 start, const float3 delta, const int count) MutableSpan<MEdge> edges{mesh->medge, mesh->totedge}; short normal[3]; - normal_float_to_short_v3(normal, delta.normalized()); + normal_float_to_short_v3(normal, math::normalize(delta)); for (const int i : verts.index_range()) { copy_v3_v3(verts[i].co, start + delta * i); diff --git a/source/blender/nodes/geometry/nodes/node_geo_points_to_volume.cc b/source/blender/nodes/geometry/nodes/node_geo_points_to_volume.cc index dda4543d5e1..c165bcf8e35 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_points_to_volume.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_points_to_volume.cc @@ -166,7 +166,7 @@ static float compute_voxel_size(const GeoNodeExecParams ¶ms, } /* The voxel size adapts to the final size of the volume. */ - const float diagonal = float3::distance(min, max); + const float diagonal = math::distance(min, max); const float extended_diagonal = diagonal + 2.0f * radius; const float voxel_size = extended_diagonal / voxel_amount; return voxel_size; diff --git a/source/blender/nodes/geometry/nodes/node_geo_proximity.cc b/source/blender/nodes/geometry/nodes/node_geo_proximity.cc index e0117c4726d..772638ef240 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_proximity.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_proximity.cc @@ -85,7 +85,7 @@ static bool calculate_mesh_proximity(const VArray<float3> &positions, for (int i : range) { const int index = mask[i]; /* Use the distance to the last found point as upper bound to speedup the bvh lookup. */ - nearest.dist_sq = float3::distance_squared(nearest.co, positions[index]); + nearest.dist_sq = math::distance_squared(float3(nearest.co), positions[index]); BLI_bvhtree_find_nearest( bvh_data.tree, positions[index], &nearest, bvh_data.nearest_callback, &bvh_data); diff --git a/source/blender/nodes/geometry/nodes/node_geo_raycast.cc b/source/blender/nodes/geometry/nodes/node_geo_raycast.cc index 2c35ca0afc9..c38503f688c 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_raycast.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_raycast.cc @@ -163,7 +163,7 @@ static void raycast_to_mesh(IndexMask mask, for (const int i : mask) { const float ray_length = ray_lengths[i]; const float3 ray_origin = ray_origins[i]; - const float3 ray_direction = ray_directions[i].normalized(); + const float3 ray_direction = math::normalize(ray_directions[i]); BVHTreeRayHit hit; hit.index = -1; diff --git a/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc b/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc index 331460296a6..6867051ecfe 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc @@ -296,7 +296,7 @@ static void get_closest_mesh_corners(const Mesh &mesh, const MLoop &loop = mesh.mloop[loop_index]; const int vertex_index = loop.v; const MVert &mvert = mesh.mvert[vertex_index]; - const float distance_sq = float3::distance_squared(position, mvert.co); + const float distance_sq = math::distance_squared(position, float3(mvert.co)); if (distance_sq < min_distance_sq) { min_distance_sq = distance_sq; closest_loop_index = loop_index; diff --git a/source/blender/nodes/geometry/nodes/node_geo_transform.cc b/source/blender/nodes/geometry/nodes/node_geo_transform.cc index 7f866ea6f4a..6187a2eacf9 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_transform.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_transform.cc @@ -37,7 +37,7 @@ namespace blender::nodes { static bool use_translate(const float3 rotation, const float3 scale) { - if (compare_ff(rotation.length_squared(), 0.0f, 1e-9f) != 1) { + if (compare_ff(math::length_squared(rotation), 0.0f, 1e-9f) != 1) { return false; } if (compare_ff(scale.x, 1.0f, 1e-9f) != 1 || compare_ff(scale.y, 1.0f, 1e-9f) != 1 || @@ -49,7 +49,7 @@ static bool use_translate(const float3 rotation, const float3 scale) static void translate_mesh(Mesh &mesh, const float3 translation) { - if (!translation.is_zero()) { + if (!math::is_zero(translation)) { BKE_mesh_translate(&mesh, translation, false); } } diff --git a/source/blender/nodes/intern/node_socket.cc b/source/blender/nodes/intern/node_socket.cc index 6a6b6e3d3cc..ed72580ccf1 100644 --- a/source/blender/nodes/intern/node_socket.cc +++ b/source/blender/nodes/intern/node_socket.cc @@ -26,8 +26,8 @@ #include "DNA_node_types.h" #include "BLI_color.hh" -#include "BLI_float3.hh" #include "BLI_listbase.h" +#include "BLI_math_vec_types.hh" #include "BLI_string.h" #include "BLI_utildefines.h" diff --git a/source/blender/nodes/shader/node_shader_util.hh b/source/blender/nodes/shader/node_shader_util.hh index 9d4d57d01dd..5a5b4f613f3 100644 --- a/source/blender/nodes/shader/node_shader_util.hh +++ b/source/blender/nodes/shader/node_shader_util.hh @@ -29,9 +29,9 @@ #include "BLI_blenlib.h" #include "BLI_color.hh" -#include "BLI_float3.hh" #include "BLI_math.h" #include "BLI_math_base_safe.h" +#include "BLI_math_vec_types.hh" #include "BLI_rand.h" #include "BLI_threads.h" #include "BLI_utildefines.h" diff --git a/source/blender/nodes/shader/nodes/node_shader_map_range.cc b/source/blender/nodes/shader/nodes/node_shader_map_range.cc index 3276a1bfd72..bc7ca661a77 100644 --- a/source/blender/nodes/shader/nodes/node_shader_map_range.cc +++ b/source/blender/nodes/shader/nodes/node_shader_map_range.cc @@ -272,7 +272,7 @@ class MapRangeVectorFunction : public blender::fn::MultiFunction { blender::MutableSpan<float3> results = params.uninitialized_single_output<float3>(5, "Vector"); for (int64_t i : mask) { - float3 factor = float3::safe_divide(values[i] - from_min[i], from_max[i] - from_min[i]); + float3 factor = math::safe_divide(values[i] - from_min[i], from_max[i] - from_min[i]); results[i] = factor * (to_max[i] - to_min[i]) + to_min[i]; } @@ -315,8 +315,8 @@ class MapRangeSteppedVectorFunction : public blender::fn::MultiFunction { blender::MutableSpan<float3> results = params.uninitialized_single_output<float3>(6, "Vector"); for (int64_t i : mask) { - float3 factor = float3::safe_divide(values[i] - from_min[i], from_max[i] - from_min[i]); - factor = float3::safe_divide(float3::floor(factor * (steps[i] + 1.0f)), steps[i]); + float3 factor = math::safe_divide(values[i] - from_min[i], from_max[i] - from_min[i]); + factor = math::safe_divide(math::floor(factor * (steps[i] + 1.0f)), steps[i]); results[i] = factor * (to_max[i] - to_min[i]) + to_min[i]; } @@ -355,7 +355,7 @@ class MapRangeSmoothstepVectorFunction : public blender::fn::MultiFunction { blender::MutableSpan<float3> results = params.uninitialized_single_output<float3>(5, "Vector"); for (int64_t i : mask) { - float3 factor = float3::safe_divide(values[i] - from_min[i], from_max[i] - from_min[i]); + float3 factor = math::safe_divide(values[i] - from_min[i], from_max[i] - from_min[i]); clamp_v3(factor, 0.0f, 1.0f); factor = (float3(3.0f) - 2.0f * factor) * (factor * factor); results[i] = factor * (to_max[i] - to_min[i]) + to_min[i]; @@ -390,7 +390,7 @@ class MapRangeSmootherstepVectorFunction : public blender::fn::MultiFunction { blender::MutableSpan<float3> results = params.uninitialized_single_output<float3>(5, "Vector"); for (int64_t i : mask) { - float3 factor = float3::safe_divide(values[i] - from_min[i], from_max[i] - from_min[i]); + float3 factor = math::safe_divide(values[i] - from_min[i], from_max[i] - from_min[i]); clamp_v3(factor, 0.0f, 1.0f); factor = factor * factor * factor * (factor * (factor * 6.0f - 15.0f) + 10.0f); results[i] = factor * (to_max[i] - to_min[i]) + to_min[i]; diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_brick.cc b/source/blender/nodes/shader/nodes/node_shader_tex_brick.cc index 61b1613c11a..81a69ef18da 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_brick.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tex_brick.cc @@ -19,8 +19,7 @@ #include "node_shader_util.hh" -#include "BLI_float2.hh" -#include "BLI_float4.hh" +#include "BLI_math_vec_types.hh" #include "UI_interface.h" #include "UI_resources.h" diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_gradient.cc b/source/blender/nodes/shader/nodes/node_shader_tex_gradient.cc index 85e0f262ca7..53be5bc09d9 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_gradient.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tex_gradient.cc @@ -130,7 +130,7 @@ class GradientFunction : public fn::MultiFunction { /* Bias a little bit for the case where input is a unit length vector, * to get exactly zero instead of a small random value depending * on float precision. */ - const float r = std::max(0.999999f - vector[i].length(), 0.0f); + const float r = std::max(0.999999f - math::length(vector[i]), 0.0f); fac[i] = r * r; } break; @@ -140,7 +140,7 @@ class GradientFunction : public fn::MultiFunction { /* Bias a little bit for the case where input is a unit length vector, * to get exactly zero instead of a small random value depending * on float precision. */ - fac[i] = std::max(0.999999f - vector[i].length(), 0.0f); + fac[i] = std::max(0.999999f - math::length(vector[i]), 0.0f); } break; } diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_noise.cc b/source/blender/nodes/shader/nodes/node_shader_tex_noise.cc index 0e549859a39..1c703313edf 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_noise.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tex_noise.cc @@ -176,14 +176,14 @@ class NoiseFunction : public fn::MultiFunction { const VArray<float3> &vector = params.readonly_single_input<float3>(0, "Vector"); if (compute_factor) { for (int64_t i : mask) { - const float2 position = vector[i] * scale[i]; + const float2 position = float2(vector[i] * scale[i]); r_factor[i] = noise::perlin_fractal_distorted( position, detail[i], roughness[i], distortion[i]); } } if (compute_color) { for (int64_t i : mask) { - const float2 position = vector[i] * scale[i]; + const float2 position = float2(vector[i] * scale[i]); const float3 c = noise::perlin_float3_fractal_distorted( position, detail[i], roughness[i], distortion[i]); r_color[i] = ColorGeometry4f(c[0], c[1], c[2], 1.0f); diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc b/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc index 2b5c1ddfe21..209f96449cd 100644 --- a/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc +++ b/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc @@ -313,7 +313,7 @@ class VoronoiMinowskiFunction : public fn::MultiFunction { r_color[i] = ColorGeometry4f(col[0], col[1], col[2], 1.0f); } if (calc_position) { - pos = float2::safe_divide(pos, scale[i]); + pos = math::safe_divide(pos, scale[i]); r_position[i] = float3(pos.x, pos.y, 0.0f); } } @@ -345,7 +345,7 @@ class VoronoiMinowskiFunction : public fn::MultiFunction { r_color[i] = ColorGeometry4f(col[0], col[1], col[2], 1.0f); } if (calc_position) { - pos = float2::safe_divide(pos, scale[i]); + pos = math::safe_divide(pos, scale[i]); r_position[i] = float3(pos.x, pos.y, 0.0f); } } @@ -380,7 +380,7 @@ class VoronoiMinowskiFunction : public fn::MultiFunction { r_color[i] = ColorGeometry4f(col[0], col[1], col[2], 1.0f); } if (calc_position) { - pos = float2::safe_divide(pos, scale[i]); + pos = math::safe_divide(pos, scale[i]); r_position[i] = float3(pos.x, pos.y, 0.0f); } } @@ -416,7 +416,7 @@ class VoronoiMinowskiFunction : public fn::MultiFunction { r_color[i] = ColorGeometry4f(col[0], col[1], col[2], 1.0f); } if (calc_position) { - r_position[i] = float3::safe_divide(r_position[i], scale[i]); + r_position[i] = math::safe_divide(r_position[i], scale[i]); } } break; @@ -446,7 +446,7 @@ class VoronoiMinowskiFunction : public fn::MultiFunction { r_color[i] = ColorGeometry4f(col[0], col[1], col[2], 1.0f); } if (calc_position) { - r_position[i] = float3::safe_divide(r_position[i], scale[i]); + r_position[i] = math::safe_divide(r_position[i], scale[i]); } } break; @@ -479,7 +479,7 @@ class VoronoiMinowskiFunction : public fn::MultiFunction { r_color[i] = ColorGeometry4f(col[0], col[1], col[2], 1.0f); } if (calc_position) { - r_position[i] = float3::safe_divide(r_position[i], scale[i]); + r_position[i] = math::safe_divide(r_position[i], scale[i]); } } break; @@ -519,7 +519,7 @@ class VoronoiMinowskiFunction : public fn::MultiFunction { r_color[i] = ColorGeometry4f(col[0], col[1], col[2], 1.0f); } if (calc_position || calc_w) { - pos = float4::safe_divide(pos, scale[i]); + pos = math::safe_divide(pos, scale[i]); if (calc_position) { r_position[i] = float3(pos.x, pos.y, pos.z); } @@ -560,7 +560,7 @@ class VoronoiMinowskiFunction : public fn::MultiFunction { r_color[i] = ColorGeometry4f(col[0], col[1], col[2], 1.0f); } if (calc_position || calc_w) { - pos = float4::safe_divide(pos, scale[i]); + pos = math::safe_divide(pos, scale[i]); if (calc_position) { r_position[i] = float3(pos.x, pos.y, pos.z); } @@ -604,7 +604,7 @@ class VoronoiMinowskiFunction : public fn::MultiFunction { r_color[i] = ColorGeometry4f(col[0], col[1], col[2], 1.0f); } if (calc_position || calc_w) { - pos = float4::safe_divide(pos, scale[i]); + pos = math::safe_divide(pos, scale[i]); if (calc_position) { r_position[i] = float3(pos.x, pos.y, pos.z); } @@ -837,7 +837,7 @@ class VoronoiMetricFunction : public fn::MultiFunction { r_color[i] = ColorGeometry4f(col[0], col[1], col[2], 1.0f); } if (calc_position) { - pos = float2::safe_divide(pos, scale[i]); + pos = math::safe_divide(pos, scale[i]); r_position[i] = float3(pos.x, pos.y, 0.0f); } } @@ -868,7 +868,7 @@ class VoronoiMetricFunction : public fn::MultiFunction { r_color[i] = ColorGeometry4f(col[0], col[1], col[2], 1.0f); } if (calc_position) { - pos = float2::safe_divide(pos, scale[i]); + pos = math::safe_divide(pos, scale[i]); r_position[i] = float3(pos.x, pos.y, 0.0f); } } @@ -902,7 +902,7 @@ class VoronoiMetricFunction : public fn::MultiFunction { r_color[i] = ColorGeometry4f(col[0], col[1], col[2], 1.0f); } if (calc_position) { - pos = float2::safe_divide(pos, scale[i]); + pos = math::safe_divide(pos, scale[i]); r_position[i] = float3(pos.x, pos.y, 0.0f); } } @@ -937,7 +937,7 @@ class VoronoiMetricFunction : public fn::MultiFunction { r_color[i] = ColorGeometry4f(col[0], col[1], col[2], 1.0f); } if (calc_position) { - r_position[i] = float3::safe_divide(r_position[i], scale[i]); + r_position[i] = math::safe_divide(r_position[i], scale[i]); } } break; @@ -966,7 +966,7 @@ class VoronoiMetricFunction : public fn::MultiFunction { r_color[i] = ColorGeometry4f(col[0], col[1], col[2], 1.0f); } if (calc_position) { - r_position[i] = float3::safe_divide(r_position[i], scale[i]); + r_position[i] = math::safe_divide(r_position[i], scale[i]); } } break; @@ -999,7 +999,7 @@ class VoronoiMetricFunction : public fn::MultiFunction { r_color[i] = ColorGeometry4f(col[0], col[1], col[2], 1.0f); } if (calc_position) { - r_position[i] = float3::safe_divide(r_position[i], scale[i]); + r_position[i] = math::safe_divide(r_position[i], scale[i]); } } } @@ -1040,7 +1040,7 @@ class VoronoiMetricFunction : public fn::MultiFunction { r_color[i] = ColorGeometry4f(col[0], col[1], col[2], 1.0f); } if (calc_position || calc_w) { - pos = float4::safe_divide(pos, scale[i]); + pos = math::safe_divide(pos, scale[i]); if (calc_position) { r_position[i] = float3(pos.x, pos.y, pos.z); } @@ -1080,7 +1080,7 @@ class VoronoiMetricFunction : public fn::MultiFunction { r_color[i] = ColorGeometry4f(col[0], col[1], col[2], 1.0f); } if (calc_position || calc_w) { - pos = float4::safe_divide(pos, scale[i]); + pos = math::safe_divide(pos, scale[i]); if (calc_position) { r_position[i] = float3(pos.x, pos.y, pos.z); } @@ -1123,7 +1123,7 @@ class VoronoiMetricFunction : public fn::MultiFunction { r_color[i] = ColorGeometry4f(col[0], col[1], col[2], 1.0f); } if (calc_position || calc_w) { - pos = float4::safe_divide(pos, scale[i]); + pos = math::safe_divide(pos, scale[i]); if (calc_position) { r_position[i] = float3(pos.x, pos.y, pos.z); } |