Cleanup: Use int64_t for size().

Check modifier keys using XKB_STATE_MODS_DEPRESSED which is used
to check if modifiers are physically held. In practice it's unlikely
this would have caused an error for key-maps in common use.

source/blender/blenkernel/BKE_pbvh.h

@@ -91,6 +91,15 @@ typedef struct {
   float (*color)[4];
 } PBVHColorBufferNode;
 
+typedef struct PBVHPixels {
+  /**
+   * Storage for texture painting on PBVH level.
+   *
+   * Contains #blender::bke::pbvh::pixels::PBVHData
+   */
+  void *data;
+} PBVHPixels;
+
 typedef struct PBVHPixelsNode {
   /**
    * Contains triangle/pixel data used during texture painting.

source/blender/blenkernel/BKE_pbvh_pixels.hh

@@ -18,8 +18,46 @@
 
 namespace blender::bke::pbvh::pixels {
 
-struct TrianglePaintInput {
-  int3 vert_indices;
+/**
+ * Data shared between pixels that belong to the same triangle.
+ *
+ * Data is stored as a list of structs, grouped by usage to improve performance (improves CPU
+ * cache prefetching).
+ */
+struct PaintGeometryPrimitives {
+  /** Data accessed by the inner loop of the painting brush. */
+  Vector<int3> vert_indices;
+
+ public:
+  void append(const int3 vert_indices)
+  {
+    this->vert_indices.append(vert_indices);
+  }
+
+  const int3 &get_vert_indices(const int index) const
+  {
+    return vert_indices[index];
+  }
+
+  void clear()
+  {
+    vert_indices.clear();
+  }
+
+  int64_t size() const
+  {
+    return vert_indices.size();
+  }
+
+  int64_t mem_size() const
+  {
+    return size() * sizeof(int3);
+  }
+};
+
+struct UVPrimitivePaintInput {
+  /** Corresponding index into PaintGeometryPrimitives */
+  int64_t geometry_primitive_index;
   /**
    * Delta barycentric coordinates between 2 neighboring UV's in the U direction.
    *
@@ -33,34 +71,27 @@ struct TrianglePaintInput {
    * delta_barycentric_coord_u is initialized in a later stage as it requires image tile
    * dimensions.
    */
-  TrianglePaintInput(const int3 vert_indices)
-      : vert_indices(vert_indices), delta_barycentric_coord_u(0.0f, 0.0f)
+  UVPrimitivePaintInput(int64_t geometry_primitive_index)
+      : geometry_primitive_index(geometry_primitive_index), delta_barycentric_coord_u(0.0f, 0.0f)
   {
   }
 };
 
-/**
- * Data shared between pixels that belong to the same triangle.
- *
- * Data is stored as a list of structs, grouped by usage to improve performance (improves CPU
- * cache prefetching).
- */
-struct Triangles {
+struct PaintUVPrimitives {
   /** Data accessed by the inner loop of the painting brush. */
-  Vector<TrianglePaintInput> paint_input;
+  Vector<UVPrimitivePaintInput> paint_input;
 
- public:
-  void append(const int3 vert_indices)
+  void append(int64_t geometry_primitive_index)
   {
-    this->paint_input.append(TrianglePaintInput(vert_indices));
+    this->paint_input.append(UVPrimitivePaintInput(geometry_primitive_index));
   }
 
-  TrianglePaintInput &get_paint_input(const int index)
+  UVPrimitivePaintInput &last()
   {
-    return paint_input[index];
+    return paint_input.last();
   }
 
-  const TrianglePaintInput &get_paint_input(const int index) const
+  const UVPrimitivePaintInput &get_paint_input(uint64_t index) const
   {
     return paint_input[index];
   }
@@ -77,7 +108,7 @@ struct Triangles {
 
   int64_t mem_size() const
   {
-    return paint_input.size() * sizeof(TrianglePaintInput);
+    return size() * sizeof(UVPrimitivePaintInput);
   }
 };
 
@@ -92,7 +123,7 @@ struct PackedPixelRow {
   /** Number of sequential pixels encoded in this package. */
   ushort num_pixels;
   /** Reference to the pbvh triangle index. */
-  ushort triangle_index;
+  ushort uv_primitive_index;
 };
 
 /**
@@ -148,7 +179,7 @@ struct NodeData {
 
   Vector<UDIMTilePixels> tiles;
   Vector<UDIMTileUndo> undo_regions;
-  Triangles triangles;
+  PaintUVPrimitives uv_primitives;
 
   NodeData()
   {
@@ -201,7 +232,7 @@ struct NodeData {
   void clear_data()
   {
     tiles.clear();
-    triangles.clear();
+    uv_primitives.clear();
   }
 
   static void free_func(void *instance)
@@ -211,7 +242,18 @@ struct NodeData {
   }
 };
 
+struct PBVHData {
+  /* Per UVPRimitive contains the paint data. */
+  PaintGeometryPrimitives geom_primitives;
+
+  void clear_data()
+  {
+    geom_primitives.clear();
+  }
+};
+
 NodeData &BKE_pbvh_pixels_node_data_get(PBVHNode &node);
 void BKE_pbvh_pixels_mark_image_dirty(PBVHNode &node, Image &image, ImageUser &image_user);
+PBVHData &BKE_pbvh_pixels_data_get(PBVH &pbvh);
 
 }  // namespace blender::bke::pbvh::pixels

source/blender/blenkernel/BKE_uv_islands.hh

@@ -0,0 +1,748 @@
+
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+#pragma once
+
+#include <fstream>
+#include <optional>
+
+#include "BLI_array.hh"
+#include "BLI_edgehash.h"
+#include "BLI_float3x3.hh"
+#include "BLI_map.hh"
+#include "BLI_math.h"
+#include "BLI_math_vec_types.hh"
+#include "BLI_rect.h"
+#include "BLI_vector.hh"
+#include "BLI_vector_list.hh"
+
+#include "DNA_meshdata_types.h"
+
+
+namespace blender::bke::uv_islands {
+
+struct MeshEdge;
+struct MeshPrimitive;
+struct UVBorder;
+struct UVEdge;
+struct UVIslands;
+struct UVIslandsMask;
+struct UVPrimitive;
+struct UVPrimitiveEdge;
+struct UVVertex;
+
+struct MeshVertex {
+  int64_t v;
+  Vector<MeshEdge *> edges;
+};
+
+struct MeshUVVert {
+  MeshVertex *vertex;
+  float2 uv;
+  int64_t loop;
+};
+
+struct MeshEdge {
+  MeshVertex *vert1;
+  MeshVertex *vert2;
+  Vector<MeshPrimitive *> primitives;
+};
+
+/** Represents a triangle in 3d space (MLoopTri) */
+struct MeshPrimitive {
+  int64_t index;
+  int64_t poly;
+  Vector<MeshEdge *, 3> edges;
+  Vector<MeshUVVert, 3> vertices;
+
+  /**
+   * UV island this primitive belongs to. This is used to speed up the initial uv island
+   * extraction, but should not be used when extending uv islands.
+   */
+  int64_t uv_island_id;
+
+  MeshUVVert *get_other_uv_vertex(const MeshVertex *v1, const MeshVertex *v2)
+  {
+    BLI_assert(vertices[0].vertex == v1 || vertices[1].vertex == v1 || vertices[2].vertex == v1);
+    BLI_assert(vertices[0].vertex == v2 || vertices[1].vertex == v2 || vertices[2].vertex == v2);
+    for (MeshUVVert &uv_vertex : vertices) {
+      if (uv_vertex.vertex != v1 && uv_vertex.vertex != v2) {
+        return &uv_vertex;
+      }
+    }
+    return nullptr;
+  }
+
+  rctf uv_bounds() const;
+
+  bool has_shared_uv_edge(const MeshPrimitive *other) const
+  {
+    int shared_uv_verts = 0;
+    for (const MeshUVVert &vert : vertices) {
+      for (const MeshUVVert &other_vert : other->vertices) {
+        if (vert.uv == other_vert.uv) {
+          shared_uv_verts += 1;
+        }
+      }
+    }
+    return shared_uv_verts >= 2;
+  }
+};
+
+/**
+ * MeshData contains input geometry data converted in a list of primitives, edges and vertices for
+ * quick access for both local space and uv space.
+ */
+struct MeshData {
+ public:
+  const MLoopTri *looptri;
+  const int64_t looptri_len;
+  const int64_t vert_len;
+  const MLoop *mloop;
+  const MLoopUV *mloopuv;
+
+ public:
+  Vector<MeshPrimitive> primitives;
+  Vector<MeshEdge> edges;
+  Vector<MeshVertex> vertices;
+  /** Total number of uv islands detected. */
+  int64_t uv_island_len;
+
+  explicit MeshData(const MLoopTri *looptri,
+                    const int64_t looptri_len,
+                    const int64_t vert_len,
+                    const MLoop *mloop,
+                    const MLoopUV *mloopuv)
+      : looptri(looptri),
+        looptri_len(looptri_len),
+        vert_len(vert_len),
+        mloop(mloop),
+        mloopuv(mloopuv)
+  {
+    init_vertices();
+    init_primitives();
+    init_edges();
+    init_primitive_uv_island_ids();
+  }
+
+  void init_vertices()
+  {
+    vertices.reserve(vert_len);
+    for (int64_t i = 0; i < vert_len; i++) {
+      MeshVertex vert;
+      vert.v = i;
+      vertices.append(vert);
+    }
+  }
+
+  void init_primitives()
+  {
+    primitives.reserve(looptri_len);
+    for (int64_t i = 0; i < looptri_len; i++) {
+      const MLoopTri &tri = looptri[i];
+      MeshPrimitive primitive;
+      primitive.index = i;
+      primitive.poly = tri.poly;
+
+      for (int j = 0; j < 3; j++) {
+        MeshUVVert uv_vert;
+        uv_vert.loop = tri.tri[j];
+        uv_vert.vertex = &vertices[mloop[uv_vert.loop].v];
+        uv_vert.uv = mloopuv[uv_vert.loop].uv;
+        primitive.vertices.append(uv_vert);
+      }
+      primitives.append(primitive);
+    }
+  }
+
+  void init_edges()
+  {
+    edges.reserve(looptri_len * 2);
+    EdgeHash *eh = BLI_edgehash_new_ex(__func__, looptri_len * 3);
+    for (int64_t i = 0; i < looptri_len; i++) {
+      const MLoopTri &tri = looptri[i];
+      MeshPrimitive &primitive = primitives[i];
+      for (int j = 0; j < 3; j++) {
+        int v1 = mloop[tri.tri[j]].v;
+        int v2 = mloop[tri.tri[(j + 1) % 3]].v;
+        /* TODO: Use lookup_ptr to be able to store edge 0. */
+        void *v = BLI_edgehash_lookup(eh, v1, v2);
+        int64_t edge_index;
+        if (v == nullptr) {
+          edge_index = edges.size();
+          BLI_edgehash_insert(eh, v1, v2, POINTER_FROM_INT(edge_index + 1));
+          MeshEdge edge;
+          edge.vert1 = &vertices[v1];
+          edge.vert2 = &vertices[v2];
+          edges.append(edge);
+          MeshEdge *edge_ptr = &edges.last();
+          vertices[v1].edges.append(edge_ptr);
+          vertices[v2].edges.append(edge_ptr);
+        }
+        else {
+          edge_index = POINTER_AS_INT(v) - 1;
+        }
+
+        MeshEdge *edge = &edges[edge_index];
+        edge->primitives.append(&primitive);
+        primitive.edges.append(edge);
+      }
+    }
+    BLI_edgehash_free(eh, nullptr);
+  }
+
+  static const int64_t INVALID_UV_ISLAND_ID = -1;
+  /**
+   * NOTE: doesn't support weird topology where unconnected mesh primitives share the same uv
+   * island. For a accurate implementation we should use implement an uv_prim_lookup.
+   */
+  static void extract_uv_neighbors(Vector<MeshPrimitive *> &prims_to_add, MeshPrimitive *primitive)
+  {
+    for (MeshEdge *edge : primitive->edges) {
+      for (MeshPrimitive *other_primitive : edge->primitives) {
+        if (primitive == other_primitive) {
+          continue;
+        }
+        if (other_primitive->uv_island_id != MeshData::INVALID_UV_ISLAND_ID) {
+          continue;
+        }
+
+        if (primitive->has_shared_uv_edge(other_primitive)) {
+          prims_to_add.append(other_primitive);
+        }
+      }
+    }
+  }
+
+  void init_primitive_uv_island_ids()
+  {
+    for (MeshPrimitive &primitive : primitives) {
+      primitive.uv_island_id = INVALID_UV_ISLAND_ID;
+    }
+
+    int64_t uv_island_id = 0;
+    Vector<MeshPrimitive *> prims_to_add;
+    for (MeshPrimitive &primitive : primitives) {
+      /* Early exit when uv island id is already extracted during uv neighbor extractions. */
+      if (primitive.uv_island_id != INVALID_UV_ISLAND_ID) {
+        continue;
+      }
+
+      prims_to_add.append(&primitive);
+      while (!prims_to_add.is_empty()) {
+        MeshPrimitive *primitive = prims_to_add.pop_last();
+        primitive->uv_island_id = uv_island_id;
+        extract_uv_neighbors(prims_to_add, primitive);
+      }
+      uv_island_id++;
+    }
+    uv_island_len = uv_island_id;
+  }
+};
+
+struct UVVertex {
+  MeshVertex *vertex;
+  /* Position in uv space. */
+  float2 uv;
+
+  /* uv edges that share this UVVertex. */
+  Vector<UVEdge *> uv_edges;
+
+  struct {
+    bool is_border : 1;
+    bool is_extended : 1;
+  } flags;
+
+  explicit UVVertex()
+  {
+    flags.is_border = false;
+    flags.is_extended = false;
+  }
+
+  explicit UVVertex(const MeshUVVert &vert) : vertex(vert.vertex), uv(vert.uv)
+  {
+    flags.is_border = false;
+    flags.is_extended = false;
+  }
+};
+
+struct UVEdge {
+  std::array<UVVertex *, 2> vertices;
+  Vector<UVPrimitive *, 2> uv_primitives;
+
+  bool has_shared_edge(const MeshUVVert &v1, const MeshUVVert &v2) const
+  {
+    return (vertices[0]->uv == v1.uv && vertices[1]->uv == v2.uv) ||
+           (vertices[0]->uv == v2.uv && vertices[1]->uv == v1.uv);
+  }
+
+  bool has_shared_edge(const UVVertex &v1, const UVVertex &v2) const
+  {
+    return (vertices[0]->uv == v1.uv && vertices[1]->uv == v2.uv) ||
+           (vertices[0]->uv == v2.uv && vertices[1]->uv == v1.uv);
+  }
+
+  bool has_shared_edge(const UVEdge &other) const
+  {
+    return has_shared_edge(*other.vertices[0], *other.vertices[1]);
+  }
+
+  bool has_same_vertices(const MeshVertex &vert1, const MeshVertex &vert2) const
+  {
+    return (vertices[0]->vertex == &vert1 && vertices[1]->vertex == &vert2) ||
+           (vertices[0]->vertex == &vert2 && vertices[1]->vertex == &vert1);
+  }
+
+  bool has_same_uv_vertices(const UVEdge &other) const
+  {
+    return has_shared_edge(other) &&
+           has_same_vertices(*other.vertices[0]->vertex, *other.vertices[1]->vertex);
+    ;
+  }
+
+  bool has_same_vertices(const MeshEdge &edge) const
+  {
+    return has_same_vertices(*edge.vert1, *edge.vert2);
+  }
+
+  bool is_border_edge() const
+  {
+    return uv_primitives.size() == 1;
+  }
+
+  void append_to_uv_vertices()
+  {
+    for (UVVertex *vertex : vertices) {
+      vertex->uv_edges.append_non_duplicates(this);
+    }
+  }
+
+  UVVertex *get_other_uv_vertex(const MeshVertex *vertex)
+  {
+    if (vertices[0]->vertex == vertex) {
+      return vertices[1];
+    }
+    return vertices[0];
+  }
+};
+
+struct UVPrimitive {
+  /**
+   * Index of the primitive in the original mesh.
+   */
+  MeshPrimitive *primitive;
+  Vector<UVEdge *, 3> edges;
+
+  explicit UVPrimitive(MeshPrimitive *primitive) : primitive(primitive)
+  {
+  }
+
+  void append_to_uv_edges()
+  {
+    for (UVEdge *uv_edge : edges) {
+      uv_edge->uv_primitives.append_non_duplicates(this);
+    }
+  }
+  void append_to_uv_vertices()
+  {
+    for (UVEdge *uv_edge : edges) {
+      uv_edge->append_to_uv_vertices();
+    }
+  }
+
+  Vector<std::pair<UVEdge *, UVEdge *>> shared_edges(UVPrimitive &other)
+  {
+    Vector<std::pair<UVEdge *, UVEdge *>> result;
+    for (int i = 0; i < 3; i++) {
+      for (int j = 0; j < 3; j++) {
+        if (edges[i]->has_shared_edge(*other.edges[j])) {
+          result.append(std::pair<UVEdge *, UVEdge *>(edges[i], other.edges[j]));
+        }
+      }
+    }
+    return result;
+  }
+
+  bool has_shared_edge(const UVPrimitive &other) const
+  {
+    for (int i = 0; i < 3; i++) {
+      for (int j = 0; j < 3; j++) {
+        if (edges[i]->has_shared_edge(*other.edges[j])) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  bool has_shared_edge(const MeshPrimitive &primitive) const
+  {
+    for (const UVEdge *uv_edge : edges) {
+      const MeshUVVert *v1 = &primitive.vertices.last();
+      for (int i = 0; i < primitive.vertices.size(); i++) {
+        const MeshUVVert *v2 = &primitive.vertices[i];
+        if (uv_edge->has_shared_edge(*v1, *v2)) {
+          return true;
+        }
+        v1 = v2;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Get the UVVertex in the order that the verts are ordered in the MeshPrimitive.
+   */
+  const UVVertex *get_uv_vertex(const uint8_t mesh_vert_index) const
+  {
+    const MeshVertex *mesh_vertex = primitive->vertices[mesh_vert_index].vertex;
+    for (const UVEdge *uv_edge : edges) {
+      for (const UVVertex *uv_vert : uv_edge->vertices) {
+        if (uv_vert->vertex == mesh_vertex) {
+          return uv_vert;
+        }
+      }
+    }
+    BLI_assert_unreachable();
+    return nullptr;
+  }
+
+  /**
+   * Get the UVEdge that share the given uv coordinates.
+   * Will assert when no UVEdge found.
+   */
+  UVEdge *get_uv_edge(const float2 uv1, const float2 uv2) const
+  {
+    for (UVEdge *uv_edge : edges) {
+      const float2 &e1 = uv_edge->vertices[0]->uv;
+      const float2 &e2 = uv_edge->vertices[1]->uv;
+      if ((e1 == uv1 && e2 == uv2) || (e1 == uv2 && e2 == uv1)) {
+        return uv_edge;
+      }
+    }
+    BLI_assert_unreachable();
+    return nullptr;
+  }
+
+  UVEdge *get_uv_edge(const MeshVertex *v1, const MeshVertex *v2) const
+  {
+    for (UVEdge *uv_edge : edges) {
+      const MeshVertex *e1 = uv_edge->vertices[0]->vertex;
+      const MeshVertex *e2 = uv_edge->vertices[1]->vertex;
+      if ((e1 == v1 && e2 == v2) || (e1 == v2 && e2 == v1)) {
+        return uv_edge;
+      }
+    }
+    BLI_assert_unreachable();
+    return nullptr;
+  }
+
+  const bool contains_uv_vertex(const UVVertex *uv_vertex) const
+  {
+    for (UVEdge *edge : edges) {
+      if (std::find(edge->vertices.begin(), edge->vertices.end(), uv_vertex) !=
+          edge->vertices.end()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  const UVVertex *get_other_uv_vertex(const UVVertex *v1, const UVVertex *v2) const
+  {
+    BLI_assert(contains_uv_vertex(v1));
+    BLI_assert(contains_uv_vertex(v2));
+
+    for (const UVEdge *edge : edges) {
+      for (const UVVertex *uv_vertex : edge->vertices) {
+        if (uv_vertex != v1 && uv_vertex != v2) {
+          return uv_vertex;
+        }
+      }
+    }
+    BLI_assert_unreachable();
+    return nullptr;
+  }
+
+  UVBorder extract_border() const;
+};
+
+struct UVBorderEdge {
+  UVEdge *edge;
+  bool tag = false;
+  UVPrimitive *uv_primitive;
+  /* Should the vertices of the edge be evaluated in reverse order. */
+  bool reverse_order = false;
+
+  int64_t index = -1;
+  int64_t prev_index = -1;
+  int64_t next_index = -1;
+  int64_t border_index = -1;
+
+  explicit UVBorderEdge(UVEdge *edge, UVPrimitive *uv_primitive)
+      : edge(edge), uv_primitive(uv_primitive)
+  {
+  }
+
+  UVVertex *get_uv_vertex(int index)
+  {
+    int actual_index = reverse_order ? 1 - index : index;
+    return edge->vertices[actual_index];
+  }
+
+  const UVVertex *get_uv_vertex(int index) const
+  {
+    int actual_index = reverse_order ? 1 - index : index;
+    return edge->vertices[actual_index];
+  }
+
+  /**
+   * Get the uv vertex from the primitive that is not part of the edge.
+   */
+  const UVVertex *get_other_uv_vertex() const
+  {
+    return uv_primitive->get_other_uv_vertex(edge->vertices[0], edge->vertices[1]);
+  }
+
+  float length() const
+  {
+    return len_v2v2(edge->vertices[0]->uv, edge->vertices[1]->uv);
+  }
+};
+
+struct UVBorderCorner {
+  UVBorderEdge *first;
+  UVBorderEdge *second;
+  float angle;
+
+  UVBorderCorner(UVBorderEdge *first, UVBorderEdge *second, float angle)
+      : first(first), second(second), angle(angle)
+  {
+  }
+
+  /**
+   * Calculate a uv coordinate between the edges of the corner.
+   *
+   * 'min_uv_distance' is the minimum distance between the corner and the
+   * resulting uv coordinate. The distance is in uv space.
+   */
+  float2 uv(float factor, float min_uv_distance);
+};
+
+struct UVBorder {
+  /** Ordered list of UV Verts of the border of this island. */
+  // TODO: support multiple rings + order (CW, CCW)
+  Vector<UVBorderEdge> edges;
+
+  /**
+   * Check if the border is counter clock wise from its island.
+   */
+  bool is_ccw() const;
+
+  /**
+   * Flip the order of the verts, changing the order between CW and CCW.
+   */
+  void flip();
+
+  /**
+   * Calculate the outside angle of the given vert.
+   */
+  float outside_angle(const UVBorderEdge &vert) const;
+
+  void update_indexes(uint64_t border_index);
+
+  static std::optional<UVBorder> extract_from_edges(Vector<UVBorderEdge> &edges);
+
+  /** Remove edge from the border. updates the indexes. */
+  void remove(int64_t index)
+  {
+    /* Could read the border_index from any border edge as they are consistent. */
+    uint64_t border_index = edges[0].border_index;
+    edges.remove(index);
+    update_indexes(border_index);
+  }
+};
+
+struct UVIsland {
+  VectorList<UVVertex> uv_vertices;
+  VectorList<UVEdge> uv_edges;
+  VectorList<UVPrimitive> uv_primitives;
+  /**
+   * List of borders of this island. There can be multiple borders per island as a border could
+   * be completely encapsulated by another one.
+   */
+  Vector<UVBorder> borders;
+
+  /**
+   * Key is mesh vert index, Value is list of UVVertices that refer to the mesh vertex with that
+   * index. Map is used internally to quickly lookup similar UVVertices.
+   */
+  Map<int64_t, Vector<UVVertex *>> uv_vertex_lookup;
+
+  UVVertex *lookup(const UVVertex &vertex)
+  {
+    int64_t vert_index = vertex.vertex->v;
+    Vector<UVVertex *> &vertices = uv_vertex_lookup.lookup_or_add_default(vert_index);
+    for (UVVertex *v : vertices) {
+      if (v->uv == vertex.uv) {
+        return v;
+      }
+    }
+    return nullptr;
+  }
+
+  UVVertex *lookup_or_create(const UVVertex &vertex)
+  {
+    UVVertex *found_vertex = lookup(vertex);
+    if (found_vertex != nullptr) {
+      return found_vertex;
+    }
+
+    uv_vertices.append(vertex);
+    UVVertex *result = &uv_vertices.last();
+    result->uv_edges.clear();
+    /* v is already a key. Ensured by UVIsland::lookup in this method. */
+    uv_vertex_lookup.lookup(vertex.vertex->v).append(result);
+    return result;
+  }
+
+  UVEdge *lookup(const UVEdge &edge)
+  {
+    UVVertex *found_vertex = lookup(*edge.vertices[0]);
+    if (found_vertex == nullptr) {
+      return nullptr;
+    }
+    for (UVEdge *e : found_vertex->uv_edges) {
+      UVVertex *other_vertex = e->get_other_uv_vertex(found_vertex->vertex);
+      if (other_vertex->vertex == edge.vertices[1]->vertex &&
+          other_vertex->uv == edge.vertices[1]->uv) {
+        return e;
+      }
+    }
+    return nullptr;
+  }
+
+  UVEdge *lookup_or_create(const UVEdge &edge)
+  {
+    UVEdge *found_edge = lookup(edge);
+    if (found_edge != nullptr) {
+      return found_edge;
+    }
+
+    uv_edges.append(edge);
+    UVEdge *result = &uv_edges.last();
+    result->uv_primitives.clear();
+    return result;
+  }
+
+  /** Initialize the border attribute. */
+  void extract_borders();
+  /** Iterative extend border to fit the mask. */
+  void extend_border(const UVIslandsMask &mask, const short island_index);
+
+ private:
+  void append(const UVPrimitive &primitive)
+  {
+    uv_primitives.append(primitive);
+    UVPrimitive *new_prim_ptr = &uv_primitives.last();
+    for (int i = 0; i < 3; i++) {
+      UVEdge *other_edge = primitive.edges[i];
+      UVEdge uv_edge_template;
+      uv_edge_template.vertices[0] = lookup_or_create(*other_edge->vertices[0]);
+      uv_edge_template.vertices[1] = lookup_or_create(*other_edge->vertices[1]);
+      new_prim_ptr->edges[i] = lookup_or_create(uv_edge_template);
+      new_prim_ptr->edges[i]->append_to_uv_vertices();
+      new_prim_ptr->edges[i]->uv_primitives.append(new_prim_ptr);
+    }
+  }
+
+ public:
+  bool has_shared_edge(const UVPrimitive &primitive) const
+  {
+    for (const VectorList<UVPrimitive>::UsedVector &prims : uv_primitives) {
+      for (const UVPrimitive &prim : prims) {
+        if (prim.has_shared_edge(primitive)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  bool has_shared_edge(const MeshPrimitive &primitive) const
+  {
+    for (const VectorList<UVPrimitive>::UsedVector &primitives : uv_primitives) {
+      for (const UVPrimitive &prim : primitives) {
+        if (prim.has_shared_edge(primitive)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  const void extend_border(const UVPrimitive &primitive)
+  {
+    for (const VectorList<UVPrimitive>::UsedVector &primitives : uv_primitives) {
+      for (const UVPrimitive &prim : primitives) {
+        if (prim.has_shared_edge(primitive)) {
+          append(primitive);
+        }
+      }
+    }
+  }
+};
+
+struct UVIslands {
+  Vector<UVIsland> islands;
+
+  explicit UVIslands(MeshData &mesh_data);
+
+  void extract_borders();
+  void extend_borders(const UVIslandsMask &islands_mask);
+};
+
+/** Mask to find the index of the UVIsland for a given UV coordinate. */
+struct UVIslandsMask {
+
+  /** Mask for each udim tile. */
+  struct Tile {
+    float2 udim_offset;
+    ushort2 tile_resolution;
+    ushort2 mask_resolution;
+    Array<uint16_t> mask;
+
+    Tile(float2 udim_offset, ushort2 tile_resolution);
+
+    bool is_masked(const uint16_t island_index, const float2 uv) const;
+    bool contains(const float2 uv) const;
+    float get_pixel_size_in_uv_space() const;
+  };
+
+  Vector<Tile> tiles;
+
+  void add_tile(float2 udim_offset, ushort2 resolution);
+
+  /**
+   * Find a tile containing the given uv coordinate.
+   */
+  const Tile *find_tile(const float2 uv) const;
+
+  /**
+   * Is the given uv coordinate part of the given island_index mask.
+   *
+   * true - part of the island mask.
+   * false - not part of the island mask.
+   */
+  bool is_masked(const uint16_t island_index, const float2 uv) const;
+
+  /**
+   * Add the given UVIslands to the mask. Tiles should be added beforehand using the 'add_tile'
+   * method.
+   */
+  void add(const UVIslands &islands);
+
+  void dilate(int max_iterations);
+};
+
+}  // namespace blender::bke::uv_islands

source/blender/blenkernel/CMakeLists.txt

@@ -250,6 +250,7 @@ set(SRC
   intern/pbvh.cc
   intern/pbvh_bmesh.c
   intern/pbvh_pixels.cc
+  intern/pbvh_uv_islands.cc
   intern/pointcache.c
   intern/pointcloud.cc
   intern/preferences.c

source/blender/blenkernel/intern/paint_canvas.cc

@@ -113,6 +113,7 @@ char *BKE_paint_canvas_key_get(struct PaintModeSettings *settings, struct Object
   Image *image;
   ImageUser *image_user;
   if (BKE_paint_canvas_image_get(settings, ob, &image, &image_user)) {
+    ss << ",SEAM_DIST:" << image->seamfix_iter;
     ImageUser tile_user = *image_user;
     LISTBASE_FOREACH (ImageTile *, image_tile, &image->tiles) {
       tile_user.tile = image_tile->tile_number;

source/blender/blenkernel/intern/pbvh.c

@@ -947,7 +947,7 @@ void BKE_pbvh_free(PBVH *pbvh)
         BLI_gset_free(node->bm_other_verts, NULL);
       }
 
-      pbvh_pixels_free(node);
+      pbvh_node_pixels_free(node);
     }
   }
 
@@ -973,6 +973,8 @@ void BKE_pbvh_free(PBVH *pbvh)
 
   MEM_SAFE_FREE(pbvh->vert_bitmap);
 
+  pbvh_pixels_free(pbvh);
+
   MEM_freeN(pbvh);
 }
 

source/blender/blenkernel/intern/pbvh_intern.h

@@ -217,6 +217,8 @@ struct PBVH {
   bool draw_cache_invalid;
 
   struct PBVHGPUFormat *vbo_id;
+
+  PBVHPixels pixels;
 };
 
 /* pbvh.c */
@@ -289,7 +291,8 @@ void pbvh_bmesh_normals_update(PBVHNode **nodes, int totnode);
 
 /* pbvh_pixels.hh */
 
-void pbvh_pixels_free(PBVHNode *node);
+void pbvh_node_pixels_free(PBVHNode *node);
+void pbvh_pixels_free(PBVH *pbvh);
 void pbvh_pixels_free_brush_test(PBVHNode *node);
 void pbvh_free_draw_buffers(PBVH *pbvh, PBVHNode *node);
 

source/blender/blenkernel/intern/pbvh_pixels.cc

@@ -20,6 +20,7 @@
 #include "bmesh.h"
 
 #include "pbvh_intern.h"
+#include "pbvh_uv_islands.hh"
 
 namespace blender::bke::pbvh::pixels {
 
@@ -57,8 +58,11 @@ static float2 calc_barycentric_delta_x(const ImBuf *image_buffer,
 
 static void extract_barycentric_pixels(UDIMTilePixels &tile_data,
                                        const ImBuf *image_buffer,
-                                       const int triangle_index,
+                                       const uv_islands::UVIslandsMask &uv_mask,
+                                       const int64_t uv_island_index,
+                                       const int64_t uv_primitive_index,
                                        const float2 uvs[3],
+                                       const float2 tile_offset,
                                        const int minx,
                                        const int miny,
                                        const int maxx,
@@ -67,7 +71,7 @@ static void extract_barycentric_pixels(UDIMTilePixels &tile_data,
   for (int y = miny; y < maxy; y++) {
     bool start_detected = false;
     PackedPixelRow pixel_row;
-    pixel_row.triangle_index = triangle_index;
+    pixel_row.uv_primitive_index = uv_primitive_index;
     pixel_row.num_pixels = 0;
     int x;
 
@@ -77,12 +81,13 @@ static void extract_barycentric_pixels(UDIMTilePixels &tile_data,
       barycentric_weights_v2(uvs[0], uvs[1], uvs[2], uv, barycentric_weights);
 
       const bool is_inside = barycentric_inside_triangle_v2(barycentric_weights);
-      if (!start_detected && is_inside) {
+      const bool is_masked = uv_mask.is_masked(uv_island_index, uv + tile_offset);
+      if (!start_detected && is_inside && is_masked) {
         start_detected = true;
         pixel_row.start_image_coordinate = ushort2(x, y);
         pixel_row.start_barycentric_coord = float2(barycentric_weights.x, barycentric_weights.y);
       }
-      else if (start_detected && !is_inside) {
+      else if (start_detected && (!is_inside || !is_masked)) {
         break;
       }
     }
@@ -95,21 +100,57 @@ static void extract_barycentric_pixels(UDIMTilePixels &tile_data,
   }
 }
 
-static void init_triangles(PBVH *pbvh, PBVHNode *node, NodeData *node_data, const MLoop *mloop)
+/** Update the geometry primitives of the pbvh. */
+static void update_geom_primitives(PBVH &pbvh, const uv_islands::MeshData &mesh_data)
 {
-  for (int i = 0; i < node->totprim; i++) {
-    const MLoopTri *lt = &pbvh->looptri[node->prim_indices[i]];
-    node_data->triangles.append(
-        int3(mloop[lt->tri[0]].v, mloop[lt->tri[1]].v, mloop[lt->tri[2]].v));
+  PBVHData &pbvh_data = BKE_pbvh_pixels_data_get(pbvh);
+  pbvh_data.clear_data();
+  for (const uv_islands::MeshPrimitive &mesh_primitive : mesh_data.primitives) {
+    pbvh_data.geom_primitives.append(int3(mesh_primitive.vertices[0].vertex->v,
+                                          mesh_primitive.vertices[1].vertex->v,
+                                          mesh_primitive.vertices[2].vertex->v));
   }
 }
 
+struct UVPrimitiveLookup {
+  struct Entry {
+    uv_islands::UVPrimitive *uv_primitive;
+    uint64_t uv_island_index;
+
+    Entry(uv_islands::UVPrimitive *uv_primitive, uint64_t uv_island_index)
+        : uv_primitive(uv_primitive), uv_island_index(uv_island_index)
+    {
+    }
+  };
+
+  Vector<Vector<Entry>> lookup;
+
+  UVPrimitiveLookup(const uint64_t geom_primitive_len, uv_islands::UVIslands &uv_islands)
+  {
+    lookup.append_n_times(Vector<Entry>(), geom_primitive_len);
+
+    uint64_t uv_island_index = 0;
+    for (uv_islands::UVIsland &uv_island : uv_islands.islands) {
+      for (VectorList<uv_islands::UVPrimitive>::UsedVector &uv_primitives :
+           uv_island.uv_primitives) {
+        for (uv_islands::UVPrimitive &uv_primitive : uv_primitives) {
+          lookup[uv_primitive.primitive->index].append_as(Entry(&uv_primitive, uv_island_index));
+        }
+      }
+      uv_island_index++;
+    }
+  }
+};
+
 struct EncodePixelsUserData {
   Image *image;
   ImageUser *image_user;
   PBVH *pbvh;
   Vector<PBVHNode *> *nodes;
   const MLoopUV *ldata_uv;
+  const uv_islands::UVIslandsMask *uv_masks;
+  /** Lookup to retrieve the UV primitives based on the primitive index. */
+  const UVPrimitiveLookup *uv_primitive_lookup;
 };
 
 static void do_encode_pixels(void *__restrict userdata,
@@ -119,9 +160,10 @@ static void do_encode_pixels(void *__restrict userdata,
   EncodePixelsUserData *data = static_cast<EncodePixelsUserData *>(userdata);
   Image *image = data->image;
   ImageUser image_user = *data->image_user;
-  PBVH *pbvh = data->pbvh;
   PBVHNode *node = (*data->nodes)[n];
   NodeData *node_data = static_cast<NodeData *>(node->pixels.node_data);
+  const uv_islands::UVIslandsMask &uv_masks = *data->uv_masks;
+
   LISTBASE_FOREACH (ImageTile *, tile, &data->image->tiles) {
     image::ImageTileWrapper image_tile(tile);
     image_user.tile = image_tile.get_tile_number();
@@ -130,40 +172,59 @@ static void do_encode_pixels(void *__restrict userdata,
       continue;
     }
 
-    float2 tile_offset = float2(image_tile.get_tile_offset());
     UDIMTilePixels tile_data;
+    tile_data.tile_number = image_tile.get_tile_number();
+    float2 tile_offset = float2(image_tile.get_tile_offset());
 
-    Triangles &triangles = node_data->triangles;
-    for (int triangle_index = 0; triangle_index < triangles.size(); triangle_index++) {
-      const MLoopTri *lt = &pbvh->looptri[node->prim_indices[triangle_index]];
-      float2 uvs[3] = {
-          float2(data->ldata_uv[lt->tri[0]].uv) - tile_offset,
-          float2(data->ldata_uv[lt->tri[1]].uv) - tile_offset,
-          float2(data->ldata_uv[lt->tri[2]].uv) - tile_offset,
-      };
+    for (int pbvh_node_prim_index = 0; pbvh_node_prim_index < node->totprim;
+         pbvh_node_prim_index++) {
+      int64_t geom_prim_index = node->prim_indices[pbvh_node_prim_index];
+      for (const UVPrimitiveLookup::Entry &entry :
+           data->uv_primitive_lookup->lookup[geom_prim_index]) {
+        uv_islands::UVBorder uv_border = entry.uv_primitive->extract_border();
+        float2 uvs[3] = {
+            entry.uv_primitive->get_uv_vertex(0)->uv - tile_offset,
+            entry.uv_primitive->get_uv_vertex(1)->uv - tile_offset,
+            entry.uv_primitive->get_uv_vertex(2)->uv - tile_offset,
+        };
+        const float minv = clamp_f(min_fff(uvs[0].y, uvs[1].y, uvs[2].y), 0.0f, 1.0f);
+        const int miny = floor(minv * image_buffer->y);
+        const float maxv = clamp_f(max_fff(uvs[0].y, uvs[1].y, uvs[2].y), 0.0f, 1.0f);
+        const int maxy = min_ii(ceil(maxv * image_buffer->y), image_buffer->y);
+        const float minu = clamp_f(min_fff(uvs[0].x, uvs[1].x, uvs[2].x), 0.0f, 1.0f);
+        const int minx = floor(minu * image_buffer->x);
+        const float maxu = clamp_f(max_fff(uvs[0].x, uvs[1].x, uvs[2].x), 0.0f, 1.0f);
+        const int maxx = min_ii(ceil(maxu * image_buffer->x), image_buffer->x);
 
-      const float minv = clamp_f(min_fff(uvs[0].y, uvs[1].y, uvs[2].y), 0.0f, 1.0f);
-      const int miny = floor(minv * image_buffer->y);
-      const float maxv = clamp_f(max_fff(uvs[0].y, uvs[1].y, uvs[2].y), 0.0f, 1.0f);
-      const int maxy = min_ii(ceil(maxv * image_buffer->y), image_buffer->y);
-      const float minu = clamp_f(min_fff(uvs[0].x, uvs[1].x, uvs[2].x), 0.0f, 1.0f);
-      const int minx = floor(minu * image_buffer->x);
-      const float maxu = clamp_f(max_fff(uvs[0].x, uvs[1].x, uvs[2].x), 0.0f, 1.0f);
-      const int maxx = min_ii(ceil(maxu * image_buffer->x), image_buffer->x);
+        /* TODO: Perform bounds check */
+        int64_t uv_prim_index = node_data->uv_primitives.size();
+        node_data->uv_primitives.append(geom_prim_index);
+        UVPrimitivePaintInput &paint_input = node_data->uv_primitives.last();
 
-      TrianglePaintInput &triangle = triangles.get_paint_input(triangle_index);
-      triangle.delta_barycentric_coord_u = calc_barycentric_delta_x(image_buffer, uvs, minx, miny);
-      extract_barycentric_pixels(
-          tile_data, image_buffer, triangle_index, uvs, minx, miny, maxx, maxy);
+        /* Calculate barycentric delta */
+        paint_input.delta_barycentric_coord_u = calc_barycentric_delta_x(
+            image_buffer, uvs, minx, miny);
+
+        /* Extract the pixels. */
+        extract_barycentric_pixels(tile_data,
+                                   image_buffer,
+                                   uv_masks,
+                                   entry.uv_island_index,
+                                   uv_prim_index,
+                                   uvs,
+                                   tile_offset,
+                                   minx,
+                                   miny,
+                                   maxx,
+                                   maxy);
+      }
     }
-
     BKE_image_release_ibuf(image, image_buffer, nullptr);
 
     if (tile_data.pixel_rows.is_empty()) {
       continue;
     }
 
-    tile_data.tile_number = image_tile.get_tile_number();
     node_data->tiles.append(tile_data);
   }
 }
@@ -211,6 +272,16 @@ static bool find_nodes_to_update(PBVH *pbvh, Vector<PBVHNode *> &r_nodes_to_upda
     return false;
   }
 
+  /* Init or reset PBVH pixel data when changes detected. */
+  if (pbvh->pixels.data == nullptr) {
+    PBVHData *pbvh_data = MEM_new<PBVHData>(__func__);
+    pbvh->pixels.data = pbvh_data;
+  }
+  else {
+    PBVHData *pbvh_data = static_cast<PBVHData *>(pbvh->pixels.data);
+    pbvh_data->clear_data();
+  }
+
   r_nodes_to_update.reserve(nodes_to_update_len);
 
   for (int n = 0; n < pbvh->totnode; n++) {
@@ -290,11 +361,31 @@ static void update_pixels(PBVH *pbvh, Mesh *mesh, Image *image, ImageUser *image
     return;
   }
 
-  for (PBVHNode *node : nodes_to_update) {
-    NodeData *node_data = static_cast<NodeData *>(node->pixels.node_data);
-    const Span<MLoop> loops = mesh->loops();
-    init_triangles(pbvh, node, node_data, loops.data());
+  uv_islands::MeshData mesh_data(
+      pbvh->looptri, pbvh->totprim, pbvh->totvert, pbvh->mloop, ldata_uv);
+  uv_islands::UVIslands islands(mesh_data);
+
+  uv_islands::UVIslandsMask uv_masks;
+  ImageUser tile_user = *image_user;
+  LISTBASE_FOREACH (ImageTile *, tile_data, &image->tiles) {
+    image::ImageTileWrapper image_tile(tile_data);
+    tile_user.tile = image_tile.get_tile_number();
+    ImBuf *tile_buffer = BKE_image_acquire_ibuf(image, &tile_user, nullptr);
+    if (tile_buffer == nullptr) {
+      continue;
+    }
+    uv_masks.add_tile(float2(image_tile.get_tile_x_offset(), image_tile.get_tile_y_offset()),
+                      ushort2(tile_buffer->x, tile_buffer->y));
+    BKE_image_release_ibuf(image, tile_buffer, nullptr);
   }
+  uv_masks.add(islands);
+  uv_masks.dilate(image->seamfix_iter);
+
+  islands.extract_borders();
+  islands.extend_borders(uv_masks);
+  update_geom_primitives(*pbvh, mesh_data);
+
+  UVPrimitiveLookup uv_primitive_lookup(mesh_data.looptri_len, islands);
 
   EncodePixelsUserData user_data;
   user_data.pbvh = pbvh;
@@ -302,6 +393,8 @@ static void update_pixels(PBVH *pbvh, Mesh *mesh, Image *image, ImageUser *image
   user_data.image_user = image_user;
   user_data.ldata_uv = ldata_uv;
   user_data.nodes = &nodes_to_update;
+  user_data.uv_primitive_lookup = &uv_primitive_lookup;
+  user_data.uv_masks = &uv_masks;
 
   TaskParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, true, nodes_to_update.size());
@@ -356,6 +449,13 @@ NodeData &BKE_pbvh_pixels_node_data_get(PBVHNode &node)
   return *node_data;
 }
 
+PBVHData &BKE_pbvh_pixels_data_get(PBVH &pbvh)
+{
+  BLI_assert(pbvh.pixels.data != nullptr);
+  PBVHData *data = static_cast<PBVHData *>(pbvh.pixels.data);
+  return *data;
+}
+
 void BKE_pbvh_pixels_mark_image_dirty(PBVHNode &node, Image &image, ImageUser &image_user)
 {
   BLI_assert(node.pixels.node_data != nullptr);
@@ -387,10 +487,17 @@ void BKE_pbvh_build_pixels(PBVH *pbvh, Mesh *mesh, Image *image, ImageUser *imag
   update_pixels(pbvh, mesh, image, image_user);
 }
 
-void pbvh_pixels_free(PBVHNode *node)
+void pbvh_node_pixels_free(PBVHNode *node)
 {
   NodeData *node_data = static_cast<NodeData *>(node->pixels.node_data);
   MEM_delete(node_data);
   node->pixels.node_data = nullptr;
 }
+
+void pbvh_pixels_free(PBVH *pbvh)
+{
+  PBVHData *pbvh_data = static_cast<PBVHData *>(pbvh->pixels.data);
+  MEM_delete(pbvh_data);
+  pbvh->pixels.data = nullptr;
+}
 }

source/blender/blenkernel/intern/pbvh_uv_islands.hh

@@ -0,0 +1,334 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+/** \file
+ * \ingroup bke
+ *
+ * UV Islands for PBVH Pixel extraction. When primitives share an edge they belong to the same UV
+ * Island.
+ *
+ * \note Similar to `uvedit_islands.cc`, but optimized for PBVH painting without using BMesh for
+ * performance reasons. Non-manifold meshes only (i.e. edges must have less than 3 faces).
+ *
+ * Polygons (face with more than 3 edges) are supported as they are split up to primitives.
+ *
+ * \note After the algorithm is stable the OO data structures should be converted back to use DOD
+ * principles to improve reusability. Currently this is not done (yet) as during implementation it
+ * was hard to follow when the algorithm evolved during several iterations. At that time we needed
+ * more flexibility.
+ */
+
+#pragma once
+
+#include <fstream>
+#include <optional>
+
+#include "BLI_array.hh"
+#include "BLI_edgehash.h"
+#include "BLI_float3x3.hh"
+#include "BLI_map.hh"
+#include "BLI_math.h"
+#include "BLI_math_vec_types.hh"
+#include "BLI_rect.h"
+#include "BLI_vector.hh"
+#include "BLI_vector_list.hh"
+
+#include "DNA_meshdata_types.h"
+
+namespace blender::bke::pbvh::uv_islands {
+
+struct MeshEdge;
+struct MeshPrimitive;
+struct UVBorder;
+struct UVEdge;
+struct UVIslands;
+struct UVIslandsMask;
+struct UVPrimitive;
+struct UVPrimitiveEdge;
+struct UVVertex;
+
+struct MeshVertex {
+  int64_t v;
+  Vector<MeshEdge *> edges;
+};
+
+struct MeshUVVert {
+  MeshVertex *vertex;
+  float2 uv;
+  int64_t loop;
+};
+
+struct MeshEdge {
+  MeshVertex *vert1;
+  MeshVertex *vert2;
+  Vector<MeshPrimitive *> primitives;
+};
+
+/** Represents a triangle in 3d space (MLoopTri). */
+struct MeshPrimitive {
+  int64_t index;
+  int64_t poly;
+  Vector<MeshEdge *, 3> edges;
+  Vector<MeshUVVert, 3> vertices;
+
+  /**
+   * UV island this primitive belongs to. This is used to speed up the initial uv island
+   * extraction and should not be used afterwards.
+   */
+  int64_t uv_island_id;
+
+  /** Get the vertex that is not given. Both given vertices must be part of the MeshPrimitive. */
+  MeshUVVert *get_other_uv_vertex(const MeshVertex *v1, const MeshVertex *v2);
+
+  /** Get the UV bounds for this MeshPrimitive. */
+  rctf uv_bounds() const;
+
+  /** Is the given MeshPrimitive sharing an edge. */
+  bool has_shared_uv_edge(const MeshPrimitive *other) const;
+};
+
+/**
+ * MeshData contains input geometry data converted in a list of primitives, edges and vertices for
+ * quick access for both local space and uv space.
+ */
+struct MeshData {
+ public:
+  const MLoopTri *looptri;
+  const int64_t looptri_len;
+  const int64_t vert_len;
+  const MLoop *mloop;
+  const MLoopUV *mloopuv;
+
+  Vector<MeshPrimitive> primitives;
+  Vector<MeshEdge> edges;
+  Vector<MeshVertex> vertices;
+  /** Total number of found uv islands. */
+  int64_t uv_island_len;
+
+ public:
+  explicit MeshData(const MLoopTri *looptri,
+                    const int64_t looptri_len,
+                    const int64_t vert_len,
+                    const MLoop *mloop,
+                    const MLoopUV *mloopuv);
+};
+
+struct UVVertex {
+  MeshVertex *vertex;
+  /* Position in uv space. */
+  float2 uv;
+
+  /* uv edges that share this UVVertex. */
+  Vector<UVEdge *> uv_edges;
+
+  struct {
+    bool is_border : 1;
+    bool is_extended : 1;
+  } flags;
+
+  explicit UVVertex();
+  explicit UVVertex(const MeshUVVert &vert);
+};
+
+struct UVEdge {
+  std::array<UVVertex *, 2> vertices;
+  Vector<UVPrimitive *, 2> uv_primitives;
+
+  UVVertex *get_other_uv_vertex(const MeshVertex *vertex);
+  bool has_shared_edge(const MeshUVVert &v1, const MeshUVVert &v2) const;
+  bool has_shared_edge(const UVEdge &other) const;
+  bool has_same_vertices(const MeshEdge &edge) const;
+  bool is_border_edge() const;
+
+ private:
+  bool has_shared_edge(const UVVertex &v1, const UVVertex &v2) const;
+  bool has_same_vertices(const MeshVertex &vert1, const MeshVertex &vert2) const;
+  bool has_same_uv_vertices(const UVEdge &other) const;
+};
+
+struct UVPrimitive {
+  /**
+   * Index of the primitive in the original mesh.
+   */
+  MeshPrimitive *primitive;
+  Vector<UVEdge *, 3> edges;
+
+  explicit UVPrimitive(MeshPrimitive *primitive);
+
+  Vector<std::pair<UVEdge *, UVEdge *>> shared_edges(UVPrimitive &other);
+  bool has_shared_edge(const UVPrimitive &other) const;
+  bool has_shared_edge(const MeshPrimitive &primitive) const;
+
+  /**
+   * Get the UVVertex in the order that the verts are ordered in the MeshPrimitive.
+   */
+  const UVVertex *get_uv_vertex(const uint8_t mesh_vert_index) const;
+
+  /**
+   * Get the UVEdge that share the given uv coordinates.
+   * Will assert when no UVEdge found.
+   */
+  UVEdge *get_uv_edge(const float2 uv1, const float2 uv2) const;
+  UVEdge *get_uv_edge(const MeshVertex *v1, const MeshVertex *v2) const;
+
+  const bool contains_uv_vertex(const UVVertex *uv_vertex) const;
+  const UVVertex *get_other_uv_vertex(const UVVertex *v1, const UVVertex *v2) const;
+
+  UVBorder extract_border() const;
+};
+
+struct UVBorderEdge {
+  UVEdge *edge;
+  bool tag = false;
+  UVPrimitive *uv_primitive;
+  /* Should the vertices of the edge be evaluated in reverse order. */
+  bool reverse_order = false;
+
+  int64_t index = -1;
+  int64_t prev_index = -1;
+  int64_t next_index = -1;
+  int64_t border_index = -1;
+
+  explicit UVBorderEdge(UVEdge *edge, UVPrimitive *uv_primitive);
+
+  UVVertex *get_uv_vertex(int index);
+  const UVVertex *get_uv_vertex(int index) const;
+
+  /**
+   * Get the uv vertex from the primitive that is not part of the edge.
+   */
+  const UVVertex *get_other_uv_vertex() const;
+
+  float length() const;
+};
+
+struct UVBorderCorner {
+  UVBorderEdge *first;
+  UVBorderEdge *second;
+  float angle;
+
+  explicit UVBorderCorner(UVBorderEdge *first, UVBorderEdge *second, float angle);
+
+  /**
+   * Calculate a uv coordinate between the edges of the corner.
+   *
+   * 'min_uv_distance' is the minimum distance between the corner and the
+   * resulting uv coordinate. The distance is in uv space.
+   */
+  float2 uv(float factor, float min_uv_distance);
+};
+
+struct UVBorder {
+  /** Ordered list of UV Verts of the border of this island. */
+  Vector<UVBorderEdge> edges;
+
+  /**
+   * Check if the border is counter clock wise from its island.
+   */
+  bool is_ccw() const;
+
+  /**
+   * Flip the order of the verts, changing the order between CW and CCW.
+   */
+  void flip_order();
+
+  /**
+   * Calculate the outside angle of the given vert.
+   */
+  float outside_angle(const UVBorderEdge &vert) const;
+
+  void update_indexes(uint64_t border_index);
+
+  static std::optional<UVBorder> extract_from_edges(Vector<UVBorderEdge> &edges);
+
+  /** Remove edge from the border. updates the indexes. */
+  void remove(int64_t index);
+};
+
+struct UVIsland {
+  VectorList<UVVertex> uv_vertices;
+  VectorList<UVEdge> uv_edges;
+  VectorList<UVPrimitive> uv_primitives;
+  /**
+   * List of borders of this island. There can be multiple borders per island as a border could
+   * be completely encapsulated by another one.
+   */
+  Vector<UVBorder> borders;
+
+  /**
+   * Key is mesh vert index, Value is list of UVVertices that refer to the mesh vertex with that
+   * index. Map is used internally to quickly lookup similar UVVertices.
+   */
+  Map<int64_t, Vector<UVVertex *>> uv_vertex_lookup;
+
+  UVVertex *lookup(const UVVertex &vertex);
+  UVVertex *lookup_or_create(const UVVertex &vertex);
+  UVEdge *lookup(const UVEdge &edge);
+  UVEdge *lookup_or_create(const UVEdge &edge);
+
+  /** Initialize the border attribute. */
+  void extract_borders();
+  /** Iterative extend border to fit the mask. */
+  void extend_border(const UVIslandsMask &mask, const short island_index);
+
+ private:
+  void append(const UVPrimitive &primitive);
+
+ public:
+  bool has_shared_edge(const UVPrimitive &primitive) const;
+  bool has_shared_edge(const MeshPrimitive &primitive) const;
+  void extend_border(const UVPrimitive &primitive);
+};
+
+struct UVIslands {
+  Vector<UVIsland> islands;
+
+  explicit UVIslands(MeshData &mesh_data);
+
+  void extract_borders();
+  void extend_borders(const UVIslandsMask &islands_mask);
+};
+
+/** Mask to find the index of the UVIsland for a given UV coordinate. */
+struct UVIslandsMask {
+
+  /** Mask for each udim tile. */
+  struct Tile {
+    float2 udim_offset;
+    ushort2 tile_resolution;
+    ushort2 mask_resolution;
+    Array<uint16_t> mask;
+
+    Tile(float2 udim_offset, ushort2 tile_resolution);
+
+    bool is_masked(const uint16_t island_index, const float2 uv) const;
+    bool contains(const float2 uv) const;
+    float get_pixel_size_in_uv_space() const;
+  };
+
+  Vector<Tile> tiles;
+
+  void add_tile(float2 udim_offset, ushort2 resolution);
+
+  /**
+   * Find a tile containing the given uv coordinate.
+   */
+  const Tile *find_tile(const float2 uv) const;
+
+  /**
+   * Is the given uv coordinate part of the given island_index mask.
+   *
+   * true - part of the island mask.
+   * false - not part of the island mask.
+   */
+  bool is_masked(const uint16_t island_index, const float2 uv) const;
+
+  /**
+   * Add the given UVIslands to the mask. Tiles should be added beforehand using the 'add_tile'
+   * method.
+   */
+  void add(const UVIslands &islands);
+
+  void dilate(int max_iterations);
+};
+
+}  // namespace blender::bke::pbvh::uv_islands

source/blender/blenlib/BLI_vector.hh

@@ -918,6 +918,11 @@ class Vector {
     return int64_t(capacity_end_ - begin_);
   }
 
+  bool is_at_capacity() const
+  {
+    return end_ == capacity_end_;
+  }
+
   /**
    * Get an index range that makes looping over all indices more convenient and less error prone.
    * Obviously, this should only be used when you actually need the index in the loop.

source/blender/blenlib/BLI_vector_list.hh

@@ -0,0 +1,120 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+#pragma once
+
+#include <algorithm>
+
+#include "BLI_vector.hh"
+
+namespace blender {
+
+/**
+ * A VectorList is a vector of vectors.
+ *
+ * VectorList can be used when:
+ *
+ * 1) Don't know up front the number of elements that will be added to the list. Use array or
+ * vector.reserve when known up front.
+ *
+ * 2) Number of reads/writes doesn't require sequential access
+ * of the whole list. A vector ensures memory is sequential which is fast when reading, writing can
+ * have overhead when the reserved memory is full.
+ *
+ * When a VectorList reserved memory is full it will allocate memory for the new items, breaking
+ * the sequential access. Within each allocated memory block the elements are ordered sequentially.
+ */
+template<typename T, int64_t CapacityStart = 32, int64_t CapacitySoftLimit = 4096>
+class VectorList {
+ public:
+  using UsedVector = Vector<T, 0>;
+
+ private:
+  /**
+   * Contains the individual vectors. There must always be at least one vector
+   */
+  Vector<UsedVector> vectors_;
+
+ public:
+  VectorList()
+  {
+    this->append_vector();
+  }
+
+  void append(const T &value)
+  {
+    this->append_as(value);
+  }
+
+  void append(T &&value)
+  {
+    this->append_as(std::move(value));
+  }
+
+  template<typename ForwardT> void append_as(ForwardT &&value)
+  {
+    UsedVector &vector = this->ensure_space_for_one();
+    vector.append_unchecked_as(std::forward<ForwardT>(value));
+  }
+
+  UsedVector *begin()
+  {
+    return vectors_.begin();
+  }
+
+  UsedVector *end()
+  {
+    return vectors_.end();
+  }
+
+  const UsedVector *begin() const
+  {
+    return vectors_.begin();
+  }
+
+  const UsedVector *end() const
+  {
+    return vectors_.end();
+  }
+
+  T &last()
+  {
+    return vectors_.last().last();
+  }
+
+  int64_t size() const
+  {
+    int64_t result = 0;
+    for (const UsedVector &vector : *this) {
+      result += vector.size();
+    }
+    return result;
+  }
+
+ private:
+  UsedVector &ensure_space_for_one()
+  {
+    UsedVector &vector = vectors_.last();
+    if (LIKELY(!vector.is_at_capacity())) {
+      return vector;
+    }
+    this->append_vector();
+    return vectors_.last();
+  }
+
+  void append_vector()
+  {
+    const int64_t new_vector_capacity = this->get_next_vector_capacity();
+    vectors_.append({});
+    vectors_.last().reserve(new_vector_capacity);
+  }
+
+  int64_t get_next_vector_capacity()
+  {
+    if (vectors_.is_empty()) {
+      return CapacityStart;
+    }
+    return std::min(vectors_.last().capacity() * 2, CapacitySoftLimit);
+  }
+};
+
+}  // namespace blender

source/blender/blenlib/CMakeLists.txt

@@ -340,6 +340,7 @@ set(SRC
   BLI_uuid.h
   BLI_uvproject.h
   BLI_vector.hh
+  BLI_vector_list.hh
   BLI_vector_set.hh
   BLI_vector_set_slots.hh
   BLI_virtual_array.hh

source/blender/blenloader/intern/versioning_300.cc

@@ -3711,5 +3711,12 @@ void blo_do_versions_300(FileData *fd, Library * /*lib*/, Main *bmain)
    */
   {
     /* Keep this block, even when empty. */
+
+    /* UVSeam fixing distance. */
+    if (!DNA_struct_elem_find(fd->filesdna, "Image", "short", "seamfix_iter")) {
+      LISTBASE_FOREACH (Image *, image, &bmain->images) {
+        image->seamfix_iter = 8;
+      }
+    }
   }
 }

source/blender/editors/sculpt_paint/sculpt_paint_image.cc

@@ -146,15 +146,18 @@ template<typename ImageBuffer> class PaintingKernel {
     init_brush_test();
   }
 
-  bool paint(const Triangles &triangles,
+  bool paint(const PaintGeometryPrimitives &geom_primitives,
+             const PaintUVPrimitives &uv_primitives,
              const PackedPixelRow &pixel_row,
              ImBuf *image_buffer,
              AutomaskingNodeData *automask_data)
   {
     image_accessor.set_image_position(image_buffer, pixel_row.start_image_coordinate);
-    const TrianglePaintInput triangle = triangles.get_paint_input(pixel_row.triangle_index);
-    float3 pixel_pos = get_start_pixel_pos(triangle, pixel_row);
-    const float3 delta_pixel_pos = get_delta_pixel_pos(triangle, pixel_row, pixel_pos);
+    const UVPrimitivePaintInput paint_input = uv_primitives.get_paint_input(
+        pixel_row.uv_primitive_index);
+    float3 pixel_pos = get_start_pixel_pos(geom_primitives, paint_input, pixel_row);
+    const float3 delta_pixel_pos = get_delta_pixel_pos(
+        geom_primitives, paint_input, pixel_row, pixel_pos);
     bool pixels_painted = false;
     for (int x = 0; x < pixel_row.num_pixels; x++) {
       if (!brush_test_fn(&test, pixel_pos)) {
@@ -231,29 +234,35 @@ template<typename ImageBuffer> class PaintingKernel {
   /**
    * Extract the starting pixel position from the given encoded_pixels belonging to the triangle.
    */
-  float3 get_start_pixel_pos(const TrianglePaintInput &triangle,
+  float3 get_start_pixel_pos(const PaintGeometryPrimitives &geom_primitives,
+                             const UVPrimitivePaintInput &paint_input,
                              const PackedPixelRow &encoded_pixels) const
   {
-    return init_pixel_pos(triangle, encoded_pixels.start_barycentric_coord);
+    return init_pixel_pos(geom_primitives, paint_input, encoded_pixels.start_barycentric_coord);
   }
 
   /**
    * Extract the delta pixel position that will be used to advance a Pixel instance to the next
    * pixel.
    */
-  float3 get_delta_pixel_pos(const TrianglePaintInput &triangle,
+  float3 get_delta_pixel_pos(const PaintGeometryPrimitives &geom_primitives,
+                             const UVPrimitivePaintInput &paint_input,
                              const PackedPixelRow &encoded_pixels,
                              const float3 &start_pixel) const
   {
-    float3 result = init_pixel_pos(
-        triangle, encoded_pixels.start_barycentric_coord + triangle.delta_barycentric_coord_u);
+    float3 result = init_pixel_pos(geom_primitives,
+                                   paint_input,
+                                   encoded_pixels.start_barycentric_coord +
+                                       paint_input.delta_barycentric_coord_u);
     return result - start_pixel;
   }
 
-  float3 init_pixel_pos(const TrianglePaintInput &triangle,
+  float3 init_pixel_pos(const PaintGeometryPrimitives &geom_primitives,
+                        const UVPrimitivePaintInput &paint_input,
                         const float2 &barycentric_weights) const
   {
-    const int3 &vert_indices = triangle.vert_indices;
+    const int3 &vert_indices = geom_primitives.get_vert_indices(
+        paint_input.geometry_primitive_index);
     float3 result;
     const float3 barycentric(barycentric_weights.x,
                              barycentric_weights.y,
@@ -267,11 +276,12 @@ template<typename ImageBuffer> class PaintingKernel {
   }
 };
 
-static std::vector<bool> init_triangle_brush_test(SculptSession *ss,
-                                                  Triangles &triangles,
-                                                  const MVert *mvert)
+static std::vector<bool> init_uv_primitives_brush_test(SculptSession *ss,
+                                                       PaintGeometryPrimitives &geom_primitives,
+                                                       PaintUVPrimitives &uv_primitives,
+                                                       const MVert *mvert)
 {
-  std::vector<bool> brush_test(triangles.size());
+  std::vector<bool> brush_test(uv_primitives.size());
   SculptBrushTest test;
   SCULPT_brush_test_init(ss, &test);
   float3 brush_min_bounds(test.location[0] - test.radius,
@@ -280,13 +290,15 @@ static std::vector<bool> init_triangle_brush_test(SculptSession *ss,
   float3 brush_max_bounds(test.location[0] + test.radius,
                           test.location[1] + test.radius,
                           test.location[2] + test.radius);
-  for (int triangle_index = 0; triangle_index < triangles.size(); triangle_index++) {
-    TrianglePaintInput &triangle = triangles.get_paint_input(triangle_index);
+  for (int uv_prim_index = 0; uv_prim_index < uv_primitives.size(); uv_prim_index++) {
+    const UVPrimitivePaintInput &paint_input = uv_primitives.get_paint_input(uv_prim_index);
+    const int3 &vert_indices = geom_primitives.get_vert_indices(
+        paint_input.geometry_primitive_index);
 
-    float3 triangle_min_bounds(mvert[triangle.vert_indices[0]].co);
+    float3 triangle_min_bounds(mvert[vert_indices[0]].co);
     float3 triangle_max_bounds(triangle_min_bounds);
     for (int i = 1; i < 3; i++) {
-      const float3 &pos = mvert[triangle.vert_indices[i]].co;
+      const float3 &pos = mvert[vert_indices[i]].co;
       triangle_min_bounds.x = min_ff(triangle_min_bounds.x, pos.x);
       triangle_min_bounds.y = min_ff(triangle_min_bounds.y, pos.y);
       triangle_min_bounds.z = min_ff(triangle_min_bounds.z, pos.z);
@@ -294,7 +306,7 @@ static std::vector<bool> init_triangle_brush_test(SculptSession *ss,
       triangle_max_bounds.y = max_ff(triangle_max_bounds.y, pos.y);
       triangle_max_bounds.z = max_ff(triangle_max_bounds.z, pos.z);
     }
-    brush_test[triangle_index] = isect_aabb_aabb_v3(
+    brush_test[uv_prim_index] = isect_aabb_aabb_v3(
         brush_min_bounds, brush_max_bounds, triangle_min_bounds, triangle_max_bounds);
   }
   return brush_test;
@@ -308,13 +320,15 @@ static void do_paint_pixels(void *__restrict userdata,
   Object *ob = data->ob;
   SculptSession *ss = ob->sculpt;
   const Brush *brush = data->brush;
+  PBVH *pbvh = ss->pbvh;
   PBVHNode *node = data->nodes[n];
-
+  PBVHData &pbvh_data = BKE_pbvh_pixels_data_get(*pbvh);
   NodeData &node_data = BKE_pbvh_pixels_node_data_get(*node);
   const int thread_id = BLI_task_parallel_thread_id(tls);
   MVert *mvert = SCULPT_mesh_deformed_mverts_get(ss);
 
-  std::vector<bool> brush_test = init_triangle_brush_test(ss, node_data.triangles, mvert);
+  std::vector<bool> brush_test = init_uv_primitives_brush_test(
+      ss, pbvh_data.geom_primitives, node_data.uv_primitives, mvert);
 
   PaintingKernel<ImageBufferFloat4> kernel_float4(ss, brush, thread_id, mvert);
   PaintingKernel<ImageBufferByte4> kernel_byte4(ss, brush, thread_id, mvert);
@@ -343,17 +357,17 @@ static void do_paint_pixels(void *__restrict userdata,
         }
 
         for (const PackedPixelRow &pixel_row : tile_data.pixel_rows) {
-          if (!brush_test[pixel_row.triangle_index]) {
+          if (!brush_test[pixel_row.uv_primitive_index]) {
             continue;
           }
           bool pixels_painted = false;
           if (image_buffer->rect_float != nullptr) {
             pixels_painted = kernel_float4.paint(
-                node_data.triangles, pixel_row, image_buffer, &automask_data);
+                pbvh_data.geom_primitives, node_data.uv_primitives, pixel_row, image_buffer, &automask_data);
           }
           else {
             pixels_painted = kernel_byte4.paint(
-                node_data.triangles, pixel_row, image_buffer, &automask_data);
+                pbvh_data.geom_primitives, node_data.uv_primitives, pixel_row, image_buffer, &automask_data);
           }
 
           if (pixels_painted) {

source/blender/editors/space_image/image_buttons.c

@@ -952,6 +952,7 @@ void uiTemplateImage(uiLayout *layout,
       }
 
       uiItemR(col, &imaptr, "use_view_as_render", 0, NULL, ICON_NONE);
+      uiItemR(col, &imaptr, "seamfix_iter", 0, NULL, ICON_NONE);
     }
   }
 

source/blender/makesdna/DNA_image_defaults.h

@@ -24,6 +24,7 @@
     .gpuframenr = INT_MAX, \
     .gpu_pass = SHRT_MAX, \
     .gpu_layer = SHRT_MAX, \
+    .seamfix_iter = 8, \
   }
 
 /** \} */

source/blender/makesdna/DNA_image_types.h

@@ -163,7 +163,11 @@ typedef struct Image {
   short gpu_pass;
   short gpu_layer;
   short gpu_view;
-  char _pad2[4];
+
+  /* Number of iterations to perform to extract a mask for uv seam fixing. */
+  short seamfix_iter;
+
+  char _pad2[2];
 
   /** Deprecated. */
   struct PackedFile *packedfile DNA_DEPRECATED;

source/blender/makesrna/intern/rna_image.c

@@ -1373,6 +1373,14 @@ static void rna_def_image(BlenderRNA *brna)
                            "Use 16 bits per channel to lower the memory usage during rendering");
   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_gpu_texture_update");
 
+  prop = RNA_def_property(srna, "seamfix_iter", PROP_INT, PROP_NONE);
+  RNA_def_property_ui_text(
+      prop,
+      "Seam-fix",
+      "Number of dilate iterations when extracting masks for UV Islands. Higher "
+      "number would improve seam-fixes for mipmaps, but decreases performance");
+  RNA_def_property_ui_range(prop, 1, 100, 1, 1);
+
   /* multiview */
   prop = RNA_def_property(srna, "views_format", PROP_ENUM, PROP_NONE);
   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);