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