Simplify Control internal transform calculation

[kleonc]

T // translation
R // rotation
S // scaling

Control._get_internal_transform() = T(pivot_offset) * R(rotation) * S(scale) * T(-pivot_offset)

Previously T(pivot_offset) * R(rotation) * S(scale) * T(-pivot_offset) was calculated by unnecessarily doing 1 affine inverse ($T(pivot\_offset) = T^{-1}(-pivot\_offset)$) and 2 full Transform2D multiplications.

Now T(pivot_offset) * R(rotation) * S(scale) is constructed directly, and T(-pivot_offset) is applied locally with a dedicated method (not performing full Transform2D multiplication).

Precision of the result is not improved / the same as before because even though before a full inverse were calculated and more multiplications / additions were done, it was just some superfluous multiplications by 1.0 / additions of 0.0 * something, hence not introducing precision errors.

[YuriSizov]

If it's a performance improvement, could you provide some rough metric for how much it is improved?

[kleonc]

If it's a performance improvement, could you provide some rough metric for how much it is improved?

I was actually hesitant to mark it with performance, as I have not benchmarked it whatsoever. 😄 Marked so purely based on the info I've described in the PR description. 🙃

---

Ok, I've downloaded artifact from this PR and from #84833 just merged into master:

Test script

extends Control

func _ready() -> void:
	for p in range(6, 9):
		var iterations: int = 10 ** p
		print()
		print("Iterations: %d" % [iterations])

		var times := []
		for r in 5:
			var time := Time.get_ticks_msec()

			for i in iterations:
				get_transform()

			time = Time.get_ticks_msec() - time
			times.push_back(time)
			print("  Time: %d" % [time])

		print("  Average time: %d" % [times.reduce(func(s, t): return s + t, 0) / float(times.size())])

	get_tree().quit()

"master" (Godot Engine v4.2.beta.custom_build.59457685c)

Iterations: 1000000
  Time: 165
  Time: 165
  Time: 166
  Time: 165
  Time: 165
  Average time: 165

Iterations: 10000000
  Time: 1660
  Time: 1667
  Time: 1666
  Time: 1653
  Time: 1692
  Average time: 1667

Iterations: 100000000
  Time: 16638
  Time: 16621
  Time: 16702
  Time: 16694
  Time: 16674
  Average time: 16665

This PR (Godot Engine v4.2.beta.custom_build.b24ce680c)

Iterations: 1000000
  Time: 114
  Time: 116
  Time: 110
  Time: 116
  Time: 116
  Average time: 114

Iterations: 10000000
  Time: 1162
  Time: 1153
  Time: 1170
  Time: 1158
  Time: 1168
  Average time: 1162

Iterations: 100000000
  Time: 11642
  Time: 11617
  Time: 11628
  Time: 11516
  Time: 11490
  Average time: 11578

Minus empty loop timings the result of this simple benchmark is ~35% faster. No idea if it will affect anyhow e.g. editor but for sure things won't be slower. 🙂

[MewPurPur]

I was curious about what this optimizes - as far as I see, aside from user project uses and editor uses of get_transform() and get_rect(), these functions are called for all controls when they need to redraw, their size changes, and a few controls also use them for other more niche things. My estimation is that this is called maybe a thousand times when you start the editor (0.1 ms), then less frequently.

[kleonc]

Rebased and changed to simplify only Control::_get_internal_transform. After #89502 it's used not only in Control::get_transform hence makes sense to not remove it. 🙃 Plus now this PR is trivial.

The speedup should still be comparable to the previous version as the main inefficiency was within Control::_get_internal_transform.

[aaronfranke]

I didn't test it, but it makes logical sense (both the approach and the code). Assuming it works, this looks good to me.

[akien-mga]

Thanks!