Lidgren.Network.NetIncomingMessage.ReadSingle C# (CSharp) Method

        public float ReadSingle()
        {
            NetException.Assert(m_bitLength - m_readPosition >= 32, c_readOverflowError);

            if ((m_readPosition & 7) == 0) // read directly
            {
                // endianness is handled inside BitConverter.ToSingle
                float retval = BitConverter.ToSingle(m_data, m_readPosition >> 3);
                m_readPosition += 32;
                return retval;
            }

            byte[] bytes = ReadBytes(4);
            return BitConverter.ToSingle(bytes, 0); // endianness is handled inside BitConverter.ToSingle
        }

        // received a library message while Connected
        internal void ReceivedLibraryMessage(NetMessageType tp, int ptr, int payloadLength)
        {
            m_peer.VerifyNetworkThread();

            float now = (float)NetTime.Now;

            switch (tp)
            {
            case NetMessageType.Disconnect:
                NetIncomingMessage msg = m_peer.SetupReadHelperMessage(ptr, payloadLength);
                ExecuteDisconnect(msg.ReadString(), false);
                break;

            case NetMessageType.Acknowledge:
                for (int i = 0; i < payloadLength; i += 3)
                {
                    NetMessageType acktp = (NetMessageType)m_peer.m_receiveBuffer[ptr++];                             // netmessagetype
                    int            seqNr = m_peer.m_receiveBuffer[ptr++];
                    seqNr |= (m_peer.m_receiveBuffer[ptr++] << 8);

                    NetSenderChannelBase chan = m_sendChannels[(int)acktp - 1];
                    if (chan == null)
                    {
                        chan = CreateSenderChannel(acktp);
                    }

                    //m_peer.LogVerbose("Received ack for " + acktp + "#" + seqNr);

                    chan.ReceiveAcknowledge(now, seqNr);
                }
                break;

            case NetMessageType.Ping:
                int pingNr = m_peer.m_receiveBuffer[ptr++];
                SendPong(pingNr);
                break;

            case NetMessageType.Pong:
                NetIncomingMessage pmsg = m_peer.SetupReadHelperMessage(ptr, payloadLength);
                int   pongNr            = pmsg.ReadByte();
                float remoteSendTime    = pmsg.ReadSingle();
                ReceivedPong(now, pongNr, remoteSendTime);
                break;

            case NetMessageType.ExpandMTURequest:
                SendMTUSuccess(payloadLength);
                break;

            case NetMessageType.ExpandMTUSuccess:
                NetIncomingMessage emsg = m_peer.SetupReadHelperMessage(ptr, payloadLength);
                int size = emsg.ReadInt32();
                HandleExpandMTUSuccess(now, size);
                break;

            default:
                m_peer.LogWarning("Connection received unhandled library message: " + tp);
                break;
            }
        }