Cleanup: Remove more #if 0 blocks
[blender.git] / source / blender / blenkernel / intern / softbody.c
index 3ab55b3705afd7a7e70888a5cbe63cef36aa2c62..e4ea839770a6fe4dafb18feb8600318dda0e528e 100644 (file)
  */
 
 
  */
 
 
-/*
-******
-variables on the UI for now
-
-       float mediafrict;  friction to env
-       float nodemass;   softbody mass of *vertex*
-       float grav;        softbody amount of gravitaion to apply
-
-       float goalspring;  softbody goal springs
-       float goalfrict;   softbody goal springs friction
-       float mingoal;     quick limits for goal
-       float maxgoal;
-
-       float inspring;   softbody inner springs
-       float infrict;     softbody inner springs friction
-
-*****
-*/
+/**
+ * variables on the UI for now
+ * <pre>
+ * float mediafrict;  friction to env
+ * float nodemass;       softbody mass of *vertex*
+ * float grav;        softbody amount of gravitaion to apply
+ *
+ * float goalspring;  softbody goal springs
+ * float goalfrict;   softbody goal springs friction
+ * float mingoal;     quick limits for goal
+ * float maxgoal;
+ *
+ * float inspring;       softbody inner springs
+ * float infrict;     softbody inner springs friction
+ * </pre>
+ */
 
 
 #include <math.h>
 
 
 #include <math.h>
@@ -118,7 +116,7 @@ typedef struct ReferenceVert {
 
 typedef struct ReferenceState {
        float com[3]; /* center of mass*/
 
 typedef struct ReferenceState {
        float com[3]; /* center of mass*/
-       ReferenceVert *ivert; /* list of intial values */
+       ReferenceVert *ivert; /* list of initial values */
 } ReferenceState;
 
 
 } ReferenceState;
 
 
@@ -219,7 +217,7 @@ static float sb_time_scale(Object *ob)
  * will cause unwanted responses of the softbody system (which does inter frame calculations )
  * so first 'cure' would be: interpolate linear in time ..
  * Q: why do i write this?
  * will cause unwanted responses of the softbody system (which does inter frame calculations )
  * so first 'cure' would be: interpolate linear in time ..
  * Q: why do i write this?
- * A: because it happend once, that some eger coder 'streamlined' code to fail.
+ * A: because it happened once, that some eger coder 'streamlined' code to fail.
  * We DO linear interpolation for goals .. and i think we should do on animated properties as well
  */
 
  * We DO linear interpolation for goals .. and i think we should do on animated properties as well
  */
 
@@ -256,16 +254,16 @@ static float _final_mass(Object *ob, BodyPoint *bp)
 
 /*+++ collider caching and dicing +++*/
 
 
 /*+++ collider caching and dicing +++*/
 
-/********************
-for each target object/face the axis aligned bounding box (AABB) is stored
-faces parallel to global axes
-so only simple "value" in [min, max] ckecks are used
-float operations still
-*/
+/*
+ * for each target object/face the axis aligned bounding box (AABB) is stored
+ * faces parallel to global axes
+ * so only simple "value" in [min, max] ckecks are used
+ * float operations still
+ */
 
 /* just an ID here to reduce the prob for killing objects
 
 /* just an ID here to reduce the prob for killing objects
-** ob->sumohandle points to we should not kill :)
-*/
+ * ob->sumohandle points to we should not kill :)
+ */
 static const int CCD_SAVETY = 190561;
 
 typedef struct ccdf_minmax {
 static const int CCD_SAVETY = 190561;
 
 typedef struct ccdf_minmax {
@@ -732,8 +730,8 @@ static void add_bp_springlist(BodyPoint *bp, int springID)
 }
 
 /* do this once when sb is build
 }
 
 /* do this once when sb is build
-it is O(N^2) so scanning for springs every iteration is too expensive
-*/
+ * it is O(N^2) so scanning for springs every iteration is too expensive
+ */
 static void build_bps_springlist(Object *ob)
 {
        SoftBody *sb= ob->soft; /* is supposed to be there */
 static void build_bps_springlist(Object *ob)
 {
        SoftBody *sb= ob->soft; /* is supposed to be there */
@@ -925,29 +923,29 @@ static void free_softbody_intern(SoftBody *sb)
 /* ************ dynamics ********** */
 
 /* the most general (micro physics correct) way to do collision
 /* ************ dynamics ********** */
 
 /* the most general (micro physics correct) way to do collision
-** (only needs the current particle position)
-**
-** it actually checks if the particle intrudes a short range force field generated
-** by the faces of the target object and returns a force to drive the particel out
-** the strenght of the field grows exponetially if the particle is on the 'wrong' side of the face
-** 'wrong' side : projection to the face normal is negative (all referred to a vertex in the face)
-**
-** flaw of this: 'fast' particles as well as 'fast' colliding faces
-** give a 'tunnel' effect such that the particle passes through the force field
-** without ever 'seeing' it
-** this is fully compliant to heisenberg: h >= fuzzy(location) * fuzzy(time)
-** besides our h is way larger than in QM because forces propagate way slower here
-** we have to deal with fuzzy(time) in the range of 1/25 seconds (typical frame rate)
-** yup collision targets are not known here any better
-** and 1/25 second is looong compared to real collision events
-** Q: why not use 'simple' collision here like bouncing back a particle
-**   --> reverting is velocity on the face normal
-** A: because our particles are not alone here
-**    and need to tell their neighbors exactly what happens via spring forces
-** unless sbObjectStep( .. ) is called on sub frame timing level
-** BTW that also questions the use of a 'implicit' solvers on softbodies
-** since that would only valid for 'slow' moving collision targets and dito particles
-*/
+ * (only needs the current particle position)
+ *
+ * it actually checks if the particle intrudes a short range force field generated
+ * by the faces of the target object and returns a force to drive the particel out
+ * the strength of the field grows exponetially if the particle is on the 'wrong' side of the face
+ * 'wrong' side : projection to the face normal is negative (all referred to a vertex in the face)
+ *
+ * flaw of this: 'fast' particles as well as 'fast' colliding faces
+ * give a 'tunnel' effect such that the particle passes through the force field
+ * without ever 'seeing' it
+ * this is fully compliant to heisenberg: h >= fuzzy(location) * fuzzy(time)
+ * besides our h is way larger than in QM because forces propagate way slower here
+ * we have to deal with fuzzy(time) in the range of 1/25 seconds (typical frame rate)
+ * yup collision targets are not known here any better
+ * and 1/25 second is looong compared to real collision events
+ * Q: why not use 'simple' collision here like bouncing back a particle
+ *   --> reverting is velocity on the face normal
+ * A: because our particles are not alone here
+ *    and need to tell their neighbors exactly what happens via spring forces
+ * unless sbObjectStep( .. ) is called on sub frame timing level
+ * BTW that also questions the use of a 'implicit' solvers on softbodies
+ * since that would only valid for 'slow' moving collision targets and dito particles
+ */
 
 /* +++ dependency information functions*/
 
 
 /* +++ dependency information functions*/
 
@@ -966,7 +964,7 @@ static int query_external_colliders(Depsgraph *depsgraph, Collection *collection
 
 
 /* +++ the aabb "force" section*/
 
 
 /* +++ the aabb "force" section*/
-static int sb_detect_aabb_collisionCached(float UNUSED(force[3]), unsigned int UNUSED(par_layer), struct Object *vertexowner, float UNUSED(time))
+static int sb_detect_aabb_collisionCached(float UNUSED(force[3]), struct Object *vertexowner, float UNUSED(time))
 {
        Object *ob;
        SoftBody *sb=vertexowner->soft;
 {
        Object *ob;
        SoftBody *sb=vertexowner->soft;
@@ -974,9 +972,6 @@ static int sb_detect_aabb_collisionCached(float UNUSED(force[3]), unsigned int U
        GHashIterator *ihash;
        float  aabbmin[3], aabbmax[3];
        int deflected=0;
        GHashIterator *ihash;
        float  aabbmin[3], aabbmax[3];
        int deflected=0;
-#if 0
-       int a;
-#endif
 
        if ((sb == NULL) || (sb->scratch ==NULL)) return 0;
        copy_v3_v3(aabbmin, sb->scratch->aabbmin);
 
        if ((sb == NULL) || (sb->scratch ==NULL)) return 0;
        copy_v3_v3(aabbmin, sb->scratch->aabbmin);
@@ -1027,7 +1022,7 @@ static int sb_detect_aabb_collisionCached(float UNUSED(force[3]), unsigned int U
 
 /* +++ the face external section*/
 static int sb_detect_face_pointCached(float face_v1[3], float face_v2[3], float face_v3[3], float *damp,
 
 /* +++ the face external section*/
 static int sb_detect_face_pointCached(float face_v1[3], float face_v2[3], float face_v3[3], float *damp,
-                                      float force[3], unsigned int UNUSED(par_layer), struct Object *vertexowner, float time)
+                                      float force[3], struct Object *vertexowner, float time)
 {
        Object *ob;
        GHash *hash;
 {
        Object *ob;
        GHash *hash;
@@ -1128,7 +1123,7 @@ static int sb_detect_face_pointCached(float face_v1[3], float face_v2[3], float
 
 
 static int sb_detect_face_collisionCached(float face_v1[3], float face_v2[3], float face_v3[3], float *damp,
 
 
 static int sb_detect_face_collisionCached(float face_v1[3], float face_v2[3], float face_v3[3], float *damp,
-                                          float force[3], unsigned int UNUSED(par_layer), struct Object *vertexowner, float time)
+                                          float force[3], struct Object *vertexowner, float time)
 {
        Object *ob;
        GHash *hash;
 {
        Object *ob;
        GHash *hash;
@@ -1265,7 +1260,7 @@ static void scan_for_ext_face_forces(Object *ob, float timenow)
                        zero_v3(feedback);
                        if (sb_detect_face_collisionCached(
                                sb->bpoint[bf->v1].pos, sb->bpoint[bf->v2].pos, sb->bpoint[bf->v3].pos,
                        zero_v3(feedback);
                        if (sb_detect_face_collisionCached(
                                sb->bpoint[bf->v1].pos, sb->bpoint[bf->v2].pos, sb->bpoint[bf->v3].pos,
-                               &damp, feedback, ob->lay, ob, timenow))
+                               &damp, feedback, ob, timenow))
                        {
                                madd_v3_v3fl(sb->bpoint[bf->v1].force, feedback, tune);
                                madd_v3_v3fl(sb->bpoint[bf->v2].force, feedback, tune);
                        {
                                madd_v3_v3fl(sb->bpoint[bf->v1].force, feedback, tune);
                                madd_v3_v3fl(sb->bpoint[bf->v2].force, feedback, tune);
@@ -1283,7 +1278,7 @@ static void scan_for_ext_face_forces(Object *ob, float timenow)
                                zero_v3(feedback);
                                if (sb_detect_face_pointCached(
                                        sb->bpoint[bf->v1].pos, sb->bpoint[bf->v2].pos, sb->bpoint[bf->v3].pos,
                                zero_v3(feedback);
                                if (sb_detect_face_pointCached(
                                        sb->bpoint[bf->v1].pos, sb->bpoint[bf->v2].pos, sb->bpoint[bf->v3].pos,
-                                       &damp,  feedback, ob->lay, ob, timenow))
+                                       &damp,  feedback, ob, timenow))
                                {
                                        madd_v3_v3fl(sb->bpoint[bf->v1].force, feedback, tune);
                                        madd_v3_v3fl(sb->bpoint[bf->v2].force, feedback, tune);
                                {
                                        madd_v3_v3fl(sb->bpoint[bf->v1].force, feedback, tune);
                                        madd_v3_v3fl(sb->bpoint[bf->v2].force, feedback, tune);
@@ -1312,7 +1307,7 @@ static void scan_for_ext_face_forces(Object *ob, float timenow)
 /* +++ the spring external section*/
 
 static int sb_detect_edge_collisionCached(float edge_v1[3], float edge_v2[3], float *damp,
 /* +++ the spring external section*/
 
 static int sb_detect_edge_collisionCached(float edge_v1[3], float edge_v2[3], float *damp,
-                                                                  float force[3], unsigned int UNUSED(par_layer), struct Object *vertexowner, float time)
+                                                                  float force[3], struct Object *vertexowner, float time)
 {
        Object *ob;
        GHash *hash;
 {
        Object *ob;
        GHash *hash;
@@ -1449,7 +1444,7 @@ static void _scan_for_ext_spring_forces(Scene *scene, Object *ob, float timenow,
                                /* +++ springs colliding */
                                if (ob->softflag & OB_SB_EDGECOLL) {
                                        if ( sb_detect_edge_collisionCached (sb->bpoint[bs->v1].pos, sb->bpoint[bs->v2].pos,
                                /* +++ springs colliding */
                                if (ob->softflag & OB_SB_EDGECOLL) {
                                        if ( sb_detect_edge_collisionCached (sb->bpoint[bs->v1].pos, sb->bpoint[bs->v2].pos,
-                                               &damp, feedback, ob->lay, ob, timenow)) {
+                                               &damp, feedback, ob, timenow)) {
                                                        add_v3_v3(bs->ext_force, feedback);
                                                        bs->flag |= BSF_INTERSECT;
                                                        //bs->cf=damp;
                                                        add_v3_v3(bs->ext_force, feedback);
                                                        bs->flag |= BSF_INTERSECT;
                                                        //bs->cf=damp;
@@ -1608,7 +1603,7 @@ static int choose_winner(float*w, float* pos, float*a, float*b, float*c, float*c
 
 static int sb_detect_vertex_collisionCached(
         float opco[3], float facenormal[3], float *damp,
 
 static int sb_detect_vertex_collisionCached(
         float opco[3], float facenormal[3], float *damp,
-        float force[3], unsigned int UNUSED(par_layer), struct Object *vertexowner,
+        float force[3], struct Object *vertexowner,
         float time, float vel[3], float *intrusion)
 {
        Object *ob= NULL;
         float time, float vel[3], float *intrusion)
 {
        Object *ob= NULL;
@@ -1704,11 +1699,11 @@ static int sb_detect_vertex_collisionCached(
 
                                                if (mprevvert) {
                                                        /* grab the average speed of the collider vertices
 
                                                if (mprevvert) {
                                                        /* grab the average speed of the collider vertices
-                                                       before we spoil nvX
-                                                       humm could be done once a SB steps but then we' need to store that too
-                                                       since the AABB reduced propabitlty to get here drasticallly
-                                                       it might be a nice tradeof CPU <--> memory
-                                                       */
+                                                        * before we spoil nvX
+                                                        * humm could be done once a SB steps but then we' need to store that too
+                                                        * since the AABB reduced propabitlty to get here drasticallly
+                                                        * it might be a nice tradeof CPU <--> memory
+                                                        */
                                                        sub_v3_v3v3(vv1, nv1, mprevvert[vt->tri[0]].co);
                                                        sub_v3_v3v3(vv2, nv2, mprevvert[vt->tri[1]].co);
                                                        sub_v3_v3v3(vv3, nv3, mprevvert[vt->tri[2]].co);
                                                        sub_v3_v3v3(vv1, nv1, mprevvert[vt->tri[0]].co);
                                                        sub_v3_v3v3(vv2, nv2, mprevvert[vt->tri[1]].co);
                                                        sub_v3_v3v3(vv3, nv3, mprevvert[vt->tri[2]].co);
@@ -1804,48 +1799,11 @@ static int sb_deflect_face(Object *ob, float *actpos, float *facenormal, float *
        float s_actpos[3];
        int deflected;
        copy_v3_v3(s_actpos, actpos);
        float s_actpos[3];
        int deflected;
        copy_v3_v3(s_actpos, actpos);
-       deflected= sb_detect_vertex_collisionCached(s_actpos, facenormal, cf, force, ob->lay, ob, time, vel, intrusion);
-       //deflected= sb_detect_vertex_collisionCachedEx(s_actpos, facenormal, cf, force, ob->lay, ob, time, vel, intrusion);
+       deflected= sb_detect_vertex_collisionCached(s_actpos, facenormal, cf, force, ob, time, vel, intrusion);
+       //deflected= sb_detect_vertex_collisionCachedEx(s_actpos, facenormal, cf, force, ob, time, vel, intrusion);
        return(deflected);
 }
 
        return(deflected);
 }
 
-/* hiding this for now .. but the jacobian may pop up on other tasks .. so i'd like to keep it
-static void dfdx_spring(int ia, int ic, int op, float dir[3], float L, float len, float factor)
-{
-       float m, delta_ij;
-       int i, j;
-       if (L < len) {
-               for (i=0;i<3;i++) {
-                       for (j=0;j<3;j++) {
-                               delta_ij = (i==j ? (1.0f): (0.0f));
-                               m=factor*(dir[i]*dir[j] + (1-L/len)*(delta_ij - dir[i]*dir[j]));
-                               EIG_linear_solver_matrix_add(ia+i, op+ic+j, m);
-                       }
-               }
-       }
-       else {
-               for (i=0;i<3;i++) {
-                       for (j=0;j<3;j++) {
-                               m=factor*dir[i]*dir[j];
-                               EIG_linear_solver_matrix_add(ia+i, op+ic+j, m);
-                       }
-               }
-       }
-}
-
-
-static void dfdx_goal(int ia, int ic, int op, float factor)
-{
-       int i;
-       for (i=0;i<3;i++) EIG_linear_solver_matrix_add(ia+i, op+ic+i, factor);
-}
-
-static void dfdv_goal(int ia, int ic, float factor)
-{
-       int i;
-       for (i=0;i<3;i++) EIG_linear_solver_matrix_add(ia+i, ic+i, factor);
-}
-*/
 static void sb_spring_force(Object *ob, int bpi, BodySpring *bs, float iks, float UNUSED(forcetime))
 {
        SoftBody *sb= ob->soft; /* is supposed to be there */
 static void sb_spring_force(Object *ob, int bpi, BodySpring *bs, float iks, float UNUSED(forcetime))
 {
        SoftBody *sb= ob->soft; /* is supposed to be there */
@@ -1853,25 +1811,15 @@ static void sb_spring_force(Object *ob, int bpi, BodySpring *bs, float iks, floa
 
        float dir[3], dvel[3];
        float distance, forcefactor, kd, absvel, projvel, kw;
 
        float dir[3], dvel[3];
        float distance, forcefactor, kd, absvel, projvel, kw;
-#if 0  /* UNUSED */
-       int ia, ic;
-#endif
+
        /* prepare depending on which side of the spring we are on */
        if (bpi == bs->v1) {
                bp1 = &sb->bpoint[bs->v1];
                bp2 = &sb->bpoint[bs->v2];
        /* prepare depending on which side of the spring we are on */
        if (bpi == bs->v1) {
                bp1 = &sb->bpoint[bs->v1];
                bp2 = &sb->bpoint[bs->v2];
-#if 0  /* UNUSED */
-               ia =3*bs->v1;
-               ic =3*bs->v2;
-#endif
        }
        else if (bpi == bs->v2) {
                bp1 = &sb->bpoint[bs->v2];
                bp2 = &sb->bpoint[bs->v1];
        }
        else if (bpi == bs->v2) {
                bp1 = &sb->bpoint[bs->v2];
                bp2 = &sb->bpoint[bs->v1];
-#if 0  /* UNUSED */
-               ia =3*bs->v2;
-               ic =3*bs->v1;
-#endif
        }
        else {
                /* TODO make this debug option */
        }
        else {
                /* TODO make this debug option */
@@ -1934,7 +1882,7 @@ static int _softbody_calc_forces_slice_in_a_thread(Scene *scene, Object *ob, flo
        SoftBody *sb= ob->soft; /* is supposed to be there */
        BodyPoint  *bp;
 
        SoftBody *sb= ob->soft; /* is supposed to be there */
        BodyPoint  *bp;
 
-       /* intitialize */
+       /* initialize */
        if (sb) {
                /* check conditions for various options */
                /* +++ could be done on object level to squeeze out the last bits of it */
        if (sb) {
                /* check conditions for various options */
                /* +++ could be done on object level to squeeze out the last bits of it */
@@ -1976,7 +1924,7 @@ static int _softbody_calc_forces_slice_in_a_thread(Scene *scene, Object *ob, flo
                        for (c=sb->totpoint, obp= sb->bpoint; c>0; c--, obp++) {
                                compare = (obp->colball + bp->colball);
                                sub_v3_v3v3(def, bp->pos, obp->pos);
                        for (c=sb->totpoint, obp= sb->bpoint; c>0; c--, obp++) {
                                compare = (obp->colball + bp->colball);
                                sub_v3_v3v3(def, bp->pos, obp->pos);
-                               /* rather check the AABBoxes before ever calulating the real distance */
+                               /* rather check the AABBoxes before ever calculating the real distance */
                                /* mathematically it is completely nuts, but performance is pretty much (3) times faster */
                                if ((ABS(def[0]) > compare) || (ABS(def[1]) > compare) || (ABS(def[2]) > compare)) continue;
                                distance = normalize_v3(def);
                                /* mathematically it is completely nuts, but performance is pretty much (3) times faster */
                                if ((ABS(def[0]) > compare) || (ABS(def[1]) > compare) || (ABS(def[2]) > compare)) continue;
                                distance = normalize_v3(def);
@@ -2018,7 +1966,7 @@ static int _softbody_calc_forces_slice_in_a_thread(Scene *scene, Object *ob, flo
                                bp->force[1]+= -ks*(auxvect[1]);
                                bp->force[2]+= -ks*(auxvect[2]);
 
                                bp->force[1]+= -ks*(auxvect[1]);
                                bp->force[2]+= -ks*(auxvect[2]);
 
-                               /* calulate damping forces generated by goals*/
+                               /* calculate damping forces generated by goals*/
                                sub_v3_v3v3(velgoal, bp->origS, bp->origE);
                                kd =  sb->goalfrict * sb_fric_force_scale(ob);
                                add_v3_v3v3(auxvect, velgoal, bp->vec);
                                sub_v3_v3v3(velgoal, bp->origS, bp->origE);
                                kd =  sb->goalfrict * sb_fric_force_scale(ob);
                                add_v3_v3v3(auxvect, velgoal, bp->vec);
@@ -2217,7 +2165,7 @@ static void softbody_calc_forcesEx(struct Depsgraph *depsgraph, Scene *scene, Ob
 
        if (do_deflector) {
                float defforce[3];
 
        if (do_deflector) {
                float defforce[3];
-               do_deflector = sb_detect_aabb_collisionCached(defforce, ob->lay, ob, timenow);
+               do_deflector = sb_detect_aabb_collisionCached(defforce, ob, timenow);
        }
 
        sb_cf_threads_run(scene, ob, forcetime, timenow, sb->totpoint, NULL, effectors, do_deflector, fieldfactor, windfactor);
        }
 
        sb_cf_threads_run(scene, ob, forcetime, timenow, sb->totpoint, NULL, effectors, do_deflector, fieldfactor, windfactor);
@@ -2248,7 +2196,7 @@ static void softbody_calc_forces(struct Depsgraph *depsgraph, Scene *scene, Obje
 
                /* rule we never alter free variables :bp->vec bp->pos in here !
                 * this will ruin adaptive stepsize AKA heun! (BM)
 
                /* rule we never alter free variables :bp->vec bp->pos in here !
                 * this will ruin adaptive stepsize AKA heun! (BM)
-               */
+                */
                SoftBody *sb= ob->soft; /* is supposed to be there */
                BodyPoint  *bp;
                /* BodyPoint *bproot; */ /* UNUSED */
                SoftBody *sb= ob->soft; /* is supposed to be there */
                BodyPoint  *bp;
                /* BodyPoint *bproot; */ /* UNUSED */
@@ -2278,7 +2226,7 @@ static void softbody_calc_forces(struct Depsgraph *depsgraph, Scene *scene, Obje
 
                if (do_deflector) {
                        float defforce[3];
 
                if (do_deflector) {
                        float defforce[3];
-                       do_deflector = sb_detect_aabb_collisionCached(defforce, ob->lay, ob, timenow);
+                       do_deflector = sb_detect_aabb_collisionCached(defforce, ob, timenow);
                }
 
                bp = sb->bpoint;
                }
 
                bp = sb->bpoint;
@@ -2303,7 +2251,7 @@ static void softbody_calc_forces(struct Depsgraph *depsgraph, Scene *scene, Obje
                                        compare = (obp->colball + bp->colball);
                                        sub_v3_v3v3(def, bp->pos, obp->pos);
 
                                        compare = (obp->colball + bp->colball);
                                        sub_v3_v3v3(def, bp->pos, obp->pos);
 
-                                       /* rather check the AABBoxes before ever calulating the real distance */
+                                       /* rather check the AABBoxes before ever calculating the real distance */
                                        /* mathematically it is completely nuts, but performance is pretty much (3) times faster */
                                        if ((ABS(def[0]) > compare) || (ABS(def[1]) > compare) || (ABS(def[2]) > compare)) continue;
 
                                        /* mathematically it is completely nuts, but performance is pretty much (3) times faster */
                                        if ((ABS(def[0]) > compare) || (ABS(def[1]) > compare) || (ABS(def[2]) > compare)) continue;
 
@@ -2352,7 +2300,7 @@ static void softbody_calc_forces(struct Depsgraph *depsgraph, Scene *scene, Obje
                                        bp->force[1]+= -ks*(auxvect[1]);
                                        bp->force[2]+= -ks*(auxvect[2]);
 
                                        bp->force[1]+= -ks*(auxvect[1]);
                                        bp->force[2]+= -ks*(auxvect[2]);
 
-                                       /* calulate damping forces generated by goals*/
+                                       /* calculate damping forces generated by goals*/
                                        sub_v3_v3v3(velgoal, bp->origS, bp->origE);
                                        kd = sb->goalfrict * sb_fric_force_scale(ob);
                                        add_v3_v3v3(auxvect, velgoal, bp->vec);
                                        sub_v3_v3v3(velgoal, bp->origS, bp->origE);
                                        kd = sb->goalfrict * sb_fric_force_scale(ob);
                                        add_v3_v3v3(auxvect, velgoal, bp->vec);
@@ -2417,16 +2365,16 @@ static void softbody_calc_forces(struct Depsgraph *depsgraph, Scene *scene, Obje
                                        if (sb_deflect_face(ob, bp->pos, facenormal, defforce, &cf, timenow, vel, &intrusion)) {
                                                if (intrusion < 0.0f) {
                                                        if (G.debug_value & 0x01) { // 17 we did check for bit 0x10 before
                                        if (sb_deflect_face(ob, bp->pos, facenormal, defforce, &cf, timenow, vel, &intrusion)) {
                                                if (intrusion < 0.0f) {
                                                        if (G.debug_value & 0x01) { // 17 we did check for bit 0x10 before
-                                                               /*fixing bug [17428] this forces adaptive step size to tiny steps
-                                                               in some situations .. keeping G.debug_value==17 option for old files 'needing' the bug
-                                                               */
-                                                               /*bjornmose:  uugh.. what an evil hack
-                                                               violation of the 'don't touch bp->pos in here' rule
-                                                               but works nice, like this-->
-                                                               we predict the solution being out of the collider
-                                                               in heun step No1 and leave the heun step No2 adapt to it
-                                                               so we kind of introduced a implicit solver for this case
-                                                               */
+                                                               /* fixing bug [17428] this forces adaptive step size to tiny steps
+                                                                * in some situations .. keeping G.debug_value==17 option for old files 'needing' the bug
+                                                                */
+                                                               /* bjornmose:  uugh.. what an evil hack
+                                                                * violation of the 'don't touch bp->pos in here' rule
+                                                                * but works nice, like this-->
+                                                                * we predict the solution being out of the collider
+                                                                * in heun step No1 and leave the heun step No2 adapt to it
+                                                                * so we kind of introduced a implicit solver for this case
+                                                                */
                                                                madd_v3_v3fl(bp->pos, facenormal, -intrusion);
                                                        }
                                                        else {
                                                                madd_v3_v3fl(bp->pos, facenormal, -intrusion);
                                                        }
                                                        else {
@@ -2496,13 +2444,6 @@ static void softbody_apply_forces(Object *ob, float forcetime, int mode, float *
        aabbmin[0]=aabbmin[1]=aabbmin[2] = 1e20f;
        aabbmax[0]=aabbmax[1]=aabbmax[2] = -1e20f;
 
        aabbmin[0]=aabbmin[1]=aabbmin[2] = 1e20f;
        aabbmax[0]=aabbmax[1]=aabbmax[2] = -1e20f;
 
-       /* old one with homogeneous masses  */
-       /* claim a minimum mass for vertex */
-       /*
-       if (sb->nodemass > 0.009999f) timeovermass = forcetime/sb->nodemass;
-       else timeovermass = forcetime/0.009999f;
-       */
-
        for (a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
 /* now we have individual masses   */
 /* claim a minimum mass for vertex */
        for (a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
 /* now we have individual masses   */
 /* claim a minimum mass for vertex */
@@ -2547,16 +2488,6 @@ static void softbody_apply_forces(Object *ob, float forcetime, int mode, float *
                        /* x(t + dt) = x(t) + v(t~) * dt */
                        mul_v3_fl(dx, forcetime);
 
                        /* x(t + dt) = x(t) + v(t~) * dt */
                        mul_v3_fl(dx, forcetime);
 
-                       /* the freezer coming sooner or later */
-#if 0
-                       if ((dot_v3v3(dx, dx)<freezeloc )&&(dot_v3v3(bp->force, bp->force)<freezeforce )) {
-                               bp->frozen /=2;
-                       }
-                       else {
-                               bp->frozen = min_ff(bp->frozen*1.05f, 1.0f);
-                       }
-                       mul_v3_fl(dx, bp->frozen);
-#endif
                        /* again some nasty if's to have heun in here too */
                        if (mode ==1) {
                                copy_v3_v3(bp->prevpos, bp->pos);
                        /* again some nasty if's to have heun in here too */
                        if (mode ==1) {
                                copy_v3_v3(bp->prevpos, bp->pos);
@@ -2621,87 +2552,12 @@ static void softbody_restore_prev_step(Object *ob)
        }
 }
 
        }
 }
 
-#if 0
-static void softbody_store_step(Object *ob)
-{
-       SoftBody *sb= ob->soft; /* is supposed to be there*/
-       BodyPoint *bp;
-       int a;
-
-       for (a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
-               copy_v3_v3(bp->prevvec, bp->vec);
-               copy_v3_v3(bp->prevpos, bp->pos);
-       }
-}
-
-
-/* used by predictors and correctors */
-static void softbody_store_state(Object *ob, float *ppos, float *pvel)
-{
-       SoftBody *sb= ob->soft; /* is supposed to be there*/
-       BodyPoint *bp;
-       int a;
-       float *pp=ppos, *pv=pvel;
-
-       for (a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
-
-               copy_v3_v3(pv, bp->vec);
-               pv+=3;
-
-               copy_v3_v3(pp, bp->pos);
-               pp+=3;
-       }
-}
-
-/* used by predictors and correctors */
-static void softbody_retrieve_state(Object *ob, float *ppos, float *pvel)
-{
-       SoftBody *sb= ob->soft; /* is supposed to be there*/
-       BodyPoint *bp;
-       int a;
-       float *pp=ppos, *pv=pvel;
-
-       for (a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
-
-               copy_v3_v3(bp->vec, pv);
-               pv+=3;
-
-               copy_v3_v3(bp->pos, pp);
-               pp+=3;
-       }
-}
-
-/* used by predictors and correctors */
-static void softbody_swap_state(Object *ob, float *ppos, float *pvel)
-{
-       SoftBody *sb= ob->soft; /* is supposed to be there*/
-       BodyPoint *bp;
-       int a;
-       float *pp=ppos, *pv=pvel;
-       float temp[3];
-
-       for (a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
-
-               copy_v3_v3(temp, bp->vec);
-               copy_v3_v3(bp->vec, pv);
-               copy_v3_v3(pv, temp);
-               pv+=3;
-
-               copy_v3_v3(temp, bp->pos);
-               copy_v3_v3(bp->pos, pp);
-               copy_v3_v3(pp, temp);
-               pp+=3;
-       }
-}
-#endif
-
-
 /* care for bodypoints taken out of the 'ordinary' solver step
 /* care for bodypoints taken out of the 'ordinary' solver step
-** because they are screwed to goal by bolts
-** they just need to move along with the goal in time
-** we need to adjust them on sub frame timing in solver
-** so now when frame is done .. put 'em to the position at the end of frame
-*/
+ * because they are screwed to goal by bolts
+ * they just need to move along with the goal in time
+ * we need to adjust them on sub frame timing in solver
+ * so now when frame is done .. put 'em to the position at the end of frame
+ */
 static void softbody_apply_goalsnap(Object *ob)
 {
        SoftBody *sb= ob->soft; /* is supposed to be there */
 static void softbody_apply_goalsnap(Object *ob)
 {
        SoftBody *sb= ob->soft; /* is supposed to be there */
@@ -2766,9 +2622,9 @@ static void interpolate_exciter(Object *ob, int timescale, int time)
 
 /* ************ convertors ********** */
 
 
 /* ************ convertors ********** */
 
-/*  for each object type we need;
      - xxxx_to_softbody(Object *ob)      : a full (new) copy, creates SB geometry
-*/
+/* for each object type we need;
* - xxxx_to_softbody(Object *ob)      : a full (new) copy, creates SB geometry
+ */
 
 /* Resetting a Mesh SB object's springs */
 /* Spring length are caculted from'raw' mesh vertices that are NOT altered by modifier stack. */
 
 /* Resetting a Mesh SB object's springs */
 /* Spring length are caculted from'raw' mesh vertices that are NOT altered by modifier stack. */
@@ -2782,7 +2638,7 @@ static void springs_from_mesh(Object *ob)
 
        sb= ob->soft;
        if (me && sb) {
 
        sb= ob->soft;
        if (me && sb) {
-               /* using bp->origS as a container for spring calcualtions here
+               /* using bp->origS as a container for spring calculations here
                 * will be overwritten sbObjectStep() to receive
                 * actual modifier stack positions
                 */
                 * will be overwritten sbObjectStep() to receive
                 * actual modifier stack positions
                 */
@@ -3370,7 +3226,7 @@ static void softbody_update_positions(Object *ob, SoftBody *sb, float (*vertexCo
  * that is:
  * a precise position vector denoting the motion of the center of mass
  * give a rotation/scale matrix using averaging method, that's why estimate and not calculate
  * that is:
  * a precise position vector denoting the motion of the center of mass
  * give a rotation/scale matrix using averaging method, that's why estimate and not calculate
- * see: this is kind of reverse engineering: having to states of a point cloud and recover what happend
+ * see: this is kind of reverse engineering: having to states of a point cloud and recover what happened
  * our advantage here we know the identity of the vertex
  * there are others methods giving other results.
  * lloc, lrot, lscale are allowed to be NULL, just in case you don't need it.
  * our advantage here we know the identity of the vertex
  * there are others methods giving other results.
  * lloc, lrot, lscale are allowed to be NULL, just in case you don't need it.