[Bf-blender-cvs] [02f628fec6d] temp-T97352-3d-texturing-seam-bleeding-b2: Use functions to detect an error in the algorithm. Still looking for the error.
Jeroen Bakker
noreply at git.blender.org
Tue Jun 14 14:56:59 CEST 2022
Commit: 02f628fec6d4b10e2cb3dba079a19e55dcd37680
Author: Jeroen Bakker
Date: Mon Jun 13 14:27:14 2022 +0200
Branches: temp-T97352-3d-texturing-seam-bleeding-b2
https://developer.blender.org/rB02f628fec6d4b10e2cb3dba079a19e55dcd37680
Use functions to detect an error in the algorithm. Still looking for the error.
===================================================================
M source/blender/blenkernel/BKE_uv_islands.hh
M source/blender/blenkernel/intern/uv_islands.cc
===================================================================
diff --git a/source/blender/blenkernel/BKE_uv_islands.hh b/source/blender/blenkernel/BKE_uv_islands.hh
index 4a07077d816..9b45fe23f2b 100644
--- a/source/blender/blenkernel/BKE_uv_islands.hh
+++ b/source/blender/blenkernel/BKE_uv_islands.hh
@@ -62,7 +62,7 @@ struct MeshPrimitive {
Vector<MeshEdge *, 3> edges;
Vector<MeshUVVert, 3> vertices;
- const MeshUVVert &get_uv_vert(const MeshVertex *vert)
+ const MeshUVVert &get_uv_vert(const MeshVertex *vert) const
{
for (const MeshUVVert &uv_vert : vertices) {
if (uv_vert.vertex == vert) {
@@ -216,6 +216,14 @@ struct UVEdge {
(vertices[0]->uv == v2.uv && vertices[1]->uv == v1.uv);
}
+ bool has_shared_loop(const UVEdge &other) const
+ {
+ return ((vertices[0]->loop == other.vertices[0]->loop &&
+ vertices[1]->loop == other.vertices[1]->loop) ||
+ (vertices[0]->loop == other.vertices[1]->loop &&
+ vertices[1]->loop == other.vertices[0]->loop));
+ }
+
bool has_shared_edge(const UVEdge &other) const
{
return has_shared_edge(*other.vertices[0], *other.vertices[1]);
@@ -315,6 +323,23 @@ struct UVPrimitive {
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 == uv2)) {
+ return uv_edge;
+ }
+ }
+ BLI_assert_unreachable();
+ return nullptr;
+ }
+
UVBorder extract_border() const;
};
@@ -428,9 +453,9 @@ struct UVIsland {
const MeshUVVert &v1 = primitive.get_uv_vert(edge->vert1);
const MeshUVVert &v2 = primitive.get_uv_vert(edge->vert2);
UVEdge uv_edge_template;
- uv_edge_template.vertices[0] = lookup_or_create(UVVertex(v1));
- uv_edge_template.vertices[1] = lookup_or_create(UVVertex(v2));
- UVEdge *uv_edge = lookup_or_create(uv_edge_template);
+ uv_edge_template.vertices[0] = lookup_or_create(UVVertex(v1), false);
+ uv_edge_template.vertices[1] = lookup_or_create(UVVertex(v2), false);
+ UVEdge *uv_edge = lookup_or_create(uv_edge_template, true);
uv_primitive_ptr->edges.append(uv_edge);
uv_edge->append_to_uv_vertices();
uv_edge->uv_primitives.append(uv_primitive_ptr);
@@ -438,10 +463,11 @@ struct UVIsland {
return uv_primitive_ptr;
}
- UVVertex *lookup_or_create(const UVVertex &vertex)
+ UVVertex *lookup_or_create(const UVVertex &vertex, const bool loop_check)
{
for (UVVertex &uv_vertex : uv_vertices) {
- if (uv_vertex.uv == vertex.uv && uv_vertex.vertex == vertex.vertex) {
+ if (uv_vertex.uv == vertex.uv && uv_vertex.vertex == vertex.vertex &&
+ ((!loop_check) || ((uv_vertex.loop == vertex.loop)))) {
return &uv_vertex;
}
}
@@ -452,10 +478,10 @@ struct UVIsland {
return result;
}
- UVEdge *lookup_or_create(const UVEdge &edge)
+ UVEdge *lookup_or_create(const UVEdge &edge, const bool loop_check)
{
for (UVEdge &uv_edge : uv_edges) {
- if (uv_edge.has_shared_edge(edge)) {
+ if (uv_edge.has_shared_edge(edge) && (!loop_check || uv_edge.has_shared_loop(edge))) {
return &uv_edge;
}
}
@@ -481,9 +507,9 @@ struct UVIsland {
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);
+ uv_edge_template.vertices[0] = lookup_or_create(*other_edge->vertices[0], false);
+ uv_edge_template.vertices[1] = lookup_or_create(*other_edge->vertices[1], false);
+ new_prim_ptr->edges[i] = lookup_or_create(uv_edge_template, false);
new_prim_ptr->edges[i]->append_to_uv_vertices();
new_prim_ptr->edges[i]->uv_primitives.append(new_prim_ptr);
}
diff --git a/source/blender/blenkernel/intern/uv_islands.cc b/source/blender/blenkernel/intern/uv_islands.cc
index 54d89682386..833c7dbdeca 100644
--- a/source/blender/blenkernel/intern/uv_islands.cc
+++ b/source/blender/blenkernel/intern/uv_islands.cc
@@ -138,6 +138,34 @@ struct Fan {
}
}
+ int count_num_to_add() const
+ {
+ int result = 0;
+ for (const FanSegment &segment : segments) {
+ if (!segment.flags.found) {
+ result++;
+ }
+ }
+ return result;
+ }
+
+ void mark_already_added_segments(const UVVertex &uv_vertex)
+ {
+ for (FanSegment &segment : segments) {
+ segment.flags.found = false;
+ const MeshVertex *v0 = segment.primitive->vertices[segment.vert_order[0]].vertex;
+ const MeshVertex *v1 = segment.primitive->vertices[segment.vert_order[1]].vertex;
+ for (const UVEdge *edge : uv_vertex.uv_edges) {
+ const MeshVertex *e0 = edge->vertices[0]->vertex;
+ const MeshVertex *e1 = edge->vertices[1]->vertex;
+ if ((e0 == v0 && e1 == v1) || (e0 == v1 && e1 == v0)) {
+ segment.flags.found = true;
+ break;
+ }
+ }
+ }
+ }
+
void init_uv_coordinates(UVVertex &uv_vertex, const UVIsland &island)
{
for (FanSegment &segment : segments) {
@@ -181,114 +209,99 @@ static void print(const Fan &fan)
}
}
+static void add_uv_primitive_shared_uv_edge(UVIsland &island,
+ UVVertex *connected_vert_1,
+ UVVertex *connected_vert_2,
+ float2 uv_unconnected,
+ MeshPrimitive *mesh_primitive)
+{
+ UVPrimitive prim1(mesh_primitive);
+
+ MeshUVVert *other_vert = mesh_primitive->get_other_uv_vertex(connected_vert_1->vertex,
+ connected_vert_2->vertex);
+ UVVertex vert_template;
+ vert_template.uv = uv_unconnected;
+ vert_template.loop = other_vert->loop;
+ vert_template.vertex = other_vert->vertex;
+ UVVertex *vert_ptr = island.lookup_or_create(vert_template, true);
+
+ const MeshUVVert *mesh_vert_1 = &mesh_primitive->get_uv_vert(connected_vert_1->vertex);
+ vert_template.uv = connected_vert_1->uv;
+ vert_template.loop = mesh_vert_1->loop;
+ vert_template.vertex = mesh_vert_1->vertex;
+ UVVertex *vert_1_ptr = island.lookup_or_create(vert_template, true);
+
+ const MeshUVVert *mesh_vert_2 = &mesh_primitive->get_uv_vert(connected_vert_2->vertex);
+ vert_template.uv = connected_vert_2->uv;
+ vert_template.loop = mesh_vert_2->loop;
+ vert_template.vertex = mesh_vert_2->vertex;
+ UVVertex *vert_2_ptr = island.lookup_or_create(vert_template, true);
+
+ UVEdge edge_template;
+ edge_template.vertices[0] = vert_1_ptr;
+ edge_template.vertices[1] = vert_2_ptr;
+ prim1.edges.append(island.lookup_or_create(edge_template, true));
+ edge_template.vertices[0] = vert_2_ptr;
+ edge_template.vertices[1] = vert_ptr;
+ prim1.edges.append(island.lookup_or_create(edge_template, true));
+ edge_template.vertices[0] = vert_ptr;
+ edge_template.vertices[1] = vert_1_ptr;
+ prim1.edges.append(island.lookup_or_create(edge_template, true));
+ prim1.append_to_uv_edges();
+ prim1.append_to_uv_vertices();
+ island.uv_primitives.append(prim1);
+ island.validate_primitive(island.uv_primitives.last());
+}
+
static void extend_at_vert(UVIsland &island, UVBorderCorner &corner, const MeshData &mesh_data)
{
- BLI_assert(corner.first->get_uv_vertex(1) == corner.second->get_uv_vertex(0));
UVVertex *uv_vertex = corner.second->get_uv_vertex(0);
Fan fan(*(uv_vertex->vertex));
- print(fan);
fan.init_uv_coordinates(*uv_vertex, island);
- print(fan);
-
- for (FanSegment &segment : fan.segments) {
- segment.flags.found = false;
- MeshVertex *v0 = segment.primitive->vertices[segment.vert_order[0]].vertex;
- MeshVertex *v1 = segment.primitive->vertices[segment.vert_order[1]].vertex;
- for (UVEdge *edge : uv_vertex->uv_edges) {
- if ((edge->vertices[0]->vertex == v0 && edge->vertices[1]->vertex == v1) ||
- (edge->vertices[0]->vertex == v1 && edge->vertices[1]->vertex == v0)) {
- segment.flags.found = true;
- break;
- }
- }
- }
+ fan.mark_already_added_segments(*uv_vertex);
print(fan);
// tag them as being 'not fixed in uv space'. count them and determine a position in uv space.
// add UV primitives for them.
// recalc the border.
- int num_to_add = 0;
- for (FanSegment &segment : fan.segments) {
- if (!segment.flags.found) {
- num_to_add++;
- }
- }
+ int num_to_add = fan.count_num_to_add();
printf("Found %d new edges to add\n", num_to_add);
if (num_to_add == 0) {
float2 center_uv = corner.uv(0.5f);
// no new triangles found. In this case we should extend the existing borders.
- UVVertex center_vertex;
- center_vertex.loop = -1;
- center_vertex.uv = center_uv;
- center_vertex.uv_edges.clear();
- {
- MeshPrimitive *mesh_primitive = corner.second->uv_primitive->primitive;
- UVPrimitive prim1(mesh_primitive);
- MeshUVVert *other_uv_vert = mesh_primitive->get_other_uv_vertex(
- corner.second->edge->vertices[0]->vertex, corner.second->edge->vertices[1]->vertex);
- center_vertex.loop = other_uv_vert->loop;
- center_vertex.vertex = other_uv_vert->vertex;
-
- UVVertex *center_vertex_ptr = island.lookup_or_create(center_vertex);
- UVEdge edge_template;
- edge_template.vertices[0] = corner.first->get_uv_vertex(1);
- edge_template.vertices[1] = corner.first->get_uv_vertex(0);
- prim1.edges.append(island.lookup_or_create(edge_template));
- edge_template.vertices[0] = corner.first->get_uv_vertex(0);
- edge_template.vertices[1] = center_vertex_ptr;
- prim1.edges.append(island.lookup_or_create(edge_template));
- edge_template.vertices[0] = center_vertex_ptr;
- edge_template.vertices[1] = corner.first->get_uv_vertex(1);
- pri
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list