C# (CSharp) Lidgren.Network NetBitWriter.WriteUInt32示例

WriteUInt32() public static method

Writes the specified number of bits into a byte array

public static WriteUInt32 ( uint source, int numberOfBits, byte destination, int destinationBitOffset ) : int
source	uint
numberOfBits	int
destination	byte
destinationBitOffset	int
return	int

示例#1

文件： NetBuffer.Write.cs 项目： DisruptionTheory/Iris

 public void Write(UInt32 source, int numberOfBits)
 {
     NetException.Assert((numberOfBits > 0 && numberOfBits <= 32), "Write(uint, numberOfBits) can only write between 1 and 32 bits");
     EnsureBufferSize(m_bitLength + numberOfBits);
     NetBitWriter.WriteUInt32(source, numberOfBits, m_data, m_bitLength);
     m_bitLength += numberOfBits;
 }

示例#2

 internal void Write(UInt16 source, int numberOfBits)
 {
     NetException.Assert((numberOfBits > 0 && numberOfBits <= 16), "Write(ushort, numberOfBits) can only write between 1 and 16 bits");
     InternalEnsureBufferSize(m_bitLength + numberOfBits);
     NetBitWriter.WriteUInt32((uint)source, numberOfBits, m_data, m_bitLength);
     m_bitLength += numberOfBits;
 }

示例#3

文件： NetBuffer.Write.cs 项目： RevoluPowered/lidgren-network

        public void WriteAt(Int32 offset, UInt32 source)
        {
            int newBitLength = Math.Max(m_bitLength, offset + 32);

            EnsureBufferSize(newBitLength);
            NetBitWriter.WriteUInt32(source, 32, m_data, offset);
            m_bitLength = newBitLength;
        }

示例#4

文件： NetBuffer.Write.cs 项目： JimmyCushnie/lidgren-network-gen3

        /// <summary>
        /// Writes a 32 bit signed integer at a given offset in the buffer
        /// </summary>
        public NetBuffer WriteAt(Int32 offset, Int32 source)
        {
            int newBitLength = Math.Max(m_bitLength, offset + 32);

            EnsureBufferSize(newBitLength);
            NetBitWriter.WriteUInt32((UInt32)source, 32, m_data, offset);
            m_bitLength = newBitLength;
            return(this);
        }

示例#5

文件： NetBuffer.Write.cs 项目： exp111/RobustToolbox

        /// <summary>
        /// Writes a 32 bit signed integer
        /// </summary>
        public void Write(Int32 source)
        {
            EnsureBufferSize(m_bitLength + 32);

            // can write fast?
            if ((m_bitLength & 7) == 0)
            {
                MemoryMarshal.Write(new Span <byte>(Buffer, m_bitLength / 8, 4), ref source);
            }
            else
            {
                NetBitWriter.WriteUInt32((UInt32)source, 32, Buffer, m_bitLength);
            }
            m_bitLength += 32;
        }

示例#6

文件： NetBuffer.Write.cs 项目： RevoluPowered/lidgren-network

        /// <summary>
        /// Writes a 32 bit signed integer
        /// </summary>
        public unsafe void Write(Int32 source)
        {
            EnsureBufferSize(m_bitLength + 32);

            // can write fast?
            if (m_bitLength % 8 == 0)
            {
                fixed(byte *numRef = &Data[m_bitLength / 8])
                {
                    *((int *)numRef) = source;
                }
            }
            else
            {
                NetBitWriter.WriteUInt32((UInt32)source, 32, Data, m_bitLength);
            }
            m_bitLength += 32;
        }

示例#7

文件： NetBuffer.Write.cs 项目： Ignis34Rus/LoE-Ghost.Server

        public void Write(UInt32 source)
        {
            EnsureBufferSize(m_bitLength + 32);
#if UNSAFE
            // can write fast?
            if (m_bitLength % 8 == 0)
            {
                unsafe
                {
                    fixed(byte *numRef = &m_data[m_bitLength / 8])
                    {
                        *((uint *)numRef) = source;
                    }
                }
            }
            else
#endif
            {
                NetBitWriter.WriteUInt32(source, 32, m_data, m_bitLength);
            }
            m_bitLength += 32;
        }

示例#8

文件： NetBuffer.Write.cs 项目： RevoluPowered/lidgren-network

        /// <summary>
        /// Writes a signed integer using 1 to 32 bits
        /// </summary>
        public void Write(Int32 source, int numberOfBits)
        {
            NetException.Assert((numberOfBits > 0 && numberOfBits <= 32), "Write(int, numberOfBits) can only write between 1 and 32 bits");
            EnsureBufferSize(m_bitLength + numberOfBits);

            if (numberOfBits != 32)
            {
                // make first bit sign
                int signBit = 1 << (numberOfBits - 1);
                if (source < 0)
                {
                    source = (-source - 1) | signBit;
                }
                else
                {
                    source &= (~signBit);
                }
            }

            NetBitWriter.WriteUInt32((uint)source, numberOfBits, m_data, m_bitLength);

            m_bitLength += numberOfBits;
        }

示例#9

文件： NetBuffer.Write.cs 项目： RevoluPowered/lidgren-network

 public void Write(UInt32 source)
 {
     EnsureBufferSize(m_bitLength + 32);
     NetBitWriter.WriteUInt32(source, 32, m_data, m_bitLength);
     m_bitLength += 32;
 }

示例#10

 public void Write(Int16 source)
 {
     EnsureBufferSize(m_bitLength + 16);
     NetBitWriter.WriteUInt32((uint)source, 16, m_data, m_bitLength);
     m_bitLength += 16;
 }

示例#11

 internal void Write(Int32 source)
 {
     InternalEnsureBufferSize(m_bitLength + 32);
     NetBitWriter.WriteUInt32((UInt32)source, 32, m_data, m_bitLength);
     m_bitLength += 32;
 }