Ejemplo n.º 1
0
        /// <summary>
        /// Read <see cref="DataMessage"/> and payload generated by <see cref="WriteData(PacketBuffer, ref uint)"/>.
        /// </summary>
        /// <param name="reader">Stream to read from</param>
        /// <returns>True on success.</returns>
        public override bool ReadData(BinaryReader reader)
        {
            DataMessage msg = new DataMessage();

            if (!msg.Read(reader))
            {
                return(false);
            }

            if (ID != msg.ObjectID)
            {
                return(false);
            }

            ArrayComponentAdaptor <Vector3> normalsAdaptor = new ArrayComponentAdaptor <Vector3>(_normals);
            ColoursAdaptor coloursAdaptor = new ColoursAdaptor(_colours);
            int            readComponent  = ReadDataComponent(reader,
                                                              new ArrayComponentAdaptor <Vector3>(_vertices),
                                                              new ArrayComponentAdaptor <int>(_indices),
                                                              normalsAdaptor, coloursAdaptor);

            if (readComponent == -1)
            {
                return(false);
            }

            // Normals and colours may have been (re)allocated. Store the results.
            switch (readComponent & ~(int)(SendDataType.End | SendDataType.ExpectEnd))
            {
            case (int)SendDataType.Normals:
            case (int)SendDataType.UniformNormal:
                // Normals array may have been (re)allocated.
                _normals = normalsAdaptor.Array;
                break;

            case (int)SendDataType.Colours:
                // Colours array may have been (re)allocated.
                _colours = coloursAdaptor.Array;
                break;
            }

            // Check for finalisation.
            // Complete if ((readComponent & (int)SendDataType.End) != 0)

            return(true);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Overridden to handle triangle data in the <paramref name="msg"/>
        /// </summary>
        /// <param name="msg"></param>
        /// <param name="packet"></param>
        /// <param name="reader"></param>
        /// <returns></returns>
        protected override Error HandleMessage(DataMessage msg, PacketBuffer packet, BinaryReader reader)
        {
            GameObject obj = null;

            if (msg.ObjectID == 0)
            {
                // Transient object.
                obj = _transientCache.LastObject;
                if (!obj)
                {
                    return(new Error(ErrorCode.InvalidObjectID, 0));
                }
            }
            else
            {
                obj = FindObject(msg.ObjectID);
                if (!obj)
                {
                    // Object already exists.
                    return(new Error(ErrorCode.InvalidObjectID, msg.ObjectID));
                }
            }

            // Naive support for multiple packets. Assume:
            // - In order.
            // - Under the overall Unity mesh indexing limit.
            MeshDataComponent meshData = obj.GetComponent <MeshDataComponent>();

            Vector3ComponentAdaptor normalsAdaptor = new Vector3ComponentAdaptor(meshData.Normals);
            ColoursAdaptor          coloursAdaptor = new ColoursAdaptor(meshData.Colours);
            int readComponent = MeshShape.ReadDataComponent(reader,
                                                            new Vector3ComponentAdaptor(meshData.Vertices),
                                                            new MeshShape.ArrayComponentAdaptor <int>(meshData.Indices),
                                                            normalsAdaptor,
                                                            coloursAdaptor
                                                            );

            if (readComponent == -1)
            {
                return(new Error(ErrorCode.MalformedMessage, DataMessage.MessageID));
            }

            // Normals and colours may have been (re)allocated. Store the results.
            switch (readComponent & ~(int)(MeshShape.SendDataType.End | MeshShape.SendDataType.ExpectEnd))
            {
            case (int)MeshShape.SendDataType.Normals:
            case (int)MeshShape.SendDataType.UniformNormal:
                // Normals array may have been (re)allocated.
                meshData.Normals = normalsAdaptor.Array;
                break;

            case (int)MeshShape.SendDataType.Colours:
                // Colours array may have been (re)allocated.
                meshData.Colours = coloursAdaptor.Array;
                break;
            }

            // Check for finalisation.
            if ((readComponent & (int)MeshShape.SendDataType.End) != 0)
            {
                _awaitingFinalisation.Add(meshData);
            }

            return(new Error());
        }