Code got unreadble due to copy-paste (hint for me: revert point)
[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_cloth_types.h"
43 #include "DNA_object_types.h"
44 #include "DNA_object_force.h"
45 #include "DNA_key_types.h"
46 #include "DNA_lattice_types.h"
47 #include "DNA_mesh_types.h"
48 #include "DNA_meshdata_types.h"
49 #include "DNA_modifier_types.h"
50 #include "DNA_scene_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_cloth.h"
59 #include "BKE_collisions.h"
60 #include "BKE_deform.h"
61 #include "BKE_DerivedMesh.h"
62 #include "BKE_cdderivedmesh.h"
63 #include "BKE_displist.h"
64 #include "BKE_effect.h"
65 #include "BKE_global.h"
66 #include "BKE_key.h"
67 #include "BKE_mesh.h"
68 #include "BKE_modifier.h"
69 #include "BKE_object.h"
70 #include "BKE_pointcache.h"
71 #include "BKE_utildefines.h"
72
73 #include "BIF_editdeform.h"
74 #include "BIF_editkey.h"
75 #include "DNA_screen_types.h"
76 #include "BSE_headerbuttons.h"
77 #include "BIF_screen.h"
78 #include "BIF_space.h"
79 #include "mydevice.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         // { "Verlet", CM_VERLET, verlet_init, verlet_solver, verlet_free },
119 };
120
121 /* ********** cloth engine ******* */
122 /* Prototypes for internal functions.
123 */
124 static void cloth_to_object (Object *ob,  DerivedMesh *dm, ClothModifierData *clmd);
125 static void cloth_from_mesh (Object *ob, ClothModifierData *clmd, DerivedMesh *dm, float framenr);
126 static int cloth_from_object(Object *ob, ClothModifierData *clmd, DerivedMesh *dm, DerivedMesh *olddm, float framenr);
127
128 int cloth_build_springs ( Cloth *cloth, DerivedMesh *dm );
129 static void cloth_apply_vgroup(ClothModifierData *clmd, DerivedMesh *dm, short vgroup);
130 /******************************************************************************
131 *
132 * External interface called by modifier.c clothModifier functions.
133 *
134 ******************************************************************************/
135 /**
136  * cloth_init -  creates a new cloth simulation.
137  *
138  * 1. create object
139  * 2. fill object with standard values or with the GUI settings if given 
140  */
141 void cloth_init (ClothModifierData *clmd)
142 {
143         /* Initialize our new data structure to reasonable values. */
144         clmd->sim_parms->gravity [0] = 0.0;
145         clmd->sim_parms->gravity [1] = 0.0;
146         clmd->sim_parms->gravity [2] = -9.81;
147         clmd->sim_parms->structural = 100.0;
148         clmd->sim_parms->shear = 100.0;
149         clmd->sim_parms->bending = 1.0;
150         clmd->sim_parms->Cdis = 5.0;
151         clmd->sim_parms->Cvi = 1.0;
152         clmd->sim_parms->mass = 1.0f;
153         clmd->sim_parms->stepsPerFrame = 5;
154         clmd->sim_parms->sim_time = 1.0;
155         clmd->sim_parms->flags = CLOTH_SIMSETTINGS_FLAG_RESET;
156         clmd->sim_parms->solver_type = 0; 
157         clmd->sim_parms->preroll = 0;
158         clmd->sim_parms->maxspringlen = 10;
159         clmd->coll_parms->self_friction = 5.0;
160         clmd->coll_parms->friction = 10.0;
161         clmd->coll_parms->loop_count = 1;
162         clmd->coll_parms->epsilon = 0.01;
163         clmd->coll_parms->selfepsilon = 0.1;
164         
165         /* These defaults are copied from softbody.c's
166         * softbody_calc_forces() function.
167         */
168         clmd->sim_parms->eff_force_scale = 1000.0;
169         clmd->sim_parms->eff_wind_scale = 250.0;
170
171         // also from softbodies
172         clmd->sim_parms->maxgoal = 1.0;
173         clmd->sim_parms->mingoal = 0.0;
174         clmd->sim_parms->defgoal = 0.0;
175         clmd->sim_parms->goalspring = 100.0;
176         clmd->sim_parms->goalfrict = 0.0;
177 }
178
179 // unused in the moment, cloth needs quads from mesh
180 DerivedMesh *CDDM_convert_to_triangle(DerivedMesh *dm)
181 {
182         /*
183         DerivedMesh *result = NULL;
184         int i;
185         int numverts = dm->getNumVerts(dm);
186         int numedges = dm->getNumEdges(dm);
187         int numfaces = dm->getNumFaces(dm);
188
189         MVert *mvert = CDDM_get_verts(dm);
190         MEdge *medge = CDDM_get_edges(dm);
191         MFace *mface = CDDM_get_faces(dm);
192
193         MVert *mvert2;
194         MFace *mface2;
195         unsigned int numtris=0;
196         unsigned int numquads=0;
197         int a = 0;
198         int random = 0;
199         int firsttime = 0;
200         float vec1[3], vec2[3], vec3[3], vec4[3], vec5[3];
201         float mag1=0, mag2=0;
202
203         for(i = 0; i < numfaces; i++)
204         {
205         if(mface[i].v4)
206         numquads++;
207         else
208         numtris++;      
209 }
210
211         result = CDDM_from_template(dm, numverts, 0, numtris + 2*numquads);
212
213         if(!result)
214         return NULL;
215
216         // do verts
217         mvert2 = CDDM_get_verts(result);
218         for(a=0; a<numverts; a++) 
219         {
220         MVert *inMV;
221         MVert *mv = &mvert2[a];
222
223         inMV = &mvert[a];
224
225         DM_copy_vert_data(dm, result, a, a, 1);
226         *mv = *inMV;
227 }
228
229
230         // do faces
231         mface2 = CDDM_get_faces(result);
232         for(a=0, i=0; a<numfaces; a++) 
233         {
234         MFace *mf = &mface2[i];
235         MFace *inMF;
236         inMF = &mface[a];
237
238                 
239                 // DM_copy_face_data(dm, result, a, i, 1);
240
241                 // *mf = *inMF;
242                 
243
244         if(mface[a].v4 && random==1)
245         {
246         mf->v1 = mface[a].v2;
247         mf->v2 = mface[a].v3;
248         mf->v3 = mface[a].v4;
249 }
250         else
251         {
252         mf->v1 = mface[a].v1;
253         mf->v2 = mface[a].v2;
254         mf->v3 = mface[a].v3;
255 }
256
257         mf->v4 = 0;
258         mf->flag |= ME_SMOOTH;
259
260         test_index_face(mf, NULL, 0, 3);
261
262         if(mface[a].v4)
263         {
264         MFace *mf2;
265
266         i++;
267
268         mf2 = &mface2[i];
269                         
270                         // DM_copy_face_data(dm, result, a, i, 1);
271
272                         // *mf2 = *inMF;
273                         
274
275         if(random==1)
276         {
277         mf2->v1 = mface[a].v1;
278         mf2->v2 = mface[a].v2;
279         mf2->v3 = mface[a].v4;
280 }
281         else
282         {
283         mf2->v1 = mface[a].v4;
284         mf2->v2 = mface[a].v1;
285         mf2->v3 = mface[a].v3;
286 }
287         mf2->v4 = 0;
288         mf2->flag |= ME_SMOOTH;
289
290         test_index_face(mf2, NULL, 0, 3);
291 }
292
293         i++;
294 }
295
296         CDDM_calc_edges(result);
297         CDDM_calc_normals(result);
298
299         return result;
300         */
301         
302         return NULL;
303 }
304
305
306 DerivedMesh *CDDM_create_tearing(ClothModifierData *clmd, DerivedMesh *dm)
307 {
308         /*
309         DerivedMesh *result = NULL;
310         unsigned int i = 0, a = 0, j=0;
311         int numverts = dm->getNumVerts(dm);
312         int numedges = dm->getNumEdges(dm);
313         int numfaces = dm->getNumFaces(dm);
314
315         MVert *mvert = CDDM_get_verts(dm);
316         MEdge *medge = CDDM_get_edges(dm);
317         MFace *mface = CDDM_get_faces(dm);
318
319         MVert *mvert2;
320         MFace *mface2;
321         unsigned int numtris=0;
322         unsigned int numquads=0;
323         EdgeHash *edgehash = NULL;
324         Cloth *cloth = clmd->clothObject;
325         ClothSpring *springs = cloth->springs;
326         unsigned int numsprings = cloth->numsprings;
327         
328         // create spring tearing hash
329         edgehash = BLI_edgehash_new();
330         
331         for(i = 0; i < numsprings; i++)
332         {
333         if((springs[i].flags & CSPRING_FLAG_DEACTIVATE)
334         &&(!BLI_edgehash_haskey(edgehash, springs[i].ij, springs[i].kl)))
335         {
336         BLI_edgehash_insert(edgehash, springs[i].ij, springs[i].kl, NULL);
337         BLI_edgehash_insert(edgehash, springs[i].kl, springs[i].ij, NULL);
338         j++;
339 }
340 }
341         
342         // printf("found %d tears\n", j);
343         
344         result = CDDM_from_template(dm, numverts, 0, numfaces);
345
346         if(!result)
347         return NULL;
348
349         // do verts
350         mvert2 = CDDM_get_verts(result);
351         for(a=0; a<numverts; a++) 
352         {
353         MVert *inMV;
354         MVert *mv = &mvert2[a];
355
356         inMV = &mvert[a];
357
358         DM_copy_vert_data(dm, result, a, a, 1);
359         *mv = *inMV;
360 }
361
362
363         // do faces
364         mface2 = CDDM_get_faces(result);
365         for(a=0, i=0; a<numfaces; a++) 
366         {
367         MFace *mf = &mface2[i];
368         MFace *inMF;
369         inMF = &mface[a];
370
371                 
372                 // DM_copy_face_data(dm, result, a, i, 1);
373
374                 // *mf = *inMF;
375                 
376                 
377         if((!BLI_edgehash_haskey(edgehash, mface[a].v1, mface[a].v2))
378         &&(!BLI_edgehash_haskey(edgehash, mface[a].v2, mface[a].v3))
379         &&(!BLI_edgehash_haskey(edgehash, mface[a].v3, mface[a].v4))
380         &&(!BLI_edgehash_haskey(edgehash, mface[a].v4, mface[a].v1)))
381         {
382         mf->v1 = mface[a].v1;
383         mf->v2 = mface[a].v2;
384         mf->v3 = mface[a].v3;
385         mf->v4 = mface[a].v4;
386         
387         test_index_face(mf, NULL, 0, 4);
388         
389         i++;
390 }
391 }
392
393         CDDM_lower_num_faces(result, i);
394         CDDM_calc_edges(result);
395         CDDM_calc_normals(result);
396         
397         BLI_edgehash_free(edgehash, NULL);
398
399         return result;
400         */
401         
402         return NULL;
403 }
404
405 int modifiers_indexInObject(Object *ob, ModifierData *md_seek);
406
407 void cloth_clear_cache(Object *ob, ClothModifierData *clmd, float framenr)
408 {
409         int stack_index = -1;
410         
411         if(!(clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_CCACHE_PROTECT))
412         {
413                 stack_index = modifiers_indexInObject(ob, (ModifierData *)clmd);
414                 
415                 PTCache_id_clear((ID *)ob, framenr, stack_index);
416         }
417 }
418 static void cloth_write_cache(Object *ob, ClothModifierData *clmd, float framenr)
419 {
420         FILE *fp = NULL;
421         int stack_index = -1;
422         unsigned int a;
423         Cloth *cloth = clmd->clothObject;
424         
425         if(!cloth)
426                 return;
427         
428         stack_index = modifiers_indexInObject(ob, (ModifierData *)clmd);
429         
430         fp = PTCache_id_fopen((ID *)ob, 'w', framenr, stack_index);
431         if(!fp) return;
432         
433         for(a = 0; a < cloth->numverts; a++)
434         {
435                 fwrite(&cloth->x[a], sizeof(float),4,fp);
436                 fwrite(&cloth->xconst[a], sizeof(float),4,fp);
437                 fwrite(&cloth->v[a], sizeof(float),4,fp);
438         }
439         
440         fclose(fp);
441 }
442 static int cloth_read_cache(Object *ob, ClothModifierData *clmd, float framenr)
443 {
444         FILE *fp = NULL;
445         int stack_index = -1;
446         unsigned int a, ret = 1;
447         Cloth *cloth = clmd->clothObject;
448         
449         if(!cloth)
450                 return 0;
451         
452         stack_index = modifiers_indexInObject(ob, (ModifierData *)clmd);
453         
454         fp = PTCache_id_fopen((ID *)ob, 'r', framenr, stack_index);
455         if(!fp)
456                 ret = 0;
457         else {
458                 for(a = 0; a < cloth->numverts; a++)
459                 {
460                         if(fread(&cloth->x[a], sizeof(float), 4, fp) != 4) 
461                         {
462                                 ret = 0;
463                                 break;
464                         }
465                         if(fread(&cloth->xconst[a], sizeof(float), 4, fp) != 4) 
466                         {
467                                 ret = 0;
468                                 break;
469                         }
470                         if(fread(&cloth->v[a], sizeof(float), 4, fp) != 4) 
471                         {
472                                 ret = 0;
473                                 break;
474                         }
475                 }
476                 
477                 fclose(fp);
478         }
479         
480         implicit_set_positions(clmd);
481                         
482         return ret;
483 }
484
485 /************************************************
486  * clothModifier_do - main simulation function
487 ************************************************/
488 DerivedMesh *clothModifier_do(ClothModifierData *clmd,Object *ob, DerivedMesh *dm, int useRenderParams, int isFinalCalc)
489 {
490         unsigned int i;
491         unsigned int numverts = -1;
492         unsigned int numedges = -1;
493         unsigned int numfaces = -1;
494         MVert *mvert = NULL;
495         MEdge *medge = NULL;
496         MFace *mface = NULL;
497         DerivedMesh *result = NULL;
498         Cloth *cloth = clmd->clothObject;
499         unsigned int framenr = (float)G.scene->r.cfra;
500         float current_time = bsystem_time(ob, (float)G.scene->r.cfra, 0.0);
501         ListBase *effectors = NULL;
502         float deltaTime = current_time - clmd->sim_parms->sim_time;     
503
504         clmd->sim_parms->dt = 1.0f / (clmd->sim_parms->stepsPerFrame * G.scene->r.frs_sec);
505
506         result = CDDM_copy(dm);
507         
508         if(!result)
509         {
510                 return dm;
511         }
512         
513         numverts = result->getNumVerts(result);
514         numedges = result->getNumEdges(result);
515         numfaces = result->getNumFaces(result);
516         mvert = CDDM_get_verts(result);
517         medge = CDDM_get_edges(result);
518         mface = CDDM_get_faces(result);
519
520         clmd->sim_parms->sim_time = current_time;
521         
522         if ( current_time < clmd->sim_parms->firstframe )
523                 return result;
524         
525         // only be active during a specific period:
526         // that's "first frame" and "last frame" on GUI
527         /*
528         if ( clmd->clothObject )
529         {
530         if ( clmd->sim_parms->cache )
531         {
532         if ( current_time < clmd->sim_parms->firstframe )
533         {
534         int frametime = cloth_cache_first_frame ( clmd );
535         if ( cloth_cache_search_frame ( clmd, frametime ) )
536         {
537         cloth_cache_get_frame ( clmd, frametime );
538         cloth_to_object ( ob, result, clmd );
539 }
540         return result;
541 }
542         else if ( current_time > clmd->sim_parms->lastframe )
543         {
544         int frametime = cloth_cache_last_frame ( clmd );
545         if ( cloth_cache_search_frame ( clmd, frametime ) )
546         {
547         cloth_cache_get_frame ( clmd, frametime );
548         cloth_to_object ( ob, result, clmd );
549 }
550         return result;
551 }
552         else if ( ABS ( deltaTime ) >= 2.0f ) // no timewarps allowed
553         {
554         if ( cloth_cache_search_frame ( clmd, framenr ) )
555         {
556         cloth_cache_get_frame ( clmd, framenr );
557         cloth_to_object ( ob, result, clmd );
558 }
559         clmd->sim_parms->sim_time = current_time;
560         return result;
561 }
562 }
563 }
564         */
565         
566         if(deltaTime == 1.0f)
567         {
568                 if ((clmd->clothObject == NULL) || (numverts != clmd->clothObject->numverts) ) 
569                 {
570                         cloth_clear_cache(ob, clmd, 0);
571                         
572                         if(!cloth_from_object (ob, clmd, result, dm, framenr))
573                                 return result;
574
575                         if(clmd->clothObject == NULL)
576                                 return result;
577
578                         cloth = clmd->clothObject;
579                 }
580
581                 clmd->clothObject->old_solver_type = clmd->sim_parms->solver_type;
582
583                 // Insure we have a clmd->clothObject, in case allocation failed.
584                 if (clmd->clothObject != NULL) 
585                 {
586                         if(!cloth_read_cache(ob, clmd, framenr))
587                         {
588                                 // Force any pinned verts to their constrained location.
589                                 // has to be commented for verlet
590                                 for ( i = 0; i < clmd->clothObject->numverts; i++ )
591                                 {
592                                         // Save the previous position.
593                                         VECCOPY ( cloth->xold[i], cloth->xconst[i] );
594                                         VECCOPY ( cloth->current_xold[i], cloth->x[i] );
595                                         // Get the current position.
596                                         VECCOPY ( cloth->xconst[i], mvert[i].co );
597                                         Mat4MulVecfl ( ob->obmat, cloth->xconst[i] );
598                                 }
599                                 
600                                 tstart();
601                                 
602                                 /* Call the solver. */
603                                 if (solvers [clmd->sim_parms->solver_type].solver)
604                                         solvers [clmd->sim_parms->solver_type].solver (ob, framenr, clmd, effectors);
605                                 
606                                 tend();
607                                 
608                                 printf("Cloth simulation time: %f\n", tval());
609                                 
610                                 cloth_write_cache(ob, clmd, framenr);
611                         }
612
613                         // Copy the result back to the object.
614                         cloth_to_object (ob, result, clmd);
615                         
616                         // bvh_free(clmd->clothObject->tree);
617                         // clmd->clothObject->tree = bvh_build(clmd, clmd->coll_parms->epsilon);
618                 } 
619
620         }
621         else if ( ( deltaTime <= 0.0f ) || ( deltaTime > 1.0f ) )
622         {
623                 if ( clmd->clothObject != NULL )
624                 {
625                         if(cloth_read_cache(ob, clmd, framenr))
626                                 cloth_to_object (ob, result, clmd);
627                 }
628         }
629         
630         return result;
631 }
632
633 /* frees all */
634 void cloth_free_modifier (ClothModifierData *clmd)
635 {
636         Cloth   *cloth = NULL;
637
638         if(!clmd)
639                 return;
640
641         cloth = clmd->clothObject;
642
643         // free our frame cache
644         // cloth_clear_cache(ob, clmd, 0);
645
646         /* Calls the solver and collision frees first as they
647         * might depend on data in clmd->clothObject. */
648
649         if (cloth) 
650         {       
651                 // If our solver provides a free function, call it
652                 if (cloth->old_solver_type < 255 && solvers [cloth->old_solver_type].free) 
653                 {       
654                         solvers [cloth->old_solver_type].free (clmd);
655                 }
656                 
657                 // Free the verts.
658                 if (cloth->verts != NULL)
659                         MEM_freeN (cloth->verts);
660                 
661                 // Free the faces.
662                 if ( cloth->mfaces != NULL )
663                         MEM_freeN ( cloth->mfaces );
664                 
665                 // Free the verts.
666                 if ( cloth->x != NULL )
667                         MEM_freeN ( cloth->x );
668                 
669                 // Free the verts.
670                 if ( cloth->xold != NULL )
671                         MEM_freeN ( cloth->xold );
672                 
673                 // Free the verts.
674                 if ( cloth->v != NULL )
675                         MEM_freeN ( cloth->v );
676                 
677                 // Free the verts.
678                 if ( cloth->current_x != NULL )
679                         MEM_freeN ( cloth->current_x );
680                 
681                 // Free the verts.
682                 if ( cloth->current_xold != NULL )
683                         MEM_freeN ( cloth->current_xold );
684                 
685                 // Free the verts.
686                 if ( cloth->current_v != NULL )
687                         MEM_freeN ( cloth->current_v );
688                 
689                 // Free the verts.
690                 if ( cloth->xconst != NULL )
691                         MEM_freeN ( cloth->xconst );
692                 
693                 cloth->verts = NULL;
694                 cloth->numverts = -1;
695                 
696                 // Free the springs.
697                 if ( cloth->springs != NULL )
698                 {
699                         LinkNode *search = cloth->springs;
700                         while(search)
701                         {
702                                 ClothSpring *spring = search->link;
703                                                 
704                                 MEM_freeN ( spring );
705                                 search = search->next;
706                         }
707                         BLI_linklist_free(cloth->springs, NULL);
708                 
709                         cloth->springs = NULL;
710                 }
711
712                 cloth->numsprings = -1;
713                 
714                 // free BVH collision tree
715                 if(cloth->tree)
716                         bvh_free((BVH *)cloth->tree);
717                 
718                 // free BVH self collision tree
719                 if(cloth->selftree)
720                         bvh_free((BVH *)cloth->selftree);
721                 
722                 if(cloth->edgehash)
723                         BLI_edgehash_free ( cloth->edgehash, NULL );
724                 
725                 MEM_freeN (cloth);
726                 clmd->clothObject = NULL;
727         }
728
729 }
730
731
732
733 /******************************************************************************
734 *
735 * Internal functions.
736 *
737 ******************************************************************************/
738
739 /**
740  * cloth_to_object - copies the deformed vertices to the object.
741  *
742  * This function is a modified version of the softbody.c:softbody_to_object() function.
743  **/
744 static void cloth_to_object (Object *ob,  DerivedMesh *dm, ClothModifierData *clmd)
745 {
746         unsigned int    i = 0;
747         MVert *mvert = NULL;
748         unsigned int numverts;
749         Cloth *cloth = clmd->clothObject;
750
751         if (clmd->clothObject) {
752                 /* inverse matrix is not uptodate... */
753                 Mat4Invert (ob->imat, ob->obmat);
754
755                 mvert = CDDM_get_verts(dm);
756                 numverts = dm->getNumVerts(dm);
757
758                 for (i = 0; i < numverts; i++)
759                 {
760                         VECCOPY (mvert[i].co, cloth->x[i]);
761                         Mat4MulVecfl (ob->imat, mvert[i].co);   /* cloth is in global coords */
762                 }
763         }
764 }
765
766
767 /**
768  * cloth_apply_vgroup - applies a vertex group as specified by type
769  *
770  **/
771 static void cloth_apply_vgroup(ClothModifierData *clmd, DerivedMesh *dm, short vgroup)
772 {
773         unsigned int i = 0;
774         unsigned int j = 0;
775         MDeformVert     *dvert = NULL;
776         Cloth *clothObj = NULL;
777         unsigned int numverts = 0;
778         float goalfac = 0;
779         ClothVertex *verts = NULL;
780
781         clothObj = clmd->clothObject;
782
783         if ( !dm )
784                 return;
785
786         numverts = dm->getNumVerts(dm);
787
788         /* vgroup is 1 based, decrement so we can match the right group. */
789         --vgroup;
790
791         verts = clothObj->verts;
792
793         for ( i = 0; i < numverts; i++, verts++ )
794         {
795                 // LATER ON, support also mass painting here
796                 if ( clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_GOAL )
797                 {
798                         dvert = dm->getVertData ( dm, i, CD_MDEFORMVERT );
799                         if ( dvert )
800                         {
801                                 for ( j = 0; j < dvert->totweight; j++ )
802                                 {
803                                         if ( dvert->dw[j].def_nr == vgroup )
804                                         {
805                                                 verts->goal = dvert->dw [j].weight;
806
807                                                 goalfac= ABS ( clmd->sim_parms->maxgoal - clmd->sim_parms->mingoal );
808                                                 verts->goal  = ( float ) pow ( verts->goal , 4.0f );
809
810                                                 if ( dvert->dw [j].weight >=SOFTGOALSNAP )
811                                                 {
812                                                         verts->flags |= CVERT_FLAG_PINNED;
813                                                 }
814
815                                                 // TODO enable mass painting here, for the moment i let "goals" go first
816
817                                                 break;
818                                         }
819                                 }
820                         }
821                 }
822         }
823 }
824                 
825 // only meshes supported at the moment
826 static int cloth_from_object(Object *ob, ClothModifierData *clmd, DerivedMesh *dm, DerivedMesh *olddm, float framenr)
827 {
828         unsigned int i;
829         unsigned int numverts = dm->getNumVerts(dm);
830         MVert *mvert = CDDM_get_verts(dm);
831         float tnull[3] = {0,0,0};
832         
833         /* If we have a clothObject, free it. */
834         if (clmd->clothObject != NULL)
835                 cloth_free_modifier (clmd);
836
837         /* Allocate a new cloth object. */
838         clmd->clothObject = MEM_callocN (sizeof(Cloth), "cloth");
839         if (clmd->clothObject) 
840         {
841                 clmd->clothObject->old_solver_type = 255;
842                 clmd->clothObject->edgehash = NULL;
843         }
844         else if (clmd->clothObject == NULL) 
845         {
846                 modifier_setError (&(clmd->modifier), "Out of memory on allocating clmd->clothObject.");
847                 return 0;
848         }
849
850         switch (ob->type)
851         {
852                 case OB_MESH:
853                 
854                         // mesh input objects need DerivedMesh
855                         if ( !dm )
856                                 return 0;
857
858                         cloth_from_mesh (ob, clmd, dm, framenr);
859
860                         if ( clmd->clothObject != NULL )
861                         {
862                                 /* create springs */
863                                 clmd->clothObject->springs = NULL;
864                                 clmd->clothObject->numsprings = -1;
865                                         
866                                 /* set initial values */
867                                 for (i = 0; i < numverts; ++i)
868                                 {
869                                         VECCOPY (clmd->clothObject->x[i], mvert[i].co);
870                                         Mat4MulVecfl(ob->obmat, clmd->clothObject->x[i]);
871         
872                                         clmd->clothObject->verts [i].mass = clmd->sim_parms->mass;
873                                         if ( clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_GOAL )
874                                                 clmd->clothObject->verts [i].goal= clmd->sim_parms->defgoal;
875                                         else
876                                                 clmd->clothObject->verts [i].goal= 0.0;
877                                         clmd->clothObject->verts [i].flags = 0;
878                                         VECCOPY(clmd->clothObject->xold[i], clmd->clothObject->x[i]);
879                                         VECCOPY(clmd->clothObject->xconst[i], clmd->clothObject->x[i]);
880                                         VECCOPY(clmd->clothObject->current_xold[i], clmd->clothObject->x[i]);
881                                         VecMulf(clmd->clothObject->v[i], 0.0);
882         
883                                         clmd->clothObject->verts [i].impulse_count = 0;
884                                         VECCOPY ( clmd->clothObject->verts [i].impulse, tnull );
885                                 }
886                                 
887                                 if (!cloth_build_springs (clmd->clothObject, dm) )
888                                 {
889                                         modifier_setError (&(clmd->modifier), "Can't build springs.");
890                                         return 0;
891                                 }  
892         
893                                 /* apply / set vertex groups */
894                                 if (clmd->sim_parms->vgroup_mass > 0)
895                                         cloth_apply_vgroup (clmd, olddm, clmd->sim_parms->vgroup_mass);
896         
897                                 /* init our solver */
898                                 if (solvers [clmd->sim_parms->solver_type].init)
899                                         solvers [clmd->sim_parms->solver_type].init (ob, clmd);
900         
901                                 clmd->clothObject->tree = bvh_build_from_float3(CDDM_get_faces(dm), dm->getNumFaces(dm), clmd->clothObject->x, numverts, clmd->coll_parms->epsilon);
902                                 
903                                 clmd->clothObject->selftree = bvh_build_from_float3(NULL, 0, clmd->clothObject->x, numverts, clmd->coll_parms->selfepsilon);
904                                 
905                                 // save initial state
906                                 cloth_write_cache(ob, clmd, framenr-1);
907                         }
908                         return 1;
909                         default: return 0; // TODO - we do not support changing meshes
910         }
911         
912         return 0;
913 }
914
915 static void cloth_from_mesh (Object *ob, ClothModifierData *clmd, DerivedMesh *dm, float framenr)
916 {
917         unsigned int numverts = dm->getNumVerts(dm);
918         unsigned int numfaces = dm->getNumFaces(dm);
919         MFace *mface = CDDM_get_faces(dm);
920
921         /* Allocate our vertices.
922         */
923         clmd->clothObject->numverts = numverts;
924         clmd->clothObject->verts = MEM_callocN (sizeof (ClothVertex) * clmd->clothObject->numverts, "clothVertex");
925         if (clmd->clothObject->verts == NULL) 
926         {
927                 cloth_free_modifier (clmd);
928                 modifier_setError (&(clmd->modifier), "Out of memory on allocating clmd->clothObject->verts.");
929                 return;
930         }
931         
932         clmd->clothObject->x = MEM_callocN ( sizeof ( float ) * clmd->clothObject->numverts * 4, "Cloth MVert_x" );
933         if ( clmd->clothObject->x == NULL )
934         {
935                 cloth_free_modifier ( clmd );
936                 modifier_setError ( & ( clmd->modifier ), "Out of memory on allocating clmd->clothObject->x." );
937                 return;
938         }
939         
940         clmd->clothObject->xold = MEM_callocN ( sizeof ( float ) * clmd->clothObject->numverts * 4, "Cloth MVert_xold" );
941         if ( clmd->clothObject->xold == NULL )
942         {
943                 cloth_free_modifier ( clmd );
944                 modifier_setError ( & ( clmd->modifier ), "Out of memory on allocating clmd->clothObject->xold." );
945                 return;
946         }
947         
948         clmd->clothObject->v = MEM_callocN ( sizeof ( float ) * clmd->clothObject->numverts * 4, "Cloth MVert_v" );
949         if ( clmd->clothObject->v == NULL )
950         {
951                 cloth_free_modifier ( clmd );
952                 modifier_setError ( & ( clmd->modifier ), "Out of memory on allocating clmd->clothObject->v." );
953                 return;
954         }
955         
956         clmd->clothObject->current_x = MEM_callocN ( sizeof ( float ) * clmd->clothObject->numverts * 4, "Cloth MVert_current_x" );
957         if ( clmd->clothObject->current_x == NULL )
958         {
959                 cloth_free_modifier ( clmd );
960                 modifier_setError ( & ( clmd->modifier ), "Out of memory on allocating clmd->clothObject->current_x." );
961                 return;
962         }
963         
964         clmd->clothObject->current_xold = MEM_callocN ( sizeof ( float ) * clmd->clothObject->numverts * 4, "Cloth MVert_current_xold" );
965         if ( clmd->clothObject->current_xold == NULL )
966         {
967                 cloth_free_modifier ( clmd );
968                 modifier_setError ( & ( clmd->modifier ), "Out of memory on allocating clmd->clothObject->current_xold." );
969                 return;
970         }
971         
972         clmd->clothObject->current_v = MEM_callocN ( sizeof ( float ) * clmd->clothObject->numverts * 4, "Cloth MVert_current_v" );
973         if ( clmd->clothObject->current_v == NULL )
974         {
975                 cloth_free_modifier ( clmd );
976                 modifier_setError ( & ( clmd->modifier ), "Out of memory on allocating clmd->clothObject->current_v." );
977                 return;
978         }
979         
980         clmd->clothObject->xconst = MEM_callocN ( sizeof ( float ) * clmd->clothObject->numverts * 4, "Cloth MVert_xconst" );
981         if ( clmd->clothObject->xconst == NULL )
982         {
983                 cloth_free_modifier ( clmd );
984                 modifier_setError ( & ( clmd->modifier ), "Out of memory on allocating clmd->clothObject->xconst." );
985                 return;
986         }
987
988         // save face information
989         clmd->clothObject->numfaces = numfaces;
990         clmd->clothObject->mfaces = MEM_callocN (sizeof (MFace) * clmd->clothObject->numfaces, "clothMFaces");
991         if (clmd->clothObject->mfaces == NULL) 
992         {
993                 cloth_free_modifier (clmd);
994                 modifier_setError (&(clmd->modifier), "Out of memory on allocating clmd->clothObject->mfaces.");
995                 return;
996         }
997         memcpy(clmd->clothObject->mfaces, mface, sizeof(MFace)*numfaces);
998
999         /* Free the springs since they can't be correct if the vertices
1000         * changed.
1001         */
1002         if (clmd->clothObject->springs != NULL)
1003                 MEM_freeN (clmd->clothObject->springs);
1004
1005 }
1006
1007 /***************************************************************************************
1008 * SPRING NETWORK BUILDING IMPLEMENTATION BEGIN
1009 ***************************************************************************************/
1010
1011 // be carefull: implicit solver has to be resettet when using this one!
1012 int cloth_add_spring ( ClothModifierData *clmd, unsigned int indexA, unsigned int indexB, float restlength, int spring_type)
1013 {
1014         Cloth *cloth = clmd->clothObject;
1015         ClothSpring *spring = NULL;
1016         
1017         if(cloth)
1018         {
1019                 // TODO: look if this spring is already there
1020                 
1021                 spring = ( ClothSpring * ) MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );
1022                 
1023                 spring->ij = indexA;
1024                 spring->kl = indexB;
1025                 spring->restlen =  restlength;
1026                 spring->type = spring_type;
1027                 spring->flags = 0;
1028                 
1029                 cloth->numsprings++;
1030         
1031                 BLI_linklist_append ( &cloth->springs, spring );
1032                 
1033                 return 1;
1034         }
1035         return 0;
1036 }
1037
1038 int cloth_build_springs ( Cloth *cloth, DerivedMesh *dm )
1039 {
1040         ClothSpring *spring = NULL, *tspring = NULL, *tspring2 = NULL;
1041         unsigned int struct_springs = 0, shear_springs=0, bend_springs = 0;
1042         unsigned int i = 0;
1043         unsigned int numverts = dm->getNumVerts ( dm );
1044         unsigned int numedges = dm->getNumEdges ( dm );
1045         unsigned int numfaces = dm->getNumFaces ( dm );
1046         MEdge *medge = CDDM_get_edges ( dm );
1047         MFace *mface = CDDM_get_faces ( dm );
1048         unsigned int index2 = 0; // our second vertex index
1049         LinkNode **edgelist = NULL;
1050         EdgeHash *edgehash = NULL;
1051         LinkNode *search = NULL, *search2 = NULL;
1052         float temp[3];
1053         LinkNode *node = NULL, *node2 = NULL;
1054         
1055         // error handling
1056         if ( numedges==0 )
1057                 return 0;
1058
1059         cloth->springs = NULL;
1060
1061         edgelist = MEM_callocN ( sizeof ( LinkNode * ) * numverts, "cloth_edgelist_alloc" );
1062         for ( i = 0; i < numverts; i++ )
1063         {
1064                 edgelist[i] = NULL;
1065         }
1066
1067         if ( cloth->springs )
1068                 MEM_freeN ( cloth->springs );
1069
1070         // create spring network hash
1071         edgehash = BLI_edgehash_new();
1072
1073         // structural springs
1074         for ( i = 0; i < numedges; i++ )
1075         {
1076                 spring = ( ClothSpring * ) MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );
1077
1078                 if ( spring )
1079                 {
1080                         spring->ij = medge[i].v1;
1081                         spring->kl = medge[i].v2;
1082                         VECSUB ( temp, cloth->x[spring->kl], cloth->x[spring->ij] );
1083                         spring->restlen =  sqrt ( INPR ( temp, temp ) );
1084                         spring->type = CLOTH_SPRING_TYPE_STRUCTURAL;
1085                         spring->flags = 0;
1086                         struct_springs++;
1087                         
1088                         if(!i)
1089                                 node2 = BLI_linklist_append_fast ( &cloth->springs, spring );
1090                         else
1091                                 node2 = BLI_linklist_append_fast ( &node->next, spring );
1092                         node = node2;
1093                 }
1094         }
1095         
1096         // shear springs
1097         for ( i = 0; i < numfaces; i++ )
1098         {
1099                 spring = ( ClothSpring *) MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );
1100
1101                 spring->ij = mface[i].v1;
1102                 spring->kl = mface[i].v3;
1103                 VECSUB ( temp, cloth->x[spring->kl], cloth->x[spring->ij] );
1104                 spring->restlen =  sqrt ( INPR ( temp, temp ) );
1105                 spring->type = CLOTH_SPRING_TYPE_SHEAR;
1106
1107                 BLI_linklist_append ( &edgelist[spring->ij], spring );
1108                 BLI_linklist_append ( &edgelist[spring->kl], spring );
1109                 shear_springs++;
1110
1111                 node2 = BLI_linklist_append_fast ( &node->next, spring );
1112                 node = node2;
1113
1114                 if ( mface[i].v4 )
1115                 {
1116                         spring = ( ClothSpring * ) MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );
1117
1118                         spring->ij = mface[i].v2;
1119                         spring->kl = mface[i].v4;
1120                         VECSUB ( temp, cloth->x[spring->kl], cloth->x[spring->ij] );
1121                         spring->restlen =  sqrt ( INPR ( temp, temp ) );
1122                         spring->type = CLOTH_SPRING_TYPE_SHEAR;
1123
1124                         BLI_linklist_append ( &edgelist[spring->ij], spring );
1125                         BLI_linklist_append ( &edgelist[spring->kl], spring );
1126                         shear_springs++;
1127
1128                         node2 = BLI_linklist_append_fast ( &node->next, spring );
1129                         node = node2;
1130                 }
1131         }
1132         
1133         // bending springs
1134         search2 = cloth->springs;
1135         for ( i = struct_springs; i < struct_springs+shear_springs; i++ )
1136         {
1137                 if ( !search2 )
1138                         break;
1139
1140                 tspring2 = search2->link;
1141                 search = edgelist[tspring2->kl];
1142                 while ( search )
1143                 {
1144                         tspring = search->link;
1145                         index2 = ( ( tspring->ij==tspring2->kl ) ? ( tspring->kl ) : ( tspring->ij ) );
1146                         
1147                         // check for existing spring
1148                         // check also if startpoint is equal to endpoint
1149                         if ( !BLI_edgehash_haskey ( edgehash, index2, tspring2->ij )
1150                         && !BLI_edgehash_haskey ( edgehash, tspring2->ij, index2 )
1151                         && ( index2!=tspring2->ij ) )
1152                         {
1153                                 spring = ( ClothSpring * ) MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );
1154
1155                                 spring->ij = tspring2->ij;
1156                                 spring->kl = index2;
1157                                 VECSUB ( temp, cloth->x[index2], cloth->x[tspring2->ij] );
1158                                 spring->restlen =  sqrt ( INPR ( temp, temp ) );
1159                                 spring->type = CLOTH_SPRING_TYPE_BENDING;
1160                                 BLI_edgehash_insert ( edgehash, spring->ij, index2, NULL );
1161                                 bend_springs++;
1162
1163                                 node2 = BLI_linklist_append_fast ( &node->next, spring );
1164                                 node = node2;
1165                         }
1166                         search = search->next;
1167                 }
1168                 search2 = search2->next;
1169         }
1170         
1171         cloth->numspringssave = cloth->numsprings = struct_springs + shear_springs + bend_springs;
1172         cloth->numothersprings = struct_springs + shear_springs;
1173         
1174         for ( i = 0; i < numverts; i++ )
1175         {
1176                 BLI_linklist_free ( edgelist[i],NULL );
1177         }
1178         if ( edgelist )
1179                 MEM_freeN ( edgelist );
1180         
1181         cloth->edgehash = edgehash;
1182
1183         return 1;
1184
1185 } /* cloth_build_springs */
1186 /***************************************************************************************
1187 * SPRING NETWORK BUILDING IMPLEMENTATION END
1188 ***************************************************************************************/
1189