Merge with trunk: svn merge -r 12182:12207 https://svn.blender.org/svnroot/bf-blender...
authorDaniel Genrich <daniel.genrich@gmx.net>
Thu, 4 Oct 2007 11:22:54 +0000 (11:22 +0000)
committerDaniel Genrich <daniel.genrich@gmx.net>
Thu, 4 Oct 2007 11:22:54 +0000 (11:22 +0000)
1  2 
source/blender/blenkernel/intern/collision.c
source/blender/blenloader/intern/readfile.c
source/blender/src/buttons_editing.c
source/blender/src/buttons_object.c

index a89cd3dc4b9b12046344c5ff743a8362da9dda61,0000000000000000000000000000000000000000..5e90dd581d81785cef3cd346d7efd5f2e11ff7c7
mode 100644,000000..100644
--- /dev/null
@@@ -1,1237 -1,0 +1,1235 @@@
-                               i+=5; // get out of here!
 +/*  collision.c      
 +* 
 +*
 +* ***** BEGIN GPL/BL DUAL 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.
 +*
 +* This program is distributed in the hope that it will be useful,
 +* but WITHOUT ANY WARRANTY; without even the implied warranty of
 +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 +* GNU General Public License for more details.
 +*
 +* You should have received a copy of the GNU General Public License
 +* along with this program; if not, write to the Free Software Foundation,
 +* Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 +*
 +* The Original Code is Copyright (C) Blender Foundation
 +* All rights reserved.
 +*
 +* The Original Code is: all of this file.
 +*
 +* Contributor(s): none yet.
 +*
 +* ***** END GPL/BL DUAL 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 "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_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_mesh.h"
 +#include "BKE_object.h"
 +#include "BKE_cloth.h"
 +#include "BKE_modifier.h"
 +#include "BKE_utildefines.h"
 +#include "BKE_DerivedMesh.h"
 +#include "DNA_screen_types.h"
 +#include "BSE_headerbuttons.h"
 +#include "BIF_screen.h"
 +#include "BIF_space.h"
 +#include "mydevice.h"
 +
 +#include "Bullet-C-Api.h"
 +
 +
 +
 +/**
 + * gsl_poly_solve_cubic -
 + *
 + * copied from SOLVE_CUBIC.C --> GSL
 + */
 +#define mySWAP(a,b) do { float tmp = b ; b = a ; a = tmp ; } while(0)
 +
 +int gsl_poly_solve_cubic (float a, float b, float c, float *x0, float *x1, float *x2)
 +{
 +      float q = (a * a - 3 * b);
 +      float r = (2 * a * a * a - 9 * a * b + 27 * c);
 +
 +      float Q = q / 9;
 +      float R = r / 54;
 +
 +      float Q3 = Q * Q * Q;
 +      float R2 = R * R;
 +
 +      float CR2 = 729 * r * r;
 +      float CQ3 = 2916 * q * q * q;
 +
 +      if (R == 0 && Q == 0)
 +      {
 +              *x0 = - a / 3 ;
 +              *x1 = - a / 3 ;
 +              *x2 = - a / 3 ;
 +              return 3 ;
 +      }
 +      else if (CR2 == CQ3) 
 +      {
 +        /* this test is actually R2 == Q3, written in a form suitable
 +              for exact computation with integers */
 +
 +        /* Due to finite precision some float roots may be missed, and
 +              considered to be a pair of complex roots z = x +/- epsilon i
 +              close to the real axis. */
 +
 +              float sqrtQ = sqrtf (Q);
 +
 +              if (R > 0)
 +              {
 +                      *x0 = -2 * sqrtQ  - a / 3;
 +                      *x1 = sqrtQ - a / 3;
 +                      *x2 = sqrtQ - a / 3;
 +              }
 +              else
 +              {
 +                      *x0 = - sqrtQ  - a / 3;
 +                      *x1 = - sqrtQ - a / 3;
 +                      *x2 = 2 * sqrtQ - a / 3;
 +              }
 +              return 3 ;
 +      }
 +      else if (CR2 < CQ3) /* equivalent to R2 < Q3 */
 +      {
 +              float sqrtQ = sqrtf (Q);
 +              float sqrtQ3 = sqrtQ * sqrtQ * sqrtQ;
 +              float theta = acosf (R / sqrtQ3);
 +              float norm = -2 * sqrtQ;
 +              *x0 = norm * cosf (theta / 3) - a / 3;
 +              *x1 = norm * cosf ((theta + 2.0 * M_PI) / 3) - a / 3;
 +              *x2 = norm * cosf ((theta - 2.0 * M_PI) / 3) - a / 3;
 +      
 +              /* Sort *x0, *x1, *x2 into increasing order */
 +
 +              if (*x0 > *x1)
 +                      mySWAP(*x0, *x1) ;
 +      
 +              if (*x1 > *x2)
 +              {
 +                      mySWAP(*x1, *x2) ;
 +          
 +                      if (*x0 > *x1)
 +                              mySWAP(*x0, *x1) ;
 +              }
 +      
 +              return 3;
 +      }
 +      else
 +      {
 +              float sgnR = (R >= 0 ? 1 : -1);
 +              float A = -sgnR * powf (fabs (R) + sqrtf (R2 - Q3), 1.0/3.0);
 +              float B = Q / A ;
 +              *x0 = A + B - a / 3;
 +              return 1;
 +      }
 +}
 +
 +
 +/**
 + * gsl_poly_solve_quadratic
 + *
 + * copied from GSL
 + */
 +int gsl_poly_solve_quadratic (float a, float b, float c,  float *x0, float *x1)
 +{
 +      float disc = b * b - 4 * a * c;
 +
 +      if (disc > 0)
 +      {
 +              if (b == 0)
 +              {
 +                      float r = fabs (0.5 * sqrtf (disc) / a);
 +                      *x0 = -r;
 +                      *x1 =  r;
 +              }
 +              else
 +              {
 +                      float sgnb = (b > 0 ? 1 : -1);
 +                      float temp = -0.5 * (b + sgnb * sqrtf (disc));
 +                      float r1 = temp / a ;
 +                      float r2 = c / temp ;
 +
 +                      if (r1 < r2) 
 +                      {
 +                              *x0 = r1 ;
 +                              *x1 = r2 ;
 +                      } 
 +                      else 
 +                      {
 +                              *x0 = r2 ;
 +                              *x1 = r1 ;
 +                      }
 +              }
 +              return 2;
 +      }
 +      else if (disc == 0) 
 +      {
 +              *x0 = -0.5 * b / a ;
 +              *x1 = -0.5 * b / a ;
 +              return 2 ;
 +      }
 +      else
 +      {
 +              return 0;
 +      }
 +}
 +
 +
 +
 +/*
 + * See Bridson et al. "Robust Treatment of Collision, Contact and Friction for Cloth Animation"
 + *     page 4, left column
 + */
 +
 +int cloth_get_collision_time(float a[3], float b[3], float c[3], float d[3], float e[3], float f[3], float solution[3]) 
 +{
 +      int num_sols = 0;
 +      
 +      float g = -a[2] * c[1] * e[0] + a[1] * c[2] * e[0] +
 +                      a[2] * c[0] * e[1] - a[0] * c[2] * e[1] -
 +                      a[1] * c[0] * e[2] + a[0] * c[1] * e[2];
 +
 +      float h = -b[2] * c[1] * e[0] + b[1] * c[2] * e[0] - a[2] * d[1] * e[0] +
 +                      a[1] * d[2] * e[0] + b[2] * c[0] * e[1] - b[0] * c[2] * e[1] +
 +                      a[2] * d[0] * e[1] - a[0] * d[2] * e[1] - b[1] * c[0] * e[2] +
 +                      b[0] * c[1] * e[2] - a[1] * d[0] * e[2] + a[0] * d[1] * e[2] -
 +                      a[2] * c[1] * f[0] + a[1] * c[2] * f[0] + a[2] * c[0] * f[1] -
 +                      a[0] * c[2] * f[1] - a[1] * c[0] * f[2] + a[0] * c[1] * f[2];
 +
 +      float i = -b[2] * d[1] * e[0] + b[1] * d[2] * e[0] +
 +                      b[2] * d[0] * e[1] - b[0] * d[2] * e[1] -
 +                      b[1] * d[0] * e[2] + b[0] * d[1] * e[2] -
 +                      b[2] * c[1] * f[0] + b[1] * c[2] * f[0] -
 +                      a[2] * d[1] * f[0] + a[1] * d[2] * f[0] +
 +                      b[2] * c[0] * f[1] - b[0] * c[2] * f[1] + 
 +                      a[2] * d[0] * f[1] - a[0] * d[2] * f[1] -
 +                      b[1] * c[0] * f[2] + b[0] * c[1] * f[2] -
 +                      a[1] * d[0] * f[2] + a[0] * d[1] * f[2];
 +
 +      float j = -b[2] * d[1] * f[0] + b[1] * d[2] * f[0] +
 +                      b[2] * d[0] * f[1] - b[0] * d[2] * f[1] -
 +                      b[1] * d[0] * f[2] + b[0] * d[1] * f[2];
 +
 +      // Solve cubic equation to determine times t1, t2, t3, when the collision will occur.
 +      if(ABS(j) > ALMOST_ZERO)
 +      {
 +              i /= j;
 +              h /= j;
 +              g /= j;
 +              
 +              num_sols = gsl_poly_solve_cubic(i, h, g, &solution[0], &solution[1], &solution[2]);
 +      }
 +      else if(ABS(i) > ALMOST_ZERO)
 +      {       
 +              num_sols = gsl_poly_solve_quadratic(i, h, g, &solution[0], &solution[1]);
 +              solution[2] = -1.0;
 +      }
 +      else if(ABS(h) > ALMOST_ZERO)
 +      {
 +              solution[0] = -g / h;
 +              solution[1] = solution[2] = -1.0;
 +              num_sols = 1;
 +      }
 +      else if(ABS(g) > ALMOST_ZERO)
 +      {
 +              solution[0] = 0;
 +              solution[1] = solution[2] = -1.0;
 +              num_sols = 1;
 +      }
 +
 +      // Discard negative solutions
 +      if ((num_sols >= 1) && (solution[0] < 0)) 
 +      {
 +              --num_sols;
 +              solution[0] = solution[num_sols];
 +      }
 +      if ((num_sols >= 2) && (solution[1] < 0)) 
 +      {
 +              --num_sols;
 +              solution[1] = solution[num_sols];
 +      }
 +      if ((num_sols == 3) && (solution[2] < 0)) 
 +      {
 +              --num_sols;
 +      }
 +
 +      // Sort
 +      if (num_sols == 2) 
 +      {
 +              if (solution[0] > solution[1]) 
 +              {
 +                      double tmp = solution[0];
 +                      solution[0] = solution[1];
 +                      solution[1] = tmp;
 +              }
 +      }
 +      else if (num_sols == 3) 
 +      {
 +
 +              // Bubblesort
 +              if (solution[0] > solution[1]) {
 +                      double tmp = solution[0]; solution[0] = solution[1]; solution[1] = tmp;
 +              }
 +              if (solution[1] > solution[2]) {
 +                      double tmp = solution[1]; solution[1] = solution[2]; solution[2] = tmp;
 +              }
 +              if (solution[0] > solution[1]) {
 +                      double tmp = solution[0]; solution[0] = solution[1]; solution[1] = tmp;
 +              }
 +      }
 +
 +      return num_sols;
 +}
 +
 +// w3 is not perfect
 +void cloth_compute_barycentric (float pv[3], float p1[3], float p2[3], float p3[3], float *w1, float *w2, float *w3)
 +{
 +      double  tempV1[3], tempV2[3], tempV4[3];
 +      double  a,b,c,d,e,f;
 +
 +      VECSUB (tempV1, p1, p3);        
 +      VECSUB (tempV2, p2, p3);        
 +      VECSUB (tempV4, pv, p3);        
 +      
 +      a = INPR (tempV1, tempV1);      
 +      b = INPR (tempV1, tempV2);      
 +      c = INPR (tempV2, tempV2);      
 +      e = INPR (tempV1, tempV4);      
 +      f = INPR (tempV2, tempV4);      
 +      
 +      d = (a * c - b * b);
 +      
 +      if (ABS(d) < ALMOST_ZERO) {
 +              *w1 = *w2 = *w3 = 1.0 / 3.0;
 +              return;
 +      }
 +      
 +      w1[0] = (float)((e * c - b * f) / d);
 +      
 +      if(w1[0] < 0)
 +              w1[0] = 0;
 +      
 +      w2[0] = (float)((f - b * (double)w1[0]) / c);
 +      
 +      if(w2[0] < 0)
 +              w2[0] = 0;
 +      
 +      w3[0] = 1.0f - w1[0] - w2[0];
 +}
 +
 +DO_INLINE void interpolateOnTriangle(float to[3], float v1[3], float v2[3], float v3[3], double w1, double w2, double w3) 
 +{
 +      to[0] = to[1] = to[2] = 0;
 +      VECADDMUL(to, v1, w1);
 +      VECADDMUL(to, v2, w2);
 +      VECADDMUL(to, v3, w3);
 +}
 +
 +
 +
 +// unused in the moment, has some bug in
 +DO_INLINE void calculateFrictionImpulse(float to[3], float vrel[3], float normal[3], double normalVelocity,
 +                                      double frictionConstant, double delta_V_n) 
 +{
 +      float vrel_t_pre[3];
 +      float vrel_t[3];
 +      VECSUBS(vrel_t_pre, vrel, normal, normalVelocity);
 +      VECCOPY(to, vrel_t_pre);
 +      VecMulf(to, MAX2(1.0f - frictionConstant * delta_V_n / INPR(vrel_t_pre,vrel_t_pre), 0.0f));
 +}
 +
 +int cloth_collision_response_static(ClothModifierData *clmd, ClothModifierData *coll_clmd)
 +{
 +      unsigned int i = 0;
 +      int result = 0;
 +      LinkNode *search = NULL;
 +      CollPair *collpair = NULL;
 +      Cloth *cloth1, *cloth2;
 +      float w1, w2, w3, u1, u2, u3;
 +      float v1[3], v2[3], relativeVelocity[3];
 +      float magrelVel;
 +      
 +      cloth1 = clmd->clothObject;
 +      cloth2 = coll_clmd->clothObject;
 +
 +      search = clmd->coll_parms.collision_list;
 +      
 +      while(search)
 +      {
 +              collpair = search->link;
 +              
 +              // compute barycentric coordinates for both collision points
 +              cloth_compute_barycentric(collpair->pa,
 +                                      cloth1->verts[collpair->ap1].txold,
 +                                      cloth1->verts[collpair->ap2].txold,
 +                                      cloth1->verts[collpair->ap3].txold, 
 +                                      &w1, &w2, &w3);
 +      
 +              cloth_compute_barycentric(collpair->pb,
 +                                      cloth2->verts[collpair->bp1].txold,
 +                                      cloth2->verts[collpair->bp2].txold,
 +                                      cloth2->verts[collpair->bp3].txold,
 +                                      &u1, &u2, &u3);
 +      
 +              // Calculate relative "velocity".
 +              interpolateOnTriangle(v1, cloth1->verts[collpair->ap1].tv, cloth1->verts[collpair->ap2].tv, cloth1->verts[collpair->ap3].tv, w1, w2, w3);
 +              
 +              interpolateOnTriangle(v2, cloth2->verts[collpair->bp1].tv, cloth2->verts[collpair->bp2].tv, cloth2->verts[collpair->bp3].tv, u1, u2, u3);
 +              
 +              VECSUB(relativeVelocity, v1, v2);
 +                      
 +              // Calculate the normal component of the relative velocity (actually only the magnitude - the direction is stored in 'normal').
 +              magrelVel = INPR(relativeVelocity, collpair->normal);
 +              
 +              // printf("magrelVel: %f\n", magrelVel);
 +                              
 +              // Calculate masses of points.
 +              
 +              // If v_n_mag < 0 the edges are approaching each other.
 +              if(magrelVel < -ALMOST_ZERO) 
 +              {
 +                      // Calculate Impulse magnitude to stop all motion in normal direction.
 +                      // const double I_mag = v_n_mag / (1/m1 + 1/m2);
 +                      float magnitude_i = magrelVel / 2.0f; // TODO implement masses
 +                      float tangential[3], magtangent, magnormal, collvel[3];
 +                      float vrel_t_pre[3];
 +                      float vrel_t[3];
 +                      double impulse;
 +                      float epsilon = clmd->coll_parms.epsilon;
 +                      float overlap = (epsilon + ALMOST_ZERO-collpair->distance);
 +                      
 +                      // calculateFrictionImpulse(tangential, relativeVelocity, collpair->normal, magrelVel, clmd->coll_parms.friction*0.01, magrelVel);
 +                      
 +                      // magtangent = INPR(tangential, tangential);
 +                      
 +                      // Apply friction impulse.
 +                      if (magtangent < -ALMOST_ZERO) 
 +                      {
 +                              
 +                              // printf("friction applied: %f\n", magtangent);
 +                              // TODO check original code 
 +                              /*
 +                              VECSUB(cloth1->verts[face1->v1].tv, cloth1->verts[face1->v1].tv,tangential);
 +                              VECSUB(cloth1->verts[face1->v1].tv, cloth1->verts[face1->v2].tv,tangential);
 +                              VECSUB(cloth1->verts[face1->v1].tv, cloth1->verts[face1->v3].tv,tangential);
 +                              VECSUB(cloth1->verts[face1->v1].tv, cloth1->verts[face1->v4].tv,tangential);
 +                              */
 +                      }
 +                      
 +
 +                      impulse = -2.0f * magrelVel / ( 1.0 + w1*w1 + w2*w2 + w3*w3);
 +                      
 +                      // printf("impulse: %f\n", impulse);
 +                      
 +                      VECADDMUL(cloth1->verts[collpair->ap1].impulse, collpair->normal, w1 * impulse); 
 +                      cloth1->verts[collpair->ap1].impulse_count++;
 +                      
 +                      VECADDMUL(cloth1->verts[collpair->ap2].impulse, collpair->normal, w2 * impulse); 
 +                      cloth1->verts[collpair->ap2].impulse_count++;
 +                      
 +                      VECADDMUL(cloth1->verts[collpair->ap3].impulse, collpair->normal, w3 * impulse); 
 +                      cloth1->verts[collpair->ap3].impulse_count++;
 +                      
 +                      result = 1;
 +                      
 +                      /*
 +                      if (overlap > ALMOST_ZERO) {
 +                      double I_mag  = overlap * 0.1;
 +                              
 +                      impulse = -I_mag / ( 1.0 + w1*w1 + w2*w2 + w3*w3);
 +                              
 +                      VECADDMUL(cloth1->verts[collpair->ap1].impulse, collpair->normal, w1 * impulse); 
 +                      cloth1->verts[collpair->ap1].impulse_count++;
 +                                                      
 +                      VECADDMUL(cloth1->verts[collpair->ap2].impulse, collpair->normal, w2 * impulse); 
 +                      cloth1->verts[collpair->ap2].impulse_count++;
 +                      
 +                      VECADDMUL(cloth1->verts[collpair->ap3].impulse, collpair->normal, w3 * impulse); 
 +                      cloth1->verts[collpair->ap3].impulse_count++;
 +              }
 +                      */
 +              
 +                      // printf("magnitude_i: %f\n", magnitude_i); // negative before collision in my case
 +                      
 +                      // Apply the impulse and increase impulse counters.
 +
 +                      /*                      
 +                      // calculateFrictionImpulse(tangential, collvel, collpair->normal, magtangent, clmd->coll_parms.friction*0.01, magtangent);
 +                      VECSUBS(vrel_t_pre, collvel, collpair->normal, magnormal);
 +                      // VecMulf(vrel_t_pre, clmd->coll_parms.friction*0.01f/INPR(vrel_t_pre,vrel_t_pre));
 +                      magtangent = Normalize(vrel_t_pre);
 +                      VecMulf(vrel_t_pre, MIN2(clmd->coll_parms.friction*0.01f*magnormal,magtangent));
 +                      
 +                      VECSUB(cloth1->verts[face1->v1].tv, cloth1->verts[face1->v1].tv,vrel_t_pre);
 +                      */
 +                      
 +                      
 +                      
 +              }
 +              
 +              search = search->next;
 +      }
 +      
 +              
 +      return result;
 +}
 +
 +void cloth_collision_static(ClothModifierData *clmd, ClothModifierData *coll_clmd, Tree *tree1, Tree *tree2)
 +{
 +      CollPair *collpair = NULL;
 +      Cloth *cloth1=NULL, *cloth2=NULL;
 +      MFace *face1=NULL, *face2=NULL;
 +      ClothVertex *verts1=NULL, *verts2=NULL;
 +      double distance = 0;
 +      float epsilon = clmd->coll_parms.epsilon;
 +      unsigned int i = 0;
 +
 +      for(i = 0; i < 4; i++)
 +      {
 +              collpair = (CollPair *)MEM_callocN(sizeof(CollPair), "cloth coll pair");                
 +              
 +              cloth1 = clmd->clothObject;
 +              cloth2 = coll_clmd->clothObject;
 +              
 +              verts1 = cloth1->verts;
 +              verts2 = cloth2->verts;
 +      
 +              face1 = &(cloth1->mfaces[tree1->tri_index]);
 +              face2 = &(cloth2->mfaces[tree2->tri_index]);
 +              
 +              // check all possible pairs of triangles
 +              if(i == 0)
 +              {
 +                      collpair->ap1 = face1->v1;
 +                      collpair->ap2 = face1->v2;
 +                      collpair->ap3 = face1->v3;
 +                      
 +                      collpair->bp1 = face2->v1;
 +                      collpair->bp2 = face2->v2;
 +                      collpair->bp3 = face2->v3;
 +                      
 +              }
 +              
 +              if(i == 1)
 +              {
 +                      if(face1->v4)
 +                      {
 +                              collpair->ap1 = face1->v3;
 +                              collpair->ap2 = face1->v4;
 +                              collpair->ap3 = face1->v1;
 +                              
 +                              collpair->bp1 = face2->v1;
 +                              collpair->bp2 = face2->v2;
 +                              collpair->bp3 = face2->v3;
 +                      }
 +                      else
 +                              i++;
 +              }
 +              
 +              if(i == 2)
 +              {
 +                      if(face2->v4)
 +                      {
 +                              collpair->ap1 = face1->v1;
 +                              collpair->ap2 = face1->v2;
 +                              collpair->ap3 = face1->v3;
 +                              
 +                              collpair->bp1 = face2->v3;
 +                              collpair->bp2 = face2->v4;
 +                              collpair->bp3 = face2->v1;
 +                      }
 +                      else
 +                              i+=2;
 +              }
 +              
 +              if(i == 3)
 +              {
 +                      if((face1->v4)&&(face2->v4))
 +                      {
 +                              collpair->ap1 = face1->v3;
 +                              collpair->ap2 = face1->v4;
 +                              collpair->ap3 = face1->v1;
 +                              
 +                              collpair->bp1 = face2->v3;
 +                              collpair->bp2 = face2->v4;
 +                              collpair->bp3 = face2->v1;
 +                      }
 +                      else
 +                              i++;
 +              }
 +              
 +              // calc SIPcode (?)
 +              
 +              if(i < 4)
 +              {
 +                      // calc distance + normal       
 +                      distance = plNearestPoints(
 +                                      verts1[collpair->ap1].txold, verts1[collpair->ap2].txold, verts1[collpair->ap3].txold, verts2[collpair->bp1].txold, verts2[collpair->bp2].txold, verts2[collpair->bp3].txold, collpair->pa,collpair->pb,collpair->vector);
 +                      
 +                      if (distance <= (epsilon + ALMOST_ZERO))
 +                      {
 +                              // printf("dist: %f\n", (float)distance);
 +                              
 +                              // collpair->face1 = tree1->tri_index;
 +                              // collpair->face2 = tree2->tri_index;
 +                              
 +                              VECCOPY(collpair->normal, collpair->vector);
 +                              Normalize(collpair->normal);
 +                              
 +                              collpair->distance = distance;
 +                              BLI_linklist_append(&clmd->coll_parms.collision_list, collpair);
 +                      }
 +                      else
 +                      {
 +                              MEM_freeN(collpair);
 +                      }
 +              }
 +              else
 +              {
 +                      MEM_freeN(collpair);
 +              }
 +      }
 +}
 +
 +int cloth_are_edges_adjacent(ClothModifierData *clmd, ClothModifierData *coll_clmd, EdgeCollPair *edgecollpair)
 +{
 +      Cloth *cloth1, *cloth2;
 +      ClothVertex *verts1, *verts2;
 +      float temp[3];
 +       
 +      cloth1 = clmd->clothObject;
 +      cloth2 = coll_clmd->clothObject;
 +      
 +      verts1 = cloth1->verts;
 +      verts2 = cloth2->verts;
 +      
 +      VECSUB(temp, verts1[edgecollpair->p11].xold, verts2[edgecollpair->p21].xold);
 +      if(ABS(INPR(temp, temp)) < ALMOST_ZERO)
 +              return 1;
 +      
 +      VECSUB(temp, verts1[edgecollpair->p11].xold, verts2[edgecollpair->p22].xold);
 +      if(ABS(INPR(temp, temp)) < ALMOST_ZERO)
 +              return 1;
 +      
 +      VECSUB(temp, verts1[edgecollpair->p12].xold, verts2[edgecollpair->p21].xold);
 +      if(ABS(INPR(temp, temp)) < ALMOST_ZERO)
 +              return 1;
 +      
 +      VECSUB(temp, verts1[edgecollpair->p12].xold, verts2[edgecollpair->p22].xold);
 +      if(ABS(INPR(temp, temp)) < ALMOST_ZERO)
 +              return 1;
 +              
 +      return 0;
 +}
 +
 +void cloth_collision_moving_edges(ClothModifierData *clmd, ClothModifierData *coll_clmd, Tree *tree1, Tree *tree2)
 +{
 +      EdgeCollPair edgecollpair;
 +      Cloth *cloth1=NULL, *cloth2=NULL;
 +      MFace *face1=NULL, *face2=NULL;
 +      ClothVertex *verts1=NULL, *verts2=NULL;
 +      double distance = 0;
 +      float epsilon = clmd->coll_parms.epsilon;
 +      unsigned int i = 0, j = 0, k = 0;
 +      int numsolutions = 0;
 +      float a[3], b[3], c[3], d[3], e[3], f[3], solution[3];
 +      
 +      cloth1 = clmd->clothObject;
 +      cloth2 = coll_clmd->clothObject;
 +      
 +      verts1 = cloth1->verts;
 +      verts2 = cloth2->verts;
 +
 +      face1 = &(cloth1->mfaces[tree1->tri_index]);
 +      face2 = &(cloth2->mfaces[tree2->tri_index]);
 +      
 +      for( i = 0; i < 5; i++)
 +      {
 +              if(i == 0) 
 +              {
 +                      edgecollpair.p11 = face1->v1;
 +                      edgecollpair.p12 = face1->v2;
 +              }
 +              else if(i == 1) 
 +              {
 +                      edgecollpair.p11 = face1->v2;
 +                      edgecollpair.p12 = face1->v3;
 +              }
 +              else if(i == 2) 
 +              {
 +                      if(face1->v4) 
 +                      {
 +                              edgecollpair.p11 = face1->v3;
 +                              edgecollpair.p12 = face1->v4;
 +                      }
 +                      else 
 +                      {
 +                              edgecollpair.p11 = face1->v3;
 +                              edgecollpair.p12 = face1->v1;
-       }
-               
-               
++                              i+=5; // get out of here after this edge pair is handled
 +                      }
 +              }
 +              else if(i == 3) 
 +              {
 +                      if(face1->v4) 
 +                      {
 +                              edgecollpair.p11 = face1->v4;
 +                              edgecollpair.p12 = face1->v1;
 +                      }       
 +                      else
 +                              continue;
 +              }
 +              else
 +              {
 +                      edgecollpair.p11 = face1->v3;
 +                      edgecollpair.p12 = face1->v1;
 +              }
 +
 +              
 +              for( j = 0; j < 5; j++)
 +              {
 +                      if(j == 0)
 +                      {
 +                              edgecollpair.p21 = face2->v1;
 +                              edgecollpair.p22 = face2->v2;
 +                      }
 +                      else if(j == 1)
 +                      {
 +                              edgecollpair.p21 = face2->v2;
 +                              edgecollpair.p22 = face2->v3;
 +                      }
 +                      else if(j == 2)
 +                      {
 +                              if(face2->v4) 
 +                              {
 +                                      edgecollpair.p21 = face2->v3;
 +                                      edgecollpair.p22 = face2->v4;
 +                              }
 +                              else 
 +                              {
 +                                      edgecollpair.p21 = face2->v3;
 +                                      edgecollpair.p22 = face2->v1;
 +                              }
 +                      }
 +                      else if(j == 3)
 +                      {
 +                              if(face2->v4) 
 +                              {
 +                                      edgecollpair.p21 = face2->v4;
 +                                      edgecollpair.p22 = face2->v1;
 +                              }
 +                              else
 +                                      continue;
 +                      }
 +                      else
 +                      {
 +                              edgecollpair.p21 = face2->v3;
 +                              edgecollpair.p22 = face2->v1;
 +                      }
 +                      
 +                      
 +                      if(!cloth_are_edges_adjacent(clmd, coll_clmd, &edgecollpair))
 +                      {
 +                              VECSUB(a, verts1[edgecollpair.p12].xold, verts1[edgecollpair.p11].xold);
 +                              VECSUB(b, verts1[edgecollpair.p12].v, verts1[edgecollpair.p11].v);
 +                              VECSUB(c, verts1[edgecollpair.p21].xold, verts1[edgecollpair.p11].xold);
 +                              VECSUB(d, verts1[edgecollpair.p21].v, verts1[edgecollpair.p11].v);
 +                              VECSUB(e, verts2[edgecollpair.p22].xold, verts1[edgecollpair.p11].xold);
 +                              VECSUB(f, verts2[edgecollpair.p22].v, verts1[edgecollpair.p11].v);
 +                              
 +                              numsolutions = cloth_get_collision_time(a, b, c, d, e, f, solution);
 +                              
 +                              for (k = 0; k < numsolutions; k++) 
 +                              {                                                               
 +                                      if ((solution[k] >= 0.0) && (solution[k] <= 1.0)) 
 +                                      {
 +                                              float out_collisionTime = solution[k];
 +                                              
 +                                              // TODO: check for collisions 
 +                                              
 +                                              // TODO: put into collision list
 +                                              
 +                                              printf("Moving edge found!\n");
 +                                      }
 +                              }
 +                      }
 +              }
++      }       
 +      
 +}
 +
 +void cloth_collision_moving_tris(ClothModifierData *clmd, ClothModifierData *coll_clmd, Tree *tree1, Tree *tree2)
 +{
 +      CollPair collpair;
 +      Cloth *cloth1=NULL, *cloth2=NULL;
 +      MFace *face1=NULL, *face2=NULL;
 +      ClothVertex *verts1=NULL, *verts2=NULL;
 +      double distance = 0;
 +      float epsilon = clmd->coll_parms.epsilon;
 +      unsigned int i = 0, j = 0, k = 0;
 +      int numsolutions = 0;
 +      float a[3], b[3], c[3], d[3], e[3], f[3], solution[3];
 +
 +      for(i = 0; i < 2; i++)
 +      {               
 +              cloth1 = clmd->clothObject;
 +              cloth2 = coll_clmd->clothObject;
 +              
 +              verts1 = cloth1->verts;
 +              verts2 = cloth2->verts;
 +      
 +              face1 = &(cloth1->mfaces[tree1->tri_index]);
 +              face2 = &(cloth2->mfaces[tree2->tri_index]);
 +              
 +              // check all possible pairs of triangles
 +              if(i == 0)
 +              {
 +                      collpair.ap1 = face1->v1;
 +                      collpair.ap2 = face1->v2;
 +                      collpair.ap3 = face1->v3;
 +                      
 +                      collpair.pointsb[0] = face2->v1;
 +                      collpair.pointsb[1] = face2->v2;
 +                      collpair.pointsb[2] = face2->v3;
 +                      collpair.pointsb[3] = face2->v4;
 +              }
 +              
 +              if(i == 1)
 +              {
 +                      if(face1->v4)
 +                      {
 +                              collpair.ap1 = face1->v3;
 +                              collpair.ap2 = face1->v4;
 +                              collpair.ap3 = face1->v1;
 +                              
 +                              collpair.pointsb[0] = face2->v1;
 +                              collpair.pointsb[1] = face2->v2;
 +                              collpair.pointsb[2] = face2->v3;
 +                              collpair.pointsb[3] = face2->v4;
 +                      }
 +                      else
 +                              i++;
 +              }
 +              
 +              // calc SIPcode (?)
 +              
 +              if(i < 2)
 +              {
 +                      VECSUB(a, verts1[collpair.ap2].xold, verts1[collpair.ap1].xold);
 +                      VECSUB(b, verts1[collpair.ap2].v, verts1[collpair.ap1].v);
 +                      VECSUB(c, verts1[collpair.ap3].xold, verts1[collpair.ap1].xold);
 +                      VECSUB(d, verts1[collpair.ap3].v, verts1[collpair.ap1].v);
 +                              
 +                      for(j = 0; j < 4; j++)
 +                      {                                       
 +                              if((j==3) && !(face2->v4))
 +                                      break;
 +                              
 +                              VECSUB(e, verts2[collpair.pointsb[j]].xold, verts1[collpair.ap1].xold);
 +                              VECSUB(f, verts2[collpair.pointsb[j]].v, verts1[collpair.ap1].v);
 +                              
 +                              numsolutions = cloth_get_collision_time(a, b, c, d, e, f, solution);
 +                              
 +                              for (k = 0; k < numsolutions; k++) 
 +                              {                                                               
 +                                      if ((solution[k] >= 0.0) && (solution[k] <= 1.0)) 
 +                                      {
 +                                              float out_collisionTime = solution[k];
 +                                              
 +                                              // TODO: check for collisions 
 +                                              
 +                                              // TODO: put into collision list
 +                                              
 +                                              printf("Moving found!\n");
 +                                      }
 +                              }
 +                              
 +                              // TODO: check borders for collisions
 +                      }
 +                      
 +              }
 +      }
 +}
 +
 +void cloth_collision_moving(ClothModifierData *clmd, ClothModifierData *coll_clmd, Tree *tree1, Tree *tree2)
 +{
 +      // TODO: check for adjacent
 +      cloth_collision_moving_edges(clmd, coll_clmd, tree1, tree2);
 +      
 +      cloth_collision_moving_tris(clmd, coll_clmd, tree1, tree2);
 +      // cloth_collision_moving_tris(coll_clmd, clmd, tree2, tree1);
 +}
 +
 +// move collision objects forward in time and update static bounding boxes
 +void cloth_update_collision_objects(float step)
 +{
 +      Base *base=NULL;
 +      ClothModifierData *coll_clmd=NULL;
 +      Object *coll_ob=NULL;
 +      unsigned int i=0;
 +      
 +      // search all objects for collision object
 +      for (base = G.scene->base.first; base; base = base->next)
 +      {
 +
 +              coll_ob = base->object;
 +              coll_clmd = (ClothModifierData *) modifiers_findByType (coll_ob, eModifierType_Cloth);
 +              if (!coll_clmd)
 +                      continue;
 +
 +              // if collision object go on
 +              if (coll_clmd->sim_parms.flags & CSIMSETT_FLAG_COLLOBJ)
 +              {
 +                      if (coll_clmd->clothObject && coll_clmd->clothObject->tree) 
 +                      {
 +                              Cloth *coll_cloth = coll_clmd->clothObject;
 +                              BVH *coll_bvh = coll_clmd->clothObject->tree;
 +                              unsigned int coll_numverts = coll_cloth->numverts;
 +
 +                              // update position of collision object
 +                              for(i = 0; i < coll_numverts; i++)
 +                              {
 +                                      VECCOPY(coll_cloth->verts[i].txold, coll_cloth->verts[i].tx);
 +
 +                                      VECADDS(coll_cloth->verts[i].tx, coll_cloth->verts[i].xold, coll_cloth->verts[i].v, step);
 +                                      
 +                                      // no dt here because of float rounding errors
 +                                      VECSUB(coll_cloth->verts[i].tv, coll_cloth->verts[i].tx, coll_cloth->verts[i].txold);
 +                              }
 +                              
 +                              // update BVH of collision object
 +                              bvh_update(coll_clmd, coll_bvh, 0); // 0 means STATIC, 1 means MOVING 
 +                      }
 +                      else
 +                              printf ("cloth_bvh_objcollision: found a collision object with clothObject or collData NULL.\n");
 +              }
 +      }
 +}
 +
 +// CLOTH_MAX_THRESHOLD defines how much collision rounds/loops should be taken
 +#define CLOTH_MAX_THRESHOLD 10
 +
 +// cloth - object collisions
 +int cloth_bvh_objcollision(ClothModifierData * clmd, float step, float dt)
 +{
 +      Base *base=NULL;
 +      ClothModifierData *coll_clmd=NULL;
 +      Cloth *cloth=NULL;
 +      Object *coll_ob=NULL;
 +      BVH *cloth_bvh=NULL;
 +      unsigned int i=0, j = 0, numfaces = 0, numverts = 0;
 +      unsigned int result = 0, ic = 0, rounds = 0; // result counts applied collisions; ic is for debug output; 
 +      ClothVertex *verts = NULL;
 +      float tnull[3] = {0,0,0};
 +      int ret = 0;
 +
 +      if ((clmd->sim_parms.flags & CSIMSETT_FLAG_COLLOBJ) || !(((Cloth *)clmd->clothObject)->tree))
 +      {
 +              return 0;
 +      }
 +      cloth = clmd->clothObject;
 +      verts = cloth->verts;
 +      cloth_bvh = (BVH *) cloth->tree;
 +      numfaces = clmd->clothObject->numfaces;
 +      numverts = clmd->clothObject->numverts;
 +      
 +      ////////////////////////////////////////////////////////////
 +      // static collisions
 +      ////////////////////////////////////////////////////////////
 +
 +      // update cloth bvh
 +      bvh_update(clmd, cloth_bvh, 0); // 0 means STATIC, 1 means MOVING (see later in this function)
 +      
 +      // update collision objects
 +      cloth_update_collision_objects(step);
 +      
 +      do
 +      {
 +              result = 0;
 +              ic = 0;
 +              clmd->coll_parms.collision_list = NULL; 
 +              
 +              // check all collision objects
 +              for (base = G.scene->base.first; base; base = base->next)
 +              {
 +                      coll_ob = base->object;
 +                      coll_clmd = (ClothModifierData *) modifiers_findByType (coll_ob, eModifierType_Cloth);
 +                      
 +                      if (!coll_clmd)
 +                              continue;
 +                      
 +                      // if collision object go on
 +                      if (coll_clmd->sim_parms.flags & CSIMSETT_FLAG_COLLOBJ)
 +                      {
 +                              if (coll_clmd->clothObject && coll_clmd->clothObject->tree) 
 +                              {
 +                                      BVH *coll_bvh = coll_clmd->clothObject->tree;
 +                                      
 +                                      bvh_traverse(clmd, coll_clmd, cloth_bvh->root, coll_bvh->root, step, cloth_collision_static);
 +                              }
 +                              else
 +                                      printf ("cloth_bvh_objcollision: found a collision object with clothObject or collData NULL.\n");
 +                      }
 +              }
 +              
 +              // process all collisions (calculate impulses, TODO: also repulses if distance too short)
 +              result = 1;
 +              for(j = 0; j < 50; j++) // 50 is just a value that ensures convergence
 +              {
 +                      result = 0;
 +                      
 +                      // handle all collision objects
 +                      for (base = G.scene->base.first; base; base = base->next)
 +                      {
 +              
 +                              coll_ob = base->object;
 +                              coll_clmd = (ClothModifierData *) modifiers_findByType (coll_ob, eModifierType_Cloth);
 +                              if (!coll_clmd)
 +                                      continue;
 +              
 +                              // if collision object go on
 +                              if (coll_clmd->sim_parms.flags & CSIMSETT_FLAG_COLLOBJ)
 +                              {
 +                                      if (coll_clmd->clothObject) 
 +                                              result += cloth_collision_response_static(clmd, coll_clmd);
 +                                      else
 +                                              printf ("cloth_bvh_objcollision: found a collision object with clothObject or collData NULL.\n");
 +                              }
 +                      }
 +                      
 +                      // apply impulses in parallel
 +                      ic=0;
 +                      for(i = 0; i < numverts; i++)
 +                      {
 +                              // calculate "velocities" (just xnew = xold + v; no dt in v)
 +                              if(verts[i].impulse_count)
 +                              {
 +                                      VECADDMUL(verts[i].tv, verts[i].impulse, 1.0f / verts[i].impulse_count);
 +                                      VECCOPY(verts[i].impulse, tnull);
 +                                      verts[i].impulse_count = 0;
 +                              
 +                                      ic++;
 +                                      ret++;
 +                              }
 +                      }
 +              }
 +              
 +              // free collision list
 +              if(clmd->coll_parms.collision_list)
 +              {
 +                      LinkNode *search = clmd->coll_parms.collision_list;
 +                      while(search)
 +                      {
 +                              CollPair *coll_pair = search->link;
 +                                                      
 +                              MEM_freeN(coll_pair);
 +                              search = search->next;
 +                      }
 +                      BLI_linklist_free(clmd->coll_parms.collision_list,NULL);
 +                      
 +                      clmd->coll_parms.collision_list = NULL;
 +              }
 +              
 +              printf("ic: %d\n", ic);
 +              rounds++;
 +      }
 +      while(result && (CLOTH_MAX_THRESHOLD>rounds));
 +      
 +      printf("\n");
 +                      
 +      ////////////////////////////////////////////////////////////
 +      // update positions
 +      // this is needed for bvh_calc_DOP_hull_moving() [kdop.c]
 +      ////////////////////////////////////////////////////////////
 +      
 +      // verts come from clmd
 +      for(i = 0; i < numverts; i++)
 +      {
 +              VECADD(verts[i].tx, verts[i].txold, verts[i].tv);
 +      }
 +      ////////////////////////////////////////////////////////////
 +
 +      ////////////////////////////////////////////////////////////
 +      // moving collisions
 +      ////////////////////////////////////////////////////////////
 +
 +      
 +      // update cloth bvh
 +      bvh_update(clmd, cloth_bvh, 1);  // 0 means STATIC, 1 means MOVING 
 +      
 +      // update moving bvh for collision object once
 +      for (base = G.scene->base.first; base; base = base->next)
 +      {
 +              
 +              coll_ob = base->object;
 +              coll_clmd = (ClothModifierData *) modifiers_findByType (coll_ob, eModifierType_Cloth);
 +              if (!coll_clmd)
 +                      continue;
 +              
 +              if(!coll_clmd->clothObject)
 +                      continue;
 +              
 +                              // if collision object go on
 +              if (coll_clmd->clothObject && coll_clmd->clothObject->tree) 
 +              {
 +                      BVH *coll_bvh = coll_clmd->clothObject->tree;
 +                      
 +                      bvh_update(coll_clmd, coll_bvh, 1);  // 0 means STATIC, 1 means MOVING  
 +              }
 +      }
 +      
 +      
 +      do
 +      {
 +              result = 0;
 +              ic = 0;
 +              clmd->coll_parms.collision_list = NULL; 
 +              
 +              // check all collision objects
 +              for (base = G.scene->base.first; base; base = base->next)
 +              {
 +                      coll_ob = base->object;
 +                      coll_clmd = (ClothModifierData *) modifiers_findByType (coll_ob, eModifierType_Cloth);
 +                      
 +                      if (!coll_clmd)
 +                              continue;
 +                      
 +                      // if collision object go on
 +                      if (coll_clmd->sim_parms.flags & CSIMSETT_FLAG_COLLOBJ)
 +                      {
 +                              if (coll_clmd->clothObject && coll_clmd->clothObject->tree) 
 +                              {
 +                                      BVH *coll_bvh = coll_clmd->clothObject->tree;
 +                                      
 +                                      bvh_traverse(clmd, coll_clmd, cloth_bvh->root, coll_bvh->root, step, cloth_collision_moving);
 +                              }
 +                              else
 +                                      printf ("cloth_bvh_objcollision: found a collision object with clothObject or collData NULL.\n");
 +                      }
 +              }
 +              /*
 +              // process all collisions (calculate impulses, TODO: also repulses if distance too short)
 +              result = 1;
 +              for(j = 0; j < 50; j++) // 50 is just a value that ensures convergence
 +              {
 +              result = 0;
 +                      
 +                      // handle all collision objects
 +              for (base = G.scene->base.first; base; base = base->next)
 +              {
 +              
 +              coll_ob = base->object;
 +              coll_clmd = (ClothModifierData *) modifiers_findByType (coll_ob, eModifierType_Cloth);
 +                              
 +              if (!coll_clmd)
 +              continue;
 +              
 +                              // if collision object go on
 +              if (coll_clmd->sim_parms.flags & CSIMSETT_FLAG_COLLOBJ)
 +              {
 +              if (coll_clmd->clothObject) 
 +              result += cloth_collision_response_moving_tris(clmd, coll_clmd);
 +              else
 +              printf ("cloth_bvh_objcollision: found a collision object with clothObject or collData NULL.\n");
 +      }
 +      }
 +                      
 +                      // apply impulses in parallel
 +              ic=0;
 +              for(i = 0; i < numverts; i++)
 +              {
 +                              // calculate "velocities" (just xnew = xold + v; no dt in v)
 +              if(verts[i].impulse_count)
 +              {
 +              VECADDMUL(verts[i].tv, verts[i].impulse, 1.0f / verts[i].impulse_count);
 +              VECCOPY(verts[i].impulse, tnull);
 +              verts[i].impulse_count = 0;
 +                              
 +              ic++;
 +              ret++;
 +      }
 +      }
 +      }
 +              */
 +              
 +              // verts come from clmd
 +              for(i = 0; i < numverts; i++)
 +              {
 +                      VECADD(verts[i].tx, verts[i].txold, verts[i].tv);
 +              }
 +              
 +              // update cloth bvh
 +              bvh_update(clmd, cloth_bvh, 1);  // 0 means STATIC, 1 means MOVING 
 +              
 +              
 +              // free collision list
 +              if(clmd->coll_parms.collision_list)
 +              {
 +                      LinkNode *search = clmd->coll_parms.collision_list;
 +                      while(search)
 +                      {
 +                              CollPair *coll_pair = search->link;
 +                                                      
 +                              MEM_freeN(coll_pair);
 +                              search = search->next;
 +                      }
 +                      BLI_linklist_free(clmd->coll_parms.collision_list,NULL);
 +                      
 +                      clmd->coll_parms.collision_list = NULL;
 +              }
 +              
 +              printf("ic: %d\n", ic);
 +              rounds++;
 +      }
 +      while(result && (CLOTH_MAX_THRESHOLD>rounds));
 +      
 +      
 +      ////////////////////////////////////////////////////////////
 +      // update positions + velocities
 +      ////////////////////////////////////////////////////////////
 +      
 +      // verts come from clmd
 +      for(i = 0; i < numverts; i++)
 +      {
 +              VECADD(verts[i].tx, verts[i].txold, verts[i].tv);
 +      }
 +      ////////////////////////////////////////////////////////////
 +
 +      return MIN2(ret, 1);
 +}
index 38e11928c7d951f5f4f841306551e953ab0c5dec,4f33a90daefe654771fefcaa6d47da52f411e58e..c3ba4b9e292f43b725f3aad6a6f0a64633f7efda
@@@ -60,7 -60,6 +60,7 @@@
  #include "DNA_actuator_types.h"
  #include "DNA_brush_types.h"
  #include "DNA_camera_types.h"
 +#include "DNA_cloth_types.h"
  #include "DNA_color_types.h"
  #include "DNA_controller_types.h"
  #include "DNA_constraint_types.h"
  
  #include "BKE_action.h"
  #include "BKE_armature.h"
 +#include "BKE_cloth.h"
  #include "BKE_colortools.h"
  #include "BKE_constraint.h"
  #include "BKE_curve.h"
@@@ -2875,20 -2873,7 +2875,20 @@@ static void direct_link_modifiers(FileD
                        SubsurfModifierData *smd = (SubsurfModifierData*) md;
  
                        smd->emCache = smd->mCache = 0;
 -              } else if (md->type==eModifierType_Hook) {
 +              } 
 +              else if (md->type==eModifierType_Cloth) {
 +                 ClothModifierData    *clmd = (ClothModifierData*) md;
 +
 +                 clmd->clothObject = NULL;
 +                 clmd->sim_parms.cache = NULL;
 +              
 +                 if (clmd->sim_parms.cache) {
 +                         // TODO 
 +                        // clmd->cache = newdataadr (fd, clmd->cache);
 +                        printf ("direct_link_modifiers: read cloth baked_data.\n");
 +                 }
 +              } 
 +              else if (md->type==eModifierType_Hook) {
                        HookModifierData *hmd = (HookModifierData*) md;
  
                        hmd->indexar= newdataadr(fd, hmd->indexar);
@@@ -6516,7 -6501,6 +6516,6 @@@ static void do_versions(FileData *fd, L
        if(main->versionfile <= 244) {
                Scene *sce;
                bScreen *sc;
-               Object *ob;
                Lamp *la;
                World *wrld;
                
                                }
                        }
                }
-               if (main->versionfile != 244 || main->subversionfile < 3) {
-                       for(ob = main->object.first; ob; ob= ob->id.next) {
+               if (main->versionfile != 244 || main->subversionfile < 3) {     
+                       /* constraints recode version patch used to be here. Moved to 245 now... */
+                       
+                       
+                       for(wrld=main->world.first; wrld; wrld= wrld->id.next) {
+                               if (wrld->mode & WO_AMB_OCC)
+                                       wrld->ao_samp_method = WO_AOSAMP_CONSTANT;
+                               else
+                                       wrld->ao_samp_method = WO_AOSAMP_HAMMERSLEY;
+                               
+                               wrld->ao_adapt_thresh = 0.005;
+                       }
+                       
+                       for(la=main->lamp.first; la; la= la->id.next) {
+                               if (la->type == LA_AREA)
+                                       la->ray_samp_method = LA_SAMP_CONSTANT;
+                               else
+                                       la->ray_samp_method = LA_SAMP_HALTON;
+                               
+                               la->adapt_thresh = 0.001;
+                       }
+               }
+       }
+       if(main->versionfile <= 245) {
+               bScreen *sc;
+               Object *ob;
+               Image *ima;
+               Lamp *la;
+               Material *ma;
+               
+               /* unless the file was created 2.44.3 but not 2.45, update the constraints */
+               if (!(main->versionfile==244 && main->subversionfile==3)) {
+                       for (ob = main->object.first; ob; ob= ob->id.next) {
                                ListBase *list;
                                list = &ob->constraints;
                                
-                               /* fix up constraints due to constraint recode changes */
+                               /* fix up constraints due to constraint recode changes (originally at 2.44.3) */
                                if (list) {
                                        bConstraint *curcon;
                                        for (curcon = list->first; curcon; curcon=curcon->next) {
                                
                                /* correctly initialise constinv matrix */
                                Mat4One(ob->constinv);
+                               
                                if (ob->type == OB_ARMATURE) {
                                        if (ob->pose) {
                                                bConstraint *curcon;
                                        }
                                }
                        }
-                       
-                       for(wrld=main->world.first; wrld; wrld= wrld->id.next) {
-                               if (wrld->mode & WO_AMB_OCC)
-                                       wrld->ao_samp_method = WO_AOSAMP_CONSTANT;
-                               else
-                                       wrld->ao_samp_method = WO_AOSAMP_HAMMERSLEY;
-                               
-                               wrld->ao_adapt_thresh = 0.005;
-                       }
-                       
-                       for(la=main->lamp.first; la; la= la->id.next) {
-                               if (la->type == LA_AREA)
-                                       la->ray_samp_method = LA_SAMP_CONSTANT;
-                               else
-                                       la->ray_samp_method = LA_SAMP_HALTON;
-                               
-                               la->adapt_thresh = 0.001;
-                       }
                }
-       }
-       if(main->versionfile <= 245) {
-               bScreen *sc;
-               Image* ima;
-               Lamp *la;
-               Material *ma;
                
                /* fix all versions before 2.45 */
                if (main->versionfile != 245) {
                                sa= sc->areabase.first;
                                while(sa) {
                                        SpaceLink *sl;
+                                       
                                        for (sl= sa->spacedata.first; sl; sl= sl->next) {
                                                if(sl->spacetype==SPACE_IMASEL) {
                                                        SpaceImaSel *simasel= (SpaceImaSel*) sl;
                                                        simasel->flag = 7; /* ??? elubie */
                                                        strcpy (simasel->dir,  U.textudir);     /* TON */
                                                        strcpy (simasel->file, "");
+                                                       
                                                        simasel->returnfunc     =  0;   
                                                        simasel->title[0]       =  0;
                                                }
index 0567cd6fb67ec9ba0efa3727d907fc1139f582b8,da60aaef71fb102e2ff6c4e99365cf60ef0938f9..f73983be4400c2dc19466fcdc49c92b989c28767
  #include "BIF_editfont.h"
  #include "BIF_editkey.h"
  #include "BIF_editmesh.h"
+ #include "BIF_imasel.h"
  #include "BIF_interface.h"
  #include "BIF_meshtools.h"
  #include "BIF_mywindow.h"
@@@ -949,7 -950,7 +950,7 @@@ static uiBlock *modifiers_add_menu(voi
                ModifierTypeInfo *mti = modifierType_getInfo(i);
  
                /* Only allow adding through appropriate other interfaces */
 -              if(ELEM(i, eModifierType_Softbody, eModifierType_Hook)) continue;
 +              if(ELEM3(i, eModifierType_Softbody, eModifierType_Hook, eModifierType_Cloth)) continue;
  
                if((mti->flags&eModifierTypeFlag_AcceptsCVs) ||
                   (ob->type==OB_MESH && (mti->flags&eModifierTypeFlag_AcceptsMesh))) {
@@@ -1600,8 -1601,6 +1601,8 @@@ static void draw_modifier(uiBlock *bloc
                                height += 20;
                } else if (md->type==eModifierType_Softbody) {
                        height = 26;
 +              } else if (md->type==eModifierType_Cloth) {
 +                      height = 26;
                } else if (md->type==eModifierType_Boolean) {
                        height = 48;
                } else if (md->type==eModifierType_Array) {
                        uiBlockBeginAlign(block);
                        but = uiDefBut(block, BUT, B_MODIFIER_RECALC, "Apply",  lx,(cy-=19),60,19, 0, 0, 0, 0, 0, "Apply the current modifier and remove from the stack");
                        uiButSetFunc(but, modifiers_applyModifier, ob, md);
 -                      if (md->type!=eModifierType_Softbody) {
 +                      if ((md->type!=eModifierType_Softbody) && (md->type!=eModifierType_Cloth)) {
                                but = uiDefBut(block, BUT, B_MODIFIER_RECALC, "Copy",   lx,(cy-=19),60,19, 0, 0, 0, 0, 0, "Duplicate the current modifier at the same position in the stack");
                                uiButSetFunc(but, modifiers_copyModifier, ob, md);
                        }
@@@ -2581,6 -2580,7 +2582,7 @@@ void do_fontbuts(unsigned short event
        }
  }
  
+ #ifdef INTERNATIONAL
  static void editing_panel_char_type(Object *ob, Curve *cu)
  {
        uiBlock *block;
        uiDefButI(block, BUT, B_SETUPCHAR, "U", 280, 185, 15, 15, &G.charstart, 0, 0xffff, 0, 0, "Scroll character table up");
        uiDefButI(block, BUT, B_SETDOWNCHAR, "D", 280, 0, 15, 15, &G.charstart, 0, 0xffff, 0, 0, "Scroll character table down");
  }
+ #endif
  
  static void editing_panel_font_type(Object *ob, Curve *cu)
  {
@@@ -3309,9 -3310,6 +3312,9 @@@ void do_latticebuts(unsigned short even
                        if(ob==G.obedit) resizelattice(editLatt, lt->opntsu, lt->opntsv, lt->opntsw, NULL);
                        else resizelattice(ob->data, lt->opntsu, lt->opntsv, lt->opntsw, NULL);
                        ob->softflag |= OB_SB_REDO;
 +                      if(modifiers_isClothEnabled(ob)) {
 +                              cloth_free_modifier(modifiers_isClothEnabled(ob));
 +                      }
                        DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
                        allqueue(REDRAWVIEW3D, 0);
                }
                        lt = ob->data;
                        resizelattice(ob->data, lt->opntsu, lt->opntsv, lt->opntsw, ob);
                        ob->softflag |= OB_SB_REDO;
 +                      if(modifiers_isClothEnabled(ob)) {
 +                              cloth_free_modifier(modifiers_isClothEnabled(ob));
 +                      }
                        DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
                        allqueue(REDRAWVIEW3D, 0);
                }
@@@ -3793,13 -3788,13 +3796,13 @@@ static void editing_panel_armature_bone
                        uiBlockBeginAlign(block);
                        for(a=0; a<8; a++) {
                                short dx= 21;
-                               but= uiDefButBitS(block, TOG, 1<<a, REDRAWVIEW3D, "", -10+a*dx, by-57, dx, 15, &curBone->layer, 0, 0, 0, 0, "Don't draw this layer for group-duplicators");
+                               but= uiDefButBitS(block, TOG, 1<<a, REDRAWVIEW3D, "", -10+a*dx, by-57, dx, 15, &curBone->layer, 0, 0, 0, 0, "Armature layer that bone exists on");
                                uiButSetFunc(but, armature_layer_cb, &curBone->layer, (void *)(1<<a));
                        }
                        uiBlockBeginAlign(block);
                        for(a=8; a<16; a++) {
                                short dx= 21;
-                               but= uiDefButBitS(block, TOG, 1<<a, REDRAWVIEW3D, "", -6+a*dx, by-57, dx, 15, &curBone->layer, 0, 0, 0, 0, "Don't draw this layer for group-duplicators");
+                               but= uiDefButBitS(block, TOG, 1<<a, REDRAWVIEW3D, "", -6+a*dx, by-57, dx, 15, &curBone->layer, 0, 0, 0, 0, "Armature layer that bone exists on");
                                uiButSetFunc(but, armature_layer_cb, &curBone->layer, (void *)(1<<a));
                        }
                        
@@@ -3890,13 -3885,13 +3893,13 @@@ static void editing_panel_pose_bones(Ob
                        uiBlockBeginAlign(block);
                        for(a=0; a<8; a++) {
                                short dx= 21;
-                               but= uiDefButBitS(block, TOG, 1<<a, REDRAWVIEW3D, "", -10+a*dx, by-57, dx, 15, &curBone->layer, 0, 0, 0, 0, "");
+                               but= uiDefButBitS(block, TOG, 1<<a, REDRAWVIEW3D, "", -10+a*dx, by-57, dx, 15, &curBone->layer, 0, 0, 0, 0, "Armature layer that bone exists on");
                                uiButSetFunc(but, armature_layer_cb, &curBone->layer, (void *)(1<<a));
                        }
                        uiBlockBeginAlign(block);
                        for(a=8; a<16; a++) {
                                short dx= 21;
-                               but= uiDefButBitS(block, TOG, 1<<a, REDRAWVIEW3D, "", -6+a*dx, by-57, dx, 15, &curBone->layer, 0, 0, 0, 0, "");
+                               but= uiDefButBitS(block, TOG, 1<<a, REDRAWVIEW3D, "", -6+a*dx, by-57, dx, 15, &curBone->layer, 0, 0, 0, 0, "Armature layer that bone exists on");
                                uiButSetFunc(but, armature_layer_cb, &curBone->layer, (void *)(1<<a));
                        }
                        uiBlockEndAlign(block);
@@@ -5072,7 -5067,11 +5075,11 @@@ void do_fpaintbuts(unsigned short event
                        if(G.buts->menunr==-2) {
                                MTex *mtex= brush->mtex[brush->texact];
                                ID *id= (ID*)((mtex)? mtex->tex: NULL);
-                               activate_databrowse(id, ID_TE, 0, B_BTEXBROWSE, &G.buts->menunr, do_global_buttons);
+                               if(G.qual & LR_CTRLKEY) {
+                                       activate_databrowse_imasel(id, ID_TE, 0, B_BTEXBROWSE, &G.buts->menunr, do_fpaintbuts);
+                               } else {
+                                       activate_databrowse(id, ID_TE, 0, B_BTEXBROWSE, &G.buts->menunr, do_fpaintbuts);
+                               }
                                break;
                        }
                        else if(G.buts->menunr < 0) break;
index 3faf298db0ea73d82d82b27586eaea42ccfe39e6,55b36ce43dbdd5a2d9aa0ab14c807f8f36ffc603..c0925f4eae1bbd37b7d7f771e6e41908a8eb724e
@@@ -86,7 -86,6 +86,7 @@@
  #include "DNA_action_types.h"
  #include "DNA_armature_types.h"
  #include "DNA_camera_types.h"
 +#include "DNA_cloth_types.h"
  #include "DNA_constraint_types.h"
  #include "DNA_curve_types.h"
  #include "DNA_effect_types.h"
  
  #include "BKE_anim.h"
  #include "BKE_armature.h"
 +#include "BKE_cloth.h"
  #include "BKE_constraint.h"
  #include "BKE_curve.h"
  #include "BKE_deform.h"
@@@ -846,7 -844,7 +846,7 @@@ static void draw_constraint (uiBlock *b
                                /* Draw target parameters */
                                uiBlockBeginAlign(block);
                                uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_CONSTRAINT_CHANGETARGET, "OB:", *xco+120, *yco-24, 135, 18, &data->tar, "Target Object"); 
 -                              
 +
                                if (is_armature_target) {
                                        but= uiDefBut(block, TEX, B_CONSTRAINT_CHANGETARGET, "BO:", *xco+120, *yco-42,135,18, &data->subtarget, 0, 24, 0, 0, "Subtarget Bone");
                                        uiButSetCompleteFunc(but, autocomplete_bone, (void *)data->tar);
                                }
                                
                                uiBlockEndAlign(block);
 -                              
 +
                                /* Draw XYZ toggles */
                                uiBlockBeginAlign(block);
                                but=uiDefButBitI(block, TOG, SIZELIKE_X, B_CONSTRAINT_TEST, "X", *xco+((width/2)-48), *yco-64, 32, 18, &data->flag, 0, 24, 0, 0, "Copy X component");
                                uiDefBut(block, ROUNDBOX, B_DIFF, "", *xco-10, *yco-height, width+40,height-1, NULL, 5.0, 0.0, 12, rb_col, ""); 
                                
                                uiDefBut(block, LABEL, B_CONSTRAINT_TEST, "Target:", *xco+65, *yco-24, 50, 18, NULL, 0.0, 0.0, 0.0, 0.0, ""); 
 -                              
 +
                                /* Draw target parameters */
                                uiDefButBitS(block, TOG, CONSTRAINT_IK_ROT, B_CONSTRAINT_TEST, "Rot", *xco, *yco-24,60,19, &data->flag, 0, 0, 0, 0, "Chain follows rotation of target");
                                
@@@ -2152,68 -2150,8 +2152,68 @@@ void do_object_panels(unsigned short ev
        case B_OBJECT_IPOFLAG:
                if(ob->ipo) ob->ipo->showkey= (ob->ipoflag & OB_DRAWKEY)?1:0;
                allqueue(REDRAWVIEW3D, 0);
 +      case B_CLOTH_CLEARCACHEALL:
 +              {
 +                      ClothModifierData *clmd = (ClothModifierData *)modifiers_findByType(ob, eModifierType_Cloth);
 +                      if(clmd)
 +                      {
 +                              CFRA= 1;
 +                              update_for_newframe_muted();
 +                              DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA); 
 +                              cloth_cache_free(clmd, 2); 
 +                              allqueue(REDRAWBUTSOBJECT, 0);
 +                              allqueue(REDRAWVIEW3D, 0);
 +                      }       
 +              }
 +              break;  
 +      case B_CLOTH_CLEARCACHEFRAME:
 +              {
 +                      ClothModifierData *clmd = (ClothModifierData *)modifiers_findByType(ob, eModifierType_Cloth);
 +                      if(clmd)
 +                      {
 +                              cloth_cache_free(clmd, MAX2(2.0,G.scene->r.cfra+1.0));
 +                              allqueue(REDRAWBUTSOBJECT, 0);
 +                      }
 +              }
 +              break;  
 +      case B_CLOTH_CHANGEPREROLL:
 +              {
 +                      ClothModifierData *clmd = (ClothModifierData *)modifiers_findByType(ob, eModifierType_Cloth);
 +                      if(clmd)
 +                      {
 +                              if(clmd->sim_parms.cache)
 +                              {
 +                                      CFRA= 1;
 +                                      update_for_newframe_muted();
 +                                      DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA); 
 +                                      allqueue(REDRAWBUTSOBJECT, 0);
 +                                      allqueue(REDRAWVIEW3D, 0);
 +                              }
 +                      }
 +              }
 +              break;
 +      case B_CLOTH_DEL_VG:
 +              {
 +                      ClothModifierData *clmd = (ClothModifierData *)modifiers_findByType(ob, eModifierType_Cloth);
 +                      if(clmd)
 +                      {
 +                              clmd->sim_parms.vgroup_mass = 0;
 +                              do_object_panels(B_CLOTH_RENEW);
 +                      }
 +                      
 +                      allqueue(REDRAWBUTSOBJECT, 0);
 +              }
 +              break;  
 +      case B_CLOTH_RENEW:
 +              {
 +                      ClothModifierData *clmd = (ClothModifierData *)modifiers_findByType(ob, eModifierType_Cloth);
 +                      if(clmd)
 +                      {
 +                              do_object_panels(B_CLOTH_CLEARCACHEALL);
 +                              cloth_free_modifier (clmd);
 +                      }
 +              }
                break;
 -              
        default:
                if(event>=B_SELEFFECT && event<B_SELEFFECT+MAX_EFFECT) {
                        int a=B_SELEFFECT;
@@@ -2869,6 -2807,13 +2869,13 @@@ static void object_softbodies_II(Objec
        uiBlock *block;
        static int val;
      if(!_can_softbodies_at_all(ob)) return;
+       /*bah that is ugly! creating missing data members in UI code*/
+       if(ob->pd == NULL){
+               ob->pd= MEM_callocN(sizeof(PartDeflect), "PartDeflect");
+               ob->pd->pdef_sbdamp = 0.1f;
+               ob->pd->pdef_sbift  = 0.2f;
+               ob->pd->pdef_sboft  = 0.02f;
+       }
        block= uiNewBlock(&curarea->uiblocks, "object_softbodies_II", UI_EMBOSS, UI_HELV, curarea->win);
        uiNewPanelTabbed("Soft Body", "Physics");
        if(uiNewPanel(curarea, block, "Soft Body Collision", "Physics", 651, 0, 318, 204)==0) return;
                        uiDefButBitS(block, TOG, 1, B_REDR, "Deflection",10,50,150,20, &ob->pd->deflect, 0, 0, 0, 0, "Makes this object visible to softbody objects");
                        if(ob->pd->deflect) {
                                uiDefButF(block, NUM, B_FIELD_CHANGE, "Damping:",       160,50,150,20, &ob->pd->pdef_sbdamp, 0.0, 1.0, 10, 0, "Amount of damping during soft body collision");
-                           uiDefButBitS(block, TOG,OB_SB_COLLFINAL , B_DIFF, "Ev.M.Stack",10,30,150,20, &ob->softflag, 0, 0, 0, 0, "Pick collision object from modifier stack");
+                               uiDefButBitS(block, TOG,OB_SB_COLLFINAL , B_DIFF, "Ev.M.Stack",10,30,150,20, &ob->softflag, 0, 0, 0, 0, "Pick collision object from modifier stack");
                                uiDefButF(block, NUM, B_FIELD_CHANGE, "Inner:", 160,30,150,20, &ob->pd->pdef_sbift, 0.001, 1.0, 10, 0, "Inner face thickness");
                                uiDefButF(block, NUM, B_FIELD_CHANGE, "Outer:", 160,10,150,20, &ob->pd->pdef_sboft, 0.001, 1.0, 10, 0, "Outer face thickness");
                        }
                        uiDefButBitS(block, TOG, 1, B_REDR, "Deflection",10,50,150,20, &ob->pd->deflect, 0, 0, 0, 0, "Makes this object visible to other softbody objects");
                        if(ob->pd->deflect) {
                                uiDefButF(block, NUM, B_DIFF, "Damping:",       160,50,150,20, &ob->pd->pdef_sbdamp, 0.0, 1.0, 10, 0, "Amount of damping during soft body collision");
-                           uiDefButBitS(block, TOG,OB_SB_COLLFINAL , B_DIFF, "Ev.M.Stack",10,30,150,20, &ob->softflag, 0, 0, 0, 0, "Pick collision object from modifier stack");
+                               uiDefButBitS(block, TOG,OB_SB_COLLFINAL , B_DIFF, "Ev.M.Stack",10,30,150,20, &ob->softflag, 0, 0, 0, 0, "Pick collision object from modifier stack");
                                uiDefButF(block, NUM, B_DIFF, "Inner:", 160,30,150,20, &ob->pd->pdef_sbift, 0.001, 1.0, 10, 0, "Inner face thickness");
                                uiDefButF(block, NUM, B_DIFF, "Outer:", 160,10,150,20, &ob->pd->pdef_sboft, 0.001, 1.0, 10, 0, "Outer face thickness");
                        }
@@@ -3068,236 -3013,6 +3075,236 @@@ static void object_softbodies(Object *o
        uiBlockEndAlign(block);
  }
  
 +/* Panel for cloth */
 +static void object_cloth__enabletoggle(void *ob_v, void *arg2)
 +{
 +      Object *ob = ob_v;
 +      ModifierData *md = modifiers_findByType(ob, eModifierType_Cloth);
 +
 +      if (!md) {
 +              md = modifier_new(eModifierType_Cloth);
 +              BLI_addhead(&ob->modifiers, md);
 +      }
 +      else {
 +              BLI_remlink(&ob->modifiers, md);
 +              modifier_free(md);
 +      }
 +
 +      allqueue(REDRAWBUTSEDIT, 0);
 +}
 +
 +static void object_panel_cloth(Object *ob)
 +{
 +      uiBlock *block;
 +      static int val, val2;
 +      uiBut *but;
 +      ClothModifierData *clmd = (ClothModifierData *)modifiers_findByType(ob, eModifierType_Cloth);
 +      block= uiNewBlock(&curarea->uiblocks, "object_panel_cloth", UI_EMBOSS, UI_HELV, curarea->win);
 +      if(uiNewPanel(curarea, block, "Cloth", "Physics", 640, 0, 318, 204)==0) return;
 +
 +      if(ob->id.lib) uiSetButLock(1, "Can't edit library data");
 +      val = ((clmd)?(1):(0));
 +
 +      but = uiDefButI(block, TOG, REDRAWBUTSOBJECT, "Cloth Object",   10,200,130,20, &val, 0, 0, 0, 0, "Sets object to become cloth");
 +      uiButSetFunc(but, object_cloth__enabletoggle, ob, NULL);
 +      uiDefBut(block, LABEL, 0, "",10,10,300,0, NULL, 0.0, 0, 0, 0, ""); /* tell UI we go to 10,10*/
 +      
 +      if(clmd)
 +      {
 +              but = uiDefButBitI(block, TOG, CSIMSETT_FLAG_COLLOBJ, B_EFFECT_DEP, "Collision Object", 170,200,130,20, &clmd->sim_parms.flags, 0, 0, 0, 0, "Sets object to become a cloth collision object");
 +
 +              if (!(clmd->sim_parms.flags & CSIMSETT_FLAG_COLLOBJ))
 +              {
 +                      Cloth *cloth = clmd->clothObject;
 +                      int defCount;
 +                      char *clvg1, *clvg2;
 +                      char clmvg [] = "Mass Vertex Group%t|None%x0|";
 +      
 +                      val2=0;
 +      
 +      //              uiDefButBitI(block, TOG, CSIMSETT_FLAG_ADVANCED, REDRAWBUTSOBJECT, "Advanced",  180,200,130,20, &clmd->sim_parms.flags, 0, 0, 0, 0, "Enable advanced mode");
 +                      
 +                      /* GENERAL STUFF */
 +                      uiClearButLock();
 +                      uiBlockBeginAlign(block);
 +                      uiDefButF(block, NUM, B_CLOTH_RENEW, "StructStiff:",       10,170,150,20, &clmd->sim_parms.structural, 1.0, 10000.0, 100, 0, "Overall stiffness of structure");
 +                      uiDefButF(block, NUM, B_CLOTH_RENEW, "BendStiff:",         160,170,150,20, &clmd->sim_parms.bending, 0.0, 10000.0, 1000, 0, "Wrinkle possibility");
 +                      uiDefButI(block, NUM, B_CLOTH_RENEW, "Steps per Frame:",           10,150,150,20, &clmd->sim_parms.stepsPerFrame, 1.0, 100.0, 5, 0, "Quality of the simulation (higher=better=slower)");
 +                      uiBlockEndAlign(block);
 +                      uiBlockBeginAlign(block);
 +                      uiDefButF(block, NUM, B_CLOTH_RENEW, "Spring Damp:",       160,150,150,20, &clmd->sim_parms.Cdis, 0.0, 10.0, 10, 0, "Spring damping");
 +                      uiDefButF(block, NUM, B_DIFF, "Air Damp:",         10,130,150,20, &clmd->sim_parms.Cvi, 0.0, 10.0, 10, 0, "Apply gravitation to point movement");
 +                      uiBlockEndAlign(block);                 
 +                      
 +                      uiClearButLock();
 +                      
 +                      uiBlockBeginAlign(block);
 +                      uiDefBut(block, LABEL, 0, "Gravity:",  10,100,60,20, NULL, 0.0, 0, 0, 0, "");
 +                      // uiClearButLock();
 +                      
 +                      uiDefButF(block, NUM, B_CLOTH_RENEW, "X:",         70,100,80,20, &clmd->sim_parms.gravity[0], -100.0, 100.0, 10, 0, "Apply gravitation to point movement");
 +                      uiDefButF(block, NUM, B_CLOTH_RENEW, "Y:",         150,100,80,20, &clmd->sim_parms.gravity[1], -100.0, 100.0, 10, 0, "Apply gravitation to point movement");
 +                      uiDefButF(block, NUM, B_CLOTH_RENEW, "Z:",         230,100,80,20, &clmd->sim_parms.gravity[2], -100.0, 100.0, 10, 0, "Apply gravitation to point movement");
 +                      uiBlockEndAlign(block);
 +                      
 +                      /* GOAL STUFF */
 +                      uiBlockBeginAlign(block);
 +                      uiDefButBitI(block, TOG, CSIMSETT_FLAG_GOAL, REDRAWVIEW3D, "Use Goal",  10,70,130,20, &clmd->sim_parms.flags, 0, 0, 0, 0, "Define forces for vertices to stick to animated position");
 +                      if (clmd->sim_parms.flags & CSIMSETT_FLAG_GOAL)
 +                      {
 +                              if(ob->type==OB_MESH) 
 +                              {
 +                                      
 +                                      defCount = sizeof (clmvg);
 +                                      clvg1 = get_vertexgroup_menustr (ob);
 +                                      clvg2 = MEM_callocN (strlen (clvg1) + 1 + defCount, "clothVgMS");
 +                                      if (! clvg2) {
 +                                              printf ("draw_modifier: error allocating memory for cloth vertex group menu string.\n");
 +                                              return;
 +                                      }
 +                                      defCount = BLI_countlist (&ob->defbase);
 +                                      if (defCount == 0) 
 +                                      {
 +                                              clmd->sim_parms.vgroup_mass = 0;
 +                                      }
 +                                      sprintf (clvg2, "%s%s", clmvg, clvg1);
 +                                      
 +                                      uiDefButS(block, MENU, B_CLOTH_RENEW, clvg2,    140,70,20,20, &clmd->sim_parms.vgroup_mass, 0, defCount, 0, 0, "Browses available vertex groups");      
 +                                      MEM_freeN (clvg1);
 +                                      MEM_freeN (clvg2);
 +                                      
 +                                      if(clmd->sim_parms.vgroup_mass) 
 +                                      {
 +                                              bDeformGroup *defGroup = BLI_findlink(&ob->defbase, clmd->sim_parms.vgroup_mass-1);
 +                                              if(defGroup)
 +                                                      uiDefBut(block, BUT, B_DIFF, defGroup->name,    160,70,130,20, NULL, 0.0, 0.0, 0, 0, "Name of current vertex group");
 +                                              else
 +                                                      uiDefBut(block, BUT, B_DIFF, "(no group)",      160,70,130,20, NULL, 0.0, 0.0, 0, 0, "Vertex Group doesn't exist anymore");
 +                                              
 +                                              uiDefIconBut(block, BUT, B_CLOTH_DEL_VG, ICON_X, 290,70,20,20, 0, 0, 0, 0, 0, "Disable use of vertex group");
 +                                              
 +                                      }
 +                                      else
 +                                              uiDefButF(block, NUM, B_CLOTH_RENEW, "Goal:",   160,70,150,20, &clmd->sim_parms.defgoal, 0.0, 1.0, 10, 0, "Default Goal (vertex target position) value, when no Vertex Group used");
 +                              
 +                              }
 +                              else 
 +                              {
 +                                      uiDefButS(block, TOG, B_CLOTH_RENEW, "W",                       140,70,20,20, &clmd->sim_parms.vgroup_mass, 0, 1, 0, 0, "Use control point weight values");
 +                                      uiDefButF(block, NUM, B_CLOTH_RENEW, "Goal:",   160,70,150,20, &clmd->sim_parms.defgoal, 0.0, 1.0, 10, 0, "Default Goal (vertex target position) value, when no Vertex Group used");
 +                              }
 +                              
 +                              uiDefButF(block, NUM, B_CLOTH_RENEW, "G Stiff:",        10,50,150,20, &clmd->sim_parms.goalspring, 0.0, 500.0, 10, 0, "Goal (vertex target position) spring stiffness");
 +                              uiDefButF(block, NUM, B_CLOTH_RENEW, "G Damp:", 160,50,150,20, &clmd->sim_parms.goalfrict  , 0.0, 50.0, 10, 0, "Goal (vertex target position) friction");
 +                              uiDefButF(block, NUM, B_CLOTH_RENEW, "G Min:",          10,30,150,20, &clmd->sim_parms.mingoal, 0.0, 1.0, 10, 0, "Goal minimum, vertex group weights are scaled to match this range");
 +                              uiDefButF(block, NUM, B_CLOTH_RENEW, "G Max:",          160,30,150,20, &clmd->sim_parms.maxgoal, 0.0, 1.0, 10, 0, "Goal maximum, vertex group weights are scaled to match this range");
 +                      }
 +                      uiBlockEndAlign(block); 
 +                      
 +                      /*
 +                      // no tearing supported anymore since modifier stack restrictions 
 +                      uiBlockBeginAlign(block);
 +                      uiDefButBitI(block, TOG, CSIMSETT_FLAG_TEARING_ENABLED, B_EFFECT_DEP, "Tearing",        10,0,150,20, &clmd->sim_parms.flags, 0, 0, 0, 0, "Sets object to become a cloth collision object");
 +                      
 +                      if (clmd->sim_parms.flags & CSIMSETT_FLAG_TEARING_ENABLED)
 +                      {
 +                              uiDefButI(block, NUM, B_DIFF, "Max extent:",       160,0,150,20, &clmd->sim_parms.maxspringlen, 1.0, 1000.0, 10, 0, "Maximum extension before spring gets cut");
 +                      }
 +                      
 +                      uiBlockEndAlign(block); 
 +                      */
 +              }
 +      }
 +}
 +
 +
 +static void object_panel_cloth_II(Object *ob)
 +{
 +      uiBlock *block;
 +      static int val;
 +      uiBut *but;
 +      ClothModifierData *clmd = NULL;
 +      
 +      clmd = (ClothModifierData *)modifiers_findByType(ob, eModifierType_Cloth);
 +      if(clmd)
 +      {
 +              if (!(clmd->sim_parms.flags & CSIMSETT_FLAG_COLLOBJ))
 +              {
 +                      Cloth *cloth = clmd->clothObject;
 +                      char str[128];
 +                      
 +                      block= uiNewBlock(&curarea->uiblocks, "object_panel_cloth_II", UI_EMBOSS, UI_HELV, curarea->win);
 +                      uiNewPanelTabbed("Cloth", "Physics");
 +                      if(uiNewPanel(curarea, block, "Cloth Cache", "Physics", 651, 0, 318, 204)==0) return;
 +              
 +                      uiSetButLock(object_data_is_libdata(ob), ERROR_LIBDATA_MESSAGE);
 +                      
 +                      uiDefButI(block, NUM, B_DIFF, "First Frame:",           10,160,150,20, &clmd->sim_parms.firstframe, 0, MAXFRAME, 1, 0, "Frame on which the simulation starts");
 +                      uiDefButI(block, NUM, B_DIFF, "Last Frame:",            160,160,150,20, &clmd->sim_parms.lastframe, 0, MAXFRAME, 10, 0, "Frame on which the simulation stops");
 +
 +                      if(clmd->sim_parms.cache)
 +                      {
 +                              int length = BLI_linklist_length(clmd->sim_parms.cache);
 +                              
 +                              /* correct spelling if only 1 frame cacheed --> only gimmick  */
 +                              if(length-clmd->sim_parms.preroll>1)
 +                                      sprintf (str, "Frame 1 - %d cached. [%d in preroll, %d in total]", length-clmd->sim_parms.preroll, clmd->sim_parms.preroll, length);
 +                              else
 +                                      sprintf (str, "Frame %d cached. [%d in preroll, %d in total]", length-clmd->sim_parms.preroll, clmd->sim_parms.preroll, length);
 +                              
 +                              uiDefBut(block, LABEL, 0, str,  10,140,290,20, NULL, 0.0, 0, 0, 0, "");
 +                              uiDefBut(block, LABEL, 0, "Clear cache:",  10,120,290,20, NULL, 0.0, 0, 0, 0, "");
 +                              uiBlockBeginAlign (block);
 +                              uiDefBut(block, BUT, B_CLOTH_CLEARCACHEALL, "All", 10, 100,145,20, NULL, 0.0, 0.0, 0, 0, "Free cloth cache without preroll");
 +                              uiDefBut(block, BUT, B_CLOTH_CLEARCACHEFRAME, "From next frame", 155, 100,145,20, NULL, 0.0, 0.0, 0, 0, "Free cloth cache");    
 +                              if(length>1) // B_CLOTH_CHANGEPREROLL
 +                                      uiDefButI(block, NUM, B_CLOTH_CHANGEPREROLL, "Preroll:", 10,80,145,20, &clmd->sim_parms.preroll, 0, length-1, 1, 0, "Simulation starts on this frame"); 
 +                              else
 +                                      uiDefBut(block, LABEL, 0, " ",  10,80,145,20, NULL, 0.0, 0, 0, 0, "");
 +                      }
 +                      else
 +                      {
 +                              uiDefBut(block, LABEL, 0, "No frames cached.",  10,120,290,20, NULL, 0.0, 0, 0, 0, "");
 +                      }
 +                      uiDefButBitI(block, TOG, CSIMSETT_FLAG_CCACHE_PROTECT, REDRAWVIEW3D, "Protect Cache",   10,50,145,20, &clmd->sim_parms.flags, 0, 0, 0, 0, "Protect cache from automatic freeing when scene changed");
 +                      uiBlockEndAlign(block);
 +              }
 +      }
 +      // uiBlockEndAlign(block);
 +}
 +
 +static void object_panel_cloth_III(Object *ob)
 +{
 +      uiBlock *block;
 +      static int val;
 +      uiBut *but;
 +      ClothModifierData *clmd = NULL;
 +      
 +      clmd = (ClothModifierData *)modifiers_findByType(ob, eModifierType_Cloth);
 +      if(clmd)
 +      {
 +              if (!(clmd->sim_parms.flags & CSIMSETT_FLAG_COLLOBJ))
 +              {
 +                      Cloth *cloth = clmd->clothObject;
 +                      char str[128];
 +                      
 +                      block= uiNewBlock(&curarea->uiblocks, "object_panel_cloth_III", UI_EMBOSS, UI_HELV, curarea->win);
 +                      uiNewPanelTabbed("Cloth", "Physics");
 +                      if(uiNewPanel(curarea, block, "Cloth Collisions", "Physics", 651, 0, 318, 204)==0) return;
 +              
 +                      uiSetButLock(object_data_is_libdata(ob), ERROR_LIBDATA_MESSAGE);
 +                      
 +                      uiBlockBeginAlign(block);
 +                      // uiDefBut(block, LABEL, 0, "",10,10,300,20, NULL, 0.0, 0, 0, 0, ""); /* tell UI we go to 10,10*/
 +                      uiDefButF(block, NUM, B_CLOTH_RENEW, "Min Distance:",      10,10,150,20, &clmd->coll_parms.epsilon, 0.001f, 1.0, 0.01f, 0, "Minimum distance between collision objects before collision response takes in");
 +                      uiDefBut(block, LABEL, 0, "",160,10,150,20, NULL, 0.0, 0, 0, 0, "");
 +                      uiBlockEndAlign(block);
 +              }
 +      }
 +      // uiBlockEndAlign(block);
 +}
 +
 +
  static void object_panel_particles_motion(Object *ob)
  {
        uiBlock *block;
@@@ -3801,9 -3516,6 +3808,9 @@@ void physics_panels(
                object_panel_particles_motion(ob);
                object_softbodies(ob);
                object_softbodies_II(ob);
 +              object_panel_cloth(ob);
 +              object_panel_cloth_II(ob);
 +              object_panel_cloth_III(ob);
                object_panel_fluidsim(ob);
        }
  }