public unsafe void Serialize(ref byte[] buffer, ref int offset, T[] value) { int count = value.Length; // Ensure capacity int size = _itemSize; int neededSize = (count * size) + 5; SerializerBinary.EnsureCapacity(ref buffer, offset, neededSize); // Count SerializerBinary.WriteUInt32NoCheck(buffer, ref offset, (uint)count); int bytes = count * size; if (bytes == 0) { return; // Write fixed(T *srcAr = &value[0]) fixed(byte *destAr = &buffer[0]) { byte *src = (byte *)srcAr; byte *dest = destAr + offset; SerializerBinary.FastCopy(src, dest, (uint)bytes); } offset += bytes; }
public unsafe void Serialize(ref byte[] buffer, ref int offset, Vector3 value) { const int v3Size = 3 * 4; SerializerBinary.EnsureCapacity(ref buffer, offset, v3Size); var bufferLocal = buffer; fixed(byte *pBuffer = buffer) { var ptr = (float *)(pBuffer + offset); *ptr = value.X; } fixed(byte *pBuffer = buffer) { var ptr = (float *)(pBuffer + offset + 4); *ptr = value.Y; } fixed(byte *pBuffer = buffer) { var ptr = (float *)(pBuffer + offset + 8); *ptr = value.Z; } offset += v3Size; }
public unsafe void Serialize(ref byte[] buffer, ref int offset, T[] value) { // Ensure capacity int size = _size; int neededSize = size + 5; SerializerBinary.EnsureCapacity(ref buffer, offset, neededSize); // Count int count = value.Length; SerializerBinary.WriteUInt32NoCheck(buffer, ref offset, (uint)count); int bytes = count * size; if (bytes == 0) { return; // Write fixed(T *p = value) Marshal.Copy(new IntPtr(p), buffer, offset, count); offset += bytes; }
public void Serialize(ref byte[] buffer, ref int offset, T value) { SerializerBinary.EnsureCapacity(ref buffer, offset, _size); Write_Raw(buffer, offset, ref value); offset += _size; }
public void Serialize(ref byte[] buffer, ref int offset, T value) { SerializerBinary.EnsureCapacity(ref buffer, offset, Unsafe.SizeOf <T>()); Write_Raw(buffer, offset, ref value); offset += Unsafe.SizeOf <T>(); }
public void Serialize(ref byte[] buffer, ref int offset, Vector3 value) { const int v3Size = 3 * 4; SerializerBinary.EnsureCapacity(ref buffer, offset, v3Size); SerializerBinary.WriteFloat32FixedNoCheck(ref buffer, ref offset, value.X); SerializerBinary.WriteFloat32FixedNoCheck(ref buffer, ref offset, value.Y); SerializerBinary.WriteFloat32FixedNoCheck(ref buffer, ref offset, value.Z); }
public void Serialize(ref byte[] buffer, ref int offset, Ulid value) { // Ensures that we have enough space to cram in an Ulid SerializerBinary.EnsureCapacity(ref buffer, offset, 16); var byteSpan = buffer.AsSpan(offset, 16); value.TryWriteBytes(byteSpan); // Move 128 bits further offset += 16; }
public void Serialize(ref byte[] buffer, ref int offset, decimal value) { SerializerBinary.EnsureCapacity(ref buffer, offset, 16); fixed(byte *dst = &buffer[offset]) { var src = &value; *(decimal *)(dst) = *src; offset += 16; } }
public void Serialize(ref byte[] buffer, ref int offset, T value) { SerializerBinary.EnsureCapacity(ref buffer, offset, _size); fixed(byte *pBuffer = buffer) { var ptr = (T *)(pBuffer + offset); *ptr = value; } offset += _size; }
public void Serialize(ref byte[] buffer, ref int offset, Bitmap img) { // Let the image serialize itself to the memory stream // Its unfortunate that there's only a stream-based api... // The alternative would be manually locking the bits. // That would be easy, but we'd potentially lose some information (animation frames etc?) // Prepare buffer stream if (_sharedMemoryStream == null) { _sharedMemoryStream = new MemoryStream(200 * 1024); } var stream = _sharedMemoryStream; // Encode image into stream stream.Position = 0; var format = BitmapModeToImgFormat(BitmapMode); img.Save(stream, format); long sizeLong = stream.Length; if (sizeLong > int.MaxValue) { throw new InvalidOperationException("image too large"); } int size = (int)sizeLong; stream.Position = 0; var streamBuffer = stream.GetBuffer(); // Write Size SerializerBinary.WriteUInt32Fixed(ref buffer, ref offset, (uint)size); // Write stream data to serialization buffer if (size > 0) { SerializerBinary.EnsureCapacity(ref buffer, offset, size); SerializerBinary.FastCopy(streamBuffer, 0, buffer, (uint)offset, (uint)size); } offset += size; }
public void Serialize(ref byte[] buffer, ref int offset, Bitmap img) { // Let the image serialize itself to the memory stream // Its unfortunate that there's only a stream-based api... // The alternative would be manually locking the bits. // That would be easy, but we'd potentially lose some information (animation frames etc?) var mode = BitmapMode; var format = BitmapModeToImgFormat(mode); if (_sharedMemoryStream == null) { _sharedMemoryStream = new MemoryStream((int)(4 * (img.Width * img.Height) * 1.35)); } var ms = _sharedMemoryStream; ms.Position = 0; img.Save(ms, format); long sizeLong = ms.Position; if (sizeLong > int.MaxValue) { throw new InvalidOperationException("image too large"); } int size = (int)sizeLong; ms.Position = 0; var memoryStreamBuffer = ms.GetBuffer(); // Write Size SerializerBinary.WriteUInt32Fixed(ref buffer, ref offset, (uint)size); // Write data into serialization buffer if (size > 0) { SerializerBinary.EnsureCapacity(ref buffer, offset, size); SerializerBinary.FastCopy(memoryStreamBuffer, 0, buffer, offset, size); } offset += size; }
public void Serialize(ref byte[] buffer, ref int offset, byte[] ar) { if (ar == null) { SerializerBinary.WriteUInt32Bias(ref buffer, ref offset, -1, 1); return; } var len = ar.Length; // Ensure we have enough space for the worst-case VarInt plus the byte array itself SerializerBinary.EnsureCapacity(ref buffer, offset, 5 + len); // Write the length, no need to check the capacity (we did that here) SerializerBinary.WriteUInt32BiasNoCheck(ref buffer, ref offset, len, 1); // Blit the array System.Array.Copy(ar, 0, buffer, offset, len); offset += len; }
public unsafe void Serialize(ref byte[] buffer, ref int offset, T[] value) { // Ensure capacity int size = _size; int neededSize = size + 5; SerializerBinary.EnsureCapacity(ref buffer, offset, neededSize); // Count int count = value.Length; SerializerBinary.WriteUInt32NoCheck(buffer, ref offset, (uint)count); int bytes = count * size; if (bytes == 0) { return; } // Write #if NETSTANDARD2_0 || NET47 fixed(T *srcAr = &value[0]) fixed(byte *dest = &buffer[offset]) { byte *srcByteAr = (byte *)srcAr; Buffer.MemoryCopy(srcByteAr, dest, bytes, bytes); } #else fixed(T *p = &value[0]) Marshal.Copy(new IntPtr(p), buffer, offset, count); #endif offset += bytes; }