Simulation: Change BPH prefix to SIM

In a previous commit the `physics` folder has been renamed to `simulation`.
This commit updates the function/file prefix accordingly.

1 files changed, 47 insertions, 47 deletions

diff --git a/source/blender/simulation/intern/implicit_blender.c b/source/blender/simulation/intern/implicit_blender.c
index 54d38f3c10b..856572aa3f5 100644
--- a/source/blender/simulation/intern/implicit_blender.c
+++ b/source/blender/simulation/intern/implicit_blender.c
@@ -40,7 +40,7 @@
 #  include "BKE_collision.h"
 #  include "BKE_effect.h"
 
-#  include "BPH_mass_spring.h"
+#  include "SIM_mass_spring.h"
 
 #  ifdef __GNUC__
 #    pragma GCC diagnostic ignored "-Wtype-limits"
@@ -679,7 +679,7 @@ typedef struct Implicit_Data {
   fmatrix3x3 *P, *Pinv; /* pre-conditioning matrix */
 } Implicit_Data;
 
-Implicit_Data *BPH_mass_spring_solver_create(int numverts, int numsprings)
+Implicit_Data *SIM_mass_spring_solver_create(int numverts, int numsprings)
 {
   Implicit_Data *id = (Implicit_Data *)MEM_callocN(sizeof(Implicit_Data), "implicit vecmat");
 
@@ -707,7 +707,7 @@ Implicit_Data *BPH_mass_spring_solver_create(int numverts, int numsprings)
   return id;
 }
 
-void BPH_mass_spring_solver_free(Implicit_Data *id)
+void SIM_mass_spring_solver_free(Implicit_Data *id)
 {
   del_bfmatrix(id->tfm);
   del_bfmatrix(id->A);
@@ -924,8 +924,8 @@ static int cg_filtered(lfVector *ldV,
   del_lfvector(s);
   // printf("W/O conjgrad_loopcount: %d\n", conjgrad_loopcount);
 
-  result->status = conjgrad_loopcount < conjgrad_looplimit ? BPH_SOLVER_SUCCESS :
-                                                             BPH_SOLVER_NO_CONVERGENCE;
+  result->status = conjgrad_loopcount < conjgrad_looplimit ? SIM_SOLVER_SUCCESS :
+                                                             SIM_SOLVER_NO_CONVERGENCE;
   result->iterations = conjgrad_loopcount;
   result->error = bnorm2 > 0.0f ? sqrtf(delta_new / bnorm2) : 0.0f;
 
@@ -1139,7 +1139,7 @@ static int cg_filtered_pre(lfVector *dv,
 }
 #  endif
 
-bool BPH_mass_spring_solve_velocities(Implicit_Data *data, float dt, ImplicitSolverResult *result)
+bool SIM_mass_spring_solve_velocities(Implicit_Data *data, float dt, ImplicitSolverResult *result)
 {
   unsigned int numverts = data->dFdV[0].vcount;
 
@@ -1173,10 +1173,10 @@ bool BPH_mass_spring_solve_velocities(Implicit_Data *data, float dt, ImplicitSol
 
   del_lfvector(dFdXmV);
 
-  return result->status == BPH_SOLVER_SUCCESS;
+  return result->status == SIM_SOLVER_SUCCESS;
 }
 
-bool BPH_mass_spring_solve_positions(Implicit_Data *data, float dt)
+bool SIM_mass_spring_solve_positions(Implicit_Data *data, float dt)
 {
   int numverts = data->M[0].vcount;
 
@@ -1186,20 +1186,20 @@ bool BPH_mass_spring_solve_positions(Implicit_Data *data, float dt)
   return true;
 }
 
-void BPH_mass_spring_apply_result(Implicit_Data *data)
+void SIM_mass_spring_apply_result(Implicit_Data *data)
 {
   int numverts = data->M[0].vcount;
   cp_lfvector(data->X, data->Xnew, numverts);
   cp_lfvector(data->V, data->Vnew, numverts);
 }
 
-void BPH_mass_spring_set_vertex_mass(Implicit_Data *data, int index, float mass)
+void SIM_mass_spring_set_vertex_mass(Implicit_Data *data, int index, float mass)
 {
   unit_m3(data->M[index].m);
   mul_m3_fl(data->M[index].m, mass);
 }
 
-void BPH_mass_spring_set_rest_transform(Implicit_Data *data, int index, float tfm[3][3])
+void SIM_mass_spring_set_rest_transform(Implicit_Data *data, int index, float tfm[3][3])
 {
 #  ifdef CLOTH_ROOT_FRAME
   copy_m3_m3(data->tfm[index].m, tfm);
@@ -1209,7 +1209,7 @@ void BPH_mass_spring_set_rest_transform(Implicit_Data *data, int index, float tf
 #  endif
 }
 
-void BPH_mass_spring_set_motion_state(Implicit_Data *data,
+void SIM_mass_spring_set_motion_state(Implicit_Data *data,
                                       int index,
                                       const float x[3],
                                       const float v[3])
@@ -1218,17 +1218,17 @@ void BPH_mass_spring_set_motion_state(Implicit_Data *data,
   world_to_root_v3(data, index, data->V[index], v);
 }
 
-void BPH_mass_spring_set_position(Implicit_Data *data, int index, const float x[3])
+void SIM_mass_spring_set_position(Implicit_Data *data, int index, const float x[3])
 {
   world_to_root_v3(data, index, data->X[index], x);
 }
 
-void BPH_mass_spring_set_velocity(Implicit_Data *data, int index, const float v[3])
+void SIM_mass_spring_set_velocity(Implicit_Data *data, int index, const float v[3])
 {
   world_to_root_v3(data, index, data->V[index], v);
 }
 
-void BPH_mass_spring_get_motion_state(struct Implicit_Data *data,
+void SIM_mass_spring_get_motion_state(struct Implicit_Data *data,
                                       int index,
                                       float x[3],
                                       float v[3])
@@ -1241,39 +1241,39 @@ void BPH_mass_spring_get_motion_state(struct Implicit_Data *data,
   }
 }
 
-void BPH_mass_spring_get_position(struct Implicit_Data *data, int index, float x[3])
+void SIM_mass_spring_get_position(struct Implicit_Data *data, int index, float x[3])
 {
   root_to_world_v3(data, index, x, data->X[index]);
 }
 
-void BPH_mass_spring_get_velocity(struct Implicit_Data *data, int index, float v[3])
+void SIM_mass_spring_get_velocity(struct Implicit_Data *data, int index, float v[3])
 {
   root_to_world_v3(data, index, v, data->V[index]);
 }
 
-void BPH_mass_spring_get_new_position(struct Implicit_Data *data, int index, float x[3])
+void SIM_mass_spring_get_new_position(struct Implicit_Data *data, int index, float x[3])
 {
   root_to_world_v3(data, index, x, data->Xnew[index]);
 }
 
-void BPH_mass_spring_set_new_position(struct Implicit_Data *data, int index, const float x[3])
+void SIM_mass_spring_set_new_position(struct Implicit_Data *data, int index, const float x[3])
 {
   world_to_root_v3(data, index, data->Xnew[index], x);
 }
 
-void BPH_mass_spring_get_new_velocity(struct Implicit_Data *data, int index, float v[3])
+void SIM_mass_spring_get_new_velocity(struct Implicit_Data *data, int index, float v[3])
 {
   root_to_world_v3(data, index, v, data->Vnew[index]);
 }
 
-void BPH_mass_spring_set_new_velocity(struct Implicit_Data *data, int index, const float v[3])
+void SIM_mass_spring_set_new_velocity(struct Implicit_Data *data, int index, const float v[3])
 {
   world_to_root_v3(data, index, data->Vnew[index], v);
 }
 
 /* -------------------------------- */
 
-static int BPH_mass_spring_add_block(Implicit_Data *data, int v1, int v2)
+static int SIM_mass_spring_add_block(Implicit_Data *data, int v1, int v2)
 {
   int s = data->M[0].vcount + data->num_blocks; /* index from array start */
   BLI_assert(s < data->M[0].vcount + data->M[0].scount);
@@ -1291,7 +1291,7 @@ static int BPH_mass_spring_add_block(Implicit_Data *data, int v1, int v2)
   return s;
 }
 
-void BPH_mass_spring_clear_constraints(Implicit_Data *data)
+void SIM_mass_spring_clear_constraints(Implicit_Data *data)
 {
   int i, numverts = data->S[0].vcount;
   for (i = 0; i < numverts; i++) {
@@ -1300,14 +1300,14 @@ void BPH_mass_spring_clear_constraints(Implicit_Data *data)
   }
 }
 
-void BPH_mass_spring_add_constraint_ndof0(Implicit_Data *data, int index, const float dV[3])
+void SIM_mass_spring_add_constraint_ndof0(Implicit_Data *data, int index, const float dV[3])
 {
   zero_m3(data->S[index].m);
 
   world_to_root_v3(data, index, data->z[index], dV);
 }
 
-void BPH_mass_spring_add_constraint_ndof1(
+void SIM_mass_spring_add_constraint_ndof1(
     Implicit_Data *data, int index, const float c1[3], const float c2[3], const float dV[3])
 {
   float m[3][3], p[3], q[3], u[3], cmat[3][3];
@@ -1328,7 +1328,7 @@ void BPH_mass_spring_add_constraint_ndof1(
   add_v3_v3(data->z[index], u);
 }
 
-void BPH_mass_spring_add_constraint_ndof2(Implicit_Data *data,
+void SIM_mass_spring_add_constraint_ndof2(Implicit_Data *data,
                                           int index,
                                           const float c1[3],
                                           const float dV[3])
@@ -1346,7 +1346,7 @@ void BPH_mass_spring_add_constraint_ndof2(Implicit_Data *data,
   add_v3_v3(data->z[index], u);
 }
 
-void BPH_mass_spring_clear_forces(Implicit_Data *data)
+void SIM_mass_spring_clear_forces(Implicit_Data *data)
 {
   int numverts = data->M[0].vcount;
   zero_lfvector(data->F, numverts);
@@ -1356,7 +1356,7 @@ void BPH_mass_spring_clear_forces(Implicit_Data *data)
   data->num_blocks = 0;
 }
 
-void BPH_mass_spring_force_reference_frame(Implicit_Data *data,
+void SIM_mass_spring_force_reference_frame(Implicit_Data *data,
                                            int index,
                                            const float acceleration[3],
                                            const float omega[3],
@@ -1411,7 +1411,7 @@ void BPH_mass_spring_force_reference_frame(Implicit_Data *data,
 #  endif
 }
 
-void BPH_mass_spring_force_gravity(Implicit_Data *data, int index, float mass, const float g[3])
+void SIM_mass_spring_force_gravity(Implicit_Data *data, int index, float mass, const float g[3])
 {
   /* force = mass * acceleration (in this case: gravity) */
   float f[3];
@@ -1421,7 +1421,7 @@ void BPH_mass_spring_force_gravity(Implicit_Data *data, int index, float mass, c
   add_v3_v3(data->F[index], f);
 }
 
-void BPH_mass_spring_force_drag(Implicit_Data *data, float drag)
+void SIM_mass_spring_force_drag(Implicit_Data *data, float drag)
 {
   int i, numverts = data->M[0].vcount;
   for (i = 0; i < numverts; i++) {
@@ -1436,7 +1436,7 @@ void BPH_mass_spring_force_drag(Implicit_Data *data, float drag)
   }
 }
 
-void BPH_mass_spring_force_extern(
+void SIM_mass_spring_force_extern(
     struct Implicit_Data *data, int i, const float f[3], float dfdx[3][3], float dfdv[3][3])
 {
   float tf[3], tdfdx[3][3], tdfdv[3][3];
@@ -1465,7 +1465,7 @@ static float calc_nor_area_tri(float nor[3],
 
 /* XXX does not support force jacobians yet, since the effector system does not provide them either
  */
-void BPH_mass_spring_force_face_wind(
+void SIM_mass_spring_force_face_wind(
     Implicit_Data *data, int v1, int v2, int v3, const float (*winvec)[3])
 {
   const float effector_scale = 0.02f;
@@ -1505,7 +1505,7 @@ void BPH_mass_spring_force_face_wind(
   madd_v3_v3fl(data->F[v3], nor, base_force + force[2]);
 }
 
-void BPH_mass_spring_force_face_extern(
+void SIM_mass_spring_force_face_extern(
     Implicit_Data *data, int v1, int v2, int v3, const float (*forcevec)[3])
 {
   const float effector_scale = 0.02f;
@@ -1536,20 +1536,20 @@ void BPH_mass_spring_force_face_extern(
   }
 }
 
-float BPH_tri_tetra_volume_signed_6x(Implicit_Data *data, int v1, int v2, int v3)
+float SIM_tri_tetra_volume_signed_6x(Implicit_Data *data, int v1, int v2, int v3)
 {
   /* The result will be 6x the volume */
   return volume_tri_tetrahedron_signed_v3_6x(data->X[v1], data->X[v2], data->X[v3]);
 }
 
-float BPH_tri_area(struct Implicit_Data *data, int v1, int v2, int v3)
+float SIM_tri_area(struct Implicit_Data *data, int v1, int v2, int v3)
 {
   float nor[3];
 
   return calc_nor_area_tri(nor, data->X[v1], data->X[v2], data->X[v3]);
 }
 
-void BPH_mass_spring_force_pressure(Implicit_Data *data,
+void SIM_mass_spring_force_pressure(Implicit_Data *data,
                                     int v1,
                                     int v2,
                                     int v3,
@@ -1617,7 +1617,7 @@ static void edge_wind_vertex(const float dir[3],
   mul_v3_v3fl(f, wind, density * cross_section);
 }
 
-void BPH_mass_spring_force_edge_wind(
+void SIM_mass_spring_force_edge_wind(
     Implicit_Data *data, int v1, int v2, float radius1, float radius2, const float (*winvec)[3])
 {
   float win[3], dir[3], length;
@@ -1635,7 +1635,7 @@ void BPH_mass_spring_force_edge_wind(
   add_v3_v3(data->F[v2], f);
 }
 
-void BPH_mass_spring_force_vertex_wind(Implicit_Data *data,
+void SIM_mass_spring_force_vertex_wind(Implicit_Data *data,
                                        int v,
                                        float UNUSED(radius),
                                        const float (*winvec)[3])
@@ -1766,7 +1766,7 @@ BLI_INLINE bool spring_length(Implicit_Data *data,
 BLI_INLINE void apply_spring(
     Implicit_Data *data, int i, int j, const float f[3], float dfdx[3][3], float dfdv[3][3])
 {
-  int block_ij = BPH_mass_spring_add_block(data, i, j);
+  int block_ij = SIM_mass_spring_add_block(data, i, j);
 
   add_v3_v3(data->F[i], f);
   sub_v3_v3(data->F[j], f);
@@ -1780,7 +1780,7 @@ BLI_INLINE void apply_spring(
   sub_m3_m3m3(data->dFdV[block_ij].m, data->dFdV[block_ij].m, dfdv);
 }
 
-bool BPH_mass_spring_force_spring_linear(Implicit_Data *data,
+bool SIM_mass_spring_force_spring_linear(Implicit_Data *data,
                                          int i,
                                          int j,
                                          float restlen,
@@ -1841,7 +1841,7 @@ bool BPH_mass_spring_force_spring_linear(Implicit_Data *data,
 }
 
 /* See "Stable but Responsive Cloth" (Choi, Ko 2005) */
-bool BPH_mass_spring_force_spring_bending(
+bool SIM_mass_spring_force_spring_bending(
     Implicit_Data *data, int i, int j, float restlen, float kb, float cb)
 {
   float extent[3], length, dir[3], vel[3];
@@ -1948,7 +1948,7 @@ BLI_INLINE void spring_angle(Implicit_Data *data,
 
 /* Angular springs roughly based on the bending model proposed by Baraff and Witkin in "Large Steps
  * in Cloth Simulation". */
-bool BPH_mass_spring_force_spring_angular(Implicit_Data *data,
+bool SIM_mass_spring_force_spring_angular(Implicit_Data *data,
                                           int i,
                                           int j,
                                           int *i_a,
@@ -2169,7 +2169,7 @@ BLI_INLINE void spring_hairbend_estimate_dfdv(Implicit_Data *data,
 /* Angular spring that pulls the vertex toward the local target
  * See "Artistic Simulation of Curly Hair" (Pixar technical memo #12-03a)
  */
-bool BPH_mass_spring_force_spring_bending_hair(Implicit_Data *data,
+bool SIM_mass_spring_force_spring_bending_hair(Implicit_Data *data,
                                                int i,
                                                int j,
                                                int k,
@@ -2184,9 +2184,9 @@ bool BPH_mass_spring_force_spring_bending_hair(Implicit_Data *data,
 
   const float vecnull[3] = {0.0f, 0.0f, 0.0f};
 
-  int block_ij = BPH_mass_spring_add_block(data, i, j);
-  int block_jk = BPH_mass_spring_add_block(data, j, k);
-  int block_ik = BPH_mass_spring_add_block(data, i, k);
+  int block_ij = SIM_mass_spring_add_block(data, i, j);
+  int block_jk = SIM_mass_spring_add_block(data, j, k);
+  int block_ik = SIM_mass_spring_add_block(data, i, k);
 
   world_to_root_v3(data, j, goal, target);
 
@@ -2318,7 +2318,7 @@ bool BPH_mass_spring_force_spring_bending_hair(Implicit_Data *data,
   return true;
 }
 
-bool BPH_mass_spring_force_spring_goal(Implicit_Data *data,
+bool SIM_mass_spring_force_spring_goal(Implicit_Data *data,
                                        int i,
                                        const float goal_x[3],
                                        const float goal_v[3],