rotation glitches when reaching 360 degrees

DJM

im trying to create weapon sway based on the cameras' and players' rotation, the main idea works but when reaching the 360degrees it glitches. maybe i need the local rotation , but i cant figure it out. how do i make it work? tnx

func doweaponsway(delta):
	#calculate rotation

	
	
	var wantedz
	var wantedx
	var wantedy


	var xrot = $CamRoot.rotation_degrees.x  - oldxrot
	var yrot = self.rotation_degrees.y- oldyrot
	wantedx = lerp(weaponsway.rotation_degrees.x,xrot,2 * delta)
	wantedy = lerp(weaponsway.rotation_degrees.y,yrot,2 * delta)
	
	
	weaponsway.rotation_degrees.x = clamp(wantedx, -2, 2)
	weaponsway.rotation_degrees.y = clamp(wantedy, -2, 2)
	#weaponsway.rotation_degrees.z =clamp(wantedz,-2,2)
	
	oldxrot = $CamRoot.rotation_degrees.x 
	oldyrot = self.rotation_degrees.y

TwistedTwigleg

Welcome to the forums @DJM!

I would recommend having the rotation for each axis in the weapon sway be a different node. This is because in Godot (and other game engines), having multiple axes of rotation that go over 180 degrees can lead to other axes being flipped to negative 180. I have found that when working with rotation and clamping, using separate nodes for each axes of rotation makes it MUCH easier. For example, instead of having weaponsway modified on the X and Y, you'd want to have something like this:

weaponsway_x
- weaponsway_y
  - (other weapon sway nodes here)

Then in your code you can modify the rotation_degrees of weaponsway_x for the x axis and weaponsway_y for the y axis. That may help with the 360 degrees issue if the reason it stops working is because of the -180 degree issue.

Also, using rotation_degrees is the local rotation. If you want the global rotation of a node, you'll need to use node.global_transform.basis to get the node's global rotations :smile:

DJM

tnx! im happy ive made the switch to godot. sadly seperating the rotation axis on different nodes doesnt fix my issue. ive also tried the global transform basis u suggested

in unity i used to use > Mathf.DeltaAngle to get the shortest distance between rotations, i dont know if there is a similar function in gdscript

TwistedTwigleg

@DJM said: tnx! im happy ive made the switch to godot. sadly seperating the rotation axis on different nodes doesnt fix my issue. ive also tried the global transform basis u suggested

A shame that didn't fix it, but thankfully it means it's not the -180 issue that is causing the problem! I've found the -180 problem can be tricky to work around, so that's good that it's not what is causing the issue here.

in unity i used to use > Mathf.DeltaAngle to get the shortest distance between rotations, i dont know if there is a similar function in gdscript

I don't think there is anything built in that is similar to the Mathf.DeltaAngle function unfortunately. This StackOverflow solution provides a language agnostic way to get the difference of angles, though I'm not sure if the mod function in GDScript returns the sign or not. This Godot StackOverflow question also has an answer with many examples on lerping between two angles, which may work for getting the difference as well.

DJM

actually i dont want to lerp between two angles. i only need to get the float between the current and last rotation per frame to do weaponsway calculations. the issue thats occurring whit my current code is that when the current rotation is 0 and the last was 359 the weapon sway gets a short glitch because of the huge difference when i subtract the values

cybereality

This is a problem with Euler angles. As they go from 0 to 360 (or -180 to 180) then you will always have problems at the end of the range, especially when interpolating the value. Think of it like this, you want to rotate 30 degrees. But the angle is from 340 to 370 (or 10). If you just interpolate the values (340 and 10) instead of rotating 30 degrees, it will rotate 330 degrees, and in the wrong direction. You can account of this by looking at the values and adjusting them, but it is an inherent issue with using Euler angles.

A few things can help. First, try to always get 0 to 360 to make the math easier (so you don't get negative values or values above 360):

var angle = fmod(angle + 360.0, 360.0)

Then you can find the smaller angle. If you know your delta angle will never be more than 180 degrees (a pretty fair assumption for most games):

var angle_delta = angle - last_angle
angle_delta = fmod(angle_delta + 360.0, 360.0)
if angle_delta > 180.0:
    angle_delta = angle_delta - 360.0

xyz

Working with separate (euler) angles in 3d is just not worth the effort. You're in for a constant barrage of annoying gotchas :) Do it the grownup way and represent your current and wanted orientation with quaternions, and interpolate between them. You can even simplify by just using two lookat vectors and slerp between them.

var current: Vector3 # current lookat direction
var wanted: Vector3 # wanted lookat direction

func _process(delta):
	wanted = calculate_wanted()
	current = current.slerp(wanted, fraction)
	look_at(current, Vector3.UP)

DJM

tnx ! that works perfect

heres the code in case anybody wonders to do the same thing

`func doweaponsway(delta): #calculate rotation



var xrot = fmod( $CamRoot.rotation_degrees.x + 360.0, 360)
var xrotdelta = xrot - oldxrot
xrotdelta = fmod(xrotdelta + 360.0, 360.0)
if xrotdelta > 180:
	xrotdelta = xrotdelta - 360
	
var yrot = fmod( self.rotation_degrees.y + 360.0, 360)
var yrotdelta = yrot - oldyrot
yrotdelta = fmod(yrotdelta + 360.0, 360.0)
if yrotdelta > 180:
	yrotdelta = yrotdelta - 360



var wantedx = lerp(weaponsway.rotation_degrees.x,xrotdelta,2 * delta)
var wantedy = lerp(weaponsway.rotation_degrees.y,yrotdelta,2 * delta)



weaponsway.rotation_degrees.x = clamp(wantedx, -2, 2)
weaponsway.rotation_degrees.y = clamp(wantedy, -2, 2)




oldxrot =fmod( $CamRoot.rotation_degrees.x + 360.0, 360)
oldyrot = fmod( self.rotation_degrees.y + 360.0, 360)

DJM

@xyz said: Working with separate (euler) angles in 3d is just not worth the effort. You're in for a constant barrage of annoying gotchas :) Do it the grownup way and represent your current and wanted orientation with quaternions, and interpolate between them. You can even simplify by just using two lookat vectors and slerp between them.
var current: Vector3 # current lookat direction
var wanted: Vector3 # wanted lookat direction

func _process(delta):
	wanted = calculate_wanted()
	current = current.slerp(wanted, fraction)
	look_at(current, Vector3.UP)

im not sure how to use that, how to calculate "wanted" and what is "fraction" in your example?

cybereality

Wanted would be the next angle, current would be the previous angle, and fraction is a variable you set that controls how fast it interpolates.

cybereality

And yes, avoid using Euler angles if you can. They make things easier in the beginning, and they are simpler to understand, but using more advanced structures like Quaternions end up with more robust functionality, less bugs, and less code.

DJM

@cybereality said: And yes, avoid using Euler angles if you can. They make things easier in the beginning, and they are simpler to understand, but using more advanced structures like Quaternions end up with more robust functionality, less bugs, and less code.

ok im having trouble figuring out the local forward lookat from the camroot. if i try the suggestion the weapon doesnt seem to point into the view direction im looking

xyz

@DJM said:
@xyz said: Working with separate (euler) angles in 3d is just not worth the effort. You're in for a constant barrage of annoying gotchas :) Do it the grownup way and represent your current and wanted orientation with quaternions, and interpolate between them. You can even simplify by just using two lookat vectors and slerp between them.
var current: Vector3 # current lookat direction
var wanted: Vector3 # wanted lookat direction

func _process(delta):
	wanted = calculate_wanted()
	current = current.slerp(wanted, fraction)
	look_at(current, Vector3.UP)
im not sure how to use that, how to calculate "wanted" and what is "fraction" in your example?

This was more at pseudocode level just to show the principle. We can discuss specifics but it'd be much easier if you could post how your nodes are set up.

DJM

@xyz said:
@DJM said:
@xyz said: Working with separate (euler) angles in 3d is just not worth the effort. You're in for a constant barrage of annoying gotchas :) Do it the grownup way and represent your current and wanted orientation with quaternions, and interpolate between them. You can even simplify by just using two lookat vectors and slerp between them.
var current: Vector3 # current lookat direction
var wanted: Vector3 # wanted lookat direction

func _process(delta):
	wanted = calculate_wanted()
	current = current.slerp(wanted, fraction)
	look_at(current, Vector3.UP)
im not sure how to use that, how to calculate "wanted" and what is "fraction" in your example?
This was more at pseudocode level just to show the principle. We can discuss specifics but it'd me much easier if you could post how your nodes are set up. here u go

xyz

Ok, here's a quick version using quaternions:

func _process(delta):
	var softness = 3.0
	do_sway($weaponsway, calculate_sway_offset(), delta * softness)

func do_sway(sway_node, offset: Vector2, fract: float):
	var wanted_quat = Quat(Vector3.UP, offset.x) * Quat(Vector3.RIGHT, offset.y)
	var current_quat = Quat(sway_node.transform.basis)
	sway_node.transform.basis = Basis(current_quat.slerp(wanted_quat, fract))

You just need to implement calculate_sway_offset() to return horizontal and vertical sway offsets as Vector2. You can calculate it as you currently do from camera rotation deltas between frames.

DJM

@xyz said: Ok, here's a quick version using quaternions:
func _process(delta):
	var softness = 3.0
	do_sway($weaponsway, calculate_sway_offset(), delta * softness)

func do_sway(sway_node, offset: Vector2, fract: float):
	var wanted_quat = Quat(Vector3.UP, offset.x) * Quat(Vector3.RIGHT, offset.y)
	var current_quat = Quat(sway_node.transform.basis)
	sway_node.transform.basis = Basis(current_quat.slerp(wanted_quat, fract))
You just need to implement calculate_sway_offset() to return horizontal and vertical sway offsets as Vector2. You can calculate it as you currently do from camera rotation deltas between frames.

what do i put in the "calculate sway offset" func? how to return the vector2 values?

im currently calculating the movement in degrees so wont that have the same euler issues as i allready had?

xyz

I'd do it from controller/mouse deltas, or if you must deal with movement - again from transformation basis/quaternions.

xyz

Here's a way to calculate offsets from difference in rotation between frames. Using quaternions will ensure there are no wrapping and gimbal problems. You'll need to maintain player/camera basis from the previous frame:

calculate_sway_offset(basis_last_frame: Basis, basis_current_frame: Basis):
	var q1 = basis_last_frame.get_rotation_quat()
	var q2 = basis_current_frame.get_rotation_quat()
	var q = q1.inverse() * q2
	var eu = q.get_euler()
	return Vector2(eu.y, eu.x)

cybereality

Right, but this is also why Euler is much easier when starting out. It took me years to fully understand Quaternions, but I guess if you use Godot it does most of the math for you (but you still kind of have to understand what you're doing).

DJM

@xyz said: Here's a way to calculate offsets from difference in rotation between frames. Using quaternions will ensure there are no wrapping and gimbal problems. You'll need to maintain player/camera basis from the previous frame:
calculate_sway_offset(basis_last_frame: Basis, basis_current_frame: Basis):
	var q1 = basis_last_frame.get_rotation_quat()
	var q2 = basis_current_frame.get_rotation_quat()
	var q = q1.inverse() * q2
	var eu = q.get_euler()
	return Vector2(eu.y, eu.x)

ok heres what ive got right now, based on your code

func _process(delta):
	
	var softness = 3.0
    do_sway(weaponsway, calculate_sway_offset(), delta * softness)
	
	
calculate_sway_offset(basis_last_frame: Basis, basis_current_frame: Basis):
	var q1 = basis_last_frame.get_rotation_quat()
	var q2 = basis_current_frame.get_rotation_quat()
	var q = q1.inverse() * q2
	var eu = q.get_euler()
	return Vector2(eu.y, eu.x)
 
    
func do_sway(sway_node, offset: Vector2, fract: float):
	var offset_quaternion: Quat = Quat(Vector3.UP, offset.x) * Quat(Vector3.RIGHT, offset.y)
	sway_node.transform.basis = Basis(Quat(sway_node.transform.basis).slerp(offset_quaternion, fract))

im not sure what to write in the > do_sway(weaponsway, calculate_sway_offset( "what goes here?"), delta * softness) i cant use mouse rotation , because it will sway the weapon even if theres no rotation happening.