mirror of
https://gitlab.com/Syroot/Worms.git
synced 2025-04-06 09:29:03 +03:00
Get rid of DisposableGCHandle.
Use Span functionality instead. This introduces some copies for .NET Standard 2.0 builds.
This commit is contained in:
Ray Koopa
parent
b4cf309156
commit
57815e9072
@ -1,44 +0,0 @@
|
||||
using System;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace Syroot.Worms.Core
|
||||
{
|
||||
/// <summary>
|
||||
/// Represents a disposable <see cref="GCHandle"/>.
|
||||
/// </summary>
|
||||
internal class DisposableGCHandle : IDisposable
|
||||
{
|
||||
// ---- FIELDS -------------------------------------------------------------------------------------------------
|
||||
|
||||
private readonly GCHandle _handle;
|
||||
private bool _disposed;
|
||||
|
||||
// ---- CONSTRUCTORS & DESTRUCTOR ------------------------------------------------------------------------------
|
||||
|
||||
public DisposableGCHandle(object value, GCHandleType type) => _handle = GCHandle.Alloc(value, type);
|
||||
|
||||
// ---- PROPERTIES ---------------------------------------------------------------------------------------------
|
||||
|
||||
public IntPtr AddrOfPinnedObject => _handle.AddrOfPinnedObject();
|
||||
|
||||
// ---- METHODS (PUBLIC) ---------------------------------------------------------------------------------------
|
||||
|
||||
public void Dispose() => Dispose(true);
|
||||
|
||||
// ---- METHODS (PROTECTED) ------------------------------------------------------------------------------------
|
||||
|
||||
protected virtual void Dispose(bool disposing)
|
||||
{
|
||||
if (_disposed)
|
||||
return;
|
||||
|
||||
if (disposing)
|
||||
{
|
||||
if (_handle.IsAllocated)
|
||||
_handle.Free();
|
||||
}
|
||||
|
||||
_disposed = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,7 +1,7 @@
|
||||
using System.Collections.Generic;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Drawing;
|
||||
using System.Drawing.Imaging;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace Syroot.Worms.Core.Graphics
|
||||
{
|
||||
@ -20,16 +20,15 @@ namespace Syroot.Worms.Core.Graphics
|
||||
/// <param name="palette">The palette as a <see cref="Color"/> array.</param>
|
||||
/// <param name="data">The data array storing bytes indexing the palette color array.</param>
|
||||
/// <returns>The <see cref="Bitmap"/> instance.</returns>
|
||||
public static Bitmap CreateIndexed(Size size, IList<Color> palette, byte[] data)
|
||||
public static unsafe Bitmap CreateIndexed(Size size, IList<Color> palette, byte[] data)
|
||||
{
|
||||
using DisposableGCHandle dataPin = new DisposableGCHandle(data, GCHandleType.Pinned);
|
||||
|
||||
// Transfer the pixel data, respecting power-of-2 strides.
|
||||
Bitmap bitmap = new Bitmap(size.Width, size.Height, PixelFormat.Format8bppIndexed);
|
||||
BitmapData bitmapData = bitmap.LockBits(new Rectangle(0, 0, size.Width, size.Height),
|
||||
ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed);
|
||||
for (int y = 0; y < size.Height; y++)
|
||||
Marshal.Copy(data, y * size.Width, bitmapData.Scan0 + y * bitmapData.Stride, size.Width);
|
||||
ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed);
|
||||
Span<byte> bitmapSpan = new Span<byte>(bitmapData.Scan0.ToPointer(), bitmapData.Stride * bitmapData.Height);
|
||||
for (int y = 0; y < size.Height; y++)
|
||||
data.AsSpan(y * size.Width, size.Width).CopyTo(bitmapSpan.Slice(y * bitmapData.Stride));
|
||||
bitmap.UnlockBits(bitmapData);
|
||||
|
||||
// Transfer the palette.
|
||||
|
||||
@ -1,8 +1,7 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Drawing;
|
||||
using System.Drawing.Imaging;
|
||||
using System.Runtime.InteropServices;
|
||||
using Syroot.Worms.Core;
|
||||
|
||||
namespace Syroot.Worms
|
||||
{
|
||||
@ -39,16 +38,15 @@ namespace Syroot.Worms
|
||||
/// Creates a <see cref="Bitmap"/> from the raw data.
|
||||
/// </summary>
|
||||
/// <returns>The <see cref="Bitmap"/> created from the raw data.</returns>
|
||||
public Bitmap ToBitmap()
|
||||
public unsafe Bitmap ToBitmap()
|
||||
{
|
||||
using DisposableGCHandle dataPin = new DisposableGCHandle(Data, GCHandleType.Pinned);
|
||||
|
||||
// Transfer the pixel data, respecting power-of-2 strides.
|
||||
Bitmap bitmap = new Bitmap(Size.Width, Size.Height, PixelFormat.Format8bppIndexed);
|
||||
BitmapData bitmapData = bitmap.LockBits(new Rectangle(0, 0, Size.Width, Size.Height),
|
||||
ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed);
|
||||
for (int y = 0; y < Size.Height; y++)
|
||||
Marshal.Copy(Data, y * Size.Width, bitmapData.Scan0 + y * bitmapData.Stride, Size.Width);
|
||||
ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed);
|
||||
Span<byte> bitmapSpan = new Span<byte>(bitmapData.Scan0.ToPointer(), bitmapData.Stride * bitmapData.Height);
|
||||
for (int y = 0; y < Size.Height; y++)
|
||||
Data.AsSpan(y * Size.Width, Size.Width).CopyTo(bitmapSpan.Slice(y * bitmapData.Stride));
|
||||
bitmap.UnlockBits(bitmapData);
|
||||
|
||||
// Transfer the palette.
|
||||
|
||||
@ -1,211 +1,225 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics;
|
||||
using System.IO;
|
||||
using System.Runtime.InteropServices;
|
||||
using Syroot.BinaryData;
|
||||
|
||||
namespace Syroot.Worms.Core.IO
|
||||
{
|
||||
/// <summary>
|
||||
/// Represents extension methods for <see cref="BinaryStream"/> instances.
|
||||
/// </summary>
|
||||
[DebuggerStepThrough]
|
||||
public static partial class BinaryStreamExtensions
|
||||
{
|
||||
// ---- METHODS (PUBLIC) ---------------------------------------------------------------------------------------
|
||||
|
||||
// ---- Reading ----
|
||||
|
||||
/// <summary>
|
||||
/// Reads an <see cref="ILoadable"/> instance from the current stream.
|
||||
/// </summary>
|
||||
/// <typeparam name="T">The type of the <see cref="ILoadable"/> class to instantiate.</typeparam>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/>.</param>
|
||||
/// <returns>The <see cref="ILoadable"/> instance.</returns>
|
||||
public static T Load<T>(this BinaryStream self) where T : ILoadable, new()
|
||||
{
|
||||
T instance = new T();
|
||||
instance.Load(self.BaseStream);
|
||||
return instance;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Reads <see cref="ILoadable"/> instances from the current stream.
|
||||
/// </summary>
|
||||
/// <typeparam name="T">The type of the <see cref="ILoadable"/> class to instantiate.</typeparam>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/>.</param>
|
||||
/// <param name="count">The number of instances to read.</param>
|
||||
/// <returns>The <see cref="ILoadable"/> instances.</returns>
|
||||
public static T[] Load<T>(this BinaryStream self, int count) where T : ILoadable, new()
|
||||
{
|
||||
T[] instances = new T[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
instances[i] = Load<T>(self);
|
||||
return instances;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Reads a 0-terminated string which is stored in a fixed-size block of <paramref name="length"/> bytes.
|
||||
/// </summary>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/>.</param>
|
||||
/// <param name="length">The number of bytes the fixed-size blocks takes.</param>
|
||||
/// <returns>The read string.</returns>
|
||||
public static string ReadString(this BinaryStream self, int length)
|
||||
{
|
||||
// TODO: This may not work with multi-byte encodings.
|
||||
// Ensure to not try to decode any bytes after the 0 termination.
|
||||
byte[] bytes = self.ReadBytes(length);
|
||||
while (bytes[--length] == 0 && length > 0) { }
|
||||
return self.Encoding.GetString(bytes, 0, length + 1);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Reads <paramref name="count"/> 0-terminated strings which are stored in a fixed-size block of
|
||||
/// <paramref name="length"/> bytes.
|
||||
/// </summary>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/>.</param>
|
||||
/// <param name="count">The number of values to read.</param>
|
||||
/// <param name="length">The number of bytes the fixed-size blocks takes.</param>
|
||||
/// <returns>The read string.</returns>
|
||||
public static string[] ReadStrings(this BinaryStream self, int count, int length)
|
||||
{
|
||||
string[] strings = new string[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
strings[i] = ReadString(self, length);
|
||||
return strings;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Reads a raw byte structure from the current stream and returns it.
|
||||
/// </summary>
|
||||
/// <typeparam name="T">The type of the structure to read.</typeparam>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/> instance.</param>
|
||||
/// <returns>The structure of type <typeparamref name="T"/>.</returns>
|
||||
public static T ReadStruct<T>(this BinaryStream self) where T : struct
|
||||
{
|
||||
// Read the raw bytes of the structure.
|
||||
byte[] bytes = self.ReadBytes(Marshal.SizeOf<T>());
|
||||
|
||||
// Convert them to a structure instance and return it.
|
||||
using DisposableGCHandle handle = new DisposableGCHandle(bytes, GCHandleType.Pinned);
|
||||
T instance = Marshal.PtrToStructure<T>(handle.AddrOfPinnedObject);
|
||||
return instance;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Reads raw byte structures from the current stream and returns them.
|
||||
/// </summary>
|
||||
/// <typeparam name="T">The type of the structure to read.</typeparam>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/> instance.</param>
|
||||
/// <param name="count">The number of values to read.</param>
|
||||
/// <returns>The structures of type <typeparamref name="T"/>.</returns>
|
||||
public static T[] ReadStructs<T>(this BinaryStream self, int count) where T : struct
|
||||
{
|
||||
T[] values = new T[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
values[i] = ReadStruct<T>(self);
|
||||
return values;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns the current address of the stream to which a 4-byte placeholder has been written which can be filled
|
||||
/// later.
|
||||
/// </summary>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/> instance.</param>
|
||||
/// <returns>The address at which a 4-byte placeholder has been written to.</returns>
|
||||
public static uint ReserveOffset(this BinaryStream self)
|
||||
{
|
||||
uint offset = (uint)self.Position;
|
||||
self.WriteUInt32(0);
|
||||
return offset;
|
||||
}
|
||||
|
||||
// ---- Writing ----
|
||||
|
||||
/// <summary>
|
||||
/// Writes the given <see cref="ISaveable"/> instance into the current stream.
|
||||
/// </summary>
|
||||
/// <typeparam name="T">The type of the <see cref="ISaveable"/> class to write.</typeparam>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/>.</param>
|
||||
/// <param name="value">The instance to write into the current stream.</param>
|
||||
public static void Save<T>(this BinaryStream self, T value) where T : ISaveable
|
||||
{
|
||||
value.Save(self.BaseStream);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Writes the given <see cref="ISaveable"/> instances into the current stream.
|
||||
/// </summary>
|
||||
/// <typeparam name="T">The type of the <see cref="ISaveable"/> class to write.</typeparam>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/>.</param>
|
||||
/// <param name="values">The instances to write into the current stream.</param>
|
||||
public static void Save<T>(this BinaryStream self, IList<T> values) where T : ISaveable
|
||||
{
|
||||
foreach (T value in values)
|
||||
Save(self, value);
|
||||
}
|
||||
|
||||
public static void SatisfyOffset(this BinaryStream self, uint offset, int value)
|
||||
{
|
||||
using (self.TemporarySeek(offset, SeekOrigin.Begin))
|
||||
self.WriteInt32(value);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Writes the given string into a fixed-size block of <paramref name="length"/> bytes and 0-terminates it.
|
||||
/// </summary>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/> instance.</param>
|
||||
/// <param name="value">The string to write.</param>
|
||||
/// <param name="length">The number of bytes the fixed-size block takes.</param>
|
||||
public static void WriteString(this BinaryStream self, string value, int length)
|
||||
{
|
||||
// TODO: This may not work with multi-byte encodings.
|
||||
byte[] bytes = new byte[length];
|
||||
if (value != null)
|
||||
self.Encoding.GetBytes(value, 0, value.Length, bytes, 0);
|
||||
self.WriteBytes(bytes);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Writes the given strings into fixed-size blocks of <paramref name="length"/> bytes and 0-terminates them.
|
||||
/// </summary>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/> instance.</param>
|
||||
/// <param name="values">The strings to write.</param>
|
||||
/// <param name="length">The number of bytes a fixed-size block takes.</param>
|
||||
public static void WriteStrings(this BinaryStream self, IList<string> values, int length)
|
||||
{
|
||||
foreach (string value in values)
|
||||
WriteString(self, value, length);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Writes the bytes of a structure into the current stream.
|
||||
/// </summary>
|
||||
/// <typeparam name="T">The type of the structure to read.</typeparam>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/> instance.</param>
|
||||
/// <param name="value">The structure to write.</param>
|
||||
public static void WriteStruct<T>(this BinaryStream self, T value) where T : struct
|
||||
{
|
||||
// Get the raw bytes of the structure instance.
|
||||
byte[] bytes = new byte[Marshal.SizeOf<T>()];
|
||||
|
||||
using (DisposableGCHandle handle = new DisposableGCHandle(bytes, GCHandleType.Pinned))
|
||||
Marshal.StructureToPtr(value, handle.AddrOfPinnedObject, false);
|
||||
|
||||
// Write the bytes to the stream.
|
||||
self.WriteStructs(bytes);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Writes the bytes of structures into the current stream.
|
||||
/// </summary>
|
||||
/// <typeparam name="T">The type of the structure to read.</typeparam>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/> instance.</param>
|
||||
/// <param name="values">The structures to write.</param>
|
||||
public static void WriteStructs<T>(this BinaryStream self, IList<T> values) where T : struct
|
||||
{
|
||||
foreach (T value in values)
|
||||
WriteStruct(self, value);
|
||||
}
|
||||
}
|
||||
}
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics;
|
||||
using System.IO;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Runtime.InteropServices;
|
||||
using Syroot.BinaryData;
|
||||
|
||||
namespace Syroot.Worms.Core.IO
|
||||
{
|
||||
/// <summary>
|
||||
/// Represents extension methods for <see cref="BinaryStream"/> instances.
|
||||
/// </summary>
|
||||
[DebuggerStepThrough]
|
||||
public static partial class BinaryStreamExtensions
|
||||
{
|
||||
// ---- METHODS (PUBLIC) ---------------------------------------------------------------------------------------
|
||||
|
||||
// ---- Reading ----
|
||||
|
||||
/// <summary>
|
||||
/// Reads an <see cref="ILoadable"/> instance from the current stream.
|
||||
/// </summary>
|
||||
/// <typeparam name="T">The type of the <see cref="ILoadable"/> class to instantiate.</typeparam>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/>.</param>
|
||||
/// <returns>The <see cref="ILoadable"/> instance.</returns>
|
||||
public static T Load<T>(this BinaryStream self) where T : ILoadable, new()
|
||||
{
|
||||
T instance = new T();
|
||||
instance.Load(self.BaseStream);
|
||||
return instance;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Reads <see cref="ILoadable"/> instances from the current stream.
|
||||
/// </summary>
|
||||
/// <typeparam name="T">The type of the <see cref="ILoadable"/> class to instantiate.</typeparam>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/>.</param>
|
||||
/// <param name="count">The number of instances to read.</param>
|
||||
/// <returns>The <see cref="ILoadable"/> instances.</returns>
|
||||
public static T[] Load<T>(this BinaryStream self, int count) where T : ILoadable, new()
|
||||
{
|
||||
T[] instances = new T[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
instances[i] = Load<T>(self);
|
||||
return instances;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Reads a 0-terminated string which is stored in a fixed-size block of <paramref name="length"/> bytes.
|
||||
/// </summary>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/>.</param>
|
||||
/// <param name="length">The number of bytes the fixed-size blocks takes.</param>
|
||||
/// <returns>The read string.</returns>
|
||||
public static string ReadString(this BinaryStream self, int length)
|
||||
{
|
||||
// TODO: This may not work with multi-byte encodings.
|
||||
// Ensure to not try to decode any bytes after the 0 termination.
|
||||
byte[] bytes = self.ReadBytes(length);
|
||||
while (bytes[--length] == 0 && length > 0) { }
|
||||
return self.Encoding.GetString(bytes, 0, length + 1);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Reads <paramref name="count"/> 0-terminated strings which are stored in a fixed-size block of
|
||||
/// <paramref name="length"/> bytes.
|
||||
/// </summary>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/>.</param>
|
||||
/// <param name="count">The number of values to read.</param>
|
||||
/// <param name="length">The number of bytes the fixed-size blocks takes.</param>
|
||||
/// <returns>The read string.</returns>
|
||||
public static string[] ReadStrings(this BinaryStream self, int count, int length)
|
||||
{
|
||||
string[] strings = new string[count];
|
||||
for (int i = 0; i < count; i++)
|
||||
strings[i] = ReadString(self, length);
|
||||
return strings;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Reads a raw byte structure from the current stream and returns it.
|
||||
/// </summary>
|
||||
/// <typeparam name="T">The type of the structure to read.</typeparam>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/> instance.</param>
|
||||
/// <returns>The structure of type <typeparamref name="T"/>.</returns>
|
||||
public static T ReadStruct<T>(this BinaryStream self) where T : struct
|
||||
{
|
||||
// Read the raw bytes of the structure.
|
||||
#if NETSTANDARD2_0
|
||||
byte[] bytes = new byte[Unsafe.SizeOf<T>()];
|
||||
self.Read(bytes, 0, bytes.Length);
|
||||
#else
|
||||
Span<byte> bytes = stackalloc byte[Unsafe.SizeOf<T>()];
|
||||
self.Read(bytes);
|
||||
#endif
|
||||
|
||||
// Convert them to a structure instance and return it.
|
||||
ReadOnlySpan<T> span = MemoryMarshal.Cast<byte, T>(bytes);
|
||||
return span[0];
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Reads raw byte structures from the current stream and returns them.
|
||||
/// </summary>
|
||||
/// <typeparam name="T">The type of the structure to read.</typeparam>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/> instance.</param>
|
||||
/// <param name="count">The number of values to read.</param>
|
||||
/// <returns>The structures of type <typeparamref name="T"/>.</returns>
|
||||
public static T[] ReadStructs<T>(this BinaryStream self, int count) where T : struct
|
||||
{
|
||||
// Read the raw bytes of the structures.
|
||||
#if NETSTANDARD2_0
|
||||
byte[] bytes = new byte[Unsafe.SizeOf<T>()];
|
||||
self.Read(bytes, 0, bytes.Length);
|
||||
#else
|
||||
Span<byte> bytes = stackalloc byte[Unsafe.SizeOf<T>() * count];
|
||||
self.Read(bytes);
|
||||
#endif
|
||||
|
||||
// Convert them to a structure array and return it.
|
||||
ReadOnlySpan<T> span = MemoryMarshal.Cast<byte, T>(bytes);
|
||||
return span.ToArray();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns the current address of the stream to which a 4-byte placeholder has been written which can be filled
|
||||
/// later.
|
||||
/// </summary>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/> instance.</param>
|
||||
/// <returns>The address at which a 4-byte placeholder has been written to.</returns>
|
||||
public static uint ReserveOffset(this BinaryStream self)
|
||||
{
|
||||
uint offset = (uint)self.Position;
|
||||
self.WriteUInt32(0);
|
||||
return offset;
|
||||
}
|
||||
|
||||
// ---- Writing ----
|
||||
|
||||
/// <summary>
|
||||
/// Writes the given <see cref="ISaveable"/> instance into the current stream.
|
||||
/// </summary>
|
||||
/// <typeparam name="T">The type of the <see cref="ISaveable"/> class to write.</typeparam>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/>.</param>
|
||||
/// <param name="value">The instance to write into the current stream.</param>
|
||||
public static void Save<T>(this BinaryStream self, T value) where T : ISaveable
|
||||
{
|
||||
value.Save(self.BaseStream);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Writes the given <see cref="ISaveable"/> instances into the current stream.
|
||||
/// </summary>
|
||||
/// <typeparam name="T">The type of the <see cref="ISaveable"/> class to write.</typeparam>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/>.</param>
|
||||
/// <param name="values">The instances to write into the current stream.</param>
|
||||
public static void Save<T>(this BinaryStream self, IList<T> values) where T : ISaveable
|
||||
{
|
||||
foreach (T value in values)
|
||||
Save(self, value);
|
||||
}
|
||||
|
||||
public static void SatisfyOffset(this BinaryStream self, uint offset, int value)
|
||||
{
|
||||
using (self.TemporarySeek(offset, SeekOrigin.Begin))
|
||||
self.WriteInt32(value);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Writes the given string into a fixed-size block of <paramref name="length"/> bytes and 0-terminates it.
|
||||
/// </summary>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/> instance.</param>
|
||||
/// <param name="value">The string to write.</param>
|
||||
/// <param name="length">The number of bytes the fixed-size block takes.</param>
|
||||
public static void WriteString(this BinaryStream self, string value, int length)
|
||||
{
|
||||
// TODO: This may not work with multi-byte encodings.
|
||||
byte[] bytes = new byte[length];
|
||||
if (value != null)
|
||||
self.Encoding.GetBytes(value, 0, value.Length, bytes, 0);
|
||||
self.WriteBytes(bytes);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Writes the given strings into fixed-size blocks of <paramref name="length"/> bytes and 0-terminates them.
|
||||
/// </summary>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/> instance.</param>
|
||||
/// <param name="values">The strings to write.</param>
|
||||
/// <param name="length">The number of bytes a fixed-size block takes.</param>
|
||||
public static void WriteStrings(this BinaryStream self, IList<string> values, int length)
|
||||
{
|
||||
foreach (string value in values)
|
||||
WriteString(self, value, length);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Writes the bytes of a structure into the current stream.
|
||||
/// </summary>
|
||||
/// <typeparam name="T">The type of the structure to read.</typeparam>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/> instance.</param>
|
||||
/// <param name="value">The structure to write.</param>
|
||||
public static void WriteStruct<T>(this BinaryStream self, T value) where T : struct
|
||||
{
|
||||
ReadOnlySpan<byte> bytes;
|
||||
unsafe { bytes = new ReadOnlySpan<byte>(Unsafe.AsPointer(ref value), Unsafe.SizeOf<T>()); }
|
||||
#if NETSTANDARD2_0
|
||||
self.Write(bytes.ToArray()); // cannot prevent copy in .NET Standard 2.0
|
||||
#else
|
||||
self.Write(bytes);
|
||||
#endif
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Writes the bytes of structures into the current stream.
|
||||
/// </summary>
|
||||
/// <typeparam name="T">The type of the structure to read.</typeparam>
|
||||
/// <param name="self">The extended <see cref="BinaryStream"/> instance.</param>
|
||||
/// <param name="values">The structures to write.</param>
|
||||
public static void WriteStructs<T>(this BinaryStream self, IEnumerable<T> values) where T : struct
|
||||
{
|
||||
foreach (T value in values)
|
||||
self.WriteStruct(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
<Import Project="$(SolutionDir)build.xml" />
|
||||
<PropertyGroup>
|
||||
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
|
||||
<AssemblyName>Syroot.Worms</AssemblyName>
|
||||
<Description>.NET library for loading and modifying files of Team17 Worms games.</Description>
|
||||
<PackageReleaseNotes>Split into game-related packages.</PackageReleaseNotes>
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user