How to rotate a Transform2D around itself

MamboSteve

Hi,

I'm currently working on a 2D game where you control spaceships from a top-down perspective. One should be able to click on a spaceship and right click to make it move to that waypoint. I implemented a very basic steering behavior that applies a constant movement and rotation to the Node2D that represents the spaceship to move it in a curve towards the waypoint:

func _process(delta: float) -> void:
	transform = transform.translated(Vector2.UP * speed * delta)
	rotate(rot_speed * delta)

The actual code is a little more complex, this is just an example. With this example, the spaceship will just move in a circle if speed and rot_speed stay constant.

Now my actual problem is the following: I want to give the user a preview of how the spaceship will move when they click to set a waypoint. For this, I want to draw a line between the spaceship and the mouse position. My idea was to pre-calculate the path using the same logic the spaceship uses to move, and save the points in an array to draw them with draw_polyline(). Late I could make it look better using a different rendering method. I used an empty Transform2D to try and move it exactly like the spaceship does and save the points along the way (think of it like a pen), but I could not get it to do what I wanted.

	var ship_path = PoolVector2Array()
	var pen = Transform2D(0, get_viewport().size / 2) # set pen to center of screen
	var speed = 25
	var rot_speed = deg2rad(4) # 4 degrees per second
	var line_segments = 20

	for i in range(line_segments * 15): # simulate 15 seconds of movement
		ship_path.append(pen.origin)
		pen = pen.translated(Vector2.UP * speed / line_segments)
		pen = pen.rotated(rot_speed / line_segments)
	
	draw_polyline(ship_path, Color.red)

The problem is, that pen.rotated() seems to rotate the Transform2D around its' origin vs. Node2D.rotate() seems to rotate it around itself, regardless of its' origin. Is there a simple way to rotate a Transform2D around itself, not the origin, or do I have to code that myself? Additionally, do you have any suggestions on how to do this in a more simple way?

Thanks in advance!

pkowal1982

Not elegant but probably what you're looking for:

MamboSteve

Okay, so you set the pen's origin to (0, 0) each round, call rotated() and translated() to apply the movement and then add the original origin back. Pretty smart. Thank you! Although I am still looking for a "clean" solution.

Here is my code with your this solution:

var ship_path = PoolVector2Array()
	var pen = Transform2D(0, ship.transform.origin) # set pen ship's origin
	var speed = 25
	var rot_speed = deg2rad(4) # 4 degrees per second
	var line_segments = 20
	
	for i in range(line_segments * 5): # simulate 15 seconds of movement
		var origin = pen.origin
		ship_path.append(pen.origin)
		pen.origin = Vector2.ZERO
		pen = pen.translated(Vector2.UP * speed / line_segments).rotated(rot_speed / line_segments)
		pen.origin += origin
	
	draw_polyline(ship_path, Color.red)

xyz

You can simply rotate the basis vectors:

# move
pen = pen.translated(Vector2.UP * speed / line_segments)
# rotate
pen.x = pen.x.rotated(rot_speed / line_segments)
pen.y = pen.y.rotated(rot_speed / line_segments)

MamboSteve

That works, too! Thanks!

xyz

It's also less hacky as direct basis vector manipulation lets you rotate transform's coordinate system independently of origin. The neat thing is that you can use exactly the same approach to perform actual motion of the spaceship.

MamboSteve

I also thought about applying the rotation matrix myself like in the godot docs (https://docs.godotengine.org/en/stable/tutorials/math/matrices_and_transforms.html). Then I saw there was a note saying that you should use the method rotated() instead. I wonder if they meant to use Vector2.rotated() instead of Transform2D.rotated(), as you pointed out in your solution.

xyz

No, they meant Transform2D.rotated().

My "solution" rotates the basis vectors. Basis vector components actually correspond to values in Transform2D's matrix. So rotating them changes the matrix directly. If you wanted to do it by another matrix multiplication, you'd still need to nullify translation, rotate, and then bring translation back. Basically the same thing @pkowal1982 suggested, only via matrix multiplication.

Rotating the basis is most straightforward approach, and least computationally expensive.

Note that you could do it without using Transform2D. Simply duplicate the spaceship node (or create a fresh Node2D), move it via same code you used for spaceship, collect positions and delete the node. All inside a single frame.

MamboSteve

Yes, I understand. What I meant was rotating the basis myself by applying the rotation manually like the documentation says:

pen.x.x = cos(rot_speed)
pen.y.y = cos(rot_speed)
pen.x.y = sin(rot_speed)
pen.y.x = -sin(rot_speed)

Should be the same as using Vector2.rotated() on each vector of the basis.

Still, the documentation seems to not mention the fact that this is not the same as applying Transform2D.rotated(). Now I know better :)

xyz

@MamboSteve said:
pen.x.x = cos(rot_speed)
pen.y.y = cos(rot_speed)
pen.x.y = sin(rot_speed)
pen.y.x = -sin(rot_speed)
Should be the same as using Vector2.rotated() on each vector of the basis.

Not really. Firstly, you'd need to use the absolute orientation angle as an argument to those trigonometric functions, not relative angle delta. So you'd need to calculate and maintain that value or extract and update it each frame from basis vectors themselves. Secondly this assignment will normalize the basis vectors. Their length represents transform's scaling so this would eradicate any existing scaling. Although it may not affect the outcome in your particular case, it's still something to be aware of when playing with the basis.