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