Blender V5.3
interface_ops_test.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include "BKE_action.hh"
6#include "BKE_anim_data.hh"
7#include "BKE_fcurve.hh"
8#include "BKE_gtest_base.hh"
9#include "BKE_idtype.hh"
10#include "BKE_lib_id.hh"
11#include "BKE_main.hh"
12#include "BKE_object.hh"
13
14#include "DNA_anim_types.h"
15
16#include "RNA_access.hh"
17#include "RNA_define.hh"
18#include "RNA_prototypes.hh"
19
20#include "BLI_listbase.hh"
21#include "BLI_string_utf8.hh"
22
23#include "ED_keyframing.hh"
24
25#include "ANIM_action.hh"
26#include "ANIM_animdata.hh"
27#include "ANIM_fcurve.hh"
28
29#include "interface_intern.hh"
30
31#include "testing/testing.h"
32
34
36 public:
38
41
45
49
50 void SetUp() override
51 {
53
56
57 cube_ptr = RNA_pointer_create_discrete(&cube->id, RNA_Object, &cube->id);
60
64
65 AnimData *adt_cube = BKE_animdata_ensure_id(&cube->id);
66 AnimData *adt_suzanne = BKE_animdata_ensure_id(&suzanne->id);
67
68 ReportList tmp_report_list;
69
70 /* Set up cube drivers. */
71 ANIM_add_driver(&tmp_report_list, &cube->id, "rotation_quaternion", 0, 0, DRIVER_TYPE_PYTHON);
72 ANIM_add_driver(&tmp_report_list, &cube->id, "rotation_quaternion", 1, 0, DRIVER_TYPE_PYTHON);
73 FCurve *cube_quat_0_driver = static_cast<FCurve *>(BLI_findlink(&adt_cube->drivers, 0));
74 FCurve *cube_quat_1_driver = static_cast<FCurve *>(BLI_findlink(&adt_cube->drivers, 1));
75 STRNCPY_UTF8(cube_quat_0_driver->driver->expression, "0.0");
76 STRNCPY_UTF8(cube_quat_1_driver->driver->expression, "1.0");
77
78 /* Set up suzanne drivers. */
80 &tmp_report_list, &suzanne->id, "rotation_quaternion", 0, 0, DRIVER_TYPE_PYTHON);
82 &tmp_report_list, &suzanne->id, "rotation_quaternion", 2, 0, DRIVER_TYPE_PYTHON);
84 &tmp_report_list, &suzanne->id, "rotation_quaternion", 3, 0, DRIVER_TYPE_PYTHON);
85 ANIM_add_driver(&tmp_report_list, &suzanne->id, "rotation_mode", 0, 0, DRIVER_TYPE_PYTHON);
86 FCurve *suzanne_quat_0_driver = static_cast<FCurve *>(BLI_findlink(&adt_suzanne->drivers, 0));
87 FCurve *suzanne_quat_2_driver = static_cast<FCurve *>(BLI_findlink(&adt_suzanne->drivers, 1));
88 FCurve *suzanne_quat_3_driver = static_cast<FCurve *>(BLI_findlink(&adt_suzanne->drivers, 2));
89 FCurve *suzanne_rotation_mode_driver = static_cast<FCurve *>(
90 BLI_findlink(&adt_suzanne->drivers, 3));
91 STRNCPY_UTF8(suzanne_quat_0_driver->driver->expression, "0.5");
92 STRNCPY_UTF8(suzanne_quat_2_driver->driver->expression, "2.5");
93 STRNCPY_UTF8(suzanne_quat_3_driver->driver->expression, "3.5");
94 STRNCPY_UTF8(suzanne_rotation_mode_driver->driver->expression, "4");
95
96 /* Add animation to cube's fourth quaternion element. */
100 bmain, act, &cube_ptr, {"rotation_quaternion", 3});
102 insert_vert_fcurve(fcu, {1.0, 1.0}, keyframe_settings, INSERTKEY_NOFLAGS);
103 }
104
105 void TearDown() override
106 {
108 RNA_exit();
109 }
110};
111
112TEST_F(CopyDriversToSelected, get_property_drivers)
113{
114 /* Cube quaternion: get all drivers. */
115 {
116 bool is_array_prop;
118 &cube_ptr, cube_quaternion_prop, true, -1, &is_array_prop);
119
120 EXPECT_EQ(is_array_prop, true);
121 EXPECT_EQ(drivers.size(), 4);
122
123 EXPECT_NE(drivers[0], nullptr);
124 EXPECT_NE(drivers[1], nullptr);
125 EXPECT_EQ(drivers[2], nullptr);
126 EXPECT_EQ(drivers[3], nullptr);
127
128 EXPECT_STREQ(drivers[0]->driver->expression, "0.0");
129 EXPECT_STREQ(drivers[1]->driver->expression, "1.0");
130 }
131
132 /* Cube quaternion: get first element driver. */
133 {
134 bool is_array_prop;
136 &cube_ptr, cube_quaternion_prop, false, 0, &is_array_prop);
137
138 EXPECT_EQ(is_array_prop, true);
139 EXPECT_EQ(drivers.size(), 4);
140
141 EXPECT_NE(drivers[0], nullptr);
142 EXPECT_EQ(drivers[1], nullptr);
143 EXPECT_EQ(drivers[2], nullptr);
144 EXPECT_EQ(drivers[3], nullptr);
145
146 EXPECT_STREQ(drivers[0]->driver->expression, "0.0");
147 }
148
149 /* Cube quaternion: try to get fourth element driver. Since there is none, we
150 * should get back an empty vector, indicating that no drivers were found. */
151 {
152 bool is_array_prop;
154 &cube_ptr, cube_quaternion_prop, false, 3, &is_array_prop);
155
156 EXPECT_EQ(drivers.size(), 0);
157 }
158
159 /* Cube rotation mode: get driver. Since there is none, we should get back an
160 * empty vector, indicating that no drivers were found. */
161 {
162 bool is_array_prop;
164 &cube_ptr, cube_rotation_mode_prop, false, 0, &is_array_prop);
165
166 EXPECT_EQ(drivers.size(), 0);
167 }
168
169 /* Suzanne quaternion: get all drivers. */
170 {
171 bool is_array_prop;
173 &suzanne_ptr, suzanne_quaternion_prop, true, -1, &is_array_prop);
174
175 EXPECT_EQ(is_array_prop, true);
176 EXPECT_EQ(drivers.size(), 4);
177
178 EXPECT_NE(drivers[0], nullptr);
179 EXPECT_EQ(drivers[1], nullptr);
180 EXPECT_NE(drivers[2], nullptr);
181 EXPECT_NE(drivers[3], nullptr);
182
183 EXPECT_STREQ(drivers[0]->driver->expression, "0.5");
184 EXPECT_STREQ(drivers[2]->driver->expression, "2.5");
185 EXPECT_STREQ(drivers[3]->driver->expression, "3.5");
186 }
187
188 /* Suzanne quaternion: get first element driver. */
189 {
190 bool is_array_prop;
192 &suzanne_ptr, suzanne_quaternion_prop, false, 0, &is_array_prop);
193
194 EXPECT_EQ(is_array_prop, true);
195 EXPECT_EQ(drivers.size(), 4);
196
197 EXPECT_NE(drivers[0], nullptr);
198 EXPECT_EQ(drivers[1], nullptr);
199 EXPECT_EQ(drivers[2], nullptr);
200 EXPECT_EQ(drivers[3], nullptr);
201
202 EXPECT_STREQ(drivers[0]->driver->expression, "0.5");
203 }
204
205 /* Suzanne quaternion: get second element driver. Since there is none, we
206 * should get back an empty vector, indicating that no drivers were found. */
207 {
208 bool is_array_prop;
210 &suzanne_ptr, suzanne_quaternion_prop, false, 1, &is_array_prop);
211
212 EXPECT_EQ(drivers.size(), 0);
213 }
214
215 /* Suzanne rotation mode: get driver. */
216 {
217 bool is_array_prop;
219 &suzanne_ptr, suzanne_rotation_mode_prop, false, 0, &is_array_prop);
220
221 EXPECT_EQ(is_array_prop, false);
222 EXPECT_EQ(drivers.size(), 1);
223 EXPECT_STREQ(drivers[0]->driver->expression, "4");
224 }
225}
226
227TEST_F(CopyDriversToSelected, paste_property_drivers)
228{
229 /* Copy all quaternion channel drivers from Suzanne to Cube. The result on
230 * Cube should be the following:
231 *
232 * - [0]: overwritten by the driver from Suzanne.
233 * - [1]: Cube's driver remains, since there was no driver here on Suzanne.
234 * - [2]: Suzanne's driver is pasted. There was no driver on Cube before.
235 * - [3]: remains without a driver. Cube has animation on this channel,
236 * preventing driver pasting.
237 */
238 {
239 bool is_array_prop;
240 Vector<FCurve *> suzanne_location_drivers = internal::get_property_drivers(
241 &suzanne_ptr, suzanne_quaternion_prop, true, -1, &is_array_prop);
242
244 suzanne_location_drivers.as_span(), is_array_prop, &cube_ptr, cube_quaternion_prop);
245
246 Vector<FCurve *> cube_location_drivers = internal::get_property_drivers(
247 &cube_ptr, cube_quaternion_prop, true, -1, &is_array_prop);
248
249 EXPECT_NE(cube_location_drivers[0], nullptr);
250 EXPECT_NE(cube_location_drivers[1], nullptr);
251 EXPECT_NE(cube_location_drivers[2], nullptr);
252 EXPECT_EQ(cube_location_drivers[3], nullptr);
253
254 EXPECT_STREQ(cube_location_drivers[0]->driver->expression, "0.5");
255 EXPECT_STREQ(cube_location_drivers[1]->driver->expression, "1.0");
256 EXPECT_STREQ(cube_location_drivers[2]->driver->expression, "2.5");
257 }
258
259 /* Copy the rotation_mode driver from Suzanne to Cube. */
260 {
261 bool is_array_prop;
262 Vector<FCurve *> suzanne_rotation_mode_driver = internal::get_property_drivers(
263 &suzanne_ptr, suzanne_rotation_mode_prop, false, 0, &is_array_prop);
264
266 suzanne_rotation_mode_driver.as_span(), is_array_prop, &cube_ptr, cube_rotation_mode_prop);
267
268 Vector<FCurve *> cube_rotation_mode_drivers = internal::get_property_drivers(
269 &cube_ptr, cube_rotation_mode_prop, false, 0, &is_array_prop);
270
271 EXPECT_NE(cube_rotation_mode_drivers[0], nullptr);
272 EXPECT_STREQ(cube_rotation_mode_drivers[0]->driver->expression, "4");
273 }
274}
275
276} // namespace blender::ui::tests
Functions and classes to work with Actions.
Functions to work with AnimData.
Functions to modify FCurves.
Blender kernel action and pose functionality.
General operations, lookup, etc. for blender objects.
#define STRNCPY_UTF8(dst, src)
Span< T > as_span() const
#define EXPECT_NE(result, expect)
bAction * id_action_ensure(Main *bmain, ID *id)
Definition animdata.cc:195
FCurve * action_fcurve_ensure_ex(Main *bmain, bAction *act, PointerRNA *ptr, const FCurveDescriptor &fcurve_descriptor)
SingleKeyingResult insert_vert_fcurve(FCurve *fcu, const float2 position, const KeyframeSettings &settings, eInsertKeyFlags flag)
Main Key-framing API call.
int paste_property_drivers(Span< FCurve * > src_drivers, bool is_array_prop, PointerRNA *dst_ptr, PropertyRNA *dst_prop)
Vector< FCurve * > get_property_drivers(PointerRNA *ptr, PropertyRNA *prop, bool get_all, int index, bool *r_is_array_prop)
TEST_F(CopyDriversToSelected, get_property_drivers)
@ BEZT_KEYTYPE_KEYFRAME
int ANIM_add_driver(ReportList *reports, ID *id, const char rna_path[], int array_index, short flag, eDriver_Types type)
Main Driver Management API calls.
Definition drivers.cc:385
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
Main * BKE_main_new()
Definition main.cc:93
AnimData * BKE_animdata_ensure_id(ID *id)
Definition anim_data.cc:107
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:541
void RNA_exit()
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
void BKE_main_free(Main *bmain)
Definition main.cc:202
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
Object * BKE_object_add_only_object(Main *bmain, ObjectType type, const char *name) ATTR_RETURNS_NONNULL
Definition object.cc:2265
ListBaseT< FCurve > drivers
ChannelDriver * driver