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