← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

Viewing changes to source/blender/blenkernel/intern/lattice.c

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

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