New: load cached data on file load; Fixed: Don't destroy cache on fileload, calculate...
[blender.git] / source / blender / blenkernel / intern / cloth.c
1 /*  cloth.c
2 *
3 *
4 * ***** BEGIN GPL/BL DUAL 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. The Blender
10 * Foundation also sells licenses for use in proprietary software under
11 * the Blender License.  See http://www.blender.org/BL/ for information
12 * about this.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software Foundation,
21 * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22 *
23 * The Original Code is Copyright (C) Blender Foundation
24 * All rights reserved.
25 *
26 * The Original Code is: all of this file.
27 *
28 * Contributor(s): none yet.
29 *
30 * ***** END GPL/BL DUAL LICENSE BLOCK *****
31 */
32
33
34 #include <math.h>
35 #include <stdlib.h>
36 #include <string.h>
37
38 #include "MEM_guardedalloc.h"
39
40 /* types */
41 #include "DNA_curve_types.h"
42 #include "DNA_object_types.h"
43 #include "DNA_object_force.h"
44 #include "DNA_cloth_types.h"
45 #include "DNA_key_types.h"
46 #include "DNA_mesh_types.h"
47 #include "DNA_meshdata_types.h"
48 #include "DNA_lattice_types.h"
49 #include "DNA_scene_types.h"
50 #include "DNA_modifier_types.h"
51
52 #include "BLI_blenlib.h"
53 #include "BLI_arithb.h"
54 #include "BLI_edgehash.h"
55 #include "BLI_linklist.h"
56
57 #include "BKE_curve.h"
58 #include "BKE_deform.h"
59 #include "BKE_DerivedMesh.h"
60 #include "BKE_cdderivedmesh.h"
61 #include "BKE_displist.h"
62 #include "BKE_effect.h"
63 #include "BKE_global.h"
64 #include "BKE_key.h"
65 #include "BKE_mesh.h"
66 #include "BKE_object.h"
67 #include "BKE_cloth.h"
68 #include "BKE_modifier.h"
69 #include "BKE_utildefines.h"
70 #include "BKE_DerivedMesh.h"
71 #include "BIF_editdeform.h"
72 #include "BIF_editkey.h"
73 #include "DNA_screen_types.h"
74 #include "BSE_headerbuttons.h"
75 #include "BIF_screen.h"
76 #include "BIF_space.h"
77 #include "mydevice.h"
78
79 #include "BKE_pointcache.h"
80
81 #ifdef _WIN32
82 void tstart ( void )
83 {}
84 void tend ( void )
85 {
86 }
87 double tval()
88 {
89         return 0;
90 }
91 #else
92 #include <sys/time.h>
93 static struct timeval _tstart, _tend;
94 static struct timezone tz;
95 void tstart ( void )
96 {
97         gettimeofday ( &_tstart, &tz );
98 }
99 void tend ( void )
100 {
101         gettimeofday ( &_tend,&tz );
102 }
103 double tval()
104 {
105         double t1, t2;
106         t1 = ( double ) _tstart.tv_sec + ( double ) _tstart.tv_usec/ ( 1000*1000 );
107         t2 = ( double ) _tend.tv_sec + ( double ) _tend.tv_usec/ ( 1000*1000 );
108         return t2-t1;
109 }
110 #endif
111
112 /* Our available solvers. */
113 // 255 is the magic reserved number, so NEVER try to put 255 solvers in here!
114 // 254 = MAX!
115 static CM_SOLVER_DEF    solvers [] =
116     {
117         { "Implicit", CM_IMPLICIT, implicit_init, implicit_solver, implicit_free },
118         // { "Implicit C++", CM_IMPLICITCPP, implicitcpp_init, implicitcpp_solver, implicitcpp_free },
119     };
120
121 /* ********** cloth engine ******* */
122 /* Prototypes for internal functions.
123 */
124 static void cloth_to_object (Object *ob,  ClothModifierData *clmd, DerivedMesh *dm);
125 static void cloth_from_mesh ( Object *ob, ClothModifierData *clmd, DerivedMesh *dm );
126 static int cloth_from_object(Object *ob, ClothModifierData *clmd, DerivedMesh *dm, float framenr);
127 int cloth_build_springs ( ClothModifierData *clmd, DerivedMesh *dm );
128 static void cloth_apply_vgroup ( ClothModifierData *clmd, DerivedMesh *dm, short vgroup );
129
130
131 /******************************************************************************
132 *
133 * External interface called by modifier.c clothModifier functions.
134 *
135 ******************************************************************************/
136 /**
137 * cloth_init -  creates a new cloth simulation.
138 *
139 * 1. create object
140 * 2. fill object with standard values or with the GUI settings if given
141 */
142 void cloth_init ( ClothModifierData *clmd )
143 {       
144         /* Initialize our new data structure to reasonable values. */
145         clmd->sim_parms->gravity [0] = 0.0;
146         clmd->sim_parms->gravity [1] = 0.0;
147         clmd->sim_parms->gravity [2] = -9.81;
148         clmd->sim_parms->structural = 100.0;
149         clmd->sim_parms->shear = 100.0;
150         clmd->sim_parms->bending = 1.0;
151         clmd->sim_parms->Cdis = 5.0;
152         clmd->sim_parms->Cvi = 1.0;
153         clmd->sim_parms->mass = 1.0f;
154         clmd->sim_parms->stepsPerFrame = 5;
155         clmd->sim_parms->sim_time = 1.0;
156         clmd->sim_parms->flags = CLOTH_SIMSETTINGS_FLAG_NEW;
157         clmd->sim_parms->solver_type = 0;
158         clmd->sim_parms->preroll = 0;
159         clmd->sim_parms->maxspringlen = 10;
160         clmd->sim_parms->firstframe = 1;
161         clmd->sim_parms->lastframe = 250;
162         clmd->sim_parms->vgroup_mass = 0;
163         clmd->sim_parms->lastcachedframe = 0;
164         
165         clmd->coll_parms->self_friction = 5.0;
166         clmd->coll_parms->friction = 10.0;
167         clmd->coll_parms->loop_count = 1;
168         clmd->coll_parms->epsilon = 0.01f;
169         clmd->coll_parms->flags = CLOTH_COLLSETTINGS_FLAG_ENABLED;
170
171         /* These defaults are copied from softbody.c's
172         * softbody_calc_forces() function.
173         */
174         clmd->sim_parms->eff_force_scale = 1000.0;
175         clmd->sim_parms->eff_wind_scale = 250.0;
176
177         // also from softbodies
178         clmd->sim_parms->maxgoal = 1.0f;
179         clmd->sim_parms->mingoal = 0.0f;
180         clmd->sim_parms->defgoal = 0.0f;
181         clmd->sim_parms->goalspring = 100.0f;
182         clmd->sim_parms->goalfrict = 0.0f;
183
184         clmd->sim_parms->cache = NULL;
185 }
186
187
188 BVH *bvh_build_from_cloth (ClothModifierData *clmd, float epsilon)
189 {
190         unsigned int i = 0;
191         BVH     *bvh=NULL;
192         Cloth *cloth = clmd->clothObject;
193         ClothVertex *verts = NULL;
194
195         if(!clmd)
196                 return NULL;
197
198         cloth = clmd->clothObject;
199
200         if(!cloth)
201                 return NULL;
202         
203         verts = cloth->verts;
204         
205         bvh = MEM_callocN(sizeof(BVH), "BVH");
206         if (bvh == NULL) 
207         {
208                 printf("bvh: Out of memory.\n");
209                 return NULL;
210         }
211         
212         // springs = cloth->springs;
213         // numsprings = cloth->numsprings;
214         
215         bvh->flags = 0;
216         bvh->leaf_tree = NULL;
217         bvh->leaf_root = NULL;
218         bvh->tree = NULL;
219
220         bvh->epsilon = epsilon;
221         bvh->numfaces = cloth->numfaces;
222         bvh->mfaces = cloth->mfaces;
223
224         bvh->numverts = cloth->numverts;
225         
226         bvh->current_x = MEM_callocN ( sizeof ( MVert ) * bvh->numverts, "bvh->current_x" );
227         bvh->current_xold = MEM_callocN ( sizeof ( MVert ) * bvh->numverts, "bvh->current_xold" );
228         
229         for(i = 0; i < bvh->numverts; i++)
230         {
231                 VECCOPY(bvh->current_x[i].co, verts[i].tx);
232                 VECCOPY(bvh->current_xold[i].co, verts[i].txold);
233         }
234         
235         bvh_build (bvh);
236         
237         return bvh;
238 }
239
240 void bvh_update_from_cloth(ClothModifierData *clmd, int moving)
241 {
242         unsigned int i = 0;
243         Cloth *cloth = clmd->clothObject;
244         BVH *bvh = cloth->tree;
245         ClothVertex *verts = cloth->verts;
246         
247         if(!bvh)
248                 return;
249         
250         if(cloth->numverts!=bvh->numverts)
251                 return;
252         
253         if(cloth->verts)
254         {
255                 for(i = 0; i < bvh->numverts; i++)
256                 {
257                         VECCOPY(bvh->current_x[i].co, verts[i].tx);
258                         VECCOPY(bvh->current_xold[i].co, verts[i].txold);
259                 }
260         }
261         
262         bvh_update(bvh, moving);
263 }
264
265 // unused in the moment, cloth needs quads from mesh
266 DerivedMesh *CDDM_convert_to_triangle ( DerivedMesh *dm )
267 {
268         DerivedMesh *result = NULL;
269         int i;
270         int numverts = dm->getNumVerts ( dm );
271         int numedges = dm->getNumEdges ( dm );
272         int numfaces = dm->getNumFaces ( dm );
273
274         MVert *mvert = CDDM_get_verts ( dm );
275         MEdge *medge = CDDM_get_edges ( dm );
276         MFace *mface = CDDM_get_faces ( dm );
277
278         MVert *mvert2;
279         MFace *mface2;
280         unsigned int numtris=0;
281         unsigned int numquads=0;
282         int a = 0;
283         int random = 0;
284         int firsttime = 0;
285         float vec1[3], vec2[3], vec3[3], vec4[3], vec5[3];
286         float mag1=0, mag2=0;
287
288         for ( i = 0; i < numfaces; i++ )
289         {
290                 if ( mface[i].v4 )
291                         numquads++;
292                 else
293                         numtris++;
294         }
295
296         result = CDDM_from_template ( dm, numverts, 0, numtris + 2*numquads );
297
298         if ( !result )
299                 return NULL;
300
301         // do verts
302         mvert2 = CDDM_get_verts ( result );
303         for ( a=0; a<numverts; a++ )
304         {
305                 MVert *inMV;
306                 MVert *mv = &mvert2[a];
307
308                 inMV = &mvert[a];
309
310                 DM_copy_vert_data ( dm, result, a, a, 1 );
311                 *mv = *inMV;
312         }
313
314
315         // do faces
316         mface2 = CDDM_get_faces ( result );
317         for ( a=0, i=0; a<numfaces; a++ )
318         {
319                 MFace *mf = &mface2[i];
320                 MFace *inMF;
321                 inMF = &mface[a];
322
323                 /*
324                 DM_copy_face_data(dm, result, a, i, 1);
325
326                 *mf = *inMF;
327                 */
328
329                 if ( mface[a].v4 && random==1 )
330                 {
331                         mf->v1 = mface[a].v2;
332                         mf->v2 = mface[a].v3;
333                         mf->v3 = mface[a].v4;
334                 }
335                 else
336                 {
337                         mf->v1 = mface[a].v1;
338                         mf->v2 = mface[a].v2;
339                         mf->v3 = mface[a].v3;
340                 }
341
342                 mf->v4 = 0;
343                 mf->flag |= ME_SMOOTH;
344
345                 test_index_face ( mf, NULL, 0, 3 );
346
347                 if ( mface[a].v4 )
348                 {
349                         MFace *mf2;
350
351                         i++;
352
353                         mf2 = &mface2[i];
354                         /*
355                         DM_copy_face_data(dm, result, a, i, 1);
356
357                         *mf2 = *inMF;
358                         */
359
360                         if ( random==1 )
361                         {
362                                 mf2->v1 = mface[a].v1;
363                                 mf2->v2 = mface[a].v2;
364                                 mf2->v3 = mface[a].v4;
365                         }
366                         else
367                         {
368                                 mf2->v1 = mface[a].v4;
369                                 mf2->v2 = mface[a].v1;
370                                 mf2->v3 = mface[a].v3;
371                         }
372                         mf2->v4 = 0;
373                         mf2->flag |= ME_SMOOTH;
374
375                         test_index_face ( mf2, NULL, 0, 3 );
376                 }
377
378                 i++;
379         }
380
381         CDDM_calc_edges ( result );
382         CDDM_calc_normals ( result );
383
384         return result;
385
386 }
387
388
389 DerivedMesh *CDDM_create_tearing ( ClothModifierData *clmd, DerivedMesh *dm )
390 {
391         DerivedMesh *result = NULL;
392         unsigned int i = 0, a = 0, j=0;
393         int numverts = dm->getNumVerts ( dm );
394         int numedges = dm->getNumEdges ( dm );
395         int numfaces = dm->getNumFaces ( dm );
396
397         MVert *mvert = CDDM_get_verts ( dm );
398         MEdge *medge = CDDM_get_edges ( dm );
399         MFace *mface = CDDM_get_faces ( dm );
400
401         MVert *mvert2;
402         MFace *mface2;
403         unsigned int numtris=0;
404         unsigned int numquads=0;
405         EdgeHash *edgehash = NULL;
406         Cloth *cloth = clmd->clothObject;
407         ClothSpring *springs = cloth->springs;
408         unsigned int numsprings = cloth->numsprings;
409
410         // create spring tearing hash
411         edgehash = BLI_edgehash_new();
412
413         for ( i = 0; i < numsprings; i++ )
414         {
415                 if ( ( springs[i].flags & CLOTH_SPRING_FLAG_DEACTIVATE )
416                         && ( !BLI_edgehash_haskey ( edgehash, springs[i].ij, springs[i].kl ) ) )
417                 {
418                         BLI_edgehash_insert ( edgehash, springs[i].ij, springs[i].kl, NULL );
419                         BLI_edgehash_insert ( edgehash, springs[i].kl, springs[i].ij, NULL );
420                         j++;
421                 }
422         }
423
424         // printf("found %d tears\n", j);
425
426         result = CDDM_from_template ( dm, numverts, 0, numfaces );
427
428         if ( !result )
429                 return NULL;
430
431         // do verts
432         mvert2 = CDDM_get_verts ( result );
433         for ( a=0; a<numverts; a++ )
434         {
435                 MVert *inMV;
436                 MVert *mv = &mvert2[a];
437
438                 inMV = &mvert[a];
439
440                 DM_copy_vert_data ( dm, result, a, a, 1 );
441                 *mv = *inMV;
442         }
443
444
445         // do faces
446         mface2 = CDDM_get_faces ( result );
447         for ( a=0, i=0; a<numfaces; a++ )
448         {
449                 MFace *mf = &mface2[i];
450                 MFace *inMF;
451                 inMF = &mface[a];
452
453                 /*
454                 DM_copy_face_data(dm, result, a, i, 1);
455
456                 *mf = *inMF;
457                 */
458
459                 if ( ( !BLI_edgehash_haskey ( edgehash, mface[a].v1, mface[a].v2 ) )
460                         && ( !BLI_edgehash_haskey ( edgehash, mface[a].v2, mface[a].v3 ) )
461                         && ( !BLI_edgehash_haskey ( edgehash, mface[a].v3, mface[a].v4 ) )
462                         && ( !BLI_edgehash_haskey ( edgehash, mface[a].v4, mface[a].v1 ) ) )
463                 {
464                         mf->v1 = mface[a].v1;
465                         mf->v2 = mface[a].v2;
466                         mf->v3 = mface[a].v3;
467                         mf->v4 = mface[a].v4;
468
469                         test_index_face ( mf, NULL, 0, 4 );
470
471                         i++;
472                 }
473         }
474
475         CDDM_lower_num_faces ( result, i );
476         CDDM_calc_edges ( result );
477         CDDM_calc_normals ( result );
478
479         BLI_edgehash_free ( edgehash, NULL );
480
481         return result;
482 }
483
484
485
486 int modifiers_indexInObject(Object *ob, ModifierData *md_seek);
487
488 static int cloth_read_cache(Object *ob, ClothModifierData *clmd, float framenr)
489 {
490         FILE *fp = NULL;
491         int stack_index = -1;
492         unsigned int a, ret = 1;
493         Cloth *cloth = clmd->clothObject;
494         
495         if(!cloth)
496                 return 0;
497         
498         stack_index = modifiers_indexInObject(ob, (ModifierData *)clmd);
499         
500         fp = BKE_ptcache_id_fopen((ID *)ob, 'r', framenr, stack_index);
501         if(!fp)
502                 ret = 0;
503         else {
504                 for(a = 0; a < cloth->numverts; a++)
505                 {
506                         if(fread(&cloth->verts[a].x, sizeof(float), 3, fp) != 3) 
507                         {
508                                 ret = 0;
509                                 break;
510                         }
511                         if(fread(&cloth->verts[a].xconst, sizeof(float), 3, fp) != 3) 
512                         {
513                                 ret = 0;
514                                 break;
515                         }
516                         if(fread(&cloth->verts[a].v, sizeof(float), 3, fp) != 3) 
517                         {
518                                 ret = 0;
519                                 break;
520                         }
521                 }
522                 
523                 fclose(fp);
524                 
525                 if(clmd->sim_parms->solver_type == 0)
526                         implicit_set_positions(clmd);
527         }
528                 
529         return ret;
530 }
531
532 void cloth_clear_cache(Object *ob, ClothModifierData *clmd, float framenr)
533 {
534         int stack_index = -1;
535         
536         /* clear cache if specific frame cleaning requested or cache is not protected */
537         if((!(clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_CCACHE_PROTECT)) || (framenr > 1.0))
538         {
539                 stack_index = modifiers_indexInObject(ob, (ModifierData *)clmd);
540                 
541                 BKE_ptcache_id_clear((ID *)ob, PTCACHE_CLEAR_AFTER, framenr, stack_index);
542         }
543         
544         if(framenr>0)
545         {
546                 cloth_read_cache(ob, clmd, framenr);
547         }
548 }
549 void cloth_write_cache(Object *ob, ClothModifierData *clmd, float framenr)
550 {
551         FILE *fp = NULL;
552         int stack_index = -1;
553         unsigned int a;
554         Cloth *cloth = clmd->clothObject;
555         
556         if(!cloth)
557         {
558                 return;
559         }
560         
561         stack_index = modifiers_indexInObject(ob, (ModifierData *)clmd);
562         
563         fp = BKE_ptcache_id_fopen((ID *)ob, 'w', framenr, stack_index);
564         if(!fp)
565         {
566                 return;
567         }
568         
569         for(a = 0; a < cloth->numverts; a++)
570         {
571                 fwrite(&cloth->verts[a].x, sizeof(float),3,fp);
572                 fwrite(&cloth->verts[a].xconst, sizeof(float),3,fp);
573                 fwrite(&cloth->verts[a].v, sizeof(float),3,fp);
574         }
575         
576         clmd->sim_parms->lastcachedframe = MAX2(clmd->sim_parms->lastcachedframe, framenr);
577         
578         fclose(fp);
579 }
580
581
582
583 /************************************************
584  * clothModifier_do - main simulation function
585 ************************************************/
586 DerivedMesh *clothModifier_do(ClothModifierData *clmd,Object *ob, DerivedMesh *dm, int useRenderParams, int isFinalCalc)
587
588 {
589         unsigned int i;
590         Cloth *cloth = clmd->clothObject;
591         unsigned int framenr = ( float ) G.scene->r.cfra;
592         float current_time = bsystem_time ( ob, ( float ) G.scene->r.cfra, 0.0 );
593         ListBase *effectors = NULL;
594         ClothVertex *verts = NULL;
595         float deltaTime = current_time - clmd->sim_parms->sim_time;
596         unsigned int numverts = -1;
597         unsigned int numedges = -1;
598         unsigned int numfaces = -1;
599         MVert *mvert = NULL;
600         MEdge *medge = NULL;
601         MFace *mface = NULL;
602         DerivedMesh *result = NULL;
603         
604         result = CDDM_copy(dm);
605         
606         if(!result)
607         {
608                 return dm;
609         }
610         
611         numverts = result->getNumVerts(result);
612         numedges = result->getNumEdges(result);
613         numfaces = result->getNumFaces(result);
614         mvert = CDDM_get_verts(result);
615         medge = CDDM_get_edges(result);
616         mface = CDDM_get_faces(result);
617         
618         // only be active during a specific period:
619         // that's "first frame" and "last frame" on GUI
620         if ( current_time < clmd->sim_parms->firstframe )
621         {
622                 return result;
623         }
624         else if ( current_time > clmd->sim_parms->lastframe )
625         {
626                 int stack_index = modifiers_indexInObject(ob, (ModifierData *)clmd);
627                 
628                 if(BKE_ptcache_id_exist((ID *)ob, clmd->sim_parms->lastcachedframe, stack_index))
629                 {
630                         if(cloth_read_cache(ob, clmd, framenr))
631                         {
632                                 // Copy the result back to the object.
633                                 cloth_to_object (ob, clmd, result);
634                         }
635                 }
636                 return result;
637         }
638         
639         // unused in the moment, calculated seperately in implicit.c
640         clmd->sim_parms->dt = 1.0f / clmd->sim_parms->stepsPerFrame;
641
642         clmd->sim_parms->sim_time = current_time;
643         
644         /* check if cache is active / if file is already saved */
645         if ((!G.relbase_valid) && ( deltaTime != 1.0f ))
646         {
647                 clmd->sim_parms->flags |= CLOTH_SIMSETTINGS_FLAG_RESET;
648         }
649
650         if(clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_RESET)
651         {       
652                 cloth_free_modifier (ob, clmd);
653         }
654
655         if ( deltaTime == 1.0f )
656         {
657                 if ( ( clmd->clothObject == NULL ) || ( numverts != clmd->clothObject->numverts ) )
658                 {
659                         cloth_clear_cache(ob, clmd, 0);
660                         
661                         // printf("v1: %d, v2: %d\n", numverts, clmd->clothObject->numverts);
662                         
663                         if ( !cloth_from_object ( ob, clmd, result, framenr ) )
664                                 return result;
665
666                         if ( clmd->clothObject == NULL )
667                                 return result;
668
669                         cloth = clmd->clothObject;
670                 }
671
672                 clmd->clothObject->old_solver_type = clmd->sim_parms->solver_type;
673
674                 // Insure we have a clmd->clothObject, in case allocation failed.
675                 if ( clmd->clothObject != NULL )
676                 {
677                         if(!cloth_read_cache(ob, clmd, framenr))
678                         {
679                                 verts = cloth->verts;
680
681                                 // Force any pinned verts to their constrained location.
682                                 for ( i = 0; i < clmd->clothObject->numverts; i++, verts++ )
683                                 {
684                                         // Save the previous position.
685                                         VECCOPY ( verts->xold, verts->xconst );
686                                         VECCOPY ( verts->txold, verts->x );
687
688                                         // Get the current position.
689                                         VECCOPY ( verts->xconst, mvert[i].co );
690                                         Mat4MulVecfl ( ob->obmat, verts->xconst );
691                                 }
692
693                                 tstart();
694
695                                 // Call the solver.
696                                 if ( solvers [clmd->sim_parms->solver_type].solver )
697                                         solvers [clmd->sim_parms->solver_type].solver ( ob, framenr, clmd, effectors );
698
699                                 tend();
700                                 // printf ( "Cloth simulation time: %f\n", ( float ) tval() );
701
702                                 cloth_write_cache(ob, clmd, framenr);
703                         }
704                         
705                         // Copy the result back to the object.
706                         cloth_to_object (ob, clmd, result);
707                 }
708
709         }
710         else
711         {
712                 if ( clmd->clothObject != NULL )
713                 {
714                         if(cloth_read_cache(ob, clmd, framenr))
715                         {
716                                 cloth_to_object (ob, clmd, result);
717                         }
718                 }
719                 else
720                 {
721                         cloth_clear_cache(ob, clmd, 0);
722                         
723                         if ( !cloth_from_object ( ob, clmd, result, framenr ) )
724                                 return result;
725                 }
726         }
727         
728         return result;
729
730 }
731
732 /* frees all */
733 void cloth_free_modifier ( Object *ob, ClothModifierData *clmd )
734 {
735         Cloth   *cloth = NULL;
736         
737         if ( !clmd )
738                 return;
739
740         cloth = clmd->clothObject;
741
742         if ( ! ( clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_CCACHE_PROTECT ) )
743         {
744                 if ( cloth )
745                 {
746                         // free our frame cache, TODO: but get to first position before
747                         cloth_clear_cache ( ob, clmd, 0 );
748                         
749                         // If our solver provides a free function, call it
750                         if ( solvers [clmd->sim_parms->solver_type].free )
751                         {
752                                 solvers [clmd->sim_parms->solver_type].free ( clmd );
753                         }
754
755                         // Free the verts.
756                         if ( cloth->verts != NULL )
757                                 MEM_freeN ( cloth->verts );
758
759                         cloth->verts = NULL;
760                         cloth->numverts = 0;
761
762                         // Free the springs.
763                         if ( cloth->springs != NULL )
764                         {
765                                 LinkNode *search = cloth->springs;
766                                 while(search)
767                                 {
768                                         ClothSpring *spring = search->link;
769                                                         
770                                         MEM_freeN ( spring );
771                                         search = search->next;
772                                 }
773                                 BLI_linklist_free(cloth->springs, NULL);
774                         
775                                 cloth->springs = NULL;
776                         }
777
778                         cloth->springs = NULL;
779                         cloth->numsprings = 0;
780
781                         // free BVH collision tree
782                         if ( cloth->tree )
783                                 bvh_free ( ( BVH * ) cloth->tree );
784
785                         // we save our faces for collision objects
786                         if ( cloth->mfaces )
787                                 MEM_freeN ( cloth->mfaces );
788                         /*
789                         if(clmd->clothObject->facemarks)
790                                 MEM_freeN(clmd->clothObject->facemarks);
791                         */
792                         MEM_freeN ( cloth );
793                         clmd->clothObject = NULL;
794                 }
795         }
796         clmd->sim_parms->flags &= ~CLOTH_SIMSETTINGS_FLAG_RESET;
797 }
798
799 /* frees all */
800 void cloth_free_modifier_extern ( ClothModifierData *clmd )
801 {
802         Cloth   *cloth = NULL;
803         
804         if ( !clmd )
805                 return;
806
807         cloth = clmd->clothObject;
808         
809         if ( cloth )
810         {       
811                 // If our solver provides a free function, call it
812                 if ( solvers [clmd->sim_parms->solver_type].free )
813                 {
814                         solvers [clmd->sim_parms->solver_type].free ( clmd );
815                 }
816
817                 // Free the verts.
818                 if ( cloth->verts != NULL )
819                         MEM_freeN ( cloth->verts );
820
821                 cloth->verts = NULL;
822                 cloth->numverts = 0;
823
824                 // Free the springs.
825                 if ( cloth->springs != NULL )
826                 {
827                         LinkNode *search = cloth->springs;
828                         while(search)
829                         {
830                                 ClothSpring *spring = search->link;
831                                                 
832                                 MEM_freeN ( spring );
833                                 search = search->next;
834                         }
835                         BLI_linklist_free(cloth->springs, NULL);
836                 
837                         cloth->springs = NULL;
838                 }
839
840                 cloth->springs = NULL;
841                 cloth->numsprings = 0;
842
843                 // free BVH collision tree
844                 if ( cloth->tree )
845                         bvh_free ( ( BVH * ) cloth->tree );
846
847                 // we save our faces for collision objects
848                 if ( cloth->mfaces )
849                         MEM_freeN ( cloth->mfaces );
850                 /*
851                 if(clmd->clothObject->facemarks)
852                 MEM_freeN(clmd->clothObject->facemarks);
853                 */
854                 MEM_freeN ( cloth );
855                 clmd->clothObject = NULL;
856         }
857 }
858
859 /******************************************************************************
860 *
861 * Internal functions.
862 *
863 ******************************************************************************/
864
865 /**
866 * cloth_to_object - copies the deformed vertices to the object.
867 *
868 **/
869 static void cloth_to_object (Object *ob,  ClothModifierData *clmd, DerivedMesh *dm)
870 {
871         unsigned int    i = 0;
872         MVert *mvert = NULL;
873         unsigned int numverts;
874         Cloth *cloth = clmd->clothObject;
875
876         if (clmd->clothObject) {
877                 /* inverse matrix is not uptodate... */
878                 Mat4Invert (ob->imat, ob->obmat);
879
880                 mvert = CDDM_get_verts(dm);
881                 numverts = dm->getNumVerts(dm);
882
883                 for (i = 0; i < numverts; i++)
884                 {
885                         VECCOPY (mvert[i].co, cloth->verts[i].x);
886                         Mat4MulVecfl (ob->imat, mvert[i].co);   /* cloth is in global coords */
887                 }
888         }
889 }
890
891
892 /**
893 * cloth_apply_vgroup - applies a vertex group as specified by type
894 *
895 **/
896 static void cloth_apply_vgroup ( ClothModifierData *clmd, DerivedMesh *dm, short vgroup )
897 {
898         unsigned int i = 0;
899         unsigned int j = 0;
900         MDeformVert *dvert = NULL;
901         Cloth *clothObj = NULL;
902         unsigned int numverts = dm->getNumVerts ( dm );
903         float goalfac = 0;
904         ClothVertex *verts = NULL;
905
906         clothObj = clmd->clothObject;
907
908         if ( !dm )
909                 return;
910
911         numverts = dm->getNumVerts ( dm );
912
913         /* vgroup is 1 based, decrement so we can match the right group. */
914         --vgroup;
915
916         verts = clothObj->verts;
917
918         for ( i = 0; i < numverts; i++, verts++ )
919         {
920                 // LATER ON, support also mass painting here
921                 if ( clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_GOAL )
922                 {
923                         dvert = dm->getVertData ( dm, i, CD_MDEFORMVERT );
924                         if ( dvert )
925                         {
926                                 for ( j = 0; j < dvert->totweight; j++ )
927                                 {
928                                         if ( dvert->dw[j].def_nr == vgroup )
929                                         {
930                                                 verts->goal = dvert->dw [j].weight;
931
932                                                 goalfac= 1.0f;
933                                                 
934                                                 /*
935                                                 // Kicking goal factor to simplify things...who uses that anyway?
936                                                 // ABS ( clmd->sim_parms->maxgoal - clmd->sim_parms->mingoal );
937                                                 */
938                                                 
939                                                 verts->goal  = ( float ) pow ( verts->goal , 4.0f );
940
941                                                 if ( verts->goal >=SOFTGOALSNAP )
942                                                 {
943                                                         verts->flags |= CLOTH_VERT_FLAG_PINNED;
944                                                 }
945
946                                                 // TODO enable mass painting here, for the moment i let "goals" go first
947
948                                                 break;
949                                         }
950                                 }
951                         }
952                 }
953         }
954 }
955
956 /*
957 helper function to get proper spring length
958 when object is rescaled
959 */
960 float cloth_globallen ( float *v1,float *v2,Object *ob )
961 {
962         float p1[3],p2[3];
963         VECCOPY ( p1,v1 );
964         Mat4MulVecfl ( ob->obmat, p1 );
965         VECCOPY ( p2,v2 );
966         Mat4MulVecfl ( ob->obmat, p2 );
967         return VecLenf ( p1,p2 );
968 }
969
970 static int cloth_from_object(Object *ob, ClothModifierData *clmd, DerivedMesh *dm, float framenr)
971 {
972         unsigned int i = 0;
973         MVert *mvert = NULL;
974         ClothVertex *verts = NULL;
975         float tnull[3] = {0,0,0};
976
977         // If we have a clothObject, free it. 
978         if ( clmd->clothObject != NULL )
979         {
980                 cloth_free_modifier ( ob, clmd );
981         }
982
983         // Allocate a new cloth object.
984         clmd->clothObject = MEM_callocN ( sizeof ( Cloth ), "cloth" );
985         if ( clmd->clothObject )
986         {
987                 clmd->clothObject->old_solver_type = 255;
988                 // clmd->clothObject->old_collision_type = 255;
989         }
990         else if ( !clmd->clothObject )
991         {
992                 modifier_setError ( & ( clmd->modifier ), "Out of memory on allocating clmd->clothObject." );
993                 return 0;
994         }
995
996         // mesh input objects need DerivedMesh
997         if ( !dm )
998                 return 0;
999
1000         cloth_from_mesh ( ob, clmd, dm );
1001
1002         if ( clmd->clothObject != NULL )
1003         {
1004                 // create springs 
1005                 clmd->clothObject->springs = NULL;
1006                 clmd->clothObject->numsprings = -1;
1007                 
1008                 mvert = CDDM_get_verts ( dm );
1009                 verts = clmd->clothObject->verts;
1010
1011                 // set initial values
1012                 for ( i = 0; i < dm->getNumVerts(dm); i++, verts++ )
1013                 {
1014                         VECCOPY ( verts->x, mvert[i].co );
1015                         Mat4MulVecfl ( ob->obmat, verts->x );
1016
1017                         verts->mass = clmd->sim_parms->mass;
1018
1019                         if ( clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_GOAL )
1020                                 verts->goal= clmd->sim_parms->defgoal;
1021                         else
1022                                 verts->goal= 0.0f;
1023
1024                         verts->flags = 0;
1025                         VECCOPY ( verts->xold, verts->x );
1026                         VECCOPY ( verts->xconst, verts->x );
1027                         VECCOPY ( verts->txold, verts->x );
1028                         VecMulf ( verts->v, 0.0f );
1029
1030                         verts->impulse_count = 0;
1031                         VECCOPY ( verts->impulse, tnull );
1032                 }
1033                 
1034                 if ( !cloth_build_springs ( clmd, dm ) )
1035                 {
1036                         cloth_free_modifier ( ob, clmd );
1037                         modifier_setError ( & ( clmd->modifier ), "Can't build springs." );
1038                         return 0;
1039                 }
1040
1041                 // apply / set vertex groups
1042                 if ( clmd->sim_parms->vgroup_mass > 0 )
1043                         cloth_apply_vgroup ( clmd, dm, clmd->sim_parms->vgroup_mass );
1044
1045                 // init our solver
1046                 if ( solvers [clmd->sim_parms->solver_type].init )
1047                         solvers [clmd->sim_parms->solver_type].init ( ob, clmd );
1048
1049                 clmd->clothObject->tree = bvh_build_from_cloth ( clmd, clmd->coll_parms->epsilon );
1050                 
1051                 if(!cloth_read_cache(ob, clmd, framenr))
1052                         cloth_write_cache(ob, clmd, framenr);
1053                 
1054                 return 1;
1055         }
1056         return 0;
1057 }
1058
1059
1060 static void cloth_from_mesh ( Object *ob, ClothModifierData *clmd, DerivedMesh *dm )
1061 {
1062         unsigned int numverts = dm->getNumVerts ( dm );
1063         unsigned int numfaces = dm->getNumFaces ( dm );
1064         MFace *mface = CDDM_get_faces(dm);
1065         unsigned int i = 0;
1066
1067         /* Allocate our vertices.
1068         */
1069         clmd->clothObject->numverts = numverts;
1070         clmd->clothObject->verts = MEM_callocN ( sizeof ( ClothVertex ) * clmd->clothObject->numverts, "clothVertex" );
1071         if ( clmd->clothObject->verts == NULL )
1072         {
1073                 cloth_free_modifier ( ob, clmd );
1074                 modifier_setError ( & ( clmd->modifier ), "Out of memory on allocating clmd->clothObject->verts." );
1075                 return;
1076         }
1077
1078         // save face information
1079         clmd->clothObject->numfaces = numfaces;
1080         clmd->clothObject->mfaces = MEM_callocN ( sizeof ( MFace ) * clmd->clothObject->numfaces, "clothMFaces" );
1081         if ( clmd->clothObject->mfaces == NULL )
1082         {
1083                 cloth_free_modifier ( ob, clmd );
1084                 modifier_setError ( & ( clmd->modifier ), "Out of memory on allocating clmd->clothObject->mfaces." );
1085                 return;
1086         }
1087         for ( i = 0; i < numfaces; i++ )
1088                 memcpy ( &clmd->clothObject->mfaces[i], &mface[i], sizeof ( MFace ) );
1089
1090         /* Free the springs since they can't be correct if the vertices
1091         * changed.
1092         */
1093         if ( clmd->clothObject->springs != NULL )
1094                 MEM_freeN ( clmd->clothObject->springs );
1095
1096 }
1097
1098 /***************************************************************************************
1099 * SPRING NETWORK BUILDING IMPLEMENTATION BEGIN
1100 ***************************************************************************************/
1101
1102 // be carefull: implicit solver has to be resettet when using this one!
1103 // --> only for implicit handling of this spring!
1104 int cloth_add_spring ( ClothModifierData *clmd, unsigned int indexA, unsigned int indexB, float restlength, int spring_type)
1105 {
1106         Cloth *cloth = clmd->clothObject;
1107         ClothSpring *spring = NULL;
1108         
1109         if(cloth)
1110         {
1111                 // TODO: look if this spring is already there
1112                 
1113                 spring = ( ClothSpring * ) MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );
1114                 
1115                 spring->ij = indexA;
1116                 spring->kl = indexB;
1117                 spring->restlen =  restlength;
1118                 spring->type = spring_type;
1119                 spring->flags = 0;
1120                 
1121                 cloth->numsprings++;
1122         
1123                 BLI_linklist_append ( &cloth->springs, spring );
1124                 
1125                 return 1;
1126         }
1127         return 0;
1128 }
1129
1130 int cloth_build_springs ( ClothModifierData *clmd, DerivedMesh *dm )
1131 {
1132         Cloth *cloth = clmd->clothObject;
1133         ClothSpring *spring = NULL, *tspring = NULL, *tspring2 = NULL;
1134         unsigned int struct_springs = 0, shear_springs=0, bend_springs = 0;
1135         unsigned int i = 0;
1136         unsigned int numverts = dm->getNumVerts ( dm );
1137         unsigned int numedges = dm->getNumEdges ( dm );
1138         unsigned int numfaces = dm->getNumFaces ( dm );
1139         MEdge *medge = CDDM_get_edges ( dm );
1140         MFace *mface = CDDM_get_faces ( dm );
1141         unsigned int index2 = 0; // our second vertex index
1142         LinkNode **edgelist = NULL;
1143         EdgeHash *edgehash = NULL;
1144         LinkNode *search = NULL, *search2 = NULL;
1145         float temp[3];
1146         LinkNode *node = NULL, *node2 = NULL;
1147         
1148         // error handling
1149         if ( numedges==0 )
1150                 return 0;
1151
1152         cloth->springs = NULL;
1153
1154         edgelist = MEM_callocN ( sizeof ( LinkNode * ) * numverts, "cloth_edgelist_alloc" );
1155         for ( i = 0; i < numverts; i++ )
1156         {
1157                 edgelist[i] = NULL;
1158         }
1159
1160         if ( cloth->springs )
1161                 MEM_freeN ( cloth->springs );
1162
1163         // create spring network hash
1164         edgehash = BLI_edgehash_new();
1165
1166         // structural springs
1167         for ( i = 0; i < numedges; i++ )
1168         {
1169                 spring = ( ClothSpring * ) MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );
1170
1171                 if ( spring )
1172                 {
1173                         spring->ij = medge[i].v1;
1174                         spring->kl = medge[i].v2;
1175                         VECSUB ( temp, cloth->verts[spring->kl].x, cloth->verts[spring->ij].x );
1176                         spring->restlen =  sqrt ( INPR ( temp, temp ) );
1177                         clmd->coll_parms->avg_spring_len += spring->restlen;
1178                         spring->type = CLOTH_SPRING_TYPE_STRUCTURAL;
1179                         spring->flags = 0;
1180                         struct_springs++;
1181                         
1182                         if(!i)
1183                                 node2 = BLI_linklist_append_fast ( &cloth->springs, spring );
1184                         else
1185                                 node2 = BLI_linklist_append_fast ( &node->next, spring );
1186                         node = node2;
1187                 }
1188         }
1189         
1190         clmd->coll_parms->avg_spring_len /= struct_springs;
1191         
1192         // shear springs
1193         for ( i = 0; i < numfaces; i++ )
1194         {
1195                 spring = ( ClothSpring *) MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );
1196
1197                 spring->ij = mface[i].v1;
1198                 spring->kl = mface[i].v3;
1199                 VECSUB ( temp, cloth->verts[spring->kl].x, cloth->verts[spring->ij].x );
1200                 spring->restlen =  sqrt ( INPR ( temp, temp ) );
1201                 spring->type = CLOTH_SPRING_TYPE_SHEAR;
1202
1203                 BLI_linklist_append ( &edgelist[spring->ij], spring );
1204                 BLI_linklist_append ( &edgelist[spring->kl], spring );
1205                 shear_springs++;
1206
1207                 node2 = BLI_linklist_append_fast ( &node->next, spring );
1208                 node = node2;
1209
1210                 if ( mface[i].v4 )
1211                 {
1212                         spring = ( ClothSpring * ) MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );
1213
1214                         spring->ij = mface[i].v2;
1215                         spring->kl = mface[i].v4;
1216                         VECSUB ( temp, cloth->verts[spring->kl].x, cloth->verts[spring->ij].x );
1217                         spring->restlen =  sqrt ( INPR ( temp, temp ) );
1218                         spring->type = CLOTH_SPRING_TYPE_SHEAR;
1219
1220                         BLI_linklist_append ( &edgelist[spring->ij], spring );
1221                         BLI_linklist_append ( &edgelist[spring->kl], spring );
1222                         shear_springs++;
1223
1224                         node2 = BLI_linklist_append_fast ( &node->next, spring );
1225                         node = node2;
1226                 }
1227         }
1228         
1229         // bending springs
1230         search2 = cloth->springs;
1231         for ( i = struct_springs; i < struct_springs+shear_springs; i++ )
1232         {
1233                 if ( !search2 )
1234                         break;
1235
1236                 tspring2 = search2->link;
1237                 search = edgelist[tspring2->kl];
1238                 while ( search )
1239                 {
1240                         tspring = search->link;
1241                         index2 = ( ( tspring->ij==tspring2->kl ) ? ( tspring->kl ) : ( tspring->ij ) );
1242                         
1243                         // check for existing spring
1244                         // check also if startpoint is equal to endpoint
1245                         if ( !BLI_edgehash_haskey ( edgehash, index2, tspring2->ij )
1246                                                    && !BLI_edgehash_haskey ( edgehash, tspring2->ij, index2 )
1247                                                    && ( index2!=tspring2->ij ) )
1248                         {
1249                                 spring = ( ClothSpring * ) MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );
1250
1251                                 spring->ij = tspring2->ij;
1252                                 spring->kl = index2;
1253                                 VECSUB ( temp, cloth->verts[index2].x, cloth->verts[tspring2->ij].x );
1254                                 spring->restlen =  sqrt ( INPR ( temp, temp ) );
1255                                 spring->type = CLOTH_SPRING_TYPE_BENDING;
1256                                 BLI_edgehash_insert ( edgehash, spring->ij, index2, NULL );
1257                                 bend_springs++;
1258
1259                                 node2 = BLI_linklist_append_fast ( &node->next, spring );
1260                                 node = node2;
1261                         }
1262                         search = search->next;
1263                 }
1264                 search2 = search2->next;
1265         }
1266         
1267         cloth->numsprings = struct_springs + shear_springs + bend_springs;
1268         
1269         for ( i = 0; i < numverts; i++ )
1270         {
1271                 BLI_linklist_free ( edgelist[i],NULL );
1272         }
1273         if ( edgelist )
1274                 MEM_freeN ( edgelist );
1275         
1276         BLI_edgehash_free ( edgehash, NULL );
1277
1278         return 1;
1279
1280 } /* cloth_build_springs */
1281 /***************************************************************************************
1282 * SPRING NETWORK BUILDING IMPLEMENTATION END
1283 ***************************************************************************************/
1284