private static void AddBeziersImpl(IntPtr thisPtr, IntPtr beziers, int beziersCount) { var shadow = ToShadow <ID2D1SimplifiedGeometrySinkShadow>(thisPtr); var callback = (ID2D1SimplifiedGeometrySink)shadow.Callback; var managedBeziers = new BezierSegment[beziersCount]; MemoryHelpers.Read(beziers, managedBeziers, 0, beziersCount); callback.AddBeziers(managedBeziers); }
private static void AddLinesImpl(IntPtr thisPtr, IntPtr points, int pointsCount) { var shadow = ToShadow <ID2D1SimplifiedGeometrySinkShadow>(thisPtr); var callback = (ID2D1SimplifiedGeometrySink)shadow.Callback; var managedPoints = new PointF[pointsCount]; MemoryHelpers.Read(points, managedPoints, 0, pointsCount); callback.AddLines(managedPoints); }
/// <summary> /// Gets structured data contained in this chunk. /// </summary> /// <typeparam name="T">The type of the data to return</typeparam> /// <returns> /// A structure filled with the chunk data /// </returns> public unsafe T GetDataAs <T>() where T : unmanaged { T value = new(); byte[] data = GetData(); fixed(void *ptr = data) { MemoryHelpers.Read((IntPtr)ptr, ref value); } return(value); }
/// <summary> /// Reads a sequence of elements from the current stream into a target buffer and /// advances the position within the stream by the number of bytes read. /// </summary> /// <remarks> /// In order to provide faster read/write, this operation doesn't check stream bound. /// A client must carefully not read/write above the size of this datastream. /// </remarks> /// <param name = "buffer">An array of values to be read from the stream.</param> /// <param name = "offset">The zero-based byte offset in buffer at which to begin storing /// the data read from the current stream.</param> /// <param name = "count">The number of values to be read from the current stream.</param> /// <returns>The number of bytes read from the stream.</returns> /// <exception cref="NotSupportedException">This stream does not support reading.</exception> public int ReadRange <T>(T[] buffer, int offset, int count) where T : unmanaged { if (!CanRead) { throw new NotSupportedException(); } long oldPosition = _position; _position = (byte *)MemoryHelpers.Read((IntPtr)(_buffer + _position), buffer, offset, count) - _buffer; return((int)(_position - oldPosition)); }
/// <summary> /// Reads an array of values from the current stream, and advances the current position within this stream by the number of bytes written. /// </summary> /// <remarks> /// In order to provide faster read/write, this operation doesn't check stream bound. /// A client must carefully not read/write above the size of this datastream. /// </remarks> /// <typeparam name="T">The type of the values to be read from the stream.</typeparam> /// <returns>An array of values that was read from the current stream.</returns> public T[] ReadRange <T>(int count) where T : unmanaged { if (!CanRead) { throw new NotSupportedException(); } byte *from = _buffer + _position; T[] result = new T[count]; _position = (byte *)MemoryHelpers.Read((IntPtr)from, result, 0, count) - _buffer; return(result); }
public unsafe uint Write(IntPtr buffer, uint numberOfBytesToWrite) { uint totalWrite = 0; while (numberOfBytesToWrite > 0) { uint countWrite = (uint)Math.Min(numberOfBytesToWrite, tempBuffer.Length); MemoryHelpers.Read(new IntPtr(totalWrite + (byte *)buffer), new ReadOnlySpan <byte>(tempBuffer), (int)countWrite); sourceStream.Write(tempBuffer, 0, (int)countWrite); numberOfBytesToWrite -= countWrite; totalWrite += countWrite; } return(totalWrite); }
public void GetCurrentState <T, TRaw, TUpdate>(ref T data) where T : class, IDeviceState <TRaw, TUpdate>, new() where TRaw : unmanaged where TUpdate : unmanaged, IStateUpdate { unsafe { int size = sizeof(TRaw); byte *pTemp = stackalloc byte[size * 2]; TRaw temp = default; GetDeviceState(size, (IntPtr)pTemp); MemoryHelpers.Read((IntPtr)pTemp, ref temp); data.MarshalFrom(ref temp); } }
/// <summary> /// Marshal this class from an unmanaged buffer. /// </summary> /// <param name="bufferSize">The size of the unmanaged buffer.</param> /// <param name="bufferPointer">The pointer to the unmanaged buffer.</param> /// <returns>An instance of TypeSpecificParameters or null</returns> protected override TypeSpecificParameters?MarshalFrom(int bufferSize, IntPtr bufferPointer) { unsafe { // BufferSize must be a multiple of the size of Condition structure if (bufferSize <= 0 || (bufferSize % sizeof(Condition)) != 0) { return(null); } // Allocate a set of Condition and marshal from unmanaged memory int numberOfConditions = bufferSize / sizeof(Condition); Conditions = new Condition[numberOfConditions]; MemoryHelpers.Read(bufferPointer, Conditions, 0, Conditions.Length); return(this); } }
/// <summary> /// Marshal this class from an unmanaged buffer. /// </summary> /// <param name="bufferSize">The size of the unmanaged buffer.</param> /// <param name="bufferPointer">The pointer to the unmanaged buffer.</param> /// <returns>An instance of TypeSpecificParameters or null</returns> protected override TypeSpecificParameters?MarshalFrom(int bufferSize, IntPtr bufferPointer) { unsafe { if (bufferSize != sizeof(RawCustomForce)) { return(null); } ChannelCount = ((RawCustomForce *)bufferPointer)->Channels; SamplePeriod = ((RawCustomForce *)bufferPointer)->SamplePeriod; SampleCount = ((RawCustomForce *)bufferPointer)->Samples; ForceData = new int[SampleCount]; MemoryHelpers.Read(((RawCustomForce *)bufferPointer)->ForceDataPointer, ForceData, 0, ForceData.Length); return(this); } }
/// <summary> /// Gets structured data contained in this chunk. /// </summary> /// <typeparam name="T">The type of the data to return</typeparam> /// <returns>A structure filled with the chunk data</returns> public unsafe T[] GetDataAsArray <T>() where T : unmanaged { int sizeOfT = sizeof(T); if ((Size % sizeOfT) != 0) { throw new ArgumentException("Size of T is incompatible with size of chunk"); } T[] values = new T[Size / sizeOfT]; byte[] data = GetData(); fixed(byte *dataPtr = data) { MemoryHelpers.Read((IntPtr)dataPtr, values, 0, values.Length); } return(values); }
internal unsafe void __MarshalFrom(ref __Native @ref) { Categories = new InfoQueueMessageCategory[@ref.NumCategories]; if (@ref.NumCategories > 0) { MemoryHelpers.Read(@ref.PCategoryList, Categories, 0, @ref.NumCategories); } Severities = new InfoQueueMessageSeverity[@ref.NumSeverities]; if (@ref.NumSeverities > 0) { MemoryHelpers.Read(@ref.PSeverityList, Severities, 0, @ref.NumSeverities); } Ids = new int[@ref.NumIDs]; if (@ref.NumIDs > 0) { MemoryHelpers.Read(@ref.PIDList, Ids, 0, @ref.NumIDs); } }
public ShaderBytecode(Blob blob) { Data = new byte[blob.BufferSize]; MemoryHelpers.Read(blob.BufferPointer, Data, 0, Data.Length); }
public ShaderBytecode(IntPtr bytecode, PointerSize length) { Data = new byte[length]; MemoryHelpers.Read(bytecode, Data, 0, Data.Length); }