Cleanup: Remove more #if 0 blocks
[blender.git] / source / blender / blenkernel / intern / softbody.c
index 1f5cefd..e4ea839 100644 (file)
@@ -116,7 +116,7 @@ typedef struct ReferenceVert {
 
 typedef struct ReferenceState {
        float com[3]; /* center of mass*/
-       ReferenceVert *ivert; /* list of intial values */
+       ReferenceVert *ivert; /* list of initial values */
 } ReferenceState;
 
 
@@ -217,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?
- * 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
  */
 
@@ -927,7 +927,7 @@ static void free_softbody_intern(SoftBody *sb)
  *
  * 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
+ * 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
@@ -964,7 +964,7 @@ static int query_external_colliders(Depsgraph *depsgraph, Collection *collection
 
 
 /* +++ 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;
@@ -972,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;
-#if 0
-       int a;
-#endif
 
        if ((sb == NULL) || (sb->scratch ==NULL)) return 0;
        copy_v3_v3(aabbmin, sb->scratch->aabbmin);
@@ -1025,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,
-                                      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;
@@ -1126,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,
-                                          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;
@@ -1263,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,
-                               &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);
@@ -1281,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,
-                                       &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);
@@ -1310,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,
-                                                                  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;
@@ -1447,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,
-                                               &damp, feedback, ob->lay, ob, timenow)) {
+                                               &damp, feedback, ob, timenow)) {
                                                        add_v3_v3(bs->ext_force, feedback);
                                                        bs->flag |= BSF_INTERSECT;
                                                        //bs->cf=damp;
@@ -1606,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,
-        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;
@@ -1802,50 +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);
-       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);
 }
 
-/* hiding this for now .. but the jacobian may pop up on other tasks .. so i'd like to keep it */
-#if 0
-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);
-}
-#endif  /* if 0 */
-
 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;
-#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];
-#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];
-#if 0  /* UNUSED */
-               ia =3*bs->v2;
-               ic =3*bs->v1;
-#endif
        }
        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;
 
-       /* intitialize */
+       /* initialize */
        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);
-                               /* 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);
@@ -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]);
 
-                               /* 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);
@@ -2217,7 +2165,7 @@ static void softbody_calc_forcesEx(struct Depsgraph *depsgraph, Scene *scene, Ob
 
        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);
@@ -2278,7 +2226,7 @@ static void softbody_calc_forces(struct Depsgraph *depsgraph, Scene *scene, Obje
 
                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;
@@ -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);
 
-                                       /* 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;
 
@@ -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]);
 
-                                       /* 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);
@@ -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;
 
-       /* old one with homogeneous masses  */
-       /* claim a minimum mass for vertex */
-#if 0
-       if (sb->nodemass > 0.009999f) timeovermass = forcetime / sb->nodemass;
-       else timeovermass = forcetime / 0.009999f;
-#endif
-
        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);
 
-                       /* 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);
@@ -2621,81 +2552,6 @@ 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
  * because they are screwed to goal by bolts
  * they just need to move along with the goal in time
@@ -2782,7 +2638,7 @@ static void springs_from_mesh(Object *ob)
 
        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
                 */
@@ -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
- * 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.