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