public TextureView([NotNull] IMemoryBlock 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;
mReadableMemory = new ReadOnlyMemoryWindow(memory);
mStride = stride;
mWidth = stride >> 2;
mHeight = (int)(memory.Size / stride);
mReadable = memory is IReadableMemory;
mWritable = memory is IWritableMemory;
if (!mReadable && !mWritable)
{
// neither readable nor writable!? must be some unknown memory restriction...
mReadable = mWritable = true;
}
}
public static ReadOnlyArrayView <T> AsReadOnlyArray <T>([NotNull] this IReadableMemory readableMemory) where T : struct
{
if (readableMemory == null)
{
throw new ArgumentNullException(nameof(readableMemory));
}
return(new ReadOnlyArrayView <T>(readableMemory));
}
public static ReadOnlyMemoryWindow GetReadOnlyWindow([NotNull] this IReadableMemory readableMemory, int offset, long size)
{
if (readableMemory == null)
{
throw new ArgumentNullException(nameof(readableMemory));
}
return(new ReadOnlyMemoryWindow(readableMemory, offset, size));
}
public HardwareRenderTargetData([NotNull] HardwareRenderTarget renderTarget)
{
if (renderTarget == null)
{
throw new ArgumentNullException(nameof(renderTarget));
}
mTexture = renderTarget.GetTexture2D();
mBox = renderTarget.Device.ImmediateContext.MapSubresource(mTexture, 0, MapMode.Read, MapFlags.None);
mMemory = new ReadOnlyMemoryWindow(mBox.Data.DataPointer, mBox.Data.Length);
}
public ReadOnlyArrayView([NotNull] IReadableMemory memory)
{
if (memory == null)
{
throw new ArgumentNullException(nameof(memory));
}
mMemory = memory;
mSizeOfT = Marshal.SizeOf <T>();
mLength = memory.Size / mSizeOfT;
}
public UnmanagedStream([NotNull] IReadableMemory memory)
{
if (memory == null)
{
throw new ArgumentNullException(nameof(memory));
}
mMemory = memory;
CanRead = true;
CanSeek = true;
CanWrite = false;
}
protected void Load([NotNull] IReadableMemory bytecode)
{
if (bytecode == null)
{
throw new ArgumentNullException(nameof(bytecode));
}
var bytecodeData = new byte[bytecode.Size];
bytecode.CopyTo(bytecodeData);
mBytecode = new ShaderBytecode(new DataStream(bytecodeData, true, false));
OnBytecodeLoaded();
}
public static void Write([NotNull] this IWritable writableMemory, [NotNull] IReadableMemory sourceMemory)
{
if (writableMemory == null)
{
throw new ArgumentNullException(nameof(writableMemory));
}
if (sourceMemory == null)
{
throw new ArgumentNullException(nameof(sourceMemory));
}
writableMemory.Write(sourceMemory.GetPointer(), 0, sourceMemory.Size);
}
public ReadOnlyTextureView([NotNull] IReadableMemory memory, int stride, TextureFormat format)
{
if (stride <= 0)
{
throw new ArgumentOutOfRangeException(nameof(stride));
}
mMemory = memory ?? throw new ArgumentNullException(nameof(memory));
mFormat = format;
mStride = stride;
mWidth = stride >> 2;
mHeight = (int)(memory.Size / stride);
}
public ReadOnlyMemoryWindow([NotNull] IReadableMemory 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 CopyTo <T>(this IReadableMemory memory, [NotNull] T[] targetArray) where T : struct
{
if (targetArray == null)
{
throw new ArgumentNullException(nameof(targetArray));
}
var targetArrayHandle = default(GCHandle);
try
{
targetArrayHandle = GCHandle.Alloc(targetArray, GCHandleType.Pinned);
UnmanagedBlock.Copy(memory.GetPointer(), targetArrayHandle.AddrOfPinnedObject(), 0, 0, memory.Size);
}
finally
{
if (targetArrayHandle.IsAllocated)
{
targetArrayHandle.Free();
}
}
}
public void Blit(IReadableMemory pixels)
{
mReactor.mBackBufferMemory.Write(pixels);
}
public static AcceleratedComputationKernel FromBytecode([NotNull] AccelerationDevice device, [NotNull] IReadableMemory bytecode)
{
if (device == null)
{
throw new ArgumentNullException(nameof(device));
}
if (bytecode == null)
{
throw new ArgumentNullException(nameof(bytecode));
}
var kernel = new AcceleratedComputationKernel(device);
kernel.Load(bytecode);
return(kernel);
}
public static IAcceleratedImagingKernelConfiguration FromBytecode([NotNull] AccelerationDevice device, [NotNull] IReadableMemory bytecode)
{
if (device == null)
{
throw new ArgumentNullException(nameof(device));
}
if (bytecode == null)
{
throw new ArgumentNullException(nameof(bytecode));
}
return(new AcceleratedImagingKernelConfiguration(device, k => k.Load(bytecode)));
}
