24dc9a21b1
This adds support for attaching gizmos for input values. The goal is to make it easier for users to set input values intuitively in the 3D viewport. We went through multiple different possible designs until we settled on the one implemented here. We picked it for it's flexibility and ease of use when using geometry node assets. The core principle in the design is that **gizmos are attached to existing input values instead of being the input value themselves**. This actually fits the existing concept of gizmos in Blender well, but may be a bit unintutitive in a node setup at first. The attachment is done using links in the node editor. The most basic usage of the node is to link a Value node to the new Linear Gizmo node. This attaches the gizmo to the input value and allows you to change it from the 3D view. The attachment is indicated by the gizmo icon in the sockets which are controlled by a gizmo as well as the back-link (notice the double link) when the gizmo is active. The core principle makes it straight forward to control the same node setup from the 3D view with gizmos, or by manually changing input values, or by driving the input values procedurally. If the input value is controlled indirectly by other inputs, it's often possible to **automatically propagate** the gizmo to the actual input. Backpropagation does not work for all nodes, although more nodes can be supported over time. This patch adds the first three gizmo nodes which cover common use cases: * **Linear Gizmo**: Creates a gizmo that controls a float or integer value using a linear movement of e.g. an arrow in the 3D viewport. * **Dial Gizmo**: Creates a circular gizmo in the 3D viewport that can be rotated to change the attached angle input. * **Transform Gizmo**: Creates a simple gizmo for location, rotation and scale. In the future, more built-in gizmos and potentially the ability for custom gizmos could be added. All gizmo nodes have a **Transform** geometry output. Using it is optional but it is recommended when the gizmo is used to control inputs that affect a geometry. When it is used, Blender will automatically transform the gizmos together with the geometry that they control. To achieve this, the output should be merged with the generated geometry using the *Join Geometry* node. The data contained in *Transform* output is not visible geometry, but just internal information that helps Blender to give a better user experience when using gizmos. The gizmo nodes have a multi-input socket. This allows **controlling multiple values** with the same gizmo. Only a small set of **gizmo shapes** is supported initially. It might be extended in the future but one goal is to give the gizmos used by different node group assets a familiar look and feel. A similar constraint exists for **colors**. Currently, one can choose from a fixed set of colors which can be modified in the theme settings. The set of **visible gizmos** is determined by a multiple factors because it's not really feasible to show all possible gizmos at all times. To see any of the geometry nodes gizmos, the "Active Modifier" option has to be enabled in the "Viewport Gizmos" popover. Then all gizmos are drawn for which at least one of the following is true: * The gizmo controls an input of the active modifier of the active object. * The gizmo controls a value in a selected node in an open node editor. * The gizmo controls a pinned value in an open node editor. Pinning works by clicking the gizmo icon next to the value. Pull Request: https://projects.blender.org/blender/blender/pulls/112677
136 lines
4.8 KiB
C++
136 lines
4.8 KiB
C++
/* SPDX-FileCopyrightText: 2023 Blender Authors
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0-or-later */
|
|
|
|
#include "BKE_curves.hh"
|
|
#include "BKE_geometry_nodes_gizmos_transforms.hh"
|
|
#include "BKE_geometry_set.hh"
|
|
#include "BKE_grease_pencil.hh"
|
|
|
|
namespace blender::bke {
|
|
|
|
GeometryComponentEditData::GeometryComponentEditData() : GeometryComponent(Type::Edit) {}
|
|
|
|
GeometryComponentPtr GeometryComponentEditData::copy() const
|
|
{
|
|
GeometryComponentEditData *new_component = new GeometryComponentEditData();
|
|
if (gizmo_edit_hints_) {
|
|
new_component->gizmo_edit_hints_ = std::make_unique<GizmoEditHints>(*gizmo_edit_hints_);
|
|
}
|
|
if (curves_edit_hints_) {
|
|
new_component->curves_edit_hints_ = std::make_unique<CurvesEditHints>(*curves_edit_hints_);
|
|
}
|
|
if (grease_pencil_edit_hints_) {
|
|
new_component->grease_pencil_edit_hints_ = std::make_unique<GreasePencilEditHints>(
|
|
*grease_pencil_edit_hints_);
|
|
}
|
|
return GeometryComponentPtr(new_component);
|
|
}
|
|
|
|
bool GeometryComponentEditData::owns_direct_data() const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
void GeometryComponentEditData::ensure_owns_direct_data()
|
|
{
|
|
/* Nothing to do. */
|
|
}
|
|
|
|
void GeometryComponentEditData::clear()
|
|
{
|
|
BLI_assert(this->is_mutable() || this->is_expired());
|
|
curves_edit_hints_.reset();
|
|
grease_pencil_edit_hints_.reset();
|
|
gizmo_edit_hints_.reset();
|
|
}
|
|
|
|
static ImplicitSharingPtrAndData save_shared_attribute(const GAttributeReader &attribute)
|
|
{
|
|
if (attribute.sharing_info && attribute.varray.is_span()) {
|
|
const void *data = attribute.varray.get_internal_span().data();
|
|
attribute.sharing_info->add_user();
|
|
return {ImplicitSharingPtr(attribute.sharing_info), data};
|
|
}
|
|
auto *data = new ImplicitSharedValue<GArray<>>(attribute.varray.type(), attribute.varray.size());
|
|
attribute.varray.materialize(data->data.data());
|
|
return {ImplicitSharingPtr<ImplicitSharingInfo>(data), data->data.data()};
|
|
}
|
|
|
|
static void remember_deformed_curve_positions_if_necessary(
|
|
const Curves *curves_id, GeometryComponentEditData &edit_component)
|
|
{
|
|
if (!edit_component.curves_edit_hints_) {
|
|
return;
|
|
}
|
|
if (curves_id == nullptr) {
|
|
return;
|
|
}
|
|
CurvesEditHints &edit_hints = *edit_component.curves_edit_hints_;
|
|
if (edit_hints.positions().has_value()) {
|
|
return;
|
|
}
|
|
const CurvesGeometry &curves = curves_id->geometry.wrap();
|
|
const int points_num = curves.points_num();
|
|
if (points_num != edit_hints.curves_id_orig.geometry.point_num) {
|
|
return;
|
|
}
|
|
edit_hints.positions_data = save_shared_attribute(curves.attributes().lookup("position"));
|
|
}
|
|
|
|
static void remember_deformed_grease_pencil_if_necessary(const GreasePencil *grease_pencil,
|
|
GeometryComponentEditData &edit_component)
|
|
{
|
|
if (!edit_component.grease_pencil_edit_hints_) {
|
|
return;
|
|
}
|
|
if (edit_component.grease_pencil_edit_hints_->drawing_hints.has_value()) {
|
|
return;
|
|
}
|
|
if (grease_pencil == nullptr) {
|
|
return;
|
|
}
|
|
const GreasePencil &orig_grease_pencil =
|
|
edit_component.grease_pencil_edit_hints_->grease_pencil_id_orig;
|
|
const Span<const greasepencil::Layer *> layers = grease_pencil->layers();
|
|
const Span<const greasepencil::Layer *> orig_layers = orig_grease_pencil.layers();
|
|
const int layers_num = layers.size();
|
|
if (layers_num != orig_layers.size()) {
|
|
return;
|
|
}
|
|
edit_component.grease_pencil_edit_hints_->drawing_hints.emplace(layers_num);
|
|
MutableSpan<GreasePencilDrawingEditHints> all_hints =
|
|
*edit_component.grease_pencil_edit_hints_->drawing_hints;
|
|
for (const int layer_index : layers.index_range()) {
|
|
const greasepencil::Drawing *drawing = grease_pencil->get_eval_drawing(
|
|
*grease_pencil->layer(layer_index));
|
|
const greasepencil::Layer &orig_layer = *orig_layers[layer_index];
|
|
const greasepencil::Drawing *orig_drawing = orig_grease_pencil.get_drawing_at(
|
|
orig_layer, grease_pencil->runtime->eval_frame);
|
|
GreasePencilDrawingEditHints &drawing_hints = all_hints[layer_index];
|
|
if (!drawing || !orig_drawing) {
|
|
continue;
|
|
}
|
|
drawing_hints.drawing_orig = orig_drawing;
|
|
const CurvesGeometry &curves = drawing->strokes();
|
|
if (curves.points_num() != orig_drawing->strokes().points_num()) {
|
|
continue;
|
|
}
|
|
drawing_hints.positions_data = save_shared_attribute(curves.attributes().lookup("position"));
|
|
}
|
|
}
|
|
|
|
void GeometryComponentEditData::remember_deformed_positions_if_necessary(GeometrySet &geometry)
|
|
{
|
|
/* This component should be created at the start of object evaluation if it's necessary. */
|
|
if (!geometry.has<GeometryComponentEditData>()) {
|
|
return;
|
|
}
|
|
GeometryComponentEditData &edit_component =
|
|
geometry.get_component_for_write<GeometryComponentEditData>();
|
|
remember_deformed_curve_positions_if_necessary(geometry.get_curves(), edit_component);
|
|
remember_deformed_grease_pencil_if_necessary(geometry.get_grease_pencil(), edit_component);
|
|
}
|
|
|
|
} // namespace blender::bke
|