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