2D: CVVS

[Dreaming381]

2D: CVVS

While 2D is not my personal focus with this framework, I am not opposed to 2D features being added by the community, and am willing to help guide its development. Despite my general lack of interest these days, I have a lot of experience with the domain.

To kick off the exploration of 2D, the first thing to develop is the foundation of a 2D transform system. In 3D, we have QVVS. But 2D has an equivalent CVSS. Building out that foundational structure is what this task is all about!

Task is Prerequisite For

• 2D Transform System
• 2D Physics
• 2D Audio
• 2D Rendering
• 2D Skeletal Animation

Background

In 2D, there is only a single axis on which things can rotate. Ironically, this axis is the very axis that is ignored for position and scale.

Because there is only a single rotation axis, it can be represented as a single angle in radians. But however memory efficient this is, it actually suffers from a few annoying issues. One issue is that you always have to wrap around angles. You could force a range of [0, 2π), but this makes small clockwise rotations appear as large counter-clockwise rotations. The ranges [-π, π) or (-π, π] are also valid, but you can no longer rely on modulus to reduce an arbitrary value into this range. But even if you solve both of these problems, there is still the major issue that transforming any point or vector but an angle requires trigonometric operations. On the GPU, this isn’t a huge deal because GPUs have special-function units that do sin() and cos() relatively efficiently. On the CPU, things tend to be a little more expensive. And that’s not great when that’s required for transform hierarchies, positioning and orienting raycasts, spawning things relative to facing directions, or defining relative spaces for colliders during collision detection. There’s a better way.

If you recall, the angle in radians is the distance traveled counter-clockwise around the unit circle. If you start at the right-most point on the unit circle, you can calculate the coordinates of the point you would end up at on the unit circle if you traveled the angle in radians. The formula as you know is:

x = cos(angle)

y = sin(angle)

Interestingly, these coordinates are also a unit vector from the origin to the unit circle at the specified angle.

What many people don’t realize is that you can multiply these vectors to add the angles. But this isn’t a dot product, cross product, nor component-wise product. This is a complex product.

The basic idea is that you treat the y-axis as the imaginary axis of the complex plane. And any coordinate or vector becomes a complex number. Then, you simply multiply the complex numbers. In code:

result.x = a.x * b.x - a.y * b.y;

result.y = a.x * b.y + a.y * b.x;

There’s some amazing properties to this. First off, unlike quaternions, the order of the multiplication does not matter. Second, if non-unit vectors are involved, this expression is true:

complexMul(a, b) = a.mag * b.mag * complexMul(a.norm, b.norm)

If you treat a as a unit vector derived from an angle, and b as some arbitrary vector, you will find that complex multiplication will rotate b while preserving the magnitude of b. In fact, you can even substitute the angle-to-vector formula for a, and you would end up with the well-known formula for transforming an angle:

result.x = x * cos(angle) - y * sin(angle)

result.y = y * cos(angle) + x * sin(angle)

But now that you know the derivation, you may be able to see how you can skip the trigonometric functions in many cases. And naturally, it is a good idea to keep a rotation stored as a complex number. Where Q is for quaternion, C is for complex. Thus, we can derive our CVVS.

Like quaternions, wrap-around happens automatically for complex numbers. However, you occasionally need to normalize the complex numbers to correct for floating point errors, just like quaternions. Another similar property is that you can invert the rotation of a unit complex number by taking the conjugate of the complex number, which is just negating the imaginary (y) component.

Lastly, a complex number requires 8 bytes. A position in 2D also requires 8 bytes. Stretch requires 8 bytes, and scale requires 4 bytes. Just like with QVVS, we can fill in 4 bytes with a worldIndex (use-case defined value) for an even 32 bytes.

Base Requirements

Implement the TransformCvvs type and the static cvvs class. Additionally, implement utilities for converting between complex rotations and angles, and converting between TransformCvvs and TransformQvvs which can either assume an XY plane or an XZ plane.

You may want to add code in MathematicsExpansion to define the complex type and implement mul() and rotate() methods.