Get rid of BKE_key_make_local().
[blender.git] / source / blender / blenkernel / intern / lattice.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) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/blenkernel/intern/lattice.c
29  *  \ingroup bke
30  */
31
32 #include <stdio.h>
33 #include <string.h>
34 #include <math.h>
35 #include <stdlib.h>
36
37 #include "MEM_guardedalloc.h"
38
39 #include "BLI_utildefines.h"
40 #include "BLI_listbase.h"
41 #include "BLI_bitmap.h"
42 #include "BLI_math.h"
43
44 #include "DNA_mesh_types.h"
45 #include "DNA_meshdata_types.h"
46 #include "DNA_scene_types.h"
47 #include "DNA_object_types.h"
48 #include "DNA_lattice_types.h"
49 #include "DNA_curve_types.h"
50 #include "DNA_key_types.h"
51
52 #include "BKE_animsys.h"
53 #include "BKE_anim.h"
54 #include "BKE_cdderivedmesh.h"
55 #include "BKE_curve.h"
56 #include "BKE_depsgraph.h"
57 #include "BKE_displist.h"
58 #include "BKE_global.h"
59 #include "BKE_key.h"
60 #include "BKE_lattice.h"
61 #include "BKE_library.h"
62 #include "BKE_library_query.h"
63 #include "BKE_library_remap.h"
64 #include "BKE_main.h"
65 #include "BKE_modifier.h"
66 #include "BKE_object.h"
67
68 #include "BKE_deform.h"
69
70 /* Workaround for cyclic depenndnecy with curves.
71  * In such case curve_cache might not be ready yet,
72  */
73 #define CYCLIC_DEPENDENCY_WORKAROUND
74
75 int BKE_lattice_index_from_uvw(Lattice *lt,
76                                const int u, const int v, const int w)
77 {
78         const int totu = lt->pntsu;
79         const int totv = lt->pntsv;
80
81         return (w * (totu * totv) + (v * totu) + u);
82 }
83
84 void BKE_lattice_index_to_uvw(Lattice *lt, const int index,
85                               int *r_u, int *r_v, int *r_w)
86 {
87         const int totu = lt->pntsu;
88         const int totv = lt->pntsv;
89
90         *r_u = (index % totu);
91         *r_v = (index / totu) % totv;
92         *r_w = (index / (totu * totv));
93 }
94
95 int BKE_lattice_index_flip(Lattice *lt, const int index,
96                            const bool flip_u, const bool flip_v, const bool flip_w)
97 {
98         int u, v, w;
99
100         BKE_lattice_index_to_uvw(lt, index, &u, &v, &w);
101
102         if (flip_u) {
103                 u = (lt->pntsu - 1) - u;
104         }
105
106         if (flip_v) {
107                 v = (lt->pntsv - 1) - v;
108         }
109
110         if (flip_w) {
111                 w = (lt->pntsw - 1) - w;
112         }
113
114         return BKE_lattice_index_from_uvw(lt, u, v, w);
115 }
116
117 void BKE_lattice_bitmap_from_flag(Lattice *lt, BLI_bitmap *bitmap, const short flag,
118                                   const bool clear, const bool respecthide)
119 {
120         const unsigned int tot = lt->pntsu * lt->pntsv * lt->pntsw;
121         unsigned int i;
122         BPoint *bp;
123
124         bp = lt->def;
125         for (i = 0; i < tot; i++, bp++) {
126                 if ((bp->f1 & flag) && (!respecthide || !bp->hide)) {
127                         BLI_BITMAP_ENABLE(bitmap, i);
128                 }
129                 else {
130                         if (clear) {
131                                 BLI_BITMAP_DISABLE(bitmap, i);
132                         }
133                 }
134         }
135
136 }
137
138 void calc_lat_fudu(int flag, int res, float *r_fu, float *r_du)
139 {
140         if (res == 1) {
141                 *r_fu = 0.0;
142                 *r_du = 0.0;
143         }
144         else if (flag & LT_GRID) {
145                 *r_fu = -0.5f * (res - 1);
146                 *r_du = 1.0f;
147         }
148         else {
149                 *r_fu = -1.0f;
150                 *r_du = 2.0f / (res - 1);
151         }
152 }
153
154 void BKE_lattice_resize(Lattice *lt, int uNew, int vNew, int wNew, Object *ltOb)
155 {
156         BPoint *bp;
157         int i, u, v, w;
158         float fu, fv, fw, uc, vc, wc, du = 0.0, dv = 0.0, dw = 0.0;
159         float *co, (*vertexCos)[3] = NULL;
160         
161         /* vertex weight groups are just freed all for now */
162         if (lt->dvert) {
163                 BKE_defvert_array_free(lt->dvert, lt->pntsu * lt->pntsv * lt->pntsw);
164                 lt->dvert = NULL;
165         }
166         
167         while (uNew * vNew * wNew > 32000) {
168                 if (uNew >= vNew && uNew >= wNew) uNew--;
169                 else if (vNew >= uNew && vNew >= wNew) vNew--;
170                 else wNew--;
171         }
172
173         vertexCos = MEM_mallocN(sizeof(*vertexCos) * uNew * vNew * wNew, "tmp_vcos");
174
175         calc_lat_fudu(lt->flag, uNew, &fu, &du);
176         calc_lat_fudu(lt->flag, vNew, &fv, &dv);
177         calc_lat_fudu(lt->flag, wNew, &fw, &dw);
178
179         /* If old size is different then resolution changed in interface,
180          * try to do clever reinit of points. Pretty simply idea, we just
181          * deform new verts by old lattice, but scaling them to match old
182          * size first.
183          */
184         if (ltOb) {
185                 if (uNew != 1 && lt->pntsu != 1) {
186                         fu = lt->fu;
187                         du = (lt->pntsu - 1) * lt->du / (uNew - 1);
188                 }
189
190                 if (vNew != 1 && lt->pntsv != 1) {
191                         fv = lt->fv;
192                         dv = (lt->pntsv - 1) * lt->dv / (vNew - 1);
193                 }
194
195                 if (wNew != 1 && lt->pntsw != 1) {
196                         fw = lt->fw;
197                         dw = (lt->pntsw - 1) * lt->dw / (wNew - 1);
198                 }
199         }
200
201         co = vertexCos[0];
202         for (w = 0, wc = fw; w < wNew; w++, wc += dw) {
203                 for (v = 0, vc = fv; v < vNew; v++, vc += dv) {
204                         for (u = 0, uc = fu; u < uNew; u++, co += 3, uc += du) {
205                                 co[0] = uc;
206                                 co[1] = vc;
207                                 co[2] = wc;
208                         }
209                 }
210         }
211         
212         if (ltOb) {
213                 float mat[4][4];
214                 int typeu = lt->typeu, typev = lt->typev, typew = lt->typew;
215
216                 /* works best if we force to linear type (endpoints match) */
217                 lt->typeu = lt->typev = lt->typew = KEY_LINEAR;
218
219                 /* prevent using deformed locations */
220                 BKE_displist_free(&ltOb->curve_cache->disp);
221
222                 copy_m4_m4(mat, ltOb->obmat);
223                 unit_m4(ltOb->obmat);
224                 lattice_deform_verts(ltOb, NULL, NULL, vertexCos, uNew * vNew * wNew, NULL, 1.0f);
225                 copy_m4_m4(ltOb->obmat, mat);
226
227                 lt->typeu = typeu;
228                 lt->typev = typev;
229                 lt->typew = typew;
230         }
231
232         lt->fu = fu;
233         lt->fv = fv;
234         lt->fw = fw;
235         lt->du = du;
236         lt->dv = dv;
237         lt->dw = dw;
238
239         lt->pntsu = uNew;
240         lt->pntsv = vNew;
241         lt->pntsw = wNew;
242
243         lt->actbp = LT_ACTBP_NONE;
244         MEM_freeN(lt->def);
245         lt->def = MEM_callocN(lt->pntsu * lt->pntsv * lt->pntsw * sizeof(BPoint), "lattice bp");
246         
247         bp = lt->def;
248         
249         for (i = 0; i < lt->pntsu * lt->pntsv * lt->pntsw; i++, bp++) {
250                 copy_v3_v3(bp->vec, vertexCos[i]);
251         }
252
253         MEM_freeN(vertexCos);
254 }
255
256 void BKE_lattice_init(Lattice *lt)
257 {
258         BLI_assert(MEMCMP_STRUCT_OFS_IS_ZERO(lt, id));
259
260         lt->flag = LT_GRID;
261         
262         lt->typeu = lt->typev = lt->typew = KEY_BSPLINE;
263         
264         lt->def = MEM_callocN(sizeof(BPoint), "lattvert"); /* temporary */
265         BKE_lattice_resize(lt, 2, 2, 2, NULL);  /* creates a uniform lattice */
266         lt->actbp = LT_ACTBP_NONE;
267 }
268
269 Lattice *BKE_lattice_add(Main *bmain, const char *name)
270 {
271         Lattice *lt;
272
273         lt = BKE_libblock_alloc(bmain, ID_LT, name);
274
275         BKE_lattice_init(lt);
276
277         return lt;
278 }
279
280 Lattice *BKE_lattice_copy(Main *bmain, Lattice *lt)
281 {
282         Lattice *ltn;
283
284         ltn = BKE_libblock_copy(bmain, &lt->id);
285         ltn->def = MEM_dupallocN(lt->def);
286
287         if (lt->key) {
288                 ltn->key = BKE_key_copy(bmain, ltn->key);
289                 ltn->key->from = (ID *)ltn;
290         }
291         
292         if (lt->dvert) {
293                 int tot = lt->pntsu * lt->pntsv * lt->pntsw;
294                 ltn->dvert = MEM_mallocN(sizeof(MDeformVert) * tot, "Lattice MDeformVert");
295                 BKE_defvert_array_copy(ltn->dvert, lt->dvert, tot);
296         }
297
298         ltn->editlatt = NULL;
299
300         if (ID_IS_LINKED_DATABLOCK(lt)) {
301                 BKE_id_expand_local(&ltn->id);
302                 BKE_id_lib_local_paths(bmain, lt->id.lib, &ltn->id);
303         }
304
305         return ltn;
306 }
307
308 /** Free (or release) any data used by this lattice (does not free the lattice itself). */
309 void BKE_lattice_free(Lattice *lt)
310 {
311         BKE_animdata_free(&lt->id, false);
312
313         MEM_SAFE_FREE(lt->def);
314         if (lt->dvert) {
315                 BKE_defvert_array_free(lt->dvert, lt->pntsu * lt->pntsv * lt->pntsw);
316                 lt->dvert = NULL;
317         }
318         if (lt->editlatt) {
319                 Lattice *editlt = lt->editlatt->latt;
320
321                 if (editlt->def)
322                         MEM_freeN(editlt->def);
323                 if (editlt->dvert)
324                         BKE_defvert_array_free(editlt->dvert, lt->pntsu * lt->pntsv * lt->pntsw);
325
326                 MEM_freeN(editlt);
327                 MEM_freeN(lt->editlatt);
328                 lt->editlatt = NULL;
329         }
330 }
331
332
333 void BKE_lattice_make_local(Main *bmain, Lattice *lt, const bool force_local)
334 {
335         bool is_local = false, is_lib = false;
336
337         /* - only lib users: do nothing (unless force_local is set)
338          * - only local users: set flag
339          * - mixed: make copy
340          */
341
342         if (!ID_IS_LINKED_DATABLOCK(lt)) {
343                 return;
344         }
345
346         BKE_library_ID_test_usages(bmain, lt, &is_local, &is_lib);
347
348         if (force_local || is_local) {
349                 if (!is_lib) {
350                         id_clear_lib_data(bmain, &lt->id);
351                         if (lt->key) {
352                                 id_clear_lib_data(bmain, &lt->key->id);
353                         }
354                         BKE_id_expand_local(&lt->id);
355                 }
356                 else {
357                         Lattice *lt_new = BKE_lattice_copy(bmain, lt);
358
359                         lt_new->id.us = 0;
360
361                         BKE_libblock_remap(bmain, lt, lt_new, ID_REMAP_SKIP_INDIRECT_USAGE);
362                 }
363         }
364 }
365
366 typedef struct LatticeDeformData {
367         Object *object;
368         float *latticedata;
369         float latmat[4][4];
370 } LatticeDeformData;
371
372 LatticeDeformData *init_latt_deform(Object *oblatt, Object *ob)
373 {
374         /* we make an array with all differences */
375         Lattice *lt = oblatt->data;
376         BPoint *bp;
377         DispList *dl = oblatt->curve_cache ? BKE_displist_find(&oblatt->curve_cache->disp, DL_VERTS) : NULL;
378         const float *co = dl ? dl->verts : NULL;
379         float *fp, imat[4][4];
380         float fu, fv, fw;
381         int u, v, w;
382         float *latticedata;
383         float latmat[4][4];
384         LatticeDeformData *lattice_deform_data;
385
386         if (lt->editlatt) lt = lt->editlatt->latt;
387         bp = lt->def;
388         
389         fp = latticedata = MEM_mallocN(sizeof(float) * 3 * lt->pntsu * lt->pntsv * lt->pntsw, "latticedata");
390         
391         /* for example with a particle system: (ob == NULL) */
392         if (ob == NULL) {
393                 /* in deformspace, calc matrix  */
394                 invert_m4_m4(latmat, oblatt->obmat);
395         
396                 /* back: put in deform array */
397                 invert_m4_m4(imat, latmat);
398         }
399         else {
400                 /* in deformspace, calc matrix */
401                 invert_m4_m4(imat, oblatt->obmat);
402                 mul_m4_m4m4(latmat, imat, ob->obmat);
403         
404                 /* back: put in deform array */
405                 invert_m4_m4(imat, latmat);
406         }
407         
408         for (w = 0, fw = lt->fw; w < lt->pntsw; w++, fw += lt->dw) {
409                 for (v = 0, fv = lt->fv; v < lt->pntsv; v++, fv += lt->dv) {
410                         for (u = 0, fu = lt->fu; u < lt->pntsu; u++, bp++, co += 3, fp += 3, fu += lt->du) {
411                                 if (dl) {
412                                         fp[0] = co[0] - fu;
413                                         fp[1] = co[1] - fv;
414                                         fp[2] = co[2] - fw;
415                                 }
416                                 else {
417                                         fp[0] = bp->vec[0] - fu;
418                                         fp[1] = bp->vec[1] - fv;
419                                         fp[2] = bp->vec[2] - fw;
420                                 }
421
422                                 mul_mat3_m4_v3(imat, fp);
423                         }
424                 }
425         }
426
427         lattice_deform_data = MEM_mallocN(sizeof(LatticeDeformData), "Lattice Deform Data");
428         lattice_deform_data->latticedata = latticedata;
429         lattice_deform_data->object = oblatt;
430         copy_m4_m4(lattice_deform_data->latmat, latmat);
431
432         return lattice_deform_data;
433 }
434
435 void calc_latt_deform(LatticeDeformData *lattice_deform_data, float co[3], float weight)
436 {
437         Object *ob = lattice_deform_data->object;
438         Lattice *lt = ob->data;
439         float u, v, w, tu[4], tv[4], tw[4];
440         float vec[3];
441         int idx_w, idx_v, idx_u;
442         int ui, vi, wi, uu, vv, ww;
443
444         /* vgroup influence */
445         int defgrp_index = -1;
446         float co_prev[3], weight_blend = 0.0f;
447         MDeformVert *dvert = BKE_lattice_deform_verts_get(ob);
448
449
450         if (lt->editlatt) lt = lt->editlatt->latt;
451         if (lattice_deform_data->latticedata == NULL) return;
452
453         if (lt->vgroup[0] && dvert) {
454                 defgrp_index = defgroup_name_index(ob, lt->vgroup);
455                 copy_v3_v3(co_prev, co);
456         }
457
458         /* co is in local coords, treat with latmat */
459         mul_v3_m4v3(vec, lattice_deform_data->latmat, co);
460
461         /* u v w coords */
462
463         if (lt->pntsu > 1) {
464                 u = (vec[0] - lt->fu) / lt->du;
465                 ui = (int)floor(u);
466                 u -= ui;
467                 key_curve_position_weights(u, tu, lt->typeu);
468         }
469         else {
470                 tu[0] = tu[2] = tu[3] = 0.0; tu[1] = 1.0;
471                 ui = 0;
472         }
473
474         if (lt->pntsv > 1) {
475                 v = (vec[1] - lt->fv) / lt->dv;
476                 vi = (int)floor(v);
477                 v -= vi;
478                 key_curve_position_weights(v, tv, lt->typev);
479         }
480         else {
481                 tv[0] = tv[2] = tv[3] = 0.0; tv[1] = 1.0;
482                 vi = 0;
483         }
484
485         if (lt->pntsw > 1) {
486                 w = (vec[2] - lt->fw) / lt->dw;
487                 wi = (int)floor(w);
488                 w -= wi;
489                 key_curve_position_weights(w, tw, lt->typew);
490         }
491         else {
492                 tw[0] = tw[2] = tw[3] = 0.0; tw[1] = 1.0;
493                 wi = 0;
494         }
495
496         for (ww = wi - 1; ww <= wi + 2; ww++) {
497                 w = tw[ww - wi + 1];
498
499                 if (w != 0.0f) {
500                         if (ww > 0) {
501                                 if (ww < lt->pntsw) idx_w = ww * lt->pntsu * lt->pntsv;
502                                 else                idx_w = (lt->pntsw - 1) * lt->pntsu * lt->pntsv;
503                         }
504                         else {
505                                 idx_w = 0;
506                         }
507
508                         for (vv = vi - 1; vv <= vi + 2; vv++) {
509                                 v = w * tv[vv - vi + 1];
510
511                                 if (v != 0.0f) {
512                                         if (vv > 0) {
513                                                 if (vv < lt->pntsv) idx_v = idx_w + vv * lt->pntsu;
514                                                 else                idx_v = idx_w + (lt->pntsv - 1) * lt->pntsu;
515                                         }
516                                         else {
517                                                 idx_v = idx_w;
518                                         }
519
520                                         for (uu = ui - 1; uu <= ui + 2; uu++) {
521                                                 u = weight * v * tu[uu - ui + 1];
522
523                                                 if (u != 0.0f) {
524                                                         if (uu > 0) {
525                                                                 if (uu < lt->pntsu) idx_u = idx_v + uu;
526                                                                 else                idx_u = idx_v + (lt->pntsu - 1);
527                                                         }
528                                                         else {
529                                                                 idx_u = idx_v;
530                                                         }
531
532                                                         madd_v3_v3fl(co, &lattice_deform_data->latticedata[idx_u * 3], u);
533
534                                                         if (defgrp_index != -1)
535                                                                 weight_blend += (u * defvert_find_weight(dvert + idx_u, defgrp_index));
536                                                 }
537                                         }
538                                 }
539                         }
540                 }
541         }
542
543         if (defgrp_index != -1)
544                 interp_v3_v3v3(co, co_prev, co, weight_blend);
545
546 }
547
548 void end_latt_deform(LatticeDeformData *lattice_deform_data)
549 {
550         if (lattice_deform_data->latticedata)
551                 MEM_freeN(lattice_deform_data->latticedata);
552
553         MEM_freeN(lattice_deform_data);
554 }
555
556 /* calculations is in local space of deformed object
557  * so we store in latmat transform from path coord inside object
558  */
559 typedef struct {
560         float dmin[3], dmax[3];
561         float curvespace[4][4], objectspace[4][4], objectspace3[3][3];
562         int no_rot_axis;
563 } CurveDeform;
564
565 static void init_curve_deform(Object *par, Object *ob, CurveDeform *cd)
566 {
567         invert_m4_m4(ob->imat, ob->obmat);
568         mul_m4_m4m4(cd->objectspace, ob->imat, par->obmat);
569         invert_m4_m4(cd->curvespace, cd->objectspace);
570         copy_m3_m4(cd->objectspace3, cd->objectspace);
571         cd->no_rot_axis = 0;
572 }
573
574 /* this makes sure we can extend for non-cyclic.
575  *
576  * returns OK: 1/0
577  */
578 static bool where_on_path_deform(Object *ob, float ctime, float vec[4], float dir[3], float quat[4], float *radius)
579 {
580         BevList *bl;
581         float ctime1;
582         int cycl = 0;
583         
584         /* test for cyclic */
585         bl = ob->curve_cache->bev.first;
586         if (!bl->nr) return false;
587         if (bl->poly > -1) cycl = 1;
588
589         if (cycl == 0) {
590                 ctime1 = CLAMPIS(ctime, 0.0f, 1.0f);
591         }
592         else {
593                 ctime1 = ctime;
594         }
595         
596         /* vec needs 4 items */
597         if (where_on_path(ob, ctime1, vec, dir, quat, radius, NULL)) {
598                 
599                 if (cycl == 0) {
600                         Path *path = ob->curve_cache->path;
601                         float dvec[3];
602                         
603                         if (ctime < 0.0f) {
604                                 sub_v3_v3v3(dvec, path->data[1].vec, path->data[0].vec);
605                                 mul_v3_fl(dvec, ctime * (float)path->len);
606                                 add_v3_v3(vec, dvec);
607                                 if (quat) copy_qt_qt(quat, path->data[0].quat);
608                                 if (radius) *radius = path->data[0].radius;
609                         }
610                         else if (ctime > 1.0f) {
611                                 sub_v3_v3v3(dvec, path->data[path->len - 1].vec, path->data[path->len - 2].vec);
612                                 mul_v3_fl(dvec, (ctime - 1.0f) * (float)path->len);
613                                 add_v3_v3(vec, dvec);
614                                 if (quat) copy_qt_qt(quat, path->data[path->len - 1].quat);
615                                 if (radius) *radius = path->data[path->len - 1].radius;
616                                 /* weight - not used but could be added */
617                         }
618                 }
619                 return true;
620         }
621         return false;
622 }
623
624 /* for each point, rotate & translate to curve */
625 /* use path, since it has constant distances */
626 /* co: local coord, result local too */
627 /* returns quaternion for rotation, using cd->no_rot_axis */
628 /* axis is using another define!!! */
629 static bool calc_curve_deform(Scene *scene, Object *par, float co[3],
630                               const short axis, CurveDeform *cd, float r_quat[4])
631 {
632         Curve *cu = par->data;
633         float fac, loc[4], dir[3], new_quat[4], radius;
634         short index;
635         const bool is_neg_axis = (axis > 2);
636
637         /* to be sure, mostly after file load, also cyclic dependencies */
638 #ifdef CYCLIC_DEPENDENCY_WORKAROUND
639         if (par->curve_cache == NULL) {
640                 BKE_displist_make_curveTypes(scene, par, false);
641         }
642 #endif
643
644         if (par->curve_cache->path == NULL) {
645                 return false;  /* happens on append, cyclic dependencies and empty curves */
646         }
647
648         /* options */
649         if (is_neg_axis) {
650                 index = axis - 3;
651                 if (cu->flag & CU_STRETCH)
652                         fac = (-co[index] - cd->dmax[index]) / (cd->dmax[index] - cd->dmin[index]);
653                 else
654                         fac = -(co[index] - cd->dmax[index]) / (par->curve_cache->path->totdist);
655         }
656         else {
657                 index = axis;
658                 if (cu->flag & CU_STRETCH) {
659                         fac = (co[index] - cd->dmin[index]) / (cd->dmax[index] - cd->dmin[index]);
660                 }
661                 else {
662                         if (LIKELY(par->curve_cache->path->totdist > FLT_EPSILON)) {
663                                 fac = +(co[index] - cd->dmin[index]) / (par->curve_cache->path->totdist);
664                         }
665                         else {
666                                 fac = 0.0f;
667                         }
668                 }
669         }
670         
671         if (where_on_path_deform(par, fac, loc, dir, new_quat, &radius)) {  /* returns OK */
672                 float quat[4], cent[3];
673
674                 if (cd->no_rot_axis) {  /* set by caller */
675
676                         /* this is not exactly the same as 2.4x, since the axis is having rotation removed rather than
677                          * changing the axis before calculating the tilt but serves much the same purpose */
678                         float dir_flat[3] = {0, 0, 0}, q[4];
679                         copy_v3_v3(dir_flat, dir);
680                         dir_flat[cd->no_rot_axis - 1] = 0.0f;
681
682                         normalize_v3(dir);
683                         normalize_v3(dir_flat);
684
685                         rotation_between_vecs_to_quat(q, dir, dir_flat); /* Could this be done faster? */
686
687                         mul_qt_qtqt(new_quat, q, new_quat);
688                 }
689
690
691                 /* Logic for 'cent' orientation *
692                  *
693                  * The way 'co' is copied to 'cent' may seem to have no meaning, but it does.
694                  *
695                  * Use a curve modifier to stretch a cube out, color each side RGB, positive side light, negative dark.
696                  * view with X up (default), from the angle that you can see 3 faces RGB colors (light), anti-clockwise
697                  * Notice X,Y,Z Up all have light colors and each ordered CCW.
698                  *
699                  * Now for Neg Up XYZ, the colors are all dark, and ordered clockwise - Campbell
700                  *
701                  * note: moved functions into quat_apply_track/vec_apply_track
702                  * */
703                 copy_qt_qt(quat, new_quat);
704                 copy_v3_v3(cent, co);
705
706                 /* zero the axis which is not used,
707                  * the big block of text above now applies to these 3 lines */
708                 quat_apply_track(quat, axis, (axis == 0 || axis == 2) ? 1 : 0); /* up flag is a dummy, set so no rotation is done */
709                 vec_apply_track(cent, axis);
710                 cent[index] = 0.0f;
711
712
713                 /* scale if enabled */
714                 if (cu->flag & CU_PATH_RADIUS)
715                         mul_v3_fl(cent, radius);
716                 
717                 /* local rotation */
718                 normalize_qt(quat);
719                 mul_qt_v3(quat, cent);
720
721                 /* translation */
722                 add_v3_v3v3(co, cent, loc);
723
724                 if (r_quat)
725                         copy_qt_qt(r_quat, quat);
726
727                 return true;
728         }
729         return false;
730 }
731
732 void curve_deform_verts(
733         Scene *scene, Object *cuOb, Object *target, DerivedMesh *dm, float (*vertexCos)[3],
734         int numVerts, const char *vgroup, short defaxis)
735 {
736         Curve *cu;
737         int a;
738         CurveDeform cd;
739         MDeformVert *dvert = NULL;
740         int defgrp_index = -1;
741         const bool is_neg_axis = (defaxis > 2);
742
743         if (cuOb->type != OB_CURVE)
744                 return;
745
746         cu = cuOb->data;
747
748         init_curve_deform(cuOb, target, &cd);
749
750         /* dummy bounds, keep if CU_DEFORM_BOUNDS_OFF is set */
751         if (is_neg_axis == false) {
752                 cd.dmin[0] = cd.dmin[1] = cd.dmin[2] = 0.0f;
753                 cd.dmax[0] = cd.dmax[1] = cd.dmax[2] = 1.0f;
754         }
755         else {
756                 /* negative, these bounds give a good rest position */
757                 cd.dmin[0] = cd.dmin[1] = cd.dmin[2] = -1.0f;
758                 cd.dmax[0] = cd.dmax[1] = cd.dmax[2] =  0.0f;
759         }
760         
761         /* Check whether to use vertex groups (only possible if target is a Mesh or Lattice).
762          * We want either a Mesh/Lattice with no derived data, or derived data with deformverts.
763          */
764         if (vgroup && vgroup[0] && ELEM(target->type, OB_MESH, OB_LATTICE)) {
765                 defgrp_index = defgroup_name_index(target, vgroup);
766
767                 if (defgrp_index != -1) {
768                         /* if there's derived data without deformverts, don't use vgroups */
769                         if (dm) {
770                                 dvert = dm->getVertDataArray(dm, CD_MDEFORMVERT);
771                         }
772                         else if (target->type == OB_LATTICE) {
773                                 dvert = ((Lattice *)target->data)->dvert;
774                         }
775                         else {
776                                 dvert = ((Mesh *)target->data)->dvert;
777                         }
778                 }
779         }
780
781         if (dvert) {
782                 MDeformVert *dvert_iter;
783                 float vec[3];
784
785                 if (cu->flag & CU_DEFORM_BOUNDS_OFF) {
786                         for (a = 0, dvert_iter = dvert; a < numVerts; a++, dvert_iter++) {
787                                 const float weight = defvert_find_weight(dvert_iter, defgrp_index);
788
789                                 if (weight > 0.0f) {
790                                         mul_m4_v3(cd.curvespace, vertexCos[a]);
791                                         copy_v3_v3(vec, vertexCos[a]);
792                                         calc_curve_deform(scene, cuOb, vec, defaxis, &cd, NULL);
793                                         interp_v3_v3v3(vertexCos[a], vertexCos[a], vec, weight);
794                                         mul_m4_v3(cd.objectspace, vertexCos[a]);
795                                 }
796                         }
797                 }
798                 else {
799                         /* set mesh min/max bounds */
800                         INIT_MINMAX(cd.dmin, cd.dmax);
801
802                         for (a = 0, dvert_iter = dvert; a < numVerts; a++, dvert_iter++) {
803                                 if (defvert_find_weight(dvert_iter, defgrp_index) > 0.0f) {
804                                         mul_m4_v3(cd.curvespace, vertexCos[a]);
805                                         minmax_v3v3_v3(cd.dmin, cd.dmax, vertexCos[a]);
806                                 }
807                         }
808
809                         for (a = 0, dvert_iter = dvert; a < numVerts; a++, dvert_iter++) {
810                                 const float weight = defvert_find_weight(dvert_iter, defgrp_index);
811
812                                 if (weight > 0.0f) {
813                                         /* already in 'cd.curvespace', prev for loop */
814                                         copy_v3_v3(vec, vertexCos[a]);
815                                         calc_curve_deform(scene, cuOb, vec, defaxis, &cd, NULL);
816                                         interp_v3_v3v3(vertexCos[a], vertexCos[a], vec, weight);
817                                         mul_m4_v3(cd.objectspace, vertexCos[a]);
818                                 }
819                         }
820                 }
821         }
822         else {
823                 if (cu->flag & CU_DEFORM_BOUNDS_OFF) {
824                         for (a = 0; a < numVerts; a++) {
825                                 mul_m4_v3(cd.curvespace, vertexCos[a]);
826                                 calc_curve_deform(scene, cuOb, vertexCos[a], defaxis, &cd, NULL);
827                                 mul_m4_v3(cd.objectspace, vertexCos[a]);
828                         }
829                 }
830                 else {
831                         /* set mesh min max bounds */
832                         INIT_MINMAX(cd.dmin, cd.dmax);
833                                 
834                         for (a = 0; a < numVerts; a++) {
835                                 mul_m4_v3(cd.curvespace, vertexCos[a]);
836                                 minmax_v3v3_v3(cd.dmin, cd.dmax, vertexCos[a]);
837                         }
838         
839                         for (a = 0; a < numVerts; a++) {
840                                 /* already in 'cd.curvespace', prev for loop */
841                                 calc_curve_deform(scene, cuOb, vertexCos[a], defaxis, &cd, NULL);
842                                 mul_m4_v3(cd.objectspace, vertexCos[a]);
843                         }
844                 }
845         }
846 }
847
848 /* input vec and orco = local coord in armature space */
849 /* orco is original not-animated or deformed reference point */
850 /* result written in vec and mat */
851 void curve_deform_vector(Scene *scene, Object *cuOb, Object *target,
852                          float orco[3], float vec[3], float mat[3][3], int no_rot_axis)
853 {
854         CurveDeform cd;
855         float quat[4];
856         
857         if (cuOb->type != OB_CURVE) {
858                 unit_m3(mat);
859                 return;
860         }
861
862         init_curve_deform(cuOb, target, &cd);
863         cd.no_rot_axis = no_rot_axis;                /* option to only rotate for XY, for example */
864         
865         copy_v3_v3(cd.dmin, orco);
866         copy_v3_v3(cd.dmax, orco);
867
868         mul_m4_v3(cd.curvespace, vec);
869         
870         if (calc_curve_deform(scene, cuOb, vec, target->trackflag, &cd, quat)) {
871                 float qmat[3][3];
872                 
873                 quat_to_mat3(qmat, quat);
874                 mul_m3_m3m3(mat, qmat, cd.objectspace3);
875         }
876         else
877                 unit_m3(mat);
878         
879         mul_m4_v3(cd.objectspace, vec);
880
881 }
882
883 void lattice_deform_verts(Object *laOb, Object *target, DerivedMesh *dm,
884                           float (*vertexCos)[3], int numVerts, const char *vgroup, float fac)
885 {
886         LatticeDeformData *lattice_deform_data;
887         int a;
888         bool use_vgroups;
889
890         if (laOb->type != OB_LATTICE)
891                 return;
892
893         lattice_deform_data = init_latt_deform(laOb, target);
894
895         /* check whether to use vertex groups (only possible if target is a Mesh)
896          * we want either a Mesh with no derived data, or derived data with
897          * deformverts
898          */
899         if (target && target->type == OB_MESH) {
900                 /* if there's derived data without deformverts, don't use vgroups */
901                 if (dm) {
902                         use_vgroups = (dm->getVertDataArray(dm, CD_MDEFORMVERT) != NULL);
903                 }
904                 else {
905                         Mesh *me = target->data;
906                         use_vgroups = (me->dvert != NULL);
907                 }
908         }
909         else {
910                 use_vgroups = false;
911         }
912         
913         if (vgroup && vgroup[0] && use_vgroups) {
914                 Mesh *me = target->data;
915                 const int defgrp_index = defgroup_name_index(target, vgroup);
916                 float weight;
917
918                 if (defgrp_index >= 0 && (me->dvert || dm)) {
919                         MDeformVert *dvert = me->dvert;
920                         
921                         for (a = 0; a < numVerts; a++, dvert++) {
922                                 if (dm) dvert = dm->getVertData(dm, a, CD_MDEFORMVERT);
923
924                                 weight = defvert_find_weight(dvert, defgrp_index);
925
926                                 if (weight > 0.0f)
927                                         calc_latt_deform(lattice_deform_data, vertexCos[a], weight * fac);
928                         }
929                 }
930         }
931         else {
932                 for (a = 0; a < numVerts; a++) {
933                         calc_latt_deform(lattice_deform_data, vertexCos[a], fac);
934                 }
935         }
936         end_latt_deform(lattice_deform_data);
937 }
938
939 bool object_deform_mball(Object *ob, ListBase *dispbase)
940 {
941         if (ob->parent && ob->parent->type == OB_LATTICE && ob->partype == PARSKEL) {
942                 DispList *dl;
943
944                 for (dl = dispbase->first; dl; dl = dl->next) {
945                         lattice_deform_verts(ob->parent, ob, NULL,
946                                              (float(*)[3])dl->verts, dl->nr, NULL, 1.0f);
947                 }
948
949                 return true;
950         }
951         else {
952                 return false;
953         }
954 }
955
956 static BPoint *latt_bp(Lattice *lt, int u, int v, int w)
957 {
958         return &lt->def[BKE_lattice_index_from_uvw(lt, u, v, w)];
959 }
960
961 void outside_lattice(Lattice *lt)
962 {
963         BPoint *bp, *bp1, *bp2;
964         int u, v, w;
965         float fac1, du = 0.0, dv = 0.0, dw = 0.0;
966
967         if (lt->flag & LT_OUTSIDE) {
968                 bp = lt->def;
969
970                 if (lt->pntsu > 1) du = 1.0f / ((float)lt->pntsu - 1);
971                 if (lt->pntsv > 1) dv = 1.0f / ((float)lt->pntsv - 1);
972                 if (lt->pntsw > 1) dw = 1.0f / ((float)lt->pntsw - 1);
973                         
974                 for (w = 0; w < lt->pntsw; w++) {
975                         
976                         for (v = 0; v < lt->pntsv; v++) {
977                         
978                                 for (u = 0; u < lt->pntsu; u++, bp++) {
979                                         if (u == 0 || v == 0 || w == 0 || u == lt->pntsu - 1 || v == lt->pntsv - 1 || w == lt->pntsw - 1) {
980                                                 /* pass */
981                                         }
982                                         else {
983                                                 bp->hide = 1;
984                                                 bp->f1 &= ~SELECT;
985                                                 
986                                                 /* u extrema */
987                                                 bp1 = latt_bp(lt, 0, v, w);
988                                                 bp2 = latt_bp(lt, lt->pntsu - 1, v, w);
989                                                 
990                                                 fac1 = du * u;
991                                                 bp->vec[0] = (1.0f - fac1) * bp1->vec[0] + fac1 * bp2->vec[0];
992                                                 bp->vec[1] = (1.0f - fac1) * bp1->vec[1] + fac1 * bp2->vec[1];
993                                                 bp->vec[2] = (1.0f - fac1) * bp1->vec[2] + fac1 * bp2->vec[2];
994                                                 
995                                                 /* v extrema */
996                                                 bp1 = latt_bp(lt, u, 0, w);
997                                                 bp2 = latt_bp(lt, u, lt->pntsv - 1, w);
998                                                 
999                                                 fac1 = dv * v;
1000                                                 bp->vec[0] += (1.0f - fac1) * bp1->vec[0] + fac1 * bp2->vec[0];
1001                                                 bp->vec[1] += (1.0f - fac1) * bp1->vec[1] + fac1 * bp2->vec[1];
1002                                                 bp->vec[2] += (1.0f - fac1) * bp1->vec[2] + fac1 * bp2->vec[2];
1003                                                 
1004                                                 /* w extrema */
1005                                                 bp1 = latt_bp(lt, u, v, 0);
1006                                                 bp2 = latt_bp(lt, u, v, lt->pntsw - 1);
1007                                                 
1008                                                 fac1 = dw * w;
1009                                                 bp->vec[0] += (1.0f - fac1) * bp1->vec[0] + fac1 * bp2->vec[0];
1010                                                 bp->vec[1] += (1.0f - fac1) * bp1->vec[1] + fac1 * bp2->vec[1];
1011                                                 bp->vec[2] += (1.0f - fac1) * bp1->vec[2] + fac1 * bp2->vec[2];
1012                                                 
1013                                                 mul_v3_fl(bp->vec, 1.0f / 3.0f);
1014                                                 
1015                                         }
1016                                 }
1017                                 
1018                         }
1019                         
1020                 }
1021         }
1022         else {
1023                 bp = lt->def;
1024
1025                 for (w = 0; w < lt->pntsw; w++)
1026                         for (v = 0; v < lt->pntsv; v++)
1027                                 for (u = 0; u < lt->pntsu; u++, bp++)
1028                                         bp->hide = 0;
1029         }
1030 }
1031
1032 float (*BKE_lattice_vertexcos_get(struct Object *ob, int *r_numVerts))[3]
1033 {
1034         Lattice *lt = ob->data;
1035         int i, numVerts;
1036         float (*vertexCos)[3];
1037
1038         if (lt->editlatt) lt = lt->editlatt->latt;
1039         numVerts = *r_numVerts = lt->pntsu * lt->pntsv * lt->pntsw;
1040         
1041         vertexCos = MEM_mallocN(sizeof(*vertexCos) * numVerts, "lt_vcos");
1042         
1043         for (i = 0; i < numVerts; i++) {
1044                 copy_v3_v3(vertexCos[i], lt->def[i].vec);
1045         }
1046
1047         return vertexCos;
1048 }
1049
1050 void BKE_lattice_vertexcos_apply(struct Object *ob, float (*vertexCos)[3])
1051 {
1052         Lattice *lt = ob->data;
1053         int i, numVerts = lt->pntsu * lt->pntsv * lt->pntsw;
1054
1055         for (i = 0; i < numVerts; i++) {
1056                 copy_v3_v3(lt->def[i].vec, vertexCos[i]);
1057         }
1058 }
1059
1060 void BKE_lattice_modifiers_calc(Scene *scene, Object *ob)
1061 {
1062         Lattice *lt = ob->data;
1063         VirtualModifierData virtualModifierData;
1064         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
1065         float (*vertexCos)[3] = NULL;
1066         int numVerts, editmode = (lt->editlatt != NULL);
1067
1068         if (ob->curve_cache) {
1069                 BKE_displist_free(&ob->curve_cache->disp);
1070         }
1071         else {
1072                 ob->curve_cache = MEM_callocN(sizeof(CurveCache), "CurveCache for lattice");
1073         }
1074
1075         for (; md; md = md->next) {
1076                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1077
1078                 md->scene = scene;
1079                 
1080                 if (!(mti->flags & eModifierTypeFlag_AcceptsLattice)) continue;
1081                 if (!(md->mode & eModifierMode_Realtime)) continue;
1082                 if (editmode && !(md->mode & eModifierMode_Editmode)) continue;
1083                 if (mti->isDisabled && mti->isDisabled(md, 0)) continue;
1084                 if (mti->type != eModifierTypeType_OnlyDeform) continue;
1085
1086                 if (!vertexCos) vertexCos = BKE_lattice_vertexcos_get(ob, &numVerts);
1087                 mti->deformVerts(md, ob, NULL, vertexCos, numVerts, 0);
1088         }
1089
1090         /* always displist to make this work like derivedmesh */
1091         if (!vertexCos) vertexCos = BKE_lattice_vertexcos_get(ob, &numVerts);
1092         
1093         {
1094                 DispList *dl = MEM_callocN(sizeof(*dl), "lt_dl");
1095                 dl->type = DL_VERTS;
1096                 dl->parts = 1;
1097                 dl->nr = numVerts;
1098                 dl->verts = (float *) vertexCos;
1099                 
1100                 BLI_addtail(&ob->curve_cache->disp, dl);
1101         }
1102 }
1103
1104 struct MDeformVert *BKE_lattice_deform_verts_get(struct Object *oblatt)
1105 {
1106         Lattice *lt = (Lattice *)oblatt->data;
1107         BLI_assert(oblatt->type == OB_LATTICE);
1108         if (lt->editlatt) lt = lt->editlatt->latt;
1109         return lt->dvert;
1110 }
1111
1112 struct BPoint *BKE_lattice_active_point_get(Lattice *lt)
1113 {
1114         BLI_assert(GS(lt->id.name) == ID_LT);
1115
1116         if (lt->editlatt) {
1117                 lt = lt->editlatt->latt;
1118         }
1119
1120         BLI_assert(lt->actbp < lt->pntsu * lt->pntsv * lt->pntsw);
1121
1122         if ((lt->actbp != LT_ACTBP_NONE) && (lt->actbp < lt->pntsu * lt->pntsv * lt->pntsw)) {
1123                 return &lt->def[lt->actbp];
1124         }
1125         else {
1126                 return NULL;
1127         }
1128 }
1129
1130 void BKE_lattice_center_median(Lattice *lt, float cent[3])
1131 {
1132         int i, numVerts;
1133
1134         if (lt->editlatt) lt = lt->editlatt->latt;
1135         numVerts = lt->pntsu * lt->pntsv * lt->pntsw;
1136
1137         zero_v3(cent);
1138
1139         for (i = 0; i < numVerts; i++)
1140                 add_v3_v3(cent, lt->def[i].vec);
1141
1142         mul_v3_fl(cent, 1.0f / (float)numVerts);
1143 }
1144
1145 static void boundbox_lattice(Object *ob)
1146 {
1147         BoundBox *bb;
1148         Lattice *lt;
1149         float min[3], max[3];
1150
1151         if (ob->bb == NULL) {
1152                 ob->bb = MEM_callocN(sizeof(BoundBox), "Lattice boundbox");
1153         }
1154
1155         bb = ob->bb;
1156         lt = ob->data;
1157
1158         INIT_MINMAX(min, max);
1159         BKE_lattice_minmax_dl(ob, lt, min, max);
1160         BKE_boundbox_init_from_minmax(bb, min, max);
1161
1162         bb->flag &= ~BOUNDBOX_DIRTY;
1163 }
1164
1165 BoundBox *BKE_lattice_boundbox_get(Object *ob)
1166 {
1167         boundbox_lattice(ob);
1168
1169         return ob->bb;
1170 }
1171
1172 void BKE_lattice_minmax_dl(Object *ob, Lattice *lt, float min[3], float max[3])
1173 {
1174         DispList *dl = ob->curve_cache ? BKE_displist_find(&ob->curve_cache->disp, DL_VERTS) : NULL;
1175
1176         if (!dl) {
1177                 BKE_lattice_minmax(lt, min, max);
1178         }
1179         else {
1180                 int i, numVerts;
1181                 
1182                 if (lt->editlatt) lt = lt->editlatt->latt;
1183                 numVerts = lt->pntsu * lt->pntsv * lt->pntsw;
1184
1185                 for (i = 0; i < numVerts; i++)
1186                         minmax_v3v3_v3(min, max, &dl->verts[i * 3]);
1187         }
1188 }
1189
1190 void BKE_lattice_minmax(Lattice *lt, float min[3], float max[3])
1191 {
1192         int i, numVerts;
1193
1194         if (lt->editlatt) lt = lt->editlatt->latt;
1195         numVerts = lt->pntsu * lt->pntsv * lt->pntsw;
1196
1197         for (i = 0; i < numVerts; i++)
1198                 minmax_v3v3_v3(min, max, lt->def[i].vec);
1199 }
1200
1201 void BKE_lattice_center_bounds(Lattice *lt, float cent[3])
1202 {
1203         float min[3], max[3];
1204
1205         INIT_MINMAX(min, max);
1206
1207         BKE_lattice_minmax(lt, min, max);
1208         mid_v3_v3v3(cent, min, max);
1209 }
1210
1211 void BKE_lattice_transform(Lattice *lt, float mat[4][4], bool do_keys)
1212 {
1213         BPoint *bp = lt->def;
1214         int i = lt->pntsu * lt->pntsv * lt->pntsw;
1215
1216         while (i--) {
1217                 mul_m4_v3(mat, bp->vec);
1218                 bp++;
1219         }
1220
1221         if (do_keys && lt->key) {
1222                 KeyBlock *kb;
1223
1224                 for (kb = lt->key->block.first; kb; kb = kb->next) {
1225                         float *fp = kb->data;
1226                         for (i = kb->totelem; i--; fp += 3) {
1227                                 mul_m4_v3(mat, fp);
1228                         }
1229                 }
1230         }
1231 }
1232
1233 void BKE_lattice_translate(Lattice *lt, float offset[3], bool do_keys)
1234 {
1235         int i, numVerts;
1236
1237         numVerts = lt->pntsu * lt->pntsv * lt->pntsw;
1238
1239         if (lt->def)
1240                 for (i = 0; i < numVerts; i++)
1241                         add_v3_v3(lt->def[i].vec, offset);
1242
1243         if (lt->editlatt)
1244                 for (i = 0; i < numVerts; i++)
1245                         add_v3_v3(lt->editlatt->latt->def[i].vec, offset);
1246
1247         if (do_keys && lt->key) {
1248                 KeyBlock *kb;
1249
1250                 for (kb = lt->key->block.first; kb; kb = kb->next) {
1251                         float *fp = kb->data;
1252                         for (i = kb->totelem; i--; fp += 3) {
1253                                 add_v3_v3(fp, offset);
1254                         }
1255                 }
1256         }
1257 }
1258
1259 /* **** Depsgraph evaluation **** */
1260
1261 void BKE_lattice_eval_geometry(EvaluationContext *UNUSED(eval_ctx),
1262                                Lattice *UNUSED(latt))
1263 {
1264 }
1265