[Bf-blender-cvs] [8226abc1114] geometry-nodes-simulation: Cleanup: Remove duplicate UV islands header
Hans Goudey
noreply at git.blender.org
Mon Dec 19 19:05:25 CET 2022
Commit: 8226abc111412881ca59bcec423fcd9ffd095118
Author: Hans Goudey
Date: Fri Dec 16 09:43:39 2022 -0600
Branches: geometry-nodes-simulation
https://developer.blender.org/rB8226abc111412881ca59bcec423fcd9ffd095118
Cleanup: Remove duplicate UV islands header
This code was duplicated from `pbvh_uv_islands.hh`,
which was the version that was actually used.
===================================================================
D source/blender/blenkernel/BKE_uv_islands.hh
M source/blender/blenkernel/CMakeLists.txt
===================================================================
diff --git a/source/blender/blenkernel/BKE_uv_islands.hh b/source/blender/blenkernel/BKE_uv_islands.hh
deleted file mode 100644
index 406ecf39b71..00000000000
--- a/source/blender/blenkernel/BKE_uv_islands.hh
+++ /dev/null
@@ -1,746 +0,0 @@
-/* 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
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list