Пример #1
0
        /// <summary>
        /// Serialises the currently active objects in for playback from file.
        /// </summary>
        /// <param name="writer">The write to serialise to.</param>
        /// <param name="info">Statistics</param>
        /// <returns>An error code on failure.</returns>
        public override Error Serialise(BinaryWriter writer, ref SerialiseInfo info)
        {
            info.TransientCount = info.PersistentCount = 0u;
            Error err = SerialiseObjects(writer, _transientCache.Objects.GetEnumerator(), ref info.TransientCount);

            if (err.Failed)
            {
                return(err);
            }

            err = SerialiseObjects(writer, _shapeCache.Objects.GetEnumerator(), ref info.PersistentCount);
            return(err);
        }
Пример #2
0
        /// <summary>
        /// Serialise messages required to restore the current state.
        /// </summary>
        /// <param name="writer"></param>
        /// <param name="info">Statistics</param>
        /// <returns>An error code on failure.</returns>
        public override Error Serialise(BinaryWriter writer, ref SerialiseInfo info)
        {
            // Iterate and serialise the meshes.
            PacketBuffer packet = new PacketBuffer();

            info.TransientCount = info.PersistentCount = 0u;
            foreach (MeshDetails mesh in _meshes.Values)
            {
                ++info.PersistentCount;
                Error err = Serialise(mesh, packet, writer);
                if (err.Failed)
                {
                    return(err);
                }
            }

            return(new Error());
        }
Пример #3
0
        /// <summary>
        /// Serialisation.
        /// </summary>
        /// <param name="writer"></param>
        /// <param name="info">Statistics</param>
        /// <returns></returns>
        public override Error Serialise(BinaryWriter writer, ref SerialiseInfo info)
        {
            PacketBuffer packet = new PacketBuffer();

            info.TransientCount = info.PersistentCount = 0u;

            if (!Serialise(TransientText, packet, writer, ref info.TransientCount))
            {
                return(new Error(ErrorCode.SerialisationFailure));
            }

            if (!Serialise(PersistentText, packet, writer, ref info.PersistentCount))
            {
                return(new Error(ErrorCode.SerialisationFailure));
            }

            return(new Error());
        }
Пример #4
0
        /// <summary>
        /// Serialises the currently active objects in for playback from file.
        /// </summary>
        /// <param name="writer">The write to serialise to.</param>
        /// <param name="info">Statistics</param>
        /// <returns>An error code on failure.</returns>
        public override Error Serialise(BinaryWriter writer, ref SerialiseInfo info)
        {
            Error err = new Error();

            info.PersistentCount = info.TransientCount = 0;
            if (_cameras.Count > 0)
            {
                PacketBuffer  packet = new PacketBuffer(256);
                CameraMessage msg    = new CameraMessage();
                Vector3       v      = Vector3.zero;
                msg.Reserved1 = 0;
                msg.Reserved2 = 0;
                foreach (CameraInfo camera in _cameras.Values)
                {
                    ++info.PersistentCount;
                    msg.CameraID = camera.ID;
                    v            = FrameTransform.UnityToRemote(camera.transform.localPosition, ServerInfo.CoordinateFrame);
                    msg.X        = v.x;
                    msg.Y        = v.y;
                    msg.Z        = v.z;
                    v            = FrameTransform.UnityToRemote(camera.transform.forward, ServerInfo.CoordinateFrame);
                    msg.DirX     = v.x;
                    msg.DirY     = v.y;
                    msg.DirZ     = v.z;
                    v            = FrameTransform.UnityToRemote(camera.transform.up, ServerInfo.CoordinateFrame);
                    msg.UpX      = v.x;
                    msg.UpY      = v.y;
                    msg.UpZ      = v.z;
                    msg.Near     = camera.Near;
                    msg.Far      = camera.Far;
                    msg.FOV      = camera.FOV;
                    packet.Reset(RoutingID, 0);
                    msg.Write(packet);
                    packet.FinalisePacket();
                    packet.ExportTo(writer);
                }
            }

            return(err);
        }
        /// <summary>
        /// Serialises the currently active objects in for playback from file.
        /// </summary>
        /// <param name="writer">The write to serialise to.</param>
        /// <param name="info">Statistics</param>
        /// <returns>An error code on failure.</returns>
        public override Error Serialise(BinaryWriter writer, ref SerialiseInfo info)
        {
            Error err = new Error();

            info.TransientCount = info.PersistentCount = 0u;

            PacketBuffer        packet = new PacketBuffer(1024);
            CategoryNameMessage msg    = new CategoryNameMessage();

            foreach (Category cat in _categories.Values)
            {
                ++info.PersistentCount;
                msg.CategoryID    = cat.ID;
                msg.ParentID      = cat.ParentID;
                msg.DefaultActive = cat.Active;
                msg.Name          = cat.Name;
                packet.Reset(RoutingID, CategoryNameMessage.MessageID);
                msg.Write(packet);
                packet.FinalisePacket();
                packet.ExportTo(writer);
            }

            return(err);
        }