I convert to half precision and send that with no further fuss.

To get the best possible size, I guess you would want to transmit a quaternion in an axis+angle representation. Normally a quaternion is like this: [ cos(theta/2), sin(theta/2)*axis.x, sin(theta/2)*axis.y, sin(theta/2)*axis.z ]. You can easily recover the axis and angle using acos(). If you can afford some loss of precision, then I would serialize theta and axis as signed 8-bit integers (a total of 32 bits). This gives you almost 1 degree precision. If you need better precision then maybe 16-bit integers would be good enough. You could maybe cut it down to 3 8-bit values if you use Euler angles instead, then turn those into a quaternion on the receiving end.

I thought about this in the past. Start with a + bi + cj + dk. The quaternions we are interested in have length 1, and it doesn't matter if you flip their sign. So we can encode in 2 bits which of the coordinates is the largest in absolute value (say it's b) and divide by it. Now we have something like a/b + i + (c/b)j + (d/b)k. It's enough to encode the numbers a/b, c/b and d/b, and they are all between -1 and 1.

So you could use 32 bits to encode a quaternion, using code like this:

using System;

class QuaternionEncoder
{
    public static uint Encode3(float x, float y, float z)
    {
        uint ux = (uint)Math.Round((x + 1.0f) * 511.0f);
        uint uy = (uint)Math.Round((y + 1.0f) * 511.0f);
        uint uz = (uint)Math.Round((z + 1.0f) * 511.0f);
        return (ux << 20) | (uy << 10) | uz;
    }

    public static uint EncodeQuaternion(float a, float b, float c, float d)
    {
        float max = Math.Max(Math.Max(Math.Max(Math.Abs(a), Math.Abs(b)), Math.Abs(c)), Math.Abs(d));
        if (Math.Abs(a) == max)
            return (0u << 30) | Encode3(b / a, c / a, d / a);
        if (Math.Abs(b) == max)
            return (1u << 30) | Encode3(a / b, c / b, d / b);
        if (Math.Abs(c) == max)
            return (2u << 30) | Encode3(a / c, b / c, d / c);
        return (3u << 30) | Encode3(a / d, b / d, c / d);
    }

    public static void NormalizeQuaternion(ref float a, ref float b, ref float c, ref float d)
    {
        float invLength = 1.0f / (float)Math.Sqrt(a * a + b * b + c * c + d * d);
        a *= invLength;
        b *= invLength;
        c *= invLength;
        d *= invLength;
    }

    public static void Decode3(uint u, out float x, out float y, out float z)
    {
        x = ((u >> 20) & 0x3ffu) / 511.0f - 1.0f;
        y = ((u >> 10) & 0x3ffu) / 511.0f - 1.0f;
        z = (u & 0x3ffu) / 511.0f - 1.0f;
    }

    public static void DecodeQuaternion(uint u, out float a, out float b, out float c, out float d)
    {
        a = b = c = d = 0;
        switch (u >> 30)
        {
            case 0: a = 1.0f; Decode3(u, out b, out c, out d); break;
            case 1: b = 1.0f; Decode3(u, out a, out c, out d); break;
            case 2: c = 1.0f; Decode3(u, out a, out b, out d); break;
            case 3: d = 1.0f; Decode3(u, out a, out b, out c); break;
        }
        NormalizeQuaternion(ref a, ref b, ref c, ref d);
    }
}

Aressera said:
To get the best possible size, I guess you would want to transmit a quaternion in an axis+angle representation.

That's still 4 values, but you could use a ‘rotation vector’ instead. There seems no general name for this, so that's just how i call it.
I mean simply axis scaled by angle, so 3 values, as used to represent angular velocity in physics, for example.

hplus0603 said:

@alvaro Shouldn't Decode3() actually set a = b = c = d = 1 for the decode path?

I think the code posted won't work without that!

I don't understand your objection. Decode3 doesn't know about a, b, c or d.

Actually, the line a=b=c=d=0 isn't needed at all. I originally wrote the code in C++ and used GPT-4 to translate it to C#, and I think it added that for no reason. My bad for not checking more carefully.

All variables are assigned values in every case.