From 4593fb52cf809de29bffa8f18af9a9a792def30d Mon Sep 17 00:00:00 2001 From: Aleksi Juvani Date: Wed, 29 Jun 2022 12:25:20 -0500 Subject: Geometry Nodes: UV Unwrap and Pack Islands Nodes This commit adds new Unwrap and Pack Islands nodes, with equivalent functionality to the existing Unwrap and Pack Islands operators. The Unwrap node uses generic boolean attributes to determine seams instead of looking at the seam flags in the mesh geometry. Unlike the Unwrap operator, the Unwrap node doesn't perform aspect ratio correction, because this is trivial for the user to implement with a Vector Math node if it is desired. The Unwrap node implicitly performs a Pack Islands operation upon completion, because the results may not be generally useful otherwise. This matches the behaviour of the Unwrap operator. The nodes use the existing Vector socket type, and do not introduce a new 2D Vector type (see T92765). Differential Revision: https://developer.blender.org/D14389 --- source/blender/nodes/NOD_geometry.h | 2 + source/blender/nodes/NOD_static_types.h | 2 + source/blender/nodes/geometry/CMakeLists.txt | 2 + .../geometry/nodes/node_geo_uv_pack_islands.cc | 152 ++++++++++++++++ .../nodes/geometry/nodes/node_geo_uv_unwrap.cc | 199 +++++++++++++++++++++ 5 files changed, 357 insertions(+) create mode 100644 source/blender/nodes/geometry/nodes/node_geo_uv_pack_islands.cc create mode 100644 source/blender/nodes/geometry/nodes/node_geo_uv_unwrap.cc (limited to 'source/blender/nodes') diff --git a/source/blender/nodes/NOD_geometry.h b/source/blender/nodes/NOD_geometry.h index 889ab2a81e4..8f15add33fd 100644 --- a/source/blender/nodes/NOD_geometry.h +++ b/source/blender/nodes/NOD_geometry.h @@ -140,6 +140,8 @@ void register_node_type_geo_triangulate(void); void register_node_type_geo_viewer(void); void register_node_type_geo_volume_cube(void); void register_node_type_geo_volume_to_mesh(void); +void register_node_type_geo_uv_pack_islands(void); +void register_node_type_geo_uv_unwrap(void); #ifdef __cplusplus } diff --git a/source/blender/nodes/NOD_static_types.h b/source/blender/nodes/NOD_static_types.h index f9925924260..609791ad091 100644 --- a/source/blender/nodes/NOD_static_types.h +++ b/source/blender/nodes/NOD_static_types.h @@ -402,6 +402,8 @@ DefNode(GeometryNode, GEO_NODE_TRIM_CURVE, def_geo_curve_trim, "TRIM_CURVE", Tri DefNode(GeometryNode, GEO_NODE_VIEWER, def_geo_viewer, "VIEWER", Viewer, "Viewer", "") DefNode(GeometryNode, GEO_NODE_VOLUME_CUBE, 0, "VOLUME_CUBE", VolumeCube, "Volume Cube", "") DefNode(GeometryNode, GEO_NODE_VOLUME_TO_MESH, def_geo_volume_to_mesh, "VOLUME_TO_MESH", VolumeToMesh, "Volume to Mesh", "") +DefNode(GeometryNode, GEO_NODE_UV_PACK_ISLANDS, 0, "UV_PACK_ISLANDS", UVPackIslands, "Pack UV Islands", "") +DefNode(GeometryNode, GEO_NODE_UV_UNWRAP, def_geo_uv_unwrap, "UV_UNWRAP", UVUnwrap, "UV Unwrap", "") /* undefine macros */ #undef DefNode diff --git a/source/blender/nodes/geometry/CMakeLists.txt b/source/blender/nodes/geometry/CMakeLists.txt index 9ef3151ddab..950124f75d0 100644 --- a/source/blender/nodes/geometry/CMakeLists.txt +++ b/source/blender/nodes/geometry/CMakeLists.txt @@ -146,6 +146,8 @@ set(SRC nodes/node_geo_transform.cc nodes/node_geo_translate_instances.cc nodes/node_geo_triangulate.cc + nodes/node_geo_uv_pack_islands.cc + nodes/node_geo_uv_unwrap.cc nodes/node_geo_viewer.cc nodes/node_geo_volume_cube.cc nodes/node_geo_volume_to_mesh.cc diff --git a/source/blender/nodes/geometry/nodes/node_geo_uv_pack_islands.cc b/source/blender/nodes/geometry/nodes/node_geo_uv_pack_islands.cc new file mode 100644 index 00000000000..feff6efc3f8 --- /dev/null +++ b/source/blender/nodes/geometry/nodes/node_geo_uv_pack_islands.cc @@ -0,0 +1,152 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "GEO_uv_parametrizer.h" + +#include "DNA_mesh_types.h" +#include "DNA_meshdata_types.h" + +#include "node_geometry_util.hh" + +namespace blender::nodes::node_geo_uv_pack_islands_cc { + +static void node_declare(NodeDeclarationBuilder &b) +{ + b.add_input(N_("UV")).hide_value().supports_field(); + b.add_input(N_("Selection")) + .default_value(true) + .hide_value() + .supports_field() + .description(N_("Faces to consider when packing islands")); + b.add_input(N_("Margin")) + .default_value(0.001f) + .min(0.0f) + .max(1.0f) + .description(N_("Space between islands")); + b.add_input(N_("Rotate")) + .default_value(true) + .description(N_("Rotate islands for best fit")); + b.add_output(N_("UV")).field_source(); +} + +static VArray construct_uv_gvarray(const MeshComponent &component, + const Field selection_field, + const Field uv_field, + const bool rotate, + const float margin, + const eAttrDomain domain) +{ + const Mesh *mesh = component.get_for_read(); + if (mesh == nullptr) { + return {}; + } + + const int face_num = component.attribute_domain_num(ATTR_DOMAIN_FACE); + GeometryComponentFieldContext face_context{component, ATTR_DOMAIN_FACE}; + FieldEvaluator face_evaluator{face_context, face_num}; + face_evaluator.add(selection_field); + face_evaluator.evaluate(); + const IndexMask selection = face_evaluator.get_evaluated_as_mask(0); + if (selection.is_empty()) { + return {}; + } + + const int corner_num = component.attribute_domain_num(ATTR_DOMAIN_CORNER); + GeometryComponentFieldContext corner_context{component, ATTR_DOMAIN_CORNER}; + FieldEvaluator evaluator{corner_context, corner_num}; + Array uv(corner_num); + evaluator.add_with_destination(uv_field, uv.as_mutable_span()); + evaluator.evaluate(); + + ParamHandle *handle = GEO_uv_parametrizer_construct_begin(); + for (const int mp_index : selection) { + const MPoly &mp = mesh->mpoly[mp_index]; + Array mp_vkeys(mp.totloop); + Array mp_pin(mp.totloop); + Array mp_select(mp.totloop); + Array mp_co(mp.totloop); + Array mp_uv(mp.totloop); + for (const int i : IndexRange(mp.totloop)) { + const MLoop &ml = mesh->mloop[mp.loopstart + i]; + mp_vkeys[i] = ml.v; + mp_co[i] = mesh->mvert[ml.v].co; + mp_uv[i] = uv[mp.loopstart + i]; + mp_pin[i] = false; + mp_select[i] = false; + } + GEO_uv_parametrizer_face_add(handle, + mp_index, + mp.totloop, + mp_vkeys.data(), + mp_co.data(), + mp_uv.data(), + mp_pin.data(), + mp_select.data()); + } + GEO_uv_parametrizer_construct_end(handle, true, true, nullptr); + + GEO_uv_parametrizer_pack(handle, margin, rotate, true); + GEO_uv_parametrizer_flush(handle); + GEO_uv_parametrizer_delete(handle); + + return component.attribute_try_adapt_domain( + VArray::ForContainer(std::move(uv)), ATTR_DOMAIN_CORNER, domain); +} + +class PackIslandsFieldInput final : public GeometryFieldInput { + private: + const Field selection_field; + const Field uv_field; + const bool rotate; + const float margin; + + public: + PackIslandsFieldInput(const Field selection_field, + const Field uv_field, + const bool rotate, + const float margin) + : GeometryFieldInput(CPPType::get(), "Pack UV Islands Field"), + selection_field(selection_field), + uv_field(uv_field), + rotate(rotate), + margin(margin) + { + category_ = Category::Generated; + } + + GVArray get_varray_for_context(const GeometryComponent &component, + const eAttrDomain domain, + IndexMask UNUSED(mask)) const final + { + if (component.type() == GEO_COMPONENT_TYPE_MESH) { + const MeshComponent &mesh_component = static_cast(component); + return construct_uv_gvarray( + mesh_component, selection_field, uv_field, rotate, margin, domain); + } + return {}; + } +}; + +static void node_geo_exec(GeoNodeExecParams params) +{ + const Field selection_field = params.extract_input>("Selection"); + const Field uv_field = params.extract_input>("UV"); + const bool rotate = params.extract_input("Rotate"); + const float margin = params.extract_input("Margin"); + params.set_output("UV", + Field(std::make_shared( + selection_field, uv_field, rotate, margin))); +} + +} // namespace blender::nodes::node_geo_uv_pack_islands_cc + +void register_node_type_geo_uv_pack_islands() +{ + namespace file_ns = blender::nodes::node_geo_uv_pack_islands_cc; + + static bNodeType ntype; + + geo_node_type_base(&ntype, GEO_NODE_UV_PACK_ISLANDS, "Pack UV Islands", NODE_CLASS_CONVERTER); + ntype.declare = file_ns::node_declare; + ntype.geometry_node_execute = file_ns::node_geo_exec; + nodeRegisterType(&ntype); +} diff --git a/source/blender/nodes/geometry/nodes/node_geo_uv_unwrap.cc b/source/blender/nodes/geometry/nodes/node_geo_uv_unwrap.cc new file mode 100644 index 00000000000..bf960c5c809 --- /dev/null +++ b/source/blender/nodes/geometry/nodes/node_geo_uv_unwrap.cc @@ -0,0 +1,199 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "GEO_uv_parametrizer.h" + +#include "DNA_mesh_types.h" +#include "DNA_meshdata_types.h" + +#include "UI_interface.h" +#include "UI_resources.h" + +#include "node_geometry_util.hh" + +namespace blender::nodes::node_geo_uv_unwrap_cc { + +NODE_STORAGE_FUNCS(NodeGeometryUVUnwrap) + +static void node_declare(NodeDeclarationBuilder &b) +{ + b.add_input(N_("Selection")) + .default_value(true) + .hide_value() + .supports_field() + .description(N_("Faces to participate in the unwrap operation")); + b.add_input(N_("Seam")) + .hide_value() + .supports_field() + .description(N_("Edges to mark where the mesh is \"cut\" for the purposes of unwrapping")); + b.add_input(N_("Margin")) + .default_value(0.001f) + .min(0.0f) + .max(1.0f) + .description(N_("Space between islands")); + b.add_input(N_("Fill Holes")) + .default_value(true) + .description(N_("Virtually fill holes in mesh before unwrapping, to better avoid overlaps " + "and preserve symmetry")); + b.add_output(N_("UV")).field_source().description( + N_("UV coordinates between 0 and 1 for each face corner in the selected faces")); +} + +static void node_layout(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr) +{ + uiLayoutSetPropSep(layout, true); + uiLayoutSetPropDecorate(layout, false); + uiItemR(layout, ptr, "method", 0, "", ICON_NONE); +} + +static void node_init(bNodeTree *UNUSED(tree), bNode *node) +{ + NodeGeometryUVUnwrap *data = MEM_cnew(__func__); + data->method = GEO_NODE_UV_UNWRAP_METHOD_ANGLE_BASED; + node->storage = data; +} + +static VArray construct_uv_gvarray(const MeshComponent &component, + const Field selection_field, + const Field seam_field, + const bool fill_holes, + const float margin, + const GeometryNodeUVUnwrapMethod method, + const eAttrDomain domain) +{ + const Mesh *mesh = component.get_for_read(); + if (mesh == nullptr) { + return {}; + } + + const int face_num = component.attribute_domain_num(ATTR_DOMAIN_FACE); + GeometryComponentFieldContext face_context{component, ATTR_DOMAIN_FACE}; + FieldEvaluator face_evaluator{face_context, face_num}; + face_evaluator.add(selection_field); + face_evaluator.evaluate(); + const IndexMask selection = face_evaluator.get_evaluated_as_mask(0); + if (selection.is_empty()) { + return {}; + } + + const int edge_num = component.attribute_domain_num(ATTR_DOMAIN_EDGE); + GeometryComponentFieldContext edge_context{component, ATTR_DOMAIN_EDGE}; + FieldEvaluator edge_evaluator{edge_context, edge_num}; + edge_evaluator.add(seam_field); + edge_evaluator.evaluate(); + const IndexMask seam = edge_evaluator.get_evaluated_as_mask(0); + + Array uv(mesh->totloop); + + ParamHandle *handle = GEO_uv_parametrizer_construct_begin(); + for (const int mp_index : selection) { + const MPoly &mp = mesh->mpoly[mp_index]; + Array mp_vkeys(mp.totloop); + Array mp_pin(mp.totloop); + Array mp_select(mp.totloop); + Array mp_co(mp.totloop); + Array mp_uv(mp.totloop); + for (const int i : IndexRange(mp.totloop)) { + const MLoop &ml = mesh->mloop[mp.loopstart + i]; + mp_vkeys[i] = ml.v; + mp_co[i] = mesh->mvert[ml.v].co; + mp_uv[i] = uv[mp.loopstart + i]; + mp_pin[i] = false; + mp_select[i] = false; + } + GEO_uv_parametrizer_face_add(handle, + mp_index, + mp.totloop, + mp_vkeys.data(), + mp_co.data(), + mp_uv.data(), + mp_pin.data(), + mp_select.data()); + } + for (const int i : seam) { + const MEdge &edge = mesh->medge[i]; + ParamKey vkeys[2]{edge.v1, edge.v2}; + GEO_uv_parametrizer_edge_set_seam(handle, vkeys); + } + /* TODO: once field input nodes are able to emit warnings (T94039), emit a + * warning if we fail to solve an island. */ + GEO_uv_parametrizer_construct_end(handle, fill_holes, false, nullptr); + + GEO_uv_parametrizer_lscm_begin(handle, false, method == GEO_NODE_UV_UNWRAP_METHOD_ANGLE_BASED); + GEO_uv_parametrizer_lscm_solve(handle, nullptr, nullptr); + GEO_uv_parametrizer_lscm_end(handle); + GEO_uv_parametrizer_average(handle, true); + GEO_uv_parametrizer_pack(handle, margin, true, true); + GEO_uv_parametrizer_flush(handle); + GEO_uv_parametrizer_delete(handle); + + return component.attribute_try_adapt_domain( + VArray::ForContainer(std::move(uv)), ATTR_DOMAIN_CORNER, domain); +} + +class UnwrapFieldInput final : public GeometryFieldInput { + private: + const Field selection; + const Field seam; + const bool fill_holes; + const float margin; + const GeometryNodeUVUnwrapMethod method; + + public: + UnwrapFieldInput(const Field selection, + const Field seam, + const bool fill_holes, + const float margin, + const GeometryNodeUVUnwrapMethod method) + : GeometryFieldInput(CPPType::get(), "UV Unwrap Field"), + selection(selection), + seam(seam), + fill_holes(fill_holes), + margin(margin), + method(method) + { + category_ = Category::Generated; + } + + GVArray get_varray_for_context(const GeometryComponent &component, + const eAttrDomain domain, + IndexMask UNUSED(mask)) const final + { + if (component.type() == GEO_COMPONENT_TYPE_MESH) { + const MeshComponent &mesh_component = static_cast(component); + return construct_uv_gvarray( + mesh_component, selection, seam, fill_holes, margin, method, domain); + } + return {}; + } +}; + +static void node_geo_exec(GeoNodeExecParams params) +{ + const NodeGeometryUVUnwrap &storage = node_storage(params.node()); + const GeometryNodeUVUnwrapMethod method = (GeometryNodeUVUnwrapMethod)storage.method; + const Field selection_field = params.extract_input>("Selection"); + const Field seam_field = params.extract_input>("Seam"); + const bool fill_holes = params.extract_input("Fill Holes"); + const float margin = params.extract_input("Margin"); + params.set_output("UV", + Field(std::make_shared( + selection_field, seam_field, fill_holes, margin, method))); +} + +} // namespace blender::nodes::node_geo_uv_unwrap_cc + +void register_node_type_geo_uv_unwrap() +{ + namespace file_ns = blender::nodes::node_geo_uv_unwrap_cc; + + static bNodeType ntype; + + geo_node_type_base(&ntype, GEO_NODE_UV_UNWRAP, "UV Unwrap", NODE_CLASS_CONVERTER); + node_type_init(&ntype, file_ns::node_init); + node_type_storage( + &ntype, "NodeGeometryUVUnwrap", node_free_standard_storage, node_copy_standard_storage); + ntype.declare = file_ns::node_declare; + ntype.geometry_node_execute = file_ns::node_geo_exec; + ntype.draw_buttons = file_ns::node_layout; + nodeRegisterType(&ntype); +} -- cgit v1.2.3