Page MenuHome
Differential D9410 Diff 30675 source/blender/blenkernel/intern/armature.c

Changeset View

Standalone View

View Options

source/blender/blenkernel/intern/armature.c

Show First 20 Lines • Show All 2,148 Lines • ▼ Show 20 Lines
* <pre> * <pre>
* ┌ z^2 - x^2, -2 * x * z ┐ * ┌ z^2 - x^2, -2 * x * z ┐
* M* = 1 / (x^2 + z^2) * │ │ * M* = 1 / (x^2 + z^2) * │ │
* └ -2 * x * z, x^2 - z^2 ┘ * └ -2 * x * z, x^2 - z^2 ┘
* </pre> * </pre>
*/ */
void vec_roll_to_mat3_normalized(const float nor[3], const float roll, float r_mat[3][3]) void vec_roll_to_mat3_normalized(const float nor[3], const float roll, float r_mat[3][3])
{ {
#define THETA_THRESHOLD_NEGY 1.0e-9f static const float THETA_CRITICAL = 1.0e-9f; // can not get closer to 0 for math stability
#define THETA_THRESHOLD_NEGY_CLOSE 1.0e-5f static const float THETA_SAFE = 1.0e-5f;
sybrenUnsubmitted
Done
Inline Actions

I think the change in name to "safe" and "critical" is really nice.

sybren: I think the change in name to "safe" and "critical" is really nice.
const float x = nor[0];
const float y = nor[1];
const float z = nor[2];
sybrenUnsubmitted
Done
Inline Actions

Any particular reason this is static? The good thing about #define is that it's all handled by the precompiler.

sybren: Any particular reason this is `static`? The good thing about `#define` is that it's all handled…
gaiaclaryAuthorUnsubmitted
Done
Inline Actions

Any particular reason this is static? The good thing about #define is that it's all handled by the precompiler.

maybe it was a misunderstanding from a comment from sergey. I removed the 'static'. I still prefer to have it a regular variable.

gaiaclary: > Any particular reason this is `static`? The good thing about `#define` is that it's all…
sybrenUnsubmitted
Done
Inline Actions

Comments in C files should be /* */ style.

sybren: Comments in C files should be `/* */` style.
sybrenUnsubmitted
Done
Inline Actions

Comments should be a full sentence, so start with capital and end with period.

sybren: Comments should be a full sentence, so start with capital and end with period.
float theta; float theta;
float theta_alt;
float rMatrix[3][3], bMatrix[3][3]; float rMatrix[3][3], bMatrix[3][3];
BLI_ASSERT_UNIT_V3(nor); BLI_ASSERT_UNIT_V3(nor);
theta = 1.0f + nor[1]; theta = 1.0f + y;
theta_alt = x * x + z * z;
sybrenUnsubmitted
Not Done
Inline Actions

Calculating theta_alt can be deferred to the else clause where it's actually used. Might save a few CPU ticks (although this might be optimized by the compiler as well).

sybren: Calculating `theta_alt` can be deferred to the `else` clause where it's actually used. Might…
gaiaclaryAuthorUnsubmitted
Done
Inline Actions

Calculating theta_alt can be deferred to the else clause where it's actually used. Might save a few CPU ticks (although this might be optimized by the compiler as well).

This is true for now, but when the bug fix is applied, then we need theta_alt already in the if clause.

gaiaclary: > Calculating `theta_alt` can be deferred to the `else` clause where it's actually used. Might…
sybrenUnsubmitted
Done
Inline Actions

These don't change value any more, so you can declare them as const:

const float theta = 1.0f + y;
const float theta_alt = x * x + z * z;
sybren: These don't change value any more, so you can declare them as `const`: ``` const float theta =…
/* With old algo, 1.0e-13f caused T23954 and T31333, 1.0e-6f caused T27675 and T30438, /* When theta is close to zero, we have to check we do have non-null X/Z components as well
sybrenUnsubmitted
Done
Inline Actions

Not for this patch, but this comment is a bit mind-boggling to me.

  1. Why does it matter what old code did when it's no longer around?
  2. Why is this comment saying it uses two different threshold values, when one of the two is actually the same as used before?
sybren: Not for this patch, but this comment is a bit mind-boggling to me. 1. Why does it matter what…
* so using 1.0e-9f as best compromise. * (due to float precision errors, we can have nor = (0.0, -0.99999994, 0.0)...).
sybrenUnsubmitted
Done
Inline Actions

Instead of

(due to float precision errors, we can have nor = (0.0, -0.99999994, 0.0)...).

I think it's nicer to remove the "..." and explain why this is a problem:

Due to float precision errors, nor can be (0.0, -0.99999994, 0.0) which results in theta being almost zero.
This will cause problems when used as divisor.

sybren: Instead of > (due to float precision errors, we can have nor = (0.0, -0.99999994, 0.0)...).
*
* New algo is supposed much more precise, since less complex computations are performed,
* but it uses two different threshold values...
*
* Note: When theta is close to zero, we have to check we do have non-null X/Z components as well
* (due to float precision errors, we can have nor = (0.0, 0.99999994, 0.0)...).
*/ */
if (theta > THETA_THRESHOLD_NEGY_CLOSE || ((nor[0] || nor[2]) && theta > THETA_THRESHOLD_NEGY)) { if (theta > THETA_SAFE || (theta_alt > THETA_CRITICAL && theta > THETA_CRITICAL)) {
/* nor is *not* -Y. /* nor is *not* -Y.
sybrenUnsubmitted
Done
Inline Actions

Instead of -Y I think not (0, -1, 0) is clearer. Or "the -Y vector", whichever you prefer.

sybren: Instead of `-Y` I think `not (0, -1, 0)` is clearer. Or "the -Y vector", whichever you prefer.
* We got these values for free... so be happy with it... ;) * We got these values for free... so be happy with it... ;)
*/ */
bMatrix[0][1] = -nor[0];
bMatrix[1][0] = nor[0]; bMatrix[0][1] = -x;
bMatrix[1][1] = nor[1]; bMatrix[1][0] = x;
bMatrix[1][2] = nor[2]; bMatrix[1][1] = y;
bMatrix[2][1] = -nor[2]; bMatrix[1][2] = z;
if (theta > THETA_THRESHOLD_NEGY_CLOSE) { bMatrix[2][1] = -z;
/* If nor is far enough from -Y, apply the general case. */
bMatrix[0][0] = 1 - nor[0] * nor[0] / theta; if (theta > THETA_SAFE) {
bMatrix[2][2] = 1 - nor[2] * nor[2] / theta; /* nor differs significantly from -Y: apply the general case. */
bMatrix[2][0] = bMatrix[0][2] = -nor[0] * nor[2] / theta; bMatrix[0][0] = 1 - x * x / theta;
bMatrix[2][2] = 1 - z * z / theta;
bMatrix[2][0] = bMatrix[0][2] = -x * z / theta;
} }
else { else {
/* If nor is too close to -Y, apply the special case. */ /* nor is close to -Y: apply the special case. */
theta = nor[0] * nor[0] + nor[2] * nor[2]; bMatrix[0][0] = (x + z) * (x - z) / -theta_alt;
bMatrix[0][0] = (nor[0] + nor[2]) * (nor[0] - nor[2]) / -theta;
bMatrix[2][2] = -bMatrix[0][0]; bMatrix[2][2] = -bMatrix[0][0];
bMatrix[2][0] = bMatrix[0][2] = 2.0f * nor[0] * nor[2] / theta; bMatrix[2][0] = bMatrix[0][2] = 2.0f * x * z / theta_alt;
} }
} }
else { else {
/* If nor is -Y, simple symmetry by Z axis. */ /* nor is -Y or very close to -Y: use simple symmetry by Z axis. */
sybrenUnsubmitted
Done
Inline Actions

"very close to" includes "at zero distance", so "nor is very close to -Y" is enough.

sybren: "very close to" includes "at zero distance", so "nor is very close to -Y" is enough.
unit_m3(bMatrix); unit_m3(bMatrix);
bMatrix[0][0] = bMatrix[1][1] = -1.0; bMatrix[0][0] = bMatrix[1][1] = -1.0;
} }
/* Make Roll matrix */ /* Make Roll matrix */
axis_angle_normalized_to_mat3(rMatrix, nor, roll); axis_angle_normalized_to_mat3(rMatrix, nor, roll);
/* Combine and output result */ /* Combine and output result */
mul_m3_m3m3(r_mat, rMatrix, bMatrix); mul_m3_m3m3(r_mat, rMatrix, bMatrix);
#undef THETA_THRESHOLD_NEGY
#undef THETA_THRESHOLD_NEGY_CLOSE
} }
void vec_roll_to_mat3(const float vec[3], const float roll, float r_mat[3][3]) void vec_roll_to_mat3(const float vec[3], const float roll, float r_mat[3][3])
{ {
float nor[3]; float nor[3];
normalize_v3_v3(nor, vec); normalize_v3_v3(nor, vec);
vec_roll_to_mat3_normalized(nor, roll, r_mat); vec_roll_to_mat3_normalized(nor, roll, r_mat);
▲ Show 20 Lines • Show All 701 Lines • Show Last 20 Lines