Rotation degrees help

hi i need some help with getLocalRotation and rotation it self, i need to get the 360 degrees of each x,y,z. but when i go for getLocalRotation i finde float values (pretty big values) and what i need is (for example ) take my object and rotate it in direction of an other object soo i need to use proportion of location of both bodies to obtain the direction,the problem is i cant set the direction values in rotate and cant undestand the output of getLocalRotation, soo cant check if body has right rotation.

You’re getting a Quaternion object, not just floats. This will have 4 floats which … well forget about them (google it if you want but you don’t need to understand them, only how to use them). Using that Quaternion you can do:

 Quaternion q = yourThing.getLocalRotation();
 float[] angles = new float[3];
 q.toAngles(angles);//this stores the angles in the float array

toAngles returns this quaternion converted to Euler rotation angles (yaw,roll,pitch).
Important to note that the order of rotation matters with euler angles and in this case its yaw roll pitch, so rotation around y, then z, then x.

Just in case, don’t forget they are radians not degrees.

Going to degrees is nothing but trouble here, anyway.

If you want to rotate towards some other object then just rotate towards it. You don’t need to manipulate angles directly. That just leads to trouble as you rapidly learn that Quaternion will return the most compact representation and not the one you want. Plus you will have to deal with quadrants, crossing boundaries, etc…

I can’t give more advice than that because I don’t really know what you are trying to do specifically.

Octants, if we’re 3d. I once did that to generate a vector that I’d understand completely… and everything reduced to two or three ifs in the end. Once more bicycle invention oh lol.

lets say i need my space ship to rotate in right direction at appropriate speed,then tell me its rotation so i can tell it to move there(like move in direction where u are looking)

What is “right direction”? What is “appropriate speed”?

How do you determine these things?

Right direction is the direction i need ,and appropriate speed is the time it will take to rotate from how it is now to how i need it lets say 1.0f *tpf;
I have my ship,soo i get its coordinates,and have object or place where i need to go .
Lets say “myLocation” is x=0;y=0;z=0; and i need to go to “wayPoint” x=10;y=1;z=1; soo i just say :
wayPoint - my Location = rightDirection
(x=10 - x=0; y=10- y=0; z=1 - z=0;) the rest is pretty simple
(it just have to rotate to the right a bit up and not totally to the right)
,and the speed is speed i get with setters and getters from an other class,i dont want it to move instantly to where i need ,i need to make it slowly

You don’t want rotations, you want a forward vector and an up vector. Look at the “math for dummies” link at the top of the page.

are u shere it will make it turn around and not just move? couse my ship will have face and it needs to turn to direction and not just move to it

You can use the left and up vector to find out how much to turn and which way. The dot product is your friend here.

This sounds like pretty typical steering behavior that’s been gone over here a bunch of times.

Just as a general rule: if you find yourself needing “degrees” for anything other than displaying something to the user then you’re usually doing something wrong. Even keeping angles in radians has only a very few specific use-cases and almost always in just one direction. (angle → rotation)

You make me wonder. I have such a use in aiming check (see pic below):

float sinA = diameter / ( 2 * targetDirectionVec.length() );
float angle = FastMath.asin(sinA);
Vector3f targetDirectionVecN = targetDirectionVec.normalize();
float realAngle = fwdLookVecN.angleBetween(targetDirectionVecN);

if ( FastMath.abs(realAngle) <= FastMath.abs(angle) ) return true;
return false;

How would you do it instead?

What exactly are you trying to determine? I’m having trouble figuring it out because the blue tangent vector (and the blue circle) seem a bit arbitrary. Like, the closer the look vector and the target vector are to being parallel, the weirder the angle of the diameter line will be. So, from one step back, what are you using this true/false value for?

I can see where targetDirectionVec comes from but how are you calculating fwdLookVecN? I want to be able to provide an accurate basis for creating a different look-based vector.

Circle represents target’s bounding sphere (so we don’t need cases inside). Point outside represents where we are now to determine if we’re aimed or not. Of course all positions and rotations are known.

I really do need the answers to those questions.

Vector3f fwdLookVecN = weaponWorldRot.mult(Vector3f.UNIT_Z);

determining if my weapon is granted to open fire or no.

So you want to know if the target is within some min/max angle of the look vector? This is why I think the diameter from the target is a strange parameter… as then the angle gets smaller and smaller the farther away the object is. Which to me doesn’t seem relevant to targeting.

Assuming you have some min/max angle in mind:

Vector3f side = weaponWorldRot.mult(Vector3f.UNIT_X);
float dot =;

‘dot’ is then the cosine of the angle between side and targetDir… ie: a projection of target along side. 0 means you are looking right at it. 1 means it is 90 degrees directly to the side.

float range = FastMath.sin(maxTargetAngle); // can be a constant probably

return FastMath.abs(dot) < range;

Edit: for steering calculations, dot can be directly pumped into ‘how much do I turn?’ calculations.

Oh, and if you want to know if the target is in front or behind then you can initially do a dot-based check against your look vector. If dot is negative then the object is behind you.

1 Like

Yep, I was determining if my weapon fires straight forward (which in your description means angle = 0) will it hit target or no. I will try your solution, it seems more general (well, as usual though). Thanks! :slight_smile:

Note: it’s also probably faster, I guess. In modern computers I guess the trig functions like asin() aren’t as expensive as they used to be… but a dot() project is an easy 3 multiplies and two adds. Hard to beat it considering all of its magical properties.

Yep, that’s why I assumed it’s worth asking and even making picture. That magic isn’t completely exposed in Math for Dummies, it seems… not to diminish the tutorial’s usefulness ofc.

well i will try to to try to try what u suggest :smiley: , but i was thinking of using .getLocalRotation().getX() ,the problem is i dont know the maximal and the minimal possible values,i was thinking this would give me some idea on where my object looking soo i can tell it how mutch it should chenge it