void IReactor.SetBackBuffer(IWritableMemory writableMemory, TextureFormat pixelFormat, int stride)
{
foreach (var kernel in mHardwareQueue)
{
kernel.CastTo <IDisposable>()?.Dispose();
}
mHardwareQueue.Clear();
mOutputKernel?.Dispose();
if (writableMemory.Size <= 0)
{
throw new InvalidOperationException("The buffer dimensions are invalid.");
}
mOutputTextureMemory = writableMemory;
mOutputTexture = new TextureView(writableMemory, stride, pixelFormat);
CreateComputeKernels(mHardwareQueue);
var outputKernel = CreateOutputKernel();
if (outputKernel == null)
{
throw new ArgumentException("The imaging kernel is null.");
}
mOutputKernel = outputKernel;
}
void IReactor.SetBackBuffer(IWritableMemory writableMemory, TextureFormat pixelFormat, int stride)
{
mBackBufferMemory = writableMemory;
mBackBufferPixelFormat = pixelFormat;
mBackBuffer = new TextureView(writableMemory, stride, pixelFormat);
InitializeOverride();
}
public static WriteOnlyMemoryWindow GetWriteOnlyWindow([NotNull] this IWritableMemory writableMemory, int offset, long size)
{
if (writableMemory == null)
{
throw new ArgumentNullException(nameof(writableMemory));
}
return(new WriteOnlyMemoryWindow(writableMemory, offset, size));
}
public static WriteOnlyArrayView <T> AsWriteOnlyArray <T>([NotNull] this IWritableMemory writableMemory) where T : struct
{
if (writableMemory == null)
{
throw new ArgumentNullException(nameof(writableMemory));
}
return(new WriteOnlyArrayView <T>(writableMemory));
}
public WriteOnlyArrayView([NotNull] IWritableMemory memory)
{
if (memory == null)
{
throw new ArgumentNullException(nameof(memory));
}
mMemory = memory;
mSizeOfT = Marshal.SizeOf <T>();
mLength = memory.Size / mSizeOfT;
}
public UnmanagedStream([NotNull] IWritableMemory memory)
{
if (memory == null)
{
throw new ArgumentNullException(nameof(memory));
}
mMemory = memory;
CanRead = false;
CanSeek = false;
CanWrite = true;
}
public static void Read([NotNull] this IReadable readableMemory, [NotNull] IWritableMemory targetMemory)
{
if (readableMemory == null)
{
throw new ArgumentNullException(nameof(readableMemory));
}
if (targetMemory == null)
{
throw new ArgumentNullException(nameof(targetMemory));
}
readableMemory.Read(targetMemory.GetPointer(), 0, targetMemory.Size);
}
public WriteOnlyTextureView([NotNull] IWritableMemory memory, int stride, TextureFormat format)
{
if (memory == null)
{
throw new ArgumentNullException(nameof(memory));
}
if (stride <= 0)
{
throw new ArgumentOutOfRangeException(nameof(stride));
}
mMemory = memory;
mFormat = format;
mStride = stride;
mWidth = stride >> 2;
mHeight = (int)(memory.Size / stride);
}
public WriteOnlyMemoryWindow([NotNull] IWritableMemory memoryBlock, int offset, long size)
{
if (memoryBlock == null)
{
throw new ArgumentNullException(nameof(memoryBlock));
}
if (offset < 0)
{
throw new ArgumentOutOfRangeException(nameof(offset));
}
if (size > memoryBlock.Size - offset)
{
throw new ArgumentOutOfRangeException(nameof(size), "The window size is larger than the size of the target block.");
}
Pointer = memoryBlock.GetPointer() + offset;
Size = size;
}
public static void FromArray <T>(this IWritableMemory memory, [NotNull] T[] sourceArray) where T : struct
{
if (sourceArray == null)
{
throw new ArgumentNullException(nameof(sourceArray));
}
var sourceArrayHandle = default(GCHandle);
try
{
sourceArrayHandle = GCHandle.Alloc(sourceArray, GCHandleType.Pinned);
UnmanagedBlock.Copy(sourceArrayHandle.AddrOfPinnedObject(), memory.GetPointer(), 0, 0, memory.Size);
}
finally
{
if (sourceArrayHandle.IsAllocated)
{
sourceArrayHandle.Free();
}
}
}
public void Dispose()
{
mBackBufferPixelFormat = default;
mBackBufferMemory = null;
mBackBuffer = null;
}
