Thank you for your answere.
I implemented your code and got almost the result i hoped for.
There is one problem:
I have a plane-modell and i calculate the axes for direction-vector,
up-vector and side-vector in a way that i get an orthogonal coordinate
system. To rotate the plane from origin into this coordinate-system i
use your method implemented as shown beneath.
This works well except if the planes-direction is the same as the
world-x-axis and the up vector is (0, -1, 0) - than that the plane is
rotated around his direction vector 180 degrees. Than instead of
pointing as expected in the same direction, it ist turned around
pointing to the oposite direction.
The method fails in some other situations too. I'm not sure on which
vector it depends.
I could solve my problem using the method posted from Gerrit Voss on
02/28/08 and 03/04/08.
But i am interested why this method is not working.
OSG::Quaternion Mathematic::lookAt(OSG::Vec3f direction_new, OSG::Vec3f
up_new)
{
OSG::Vec3f direction_old(1.0f, 0.0f, 0.0f);
OSG::Vec3f up_old(0.0f, 1.0f, 0.0f);
OSG::Quaternion qD(direction_old, direction_new);
OSG::Vec3f up_temp;
qD.multVec(up_old, up_temp);
OSG::Quaternion qU(up_temp, up_new);
OSG::Quaternion qResult;
qResult = qU;
qResult.mult(qD);
return qResult;
}
void FlightState::rotateAroundFrontVector(float angle)
{
OSG::Quaternion rotation;
rotation.setValueAsAxisDeg(frontVec, angle);
rotation.multVec(upVec, upVec);
rotation.multVec(downVec, downVec);
rotation.multVec(leftVec, leftVec);
rotation.multVec(rightVec, rightVec);
// quaternionRotation is used to rotate the plane
quaternionRotation = Mathematic::lookAt(frontVec, upVec);
}
void FlightState::rotateAroundUpVector(float angle)
{
...
}
void FlightState::rotateAroundRightVector(float angle)
{
...
}
Kind regards
Sebastian B.
Daniel Sperka schrieb:
> IIRC, this is similar to the transforms done in the billboards. I
> recently needed something similar to what you describe.
>
> First, I'll try to refer to the "direction" and "up" vectors, either the
> "old" or "new". You're seeking a transform which takes you FROM the "old
> direction and up" TO the "new direction and up".
>
> The quaternion you require is the product of two quaternions.
>
> One quaternion, call it qD, represents a rotation FROM the "old
> direction" vector to the "new direction" vector. The second quaternion
> takes care of the fact that qD does NOT necessarily rotate the "up"
> vector correctly.
>
>
> Vec3f direc_old, direc_new; // assume these get their values in
> Vec3f up_old, up_new; // your code somewhere
>
> ...
> ...
>
> Quaternion qD(direc_old, direc_new);
>
> // Now apply this transform to the "old up" vector
>
> Vec3f up_temp;
> qD.multVec(up_old, up_temp);
>
> // Make a second quaternion which rotates up_temp into the "new up"
> vector.
> Quaternion qU(up_temp, up_new);
>
> // The result is the product of these quaternions
> Quaternion qResult;
> qResult = qU;
> qResult.mult(qD);
>
>
> Can't say that this code will compile ;). I've paraphrased my own
> algorithm.... which does something similar but not quite the same. I
> must say that exercise really taught me how to use quaternions!
>
> It took me a while to convince myself this was right. Think of the
> qResult as the product of two transforms: first you transform the
> direction/pointing vector, then you apply the "up" transformation. The
> "up" transformation doesn't affect the first transform because it is
> really a rotation around the direction vector!
>
>
> Hope this helps!
>
> Dan
>
>
>
-------------------------------------------------------------------------
This SF.net email is sponsored by: Microsoft
Defy all challenges. Microsoft(R) Visual Studio 2008.
http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/
_______________________________________________
Opensg-users mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/opensg-users
