Support rotation in test mock

[Mimickal]

Rotation in Blender is more complicated than it first appears. The rotation mode an individual object uses is set as follows:

# Self-explanatory
object.rotation_mode = 'QUATERNION'

# These are both Euler systems. Every permutation of XYZ is supported
object.rotation_mode = 'XYZ'
object.rotation_mode = 'ZYX' 

Through a little bit of experimentation, we've discovered the following:

• Blender objects have two separate internal rotation values -- one for quaternion, and one for Euler
• Only the internal rotation value corresponding to the current rotation mode is updated
• When changing rotation_mode, Blender actually recalculates the internal rotation values on the fly, presumably from the previous rotation state. For example:
  1. I create an object with XYZ Euler rotation.
     • Euler rotation = ((0.0, 0.0, 0.0,), 'XYZ')
     • quaternion rotation = (1.0, 0.0, 0.0, 0.0).
  2. I rotate the object 90 degrees on the Z axis.
     • Euler rotation = ((0.0, -0.0, 1.571), 'XYZ')
     • quaternion rotation = (1.0, 0.0, 0.0, 0.0)
  3. I change the rotation mode to QUATERNION (WXYZ)
     • Euler rotation = ((0.0, -0.0, 1.571), 'XYZ')
     • quaternion rotation = (0.707, 0.0, 0.0, 0.707)
  4. I change the Z to 1.0
     • Euler rotation = ((0.0, -0.0, 1.571), 'XYZ')
     • quaternion rotation = (0.707, 0.0, 0.0, 1.0)
  5. I change rotation mode back to 'XYZ'. Perplexingly, quaternion rotation is updated when this happens.
     • Euler rotation = ((0.0, -0.0, 1.911), 'XYZ')
     • quaternion rotation = (0.577, 0.0, 0.0, 0.816)
  6. I change Z rotation to 189 degrees. Quaternion rotation does not update this time.
     • Euler rotation = ((0.0, -0.0, 3.293), 'XYZ')
     • quaternion rotation = (0.577, 0.0, 0.0, 0.816)
• Converting from Euler to quaternion rotation seems to be slightly lossy. The last few decimal places of the quaternion value changes a bit.
• Conversion back to Euler does not appear to be lossy though, somehow. Maybe Blender's "single point of truth" for rotation is Euler?
• When converting between Euler XYZ and (for example) YXZ, the order and values of the rotation tuple remain the same. The only thing that changes is that last value. It will show 'YXZ' instead of 'XYZ'. Presumably, the index of each character corresponds to the index of the value in the rotation tuple.

These quirks need to be (somewhat) accurately captured by the test mocks. Accurately enough that a script run against the mocks produces nearly-identical results to running that same script against real Blender.

[Mimickal]

Something helpful here to emulate the recalculation on rotation_mode assignment:

    @property
    def x(self): return self[0]
    @x.setter
    def x(self, new_val): self[0] = float(new_val)

[Mimickal]

Some functions that will be very helpful

def euler_to_quaternion(y, p, r):
    '''Angles are expected to be in radians.'''
    c0, c1, c2 = cos(y / 2), cos(p / 2), cos(r / 2)
    s1, s2, s3 = sin(y / 2), sin(p / 2), sin(r / 2)
    return (s1*s2*c2*+ c0*c1*s3,
            s1*c1*c2 + c0*s2*s3,
            c0*s2*c2 - s1*c1*s3,
            c0*c1*c2 - s1*s2*s3)

def quaternion_to_euler(i, j, k, w):
    '''Angles returned are in radians.'''
    p_sin = 2*(i * j + k * w);
    # check for singularities at north and south poles
    if p_sin > 0.99999999999999:
        return 2 * atan2(i, w),   pi / 2, 0
    elif p_sin < -0.99999999999999:
        return -2 * atan2(i, w), -pi / 2, 0
    else:
        y = atan2(2*(j*w - i*k), 1 - 2*(j**2 - k**2));
        p = asin(p_sin);
        r = atan2(2*(i*w - j*k), 1 - 2*(i**2 - k**2))
        return y, p, r

[Mimickal]

mathutils handles almost all of this for us. There's an Euler and Quaternion class that handles all the math for converting between the two, the same way Blender does it.

The only trick right now is it seems the standalone version of mathutils we're using seems to be outdated, and doesn't yet support the Euler((1, 2, 3), 'XYZ') constructor. Or if it does, it expects it in a way different than Blender 2.80's scripting terminal does.