merge with/from trunk at r35190
[blender.git] / source / blender / modifiers / intern / MOD_explode.c
1 /*
2 * $Id$
3 *
4 * ***** BEGIN GPL LICENSE BLOCK *****
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software  Foundation,
18 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 *
20 * The Original Code is Copyright (C) 2005 by the Blender Foundation.
21 * All rights reserved.
22 *
23 * Contributor(s): Daniel Dunbar
24 *                 Ton Roosendaal,
25 *                 Ben Batt,
26 *                 Brecht Van Lommel,
27 *                 Campbell Barton
28 *
29 * ***** END GPL LICENSE BLOCK *****
30 *
31 */
32
33 /** \file blender/modifiers/intern/MOD_explode.c
34  *  \ingroup modifiers
35  */
36
37
38 #include "DNA_meshdata_types.h"
39 #include "DNA_scene_types.h"
40
41 #include "BLI_kdtree.h"
42 #include "BLI_rand.h"
43 #include "BLI_math.h"
44 #include "BLI_edgehash.h"
45 #include "BLI_utildefines.h"
46
47 #include "BKE_cdderivedmesh.h"
48 #include "BKE_deform.h"
49 #include "BKE_lattice.h"
50 #include "BKE_mesh.h"
51 #include "BKE_modifier.h"
52 #include "BKE_object.h"
53 #include "BKE_particle.h"
54 #include "BKE_scene.h"
55
56
57 #include "MEM_guardedalloc.h"
58
59 #include "MOD_util.h"
60
61 static void initData(ModifierData *md)
62 {
63         ExplodeModifierData *emd= (ExplodeModifierData*) md;
64
65         emd->facepa=0;
66         emd->flag |= eExplodeFlag_Unborn+eExplodeFlag_Alive+eExplodeFlag_Dead;
67 }
68 static void freeData(ModifierData *md)
69 {
70         ExplodeModifierData *emd= (ExplodeModifierData*) md;
71         
72         if(emd->facepa) MEM_freeN(emd->facepa);
73 }
74 static void copyData(ModifierData *md, ModifierData *target)
75 {
76         ExplodeModifierData *emd= (ExplodeModifierData*) md;
77         ExplodeModifierData *temd= (ExplodeModifierData*) target;
78
79         temd->facepa = 0;
80         temd->flag = emd->flag;
81         temd->protect = emd->protect;
82         temd->vgroup = emd->vgroup;
83 }
84 static int dependsOnTime(ModifierData *UNUSED(md)) 
85 {
86         return 1;
87 }
88 static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
89 {
90         ExplodeModifierData *emd= (ExplodeModifierData*) md;
91         CustomDataMask dataMask = 0;
92
93         if(emd->vgroup)
94                 dataMask |= CD_MASK_MDEFORMVERT;
95
96         return dataMask;
97 }
98
99 static void createFacepa(ExplodeModifierData *emd,
100                                                 ParticleSystemModifierData *psmd,
101                                                 DerivedMesh *dm)
102 {
103         ParticleSystem *psys=psmd->psys;
104         MFace *fa=0, *mface=0;
105         MVert *mvert = 0;
106         ParticleData *pa;
107         KDTree *tree;
108         float center[3], co[3];
109         int *facepa=0,*vertpa=0,totvert=0,totface=0,totpart=0;
110         int i,p,v1,v2,v3,v4=0;
111
112         mvert = dm->getVertArray(dm);
113         mface = dm->getTessFaceArray(dm);
114         totface= dm->getNumTessFaces(dm);
115         totvert= dm->getNumVerts(dm);
116         totpart= psmd->psys->totpart;
117
118         BLI_srandom(psys->seed);
119
120         if(emd->facepa)
121                 MEM_freeN(emd->facepa);
122
123         facepa = emd->facepa = MEM_callocN(sizeof(int)*totface, "explode_facepa");
124
125         vertpa = MEM_callocN(sizeof(int)*totvert, "explode_vertpa");
126
127         /* initialize all faces & verts to no particle */
128         for(i=0; i<totface; i++)
129                 facepa[i]=totpart;
130
131         for (i=0; i<totvert; i++)
132                 vertpa[i]=totpart;
133
134         /* set protected verts */
135         if(emd->vgroup){
136                 MDeformVert *dvert = dm->getVertDataArray(dm, CD_MDEFORMVERT);
137                 if(dvert){
138                         const int defgrp_index= emd->vgroup-1;
139                         for(i=0; i<totvert; i++, dvert++){
140                                 float val = BLI_frand();
141                                 val = (1.0f-emd->protect)*val + emd->protect*0.5f;
142                                 if(val < defvert_find_weight(dvert, defgrp_index))
143                                         vertpa[i] = -1;
144                         }
145                 }
146         }
147
148         /* make tree of emitter locations */
149         tree=BLI_kdtree_new(totpart);
150         for(p=0,pa=psys->particles; p<totpart; p++,pa++){
151                 psys_particle_on_dm(psmd->dm,psys->part->from,pa->num,pa->num_dmcache,pa->fuv,pa->foffset,co,0,0,0,0,0);
152                 BLI_kdtree_insert(tree, p, co, NULL);
153         }
154         BLI_kdtree_balance(tree);
155
156         /* set face-particle-indexes to nearest particle to face center */
157         for(i=0,fa=mface; i<totface; i++,fa++){
158                 add_v3_v3v3(center,mvert[fa->v1].co,mvert[fa->v2].co);
159                 add_v3_v3(center, mvert[fa->v3].co);
160                 if(fa->v4){
161                         add_v3_v3(center, mvert[fa->v4].co);
162                         mul_v3_fl(center,0.25);
163                 }
164                 else
165                         mul_v3_fl(center,0.3333f);
166
167                 p= BLI_kdtree_find_nearest(tree,center,NULL,NULL);
168
169                 v1=vertpa[fa->v1];
170                 v2=vertpa[fa->v2];
171                 v3=vertpa[fa->v3];
172                 if(fa->v4)
173                         v4=vertpa[fa->v4];
174
175                 if(v1>=0 && v2>=0 && v3>=0 && (fa->v4==0 || v4>=0))
176                         facepa[i]=p;
177
178                 if(v1>=0) vertpa[fa->v1]=p;
179                 if(v2>=0) vertpa[fa->v2]=p;
180                 if(v3>=0) vertpa[fa->v3]=p;
181                 if(fa->v4 && v4>=0) vertpa[fa->v4]=p;
182         }
183
184         if(vertpa) MEM_freeN(vertpa);
185         BLI_kdtree_free(tree);
186 }
187
188 static int edgecut_get(EdgeHash *edgehash, int v1, int v2)
189 {
190         return GET_INT_FROM_POINTER(BLI_edgehash_lookup(edgehash, v1, v2));
191 }
192
193  
194 const short add_faces[24] = {
195         0,
196         0, 0, 2, 0, 1, 2, 2, 0, 2, 1,
197         2, 2, 2, 2, 3, 0, 0, 0, 1, 0,
198         1, 1, 2
199  };
200
201 MFace *get_dface(DerivedMesh *dm, DerivedMesh *split, int cur, int i, MFace *mf)
202 {
203         MFace *df = CDDM_get_tessface(split, cur);
204         DM_copy_face_data(dm, split, i, cur, 1);
205         *df = *mf;
206         return df;
207 }
208
209 #define SET_VERTS(a, b, c, d) \
210                         v[0]=mf->v##a; uv[0]=a-1; \
211                         v[1]=mf->v##b; uv[1]=b-1; \
212                         v[2]=mf->v##c; uv[2]=c-1; \
213                         v[3]=mf->v##d; uv[3]=d-1;
214
215 #define GET_ES(v1, v2) edgecut_get(eh, v1, v2);
216 #define INT_UV(uvf, c0, c1) interp_v2_v2v2(uvf, mf->uv[c0], mf->uv[c1], 0.5f);
217
218 static void remap_faces_3_6_9_12(DerivedMesh *dm, DerivedMesh *split, MFace *mf, int *facepa, int *vertpa, int i, EdgeHash *eh, int cur, int v1, int v2, int v3, int v4)
219 {
220         MFace *df1 = get_dface(dm, split, cur, i, mf);
221         MFace *df2 = get_dface(dm, split, cur+1, i, mf);
222         MFace *df3 = get_dface(dm, split, cur+2, i, mf);
223
224         facepa[cur] = vertpa[v1];
225         df1->v1 = v1;
226         df1->v2 = GET_ES(v1, v2)
227         df1->v3 = GET_ES(v2, v3)
228         df1->v4 = v3;
229         df1->flag |= ME_FACE_SEL;
230
231         facepa[cur+1] = vertpa[v2];
232         df2->v1 = GET_ES(v1, v2)
233         df2->v2 = v2;
234         df2->v3 = GET_ES(v2, v3)
235         df2->v4 = 0;
236         df2->flag &= ~ME_FACE_SEL;
237
238         facepa[cur+2] = vertpa[v1];
239         df3->v1 = v1;
240         df3->v2 = v3;
241         df3->v3 = v4;
242         df3->v4 = 0;
243         df3->flag &= ~ME_FACE_SEL;
244 }
245
246 static void remap_uvs_3_6_9_12(DerivedMesh *dm, DerivedMesh *split, int numlayer, int i, int cur, int c0, int c1, int c2, int c3)
247 {
248         MTFace *mf, *df1, *df2, *df3;
249         int l;
250
251         for(l=0; l<numlayer; l++) {
252                 mf = CustomData_get_layer_n(&split->faceData, CD_MTFACE, l);
253                 df1 = mf+cur;
254                 df2 = df1 + 1;
255                 df3 = df1 + 2;
256                 mf = CustomData_get_layer_n(&dm->faceData, CD_MTFACE, l);
257                 mf += i;
258
259                 copy_v2_v2(df1->uv[0], mf->uv[c0]);
260                 INT_UV(df1->uv[1], c0, c1)
261                 INT_UV(df1->uv[2], c1, c2)
262                 copy_v2_v2(df1->uv[3], mf->uv[c2]);
263
264                 INT_UV(df2->uv[0], c0, c1)
265                 copy_v2_v2(df2->uv[1], mf->uv[c1]);
266                 INT_UV(df2->uv[2], c1, c2)
267
268                 copy_v2_v2(df3->uv[0], mf->uv[c0]);
269                 copy_v2_v2(df3->uv[1], mf->uv[c2]);
270                 copy_v2_v2(df3->uv[2], mf->uv[c3]);
271         }
272 }
273
274 static void remap_faces_5_10(DerivedMesh *dm, DerivedMesh *split, MFace *mf, int *facepa, int *vertpa, int i, EdgeHash *eh, int cur, int v1, int v2, int v3, int v4)
275 {
276         MFace *df1 = get_dface(dm, split, cur, i, mf);
277         MFace *df2 = get_dface(dm, split, cur+1, i, mf);
278
279         facepa[cur] = vertpa[v1];
280         df1->v1 = v1;
281         df1->v2 = v2;
282         df1->v3 = GET_ES(v2, v3)
283         df1->v4 = GET_ES(v1, v4)
284         df1->flag |= ME_FACE_SEL;
285
286         facepa[cur+1] = vertpa[v3];
287         df2->v1 = GET_ES(v1, v4)
288         df2->v2 = GET_ES(v2, v3)
289         df2->v3 = v3;
290         df2->v4 = v4;
291         df2->flag |= ME_FACE_SEL;
292 }
293
294 static void remap_uvs_5_10(DerivedMesh *dm, DerivedMesh *split, int numlayer, int i, int cur, int c0, int c1, int c2, int c3)
295 {
296         MTFace *mf, *df1, *df2;
297         int l;
298
299         for(l=0; l<numlayer; l++) {
300                 mf = CustomData_get_layer_n(&split->faceData, CD_MTFACE, l);
301                 df1 = mf+cur;
302                 df2 = df1 + 1;
303                 mf = CustomData_get_layer_n(&dm->faceData, CD_MTFACE, l);
304                 mf += i;
305
306                 copy_v2_v2(df1->uv[0], mf->uv[c0]);
307                 copy_v2_v2(df1->uv[1], mf->uv[c1]);
308                 INT_UV(df1->uv[2], c1, c2)
309                 INT_UV(df1->uv[3], c0, c3)
310
311                 INT_UV(df2->uv[0], c0, c3)
312                 INT_UV(df2->uv[1], c1, c2)
313                 copy_v2_v2(df2->uv[2], mf->uv[c2]);
314                 copy_v2_v2(df2->uv[3], mf->uv[c3]);
315
316         }
317 }
318
319 static void remap_faces_15(DerivedMesh *dm, DerivedMesh *split, MFace *mf, int *facepa, int *vertpa, int i, EdgeHash *eh, int cur, int v1, int v2, int v3, int v4)
320 {
321         MFace *df1 = get_dface(dm, split, cur, i, mf);
322         MFace *df2 = get_dface(dm, split, cur+1, i, mf);
323         MFace *df3 = get_dface(dm, split, cur+2, i, mf);
324         MFace *df4 = get_dface(dm, split, cur+3, i, mf);
325
326         facepa[cur] = vertpa[v1];
327         df1->v1 = v1;
328         df1->v2 = GET_ES(v1, v2)
329         df1->v3 = GET_ES(v1, v3)
330         df1->v4 = GET_ES(v1, v4)
331         df1->flag |= ME_FACE_SEL;
332
333         facepa[cur+1] = vertpa[v2];
334         df2->v1 = GET_ES(v1, v2)
335         df2->v2 = v2;
336         df2->v3 = GET_ES(v2, v3)
337         df2->v4 = GET_ES(v1, v3)
338         df2->flag |= ME_FACE_SEL;
339
340         facepa[cur+2] = vertpa[v3];
341         df3->v1 = GET_ES(v1, v3)
342         df3->v2 = GET_ES(v2, v3)
343         df3->v3 = v3;
344         df3->v4 = GET_ES(v3, v4)
345         df3->flag |= ME_FACE_SEL;
346
347         facepa[cur+3] = vertpa[v4];
348         df4->v1 = GET_ES(v1, v4)
349         df4->v2 = GET_ES(v1, v3)
350         df4->v3 = GET_ES(v3, v4)
351         df4->v4 = v4;
352         df4->flag |= ME_FACE_SEL;
353 }
354
355 static void remap_uvs_15(DerivedMesh *dm, DerivedMesh *split, int numlayer, int i, int cur, int c0, int c1, int c2, int c3)
356 {
357         MTFace *mf, *df1, *df2, *df3, *df4;
358         int l;
359
360         for(l=0; l<numlayer; l++) {
361                 mf = CustomData_get_layer_n(&split->faceData, CD_MTFACE, l);
362                 df1 = mf+cur;
363                 df2 = df1 + 1;
364                 df3 = df1 + 2;
365                 df4 = df1 + 3;
366                 mf = CustomData_get_layer_n(&dm->faceData, CD_MTFACE, l);
367                 mf += i;
368
369                 copy_v2_v2(df1->uv[0], mf->uv[c0]);
370                 INT_UV(df1->uv[1], c0, c1)
371                 INT_UV(df1->uv[2], c0, c2)
372                 INT_UV(df1->uv[3], c0, c3)
373
374                 INT_UV(df2->uv[0], c0, c1)
375                 copy_v2_v2(df2->uv[1], mf->uv[c1]);
376                 INT_UV(df2->uv[2], c1, c2)
377                 INT_UV(df2->uv[3], c0, c2)
378
379                 INT_UV(df3->uv[0], c0, c2)
380                 INT_UV(df3->uv[1], c1, c2)
381                 copy_v2_v2(df3->uv[2], mf->uv[c2]);
382                 INT_UV(df3->uv[3], c2, c3)
383
384                 INT_UV(df4->uv[0], c0, c3)
385                 INT_UV(df4->uv[1], c0, c2)
386                 INT_UV(df4->uv[2], c2, c3)
387                 copy_v2_v2(df4->uv[3], mf->uv[c3]);
388         }
389 }
390
391 static void remap_faces_7_11_13_14(DerivedMesh *dm, DerivedMesh *split, MFace *mf, int *facepa, int *vertpa, int i, EdgeHash *eh, int cur, int v1, int v2, int v3, int v4)
392 {
393         MFace *df1 = get_dface(dm, split, cur, i, mf);
394         MFace *df2 = get_dface(dm, split, cur+1, i, mf);
395         MFace *df3 = get_dface(dm, split, cur+2, i, mf);
396
397         facepa[cur] = vertpa[v1];
398         df1->v1 = v1;
399         df1->v2 = GET_ES(v1, v2)
400         df1->v3 = GET_ES(v2, v3)
401         df1->v4 = GET_ES(v1, v4)
402         df1->flag |= ME_FACE_SEL;
403
404         facepa[cur+1] = vertpa[v2];
405         df2->v1 = GET_ES(v1, v2)
406         df2->v2 = v2;
407         df2->v3 = GET_ES(v2, v3)
408         df2->v4 = 0;
409         df2->flag &= ~ME_FACE_SEL;
410
411         facepa[cur+2] = vertpa[v4];
412         df3->v1 = GET_ES(v1, v4)
413         df3->v2 = GET_ES(v2, v3)
414         df3->v3 = v3;
415         df3->v4 = v4;
416         df3->flag |= ME_FACE_SEL;
417 }
418
419 static void remap_uvs_7_11_13_14(DerivedMesh *dm, DerivedMesh *split, int numlayer, int i, int cur, int c0, int c1, int c2, int c3)
420 {
421         MTFace *mf, *df1, *df2, *df3;
422         int l;
423
424         for(l=0; l<numlayer; l++) {
425                 mf = CustomData_get_layer_n(&split->faceData, CD_MTFACE, l);
426                 df1 = mf+cur;
427                 df2 = df1 + 1;
428                 df3 = df1 + 2;
429                 mf = CustomData_get_layer_n(&dm->faceData, CD_MTFACE, l);
430                 mf += i;
431
432                 copy_v2_v2(df1->uv[0], mf->uv[c0]);
433                 INT_UV(df1->uv[1], c0, c1)
434                 INT_UV(df1->uv[2], c1, c2)
435                 INT_UV(df1->uv[3], c0, c3)
436
437                 INT_UV(df2->uv[0], c0, c1)
438                 copy_v2_v2(df2->uv[1], mf->uv[c1]);
439                 INT_UV(df2->uv[2], c1, c2)
440
441                 INT_UV(df3->uv[0], c0, c3)
442                 INT_UV(df3->uv[1], c1, c2)
443                 copy_v2_v2(df3->uv[2], mf->uv[c2]);
444                 copy_v2_v2(df3->uv[3], mf->uv[c3]);
445         }
446 }
447
448 static void remap_faces_19_21_22(DerivedMesh *dm, DerivedMesh *split, MFace *mf, int *facepa, int *vertpa, int i, EdgeHash *eh, int cur, int v1, int v2, int v3)
449 {
450         MFace *df1 = get_dface(dm, split, cur, i, mf);
451         MFace *df2 = get_dface(dm, split, cur+1, i, mf);
452
453         facepa[cur] = vertpa[v1];
454         df1->v1 = v1;
455         df1->v2 = GET_ES(v1, v2)
456         df1->v3 = GET_ES(v1, v3)
457         df1->v4 = 0;
458         df1->flag &= ~ME_FACE_SEL;
459
460         facepa[cur+1] = vertpa[v2];
461         df2->v1 = GET_ES(v1, v2)
462         df2->v2 = v2;
463         df2->v3 = v3;
464         df2->v4 = GET_ES(v1, v3)
465         df2->flag |= ME_FACE_SEL;
466 }
467
468 static void remap_uvs_19_21_22(DerivedMesh *dm, DerivedMesh *split, int numlayer, int i, int cur, int c0, int c1, int c2)
469 {
470         MTFace *mf, *df1, *df2;
471         int l;
472
473         for(l=0; l<numlayer; l++) {
474                 mf = CustomData_get_layer_n(&split->faceData, CD_MTFACE, l);
475                 df1 = mf+cur;
476                 df2 = df1 + 1;
477                 mf = CustomData_get_layer_n(&dm->faceData, CD_MTFACE, l);
478                 mf += i;
479
480                 copy_v2_v2(df1->uv[0], mf->uv[c0]);
481                 INT_UV(df1->uv[1], c0, c1)
482                 INT_UV(df1->uv[2], c0, c2)
483
484                 INT_UV(df2->uv[0], c0, c1)
485                 copy_v2_v2(df2->uv[1], mf->uv[c1]);
486                 copy_v2_v2(df2->uv[2], mf->uv[c2]);
487                 INT_UV(df2->uv[3], c0, c2)
488         }
489 }
490
491 static void remap_faces_23(DerivedMesh *dm, DerivedMesh *split, MFace *mf, int *facepa, int *vertpa, int i, EdgeHash *eh, int cur, int v1, int v2, int v3)
492 {
493         MFace *df1 = get_dface(dm, split, cur, i, mf);
494         MFace *df2 = get_dface(dm, split, cur+1, i, mf);
495         MFace *df3 = get_dface(dm, split, cur+2, i, mf);
496
497         facepa[cur] = vertpa[v1];
498         df1->v1 = v1;
499         df1->v2 = GET_ES(v1, v2)
500         df1->v3 = GET_ES(v2, v3)
501         df1->v4 = GET_ES(v1, v3)
502         df1->flag |= ME_FACE_SEL;
503
504         facepa[cur+1] = vertpa[v2];
505         df2->v1 = GET_ES(v1, v2)
506         df2->v2 = v2;
507         df2->v3 = GET_ES(v2, v3)
508         df2->v4 = 0;
509         df2->flag &= ~ME_FACE_SEL;
510
511         facepa[cur+2] = vertpa[v3];
512         df3->v1 = GET_ES(v1, v3)
513         df3->v2 = GET_ES(v2, v3)
514         df3->v3 = v3;
515         df3->v4 = 0;
516         df3->flag &= ~ME_FACE_SEL;
517 }
518
519 static void remap_uvs_23(DerivedMesh *dm, DerivedMesh *split, int numlayer, int i, int cur, int c0, int c1, int c2)
520 {
521         MTFace *mf, *df1, *df2, *df3;
522         int l;
523
524         for(l=0; l<numlayer; l++) {
525                 mf = CustomData_get_layer_n(&split->faceData, CD_MTFACE, l);
526                 df1 = mf+cur;
527                 df2 = df1 + 1;
528                 df3 = df1 + 2;
529                 mf = CustomData_get_layer_n(&dm->faceData, CD_MTFACE, l);
530                 mf += i;
531
532                 copy_v2_v2(df1->uv[0], mf->uv[c0]);
533                 INT_UV(df1->uv[1], c0, c1)
534                 INT_UV(df1->uv[2], c1, c2)
535                 INT_UV(df1->uv[3], c0, c2)
536
537                 INT_UV(df2->uv[0], c0, c1)
538                 copy_v2_v2(df2->uv[1], mf->uv[c1]);
539                 INT_UV(df2->uv[2], c1, c2)
540
541                 INT_UV(df2->uv[0], c0, c2)
542                 INT_UV(df2->uv[1], c1, c2)
543                 copy_v2_v2(df2->uv[2], mf->uv[c2]);
544         }
545 }
546
547 static DerivedMesh * cutEdges(ExplodeModifierData *emd, DerivedMesh *dm){
548         DerivedMesh *splitdm;
549         MFace *mf=NULL,*df1=NULL;
550         MFace *mface=dm->getTessFaceArray(dm);
551         MVert *dupve, *mv;
552         EdgeHash *edgehash;
553         EdgeHashIterator *ehi;
554         int totvert=dm->getNumVerts(dm);
555         int totface=dm->getNumTessFaces(dm);
556
557         int *facesplit = MEM_callocN(sizeof(int)*totface,"explode_facesplit");
558         int *vertpa = MEM_callocN(sizeof(int)*totvert,"explode_vertpa2");
559         int *facepa = emd->facepa;
560         int *fs, totesplit=0,totfsplit=0,curdupface=0;
561         int i,j,v1,v2,v3,v4,esplit, v[4], uv[4];
562         int numlayer;
563
564         edgehash= BLI_edgehash_new();
565
566         /* recreate vertpa from facepa calculation */
567         for (i=0,mf=mface; i<totface; i++,mf++) {
568                 vertpa[mf->v1]=facepa[i];
569                 vertpa[mf->v2]=facepa[i];
570                 vertpa[mf->v3]=facepa[i];
571                 if(mf->v4)
572                         vertpa[mf->v4]=facepa[i];
573         }
574
575         /* mark edges for splitting and how to split faces */
576         for (i=0,mf=mface,fs=facesplit; i<totface; i++,mf++,fs++) {
577                 v1=vertpa[mf->v1];
578                 v2=vertpa[mf->v2];
579                 v3=vertpa[mf->v3];
580
581                 if(v1!=v2){
582                         BLI_edgehash_insert(edgehash, mf->v1, mf->v2, NULL);
583                         (*fs) |= 1;
584                 }
585
586                 if(v2!=v3){
587                         BLI_edgehash_insert(edgehash, mf->v2, mf->v3, NULL);
588                         (*fs) |= 2;
589                 }
590
591                 if(mf->v4){
592                         v4=vertpa[mf->v4];
593
594                         if(v3!=v4){
595                                 BLI_edgehash_insert(edgehash, mf->v3, mf->v4, NULL);
596                                 (*fs) |= 4;
597                         }
598
599                         if(v1!=v4){
600                                 BLI_edgehash_insert(edgehash, mf->v1, mf->v4, NULL);
601                                 (*fs) |= 8;
602                         }
603
604                         /* mark center vertex as a fake edge split */
605                         if(*fs == 15)
606                                 BLI_edgehash_insert(edgehash, mf->v1, mf->v3, NULL);
607                 }
608                 else {
609                         (*fs) |= 16; /* mark face as tri */
610
611                         if(v1!=v3){
612                                 BLI_edgehash_insert(edgehash, mf->v1, mf->v3, NULL);
613                                 (*fs) |= 4;
614                         }
615                 }
616         }
617
618         /* count splits & create indexes for new verts */
619         ehi= BLI_edgehashIterator_new(edgehash);
620         totesplit=totvert;
621         for(; !BLI_edgehashIterator_isDone(ehi); BLI_edgehashIterator_step(ehi)) {
622                 BLI_edgehashIterator_setValue(ehi, SET_INT_IN_POINTER(totesplit));
623                 totesplit++;
624         }
625         BLI_edgehashIterator_free(ehi);
626
627         /* count new faces due to splitting */
628         for(i=0,fs=facesplit; i<totface; i++,fs++)
629                 totfsplit += add_faces[*fs];
630         
631         splitdm= CDDM_from_template(dm, totesplit, 0, totface+totfsplit, 0, 0);
632         numlayer = CustomData_number_of_layers(&splitdm->faceData, CD_MTFACE);
633
634         /* copy new faces & verts (is it really this painful with custom data??) */
635         for(i=0; i<totvert; i++){
636                 MVert source;
637                 MVert *dest;
638                 dm->getVert(dm, i, &source);
639                 dest = CDDM_get_vert(splitdm, i);
640
641                 DM_copy_vert_data(dm, splitdm, i, i, 1);
642                 *dest = source;
643         }
644
645         /* override original facepa (original pointer is saved in caller function) */
646         facepa= MEM_callocN(sizeof(int)*(totface+totfsplit),"explode_facepa");
647         //memcpy(facepa,emd->facepa,totface*sizeof(int));
648         emd->facepa=facepa;
649
650         /* create new verts */
651         ehi= BLI_edgehashIterator_new(edgehash);
652         for(; !BLI_edgehashIterator_isDone(ehi); BLI_edgehashIterator_step(ehi)) {
653                 BLI_edgehashIterator_getKey(ehi, &i, &j);
654                 esplit= GET_INT_FROM_POINTER(BLI_edgehashIterator_getValue(ehi));
655                 mv=CDDM_get_vert(splitdm,j);
656                 dupve=CDDM_get_vert(splitdm,esplit);
657
658                 DM_copy_vert_data(splitdm,splitdm,j,esplit,1);
659
660                 *dupve=*mv;
661
662                 mv=CDDM_get_vert(splitdm,i);
663
664                 add_v3_v3(dupve->co, mv->co);
665                 mul_v3_fl(dupve->co, 0.5f);
666         }
667         BLI_edgehashIterator_free(ehi);
668
669         /* create new faces */
670         curdupface=0;//=totface;
671         //curdupin=totesplit;
672         for(i=0,fs=facesplit; i<totface; i++,fs++){
673                 mf = dm->getTessFaceData(dm, i, CD_MFACE);
674
675                 switch(*fs) {
676                 case 3:
677                 case 10:
678                 case 11:
679                 case 15:
680                         SET_VERTS(1, 2, 3, 4)
681                         break;
682                 case 5:
683                 case 6:
684                 case 7:
685                         SET_VERTS(2, 3, 4, 1)
686                         break;
687                 case 9:
688                 case 13:
689                         SET_VERTS(4, 1, 2, 3)
690                         break;
691                 case 12:
692                 case 14:
693                         SET_VERTS(3, 4, 1, 2)
694                         break;
695                 case 21:
696                 case 23:
697                         SET_VERTS(1, 2, 3, 4)
698                         break;
699                 case 19:
700                         SET_VERTS(2, 3, 1, 4)
701                         break;
702                 case 22:
703                         SET_VERTS(3, 1, 2, 4)
704                         break;
705                 }
706
707                 switch(*fs) {
708                 case 3:
709                 case 6:
710                 case 9:
711                 case 12:
712                         remap_faces_3_6_9_12(dm, splitdm, mf, facepa, vertpa, i, edgehash, curdupface, v[0], v[1], v[2], v[3]);
713                         if(numlayer)
714                                 remap_uvs_3_6_9_12(dm, splitdm, numlayer, i, curdupface, uv[0], uv[1], uv[2], uv[3]);
715                         break;
716                 case 5:
717                 case 10:
718                         remap_faces_5_10(dm, splitdm, mf, facepa, vertpa, i, edgehash, curdupface, v[0], v[1], v[2], v[3]);
719                         if(numlayer)
720                                 remap_uvs_5_10(dm, splitdm, numlayer, i, curdupface, uv[0], uv[1], uv[2], uv[3]);
721                         break;
722                 case 15:
723                         remap_faces_15(dm, splitdm, mf, facepa, vertpa, i, edgehash, curdupface, v[0], v[1], v[2], v[3]);
724                         if(numlayer)
725                                 remap_uvs_15(dm, splitdm, numlayer, i, curdupface, uv[0], uv[1], uv[2], uv[3]);
726                         break;
727                 case 7:
728                 case 11:
729                 case 13:
730                 case 14:
731                         remap_faces_7_11_13_14(dm, splitdm, mf, facepa, vertpa, i, edgehash, curdupface, v[0], v[1], v[2], v[3]);
732                         if(numlayer)
733                                 remap_uvs_7_11_13_14(dm, splitdm, numlayer, i, curdupface, uv[0], uv[1], uv[2], uv[3]);
734                         break;
735                 case 19:
736                 case 21:
737                 case 22:
738                         remap_faces_19_21_22(dm, splitdm, mf, facepa, vertpa, i, edgehash, curdupface, v[0], v[1], v[2]);
739                         if(numlayer)
740                                 remap_uvs_19_21_22(dm, splitdm, numlayer, i, curdupface, uv[0], uv[1], uv[2]);
741                         break;
742                 case 23:
743                         remap_faces_23(dm, splitdm, mf, facepa, vertpa, i, edgehash, curdupface, v[0], v[1], v[2]);
744                         if(numlayer)
745                                 remap_uvs_23(dm, splitdm, numlayer, i, curdupface, uv[0], uv[1], uv[2]);
746                         break;
747                 case 0:
748                 case 16:
749                         df1 = get_dface(dm, splitdm, curdupface, i, mf);
750                         facepa[curdupface] = vertpa[mf->v1];
751
752                         if(df1->v4)
753                                 df1->flag |= ME_FACE_SEL;
754                         else
755                                 df1->flag &= ~ME_FACE_SEL;
756                         break;
757                 }
758
759                 curdupface += add_faces[*fs]+1;
760         }
761
762         for(i=0; i<curdupface; i++) {
763                 mf = CDDM_get_tessface(splitdm, i);
764                 test_index_face(mf, &splitdm->faceData, i, (mf->flag & ME_FACE_SEL ? 4 : 3));
765         }
766
767         BLI_edgehash_free(edgehash, NULL);
768         MEM_freeN(facesplit);
769         MEM_freeN(vertpa);
770
771         dm = CDDM_copy(splitdm, 1); /*builds ngon faces from tess (mface) faces*/
772         splitdm->needsFree = 1;
773         splitdm->release(splitdm);
774
775         return dm;
776 }
777 static DerivedMesh * explodeMesh(ExplodeModifierData *emd, 
778                 ParticleSystemModifierData *psmd, Scene *scene, Object *ob, 
779   DerivedMesh *to_explode)
780 {
781         DerivedMesh *explode, *dm=to_explode;
782         MFace *mf=0, *mface;
783         ParticleSettings *part=psmd->psys->part;
784         ParticleSimulationData sim= {0};
785         ParticleData *pa=NULL, *pars=psmd->psys->particles;
786         ParticleKey state;
787         EdgeHash *vertpahash;
788         EdgeHashIterator *ehi;
789         float *vertco=0, imat[4][4];
790         float loc0[3], nor[3];
791         float cfra;
792         /* float timestep; */
793         int *facepa=emd->facepa;
794         int totdup=0,totvert=0,totface=0,totpart=0;
795         int i, j, v, mindex=0;
796         MTFace *mtface = NULL, *mtf;
797
798         totface= dm->getNumTessFaces(dm);
799         totvert= dm->getNumVerts(dm);
800         mface= dm->getTessFaceArray(dm);
801         totpart= psmd->psys->totpart;
802
803         sim.scene= scene;
804         sim.ob= ob;
805         sim.psys= psmd->psys;
806         sim.psmd= psmd;
807
808         /* timestep= psys_get_timestep(&sim); */
809
810         //if(part->flag & PART_GLOB_TIME)
811                 cfra= BKE_curframe(scene);
812         //else
813         //      cfra=bsystem_time(scene, ob,(float)scene->r.cfra,0.0);
814
815         /* hash table for vertice <-> particle relations */
816         vertpahash= BLI_edgehash_new();
817
818         for (i=0; i<totface; i++) {
819                 /* do mindex + totvert to ensure the vertex index to be the first
820                  * with BLI_edgehashIterator_getKey */
821                 if(facepa[i]==totpart || cfra <= (pars+facepa[i])->time)
822                         mindex = totvert+totpart;
823                 else 
824                         mindex = totvert+facepa[i];
825
826                 mf= &mface[i];
827
828                 /* set face vertices to exist in particle group */
829                 BLI_edgehash_insert(vertpahash, mf->v1, mindex, NULL);
830                 BLI_edgehash_insert(vertpahash, mf->v2, mindex, NULL);
831                 BLI_edgehash_insert(vertpahash, mf->v3, mindex, NULL);
832                 if(mf->v4)
833                         BLI_edgehash_insert(vertpahash, mf->v4, mindex, NULL);
834         }
835
836         /* make new vertice indexes & count total vertices after duplication */
837         ehi= BLI_edgehashIterator_new(vertpahash);
838         for(; !BLI_edgehashIterator_isDone(ehi); BLI_edgehashIterator_step(ehi)) {
839                 BLI_edgehashIterator_setValue(ehi, SET_INT_IN_POINTER(totdup));
840                 totdup++;
841         }
842         BLI_edgehashIterator_free(ehi);
843
844         /* the final duplicated vertices */
845         explode= CDDM_from_template(dm, totdup, 0,totface, 0, 0);
846         mtface = CustomData_get_layer_named(&explode->faceData, CD_MTFACE, emd->uvname);
847         /*dupvert= CDDM_get_verts(explode);*/
848
849         /* getting back to object space */
850         invert_m4_m4(imat,ob->obmat);
851
852         psmd->psys->lattice = psys_get_lattice(&sim);
853
854         /* duplicate & displace vertices */
855         ehi= BLI_edgehashIterator_new(vertpahash);
856         for(; !BLI_edgehashIterator_isDone(ehi); BLI_edgehashIterator_step(ehi)) {
857                 MVert source;
858                 MVert *dest;
859
860                 /* get particle + vertex from hash */
861                 BLI_edgehashIterator_getKey(ehi, &j, &i);
862                 i -= totvert;
863                 v= GET_INT_FROM_POINTER(BLI_edgehashIterator_getValue(ehi));
864
865                 dm->getVert(dm, j, &source);
866                 dest = CDDM_get_vert(explode,v);
867
868                 DM_copy_vert_data(dm,explode,j,v,1);
869                 *dest = source;
870
871                 if(i!=totpart) {
872                         /* get particle */
873                         pa= pars+i;
874
875                         /* get particle state */
876                         psys_particle_on_emitter(psmd,part->from,pa->num,pa->num_dmcache,pa->fuv,pa->foffset,loc0,nor,0,0,0,0);
877                         mul_m4_v3(ob->obmat,loc0);
878
879                         state.time=cfra;
880                         psys_get_particle_state(&sim, i, &state, 1);
881
882                         vertco=CDDM_get_vert(explode,v)->co;
883                         
884                         mul_m4_v3(ob->obmat,vertco);
885
886                         VECSUB(vertco,vertco,loc0);
887
888                         /* apply rotation, size & location */
889                         mul_qt_v3(state.rot,vertco);
890                         if(emd->flag & eExplodeFlag_PaSize)
891                                 mul_v3_fl(vertco,pa->size);
892                         VECADD(vertco,vertco,state.co);
893
894                         mul_m4_v3(imat,vertco);
895                 }
896         }
897         BLI_edgehashIterator_free(ehi);
898
899         /*map new vertices to faces*/
900         for (i=0; i<totface; i++) {
901                 MFace source;
902                 int orig_v4;
903
904                 if(facepa[i]!=totpart)
905                 {
906                         pa=pars+facepa[i];
907
908                         if(pa->alive==PARS_UNBORN && (emd->flag&eExplodeFlag_Unborn)==0) continue;
909                         if(pa->alive==PARS_ALIVE && (emd->flag&eExplodeFlag_Alive)==0) continue;
910                         if(pa->alive==PARS_DEAD && (emd->flag&eExplodeFlag_Dead)==0) continue;
911                 }
912
913                 dm->getTessFace(dm,i,&source);
914                 mf=CDDM_get_tessface(explode,i);
915                 
916                 orig_v4 = source.v4;
917
918                 if(facepa[i]!=totpart && cfra <= pa->time)
919                         mindex = totvert+totpart;
920                 else 
921                         mindex = totvert+facepa[i];
922
923                 source.v1 = edgecut_get(vertpahash, source.v1, mindex);
924                 source.v2 = edgecut_get(vertpahash, source.v2, mindex);
925                 source.v3 = edgecut_get(vertpahash, source.v3, mindex);
926                 if(source.v4)
927                         source.v4 = edgecut_get(vertpahash, source.v4, mindex);
928
929                 DM_copy_face_data(dm,explode,i,i,1);
930
931                 *mf = source;
932
933                 /* override uv channel for particle age */
934                 if(mtface) {
935                         float age = (cfra - pa->time)/pa->lifetime;
936                         /* Clamp to this range to avoid flipping to the other side of the coordinates. */
937                         CLAMP(age, 0.001f, 0.999f);
938
939                         mtf = mtface + i;
940
941                         mtf->uv[0][0] = mtf->uv[1][0] = mtf->uv[2][0] = mtf->uv[3][0] = age;
942                         mtf->uv[0][1] = mtf->uv[1][1] = mtf->uv[2][1] = mtf->uv[3][1] = 0.5f;
943                 }
944
945                 test_index_face(mf, &explode->faceData, i, (orig_v4 ? 4 : 3));
946         }
947
948         /* cleanup */
949         BLI_edgehash_free(vertpahash, NULL);
950
951         /* finalization */
952         CDDM_calc_edges(explode);
953         CDDM_calc_normals(explode);
954
955         if(psmd->psys->lattice){
956                 end_latt_deform(psmd->psys->lattice);
957                 psmd->psys->lattice= NULL;
958         }
959
960         dm = CDDM_copy(explode, 1); /*builds ngon faces from tess (mface) faces*/
961         explode->needsFree = 1;
962         explode->release(explode);
963
964         return explode;
965 }
966
967 static ParticleSystemModifierData * findPrecedingParticlesystem(Object *ob, ModifierData *emd)
968 {
969         ModifierData *md;
970         ParticleSystemModifierData *psmd=0;
971
972         for (md=ob->modifiers.first; emd!=md; md=md->next){
973                 if(md->type==eModifierType_ParticleSystem)
974                         psmd= (ParticleSystemModifierData*) md;
975         }
976         return psmd;
977 }
978 static DerivedMesh * applyModifier(ModifierData *md, Object *ob,
979                                                 DerivedMesh *derivedData,
980                                                 int UNUSED(useRenderParams),
981                                                 int UNUSED(isFinalCalc))
982 {
983         DerivedMesh *dm = derivedData;
984         ExplodeModifierData *emd= (ExplodeModifierData*) md;
985         ParticleSystemModifierData *psmd=findPrecedingParticlesystem(ob,md);
986
987         if(psmd){
988                 ParticleSystem * psys=psmd->psys;
989
990                 if(psys==0 || psys->totpart==0) return derivedData;
991                 if(psys->part==0 || psys->particles==0) return derivedData;
992                 if(psmd->dm==0) return derivedData;
993
994                 /* 1. find faces to be exploded if needed */
995                 if(emd->facepa==0
996                                  || psmd->flag&eParticleSystemFlag_Pars
997                                  || emd->flag&eExplodeFlag_CalcFaces
998                                  || MEM_allocN_len(emd->facepa)/sizeof(int) != dm->getNumTessFaces(dm))
999                 {
1000                         if(psmd->flag & eParticleSystemFlag_Pars)
1001                                 psmd->flag &= ~eParticleSystemFlag_Pars;
1002                         
1003                         if(emd->flag & eExplodeFlag_CalcFaces)
1004                                 emd->flag &= ~eExplodeFlag_CalcFaces;
1005
1006                         createFacepa(emd,psmd,derivedData);
1007                 }
1008                                  /* 2. create new mesh */
1009                                  if(emd->flag & eExplodeFlag_EdgeCut){
1010                                          int *facepa = emd->facepa;
1011                                          DerivedMesh *splitdm=cutEdges(emd,dm);
1012                                          DerivedMesh *explode=explodeMesh(emd, psmd, md->scene, ob, splitdm);
1013
1014                                          MEM_freeN(emd->facepa);
1015                                          emd->facepa=facepa;
1016                                          splitdm->release(splitdm);
1017                                          return explode;
1018                                  }
1019                                  else
1020                                          return explodeMesh(emd, psmd, md->scene, ob, derivedData);
1021         }
1022         return derivedData;
1023 }
1024
1025
1026 ModifierTypeInfo modifierType_Explode = {
1027         /* name */              "Explode",
1028         /* structName */        "ExplodeModifierData",
1029         /* structSize */        sizeof(ExplodeModifierData),
1030         /* type */              eModifierTypeType_Nonconstructive,
1031         /* flags */             eModifierTypeFlag_AcceptsMesh,
1032         /* copyData */          copyData,
1033         /* deformVerts */       0,
1034         /* deformMatrices */    0,
1035         /* deformVertsEM */     0,
1036         /* deformMatricesEM */  0,
1037         /* applyModifier */     applyModifier,
1038         /* applyModifierEM */   0,
1039         /* initData */          initData,
1040         /* requiredDataMask */  requiredDataMask,
1041         /* freeData */          freeData,
1042         /* isDisabled */        0,
1043         /* updateDepgraph */    0,
1044         /* dependsOnTime */     dependsOnTime,
1045         /* dependsOnNormals */  0,
1046         /* foreachObjectLink */ 0,
1047         /* foreachIDLink */     0,
1048 };