在光子统一中序列化 Vector3d 数据类型

Question

I want to use vector3d datatype in PUN RPC parameter but Photon doesn't accept vector3d. We need to register and serialize it to use in RPC method. I am having some issues with the serialization code.

namespace VoxelPlay
{
    internal static class MyCustomDataType
    {
        
        internal static void Register()
        {

            PhotonPeer.RegisterType(typeof(Vector3d), (byte)'V', SerializeVector3d, DeserializeVector3d);

        }

        public static readonly byte[] memVector3d = new byte[3 * 4];

        private static short SerializeVector3d(StreamBuffer outStream, object customobject)
        {
            Vector3d vo = (Vector3d)customobject;

            int index = 0;
            lock (memVector3d)
            {
                byte[] bytes = memVector3d;
                Protocol.Serialize(vo.x, bytes, ref index);      //Getting error: Cannot convert from double to short
                Protocol.Serialize(vo.y, bytes, ref index);
                Protocol.Serialize(vo.z, bytes, ref index);
                outStream.Write(bytes, 0, 3 * 4);
            }
            return 3 * 4;
        }

        private static object DeserializeVector3d(StreamBuffer inStream, short length)
        {
            Vector3d vo = new Vector3d();
            lock (memVector3d)
            {
                inStream.Read(memVector3d, 0, 3 * 4);
                int index = 0;
                Protocol.Deserialize(out vo.x, memVector3d, ref index);
                Protocol.Deserialize(out vo.y, memVector3d, ref index);
                Protocol.Deserialize(out vo.z, memVector3d, ref index);
            }

            return vo;
        }
    }
}

Answer 1

ExitGames.Client.Photon.Protocol.Serialize indeed only (de)serializes short , int or float .

However, you could easily define your very own double (de) serialization eg usingBitConverter and/or Buffer.BlockCopy

Note that your array was wrong anyway! A double has not 4 but rather 8 bytes

I would recommend you use sizeof for this kind of things;)

internal static class MyCustomDataType
{
    internal static void Register()
    {
        PhotonPeer.RegisterType(typeof(Vector3d), (byte)'V', SerializeVector3d, DeserializeVector3d);
    }

    // Note: Your array had the wrong length anyway!
    // double is not 4 but 8 bytes!
    // Instead of magic numbers rather use sizeof in general
    public const short ByteSize = 3 * sizeof(double);
    public static readonly byte[] memVector3d = new byte[ByteSize];

    private static short SerializeVector3d(StreamBuffer outStream, object customobject)
    {
        var vo = (Vector3d)customobject;

        var index = 0;
        lock (memVector3d)
        {
            ToBytes(vo.x, memVector3d, ref index);      
            ToBytes(vo.y, memVector3d, ref index);
            ToBytes(vo.z, memVector3d, ref index);
            outStream.Write(memVector3d, 0, ByteSize);
        }
        return ByteSize;
    }

    private static object DeserializeVector3d(StreamBuffer inStream, short length)
    {
        var vo = new Vector3d();
        lock (memVector3d)
        {
            inStream.Read(memVector3d, 0, ByteSize);
            int index = 0;
            ReadDouble(out vo.x, memVector3d, ref index);
            ReadDouble(out vo.y, memVector3d, ref index);
            ReadDouble(out vo.z, memVector3d, ref index);
        }

        return vo;
    }

    private static void byte[] ToBytes(double input, byte[] bytes, ref offset)
    {
        // Converts the double to a byte[] of length "sizeof(double)" (=8)
        var doubleBytes = BitConverter.ToBytes(input);
        // Copy the content of the doubleSize into the combined bytes
        // starting at current offset
        Buffer.BlockCopy(doubleBytes, 0, bytes, offset, doubleBytes.Length);
        // increase by the copied size
        offset += doubleBytes.Length;
    }

    private static void ReadDouble(out double value, byte[] bytes, ref offset)
    {
        // Reads "sizeof(double)" (=8) byes starting at given offset
        // and converts them to a double
        value = BitConverter.ToDouble(bytes, offset);
        // Increase by the amount of read bytes
        offset+=sizeof(double);
        return output;
    }
}

---

Or a probably slightly more efficient approach would be to use the Buffer.BlockCopy directly for converting the values like

internal static class MyCustomDataType
{
    internal static void Register()
    {
        PhotonPeer.RegisterType(typeof(Vector3d), (byte)'V', SerializeVector3d, DeserializeVector3d);
    }

    // Note: Your array had the wrong length anyway!
    // double is not 4 but 8 bytes!
    // Instead of magic numbers rather use sizeof in general
    public const short ByteSize = 3 * sizeof(double);
    public static readonly byte[] memVector3d = new byte[ByteSize];
    public static readonly double[] doubles = new double[3];

    private static short SerializeVector3d(StreamBuffer outStream, object customobject)
    {
        var vo = (Vector3d)customobject;

        lock (memVector3d)
        {
            // Fill the doubles array
            doubles[0] = vo.x;
            doubles[1] = vo.y;
            doubles[2] = vo.z;

            // directly copy that array on the bytes level
            Buffer.BlockCopy(floats, 0, memVector3d, 0, ByteSize);
            
            outStream.Write(memVector3d, 0, ByteSize);
        }
        return ByteSize;
    }

    private static object DeserializeVector3d(StreamBuffer inStream, short length)
    {
        var vo = new Vector3d();
        lock (memVector3d)
        {
            inStream.Read(memVector3d, 0, ByteSize);

            // Just the other way round directly copy into the doubles array on byte level
            Buffer.BlockCopy(memVector3d, 0, floats, 0, ByteSize);
            
            vo.x = doubles[0];
            vo.y = doubles[1];
            vo.z = doubles[2];
        }

        return vo;
    }
}

---

And now allow me the question: Do you really need Vector3d with double values?

Basically everything in Unity uses float anyway so at some point you will lose precision anyway. So why not already lose the precision while synchronizing?

And afaik the Vector3 has built-in support in Photon so no custom code has to be written/maintained.

---

As alternative if losing precision is ok while synchronizing but you still want to use Vector3d you could probably simply use

Protocol.Serialize((float)vo.x, bytes, ref index);
Protocol.Serialize((float)vo.y, bytes, ref index);
Protocol.Serialize((float)vo.z, bytes, ref index);

And then for receiving just make sure it uses the float version

Protocol.Deserialize(out float x, memVector3d, ref index);
Protocol.Deserialize(out float y, memVector3d, ref index);
Protocol.Deserialize(out float z, memVector3d, ref index);

vo.x = x;
vo.y = y;
vo.z = z;
        

But then again, why not simply use Vector3 in the first place, assuming it is supported directly as mentioned before.