OVRAvatarView

/**
 * Created Date: 9/18/2018
 * Author: Octavian Pintiliciuc
 *
 * Copyright (c) 2018 ATiStudios. All rights reserved.
 */

using System.Collections.Generic;
using System.IO;
using ATiStudios.Core;
using UnityEngine;

namespace ATiStudios.MondlyVR.MultiplayerPhoton.Scripts {
    public class OVRAvatarView : BaseMonoBehaviour {
        private PhotonView _photonView;
        private OvrAvatar _ovrAvatar;
        private OvrAvatarRemoteDriver _ovrAvatarRemoteDriver;
        private List<byte[]> _packetData;
        private int _localSequence;

        protected override void StartComponent() {
            base.StartComponent();
            this._packetData = new List<byte[]>();
            this._photonView = GetComponent<PhotonView>();
            if (this._photonView.isMine) {
                this._ovrAvatar = GetComponent<OvrAvatar>();
                this._ovrAvatar.RecordPackets = true;
                this._ovrAvatar.PacketRecorded += OnLocalAvatarPacketRecorded;
                this._ovrAvatar.StartWithControllers = false;
                this._ovrAvatar.oculusUserID = PlayerNetwork.Instance.SelectedAvatarId;
            } else {
                this._ovrAvatarRemoteDriver = GetComponent<OvrAvatarRemoteDriver>();
            }
        }

        public void OnDisable() {
            if (this._photonView.isMine) {
                this._ovrAvatar.RecordPackets = false;
                this._ovrAvatar.PacketRecorded -= OnLocalAvatarPacketRecorded;
            }
        }

        public void OnLocalAvatarPacketRecorded(object sender, OvrAvatar.PacketEventArgs args) {
            if (!PhotonNetwork.inRoom || PhotonNetwork.room.PlayerCount < 2 || !OvrAvatarSDKManager.Instance.IsInitialized) {
                return;
            }

            using (MemoryStream outputStream = new MemoryStream()) {
                BinaryWriter writer = new BinaryWriter(outputStream);

                var size = Oculus.Avatar.CAPI.ovrAvatarPacket_GetSize(args.Packet.ovrNativePacket);
                byte[] data = new byte[size];
                Oculus.Avatar.CAPI.ovrAvatarPacket_Write(args.Packet.ovrNativePacket, size, data);

                writer.Write(this._localSequence++);
                writer.Write(size);
                writer.Write(data);

                this._packetData.Add(outputStream.ToArray());
            }
        }

        private void DeserializeAndQueuePacketData(byte[] data) {
            using (MemoryStream inputStream = new MemoryStream(data)) {
                BinaryReader reader = new BinaryReader(inputStream);
                int remoteSequence = reader.ReadInt32();

                int size = reader.ReadInt32();
                byte[] sdkData = reader.ReadBytes(size);

                System.IntPtr packet = Oculus.Avatar.CAPI.ovrAvatarPacket_Read((System.UInt32) data.Length, sdkData);
                this._ovrAvatarRemoteDriver.QueuePacket(remoteSequence, new OvrAvatarPacket {ovrNativePacket = packet});
            }
        }

        public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info) {
            if (stream.isWriting) {
                if (this._packetData.Count == 0) {
                    return;
                }

                stream.SendNext(this._packetData.Count);

                foreach (byte[] b in this._packetData) {
                    stream.SendNext(b);
                }

                this._packetData.Clear();
            }

            if (stream.isReading) {
                int num = (int) stream.ReceiveNext();

                for (int counter = 0; counter < num; ++counter) {
                    byte[] data = (byte[]) stream.ReceiveNext();

                    DeserializeAndQueuePacketData(data);
                }
            }
        }
    }
}