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

Changeset View

Standalone View

View Options

source/blender/blenkernel/intern/armature.c

Context not available.
} }
} }
/* Fills the array with the desired amount of bone->segments elements. static int pchan_bbone_spline_compute(BBoneSplineParameters *param, const float h1[3], float roll1, const float h2[3], float roll2, Mat4 *result_array)
* 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])
{ {
BBoneSplineParameters param; 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;
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 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;
}
static void pchan_bbone_spline_setup(bPoseChannel *pchan, float h1[3], float *roll1, float h2[3], float *roll2, const bool rest, Mat4 *result_array)
{
BBoneSplineParameters param;
BKE_pchan_bbone_spline_params_get(pchan, rest, &param); 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);
}
pchan->bone->segments = BKE_pchan_bbone_spline_compute(&param, result_array); /* Fills the array with the desired amount of bone->segments elements.
* 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])
{
float h1[3], roll1, h2[3], roll2;
pchan_bbone_spline_setup(pchan, h1, &roll1, h2, &roll2, rest, 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");
} }
} }
Context not available.
Mat4 *b_bone_mats = runtime->bbone_deform_mats; Mat4 *b_bone_mats = runtime->bbone_deform_mats;
DualQuat *b_bone_dual_quats = runtime->bbone_dual_quats; DualQuat *b_bone_dual_quats = runtime->bbone_dual_quats;
int a; int a;
float pose_h[2][3], pose_roll[2];
float rest_h[2][3], rest_roll[2];
float m4x4[3][4][4], m3x3[3][3];
pchan_bbone_spline_setup(pchan, pose_h[0], &pose_roll[0], pose_h[1], &pose_roll[1], false, b_bone);
pchan_bbone_spline_setup(pchan, rest_h[0], &rest_roll[0], rest_h[1], &rest_roll[1], true, b_bone_rest);
BKE_pchan_bbone_spline_setup(pchan, false, b_bone); /* Negate second endpoint's handle vectors. */
BKE_pchan_bbone_spline_setup(pchan, true, b_bone_rest); negate_v3(pose_h[1]);
negate_v3(rest_h[1]);
/* Compute deform matrices. */ /* Compute deform matrices. */
/* first matrix is the inverse arm_mat, to bring points in local bone space /* first matrix is the inverse arm_mat, to bring points in local bone space
Context not available.
* - transform with b_bone matrix * - transform with b_bone matrix
* - transform back into global space */ * - transform back into global space */
for (a = 0; a < bone->segments; a++) { mul_m4_m4m4(m4x4[0], pchan->chan_mat, bone->arm_mat);
float tmat[4][4];
invert_m4_m4(tmat, b_bone_rest[a].mat); for (a = 0; a < segments; a++) {
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); invert_m4_m4(m4x4[1], b_bone_rest[a].mat);
mul_m4_series(b_bone_mats[a + 1].mat, m4x4[0], b_bone[a].mat, m4x4[1], b_bone_mats[0].mat);
mat4_to_dquat(&b_bone_dual_quats[a], bone->arm_mat, b_bone_mats[a + 1].mat); mat4_to_dquat(&b_bone_dual_quats[a], bone->arm_mat, b_bone_mats[a + 1].mat);
} }
/* Compute deform transforms for bone endpoints.
* Store them after segment transforms in b_bone_mats and b_bone_dual_quats. */
float y[2] = { 0.0f, bone->length };
for (a = 0; a < 2; a++) {
vec_roll_to_mat3(rest_h[a], rest_roll[a], m3x3);
copy_m4_m3(m4x4[1], m3x3);
m4x4[1][3][1] = y[a];
invert_m4_m4(m4x4[2], m4x4[1]);
vec_roll_to_mat3(pose_h[a], pose_roll[a], m3x3);
copy_m4_m3(m4x4[1], m3x3);
m4x4[1][3][1] = y[a];
mul_m4_series(b_bone_mats[segments + a + 1].mat, m4x4[0], m4x4[1], m4x4[2], b_bone_mats[0].mat);
mat4_to_dquat(&b_bone_dual_quats[segments + a], bone->arm_mat, b_bone_mats[segments + a + 1].mat);
}
} }
/** Copy cached B-Bone segments from one channel to another */ /** Copy cached B-Bone segments from one channel to another */
Context not available.
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…
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.