Ce site est optimisé pour être consulté depuis un navigateur moderne dans lequel JavaScript est activé.

spBone_worldToLocal confusion

jdtec86

I'm trying to do a very similar thing to what milos1290 was attempting in this thread viewtopic.php?f=7&t=3952

But it's not working for all bones for me.

Additionally, I've seen that I can pass in world coordinates and get different local coordinates when compared with the bone->x and bone->y locals coords.

When passing in the bone->x and bone->y I get the expected world coordinates! These two functions don't appear to be symmetrical!?

spBone_localToWorld (bone->parent, bone->x, bone->y, &worldX, &worldY);

spBone_worldToLocal (bone->parent, worldX, worldY, &localX, &localY);

The second function produces different localX and localY to bone->x and bone->y.

Why is this wrong? How are these functions expected to be called? It would be helpful if the parameter names for the bone had something other than 'self' too. It was not immediately obvious that I should pass in the parent bone.

Thanks
Jon

jpoag

Starting at: Bone.c :: spBone_worldToLocal (Line 113)

Lines 122 & 123:

*localX = (dx * m00 * invDet - dy * self->m01 * invDet);
*localY = (dy * m11 * invDet - dx * self->m10 * invDet);

might probably be:

*localX = (dx * m11 * invDet - dy * self->m01 * invDet);
*localY = (dy * m00 * invDet - dx * self->m10 * invDet);

Because m00 and m11 should be swapped in an inverse matrix. See https://www.mathsisfun.com/algebra/matrix-inverse.html

void spBone_worldToLocal (spBone* self, float worldX, float worldY, float* localX, float* localY) {
   float invDet;
   float dx = worldX - self->worldX, dy = worldY - self->worldY;
   float m00 = self->m00, m11 = self->m11;
   if (self->worldFlipX != (self->worldFlipY != yDown)) { // comment [1]
      m00 *= -1;
      m11 *= -1;
   }
   invDet = 1 / (m00 * m11 - self->m01 * self->m10); 
   *localX = (dx * m00 * invDet - dy * self->m01 * invDet);
   *localY = (dy * m11 * invDet - dx * self->m10 * invDet);
}

void spBone_localToWorld (spBone* self, float localX, float localY, float* worldX, float* worldY) {
   *worldX = localX * self->m00 + localY * self->m01 + self->worldX;
   *worldY = localX * self->m10 + localY * self->m11 + self->worldY;
}

I haven't fully inspected the implications of flipping the signs of m00 and m11 as is done on lines 117-119 as the spBone_localToWorld doesn't seem to do this when computing world coordinates. That implies that the bone matrix might already take this into account (see spBone_updateWorldTransform).

jdtec86

Thanks a lot for investigating this, jpoag. Your new version produces the correct result!

I wonder if this qualifies as a bug if they are taking this into account elsewhere already. It is certainly very confusing from an API perspective since those functions are not symmetrical but perhaps they have their internal reasons for doing it like that?

jpoag

The inverse multiplication is clever code that uses some tricks. What I imagined is that someone copied and pasted code for normal matrix multiplication and then started modifying it. (E.g. subtracting instead of multiplying m10 and m01 by negative, multiplying all the terms by the inverse of the determinant instead of computing each term separately, etc...)

As for the flip? doesn't affect the determinant calculation as the signs cancel, not sure the total implications. Seems like if the image is flipped on the X axis, it gives you the not-flipped X.