private Buffer(
GraphicsDevice graphicsDevice,
uint elementSizeInBytes,
uint elementCount,
BufferBindFlags flags,
ResourceUsage usage,
byte[] initialData)
: base(graphicsDevice, elementSizeInBytes, elementCount, flags, usage, initialData)
{
}
public static Buffer CreateDynamic(
GraphicsDevice graphicsDevice,
uint sizeInBytes,
BufferBindFlags flags)
{
return(new Buffer(
graphicsDevice,
sizeInBytes,
1u,
flags,
ResourceUsage.Dynamic,
null));
}
public static Buffer <T> CreateDynamicArray(
GraphicsDevice graphicsDevice,
int arrayLength,
BufferBindFlags flags)
{
return(new Buffer <T>(
graphicsDevice,
SizeOfT,
(uint)arrayLength,
flags,
ResourceUsage.Dynamic,
null)
{
DebugName = $"Dynamic Buffer <{typeof(T).Name}, {arrayLength}, {flags}>"
});
}
private void PlatformConstruct(
GraphicsDevice graphicsDevice,
uint sizeInBytes,
uint elementSizeInBytes,
BufferBindFlags flags,
ResourceUsage usage,
byte[] initialData)
{
var optionFlags = flags.HasFlag(BufferBindFlags.ShaderResource)
? D3D11.ResourceOptionFlags.BufferStructured
: D3D11.ResourceOptionFlags.None;
var cpuAccessFlags = usage == ResourceUsage.Dynamic
? D3D11.CpuAccessFlags.Write
: D3D11.CpuAccessFlags.None;
var d3d11Usage = usage == ResourceUsage.Dynamic
? D3D11.ResourceUsage.Dynamic
: D3D11.ResourceUsage.Immutable;
var description = new D3D11.BufferDescription
{
BindFlags = flags.ToBindFlags(),
CpuAccessFlags = cpuAccessFlags,
OptionFlags = optionFlags,
SizeInBytes = (int)sizeInBytes,
StructureByteStride = (int)elementSizeInBytes,
Usage = d3d11Usage
};
if (usage == ResourceUsage.Static)
{
using (var dataStream = DataStream.Create(initialData, true, false))
{
DeviceBuffer = AddDisposable(new D3D11.Buffer(
graphicsDevice.Device,
dataStream,
description));
}
}
else
{
DeviceBuffer = AddDisposable(new D3D11.Buffer(
graphicsDevice.Device,
description));
}
}
public static Buffer <T> CreateStatic(
GraphicsDevice graphicsDevice,
T[] data,
BufferBindFlags flags)
{
byte[] initialData = StructInteropUtility.ToBytes(data);
return(new Buffer <T>(
graphicsDevice,
SizeOfT,
(uint)data.Length,
flags,
ResourceUsage.Static,
initialData)
{
DebugName = $"Static Array Buffer <{typeof(T).Name}, {flags}>"
});
}
private void PlatformConstruct(
GraphicsDevice graphicsDevice,
uint sizeInBytes,
uint elementSizeInBytes,
BufferBindFlags flags,
ResourceUsage usage,
byte[] initialData)
{
if (usage == ResourceUsage.Static)
{
DeviceBuffer = AddDisposable(graphicsDevice.Device.CreateBuffer(
initialData,
MTLResourceOptions.StorageModeManaged));
}
else
{
DeviceBuffer = AddDisposable(graphicsDevice.Device.CreateBuffer(
sizeInBytes,
MTLResourceOptions.CpuCacheModeWriteCombined | MTLResourceOptions.StorageModeManaged));
}
}
protected Buffer(
GraphicsDevice graphicsDevice,
uint elementSizeInBytes,
uint elementCount,
BufferBindFlags flags,
ResourceUsage usage,
byte[] initialData)
: base(graphicsDevice)
{
if (usage == ResourceUsage.Dynamic && initialData != null)
{
throw new ArgumentOutOfRangeException();
}
if (usage == ResourceUsage.Static && initialData == null)
{
throw new ArgumentOutOfRangeException();
}
ElementSizeInBytes = elementSizeInBytes;
ElementCount = elementCount;
var alignedElementSize = flags.HasFlag(BufferBindFlags.ConstantBuffer)
? PlatformGetAlignedSize(elementSizeInBytes)
: elementSizeInBytes;
SizeInBytes = alignedElementSize * elementCount;
BindFlags = flags;
Usage = usage;
PlatformConstruct(
graphicsDevice,
SizeInBytes,
elementSizeInBytes,
flags,
usage,
initialData);
}
public static BindFlags ToBindFlags(this BufferBindFlags value)
{
switch (value)
{
case BufferBindFlags.None:
return(BindFlags.None);
case BufferBindFlags.VertexBuffer:
return(BindFlags.VertexBuffer);
case BufferBindFlags.IndexBuffer:
return(BindFlags.IndexBuffer);
case BufferBindFlags.ConstantBuffer:
return(BindFlags.ConstantBuffer);
case BufferBindFlags.ShaderResource:
return(BindFlags.ShaderResource);
default:
throw new ArgumentOutOfRangeException();
}
}
public static Buffer <T> CreateDynamic(
GraphicsDevice graphicsDevice,
BufferBindFlags flags)
{
return(CreateDynamicArray(graphicsDevice, 1, flags));
}
