Differential D3662 Diff 11727 source/blender/blenkernel/intern/cloth.c

Changeset View

Standalone View

source/blender/blenkernel/intern/cloth.c

Context not available.
	static int cloth_build_springs ( ClothModifierData clmd, Mesh mesh );	static int cloth_build_springs ( ClothModifierData clmd, Mesh mesh );
	static void cloth_apply_vgroup ( ClothModifierData clmd, Mesh mesh );	static void cloth_apply_vgroup ( ClothModifierData clmd, Mesh mesh );

		typedef struct BendSpringRef {
		int index;
		int polys;
		ClothSpring *spring;
		} BendSpringRef;

	/******************************************************************************	/******************************************************************************
	*	*
	* External interface called by modifier.c clothModifier functions.	* External interface called by modifier.c clothModifier functions.
Context not available.
	while (search) {	while (search) {
	ClothSpring *spring = search->link;	ClothSpring *spring = search->link;

		MEM_SAFE_FREE(spring->pa);
		MEM_SAFE_FREE(spring->pb);

	MEM_freeN ( spring );	MEM_freeN ( spring );
	search = search->next;	search = search->next;
	}	}
Context not available.
	while (search) {	while (search) {
	ClothSpring *spring = search->link;	ClothSpring *spring = search->link;

		MEM_SAFE_FREE(spring->pa);
		MEM_SAFE_FREE(spring->pb);

	MEM_freeN ( spring );	MEM_freeN ( spring );
	search = search->next;	search = search->next;
	}	}
Context not available.
	}	}
	}	}

	static void cloth_free_errorsprings(Cloth cloth, LinkNodePair edgelist)	static void cloth_free_errorsprings(Cloth cloth, LinkNodePair edgelist, BendSpringRef *spring_ref)
	{	{
	if ( cloth->springs != NULL ) {	if ( cloth->springs != NULL ) {
	LinkNode *search = cloth->springs;	LinkNode *search = cloth->springs;
	while (search) {	while (search) {
	ClothSpring *spring = search->link;	ClothSpring *spring = search->link;

		MEM_SAFE_FREE(spring->pa);
		MEM_SAFE_FREE(spring->pb);

	MEM_freeN ( spring );	MEM_freeN ( spring );
	search = search->next;	search = search->next;
	}	}
Context not available.

	cloth_free_edgelist(edgelist, cloth->mvert_num);	cloth_free_edgelist(edgelist, cloth->mvert_num);

		MEM_SAFE_FREE(spring_ref);

	if (cloth->edgeset) {	if (cloth->edgeset) {
	BLI_edgeset_free(cloth->edgeset);	BLI_edgeset_free(cloth->edgeset);
	cloth->edgeset = NULL;	cloth->edgeset = NULL;
	}	}
	}	}

		BLI_INLINE void cloth_bend_poly_dir(ClothVertex verts, int i, int j, int inds, int len, float r_dir[3])
		{
		float cent[3] = {0};
		float fact = 1.0f / len;

		for (int x = 0; x < len; x++) {
		madd_v3_v3fl(cent, verts[inds[x]].xrest, fact);
		}

		normal_tri_v3(r_dir, verts[i].xrest, verts[j].xrest, cent);
		}

		static float cloth_spring_angle(ClothVertex verts, int i, int j, int i_a, int *i_b, int len_a, int len_b)
		{
		float dir_a[3], dir_b[3];
		float tmp[3], vec_e[3];
		float sin, cos;

		/* Poly vectors. */
		cloth_bend_poly_dir(verts, j, i, i_a, len_a, dir_a);
		cloth_bend_poly_dir(verts, i, j, i_b, len_b, dir_b);

		/* Edge vector. */
		sub_v3_v3v3(vec_e, verts[i].xrest, verts[j].xrest);
		normalize_v3(vec_e);

		/* Compute angle. */
		cos = dot_v3v3(dir_a, dir_b);

		cross_v3_v3v3(tmp, dir_a, dir_b);
		sin = dot_v3v3(tmp, vec_e);

		return atan2(sin, cos);
		brechtUnsubmitted Not Done Inline Actions Convention is to use float functions like `atan2f()`. brecht: Convention is to use float functions like `atan2f()`.
		}

	static void cloth_hair_update_bending_targets(ClothModifierData *clmd)	static void cloth_hair_update_bending_targets(ClothModifierData *clmd)
	{	{
	Cloth *cloth = clmd->clothObject;	Cloth *cloth = clmd->clothObject;
Context not available.
	ClothHairData hair_ij, hair_kl;	ClothHairData hair_ij, hair_kl;
	bool is_root = spring->kl != prev_mn;	bool is_root = spring->kl != prev_mn;

	if (spring->type != CLOTH_SPRING_TYPE_BENDING_ANG) {	if (spring->type != CLOTH_SPRING_TYPE_BENDING_HAIR) {
	continue;	continue;
	}	}

Context not available.
	ClothHairData hair_ij, hair_kl;	ClothHairData hair_ij, hair_kl;
	bool is_root = spring->kl != prev_mn;	bool is_root = spring->kl != prev_mn;

	if (spring->type != CLOTH_SPRING_TYPE_BENDING_ANG) {	if (spring->type != CLOTH_SPRING_TYPE_BENDING_HAIR) {
	continue;	continue;
	}	}

Context not available.
	while (search) {	while (search) {
	ClothSpring *spring = search->link;	ClothSpring *spring = search->link;

	spring->stiffness = 0.0f;	spring->lin_stiffness = 0.0f;

		if (clmd->sim_parms->bending_model == CLOTH_BENDING_ANGULAR) {
		if (spring->type & CLOTH_SPRING_TYPE_BENDING) {
		spring->ang_stiffness = (cloth->verts[spring->kl].bend_stiff + cloth->verts[spring->ij].bend_stiff) / 2.0f;
		}
		}

	if (spring->type == CLOTH_SPRING_TYPE_STRUCTURAL) {	if (spring->type & CLOTH_SPRING_TYPE_STRUCTURAL) {
	spring->stiffness = (cloth->verts[spring->kl].struct_stiff + cloth->verts[spring->ij].struct_stiff) / 2.0f;	spring->lin_stiffness = (cloth->verts[spring->kl].struct_stiff + cloth->verts[spring->ij].struct_stiff) / 2.0f;
	}	}
	else if (spring->type == CLOTH_SPRING_TYPE_SHEAR) {	else if (spring->type & CLOTH_SPRING_TYPE_SHEAR) {
	spring->stiffness = (cloth->verts[spring->kl].shear_stiff + cloth->verts[spring->ij].shear_stiff) / 2.0f;	spring->lin_stiffness = (cloth->verts[spring->kl].shear_stiff + cloth->verts[spring->ij].shear_stiff) / 2.0f;
	}	}
	else if (spring->type == CLOTH_SPRING_TYPE_BENDING) {	else if (spring->type == CLOTH_SPRING_TYPE_BENDING) {
	spring->stiffness = (cloth->verts[spring->kl].bend_stiff + cloth->verts[spring->ij].bend_stiff) / 2.0f;	spring->lin_stiffness = (cloth->verts[spring->kl].bend_stiff + cloth->verts[spring->ij].bend_stiff) / 2.0f;
	}	}
	else if (spring->type == CLOTH_SPRING_TYPE_BENDING_ANG) {	else if (spring->type == CLOTH_SPRING_TYPE_BENDING_HAIR) {
	ClothVertex *v1 = &cloth->verts[spring->ij];	ClothVertex *v1 = &cloth->verts[spring->ij];
	ClothVertex *v2 = &cloth->verts[spring->kl];	ClothVertex *v2 = &cloth->verts[spring->kl];
	if (clmd->hairdata) {	if (clmd->hairdata) {
Context not available.
	v1->bend_stiff = clmd->hairdata[spring->ij].bending_stiffness;	v1->bend_stiff = clmd->hairdata[spring->ij].bending_stiffness;
	v2->bend_stiff = clmd->hairdata[spring->kl].bending_stiffness;	v2->bend_stiff = clmd->hairdata[spring->kl].bending_stiffness;
	}	}
	spring->stiffness = (v1->bend_stiff + v2->bend_stiff) / 2.0f;	spring->lin_stiffness = (v1->bend_stiff + v2->bend_stiff) / 2.0f;
	}	}
	else if (spring->type == CLOTH_SPRING_TYPE_GOAL) {	else if (spring->type == CLOTH_SPRING_TYPE_GOAL) {
	/* Warning: Appending NEW goal springs does not work because implicit solver would need reset! */	/* Warning: Appending NEW goal springs does not work because implicit solver would need reset! */
Context not available.
	while (search) {	while (search) {
	ClothSpring *spring = search->link;	ClothSpring *spring = search->link;

	if ( spring->type != CLOTH_SPRING_TYPE_SEWING ) {	if (spring->type != CLOTH_SPRING_TYPE_SEWING) {
	if ( spring->type & (CLOTH_SPRING_TYPE_STRUCTURAL \| CLOTH_SPRING_TYPE_SHEAR \| CLOTH_SPRING_TYPE_BENDING) )	if (spring->type & (CLOTH_SPRING_TYPE_STRUCTURAL \| CLOTH_SPRING_TYPE_SHEAR \| CLOTH_SPRING_TYPE_BENDING)) {
	shrink_factor = cloth_shrink_factor(clmd, cloth->verts, spring->ij, spring->kl);	shrink_factor = cloth_shrink_factor(clmd, cloth->verts, spring->ij, spring->kl);
	else	}
		else {
	shrink_factor = 1.0f;	shrink_factor = 1.0f;
		}

	spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest) * shrink_factor;	spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest) * shrink_factor;

		if (spring->type & CLOTH_SPRING_TYPE_BENDING) {
		spring->restang = cloth_spring_angle(cloth->verts, spring->ij, spring->kl,
		spring->pa, spring->pb, spring->la, spring->lb);
		}
	}	}

	if ( spring->type == CLOTH_SPRING_TYPE_STRUCTURAL ) {	if (spring->type & CLOTH_SPRING_TYPE_STRUCTURAL) {
	clmd->sim_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->ij].avg_spring_len += spring->restlen;
	cloth->verts[spring->kl].avg_spring_len += spring->restlen;	cloth->verts[spring->kl].avg_spring_len += spring->restlen;
Context not available.
	search = search->next;	search = search->next;
	}	}

	if (struct_springs > 0)	if (struct_springs > 0) {
	clmd->sim_parms->avg_spring_len /= struct_springs;	clmd->sim_parms->avg_spring_len /= struct_springs;
		}

	for (i = 0; i < mvert_num; i++) {	for (i = 0; i < mvert_num; i++) {
	if (cloth->verts[i].spring_count > 0)	if (cloth->verts[i].spring_count > 0) {
	cloth->verts[i].avg_spring_len = cloth->verts[i].avg_spring_len * 0.49f / ((float)cloth->verts[i].spring_count);	cloth->verts[i].avg_spring_len = cloth->verts[i].avg_spring_len * 0.49f / ((float)cloth->verts[i].spring_count);
		}
	}	}
	}	}

Context not available.
	mul_m3_m3m3(mat, rot, mat);	mul_m3_m3m3(mat, rot, mat);
	}	}

		/* Add a shear and a bend spring between two verts within a poly. */
		static bool cloth_add_shear_bend_spring(ClothModifierData clmd, LinkNodePair edgelist,
		const MLoop mloop, const MPoly mpoly, int i, int j, int k)
		{
		Cloth *cloth = clmd->clothObject;
		ClothSpring *spring;
		const MLoop *tmp_loop;
		float shrink_factor;
		int x, y;

		/* Combined shear/bend properties. */
		spring = (ClothSpring *)MEM_callocN(sizeof(ClothSpring), "cloth spring");

		if (!spring) {
		return false;
		}

		spring_verts_ordered_set(spring,
		mloop[mpoly[i].loopstart + j].v,
		mloop[mpoly[i].loopstart + k].v);

		shrink_factor = cloth_shrink_factor(clmd, cloth->verts, spring->ij, spring->kl);
		spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest) * shrink_factor;
		spring->type \|= CLOTH_SPRING_TYPE_SHEAR;
		spring->lin_stiffness = (cloth->verts[spring->kl].shear_stiff + cloth->verts[spring->ij].shear_stiff) / 2.0f;

		if (edgelist) {
		BLI_linklist_append(&edgelist[spring->ij], spring);
		BLI_linklist_append(&edgelist[spring->kl], spring);
		}

		/* Bending specific properties. */
		if (clmd->sim_parms->bending_model == CLOTH_BENDING_ANGULAR) {
		spring->type \|= CLOTH_SPRING_TYPE_BENDING;

		spring->la = k - j + 1;
		spring->lb = mpoly[i].totloop - k + j + 1;

		spring->pa = MEM_mallocN(sizeof(spring->pa) spring->la, "spring poly");
		if (!spring->pa) {
		return false;
		}

		spring->pb = MEM_mallocN(sizeof(spring->pb) spring->lb, "spring poly");
		if (!spring->pb) {
		return false;
		}

		tmp_loop = mloop + mpoly[i].loopstart;

		for (x = 0; x < spring->la; x++) {
		spring->pa[x] = tmp_loop[j + x].v;
		}

		for (x = 0; x <= j; x++) {
		spring->pb[x] = tmp_loop[x].v;
		}

		for (y = k; y < mpoly[i].totloop; x++, y++) {
		spring->pb[x] = tmp_loop[y].v;
		}

		spring->mn = -1;

		spring->restang = cloth_spring_angle(cloth->verts, spring->ij, spring->kl,
		spring->pa, spring->pb, spring->la, spring->lb);

		spring->ang_stiffness = (cloth->verts[spring->ij].bend_stiff + cloth->verts[spring->kl].bend_stiff) / 2.0f;
		}

		BLI_linklist_prepend(&cloth->springs, spring);

		return true;
		}

		BLI_INLINE bool cloth_bend_set_poly_vert_array(int *poly, int len, const MLoop mloop)
		{
		int p = MEM_mallocN(sizeof(int) len, "spring poly");

		if (!p) {
		return false;
		}

		for (int i = 0; i < len; i++, mloop++) {
		p[i] = mloop->v;
		}

		*poly = p;

		return true;
		}

	static int cloth_build_springs ( ClothModifierData clmd, Mesh mesh )	static int cloth_build_springs ( ClothModifierData clmd, Mesh mesh )
	{	{
	Cloth *cloth = clmd->clothObject;	Cloth *cloth = clmd->clothObject;
	ClothSpring spring = NULL, tspring = NULL, *tspring2 = NULL;	ClothSpring spring = NULL, tspring = NULL, *tspring2 = NULL;
	unsigned int struct_springs = 0, shear_springs=0, bend_springs = 0, struct_springs_real = 0;	unsigned int struct_springs = 0, shear_springs=0, bend_springs = 0, struct_springs_real = 0;
	unsigned int i = 0;
	unsigned int mvert_num = (unsigned int)mesh->totvert;	unsigned int mvert_num = (unsigned int)mesh->totvert;
	unsigned int numedges = (unsigned int)mesh->totedge;	unsigned int numedges = (unsigned int)mesh->totedge;
	unsigned int numpolys = (unsigned int)mesh->totpoly;	unsigned int numpolys = (unsigned int)mesh->totpoly;
Context not available.
	const MPoly *mpoly = mesh->mpoly;	const MPoly *mpoly = mesh->mpoly;
	const MLoop *mloop = mesh->mloop;	const MLoop *mloop = mesh->mloop;
	int index2 = 0; // our second vertex index	int index2 = 0; // our second vertex index
	LinkNodePair *edgelist;	LinkNodePair *edgelist = NULL;
	EdgeSet *edgeset = NULL;	EdgeSet *edgeset = NULL;
	LinkNode search = NULL, search2 = NULL;	LinkNode search = NULL, search2 = NULL;
		BendSpringRef *spring_ref = NULL;

	// error handling	// error handling
	if ( numedges==0 )	if ( numedges==0 )
Context not available.
	cloth->springs = NULL;	cloth->springs = NULL;
	cloth->edgeset = NULL;	cloth->edgeset = NULL;

	edgelist = MEM_callocN(sizeof(edgelist) mvert_num, "cloth_edgelist_alloc" );	if (clmd->sim_parms->bending_model == CLOTH_BENDING_ANGULAR) {
		spring_ref = MEM_callocN(sizeof(spring_ref) numedges, "temp bend spring reference");

	if (!edgelist)	if (!spring_ref) {
	return 0;	return 0;
		}
		}
		else {
		edgelist = MEM_callocN(sizeof(edgelist) mvert_num, "cloth_edgelist_alloc" );

		if (!edgelist) {
		return 0;
		}
		}

	// structural springs	/* Structural springs. */
	for ( i = 0; i < numedges; i++ ) {	for (int i = 0; i < numedges; i++) {
	spring = (ClothSpring *)MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );	spring = (ClothSpring *)MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );

	if ( spring ) {	if ( spring ) {
Context not available.
	if (clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_SEW && medge[i].flag & ME_LOOSEEDGE) {	if (clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_SEW && medge[i].flag & ME_LOOSEEDGE) {
	// handle sewing (loose edges will be pulled together)	// handle sewing (loose edges will be pulled together)
	spring->restlen = 0.0f;	spring->restlen = 0.0f;
	spring->stiffness = 1.0f;	spring->lin_stiffness = 1.0f;
	spring->type = CLOTH_SPRING_TYPE_SEWING;	spring->type = CLOTH_SPRING_TYPE_SEWING;
	}	}
	else {	else {
	shrink_factor = cloth_shrink_factor(clmd, cloth->verts, spring->ij, spring->kl);	shrink_factor = cloth_shrink_factor(clmd, cloth->verts, spring->ij, spring->kl);
	spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest) * shrink_factor;	spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest) * shrink_factor;
	spring->stiffness = (cloth->verts[spring->kl].struct_stiff + cloth->verts[spring->ij].struct_stiff) / 2.0f;	spring->lin_stiffness = (cloth->verts[spring->kl].struct_stiff + cloth->verts[spring->ij].struct_stiff) / 2.0f;
	spring->type = CLOTH_SPRING_TYPE_STRUCTURAL;	spring->type = CLOTH_SPRING_TYPE_STRUCTURAL;

	clmd->sim_parms->avg_spring_len += spring->restlen;	clmd->sim_parms->avg_spring_len += spring->restlen;
Context not available.
	struct_springs++;	struct_springs++;

	BLI_linklist_prepend ( &cloth->springs, spring );	BLI_linklist_prepend ( &cloth->springs, spring );

		if (spring_ref) {
		spring_ref[i].spring = spring;
		}
	}	}
	else {	else {
	cloth_free_errorsprings(cloth, edgelist);	cloth_free_errorsprings(cloth, edgelist, spring_ref);
	return 0;	return 0;
	}	}
	}	}
Context not available.
	if (struct_springs_real > 0)	if (struct_springs_real > 0)
	clmd->sim_parms->avg_spring_len /= struct_springs_real;	clmd->sim_parms->avg_spring_len /= struct_springs_real;

	for (i = 0; i < mvert_num; i++) {	for (int i = 0; i < mvert_num; i++) {
	if (cloth->verts[i].spring_count > 0)	if (cloth->verts[i].spring_count > 0)
	cloth->verts[i].avg_spring_len = cloth->verts[i].avg_spring_len * 0.49f / ((float)cloth->verts[i].spring_count);	cloth->verts[i].avg_spring_len = cloth->verts[i].avg_spring_len * 0.49f / ((float)cloth->verts[i].spring_count);
	}	}

	// shear springs	edgeset = BLI_edgeset_new_ex(__func__, numedges);
	for (i = 0; i < numpolys; i++) {	cloth->edgeset = edgeset;
	/* triangle faces already have shear springs due to structural geometry */
	if (mpoly[i].totloop == 4) {	if (numpolys) {
	int j;	for (int i = 0; i < numpolys; i++) {
		/* Shear springs. */
		/* Triangle faces already have shear springs due to structural geometry. */
		if (mpoly[i].totloop > 3) {
		for (int j = 1; j < mpoly[i].totloop - 1; j++) {
		if (j > 1) {
		if (cloth_add_shear_bend_spring(clmd, edgelist, mloop, mpoly, i, 0, j)) {
		shear_springs++;

		if (clmd->sim_parms->bending_model == CLOTH_BENDING_ANGULAR) {
		bend_springs++;
		}
		}
		else {
		cloth_free_errorsprings(cloth, edgelist, spring_ref);
		return 0;
		}
		}

	for (j = 0; j != 2; j++) {	for (int k = j + 2; k < mpoly[i].totloop; k++) {
	spring = (ClothSpring *)MEM_callocN(sizeof(ClothSpring), "cloth spring");	if (cloth_add_shear_bend_spring(clmd, edgelist, mloop, mpoly, i, j, k)) {
		shear_springs++;

	if (!spring) {	if (clmd->sim_parms->bending_model == CLOTH_BENDING_ANGULAR) {
	cloth_free_errorsprings(cloth, edgelist);	bend_springs++;
	return 0;	}
		}
		else {
		cloth_free_errorsprings(cloth, edgelist, spring_ref);
		return 0;
		}
		}
	}	}
		}

	spring_verts_ordered_set(	/* Angular bending springs along struct springs. */
	spring,	if (clmd->sim_parms->bending_model == CLOTH_BENDING_ANGULAR) {
	mloop[mpoly[i].loopstart + (j + 0)].v,	const MLoop *ml = mloop + mpoly[i].loopstart;
	mloop[mpoly[i].loopstart + (j + 2)].v);

	shrink_factor = cloth_shrink_factor(clmd, cloth->verts, spring->ij, spring->kl);	for (int j = 0; j < mpoly[i].totloop; j++, ml++) {
	spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest) * shrink_factor;	BendSpringRef *curr_ref = &spring_ref[ml->e];
	spring->type = CLOTH_SPRING_TYPE_SHEAR;	curr_ref->polys++;
	spring->stiffness = (cloth->verts[spring->kl].shear_stiff + cloth->verts[spring->ij].shear_stiff) / 2.0f;
		/* First poly found for this edge, store poly index. */
		if (curr_ref->polys == 1) {
		curr_ref->index = i;
		}
		/* Second poly found for this egde, add bending data. */
		else if (curr_ref->polys == 2) {
		spring = curr_ref->spring;

		spring->type \|= CLOTH_SPRING_TYPE_BENDING;

		spring->la = mpoly[curr_ref->index].totloop;
		spring->lb = mpoly[i].totloop;

		if (!cloth_bend_set_poly_vert_array(&spring->pa, spring->la, &mloop[mpoly[curr_ref->index].loopstart]) \|\|
		!cloth_bend_set_poly_vert_array(&spring->pb, spring->lb, &mloop[mpoly[i].loopstart]))
		{
		cloth_free_errorsprings(cloth, edgelist, spring_ref);
		return 0;
		}

		spring->mn = ml->e;

	BLI_linklist_append(&edgelist[spring->ij], spring);	spring->restang = cloth_spring_angle(cloth->verts, spring->ij, spring->kl,
	BLI_linklist_append(&edgelist[spring->kl], spring);	spring->pa, spring->pb, spring->la, spring->lb);

	shear_springs++;	spring->ang_stiffness = (cloth->verts[spring->ij].bend_stiff + cloth->verts[spring->kl].bend_stiff) / 2.0f;

	BLI_linklist_prepend(&cloth->springs, spring);	bend_springs++;
		}
		/* Third poly found for this egde, remove bending data. */
		else if (curr_ref->polys == 3) {
		spring = curr_ref->spring;

		spring->type &= ~CLOTH_SPRING_TYPE_BENDING;
		MEM_freeN(spring->pa);
		MEM_freeN(spring->pb);
		spring->pa = NULL;
		spring->pb = NULL;

		bend_springs--;
		}
		}
	}	}
	}	}
	}

	edgeset = BLI_edgeset_new_ex(__func__, numedges);	/* Linear bending springs. */
	cloth->edgeset = edgeset;	if (clmd->sim_parms->bending_model == CLOTH_BENDING_LINEAR) {
		search2 = cloth->springs;

	if (numpolys) {	for (int i = struct_springs; i < struct_springs+shear_springs; i++) {
	// bending springs	if (!search2) {
	search2 = cloth->springs;	break;
	for ( i = struct_springs; i < struct_springs+shear_springs; i++ ) {	}
	if ( !search2 )
	break;

	tspring2 = search2->link;	tspring2 = search2->link;
	search = edgelist[tspring2->kl].list;	search = edgelist[tspring2->kl].list;
	while ( search ) {
	tspring = search->link;	while (search) {
	index2 = ( ( tspring->ij==tspring2->kl ) ? ( tspring->kl ) : ( tspring->ij ) );	tspring = search->link;
		index2 = ((tspring->ij == tspring2->kl) ? (tspring->kl) : (tspring->ij));

		/* Check for existing spring. */
		/* Check also if startpoint is equal to endpoint. */
		if ((index2 != tspring2->ij) &&
		!BLI_edgeset_haskey(edgeset, tspring2->ij, index2))
		{
		spring = (ClothSpring *)MEM_callocN(sizeof(ClothSpring), "cloth spring");

		if (!spring) {
		cloth_free_errorsprings(cloth, edgelist, spring_ref);
		return 0;
		}

	// check for existing spring	spring_verts_ordered_set(spring, tspring2->ij, index2);
	// check also if startpoint is equal to endpoint	shrink_factor = cloth_shrink_factor(clmd, cloth->verts, spring->ij, spring->kl);
	if ((index2 != tspring2->ij) &&	spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest) * shrink_factor;
	!BLI_edgeset_haskey(edgeset, tspring2->ij, index2))	spring->type = CLOTH_SPRING_TYPE_BENDING;
	{	spring->lin_stiffness = (cloth->verts[spring->kl].bend_stiff + cloth->verts[spring->ij].bend_stiff) / 2.0f;
	spring = (ClothSpring *)MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );	BLI_edgeset_insert(edgeset, spring->ij, spring->kl);
		bend_springs++;

	if (!spring) {	BLI_linklist_prepend(&cloth->springs, spring);
	cloth_free_errorsprings(cloth, edgelist);
	return 0;
	}	}

	spring_verts_ordered_set(spring, tspring2->ij, index2);	search = search->next;
	shrink_factor = cloth_shrink_factor(clmd, cloth->verts, spring->ij, spring->kl);
	spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest) * shrink_factor;
	spring->type = CLOTH_SPRING_TYPE_BENDING;
	spring->stiffness = (cloth->verts[spring->kl].bend_stiff + cloth->verts[spring->ij].bend_stiff) / 2.0f;
	BLI_edgeset_insert(edgeset, spring->ij, spring->kl);
	bend_springs++;

	BLI_linklist_prepend ( &cloth->springs, spring );
	}	}
	search = search->next;
		search2 = search2->next;
	}	}
	search2 = search2->next;
	}	}
	}	}
	else if (struct_springs > 2) {	else if (struct_springs > 2) {
Context not available.
	spring = (ClothSpring *)MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );	spring = (ClothSpring *)MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );

	if (!spring) {	if (!spring) {
	cloth_free_errorsprings(cloth, edgelist);	cloth_free_errorsprings(cloth, edgelist, spring_ref);
	return 0;	return 0;
	}	}

Context not available.
	spring->kl = tspring->ij;	spring->kl = tspring->ij;
	spring->mn = tspring->kl;	spring->mn = tspring->kl;
	spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest);	spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest);
	spring->type = CLOTH_SPRING_TYPE_BENDING_ANG;	spring->type = CLOTH_SPRING_TYPE_BENDING_HAIR;
	spring->stiffness = (cloth->verts[spring->kl].bend_stiff + cloth->verts[spring->ij].bend_stiff) / 2.0f;	spring->lin_stiffness = (cloth->verts[spring->kl].bend_stiff + cloth->verts[spring->ij].bend_stiff) / 2.0f;
	bend_springs++;	bend_springs++;

	BLI_linklist_prepend ( &cloth->springs, spring );	BLI_linklist_prepend ( &cloth->springs, spring );
Context not available.
	spring = (ClothSpring *)MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );	spring = (ClothSpring *)MEM_callocN ( sizeof ( ClothSpring ), "cloth spring" );

	if (!spring) {	if (!spring) {
	cloth_free_errorsprings(cloth, edgelist);	cloth_free_errorsprings(cloth, edgelist, spring_ref);
	return 0;	return 0;
	}	}

Context not available.
	spring->kl = tspring->kl;	spring->kl = tspring->kl;
	spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest);	spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest);
	spring->type = CLOTH_SPRING_TYPE_BENDING;	spring->type = CLOTH_SPRING_TYPE_BENDING;
	spring->stiffness = (cloth->verts[spring->kl].bend_stiff + cloth->verts[spring->ij].bend_stiff) / 2.0f;	spring->lin_stiffness = (cloth->verts[spring->kl].bend_stiff + cloth->verts[spring->ij].bend_stiff) / 2.0f;
	bend_springs++;	bend_springs++;

	BLI_linklist_prepend ( &cloth->springs, spring );	BLI_linklist_prepend ( &cloth->springs, spring );
Context not available.
	/* note: the edges may already exist so run reinsert */	/* note: the edges may already exist so run reinsert */

	/* insert other near springs in edgeset AFTER bending springs are calculated (for selfcolls) */	/* insert other near springs in edgeset AFTER bending springs are calculated (for selfcolls) */
	for (i = 0; i < numedges; i++) { /* struct springs */	for (int i = 0; i < numedges; i++) { /* struct springs */
	BLI_edgeset_add(edgeset, medge[i].v1, medge[i].v2);	BLI_edgeset_add(edgeset, medge[i].v1, medge[i].v2);
	}	}

	for (i = 0; i < numpolys; i++) { /* edge springs */	for (int i = 0; i < numpolys; i++) { /* edge springs */
	if (mpoly[i].totloop == 4) {	if (mpoly[i].totloop == 4) {
	BLI_edgeset_add(edgeset, mloop[mpoly[i].loopstart + 0].v, mloop[mpoly[i].loopstart + 2].v);	BLI_edgeset_add(edgeset, mloop[mpoly[i].loopstart + 0].v, mloop[mpoly[i].loopstart + 2].v);
	BLI_edgeset_add(edgeset, mloop[mpoly[i].loopstart + 1].v, mloop[mpoly[i].loopstart + 3].v);	BLI_edgeset_add(edgeset, mloop[mpoly[i].loopstart + 1].v, mloop[mpoly[i].loopstart + 3].v);
	}	}
	}	}

		MEM_SAFE_FREE(spring_ref);

	cloth->numsprings = struct_springs + shear_springs + bend_springs;	cloth->numsprings = struct_springs + shear_springs + bend_springs;

Context not available.