svn merge -r 13452:14721 https://svn.blender.org/svnroot/bf-blender/trunk/blender

1 files changed, 412 insertions, 681 deletions

diff --git a/source/blender/blenkernel/intern/cloth.c b/source/blender/blenkernel/intern/cloth.c
index a99ac705c0b..4be4434dfda 100644
--- a/source/blender/blenkernel/intern/cloth.c
+++ b/source/blender/blenkernel/intern/cloth.c
@@ -1,15 +1,12 @@
 /*  cloth.c
 *
 *
-* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+* ***** BEGIN GPL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
-* of the License, or (at your option) any later version. The Blender
-* Foundation also sells licenses for use in proprietary software under
-* the Blender License.  See http://www.blender.org/BL/ for information
-* about this.
+* of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -23,58 +20,28 @@
 * The Original Code is Copyright (C) Blender Foundation
 * All rights reserved.
 *
-* The Original Code is: all of this file.
+* Contributor(s): Daniel Genrich
 *
-* Contributor(s): none yet.
-*
-* ***** END GPL/BL DUAL LICENSE BLOCK *****
+* ***** END GPL LICENSE BLOCK *****
 */
 
-
-#include <math.h>
-#include <stdlib.h>
-#include <string.h>
-
 #include "MEM_guardedalloc.h"
 
-/* types */
-#include "DNA_curve_types.h"
-#include "DNA_object_types.h"
-#include "DNA_object_force.h"
+#include "BKE_cloth.h"
+
 #include "DNA_cloth_types.h"
-#include "DNA_key_types.h"
 #include "DNA_mesh_types.h"
-#include "DNA_meshdata_types.h"
-#include "DNA_lattice_types.h"
+#include "DNA_object_force.h"
 #include "DNA_scene_types.h"
-#include "DNA_modifier_types.h"
 
-#include "BLI_blenlib.h"
-#include "BLI_arithb.h"
-#include "BLI_edgehash.h"
-#include "BLI_linklist.h"
-
-#include "BKE_curve.h"
 #include "BKE_deform.h"
 #include "BKE_DerivedMesh.h"
 #include "BKE_cdderivedmesh.h"
-#include "BKE_displist.h"
 #include "BKE_effect.h"
 #include "BKE_global.h"
-#include "BKE_key.h"
-#include "BKE_mesh.h"
 #include "BKE_object.h"
-#include "BKE_cloth.h"
 #include "BKE_modifier.h"
 #include "BKE_utildefines.h"
-#include "BKE_DerivedMesh.h"
-#include "BIF_editdeform.h"
-#include "BIF_editkey.h"
-#include "DNA_screen_types.h"
-#include "BSE_headerbuttons.h"
-#include "BIF_screen.h"
-#include "BIF_space.h"
-#include "mydevice.h"
 
 #include "BKE_pointcache.h"
 
@@ -90,9 +57,9 @@ double tval()
 }
 #else
 #include <sys/time.h>
-static struct timeval _tstart, _tend;
-static struct timezone tz;
-void tstart ( void )
+			 static struct timeval _tstart, _tend;
+	 static struct timezone tz;
+	 void tstart ( void )
 {
 	gettimeofday ( &_tstart, &tz );
 }
@@ -113,17 +80,17 @@ double tval()
 // 255 is the magic reserved number, so NEVER try to put 255 solvers in here!
 // 254 = MAX!
 static CM_SOLVER_DEF	solvers [] =
-    {
-        { "Implicit", CM_IMPLICIT, implicit_init, implicit_solver, implicit_free },
+{
+	{ "Implicit", CM_IMPLICIT, implicit_init, implicit_solver, implicit_free },
         // { "Implicit C++", CM_IMPLICITCPP, implicitcpp_init, implicitcpp_solver, implicitcpp_free },
-    };
+};
 
 /* ********** cloth engine ******* */
 /* Prototypes for internal functions.
 */
 static void cloth_to_object (Object *ob,  ClothModifierData *clmd, DerivedMesh *dm);
 static void cloth_from_mesh ( Object *ob, ClothModifierData *clmd, DerivedMesh *dm );
-static int cloth_from_object(Object *ob, ClothModifierData *clmd, DerivedMesh *dm, float framenr);
+static int cloth_from_object(Object *ob, ClothModifierData *clmd, DerivedMesh *dm, float framenr, int first);
 int cloth_build_springs ( ClothModifierData *clmd, DerivedMesh *dm );
 static void cloth_apply_vgroup ( ClothModifierData *clmd, DerivedMesh *dm );
 
@@ -134,42 +101,41 @@ static void cloth_apply_vgroup ( ClothModifierData *clmd, DerivedMesh *dm );
 *
 ******************************************************************************/
 /**
-* cloth_init -  creates a new cloth simulation.
-*
-* 1. create object
-* 2. fill object with standard values or with the GUI settings if given
-*/
+ * cloth_init -  creates a new cloth simulation.
+ *
+ * 1. create object
+ * 2. fill object with standard values or with the GUI settings if given
+ */
 void cloth_init ( ClothModifierData *clmd )
 {	
 	/* Initialize our new data structure to reasonable values. */
 	clmd->sim_parms->gravity [0] = 0.0;
 	clmd->sim_parms->gravity [1] = 0.0;
 	clmd->sim_parms->gravity [2] = -9.81;
-	clmd->sim_parms->structural = 200.0;
-	clmd->sim_parms->shear = 200.0;
-	clmd->sim_parms->bending = 0.1;
-	clmd->sim_parms->Cdis = 5.0;
+	clmd->sim_parms->structural = 15.0;
+	clmd->sim_parms->shear = 15.0;
+	clmd->sim_parms->bending = 0.5;
+	clmd->sim_parms->Cdis = 5.0; 
 	clmd->sim_parms->Cvi = 1.0;
-	clmd->sim_parms->mass = 1.0f;
+	clmd->sim_parms->mass = 0.3f;
 	clmd->sim_parms->stepsPerFrame = 5;
-	clmd->sim_parms->sim_time = 1.0;
 	clmd->sim_parms->flags = 0;
 	clmd->sim_parms->solver_type = 0;
 	clmd->sim_parms->preroll = 0;
 	clmd->sim_parms->maxspringlen = 10;
-	clmd->sim_parms->firstframe = 1;
-	clmd->sim_parms->lastframe = 250;
 	clmd->sim_parms->vgroup_mass = 0;
-	clmd->sim_parms->lastcachedframe = 0;
-	clmd->sim_parms->editedframe = 0;
-	clmd->sim_parms->autoprotect = 25;
-	clmd->sim_parms->firstcachedframe = -1.0;
+	clmd->sim_parms->avg_spring_len = 0.0;
+	clmd->sim_parms->presets = 2; /* cotton as start setting */
+	clmd->sim_parms->timescale = 1.0f; /* speed factor, describes how fast cloth moves */
 	
 	clmd->coll_parms->self_friction = 5.0;
-	clmd->coll_parms->friction = 10.0;
+	clmd->coll_parms->friction = 5.0;
 	clmd->coll_parms->loop_count = 3;
 	clmd->coll_parms->epsilon = 0.015f;
 	clmd->coll_parms->flags = CLOTH_COLLSETTINGS_FLAG_ENABLED;
+	clmd->coll_parms->collision_list = NULL;
+	clmd->coll_parms->self_loop_count = 1.0;
+	clmd->coll_parms->selfepsilon = 0.75;
 
 	/* These defaults are copied from softbody.c's
 	* softbody_calc_forces() function.
@@ -181,7 +147,7 @@ void cloth_init ( ClothModifierData *clmd )
 	clmd->sim_parms->maxgoal = 1.0f;
 	clmd->sim_parms->mingoal = 0.0f;
 	clmd->sim_parms->defgoal = 0.0f;
-	clmd->sim_parms->goalspring = 100.0f;
+	clmd->sim_parms->goalspring = 1.0f;
 	clmd->sim_parms->goalfrict = 0.0f;
 }
 
@@ -203,6 +169,10 @@ BVH *bvh_build_from_cloth (ClothModifierData *clmd, float epsilon)
 	
 	verts = cloth->verts;
 	
+	// in the moment, return zero if no faces there
+	if(!cloth->numfaces)
+		return NULL;
+	
 	bvh = MEM_callocN(sizeof(BVH), "BVH");
 	if (bvh == NULL) 
 	{
@@ -212,11 +182,6 @@ BVH *bvh_build_from_cloth (ClothModifierData *clmd, float epsilon)
 	
 	// springs = cloth->springs;
 	// numsprings = cloth->numsprings;
-	
-	bvh->flags = 0;
-	bvh->leaf_tree = NULL;
-	bvh->leaf_root = NULL;
-	bvh->tree = NULL;
 
 	bvh->epsilon = epsilon;
 	bvh->numfaces = cloth->numfaces;
@@ -225,12 +190,17 @@ BVH *bvh_build_from_cloth (ClothModifierData *clmd, float epsilon)
 	bvh->numverts = cloth->numverts;
 	
 	bvh->current_x = MEM_callocN ( sizeof ( MVert ) * bvh->numverts, "bvh->current_x" );
-	bvh->current_xold = MEM_callocN ( sizeof ( MVert ) * bvh->numverts, "bvh->current_xold" );
+	
+	if (bvh->current_x == NULL) 
+	{
+		printf("bvh: Out of memory.\n");
+		MEM_freeN(bvh);
+		return NULL;
+	}
 	
 	for(i = 0; i < bvh->numverts; i++)
 	{
 		VECCOPY(bvh->current_x[i].co, verts[i].tx);
-		VECCOPY(bvh->current_xold[i].co, verts[i].txold);
 	}
 	
 	bvh_build (bvh);
@@ -263,589 +233,265 @@ void bvh_update_from_cloth(ClothModifierData *clmd, int moving)
 	bvh_update(bvh, moving);
 }
 
-// unused in the moment, cloth needs quads from mesh
-DerivedMesh *CDDM_convert_to_triangle ( DerivedMesh *dm )
-{
-	DerivedMesh *result = NULL;
-	int i;
-	int numverts = dm->getNumVerts ( dm );
-	int numedges = dm->getNumEdges ( dm );
-	int numfaces = dm->getNumFaces ( dm );
-
-	MVert *mvert = CDDM_get_verts ( dm );
-	MEdge *medge = CDDM_get_edges ( dm );
-	MFace *mface = CDDM_get_faces ( dm );
-
-	MVert *mvert2;
-	MFace *mface2;
-	unsigned int numtris=0;
-	unsigned int numquads=0;
-	int a = 0;
-	int random = 0;
-	int firsttime = 0;
-	float vec1[3], vec2[3], vec3[3], vec4[3], vec5[3];
-	float mag1=0, mag2=0;
-
-	for ( i = 0; i < numfaces; i++ )
-	{
-		if ( mface[i].v4 )
-			numquads++;
-		else
-			numtris++;
-	}
-
-	result = CDDM_from_template ( dm, numverts, 0, numtris + 2*numquads );
-
-	if ( !result )
-		return NULL;
-
-	// do verts
-	mvert2 = CDDM_get_verts ( result );
-	for ( a=0; a<numverts; a++ )
-	{
-		MVert *inMV;
-		MVert *mv = &mvert2[a];
-
-		inMV = &mvert[a];
-
-		DM_copy_vert_data ( dm, result, a, a, 1 );
-		*mv = *inMV;
-	}
-
-
-	// do faces
-	mface2 = CDDM_get_faces ( result );
-	for ( a=0, i=0; a<numfaces; a++ )
-	{
-		MFace *mf = &mface2[i];
-		MFace *inMF;
-		inMF = &mface[a];
-
-		/*
-		DM_copy_face_data(dm, result, a, i, 1);
-
-		*mf = *inMF;
-		*/
-
-		if ( mface[a].v4 && random==1 )
-		{
-			mf->v1 = mface[a].v2;
-			mf->v2 = mface[a].v3;
-			mf->v3 = mface[a].v4;
-		}
-		else
-		{
-			mf->v1 = mface[a].v1;
-			mf->v2 = mface[a].v2;
-			mf->v3 = mface[a].v3;
-		}
-
-		mf->v4 = 0;
-		mf->flag |= ME_SMOOTH;
-
-		test_index_face ( mf, NULL, 0, 3 );
-
-		if ( mface[a].v4 )
-		{
-			MFace *mf2;
-
-			i++;
-
-			mf2 = &mface2[i];
-			/*
-			DM_copy_face_data(dm, result, a, i, 1);
-
-			*mf2 = *inMF;
-			*/
-
-			if ( random==1 )
-			{
-				mf2->v1 = mface[a].v1;
-				mf2->v2 = mface[a].v2;
-				mf2->v3 = mface[a].v4;
-			}
-			else
-			{
-				mf2->v1 = mface[a].v4;
-				mf2->v2 = mface[a].v1;
-				mf2->v3 = mface[a].v3;
-			}
-			mf2->v4 = 0;
-			mf2->flag |= ME_SMOOTH;
-
-			test_index_face ( mf2, NULL, 0, 3 );
-		}
-
-		i++;
-	}
-
-	CDDM_calc_edges ( result );
-	CDDM_calc_normals ( result );
-
-	return result;
-
-}
-
-
-DerivedMesh *CDDM_create_tearing ( ClothModifierData *clmd, DerivedMesh *dm )
-{
-	DerivedMesh *result = NULL;
-	unsigned int i = 0, a = 0, j=0;
-	int numverts = dm->getNumVerts ( dm );
-	int numedges = dm->getNumEdges ( dm );
-	int numfaces = dm->getNumFaces ( dm );
-
-	MVert *mvert = CDDM_get_verts ( dm );
-	MEdge *medge = CDDM_get_edges ( dm );
-	MFace *mface = CDDM_get_faces ( dm );
-
-	MVert *mvert2;
-	MFace *mface2;
-	unsigned int numtris=0;
-	unsigned int numquads=0;
-	EdgeHash *edgehash = NULL;
-	Cloth *cloth = clmd->clothObject;
-	ClothSpring *springs = cloth->springs;
-	unsigned int numsprings = cloth->numsprings;
-
-	// create spring tearing hash
-	edgehash = BLI_edgehash_new();
-
-	for ( i = 0; i < numsprings; i++ )
-	{
-		if ( ( springs[i].flags & CLOTH_SPRING_FLAG_DEACTIVATE )
-		        && ( !BLI_edgehash_haskey ( edgehash, springs[i].ij, springs[i].kl ) ) )
-		{
-			BLI_edgehash_insert ( edgehash, springs[i].ij, springs[i].kl, NULL );
-			BLI_edgehash_insert ( edgehash, springs[i].kl, springs[i].ij, NULL );
-			j++;
-		}
-	}
-
-	// printf("found %d tears\n", j);
-
-	result = CDDM_from_template ( dm, numverts, 0, numfaces );
-
-	if ( !result )
-		return NULL;
-
-	// do verts
-	mvert2 = CDDM_get_verts ( result );
-	for ( a=0; a<numverts; a++ )
-	{
-		MVert *inMV;
-		MVert *mv = &mvert2[a];
-
-		inMV = &mvert[a];
-
-		DM_copy_vert_data ( dm, result, a, a, 1 );
-		*mv = *inMV;
-	}
-
-
-	// do faces
-	mface2 = CDDM_get_faces ( result );
-	for ( a=0, i=0; a<numfaces; a++ )
-	{
-		MFace *mf = &mface2[i];
-		MFace *inMF;
-		inMF = &mface[a];
-
-		/*
-		DM_copy_face_data(dm, result, a, i, 1);
-
-		*mf = *inMF;
-		*/
-
-		if ( ( !BLI_edgehash_haskey ( edgehash, mface[a].v1, mface[a].v2 ) )
-		        && ( !BLI_edgehash_haskey ( edgehash, mface[a].v2, mface[a].v3 ) )
-		        && ( !BLI_edgehash_haskey ( edgehash, mface[a].v3, mface[a].v4 ) )
-		        && ( !BLI_edgehash_haskey ( edgehash, mface[a].v4, mface[a].v1 ) ) )
-		{
-			mf->v1 = mface[a].v1;
-			mf->v2 = mface[a].v2;
-			mf->v3 = mface[a].v3;
-			mf->v4 = mface[a].v4;
-
-			test_index_face ( mf, NULL, 0, 4 );
-
-			i++;
-		}
-	}
-
-	CDDM_lower_num_faces ( result, i );
-	CDDM_calc_edges ( result );
-	CDDM_calc_normals ( result );
-
-	BLI_edgehash_free ( edgehash, NULL );
-
-	return result;
-}
-
 int modifiers_indexInObject(Object *ob, ModifierData *md_seek);
 
 int cloth_read_cache(Object *ob, ClothModifierData *clmd, float framenr)
 {
-	FILE *fp = NULL;
-	int stack_index = -1;
-	unsigned int a, ret = 1;
+	PTCacheID pid;
+	PTCacheFile *pf;
 	Cloth *cloth = clmd->clothObject;
+	unsigned int a, ret = 1;
 	
 	if(!cloth)
 		return 0;
 	
-	stack_index = modifiers_indexInObject(ob, (ModifierData *)clmd);
-	
-	fp = BKE_ptcache_id_fopen((ID *)ob, 'r', framenr, stack_index);
-	if(!fp)
-		ret = 0;
-	else {
-		for(a = 0; a < cloth->numverts; a++)
-		{
-			if(fread(&cloth->verts[a].x, sizeof(float), 3, fp) != 3) 
-			{
+	BKE_ptcache_id_from_cloth(&pid, ob, clmd);
+	pf = BKE_ptcache_file_open(&pid, PTCACHE_FILE_READ, framenr);
+	if(pf) {
+		for(a = 0; a < cloth->numverts; a++) {
+			if(!BKE_ptcache_file_read_floats(pf, cloth->verts[a].x, 3)) {
 				ret = 0;
 				break;
 			}
-			if(fread(&cloth->verts[a].xconst, sizeof(float), 3, fp) != 3) 
-			{
+			if(!BKE_ptcache_file_read_floats(pf, cloth->verts[a].xconst, 3)) {
 				ret = 0;
 				break;
 			}
-			if(fread(&cloth->verts[a].v, sizeof(float), 3, fp) != 3) 
-			{
+			if(!BKE_ptcache_file_read_floats(pf, cloth->verts[a].v, 3)) {
 				ret = 0;
 				break;
 			}
 		}
 		
-		fclose(fp);
-		
-		if(clmd->sim_parms->lastcachedframe < framenr)
-		{
-			if(G.rt > 0)
-			printf("cloth_read_cache problem: lnex - f#: %f, lastCF: %d\n", framenr, clmd->sim_parms->lastcachedframe);
-		}
+		BKE_ptcache_file_close(pf);
 	}
-	
-	if(G.rt > 0)
-	printf("cloth_read_cache: %f\n", framenr);
+	else
+		ret = 0;
 	
 	return ret;
 }
 
 void cloth_clear_cache(Object *ob, ClothModifierData *clmd, float framenr)
 {
-	int stack_index = -1;
+	PTCacheID pid;
 	
+	BKE_ptcache_id_from_cloth(&pid, ob, clmd);
+
 	// don't do anything as long as we're in editmode!
-	if(clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_EDITMODE)
-	{
-		/* delete cache free request */
-		clmd->sim_parms->flags &= ~CLOTH_SIMSETTINGS_FLAG_CCACHE_FFREE;
-		
+	if(pid.cache->flag & PTCACHE_BAKE_EDIT_ACTIVE)
 		return;
-	}
-	
-	/* clear cache if specific frame cleaning requested or cache is not protected */
-	if((!(clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_CCACHE_PROTECT)) || (clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_CCACHE_FFREE))
-	{
-		stack_index = modifiers_indexInObject(ob, (ModifierData *)clmd);
-		
-		BKE_ptcache_id_clear((ID *)ob, PTCACHE_CLEAR_AFTER, framenr, stack_index);
-		
-		/* update last cached frame # */
-		clmd->sim_parms->lastcachedframe = framenr;
-		
-		/* update first cached frame # */
-		if((framenr < clmd->sim_parms->firstcachedframe) && (clmd->sim_parms->firstcachedframe >=0.0))
-			clmd->sim_parms->firstcachedframe = -1.0;
-		
-		if(G.rt > 0)
-		printf("cloth_clear_cache: %f\n", framenr);
-	}
-	
-	/* delete cache free request */
-	clmd->sim_parms->flags &= ~CLOTH_SIMSETTINGS_FLAG_CCACHE_FFREE;
-	
 	
+	BKE_ptcache_id_clear(&pid, PTCACHE_CLEAR_AFTER, framenr);
 }
+
 void cloth_write_cache(Object *ob, ClothModifierData *clmd, float framenr)
 {
-	FILE *fp = NULL;
-	int stack_index = -1;
-	unsigned int a;
 	Cloth *cloth = clmd->clothObject;
-	
-	if(G.rt > 0)
-	printf("cloth_write_cache: %f\n", framenr);
+	PTCacheID pid;
+	PTCacheFile *pf;
+	unsigned int a;
 	
 	if(!cloth)
-	{
-		if(G.rt > 0)
-		printf("cloth_write_cache: no cloth\n");
 		return;
-	}
-	
-	stack_index = modifiers_indexInObject(ob, (ModifierData *)clmd);
 	
-	fp = BKE_ptcache_id_fopen((ID *)ob, 'w', framenr, stack_index);
-	if(!fp)
-	{
-		if(G.rt > 0)
-		printf("cloth_write_cache: no fp\n");
+	BKE_ptcache_id_from_cloth(&pid, ob, clmd);
+	pf = BKE_ptcache_file_open(&pid, PTCACHE_FILE_WRITE, framenr);
+	if(!pf)
 		return;
-	}
 	
-	for(a = 0; a < cloth->numverts; a++)
-	{
-		fwrite(&cloth->verts[a].x, sizeof(float),3,fp);
-		fwrite(&cloth->verts[a].xconst, sizeof(float),3,fp);
-		fwrite(&cloth->verts[a].v, sizeof(float),3,fp);
+	for(a = 0; a < cloth->numverts; a++) {
+		BKE_ptcache_file_write_floats(pf, cloth->verts[a].x, 3);
+		BKE_ptcache_file_write_floats(pf, cloth->verts[a].xconst, 3);
+		BKE_ptcache_file_write_floats(pf, cloth->verts[a].v, 3);
 	}
 	
-	/* update last cached frame # */
-	clmd->sim_parms->lastcachedframe = MAX2(clmd->sim_parms->lastcachedframe, framenr);
+	BKE_ptcache_file_close(pf);
+}
+
+static int do_init_cloth(Object *ob, ClothModifierData *clmd, DerivedMesh *result, int framenr)
+{
+	PointCache *cache;
+
+	cache= clmd->point_cache;
+
+	/* initialize simulation data if it didn't exist already */
+	if(clmd->clothObject == NULL) {	
+		if(!cloth_from_object(ob, clmd, result, framenr, 1)) {
+			cache->flag &= ~PTCACHE_SIMULATION_VALID;
+			cache->simframe= 0;
+			return 0;
+		}
 	
-	/* update first cached frame # */
-	if((clmd->sim_parms->firstcachedframe < 0.0) || ((framenr < clmd->sim_parms->firstcachedframe) && (clmd->sim_parms->firstcachedframe > 0.0)))
-		clmd->sim_parms->firstcachedframe = framenr;
+		if(clmd->clothObject == NULL) {
+			cache->flag &= ~PTCACHE_SIMULATION_VALID;
+			cache->simframe= 0;
+			return 0;
+		}
 	
-	if(G.rt > 0)
-	printf("lcf: %d, framenr: %f\n", clmd->sim_parms->lastcachedframe, framenr);
+		implicit_set_positions(clmd);
+	}
 
-	fclose(fp);
+	return 1;
 }
 
+static int do_step_cloth(Object *ob, ClothModifierData *clmd, DerivedMesh *result, int framenr)
+{
+	ClothVertex *verts = NULL;
+	Cloth *cloth;
+	ListBase *effectors = NULL;
+	MVert *mvert;
+	int i, ret = 0;
+
+	/* simulate 1 frame forward */
+	cloth = clmd->clothObject;
+	verts = cloth->verts;
+	mvert = result->getVertArray(result);
+
+	/* force any pinned verts to their constrained location. */
+	for(i = 0; i < clmd->clothObject->numverts; i++, verts++) {
+		/* save the previous position. */
+		VECCOPY(verts->xold, verts->xconst);
+		VECCOPY(verts->txold, verts->x);
 
+		/* Get the current position. */
+		VECCOPY(verts->xconst, mvert[i].co);
+		Mat4MulVecfl(ob->obmat, verts->xconst);
+	}
+	
+	tstart();
+
+	/* call the solver. */
+	if(solvers [clmd->sim_parms->solver_type].solver)
+		ret = solvers[clmd->sim_parms->solver_type].solver(ob, framenr, clmd, effectors);
+
+	tend();
+
+	printf ( "Cloth simulation time: %f\n", ( float ) tval() ); 
+	
+	return ret;
+}
 
 /************************************************
  * clothModifier_do - main simulation function
 ************************************************/
-DerivedMesh *clothModifier_do(ClothModifierData *clmd,Object *ob, DerivedMesh *dm, int useRenderParams, int isFinalCalc)
-
+DerivedMesh *clothModifier_do(ClothModifierData *clmd, Object *ob, DerivedMesh *dm, int useRenderParams, int isFinalCalc)
 {
-	unsigned int i;
-	Cloth *cloth = clmd->clothObject;
-	float framenr = G.scene->r.cfra;
-	float current_time = bsystem_time ( ob, ( float ) G.scene->r.cfra, 0.0 );
-	ListBase *effectors = NULL;
-	ClothVertex *verts = NULL;
-	float deltaTime = current_time - clmd->sim_parms->sim_time;
-	unsigned int numverts = -1;
-	unsigned int numedges = -1;
-	unsigned int numfaces = -1;
-	MVert *mvert = NULL;
-	MEdge *medge = NULL;
-	MFace *mface = NULL;
-	DerivedMesh *result = NULL;
-	
-	if(G.rt > 0)
-	printf("clothModifier_do start\n");
-	
-	/* we're getting called two times during file load,
-	resulting in a not valid G.relbase on the first time (cache makes problems)
-	--> just return back */
-	if((clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_LOADED)&& (!G.relbase_valid))
-	{
-		clmd->sim_parms->flags &= ~CLOTH_SIMSETTINGS_FLAG_LOADED;
-		return dm;
-	}
-	
+	DerivedMesh *result;
+	PointCache *cache;
+	PTCacheID pid;
+	float timescale;
+	int framedelta, framenr, startframe, endframe;
+
+	framenr= (int)G.scene->r.cfra;
+	cache= clmd->point_cache;
 	result = CDDM_copy(dm);
-	
-	if(!result)
-	{
+
+	BKE_ptcache_id_from_cloth(&pid, ob, clmd);
+	BKE_ptcache_id_time(&pid, framenr, &startframe, &endframe, &timescale);
+	clmd->sim_parms->timescale= timescale;
+
+	if(!result) {
+		cache->flag &= ~PTCACHE_SIMULATION_VALID;
+		cache->simframe= 0;
 		return dm;
 	}
 	
-	numverts = result->getNumVerts(result);
-	numedges = result->getNumEdges(result);
-	numfaces = result->getNumFaces(result);
-	mvert = dm->getVertArray(result);
-	medge = dm->getEdgeArray(result);
-	mface = dm->getFaceArray(result);
-	
-	/* check if cache is active / if file is already saved */
-	/*
-	if ((!G.relbase_valid) && ( deltaTime != 1.0f ))
-	{
-		clmd->sim_parms->flags |= CLOTH_SIMSETTINGS_FLAG_RESET;
-	}
-	*/
-	
-	if(clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_RESET)
-	{	
-		cloth_free_modifier (ob, clmd);
-		if(G.rt > 0)
-		printf("clothModifier_do CLOTH_SIMSETTINGS_FLAG_RESET\n");
-	}
-	
-	// unused in the moment, calculated seperately in implicit.c
-	clmd->sim_parms->dt = 1.0f / clmd->sim_parms->stepsPerFrame;
-	
-	if ( ( clmd->clothObject == NULL ) || (clmd->clothObject && (numverts != clmd->clothObject->numverts )) )
-	{
-		/* only force free the cache if we have a different number of verts */
-		if(clmd->clothObject && (numverts != clmd->clothObject->numverts ))
-		{
-			clmd->sim_parms->flags |= CLOTH_SIMSETTINGS_FLAG_CCACHE_FFREE;
-			cloth_free_modifier ( ob, clmd );
-		}
-		
-		cloth_clear_cache(ob, clmd, 0);
-				
-		if ( !cloth_from_object ( ob, clmd, result, framenr ) )
-			return result;
-	
-		if ( clmd->clothObject == NULL )
+	/* verify we still have the same number of vertices, if not do nothing.
+	 * note that this should only happen if the number of vertices changes
+	 * during an animation due to a preceding modifier, this should not
+	 * happen because of object changes! */
+	if(clmd->clothObject) {
+		if(result->getNumVerts(result) != clmd->clothObject->numverts) {
+			cache->flag &= ~PTCACHE_SIMULATION_VALID;
+			cache->simframe= 0;
 			return result;
-	
-		cloth = clmd->clothObject;
-		
-		if(!cloth_read_cache(ob, clmd, framenr))
-		{
-			/* save first frame in case we have a reseted object 
-			and we move one frame forward.
-			In that case we would only start with the SECOND frame
-			if we don't save the current state before 
-			TODO PROBLEM: IMHO we can't track external movement from the
-			first frame in this case! */
-			/*
-			if ( deltaTime == 1.0f )
-				cloth_write_cache(ob, clmd, framenr-1.0);
-			*/
-			if(G.rt > 0)
-			printf("cloth_from_object NO cloth_read_cache cloth_write_cache\n");
 		}
-		else
-		{
-			if(G.rt > 0)
-			printf("cloth_from_object cloth_read_cache\n");
-			
-			implicit_set_positions(clmd);
-		}
-		
-		clmd->sim_parms->sim_time = current_time;
 	}
 	
-	// only be active during a specific period:
-	// that's "first frame" and "last frame" on GUI
-	
-	// TODO: enable later again after refactoring
-	if ( current_time < clmd->sim_parms->firstframe )
-	{
+	// unused in the moment, calculated seperately in implicit.c
+	clmd->sim_parms->dt = clmd->sim_parms->timescale / clmd->sim_parms->stepsPerFrame;
+
+	/* handle continuous simulation with the play button */
+	if(BKE_ptcache_get_continue_physics()) {
+		cache->flag &= ~PTCACHE_SIMULATION_VALID;
+		cache->simframe= 0;
+
+		/* do simulation */
+		if(!do_init_cloth(ob, clmd, result, framenr))
+			return result;
+
+		do_step_cloth(ob, clmd, result, framenr);
+		cloth_to_object(ob, clmd, result);
+
 		return result;
 	}
-	else if ( current_time > clmd->sim_parms->lastframe )
-	{
-		int stack_index = modifiers_indexInObject(ob, (ModifierData *)clmd);
-			
-		if(BKE_ptcache_id_exist((ID *)ob, clmd->sim_parms->lastcachedframe, stack_index))
-		{
-			if(cloth_read_cache(ob, clmd, clmd->sim_parms->lastcachedframe))
-			{
-				implicit_set_positions(clmd);
-				
-				// Copy the result back to the object.
-				cloth_to_object (ob, clmd, result);
-			}
-		}
+
+	/* simulation is only active during a specific period */
+	if(framenr < startframe) {
+		cache->flag &= ~PTCACHE_SIMULATION_VALID;
+		cache->simframe= 0;
 		return result;
 	}
-	
-	/* nice moving one frame forward */
-	if ( deltaTime == 1.0f )
-	{
-		clmd->sim_parms->sim_time = current_time;
-		
-		if(G.rt > 0)
-		printf("clothModifier_do deltaTime=1\n");
-		
-		if(!cloth_read_cache(ob, clmd, framenr))
-		{
-			verts = cloth->verts;
-
-			// Force any pinned verts to their constrained location.
-			for ( i = 0; i < clmd->clothObject->numverts; i++, verts++ )
-			{
-				// Save the previous position.
-				VECCOPY ( verts->xold, verts->xconst );
-				VECCOPY ( verts->txold, verts->x );
+	else if(framenr > endframe) {
+		framenr= endframe;
+	}
 
-				// Get the current position.
-				VECCOPY ( verts->xconst, mvert[i].co );
-				Mat4MulVecfl ( ob->obmat, verts->xconst );
-			}
-			
-			tstart();
+	if(cache->flag & PTCACHE_SIMULATION_VALID)
+		framedelta= framenr - cache->simframe;
+	else
+		framedelta= -1;
 
-			// Call the solver.
-			if ( solvers [clmd->sim_parms->solver_type].solver )
-				solvers [clmd->sim_parms->solver_type].solver ( ob, framenr, clmd, effectors );
+	/* initialize simulation data if it didn't exist already */
+	if(!do_init_cloth(ob, clmd, result, framenr))
+		return result;
 
-			tend();
-			// printf ( "Cloth simulation time: %f\n", ( float ) tval() );
+	/* try to read from cache */
+	if(cloth_read_cache(ob, clmd, framenr)) {
+		cache->flag |= PTCACHE_SIMULATION_VALID;
+		cache->simframe= framenr;
 
-			cloth_write_cache(ob, clmd, framenr);
-			
-			// check for autoprotection
-			if(framenr >= clmd->sim_parms->autoprotect)
-			{
-				if(G.rt > 0)
-				printf("fr#: %f, auto: %d\n", framenr, clmd->sim_parms->autoprotect);
-				clmd->sim_parms->flags |= CLOTH_SIMSETTINGS_FLAG_CCACHE_PROTECT;
-			}
-			if(G.rt > 0)
-			printf("clothModifier_do deltaTime=1 cachewrite\n");
-		}
-		else
-		{
-			if(G.rt > 0)
-			printf("clothModifier_do deltaTime=1 cacheread\n");
-			implicit_set_positions(clmd);
-		}
-		
-		// Copy the result back to the object.
+		implicit_set_positions(clmd);
 		cloth_to_object (ob, clmd, result);
+
+		return result;
 	}
-	else if(deltaTime == 0.0f) 
-	{	
-		if(G.rt > 0)
-		printf("clothModifier_do deltaTime!=1 clmd->clothObject != NULL\n");
-		if(cloth_read_cache(ob, clmd, framenr))
-		{
-			cloth_to_object (ob, clmd, result);
-			implicit_set_positions(clmd);
-		}
-		else /* same cache parts are missing */
-		{
-			/*
-			clmd->sim_parms->flags |= CLOTH_SIMSETTINGS_FLAG_RESET;
-			*/
-			clmd->sim_parms->flags |= CLOTH_SIMSETTINGS_FLAG_CCACHE_FFREE;
-			cloth_clear_cache(ob, clmd, 0);
-			
-			cloth_write_cache(ob, clmd, framenr);
-		}
+	else if(ob->id.lib || (cache->flag & PTCACHE_BAKED)) {
+		/* if baked and nothing in cache, do nothing */
+		cache->flag &= ~PTCACHE_SIMULATION_VALID;
+		cache->simframe= 0;
+		return result;
 	}
-	else
-	{	
-		if(G.rt > 0)
-		printf("clothModifier_do deltaTime!=1 clmd->clothObject != NULL\n");
-		if(cloth_read_cache(ob, clmd, framenr))
-		{
-			cloth_to_object (ob, clmd, result);
-			implicit_set_positions(clmd);
-			clmd->sim_parms->sim_time = current_time;
+
+	if(framenr == startframe) {
+		cache->flag |= PTCACHE_SIMULATION_VALID;
+		cache->simframe= framenr;
+
+		/* don't write cache on first frame, but on second frame write
+		 * cache for frame 1 and 2 */
+	}
+	else if(framedelta == 1) {
+		/* if on second frame, write cache for first frame */
+		if(framenr == startframe+1)
+			cloth_write_cache(ob, clmd, startframe);
+
+		/* do simulation */
+		cache->flag |= PTCACHE_SIMULATION_VALID;
+		cache->simframe= framenr;
+
+		if(!do_step_cloth(ob, clmd, result, framenr)) {
+			cache->flag &= ~PTCACHE_SIMULATION_VALID;
+			cache->simframe= 0;
 		}
 		else
-		{
-			/* jump to a non-existing frame makes sim reset */
-			clmd->sim_parms->flags |= CLOTH_SIMSETTINGS_FLAG_RESET;
-		}
+			cloth_write_cache(ob, clmd, framenr);
+
+		cloth_to_object (ob, clmd, result);
 	}
-	
+	else {
+		cache->flag &= ~PTCACHE_SIMULATION_VALID;
+		cache->simframe= 0;
+	}
+
 	return result;
 }
 
@@ -901,14 +547,18 @@ void cloth_free_modifier ( Object *ob, ClothModifierData *clmd )
 		// we save our faces for collision objects
 		if ( cloth->mfaces )
 			MEM_freeN ( cloth->mfaces );
+		
+		if(cloth->edgehash)
+			BLI_edgehash_free ( cloth->edgehash, NULL );
+		
+		
 		/*
 		if(clmd->clothObject->facemarks)
-			MEM_freeN(clmd->clothObject->facemarks);
+		MEM_freeN(clmd->clothObject->facemarks);
 		*/
 		MEM_freeN ( cloth );
 		clmd->clothObject = NULL;
 	}
-	clmd->sim_parms->flags &= ~CLOTH_SIMSETTINGS_FLAG_RESET;
 }
 
 /* frees all */
@@ -916,7 +566,7 @@ void cloth_free_modifier_extern ( ClothModifierData *clmd )
 {
 	Cloth	*cloth = NULL;
 	if(G.rt > 0)
-	printf("cloth_free_modifier_extern\n");
+		printf("cloth_free_modifier_extern\n");
 	
 	if ( !clmd )
 		return;
@@ -926,7 +576,7 @@ void cloth_free_modifier_extern ( ClothModifierData *clmd )
 	if ( cloth )
 	{	
 		if(G.rt > 0)
-		printf("cloth_free_modifier_extern in\n");
+			printf("cloth_free_modifier_extern in\n");
 		
 		// If our solver provides a free function, call it
 		if ( solvers [clmd->sim_parms->solver_type].free )
@@ -967,6 +617,11 @@ void cloth_free_modifier_extern ( ClothModifierData *clmd )
 		// we save our faces for collision objects
 		if ( cloth->mfaces )
 			MEM_freeN ( cloth->mfaces );
+		
+		if(cloth->edgehash)
+			BLI_edgehash_free ( cloth->edgehash, NULL );
+		
+		
 		/*
 		if(clmd->clothObject->facemarks)
 		MEM_freeN(clmd->clothObject->facemarks);
@@ -983,9 +638,9 @@ void cloth_free_modifier_extern ( ClothModifierData *clmd )
 ******************************************************************************/
 
 /**
-* cloth_to_object - copies the deformed vertices to the object.
-*
-**/
+ * cloth_to_object - copies the deformed vertices to the object.
+ *
+ **/
 static void cloth_to_object (Object *ob,  ClothModifierData *clmd, DerivedMesh *dm)
 {
 	unsigned int	i = 0;
@@ -1010,9 +665,9 @@ static void cloth_to_object (Object *ob,  ClothModifierData *clmd, DerivedMesh *
 
 
 /**
-* cloth_apply_vgroup - applies a vertex group as specified by type
-*
-**/
+ * cloth_apply_vgroup - applies a vertex group as specified by type
+ *
+ **/
 /* can be optimized to do all groups in one loop */
 static void cloth_apply_vgroup ( ClothModifierData *clmd, DerivedMesh *dm )
 {
@@ -1023,7 +678,6 @@ static void cloth_apply_vgroup ( ClothModifierData *clmd, DerivedMesh *dm )
 	unsigned int numverts = dm->getNumVerts ( dm );
 	float goalfac = 0;
 	ClothVertex *verts = NULL;
-	// clmd->sim_parms->vgroup_mass
 
 	clothObj = clmd->clothObject;
 
@@ -1041,7 +695,7 @@ static void cloth_apply_vgroup ( ClothModifierData *clmd, DerivedMesh *dm )
 		     (clmd->sim_parms->vgroup_bend>0)))
 	{
 		for ( i = 0; i < numverts; i++, verts++ )
-		{
+		{	
 			dvert = dm->getVertData ( dm, i, CD_MDEFORMVERT );
 			if ( dvert )
 			{
@@ -1059,7 +713,9 @@ static void cloth_apply_vgroup ( ClothModifierData *clmd, DerivedMesh *dm )
 						
 						verts->goal  = ( float ) pow ( verts->goal , 4.0f );
 						if ( verts->goal >=SOFTGOALSNAP )
-							verts->flags |= CLOTH_VERT_FLAG_PINNED;
+						{
+ 							verts->flags |= CLOTH_VERT_FLAG_PINNED;
+						}
 					}
 					
 					if (clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_SCALING )
@@ -1075,40 +731,33 @@ static void cloth_apply_vgroup ( ClothModifierData *clmd, DerivedMesh *dm )
 							verts->bend_stiff = dvert->dw [j].weight;
 						}
 					}
+					/*
+					// for later
+					if( dvert->dw[j].def_nr == (clmd->sim_parms->vgroup_weight-1))
+					{
+						verts->mass = dvert->dw [j].weight;
+					}
+					*/
 				}
 			}
 		}
 	}
 }
 
-/*
-helper function to get proper spring length
-when object is rescaled
-*/
-float cloth_globallen ( float *v1,float *v2,Object *ob )
-{
-	float p1[3],p2[3];
-	VECCOPY ( p1,v1 );
-	Mat4MulVecfl ( ob->obmat, p1 );
-	VECCOPY ( p2,v2 );
-	Mat4MulVecfl ( ob->obmat, p2 );
-	return VecLenf ( p1,p2 );
-}
-
-static int cloth_from_object(Object *ob, ClothModifierData *clmd, DerivedMesh *dm, float framenr)
+static int cloth_from_object(Object *ob, ClothModifierData *clmd, DerivedMesh *dm, float framenr, int first)
 {
 	unsigned int i = 0;
 	MVert *mvert = NULL;
 	ClothVertex *verts = NULL;
 	float tnull[3] = {0,0,0};
-	int cache_there = 0;
+	Cloth *cloth = NULL;
 
 	// If we have a clothObject, free it. 
 	if ( clmd->clothObject != NULL )
 	{
 		cloth_free_modifier ( ob, clmd );
 		if(G.rt > 0)
-		printf("cloth_free_modifier cloth_from_object\n");
+			printf("cloth_free_modifier cloth_from_object\n");
 	}
 
 	// Allocate a new cloth object.
@@ -1117,6 +766,8 @@ static int cloth_from_object(Object *ob, ClothModifierData *clmd, DerivedMesh *d
 	{
 		clmd->clothObject->old_solver_type = 255;
 		// clmd->clothObject->old_collision_type = 255;
+		cloth = clmd->clothObject;
+		clmd->clothObject->edgehash = NULL;
 	}
 	else if ( !clmd->clothObject )
 	{
@@ -1130,21 +781,6 @@ static int cloth_from_object(Object *ob, ClothModifierData *clmd, DerivedMesh *d
 
 	cloth_from_mesh ( ob, clmd, dm );
 
-	if((clmd->sim_parms->firstcachedframe < 0.0) || ((clmd->sim_parms->firstcachedframe >= 0.0) && (!cloth_read_cache(ob, clmd, clmd->sim_parms->firstcachedframe))))
-	{
-		// no cache there
-		cache_there = 0;
-		if(G.rt > 0)
-		printf("cache_there = 0\n");
-	}
-	else
-	{
-		// we have a cache
-		cache_there = 1;
-		if(G.rt > 0)
-		printf("cache_there = 1, fcf: %d\n", clmd->sim_parms->firstcachedframe);
-	}
-	
 	// create springs 
 	clmd->clothObject->springs = NULL;
 	clmd->clothObject->numsprings = -1;
@@ -1155,13 +791,15 @@ static int cloth_from_object(Object *ob, ClothModifierData *clmd, DerivedMesh *d
 	// set initial values
 	for ( i = 0; i < dm->getNumVerts(dm); i++, verts++ )
 	{
-		if(!cache_there)
+		if(first)
 		{
 			VECCOPY ( verts->x, mvert[i].co );
 			Mat4MulVecfl ( ob->obmat, verts->x );
 		}
 		
-		verts->mass = clmd->sim_parms->mass;
+		/* no GUI interface yet */
+		verts->mass = clmd->sim_parms->mass; 
+		verts->impulse_count = 0;
 
 		if ( clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_GOAL )
 			verts->goal= clmd->sim_parms->defgoal;
@@ -1182,6 +820,7 @@ static int cloth_from_object(Object *ob, ClothModifierData *clmd, DerivedMesh *d
 	// has to be happen before springs are build!
 	cloth_apply_vgroup (clmd, dm);
 	
+	
 	if ( !cloth_build_springs ( clmd, dm ) )
 	{
 		cloth_free_modifier ( ob, clmd );
@@ -1190,12 +829,24 @@ static int cloth_from_object(Object *ob, ClothModifierData *clmd, DerivedMesh *d
 		return 0;
 	}
 	
+	for ( i = 0; i < dm->getNumVerts(dm); i++)
+	{
+		if((!(cloth->verts[i].flags & CLOTH_VERT_FLAG_PINNED)) && (cloth->verts[i].goal > ALMOST_ZERO))
+		{
+			cloth_add_spring (clmd, i, i, 0.0, CLOTH_SPRING_TYPE_GOAL);
+		}
+	}
+	
 	// init our solver
-	if ( solvers [clmd->sim_parms->solver_type].init )
+	if ( solvers [clmd->sim_parms->solver_type].init ) {
 		solvers [clmd->sim_parms->solver_type].init ( ob, clmd );
+	}
+	
+	if(!first)
+		implicit_set_positions(clmd);
 
 	clmd->clothObject->tree = bvh_build_from_cloth ( clmd, clmd->coll_parms->epsilon );
-	
+
 	return 1;
 }
 
@@ -1207,8 +858,7 @@ static void cloth_from_mesh ( Object *ob, ClothModifierData *clmd, DerivedMesh *
 	MFace *mface = CDDM_get_faces(dm);
 	unsigned int i = 0;
 
-	/* Allocate our vertices.
-	*/
+	/* Allocate our vertices. */
 	clmd->clothObject->numverts = numverts;
 	clmd->clothObject->verts = MEM_callocN ( sizeof ( ClothVertex ) * clmd->clothObject->numverts, "clothVertex" );
 	if ( clmd->clothObject->verts == NULL )
@@ -1257,21 +907,58 @@ int cloth_add_spring ( ClothModifierData *clmd, unsigned int indexA, unsigned in
 		
 		spring = ( ClothSpring * ) MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );
 		
+		if(!spring)
+			return 0;
+		
 		spring->ij = indexA;
 		spring->kl = indexB;
 		spring->restlen =  restlength;
 		spring->type = spring_type;
 		spring->flags = 0;
+		spring->stiffness = 0;
 		
 		cloth->numsprings++;
 	
-		BLI_linklist_append ( &cloth->springs, spring );
+		BLI_linklist_prepend ( &cloth->springs, spring );
 		
 		return 1;
 	}
 	return 0;
 }
 
+void cloth_free_errorsprings(Cloth *cloth, EdgeHash *edgehash, LinkNode **edgelist)
+{
+	unsigned int i = 0;
+	
+	if ( cloth->springs != NULL )
+	{
+		LinkNode *search = cloth->springs;
+		while(search)
+		{
+			ClothSpring *spring = search->link;
+						
+			MEM_freeN ( spring );
+			search = search->next;
+		}
+		BLI_linklist_free(cloth->springs, NULL);
+		
+		cloth->springs = NULL;
+	}
+	
+	if(edgelist)
+	{
+		for ( i = 0; i < cloth->numverts; i++ )
+		{
+			BLI_linklist_free ( edgelist[i],NULL );
+		}
+
+		MEM_freeN ( edgelist );
+	}
+	
+	if(cloth->edgehash)
+		BLI_edgehash_free ( cloth->edgehash, NULL );
+}
+
 int cloth_build_springs ( ClothModifierData *clmd, DerivedMesh *dm )
 {
 	Cloth *cloth = clmd->clothObject;
@@ -1288,7 +975,6 @@ int cloth_build_springs ( ClothModifierData *clmd, DerivedMesh *dm )
 	EdgeHash *edgehash = NULL;
 	LinkNode *search = NULL, *search2 = NULL;
 	float temp[3];
-	LinkNode *node = NULL, *node2 = NULL;
 	
 	// error handling
 	if ( numedges==0 )
@@ -1297,6 +983,10 @@ int cloth_build_springs ( ClothModifierData *clmd, DerivedMesh *dm )
 	cloth->springs = NULL;
 
 	edgelist = MEM_callocN ( sizeof ( LinkNode * ) * numverts, "cloth_edgelist_alloc" );
+	
+	if(!edgelist)
+		return 0;
+	
 	for ( i = 0; i < numverts; i++ )
 	{
 		edgelist[i] = NULL;
@@ -1315,41 +1005,54 @@ int cloth_build_springs ( ClothModifierData *clmd, DerivedMesh *dm )
 
 		if ( spring )
 		{
-			spring->ij = medge[i].v1;
-			spring->kl = medge[i].v2;
+			spring->ij = MIN2(medge[i].v1, medge[i].v2);
+			spring->kl = MAX2(medge[i].v2, medge[i].v1);
 			VECSUB ( temp, cloth->verts[spring->kl].x, cloth->verts[spring->ij].x );
 			spring->restlen =  sqrt ( INPR ( temp, temp ) );
-			/*
-			if(spring->restlen > 1.0)
-			{
-				printf("i: %d, L: %f\n", i, spring->restlen);
-				printf("%d, x: %f, y: %f, z: %f\n", cloth->verts[spring->ij].x[0], cloth->verts[spring->ij].x[1], spring->ij, cloth->verts[spring->ij].x[2]);
-				printf("%d, x: %f, y: %f, z: %f\n\n",spring->kl, cloth->verts[spring->kl].x[0], cloth->verts[spring->kl].x[1], cloth->verts[spring->kl].x[2]);
-			}
-			*/
-			clmd->coll_parms->avg_spring_len += spring->restlen;
+			clmd->sim_parms->avg_spring_len += spring->restlen;
+			cloth->verts[spring->ij].avg_spring_len += spring->restlen;
+			cloth->verts[spring->kl].avg_spring_len += spring->restlen;
+			cloth->verts[spring->ij].spring_count++;
+			cloth->verts[spring->kl].spring_count++;
 			spring->type = CLOTH_SPRING_TYPE_STRUCTURAL;
 			spring->flags = 0;
 			spring->stiffness = (cloth->verts[spring->kl].struct_stiff + cloth->verts[spring->ij].struct_stiff) / 2.0;
 			struct_springs++;
 			
-			if(!i)
-				node2 = BLI_linklist_append_fast ( &cloth->springs, spring );
-			else
-				node2 = BLI_linklist_append_fast ( &node->next, spring );
-			node = node2;
+			BLI_linklist_prepend ( &cloth->springs, spring );
+		}
+		else
+		{
+			cloth_free_errorsprings(cloth, edgehash, edgelist);
+			return 0;
 		}
 	}
 	
-	clmd->coll_parms->avg_spring_len /= struct_springs;
+	if(struct_springs > 0)
+		clmd->sim_parms->avg_spring_len /= struct_springs;
+	
+	for(i = 0; i < numverts; i++)
+	{
+		cloth->verts[i].avg_spring_len = cloth->verts[i].avg_spring_len * 0.49 / ((float)cloth->verts[i].spring_count);
+	}
 	
 	// shear springs
 	for ( i = 0; i < numfaces; i++ )
 	{
+		// triangle faces already have shear springs due to structural geometry
+		if ( !mface[i].v4 )
+			continue; 
+		
 		spring = ( ClothSpring *) MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );
+		
+		if(!spring)
+		{
+			cloth_free_errorsprings(cloth, edgehash, edgelist);
+			return 0;
+		}
 
-		spring->ij = mface[i].v1;
-		spring->kl = mface[i].v3;
+		spring->ij = MIN2(mface[i].v1, mface[i].v3);
+		spring->kl = MAX2(mface[i].v3, mface[i].v1);
 		VECSUB ( temp, cloth->verts[spring->kl].x, cloth->verts[spring->ij].x );
 		spring->restlen =  sqrt ( INPR ( temp, temp ) );
 		spring->type = CLOTH_SPRING_TYPE_SHEAR;
@@ -1359,27 +1062,30 @@ int cloth_build_springs ( ClothModifierData *clmd, DerivedMesh *dm )
 		BLI_linklist_append ( &edgelist[spring->kl], spring );
 		shear_springs++;
 
-		node2 = BLI_linklist_append_fast ( &node->next, spring );
-		node = node2;
+		BLI_linklist_prepend ( &cloth->springs, spring );
 
-		if ( mface[i].v4 )
+		
+		// if ( mface[i].v4 ) --> Quad face
+		spring = ( ClothSpring * ) MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );
+		
+		if(!spring)
 		{
-			spring = ( ClothSpring * ) MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );
+			cloth_free_errorsprings(cloth, edgehash, edgelist);
+			return 0;
+		}
 
-			spring->ij = mface[i].v2;
-			spring->kl = mface[i].v4;
-			VECSUB ( temp, cloth->verts[spring->kl].x, cloth->verts[spring->ij].x );
-			spring->restlen =  sqrt ( INPR ( temp, temp ) );
-			spring->type = CLOTH_SPRING_TYPE_SHEAR;
-			spring->stiffness = (cloth->verts[spring->kl].shear_stiff + cloth->verts[spring->ij].shear_stiff) / 2.0;
+		spring->ij = MIN2(mface[i].v2, mface[i].v4);
+		spring->kl = MAX2(mface[i].v4, mface[i].v2);
+		VECSUB ( temp, cloth->verts[spring->kl].x, cloth->verts[spring->ij].x );
+		spring->restlen =  sqrt ( INPR ( temp, temp ) );
+		spring->type = CLOTH_SPRING_TYPE_SHEAR;
+		spring->stiffness = (cloth->verts[spring->kl].shear_stiff + cloth->verts[spring->ij].shear_stiff) / 2.0;
 
-			BLI_linklist_append ( &edgelist[spring->ij], spring );
-			BLI_linklist_append ( &edgelist[spring->kl], spring );
-			shear_springs++;
+		BLI_linklist_append ( &edgelist[spring->ij], spring );
+		BLI_linklist_append ( &edgelist[spring->kl], spring );
+		shear_springs++;
 
-			node2 = BLI_linklist_append_fast ( &node->next, spring );
-			node = node2;
-		}
+		BLI_linklist_prepend ( &cloth->springs, spring );
 	}
 	
 	// bending springs
@@ -1398,39 +1104,64 @@ int cloth_build_springs ( ClothModifierData *clmd, DerivedMesh *dm )
 			
 			// check for existing spring
 			// check also if startpoint is equal to endpoint
-			if ( !BLI_edgehash_haskey ( edgehash, index2, tspring2->ij )
-						   && !BLI_edgehash_haskey ( edgehash, tspring2->ij, index2 )
-						   && ( index2!=tspring2->ij ) )
+			if ( !BLI_edgehash_haskey ( edgehash, MIN2(tspring2->ij, index2), MAX2(tspring2->ij, index2) )
+			&& ( index2!=tspring2->ij ) )
 			{
 				spring = ( ClothSpring * ) MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );
+				
+				if(!spring)
+				{
+					cloth_free_errorsprings(cloth, edgehash, edgelist);
+					return 0;
+				}
 
-				spring->ij = tspring2->ij;
-				spring->kl = index2;
-				VECSUB ( temp, cloth->verts[index2].x, cloth->verts[tspring2->ij].x );
+				spring->ij = MIN2(tspring2->ij, index2);
+				spring->kl = MAX2(tspring2->ij, index2);
+				VECSUB ( temp, cloth->verts[spring->kl].x, cloth->verts[spring->ij].x );
 				spring->restlen =  sqrt ( INPR ( temp, temp ) );
 				spring->type = CLOTH_SPRING_TYPE_BENDING;
 				spring->stiffness = (cloth->verts[spring->kl].bend_stiff + cloth->verts[spring->ij].bend_stiff) / 2.0;
-				BLI_edgehash_insert ( edgehash, spring->ij, index2, NULL );
+				BLI_edgehash_insert ( edgehash, spring->ij, spring->kl, NULL );
 				bend_springs++;
 
-				node2 = BLI_linklist_append_fast ( &node->next, spring );
-				node = node2;
+				BLI_linklist_prepend ( &cloth->springs, spring );
 			}
 			search = search->next;
 		}
 		search2 = search2->next;
 	}
 	
-	cloth->numsprings = struct_springs + shear_springs + bend_springs;
+	/* insert other near springs in edgehash AFTER bending springs are calculated (for selfcolls) */
+	for ( i = 0; i < numedges; i++ ) // struct springs
+		BLI_edgehash_insert ( edgehash, MIN2(medge[i].v1, medge[i].v2), MAX2(medge[i].v2, medge[i].v1), NULL );
 	
-	for ( i = 0; i < numverts; i++ )
+	for ( i = 0; i < numfaces; i++ ) // edge springs
 	{
-		BLI_linklist_free ( edgelist[i],NULL );
+		if(mface[i].v4)
+		{
+			BLI_edgehash_insert ( edgehash, MIN2(mface[i].v1, mface[i].v3), MAX2(mface[i].v3, mface[i].v1), NULL );
+			
+			BLI_edgehash_insert ( edgehash, MIN2(mface[i].v2, mface[i].v4), MAX2(mface[i].v2, mface[i].v4), NULL );
+		}
 	}
+	
+	
+	cloth->numsprings = struct_springs + shear_springs + bend_springs;
+	
 	if ( edgelist )
+	{
+		for ( i = 0; i < numverts; i++ )
+		{
+			BLI_linklist_free ( edgelist[i],NULL );
+		}
+	
 		MEM_freeN ( edgelist );
+	}
+	
+	cloth->edgehash = edgehash;
 	
-	BLI_edgehash_free ( edgehash, NULL );
+	if(G.rt>0)
+		printf("avg_len: %f\n",clmd->sim_parms->avg_spring_len);
 
 	return 1;