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 @Howard Trickey (howardt) opinion on the matter.
- The noexcept on the copy constructor of mpq(2|3) is being removed.
  But according to @Jacques Lucke (JacquesLucke) it is not a real problem
  for now.

I would like to give a huge thanks to @Jacques Lucke (JacquesLucke) who
helped during this and pushed me to reduce the duplication further.

Reviewed By: brecht, sergey, JacquesLucke

Differential Revision: http://developer.blender.org/D13791

34 files changed, 138 insertions, 107 deletions

diff --git a/source/blender/blenkernel/BKE_appdir.h b/source/blender/blenkernel/BKE_appdir.h
index a7baaed141f..e92909fb3ca 100644
--- a/source/blender/blenkernel/BKE_appdir.h
+++ b/source/blender/blenkernel/BKE_appdir.h
@@ -140,7 +140,7 @@ bool BKE_appdir_font_folder_default(char *dir);
  * Find Python executable.
  */
 bool BKE_appdir_program_python_search(char *fullpath,
-                                      size_t fullpath_len,
+                                      const size_t fullpath_len,
                                       int version_major,
                                       int version_minor);
 
diff --git a/source/blender/blenkernel/BKE_attribute.h b/source/blender/blenkernel/BKE_attribute.h
index 6020da08f51..db8f3759bf8 100644
--- a/source/blender/blenkernel/BKE_attribute.h
+++ b/source/blender/blenkernel/BKE_attribute.h
@@ -73,7 +73,7 @@ bool BKE_id_attribute_rename(struct ID *id,
                              const char *new_name,
                              struct ReportList *reports);
 
-int BKE_id_attributes_length(struct ID *id, CustomDataMask mask);
+int BKE_id_attributes_length(struct ID *id, const CustomDataMask mask);
 
 struct CustomDataLayer *BKE_id_attributes_active_get(struct ID *id);
 void BKE_id_attributes_active_set(struct ID *id, struct CustomDataLayer *layer);
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_bvhutils.h b/source/blender/blenkernel/BKE_bvhutils.h
index 146e6394fd6..42c8a5dae5d 100644
--- a/source/blender/blenkernel/BKE_bvhutils.h
+++ b/source/blender/blenkernel/BKE_bvhutils.h
@@ -128,7 +128,7 @@ BVHTree *bvhtree_from_editmesh_verts_ex(BVHTreeFromEditMesh *data,
                                         float epsilon,
                                         int tree_type,
                                         int axis,
-                                        BVHCacheType bvh_cache_type,
+                                        const BVHCacheType bvh_cache_type,
                                         struct BVHCache **bvh_cache_p,
                                         ThreadMutex *mesh_eval_mutex);
 
@@ -148,7 +148,7 @@ BVHTree *bvhtree_from_mesh_verts_ex(struct BVHTreeFromMesh *data,
                                     float epsilon,
                                     int tree_type,
                                     int axis,
-                                    BVHCacheType bvh_cache_type,
+                                    const BVHCacheType bvh_cache_type,
                                     struct BVHCache **bvh_cache_p,
                                     ThreadMutex *mesh_eval_mutex);
 
@@ -165,7 +165,7 @@ BVHTree *bvhtree_from_editmesh_edges_ex(BVHTreeFromEditMesh *data,
                                         float epsilon,
                                         int tree_type,
                                         int axis,
-                                        BVHCacheType bvh_cache_type,
+                                        const BVHCacheType bvh_cache_type,
                                         struct BVHCache **bvh_cache_p,
                                         ThreadMutex *mesh_eval_mutex);
 
@@ -188,7 +188,7 @@ BVHTree *bvhtree_from_mesh_edges_ex(struct BVHTreeFromMesh *data,
                                     float epsilon,
                                     int tree_type,
                                     int axis,
-                                    BVHCacheType bvh_cache_type,
+                                    const BVHCacheType bvh_cache_type,
                                     struct BVHCache **bvh_cache_p,
                                     ThreadMutex *mesh_eval_mutex);
 
@@ -212,7 +212,7 @@ BVHTree *bvhtree_from_mesh_faces_ex(struct BVHTreeFromMesh *data,
                                     float epsilon,
                                     int tree_type,
                                     int axis,
-                                    BVHCacheType bvh_cache_type,
+                                    const BVHCacheType bvh_cache_type,
                                     struct BVHCache **bvh_cache_p,
                                     ThreadMutex *mesh_eval_mutex);
 
@@ -229,7 +229,7 @@ BVHTree *bvhtree_from_editmesh_looptri_ex(BVHTreeFromEditMesh *data,
                                           float epsilon,
                                           int tree_type,
                                           int axis,
-                                          BVHCacheType bvh_cache_type,
+                                          const BVHCacheType bvh_cache_type,
                                           struct BVHCache **bvh_cache_p,
                                           ThreadMutex *mesh_eval_mutex);
 
@@ -251,7 +251,7 @@ BVHTree *bvhtree_from_mesh_looptri_ex(struct BVHTreeFromMesh *data,
                                       float epsilon,
                                       int tree_type,
                                       int axis,
-                                      BVHCacheType bvh_cache_type,
+                                      const BVHCacheType bvh_cache_type,
                                       struct BVHCache **bvh_cache_p,
                                       ThreadMutex *mesh_eval_mutex);
 
@@ -263,7 +263,7 @@ BVHTree *bvhtree_from_mesh_looptri_ex(struct BVHTreeFromMesh *data,
  */
 BVHTree *BKE_bvhtree_from_mesh_get(struct BVHTreeFromMesh *data,
                                    const struct Mesh *mesh,
-                                   BVHCacheType bvh_cache_type,
+                                   const BVHCacheType bvh_cache_type,
                                    int tree_type);
 
 /**
@@ -272,7 +272,7 @@ BVHTree *BKE_bvhtree_from_mesh_get(struct BVHTreeFromMesh *data,
 BVHTree *BKE_bvhtree_from_editmesh_get(BVHTreeFromEditMesh *data,
                                        struct BMEditMesh *em,
                                        int tree_type,
-                                       BVHCacheType bvh_cache_type,
+                                       const BVHCacheType bvh_cache_type,
                                        struct BVHCache **bvh_cache_p,
                                        ThreadMutex *mesh_eval_mutex);
 
diff --git a/source/blender/blenkernel/BKE_customdata.h b/source/blender/blenkernel/BKE_customdata.h
index 17a44274712..b5b6296a0fa 100644
--- a/source/blender/blenkernel/BKE_customdata.h
+++ b/source/blender/blenkernel/BKE_customdata.h
@@ -323,7 +323,7 @@ void CustomData_bmesh_copy_data_exclude_by_type(const struct CustomData *source,
                                                 struct CustomData *dest,
                                                 void *src_block,
                                                 void **dest_block,
-                                                CustomDataMask mask_exclude);
+                                                const CustomDataMask mask_exclude);
 
 /**
  * Copies data of a single layer of a given type.
@@ -496,7 +496,7 @@ void CustomData_bmesh_free_block_data(struct CustomData *data, void *block);
  */
 void CustomData_bmesh_free_block_data_exclude_by_type(struct CustomData *data,
                                                       void *block,
-                                                      CustomDataMask mask_exclude);
+                                                      const CustomDataMask mask_exclude);
 
 /**
  * Copy custom data to/from layers as in mesh/derived-mesh, to edit-mesh
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_image.h b/source/blender/blenkernel/BKE_image.h
index 80c6b155be0..7b87189a13f 100644
--- a/source/blender/blenkernel/BKE_image.h
+++ b/source/blender/blenkernel/BKE_image.h
@@ -367,7 +367,7 @@ void BKE_image_packfiles(struct ReportList *reports, struct Image *ima, const ch
 void BKE_image_packfiles_from_mem(struct ReportList *reports,
                                   struct Image *ima,
                                   char *data,
-                                  size_t data_len);
+                                  const size_t data_len);
 
 /**
  * Prints memory statistics for images.
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_node.h b/source/blender/blenkernel/BKE_node.h
index ef86804cc3b..71d1728a870 100644
--- a/source/blender/blenkernel/BKE_node.h
+++ b/source/blender/blenkernel/BKE_node.h
@@ -1373,12 +1373,18 @@ void ntreeCompositTagRender(struct Scene *scene);
  * - Each render layer node calls the update function of the
  *   render engine that's used for its scene.
  * - The render engine calls RE_engine_register_pass for each pass.
- * - #RE_engine_register_pass calls #node_cmp_rlayers_register_pass.
+ * - #RE_engine_register_pass calls #ntreeCompositRegisterPass,
+ *   which calls #node_cmp_rlayers_register_pass for every render layer node.
  *
  * TODO: This is *not* part of `blenkernel`, it's defined under "source/blender/nodes/".
  * This declaration should be moved out of BKE.
  */
 void ntreeCompositUpdateRLayers(struct bNodeTree *ntree);
+void ntreeCompositRegisterPass(struct bNodeTree *ntree,
+                               struct Scene *scene,
+                               struct ViewLayer *view_layer,
+                               const char *name,
+                               eNodeSocketDatatype type);
 void ntreeCompositClearTags(struct bNodeTree *ntree);
 
 struct bNodeSocket *ntreeCompositOutputFileAddSocket(struct bNodeTree *ntree,
diff --git a/source/blender/blenkernel/BKE_scene.h b/source/blender/blenkernel/BKE_scene.h
index a40359e8650..8610bc09a92 100644
--- a/source/blender/blenkernel/BKE_scene.h
+++ b/source/blender/blenkernel/BKE_scene.h
@@ -317,8 +317,11 @@ void BKE_scene_multiview_view_prefix_get(struct Scene *scene,
                                          const char *name,
                                          char *r_prefix,
                                          const char **r_ext);
-void BKE_scene_multiview_videos_dimensions_get(
-    const struct RenderData *rd, size_t width, size_t height, size_t *r_width, size_t *r_height);
+void BKE_scene_multiview_videos_dimensions_get(const struct RenderData *rd,
+                                               const size_t width,
+                                               const size_t height,
+                                               size_t *r_width,
+                                               size_t *r_height);
 int BKE_scene_multiview_num_videos_get(const struct RenderData *rd);
 
 /* depsgraph */
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_vfont.h b/source/blender/blenkernel/BKE_vfont.h
index 3397f2ef82a..d0a44ce4e47 100644
--- a/source/blender/blenkernel/BKE_vfont.h
+++ b/source/blender/blenkernel/BKE_vfont.h
@@ -104,7 +104,7 @@ void BKE_vfont_select_clamp(struct Object *ob);
 void BKE_vfont_clipboard_free(void);
 void BKE_vfont_clipboard_set(const char32_t *text_buf,
                              const struct CharInfo *info_buf,
-                             size_t len);
+                             const size_t len);
 void BKE_vfont_clipboard_get(char32_t **r_text_buf,
                              struct CharInfo **r_info_buf,
                              size_t *r_len_utf8,
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/data_transfer_intern.h b/source/blender/blenkernel/intern/data_transfer_intern.h
index b5b3db31fbf..e5218415df9 100644
--- a/source/blender/blenkernel/intern/data_transfer_intern.h
+++ b/source/blender/blenkernel/intern/data_transfer_intern.h
@@ -44,9 +44,9 @@ void data_transfer_layersmapping_add_item(struct ListBase *r_map,
                                           void *data_dst,
                                           int data_src_n,
                                           int data_dst_n,
-                                          size_t elem_size,
-                                          size_t data_size,
-                                          size_t data_offset,
+                                          const size_t elem_size,
+                                          const size_t data_size,
+                                          const size_t data_offset,
                                           uint64_t data_flag,
                                           cd_datatransfer_interp interp,
                                           void *interp_data);
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/image.c b/source/blender/blenkernel/intern/image.c
index 23b1054f814..4899c3671aa 100644
--- a/source/blender/blenkernel/intern/image.c
+++ b/source/blender/blenkernel/intern/image.c
@@ -2446,7 +2446,7 @@ void BKE_image_stamp_buf(Scene *scene,
 
     /* and draw the text. */
     BLF_position(mono, x, y + y_ofs, 0.0);
-    BLF_draw_buffer(mono, stamp_data.file, sizeof(stamp_data.file));
+    BLF_draw_buffer(mono, stamp_data.file, BLF_DRAW_STR_DUMMY_MAX);
 
     /* the extra pixel for background. */
     y -= BUFF_MARGIN_Y * 2;
@@ -2469,7 +2469,7 @@ void BKE_image_stamp_buf(Scene *scene,
                       y + h + BUFF_MARGIN_Y);
 
     BLF_position(mono, x, y + y_ofs, 0.0);
-    BLF_draw_buffer(mono, stamp_data.date, sizeof(stamp_data.date));
+    BLF_draw_buffer(mono, stamp_data.date, BLF_DRAW_STR_DUMMY_MAX);
 
     /* the extra pixel for background. */
     y -= BUFF_MARGIN_Y * 2;
@@ -2492,7 +2492,7 @@ void BKE_image_stamp_buf(Scene *scene,
                       y + h + BUFF_MARGIN_Y);
 
     BLF_position(mono, x, y + y_ofs, 0.0);
-    BLF_draw_buffer(mono, stamp_data.rendertime, sizeof(stamp_data.rendertime));
+    BLF_draw_buffer(mono, stamp_data.rendertime, BLF_DRAW_STR_DUMMY_MAX);
 
     /* the extra pixel for background. */
     y -= BUFF_MARGIN_Y * 2;
@@ -2515,7 +2515,7 @@ void BKE_image_stamp_buf(Scene *scene,
                       y + h + BUFF_MARGIN_Y);
 
     BLF_position(mono, x, y + y_ofs, 0.0);
-    BLF_draw_buffer(mono, stamp_data.memory, sizeof(stamp_data.memory));
+    BLF_draw_buffer(mono, stamp_data.memory, BLF_DRAW_STR_DUMMY_MAX);
 
     /* the extra pixel for background. */
     y -= BUFF_MARGIN_Y * 2;
@@ -2538,7 +2538,7 @@ void BKE_image_stamp_buf(Scene *scene,
                       y + h + BUFF_MARGIN_Y);
 
     BLF_position(mono, x, y + y_ofs, 0.0);
-    BLF_draw_buffer(mono, stamp_data.hostname, sizeof(stamp_data.hostname));
+    BLF_draw_buffer(mono, stamp_data.hostname, BLF_DRAW_STR_DUMMY_MAX);
 
     /* the extra pixel for background. */
     y -= BUFF_MARGIN_Y * 2;
@@ -2562,7 +2562,7 @@ void BKE_image_stamp_buf(Scene *scene,
                       y + h + BUFF_MARGIN_Y);
 
     BLF_position(mono, x, y + y_ofs + (h - h_fixed), 0.0);
-    BLF_draw_buffer(mono, stamp_data.note, sizeof(stamp_data.note));
+    BLF_draw_buffer(mono, stamp_data.note, BLF_DRAW_STR_DUMMY_MAX);
   }
   BLF_disable(mono, BLF_WORD_WRAP);
 
@@ -2586,7 +2586,7 @@ void BKE_image_stamp_buf(Scene *scene,
 
     /* and pad the text. */
     BLF_position(mono, x, y + y_ofs, 0.0);
-    BLF_draw_buffer(mono, stamp_data.marker, sizeof(stamp_data.marker));
+    BLF_draw_buffer(mono, stamp_data.marker, BLF_DRAW_STR_DUMMY_MAX);
 
     /* space width. */
     x += w + pad;
@@ -2609,7 +2609,7 @@ void BKE_image_stamp_buf(Scene *scene,
 
     /* and pad the text. */
     BLF_position(mono, x, y + y_ofs, 0.0);
-    BLF_draw_buffer(mono, stamp_data.time, sizeof(stamp_data.time));
+    BLF_draw_buffer(mono, stamp_data.time, BLF_DRAW_STR_DUMMY_MAX);
 
     /* space width. */
     x += w + pad;
@@ -2631,7 +2631,7 @@ void BKE_image_stamp_buf(Scene *scene,
 
     /* and pad the text. */
     BLF_position(mono, x, y + y_ofs, 0.0);
-    BLF_draw_buffer(mono, stamp_data.frame, sizeof(stamp_data.frame));
+    BLF_draw_buffer(mono, stamp_data.frame, BLF_DRAW_STR_DUMMY_MAX);
 
     /* space width. */
     x += w + pad;
@@ -2651,7 +2651,7 @@ void BKE_image_stamp_buf(Scene *scene,
                       x + w + BUFF_MARGIN_X,
                       y + h + BUFF_MARGIN_Y);
     BLF_position(mono, x, y + y_ofs, 0.0);
-    BLF_draw_buffer(mono, stamp_data.camera, sizeof(stamp_data.camera));
+    BLF_draw_buffer(mono, stamp_data.camera, BLF_DRAW_STR_DUMMY_MAX);
 
     /* space width. */
     x += w + pad;
@@ -2671,7 +2671,7 @@ void BKE_image_stamp_buf(Scene *scene,
                       x + w + BUFF_MARGIN_X,
                       y + h + BUFF_MARGIN_Y);
     BLF_position(mono, x, y + y_ofs, 0.0);
-    BLF_draw_buffer(mono, stamp_data.cameralens, sizeof(stamp_data.cameralens));
+    BLF_draw_buffer(mono, stamp_data.cameralens, BLF_DRAW_STR_DUMMY_MAX);
   }
 
   if (TEXT_SIZE_CHECK(stamp_data.scene, w, h)) {
@@ -2693,7 +2693,7 @@ void BKE_image_stamp_buf(Scene *scene,
 
     /* and pad the text. */
     BLF_position(mono, x, y + y_ofs, 0.0);
-    BLF_draw_buffer(mono, stamp_data.scene, sizeof(stamp_data.scene));
+    BLF_draw_buffer(mono, stamp_data.scene, BLF_DRAW_STR_DUMMY_MAX);
   }
 
   if (TEXT_SIZE_CHECK(stamp_data.strip, w, h)) {
@@ -2715,7 +2715,7 @@ void BKE_image_stamp_buf(Scene *scene,
                       y + h + BUFF_MARGIN_Y);
 
     BLF_position(mono, x, y + y_ofs, 0.0);
-    BLF_draw_buffer(mono, stamp_data.strip, sizeof(stamp_data.strip));
+    BLF_draw_buffer(mono, stamp_data.strip, BLF_DRAW_STR_DUMMY_MAX);
   }
 
   /* cleanup the buffer. */
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 &current_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"