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