Cleanup: split object data deform functions into their own files

Move armature/curve functions into their headers,
they were previously in BKE_lattice.h

1 files changed, 0 insertions, 562 deletions

diff --git a/source/blender/blenkernel/intern/armature.c b/source/blender/blenkernel/intern/armature.c
index d2ba3434f2a..007062abb5b 100644
--- a/source/blender/blenkernel/intern/armature.c
+++ b/source/blender/blenkernel/intern/armature.c
@@ -35,18 +35,12 @@
 #include "BLI_listbase.h"
 #include "BLI_math.h"
 #include "BLI_string.h"
-#include "BLI_task.h"
 #include "BLI_utildefines.h"
 #include "BLT_translation.h"
 
-#include "DNA_anim_types.h"
 #include "DNA_armature_types.h"
 #include "DNA_constraint_types.h"
-#include "DNA_gpencil_types.h"
-#include "DNA_lattice_types.h"
 #include "DNA_listBase.h"
-#include "DNA_mesh_types.h"
-#include "DNA_meshdata_types.h"
 #include "DNA_object_types.h"
 #include "DNA_scene_types.h"
 
@@ -55,11 +49,8 @@
 #include "BKE_armature.h"
 #include "BKE_constraint.h"
 #include "BKE_curve.h"
-#include "BKE_deform.h"
-#include "BKE_displist.h"
 #include "BKE_idprop.h"
 #include "BKE_idtype.h"
-#include "BKE_lattice.h"
 #include "BKE_lib_id.h"
 #include "BKE_lib_query.h"
 #include "BKE_main.h"
@@ -71,8 +62,6 @@
 
 #include "BIK_api.h"
 
-#include "atomic_ops.h"
-
 #include "CLG_log.h"
 
 static CLG_LogRef LOG = {"bke.armature"};
@@ -1386,557 +1375,6 @@ void BKE_pchan_bbone_deform_segment_index(const bPoseChannel *pchan,
 /** \} */
 
 /* -------------------------------------------------------------------- */
-/** \name Armature Deform Internal Utilities
- * \{ */
-
-/* Add the effect of one bone or B-Bone segment to the accumulated result. */
-static void pchan_deform_accumulate(const DualQuat *deform_dq,
-                                    const float deform_mat[4][4],
-                                    const float co_in[3],
-                                    float weight,
-                                    float co_accum[3],
-                                    DualQuat *dq_accum,
-                                    float mat_accum[3][3])
-{
-  if (weight == 0.0f) {
-    return;
-  }
-
-  if (dq_accum) {
-    BLI_assert(!co_accum);
-
-    add_weighted_dq_dq(dq_accum, deform_dq, weight);
-  }
-  else {
-    float tmp[3];
-    mul_v3_m4v3(tmp, deform_mat, co_in);
-
-    sub_v3_v3(tmp, co_in);
-    madd_v3_v3fl(co_accum, tmp, weight);
-
-    if (mat_accum) {
-      float tmpmat[3][3];
-      copy_m3_m4(tmpmat, deform_mat);
-
-      madd_m3_m3m3fl(mat_accum, mat_accum, tmpmat, weight);
-    }
-  }
-}
-
-static void b_bone_deform(const bPoseChannel *pchan,
-                          const float co[3],
-                          float weight,
-                          float vec[3],
-                          DualQuat *dq,
-                          float defmat[3][3])
-{
-  const DualQuat *quats = pchan->runtime.bbone_dual_quats;
-  const Mat4 *mats = pchan->runtime.bbone_deform_mats;
-  const float(*mat)[4] = mats[0].mat;
-  float blend, y;
-  int index;
-
-  /* Transform co to bone space and get its y component. */
-  y = mat[0][1] * co[0] + mat[1][1] * co[1] + mat[2][1] * co[2] + mat[3][1];
-
-  /* Calculate the indices of the 2 affecting b_bone segments. */
-  BKE_pchan_bbone_deform_segment_index(pchan, y / pchan->bone->length, &index, &blend);
-
-  pchan_deform_accumulate(
-      &quats[index], mats[index + 1].mat, co, weight * (1.0f - blend), vec, dq, defmat);
-  pchan_deform_accumulate(
-      &quats[index + 1], mats[index + 2].mat, co, weight * blend, vec, dq, defmat);
-}
-
-/* using vec with dist to bone b1 - b2 */
-float distfactor_to_bone(
-    const float vec[3], const float b1[3], const float b2[3], float rad1, float rad2, float rdist)
-{
-  float dist_sq;
-  float bdelta[3];
-  float pdelta[3];
-  float hsqr, a, l, rad;
-
-  sub_v3_v3v3(bdelta, b2, b1);
-  l = normalize_v3(bdelta);
-
-  sub_v3_v3v3(pdelta, vec, b1);
-
-  a = dot_v3v3(bdelta, pdelta);
-  hsqr = len_squared_v3(pdelta);
-
-  if (a < 0.0f) {
-    /* If we're past the end of the bone, do a spherical field attenuation thing */
-    dist_sq = len_squared_v3v3(b1, vec);
-    rad = rad1;
-  }
-  else if (a > l) {
-    /* If we're past the end of the bone, do a spherical field attenuation thing */
-    dist_sq = len_squared_v3v3(b2, vec);
-    rad = rad2;
-  }
-  else {
-    dist_sq = (hsqr - (a * a));
-
-    if (l != 0.0f) {
-      rad = a / l;
-      rad = rad * rad2 + (1.0f - rad) * rad1;
-    }
-    else {
-      rad = rad1;
-    }
-  }
-
-  a = rad * rad;
-  if (dist_sq < a) {
-    return 1.0f;
-  }
-  else {
-    l = rad + rdist;
-    l *= l;
-    if (rdist == 0.0f || dist_sq >= l) {
-      return 0.0f;
-    }
-    else {
-      a = sqrtf(dist_sq) - rad;
-      return 1.0f - (a * a) / (rdist * rdist);
-    }
-  }
-}
-
-static float dist_bone_deform(
-    bPoseChannel *pchan, float vec[3], DualQuat *dq, float mat[3][3], const float co[3])
-{
-  Bone *bone = pchan->bone;
-  float fac, contrib = 0.0;
-
-  if (bone == NULL) {
-    return 0.0f;
-  }
-
-  fac = distfactor_to_bone(
-      co, bone->arm_head, bone->arm_tail, bone->rad_head, bone->rad_tail, bone->dist);
-
-  if (fac > 0.0f) {
-    fac *= bone->weight;
-    contrib = fac;
-    if (contrib > 0.0f) {
-      if (bone->segments > 1 && pchan->runtime.bbone_segments == bone->segments) {
-        b_bone_deform(pchan, co, fac, vec, dq, mat);
-      }
-      else {
-        pchan_deform_accumulate(
-            &pchan->runtime.deform_dual_quat, pchan->chan_mat, co, fac, vec, dq, mat);
-      }
-    }
-  }
-
-  return contrib;
-}
-
-static void pchan_bone_deform(bPoseChannel *pchan,
-                              float weight,
-                              float vec[3],
-                              DualQuat *dq,
-                              float mat[3][3],
-                              const float co[3],
-                              float *contrib)
-{
-  Bone *bone = pchan->bone;
-
-  if (!weight) {
-    return;
-  }
-
-  if (bone->segments > 1 && pchan->runtime.bbone_segments == bone->segments) {
-    b_bone_deform(pchan, co, weight, vec, dq, mat);
-  }
-  else {
-    pchan_deform_accumulate(
-        &pchan->runtime.deform_dual_quat, pchan->chan_mat, co, weight, vec, dq, mat);
-  }
-
-  (*contrib) += weight;
-}
-
-/** \} */
-
-/* -------------------------------------------------------------------- */
-/** \name Armature Deform #BKE_armature_deform_coords API
- *
- * #BKE_armature_deform_coords and related functions.
- * \{ */
-
-typedef struct ArmatureUserdata {
-  Object *ob_arm;
-  Object *ob_target;
-  const Mesh *me_target;
-  float (*vert_coords)[3];
-  float (*vert_deform_mats)[3][3];
-  float (*vert_coords_prev)[3];
-
-  bool use_envelope;
-  bool use_quaternion;
-  bool invert_vgroup;
-  bool use_dverts;
-
-  int armature_def_nr;
-
-  const MDeformVert *dverts;
-  int dverts_len;
-
-  bPoseChannel **pchan_from_defbase;
-  int defbase_len;
-
-  float premat[4][4];
-  float postmat[4][4];
-} ArmatureUserdata;
-
-static void armature_vert_task(void *__restrict userdata,
-                               const int i,
-                               const TaskParallelTLS *__restrict UNUSED(tls))
-{
-  const ArmatureUserdata *data = userdata;
-  float(*const vert_coords)[3] = data->vert_coords;
-  float(*const vert_deform_mats)[3][3] = data->vert_deform_mats;
-  float(*const vert_coords_prev)[3] = data->vert_coords_prev;
-  const bool use_envelope = data->use_envelope;
-  const bool use_quaternion = data->use_quaternion;
-  const bool use_dverts = data->use_dverts;
-  const int armature_def_nr = data->armature_def_nr;
-
-  const MDeformVert *dvert;
-  DualQuat sumdq, *dq = NULL;
-  bPoseChannel *pchan;
-  float *co, dco[3];
-  float sumvec[3], summat[3][3];
-  float *vec = NULL, (*smat)[3] = NULL;
-  float contrib = 0.0f;
-  float armature_weight = 1.0f; /* default to 1 if no overall def group */
-  float prevco_weight = 1.0f;   /* weight for optional cached vertexcos */
-
-  if (use_quaternion) {
-    memset(&sumdq, 0, sizeof(DualQuat));
-    dq = &sumdq;
-  }
-  else {
-    zero_v3(sumvec);
-    vec = sumvec;
-
-    if (vert_deform_mats) {
-      zero_m3(summat);
-      smat = summat;
-    }
-  }
-
-  if (use_dverts || armature_def_nr != -1) {
-    if (data->me_target) {
-      BLI_assert(i < data->me_target->totvert);
-      if (data->me_target->dvert != NULL) {
-        dvert = data->me_target->dvert + i;
-      }
-      else {
-        dvert = NULL;
-      }
-    }
-    else if (data->dverts && i < data->dverts_len) {
-      dvert = data->dverts + i;
-    }
-    else {
-      dvert = NULL;
-    }
-  }
-  else {
-    dvert = NULL;
-  }
-
-  if (armature_def_nr != -1 && dvert) {
-    armature_weight = BKE_defvert_find_weight(dvert, armature_def_nr);
-
-    if (data->invert_vgroup) {
-      armature_weight = 1.0f - armature_weight;
-    }
-
-    /* hackish: the blending factor can be used for blending with vert_coords_prev too */
-    if (vert_coords_prev) {
-      prevco_weight = armature_weight;
-      armature_weight = 1.0f;
-    }
-  }
-
-  /* check if there's any  point in calculating for this vert */
-  if (armature_weight == 0.0f) {
-    return;
-  }
-
-  /* get the coord we work on */
-  co = vert_coords_prev ? vert_coords_prev[i] : vert_coords[i];
-
-  /* Apply the object's matrix */
-  mul_m4_v3(data->premat, co);
-
-  if (use_dverts && dvert && dvert->totweight) { /* use weight groups ? */
-    const MDeformWeight *dw = dvert->dw;
-    int deformed = 0;
-    unsigned int j;
-    for (j = dvert->totweight; j != 0; j--, dw++) {
-      const uint index = dw->def_nr;
-      if (index < data->defbase_len && (pchan = data->pchan_from_defbase[index])) {
-        float weight = dw->weight;
-        Bone *bone = pchan->bone;
-
-        deformed = 1;
-
-        if (bone && bone->flag & BONE_MULT_VG_ENV) {
-          weight *= distfactor_to_bone(
-              co, bone->arm_head, bone->arm_tail, bone->rad_head, bone->rad_tail, bone->dist);
-        }
-
-        pchan_bone_deform(pchan, weight, vec, dq, smat, co, &contrib);
-      }
-    }
-    /* if there are vertexgroups but not groups with bones
-     * (like for softbody groups) */
-    if (deformed == 0 && use_envelope) {
-      for (pchan = data->ob_arm->pose->chanbase.first; pchan; pchan = pchan->next) {
-        if (!(pchan->bone->flag & BONE_NO_DEFORM)) {
-          contrib += dist_bone_deform(pchan, vec, dq, smat, co);
-        }
-      }
-    }
-  }
-  else if (use_envelope) {
-    for (pchan = data->ob_arm->pose->chanbase.first; pchan; pchan = pchan->next) {
-      if (!(pchan->bone->flag & BONE_NO_DEFORM)) {
-        contrib += dist_bone_deform(pchan, vec, dq, smat, co);
-      }
-    }
-  }
-
-  /* actually should be EPSILON? weight values and contrib can be like 10e-39 small */
-  if (contrib > 0.0001f) {
-    if (use_quaternion) {
-      normalize_dq(dq, contrib);
-
-      if (armature_weight != 1.0f) {
-        copy_v3_v3(dco, co);
-        mul_v3m3_dq(dco, (vert_deform_mats) ? summat : NULL, dq);
-        sub_v3_v3(dco, co);
-        mul_v3_fl(dco, armature_weight);
-        add_v3_v3(co, dco);
-      }
-      else {
-        mul_v3m3_dq(co, (vert_deform_mats) ? summat : NULL, dq);
-      }
-
-      smat = summat;
-    }
-    else {
-      mul_v3_fl(vec, armature_weight / contrib);
-      add_v3_v3v3(co, vec, co);
-    }
-
-    if (vert_deform_mats) {
-      float pre[3][3], post[3][3], tmpmat[3][3];
-
-      copy_m3_m4(pre, data->premat);
-      copy_m3_m4(post, data->postmat);
-      copy_m3_m3(tmpmat, vert_deform_mats[i]);
-
-      if (!use_quaternion) { /* quaternion already is scale corrected */
-        mul_m3_fl(smat, armature_weight / contrib);
-      }
-
-      mul_m3_series(vert_deform_mats[i], post, smat, pre, tmpmat);
-    }
-  }
-
-  /* always, check above code */
-  mul_m4_v3(data->postmat, co);
-
-  /* interpolate with previous modifier position using weight group */
-  if (vert_coords_prev) {
-    float mw = 1.0f - prevco_weight;
-    vert_coords[i][0] = prevco_weight * vert_coords[i][0] + mw * co[0];
-    vert_coords[i][1] = prevco_weight * vert_coords[i][1] + mw * co[1];
-    vert_coords[i][2] = prevco_weight * vert_coords[i][2] + mw * co[2];
-  }
-}
-
-static void armature_deform_coords_impl(Object *ob_arm,
-                                        Object *ob_target,
-                                        float (*vert_coords)[3],
-                                        float (*vert_deform_mats)[3][3],
-                                        const int vert_coords_len,
-                                        const int deformflag,
-                                        float (*vert_coords_prev)[3],
-                                        const char *defgrp_name,
-                                        const Mesh *me_target,
-                                        bGPDstroke *gps_target)
-{
-  bArmature *arm = ob_arm->data;
-  bPoseChannel **pchan_from_defbase = NULL;
-  const MDeformVert *dverts = NULL;
-  bDeformGroup *dg;
-  const bool use_envelope = (deformflag & ARM_DEF_ENVELOPE) != 0;
-  const bool use_quaternion = (deformflag & ARM_DEF_QUATERNION) != 0;
-  const bool invert_vgroup = (deformflag & ARM_DEF_INVERT_VGROUP) != 0;
-  int defbase_len = 0;   /* safety for vertexgroup index overflow */
-  int i, dverts_len = 0; /* safety for vertexgroup overflow */
-  bool use_dverts = false;
-  int armature_def_nr;
-
-  /* in editmode, or not an armature */
-  if (arm->edbo || (ob_arm->pose == NULL)) {
-    return;
-  }
-
-  if ((ob_arm->pose->flag & POSE_RECALC) != 0) {
-    CLOG_ERROR(&LOG,
-               "Trying to evaluate influence of armature '%s' which needs Pose recalc!",
-               ob_arm->id.name);
-    BLI_assert(0);
-  }
-
-  /* get the def_nr for the overall armature vertex group if present */
-  armature_def_nr = BKE_object_defgroup_name_index(ob_target, defgrp_name);
-
-  if (ELEM(ob_target->type, OB_MESH, OB_LATTICE, OB_GPENCIL)) {
-    defbase_len = BLI_listbase_count(&ob_target->defbase);
-
-    if (ob_target->type == OB_MESH) {
-      Mesh *me = ob_target->data;
-      dverts = me->dvert;
-      if (dverts) {
-        dverts_len = me->totvert;
-      }
-    }
-    else if (ob_target->type == OB_LATTICE) {
-      Lattice *lt = ob_target->data;
-      dverts = lt->dvert;
-      if (dverts) {
-        dverts_len = lt->pntsu * lt->pntsv * lt->pntsw;
-      }
-    }
-    else if (ob_target->type == OB_GPENCIL) {
-      dverts = gps_target->dvert;
-      if (dverts) {
-        dverts_len = gps_target->totpoints;
-      }
-    }
-  }
-
-  /* get a vertex-deform-index to posechannel array */
-  if (deformflag & ARM_DEF_VGROUP) {
-    if (ELEM(ob_target->type, OB_MESH, OB_LATTICE, OB_GPENCIL)) {
-      /* if we have a Mesh, only use dverts if it has them */
-      if (me_target) {
-        use_dverts = (me_target->dvert != NULL);
-      }
-      else if (dverts) {
-        use_dverts = true;
-      }
-
-      if (use_dverts) {
-        pchan_from_defbase = MEM_callocN(sizeof(*pchan_from_defbase) * defbase_len, "defnrToBone");
-        /* TODO(sergey): Some considerations here:
-         *
-         * - Check whether keeping this consistent across frames gives speedup.
-         */
-        for (i = 0, dg = ob_target->defbase.first; dg; i++, dg = dg->next) {
-          pchan_from_defbase[i] = BKE_pose_channel_find_name(ob_arm->pose, dg->name);
-          /* exclude non-deforming bones */
-          if (pchan_from_defbase[i]) {
-            if (pchan_from_defbase[i]->bone->flag & BONE_NO_DEFORM) {
-              pchan_from_defbase[i] = NULL;
-            }
-          }
-        }
-      }
-    }
-  }
-
-  ArmatureUserdata data = {
-      .ob_arm = ob_arm,
-      .ob_target = ob_target,
-      .me_target = me_target,
-      .vert_coords = vert_coords,
-      .vert_deform_mats = vert_deform_mats,
-      .vert_coords_prev = vert_coords_prev,
-      .use_envelope = use_envelope,
-      .use_quaternion = use_quaternion,
-      .invert_vgroup = invert_vgroup,
-      .use_dverts = use_dverts,
-      .armature_def_nr = armature_def_nr,
-      .dverts = dverts,
-      .dverts_len = dverts_len,
-      .pchan_from_defbase = pchan_from_defbase,
-      .defbase_len = defbase_len,
-  };
-
-  float obinv[4][4];
-  invert_m4_m4(obinv, ob_target->obmat);
-
-  mul_m4_m4m4(data.postmat, obinv, ob_arm->obmat);
-  invert_m4_m4(data.premat, data.postmat);
-
-  TaskParallelSettings settings;
-  BLI_parallel_range_settings_defaults(&settings);
-  settings.min_iter_per_thread = 32;
-  BLI_task_parallel_range(0, vert_coords_len, &data, armature_vert_task, &settings);
-
-  if (pchan_from_defbase) {
-    MEM_freeN(pchan_from_defbase);
-  }
-}
-
-void BKE_armature_deform_coords_with_gpencil_stroke(Object *ob_arm,
-                                                    Object *ob_target,
-                                                    float (*vert_coords)[3],
-                                                    float (*vert_deform_mats)[3][3],
-                                                    int vert_coords_len,
-                                                    int deformflag,
-                                                    float (*vert_coords_prev)[3],
-                                                    const char *defgrp_name,
-                                                    bGPDstroke *gps_target)
-{
-  armature_deform_coords_impl(ob_arm,
-                              ob_target,
-                              vert_coords,
-                              vert_deform_mats,
-                              vert_coords_len,
-                              deformflag,
-                              vert_coords_prev,
-                              defgrp_name,
-                              NULL,
-                              gps_target);
-}
-
-void BKE_armature_deform_coords_with_mesh(Object *ob_arm,
-                                          Object *ob_target,
-                                          float (*vert_coords)[3],
-                                          float (*vert_deform_mats)[3][3],
-                                          int vert_coords_len,
-                                          int deformflag,
-                                          float (*vert_coords_prev)[3],
-                                          const char *defgrp_name,
-                                          const Mesh *me_target)
-{
-  armature_deform_coords_impl(ob_arm,
-                              ob_target,
-                              vert_coords,
-                              vert_deform_mats,
-                              vert_coords_len,
-                              deformflag,
-                              vert_coords_prev,
-                              defgrp_name,
-                              me_target,
-                              NULL);
-}
-
-/** \} */
-
-/* -------------------------------------------------------------------- */
 /** \name Bone Space to Space Conversion API
  * \{ */