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