Blender V5.3
node_fn_align_rotation_to_vector.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
7#include "BLI_math_vector.hh"
9
11#include "UI_resources.hh"
12
13#include "NOD_rna_define.hh"
14
15#include "node_function_util.hh"
16#include "node_shader_util.hh"
17
19
21{
22 b.use_custom_socket_order();
23 b.allow_any_socket_order();
24 b.add_default_layout();
25 b.is_function_node();
26 b.add_input<decl::Rotation>("Rotation"_ustr).hide_value();
27 b.add_output<decl::Rotation>("Rotation"_ustr).align_with_previous();
28 b.add_input<decl::Float>("Factor"_ustr)
29 .default_value(1.0f)
30 .min(0.0f)
31 .max(1.0f)
33 b.add_input<decl::Vector>("Vector"_ustr).default_value({0.0, 0.0, 1.0}).subtype(PROP_XYZ);
34}
35
36static void node_layout(ui::Layout &layout, bContext * /*C*/, PointerRNA *ptr)
37{
38 layout.prop(ptr, "axis", ui::ITEM_R_EXPAND, std::nullopt, ICON_NONE);
39 layout.use_property_split_set(true);
40 layout.use_property_decorate_set(false);
41 layout.prop(ptr, "pivot_axis", UI_ITEM_NONE, IFACE_("Pivot"), ICON_NONE);
42}
43
44static void node_init(bNodeTree * /*tree*/, bNode *node)
45{
46 node->custom1 = int16_t(math::Axis::Z);
47}
48
50 const VArray<math::Quaternion> &input_rotations,
51 const VArray<float3> &vectors,
52 const VArray<float> &factors,
53 const float3 local_main_axis,
54 MutableSpan<math::Quaternion> output_rotations)
55{
56 mask.foreach_index([&](const int64_t i) {
57 const math::Quaternion old_rotation = input_rotations[i];
58 const float3 vector = vectors[i];
59 if (math::is_zero(vector)) {
60 output_rotations[i] = old_rotation;
61 return;
62 }
63
64 const float3 old_axis = math::transform_point(old_rotation, local_main_axis);
65
66 const float3 new_axis = math::normalize(vector);
67 float3 rotation_axis = math::cross_high_precision(old_axis, new_axis);
68 if (math::is_zero(rotation_axis)) {
69 /* The vectors are linearly dependent, so we fall back to another axis. */
70 rotation_axis = math::cross_high_precision(old_axis, float3(1, 0, 0));
71 if (math::is_zero(rotation_axis)) {
72 /* This is now guaranteed to not be zero. */
73 rotation_axis = math::cross_high_precision(old_axis, float3(0, 1, 0));
74 }
75 }
76
77 const float full_angle = angle_normalized_v3v3(old_axis, new_axis);
78 const float angle = factors[i] * full_angle;
79
80 const math::AxisAngle axis_angle = math::AxisAngle(math::normalize(rotation_axis), angle);
81 output_rotations[i] = math::to_quaternion(axis_angle) * old_rotation;
82 });
83}
84
86 const VArray<math::Quaternion> &input_rotations,
87 const VArray<float3> &vectors,
88 const VArray<float> &factors,
89 const float3 local_main_axis,
90 const float3 local_pivot_axis,
91 MutableSpan<math::Quaternion> output_rotations)
92{
93 mask.foreach_index([&](const int64_t i) {
94 const math::Quaternion old_rotation = input_rotations[i];
95 if (local_main_axis == local_pivot_axis) {
96 /* Can't compute any meaningful rotation angle in this case. */
97 output_rotations[i] = old_rotation;
98 return;
99 }
100
101 const float3 vector = vectors[i];
102 if (math::is_zero(vector)) {
103 output_rotations[i] = old_rotation;
104 return;
105 }
106
107 const float3 old_axis = math::transform_point(old_rotation, local_main_axis);
108 const float3 pivot_axis = math::transform_point(old_rotation, local_pivot_axis);
109
110 float full_angle = angle_signed_on_axis_v3v3_v3(vector, old_axis, pivot_axis);
111 if (full_angle > M_PI) {
112 /* Make sure the point is rotated as little as possible. */
113 full_angle -= 2.0f * M_PI;
114 }
115 const float angle = factors[i] * full_angle;
116
117 const math::AxisAngle axis_angle = math::AxisAngle(math::normalize(pivot_axis), angle);
118 output_rotations[i] = math::to_quaternion(axis_angle) * old_rotation;
119 });
120}
121
122class AlignRotationToVectorFunction : public mf::MultiFunction {
123 math::Axis main_axis_mode_;
124 NodeAlignEulerToVectorPivotAxis pivot_axis_mode_;
125
126 public:
128 const NodeAlignEulerToVectorPivotAxis pivot_axis_mode)
129 : main_axis_mode_(main_axis_mode), pivot_axis_mode_(pivot_axis_mode)
130 {
131 static const mf::Signature signature = []() {
132 mf::Signature signature;
133 mf::SignatureBuilder builder{"Align Rotation to Vector", signature};
134 builder.single_input<math::Quaternion>("Rotation");
135 builder.single_input<float>("Factor");
136 builder.single_input<float3>("Vector");
137 builder.single_output<math::Quaternion>("Rotation");
138 return signature;
139 }();
140 this->set_signature(&signature);
141 }
142
143 void call(const IndexMask &mask, mf::Params params, mf::Context /*context*/) const final
144 {
145 const VArray input_rotations = params.readonly_single_input<math::Quaternion>(0, "Rotation");
146 const VArray<float> factors = params.readonly_single_input<float>(1, "Factor");
147 const VArray<float3> vectors = params.readonly_single_input<float3>(2, "Vector");
148
149 MutableSpan output_rotations = params.uninitialized_single_output<math::Quaternion>(
150 3, "Rotation");
151
152 float3 local_main_axis = {0.0f, 0.0f, 0.0f};
153 local_main_axis[main_axis_mode_.as_int()] = 1.0f;
154
155 if (pivot_axis_mode_ == FN_NODE_ALIGN_EULER_TO_VECTOR_PIVOT_AXIS_AUTO) {
157 mask, input_rotations, vectors, factors, local_main_axis, output_rotations);
158 }
159 else {
160 float3 local_pivot_axis = {0.0f, 0.0f, 0.0f};
161 local_pivot_axis[pivot_axis_mode_ - 1] = 1;
163 input_rotations,
164 vectors,
165 factors,
166 local_main_axis,
167 local_pivot_axis,
168 output_rotations);
169 }
170 }
171
173 {
174 ExecutionHints hints;
175 hints.min_grain_size = 512;
176 return hints;
177 }
178
179 void hash_unique(UniqueHashBytes &hash) const override
180 {
181 static constexpr int8_t id = 0;
182 hash.add(&id);
183 hash.add(main_axis_mode_);
184 hash.add(pivot_axis_mode_);
185 }
186};
187
194
196 bNode *node,
197 bNodeExecData * /*execdata*/,
200{
201 const math::Axis main_axis_mode = math::Axis::from_int(node->custom1);
203 node->custom2);
204
205 float3 local_main_axis = {0.0f, 0.0f, 0.0f};
206 local_main_axis[main_axis_mode.as_int()] = 1.0f;
207
208 if (pivot_axis_mode == FN_NODE_ALIGN_EULER_TO_VECTOR_PIVOT_AXIS_AUTO) {
209 return GPU_stack_link(
210 mat, node, "align_rotation_to_vector_auto_pivot", in, out, GPU_constant(local_main_axis));
211 }
212
213 float3 local_pivot_axis = {0.0f, 0.0f, 0.0f};
214 local_pivot_axis[pivot_axis_mode - 1] = 1.0f;
215 return GPU_stack_link(mat,
216 node,
217 "align_rotation_to_vector_fixed_pivot",
218 in,
219 out,
220 GPU_constant(local_main_axis),
221 GPU_constant(local_pivot_axis));
222}
223
224static void node_rna(StructRNA *srna)
225{
226 static const EnumPropertyItem axis_items[] = {
227 {int(math::Axis::X), "X", ICON_NONE, "X", "Align the X axis with the vector"},
228 {int(math::Axis::Y), "Y", ICON_NONE, "Y", "Align the Y axis with the vector"},
229 {int(math::Axis::Z), "Z", ICON_NONE, "Z", "Align the Z axis with the vector"},
230 {0, nullptr, 0, nullptr, nullptr},
231 };
232
234 "axis",
235 "Axis",
236 "Axis to align to the vector",
237 axis_items,
239 int(math::Axis::Z));
240
241 static const EnumPropertyItem pivot_axis_items[] = {
243 "AUTO",
244 ICON_NONE,
245 "Auto",
246 "Automatically detect the best rotation axis to rotate towards the vector"},
248 "X",
249 ICON_NONE,
250 "X",
251 "Rotate around the local X axis"},
253 "Y",
254 ICON_NONE,
255 "Y",
256 "Rotate around the local Y axis"},
258 "Z",
259 ICON_NONE,
260 "Z",
261 "Rotate around the local Z axis"},
262 {0, nullptr, 0, nullptr, nullptr},
263 };
264
266 "pivot_axis",
267 "Pivot Axis",
268 "Axis to rotate around",
269 pivot_axis_items,
271}
272
273static void node_register()
274{
275 static bke::bNodeType ntype;
276
278 &ntype, "FunctionNodeAlignRotationToVector"_ustr, FN_NODE_ALIGN_ROTATION_TO_VECTOR);
279 ntype.ui_name = "Align Rotation to Vector";
280 ntype.ui_description = "Orient a rotation along the given direction";
281 ntype.enum_name_legacy = "ALIGN_ROTATION_TO_VECTOR";
283 ntype.declare = node_declare;
284 ntype.initfunc = node_init;
289
290 node_rna(ntype.rna_ext.srna);
291}
293
294} // namespace blender::nodes::node_fn_align_rotation_to_vector_cc
#define NODE_CLASS_CONVERTER
Definition BKE_node.hh:484
#define FN_NODE_ALIGN_ROTATION_TO_VECTOR
#define final(a, b, c)
Definition BLI_hash_c.hh:21
#define M_PI
#define IFACE_(msgid)
#define NOD_REGISTER_NODE(REGISTER_FUNC)
#define NOD_inline_enum_accessors(member)
#define UI_ITEM_NONE
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
Definition btVector3.h:356
void set_signature(const Signature *signature)
constexpr int as_int() const
static constexpr Value Z
static constexpr Axis from_int(const int axis_int)
static constexpr Value X
static constexpr Value Y
void call(const IndexMask &mask, mf::Params params, mf::Context) const final
AlignRotationToVectorFunction(const math::Axis main_axis_mode, const NodeAlignEulerToVectorPivotAxis pivot_axis_mode)
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
QuaternionBase< float > Quaternion
QuaternionBase< T > to_quaternion(const AxisAngleBase< T, AngleT > &axis_angle)
VecBase< float, 3 > cross_high_precision(const VecBase< float, 3 > &a, const VecBase< float, 3 > &b)
AxisAngleBase< float, AngleRadianBase< float > > AxisAngle
bool is_zero(const T &a)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
VecBase< T, 3 > transform_point(const CartesianBasis &basis, const VecBase< T, 3 > &v)
static void node_layout(ui::Layout &layout, bContext *, PointerRNA *ptr)
static void align_rotations_auto_pivot(const IndexMask &mask, const VArray< math::Quaternion > &input_rotations, const VArray< float3 > &vectors, const VArray< float > &factors, const float3 local_main_axis, MutableSpan< math::Quaternion > output_rotations)
static int node_gpu_material(GPUMaterial *mat, bNode *node, bNodeExecData *, GPUNodeStack *in, GPUNodeStack *out)
static void align_rotations_fixed_pivot(const IndexMask &mask, const VArray< math::Quaternion > &input_rotations, const VArray< float3 > &vectors, const VArray< float > &factors, const float3 local_main_axis, const float3 local_pivot_axis, MutableSpan< math::Quaternion > output_rotations)
static void node_build_multi_function(NodeMultiFunctionBuilder &builder)
PropertyRNA * RNA_def_node_enum(StructRNA *srna, const char *identifier, const char *ui_name, const char *ui_description, const EnumPropertyItem *static_items, const EnumRNAAccessors accessors, std::optional< int > default_value, const EnumPropertyItemFunc item_func, const bool allow_animation)
bool GPU_stack_link(GPUMaterial *mat, const bNode *node, const char *name, GPUNodeStack *in, GPUNodeStack *out,...)
float angle_normalized_v3v3(const float v1[3], const float v2[3]) ATTR_WARN_UNUSED_RESULT
__int64 int64_t
Definition BKE_text.h:90
void fn_cmp_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
float angle_signed_on_axis_v3v3_v3(const float v1[3], const float v2[3], const float axis[3]) ATTR_WARN_UNUSED_RESULT
GPUNodeLink * GPU_constant(const float *num)
VecBase< float, 3 > float3
@ PROP_FACTOR
Definition RNA_types.hh:308
NodeAlignEulerToVectorPivotAxis
@ FN_NODE_ALIGN_EULER_TO_VECTOR_PIVOT_AXIS_Y
@ FN_NODE_ALIGN_EULER_TO_VECTOR_PIVOT_AXIS_Z
@ FN_NODE_ALIGN_EULER_TO_VECTOR_PIVOT_AXIS_X
@ FN_NODE_ALIGN_EULER_TO_VECTOR_PIVOT_AXIS_AUTO
signed char int8_t
Definition BKE_text.h:76
signed short int16_t
Definition BKE_text.h:77
#define hash
Definition noise_c.cc:156
Defines a node type.
Definition BKE_node.hh:265
void(*) draw_buttons(ui::Layout &, bContext *C, PointerRNA *ptr)
Definition BKE_node.hh:290
std::string ui_description
Definition BKE_node.hh:271
NodeGPUExecFunction gpu_fn
Definition BKE_node.hh:373
NodeMultiFunctionBuildFunction build_multi_function
Definition BKE_node.hh:382
void(*) initfunc(bNodeTree *ntree, bNode *node)
Definition BKE_node.hh:320
const char * enum_name_legacy
Definition BKE_node.hh:274
NodeDeclareFunction declare
Definition BKE_node.hh:393
void use_property_decorate_set(bool is_decorate)
void use_property_split_set(bool is_sep)
void prop(PointerRNA *ptr, PropertyRNA *prop, int index, int value, eUI_Item_Flag flag, std::optional< StringRef > name_opt, int icon, std::optional< StringRef > placeholder=std::nullopt)