Page MenuHome
Differential D4635 Diff 14639 source/blender/blenkernel/intern/armature.c

Changeset View

Standalone View

View Options

source/blender/blenkernel/intern/armature.c

Context not available.
} }
} }
static int pchan_bbone_spline_compute(BBoneSplineParameters *param, const float h1[3], float roll1, const float h2[3], float roll2, Mat4 *result_array)
{
float scalemat[4][4], iscalemat[4][4];
float mat3[3][3];
float vec[3];
float data[MAX_BBONE_SUBDIV + 1][4], *fp;
float length = param->length;
float seg_frac = 1.0f / (float)param->segments;
int a;
if (param->do_scale) {
size_to_mat4(scalemat, param->scale);
invert_m4_m4(iscalemat, scalemat);
length *= param->scale[1];
}
/* Make curve. */
CLAMP_MAX(param->segments, MAX_BBONE_SUBDIV);
BKE_curve_forward_diff_bezier(0.0f, h1[0], h2[0], 0.0f, data[0], MAX_BBONE_SUBDIV, 4 * sizeof(float));
BKE_curve_forward_diff_bezier(0.0f, h1[1], length + h2[1], length, data[0] + 1, MAX_BBONE_SUBDIV, 4 * sizeof(float));
BKE_curve_forward_diff_bezier(0.0f, h1[2], h2[2], 0.0f, data[0] + 2, MAX_BBONE_SUBDIV, 4 * sizeof(float));
BKE_curve_forward_diff_bezier(roll1, roll1 + 0.390464f * (roll2 - roll1), roll2 - 0.390464f * (roll2 - roll1), roll2, data[0] + 3, MAX_BBONE_SUBDIV, 4 * sizeof(float));
equalize_bbone_bezier(data[0], param->segments); /* note: does stride 4! */
/* Make transformation matrices for the segments for drawing. */
for (a = 0, fp = data[0]; a < param->segments; a++, fp += 4) {
sub_v3_v3v3(vec, fp + 4, fp);
vec_roll_to_mat3(vec, fp[3], mat3); /* fp[3] is roll */
copy_m4_m3(result_array[a].mat, mat3);
copy_v3_v3(result_array[a].mat[3], fp);
if (param->do_scale) {
/* Correct for scaling when this matrix is used in scaled space. */
mul_m4_series(result_array[a].mat, iscalemat, result_array[a].mat, scalemat);
}
/* BBone scale... */
{
const float scaleFacBlend = seg_frac * (0.5f + (float)a);
const float scalefac = (1.0f - scaleFacBlend) * param->scaleIn + scaleFacBlend * param->scaleOut;
float bscalemat[4][4], bscale[3];
bscale[0] = scalefac;
bscale[1] = 1.0f;
bscale[2] = scalefac;
size_to_mat4(bscalemat, bscale);
/* Note: don't multiply by inverse scale mat here, as it causes problems with scaling shearing and breaking segment chains */
/*mul_m4_series(result_array[a].mat, ibscalemat, result_array[a].mat, bscalemat);*/
mul_m4_series(result_array[a].mat, result_array[a].mat, bscalemat);
}
}
return param->segments;
}
static void pchan_bbone_spline_setup(bPoseChannel *pchan, const bool rest, BBoneSplineParameters *param, float h1[3], float *roll1, float h2[3], float *roll2, Mat4 *result_array)
{
BKE_pchan_bbone_spline_params_get(pchan, rest, param);
BKE_pchan_bbone_handles_compute(param, h1, roll1, h2, roll2, true, true);
pchan->bone->segments = pchan_bbone_spline_compute(param, h1, *roll1, h2, *roll2, result_array);
}
/* Fills the array with the desired amount of bone->segments elements. /* Fills the array with the desired amount of bone->segments elements.
* This calculation is done within unit bone space. */ * This calculation is done within unit bone space. */
void BKE_pchan_bbone_spline_setup(bPoseChannel *pchan, const bool rest, Mat4 result_array[MAX_BBONE_SUBDIV]) void BKE_pchan_bbone_spline_setup(bPoseChannel *pchan, const bool rest, Mat4 result_array[MAX_BBONE_SUBDIV])
{ {
BBoneSplineParameters param; BBoneSplineParameters param;
float h1[3], roll1, h2[3], roll2;
BKE_pchan_bbone_spline_params_get(pchan, rest, &param); pchan_bbone_spline_setup(pchan, rest, &param, h1, &roll1, h2, &roll2, result_array);
pchan->bone->segments = BKE_pchan_bbone_spline_compute(&param, result_array);
} }
/* Computes the bezier handle vectors and rolls coming from custom handles. */ /* Computes the bezier handle vectors and rolls coming from custom handles. */
Context not available.
} }
/* Fills the array with the desired amount of bone->segments elements. /* Fills the array with the desired amount of bone->segments elements.
* This calculation is done within unit bone space. */ * This calculation is done within unit bone space. */
int BKE_pchan_bbone_spline_compute(BBoneSplineParameters *param, Mat4 result_array[MAX_BBONE_SUBDIV]) int BKE_pchan_bbone_spline_compute(BBoneSplineParameters *param, Mat4 result_array[MAX_BBONE_SUBDIV])
{ {
float scalemat[4][4], iscalemat[4][4];
float mat3[3][3];
float h1[3], roll1, h2[3], roll2; float h1[3], roll1, h2[3], roll2;
float data[MAX_BBONE_SUBDIV + 1][4], *fp;
float length = param->length;
int a;
if (param->do_scale) {
size_to_mat4(scalemat, param->scale);
invert_m4_m4(iscalemat, scalemat);
length *= param->scale[1];
}
BKE_pchan_bbone_handles_compute(param, h1, &roll1, h2, &roll2, true, true); BKE_pchan_bbone_handles_compute(param, h1, &roll1, h2, &roll2, true, true);
return pchan_bbone_spline_compute(param, h1, roll1, h2, roll2, result_array);
/* Make curve. */
CLAMP_MAX(param->segments, MAX_BBONE_SUBDIV);
BKE_curve_forward_diff_bezier(0.0f, h1[0], h2[0], 0.0f, data[0], MAX_BBONE_SUBDIV, 4 * sizeof(float));
BKE_curve_forward_diff_bezier(0.0f, h1[1], length + h2[1], length, data[0] + 1, MAX_BBONE_SUBDIV, 4 * sizeof(float));
BKE_curve_forward_diff_bezier(0.0f, h1[2], h2[2], 0.0f, data[0] + 2, MAX_BBONE_SUBDIV, 4 * sizeof(float));
BKE_curve_forward_diff_bezier(roll1, roll1 + 0.390464f * (roll2 - roll1), roll2 - 0.390464f * (roll2 - roll1), roll2, data[0] + 3, MAX_BBONE_SUBDIV, 4 * sizeof(float));
equalize_bbone_bezier(data[0], param->segments); /* note: does stride 4! */
/* Make transformation matrices for the segments for drawing. */
for (a = 0, fp = data[0]; a < param->segments; a++, fp += 4) {
sub_v3_v3v3(h1, fp + 4, fp);
vec_roll_to_mat3(h1, fp[3], mat3); /* fp[3] is roll */
copy_m4_m3(result_array[a].mat, mat3);
copy_v3_v3(result_array[a].mat[3], fp);
if (param->do_scale) {
/* Correct for scaling when this matrix is used in scaled space. */
mul_m4_series(result_array[a].mat, iscalemat, result_array[a].mat, scalemat);
}
/* BBone scale... */
{
const int num_segments = param->segments;
const float scaleIn = param->scaleIn;
const float scaleFactorIn = 1.0f + (scaleIn - 1.0f) * ((float)(num_segments - a) / (float)num_segments);
const float scaleOut = param->scaleOut;
const float scaleFactorOut = 1.0f + (scaleOut - 1.0f) * ((float)(a + 1) / (float)num_segments);
const float scalefac = scaleFactorIn * scaleFactorOut;
float bscalemat[4][4], bscale[3];
bscale[0] = scalefac;
bscale[1] = 1.0f;
bscale[2] = scalefac;
size_to_mat4(bscalemat, bscale);
/* Note: don't multiply by inverse scale mat here, as it causes problems with scaling shearing and breaking segment chains */
/*mul_m4_series(result_array[a].mat, ibscalemat, result_array[a].mat, bscalemat);*/
mul_m4_series(result_array[a].mat, result_array[a].mat, bscalemat);
}
}
return param->segments;
} }
/* ************ Armature Deform ******************* */ /* ************ Armature Deform ******************* */
Context not available.
runtime->bbone_segments = segments; runtime->bbone_segments = segments;
runtime->bbone_rest_mats = MEM_malloc_arrayN(sizeof(Mat4), (uint)segments, "bPoseChannel_Runtime::bbone_rest_mats"); runtime->bbone_rest_mats = MEM_malloc_arrayN(sizeof(Mat4), (uint)segments, "bPoseChannel_Runtime::bbone_rest_mats");
runtime->bbone_pose_mats = MEM_malloc_arrayN(sizeof(Mat4), (uint)segments, "bPoseChannel_Runtime::bbone_pose_mats"); runtime->bbone_pose_mats = MEM_malloc_arrayN(sizeof(Mat4), (uint)segments, "bPoseChannel_Runtime::bbone_pose_mats");
runtime->bbone_deform_mats = MEM_malloc_arrayN(sizeof(Mat4), 1 + (uint)segments, "bPoseChannel_Runtime::bbone_deform_mats"); runtime->bbone_deform_mats = MEM_malloc_arrayN(sizeof(Mat4), 3 + (uint)segments, "bPoseChannel_Runtime::bbone_deform_mats");
runtime->bbone_dual_quats = MEM_malloc_arrayN(sizeof(DualQuat), (uint)segments, "bPoseChannel_Runtime::bbone_dual_quats"); runtime->bbone_dual_quats = MEM_malloc_arrayN(sizeof(DualQuat), 2 + (uint)segments, "bPoseChannel_Runtime::bbone_dual_quats");
} }
} }
static void calculate_bbone_endpoint_deform(
const float bone_mat[4][4], const float bone_arm_mat[4][4], const float pose_arm_mat[4][4],
const float rest_vec[3], float rest_roll, const float pose_vec[3], float pose_roll, float y, float scale,
float deform_mat[4][4], DualQuat *deform_quat)
{
float m33_1[3][3], m33_2[3][3];
float m44_1[4][4], m44_2[4][4];
float scale_mat[3][3];
vec_roll_to_mat3(rest_vec, rest_roll, m33_1);
copy_m4_m3(m44_1, m33_1);
m44_1[3][1] = y;
invert_m4_m4(m44_2, m44_1);
unit_m3(scale_mat);
scale_mat[0][0] = scale;
scale_mat[2][2] = scale;
vec_roll_to_mat3(pose_vec, pose_roll, m33_1);
mul_m3_m3m3(m33_2, m33_1, scale_mat);
copy_m4_m3(m44_1, m33_2);
m44_1[3][1] = y;
/* Transform composition is as follows:
* - global to bone space
* - to rest handle space
* - to pose handle space
* - to global space */
mul_m4_series(deform_mat, pose_arm_mat, m44_1, m44_2, bone_mat);
mat4_to_dquat(deform_quat, bone_arm_mat, deform_mat);
}
/** Compute and cache the B-Bone shape in the channel runtime struct. */ /** Compute and cache the B-Bone shape in the channel runtime struct. */
void BKE_pchan_bbone_segments_cache_compute(bPoseChannel *pchan) void BKE_pchan_bbone_segments_cache_compute(bPoseChannel *pchan)
{ {
bPoseChannel_Runtime *runtime = &pchan->runtime;
Bone *bone = pchan->bone; Bone *bone = pchan->bone;
int segments = bone->segments; int segments = bone->segments;
Context not available.
allocate_bbone_cache(pchan, segments); allocate_bbone_cache(pchan, segments);
/* Compute the shape. */ /* Compute the shape. */
Mat4 *b_bone = runtime->bbone_pose_mats; BBoneSplineParameters param;
Mat4 *b_bone_rest = runtime->bbone_rest_mats; bPoseChannel_Runtime *runtime = &pchan->runtime;
Mat4 *b_bone_mats = runtime->bbone_deform_mats; Mat4 *pose_mats = runtime->bbone_pose_mats;
DualQuat *b_bone_dual_quats = runtime->bbone_dual_quats; Mat4 *rest_mats = runtime->bbone_rest_mats;
Mat4 *deform_mats = runtime->bbone_deform_mats;
DualQuat *deform_quats = runtime->bbone_dual_quats;
int a; int a;
float mat[4][4];
BKE_pchan_bbone_spline_setup(pchan, false, b_bone); float rest_h1[3], rest_roll1;
BKE_pchan_bbone_spline_setup(pchan, true, b_bone_rest); float rest_h2[3], rest_roll2;
/* Compute deform matrices. */ float pose_h1[3], pose_roll1;
/* first matrix is the inverse arm_mat, to bring points in local bone space float pose_h2[3], pose_roll2;
* for finding out which segment it belongs to */
invert_m4_m4(b_bone_mats[0].mat, bone->arm_mat);
/* then we make the b_bone_mats:
* - first transform to local bone space
* - translate over the curve to the bbone mat space
* - transform with b_bone matrix
* - transform back into global space */
for (a = 0; a < bone->segments; a++) { /* Order of function calls is important, because param needs pose (not rest) parameters. */
float tmat[4][4]; pchan_bbone_spline_setup(pchan, true, &param, rest_h1, &rest_roll1, rest_h2, &rest_roll2, rest_mats);
pchan_bbone_spline_setup(pchan, false, &param, pose_h1, &pose_roll1, pose_h2, &pose_roll2, pose_mats);
invert_m4_m4(tmat, b_bone_rest[a].mat); /* Second handle's vector must be flipped to produce correct transform blending. */
mul_m4_series(b_bone_mats[a + 1].mat, pchan->chan_mat, bone->arm_mat, b_bone[a].mat, tmat, b_bone_mats[0].mat); negate_v3(pose_h2);
negate_v3(rest_h2);
mat4_to_dquat(&b_bone_dual_quats[a], bone->arm_mat, b_bone_mats[a + 1].mat); /* Compute deform matrices. */
/* first matrix is the inverse arm_mat, to bring points in local bone space
* for finding out which segment it belongs to */
invert_m4_m4(deform_mats[0].mat, bone->arm_mat);
/* Create deform_mats as follows:
* - transform from global to bone space
* - to rest segment space
* - to pose segment space
* - to global space */
for (a = 0; a < segments; ++a) {
invert_m4_m4(mat, rest_mats[a].mat);
mul_m4_series(deform_mats[a + 1].mat, pchan->pose_mat, pose_mats[a].mat, mat, deform_mats[0].mat);
mat4_to_dquat(&deform_quats[a], bone->arm_mat, deform_mats[a + 1].mat);
}
/* Compute deform transforms for bone endpoints.
* Store them after segment transforms in deform_mats and deform_quats. */
angavrilovAuthorUnsubmitted
Done
Inline Actions

There is a whole library of matrix math functions, I'm sure there's something suitable there for this.

angavrilov: There is a whole library of matrix math functions, I'm sure there's something suitable there…
calculate_bbone_endpoint_deform(
deform_mats[0].mat, bone->arm_mat, pchan->pose_mat,
rest_h1, rest_roll1, pose_h1, pose_roll1, 0.0f, param.scaleIn,
deform_mats[segments + 1].mat, &deform_quats[segments]);
calculate_bbone_endpoint_deform(
deform_mats[0].mat, bone->arm_mat, pchan->pose_mat,
rest_h2, rest_roll2, pose_h2, pose_roll2, param.length, param.scaleOut,
deform_mats[segments + 2].mat, &deform_quats[segments + 1]);
/* HACK: If there is any scaling involved, make sure that all quats have a scale and scale_weight set,
* otherwise add_weighted_dq_dq function will produce wrong results. */
if (param.scaleIn != 1.0f || param.scaleOut != 1.0f) {
int quat_count = segments + 2;
for (a = 0; a < quat_count; ++a) {
if (deform_quats[a].scale_weight == 0.0f) {
deform_quats[a].scale_weight = 1.0f;
unit_m4(deform_quats[a].scale);
}
}
} }
} }
Context not available.
memcpy(runtime->bbone_rest_mats, runtime_from->bbone_rest_mats, sizeof(Mat4) * segments); memcpy(runtime->bbone_rest_mats, runtime_from->bbone_rest_mats, sizeof(Mat4) * segments);
memcpy(runtime->bbone_pose_mats, runtime_from->bbone_pose_mats, sizeof(Mat4) * segments); memcpy(runtime->bbone_pose_mats, runtime_from->bbone_pose_mats, sizeof(Mat4) * segments);
memcpy(runtime->bbone_deform_mats, runtime_from->bbone_deform_mats, sizeof(Mat4) * (1 + segments)); memcpy(runtime->bbone_deform_mats, runtime_from->bbone_deform_mats, sizeof(Mat4) * (3 + segments));
memcpy(runtime->bbone_dual_quats, runtime_from->bbone_dual_quats, sizeof(DualQuat) * segments); memcpy(runtime->bbone_dual_quats, runtime_from->bbone_dual_quats, sizeof(DualQuat) * (2 + segments));
}
}
static void b_bone_deform_by_one_segment(const DualQuat *seg_dq, const float seg_mat[4][4], float co[3], DualQuat *dq, float defmat[3][3])
{
if (dq) {
copy_dq_dq(dq, seg_dq);
}
else {
mul_m4_v3(seg_mat, co);
if (defmat) {
copy_m3_m4(defmat, seg_mat);
}
}
}
static void b_bone_deform_by_two_segments(const DualQuat *seg1_dq, const DualQuat *seg2_dq, const float seg1_mat[4][4], const float seg2_mat[4][4], float blend, float co[3], DualQuat *dq, float defmat[3][3])
{
if (dq) {
/* Interpolate dual quats. */
memset(dq, 0, sizeof(DualQuat));
add_weighted_dq_dq(dq, seg1_dq, 1.0f - blend);
add_weighted_dq_dq(dq, seg2_dq, blend);
}
else {
/* Linearly interpolate matrices. */
float m[4][4];
linear_blend_m4_m4m4(m, seg1_mat, seg2_mat, blend);
mul_m4_v3(m, co);
if (defmat) {
copy_m3_m4(defmat, m);
}
} }
} }
static void b_bone_deform(const bPoseChannel *pchan, float co[3], DualQuat *dq, float defmat[3][3]) static void b_bone_deform(const bPoseChannel *pchan, float co[3], DualQuat *dq, float defmat[3][3])
{ {
Bone *bone = pchan->bone; Bone *bone = pchan->bone;
const Mat4 *b_bone = pchan->runtime.bbone_deform_mats; const DualQuat *quats = pchan->runtime.bbone_dual_quats;
const float (*mat)[4] = b_bone[0].mat; const Mat4 *mats = pchan->runtime.bbone_deform_mats;
float segment, y; const float (*mat)[4] = mats[0].mat;
int a; float blend, y;
int segments = bone->segments;
int seg_index;
/* need to transform co back to bonespace, only need y */ /* 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]; y = mat[0][1] * co[0] + mat[1][1] * co[1] + mat[2][1] * co[2] + mat[3][1];
/* now calculate which of the b_bones are deforming this */ /* Calculate the indices of the 2 affecting b_bone segments.
segment = bone->length / ((float)bone->segments); * Integer part is the first segment's index.
a = (int)(y / segment); * Integer part plus 1 is the second segment's index.
* Fractional part is the blend factor. */
/* note; by clamping it extends deform at endpoints, goes best with blend = (y / bone->length) * (float)segments - 0.5f;
* straight joints in restpos. */
CLAMP(a, 0, bone->segments - 1);
if (dq) { if (blend <= -0.5f) {
copy_dq_dq(dq, &(pchan->runtime.bbone_dual_quats)[a]); /* Deform by first endpoint. */
b_bone_deform_by_one_segment(&quats[segments], mats[segments + 1].mat, co, dq, defmat);
}
else if (blend <= 0.0f) {
/* Blend deform between first endpoint and first segment. */
blend = (blend + 0.5f) * 2.0f;
b_bone_deform_by_two_segments(&quats[segments], &quats[0], mats[segments + 1].mat, mats[1].mat, blend, co, dq, defmat);
}
else if (blend >= (float)(segments) - 0.5f) {
/* Deform by second endpoint. */
b_bone_deform_by_one_segment(&quats[segments + 1], mats[segments + 2].mat, co, dq, defmat);
}
else if (blend >= (float)(segments - 1)) {
/* Blend deform between last segment and second endpoint. */
blend = (blend - (float)(segments - 1)) * 2.0f;
b_bone_deform_by_two_segments(&quats[segments - 1], &quats[segments + 1], mats[segments].mat, mats[segments + 2].mat, blend, co, dq, defmat);
} }
else { else {
mul_m4_v3(b_bone[a + 1].mat, co); /* Blend deform between two segments. */
seg_index = (int)blend;
if (defmat) { blend -= (float)seg_index;
copy_m3_m4(defmat, b_bone[a + 1].mat); b_bone_deform_by_two_segments(&quats[seg_index], &quats[seg_index + 1], mats[seg_index + 1].mat, mats[seg_index + 2].mat, blend, co, dq, defmat);
}
} }
} }
Context not available.