Orientation for 3D cursor
[blender.git] / source / blender / editors / object / object_warp.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2013 by Blender Foundation
19  * All rights reserved.
20  *
21  * ***** END GPL LICENSE BLOCK *****
22  */
23
24 /** \file blender/editors/object/object_warp.c
25  *  \ingroup edobj
26  */
27
28 #include "DNA_object_types.h"
29 #include "DNA_scene_types.h"
30 #include "DNA_view3d_types.h"
31
32 #include "BLI_math.h"
33
34 #include "BKE_context.h"
35
36 #include "RNA_access.h"
37 #include "RNA_define.h"
38
39 #include "WM_api.h"
40 #include "WM_types.h"
41
42 #include "ED_view3d.h"
43 #include "ED_transverts.h"
44
45 #include "object_intern.h"
46
47
48 static void object_warp_calc_view_matrix(float r_mat_view[4][4], float r_center_view[3],
49                                          Object *obedit, float viewmat[4][4], const float center[3],
50                                          const float offset_angle)
51 {
52         float mat_offset[4][4];
53         float viewmat_roll[4][4];
54
55         /* apply the rotation offset by rolling the view */
56         axis_angle_to_mat4_single(mat_offset, 'Z', offset_angle);
57         mul_m4_m4m4(viewmat_roll, mat_offset, viewmat);
58
59         /* apply the view and the object matrix */
60         mul_m4_m4m4(r_mat_view, viewmat_roll, obedit->obmat);
61
62         /* get the view-space cursor */
63         mul_v3_m4v3(r_center_view, viewmat_roll, center);
64 }
65
66
67 static void object_warp_transverts_minmax_x(TransVertStore *tvs,
68                                             float mat_view[4][4], const float center_view[3],
69                                             float *r_min, float *r_max)
70 {
71         /* no need to apply translation and cursor offset for every vertex, delay this */
72         const float x_ofs = (mat_view[3][0] - center_view[0]);
73         float min = FLT_MAX, max = -FLT_MAX;
74
75         TransVert *tv;
76         int i;
77
78
79         tv = tvs->transverts;
80         for (i = 0; i < tvs->transverts_tot; i++, tv++) {
81                 float val;
82
83                 /* convert objectspace->viewspace */
84                 val = dot_m4_v3_row_x(mat_view, tv->loc);
85
86                 min = min_ff(min, val);
87                 max = max_ff(max, val);
88         }
89
90         *r_min = min + x_ofs;
91         *r_max = max + x_ofs;
92 }
93
94
95 static void object_warp_transverts(TransVertStore *tvs,
96                                    float mat_view[4][4], const float center_view[3],
97                                    const float angle_, const float min, const float max)
98 {
99         TransVert *tv;
100         int i;
101         const float angle = -angle_;
102         /* cache vars for tiny speedup */
103 #if 1
104         const float range = max - min;
105         const float range_inv = 1.0f / range;
106         const float min_ofs = min + (0.5f * range);
107 #endif
108
109         float dir_min[2], dir_max[2];
110         float imat_view[4][4];
111
112
113         invert_m4_m4(imat_view, mat_view);
114
115         /* calculate the direction vectors outside min/max range */
116         {
117                 const float phi = angle * 0.5f;
118
119                 dir_max[0] = cosf(phi);
120                 dir_max[1] = sinf(phi);
121
122                 dir_min[0] = -dir_max[0];
123                 dir_min[1] =  dir_max[1];
124         }
125
126
127         tv = tvs->transverts;
128         for (i = 0; i < tvs->transverts_tot; i++, tv++) {
129                 float co[3], co_add[2];
130                 float val, phi;
131
132                 /* convert objectspace->viewspace */
133                 mul_v3_m4v3(co, mat_view, tv->loc);
134                 sub_v2_v2(co, center_view);
135
136                 val = co[0];
137                 /* is overwritten later anyway */
138                 // co[0] = 0.0f;
139
140                 if (val < min) {
141                         mul_v2_v2fl(co_add, dir_min, min - val);
142                         val = min;
143                 }
144                 else if (val > max) {
145                         mul_v2_v2fl(co_add, dir_max, val - max);
146                         val = max;
147                 }
148                 else {
149                         zero_v2(co_add);
150                 }
151
152                 /* map from x axis to (-0.5 - 0.5) */
153 #if 0
154                 val = ((val - min) / (max - min)) - 0.5f;
155 #else
156                 val = (val - min_ofs) * range_inv;
157 #endif
158
159                 /* convert the x axis into a rotation */
160                 phi = val * angle;
161
162                 co[0] = -sinf(phi) * co[1];
163                 co[1] =  cosf(phi) * co[1];
164
165                 add_v2_v2(co, co_add);
166
167                 /* convert viewspace->objectspace */
168                 add_v2_v2(co, center_view);
169                 mul_v3_m4v3(tv->loc, imat_view, co);
170         }
171 }
172
173 static int object_warp_verts_exec(bContext *C, wmOperator *op)
174 {
175         const float warp_angle = RNA_float_get(op->ptr, "warp_angle");
176         const float offset_angle = RNA_float_get(op->ptr, "offset_angle");
177
178         TransVertStore tvs = {NULL};
179         Object *obedit = CTX_data_edit_object(C);
180
181         /* typically from 'rv3d' and 3d cursor */
182         float viewmat[4][4];
183         float center[3];
184
185         /* 'viewmat' relative vars */
186         float mat_view[4][4];
187         float center_view[3];
188
189         float min, max;
190
191
192         ED_transverts_create_from_obedit(&tvs, obedit, TM_ALL_JOINTS | TM_SKIP_HANDLES);
193         if (tvs.transverts == NULL) {
194                 return OPERATOR_CANCELLED;
195         }
196
197
198         /* get viewmatrix */
199         {
200                 PropertyRNA *prop_viewmat = RNA_struct_find_property(op->ptr, "viewmat");
201                 if (RNA_property_is_set(op->ptr, prop_viewmat)) {
202                         RNA_property_float_get_array(op->ptr, prop_viewmat, (float *)viewmat);
203                 }
204                 else {
205                         RegionView3D *rv3d = CTX_wm_region_view3d(C);
206
207                         if (rv3d) {
208                                 copy_m4_m4(viewmat, rv3d->viewmat);
209                         }
210                         else {
211                                 unit_m4(viewmat);
212                         }
213
214                         RNA_property_float_set_array(op->ptr, prop_viewmat, (float *)viewmat);
215                 }
216         }
217
218
219         /* get center */
220         {
221                 PropertyRNA *prop_center = RNA_struct_find_property(op->ptr, "center");
222                 if (RNA_property_is_set(op->ptr, prop_center)) {
223                         RNA_property_float_get_array(op->ptr, prop_center, center);
224                 }
225                 else {
226                         Scene *scene = CTX_data_scene(C);
227                         View3D *v3d = CTX_wm_view3d(C);
228                         const float *cursor;
229
230                         cursor = ED_view3d_cursor3d_get(scene, v3d)->location;
231                         copy_v3_v3(center, cursor);
232
233                         RNA_property_float_set_array(op->ptr, prop_center, center);
234                 }
235         }
236
237
238         object_warp_calc_view_matrix(mat_view, center_view, obedit, viewmat, center, offset_angle);
239
240
241         /* get minmax */
242         {
243                 PropertyRNA *prop_min = RNA_struct_find_property(op->ptr, "min");
244                 PropertyRNA *prop_max = RNA_struct_find_property(op->ptr, "max");
245
246                 if (RNA_property_is_set(op->ptr, prop_min) ||
247                     RNA_property_is_set(op->ptr, prop_max))
248                 {
249                         min = RNA_property_float_get(op->ptr, prop_min);
250                         max = RNA_property_float_get(op->ptr, prop_max);
251                 }
252                 else {
253                         /* handy to set the bounds of the mesh */
254                         object_warp_transverts_minmax_x(&tvs, mat_view, center_view, &min, &max);
255
256                         RNA_property_float_set(op->ptr, prop_min, min);
257                         RNA_property_float_set(op->ptr, prop_max, max);
258                 }
259
260                 if (min > max) {
261                         SWAP(float, min, max);
262                 }
263         }
264
265         if (min != max) {
266                 object_warp_transverts(&tvs, mat_view, center_view, warp_angle, min, max);
267         }
268
269         ED_transverts_update_obedit(&tvs, obedit);
270         ED_transverts_free(&tvs);
271
272         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, obedit);
273
274         return OPERATOR_FINISHED;
275 }
276
277 void TRANSFORM_OT_vertex_warp(struct wmOperatorType *ot)
278 {
279         PropertyRNA *prop;
280
281         /* identifiers */
282         ot->name = "Warp";
283         ot->description = "Warp vertices around the cursor";
284         ot->idname = "TRANSFORM_OT_vertex_warp";
285
286         /* api callbacks */
287         ot->exec = object_warp_verts_exec;
288         ot->poll = ED_transverts_poll;
289
290         /* flags */
291         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
292
293         /* props */
294         prop = RNA_def_float(ot->srna, "warp_angle", DEG2RADF(360.0f), -FLT_MAX, FLT_MAX, "Warp Angle",
295                              "Amount to warp about the cursor", DEG2RADF(-360.0f), DEG2RADF(360.0f));
296         RNA_def_property_subtype(prop, PROP_ANGLE);
297
298         prop = RNA_def_float(ot->srna, "offset_angle", DEG2RADF(0.0f), -FLT_MAX, FLT_MAX, "Offset Angle",
299                              "Angle to use as the basis for warping", DEG2RADF(-360.0f), DEG2RADF(360.0f));
300         RNA_def_property_subtype(prop, PROP_ANGLE);
301
302         prop = RNA_def_float(ot->srna, "min", -1.0f, -FLT_MAX, FLT_MAX, "Min", "", -100.0, 100.0);
303         prop = RNA_def_float(ot->srna, "max",  1.0f, -FLT_MAX, FLT_MAX, "Max", "", -100.0, 100.0);
304
305         /* hidden props */
306         prop = RNA_def_float_matrix(ot->srna, "viewmat", 4, 4, NULL, 0.0f, 0.0f, "Matrix", "", 0.0f, 0.0f);
307         RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
308
309         prop = RNA_def_float_vector_xyz(ot->srna, "center", 3, NULL, -FLT_MAX, FLT_MAX, "Center", "", -FLT_MAX, FLT_MAX);
310         RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
311 }