/// <summary>
/// Initializes a new instance of <see cref="BufferDescription"/> struct.
/// </summary>
/// <param name="sizeInBytes">Size of the buffer in bytes.</param>
/// <param name="bufferFlags">Buffer flags describing the type of buffer.</param>
/// <param name="usage">Usage of this buffer.</param>
/// <param name="structureByteStride">The size of the structure (in bytes) when it represents a structured/typed buffer. Default = 0.</param>
public BufferDescription(int sizeInBytes, BufferFlags bufferFlags, GraphicsResourceUsage usage, int structureByteStride = 0)
{
SizeInBytes = sizeInBytes;
BufferFlags = bufferFlags;
Usage = usage;
StructureByteStride = structureByteStride;
}
private static TextureDescription New1D(int width, PixelFormat format, TextureFlags flags, int mipCount, int arraySize, GraphicsResourceUsage usage)
{
usage = (flags & TextureFlags.UnorderedAccess) != 0 ? GraphicsResourceUsage.Default : usage;
var desc = new TextureDescription()
{
Dimension = TextureDimension.Texture1D,
Width = width,
Height = 1,
Depth = 1,
ArraySize = arraySize,
Flags = flags,
Format = format,
MipLevels = Texture.CalculateMipMapCount(mipCount, width),
Usage = Texture.GetUsageWithFlags(usage, flags),
};
return desc;
}
private static TextureDescription New3D(int width, int height, int depth, PixelFormat format, TextureFlags flags, int mipCount, GraphicsResourceUsage usage)
{
var desc = new TextureDescription()
{
Width = width,
Height = height,
Depth = depth,
Flags = flags,
Format = format,
MipLevels = Texture.CalculateMipMapCount(mipCount, width, height, depth),
Usage = Texture.GetUsageWithFlags(usage, flags),
ArraySize = 1,
Dimension = TextureDimension.Texture3D,
MultiSampleLevel = MSAALevel.None
};
return desc;
}
private static TextureDescription New2D(int width, int height, PixelFormat format, TextureFlags textureFlags, int mipCount, int arraySize, GraphicsResourceUsage usage)
{
if ((textureFlags & TextureFlags.UnorderedAccess) != 0)
usage = GraphicsResourceUsage.Default;
var desc = new TextureDescription()
{
Dimension = TextureDimension.Texture2D,
Width = width,
Height = height,
Depth = 1,
ArraySize = arraySize,
MultiSampleLevel = MSAALevel.None,
Flags = textureFlags,
Format = format,
MipLevels = Texture.CalculateMipMapCount(mipCount, width, height),
Usage = Texture.GetUsageWithFlags(usage, textureFlags),
};
return desc;
}
/// <summary>
/// Creates a new Argument buffer with <see cref="GraphicsResourceUsage.Default"/> uasge by default.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="size">The size in bytes.</param>
/// <param name="usage">The usage.</param>
/// <returns>A Argument buffer</returns>
public static Buffer New(GraphicsDevice device, int size, GraphicsResourceUsage usage = GraphicsResourceUsage.Default)
{
return(Buffer.New(device, size, BufferFlags.ArgumentBuffer, usage));
}
/// <summary>
/// Creates a new 1D <see cref="Texture" /> with a single level of mipmap.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice" />.</param>
/// <param name="width">The width.</param>
/// <param name="format">Describes the format to use.</param>
/// <param name="dataPtr">Data ptr</param>
/// <param name="textureFlags">true if the texture needs to support unordered read write.</param>
/// <param name="usage">The usage.</param>
/// <returns>A new instance of 1D <see cref="Texture" /> class.</returns>
/// <remarks>The first dimension of mipMapTextures describes the number of array (Texture Array), second dimension is the mipmap, the third is the texture data for a particular mipmap.</remarks>
public static Texture New1D(GraphicsDevice device, int width, PixelFormat format, IntPtr dataPtr, TextureFlags textureFlags = TextureFlags.ShaderResource, GraphicsResourceUsage usage = GraphicsResourceUsage.Immutable)
{
return(New(device, TextureDescription.New1D(width, format, textureFlags, usage), new[] { new DataBox(dataPtr, 0, 0), }));
}
/// <summary>
/// Creates a new 1D <see cref="Texture"/>.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="width">The width.</param>
/// <param name="mipCount">Number of mipmaps, set to true to have all mipmaps, set to an int >=1 for a particular mipmap count.</param>
/// <param name="format">Describes the format to use.</param>
/// <param name="usage">The usage.</param>
/// <param name="textureFlags">true if the texture needs to support unordered read write.</param>
/// <param name="arraySize">Size of the texture 2D array, default to 1.</param>
/// <returns>
/// A new instance of 1D <see cref="Texture"/> class.
/// </returns>
public static Texture New1D(GraphicsDevice device, int width, MipMapCount mipCount, PixelFormat format, TextureFlags textureFlags = TextureFlags.ShaderResource, int arraySize = 1, GraphicsResourceUsage usage = GraphicsResourceUsage.Default)
{
return(New(device, TextureDescription.New1D(width, mipCount, format, textureFlags, arraySize, usage)));
}
private static BufferDescription NewDescription(int bufferSize, int elementSize, BufferFlags bufferFlags, GraphicsResourceUsage usage)
{
return(new BufferDescription()
{
SizeInBytes = bufferSize,
StructureByteStride = (bufferFlags & BufferFlags.StructuredBuffer) != 0 ? elementSize : 0,
BufferFlags = bufferFlags,
Usage = usage,
});
}
/// <summary>
/// Creates a new <see cref="Buffer" /> instance.
/// </summary>
/// <typeparam name="T">Type of the buffer, to get the sizeof from.</typeparam>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="initialValue">The initial value of this buffer.</param>
/// <param name="bufferFlags">The buffer flags to specify the type of buffer.</param>
/// <param name="usage">The usage.</param>
/// <returns>An instance of a new <see cref="Buffer" /></returns>
public static Buffer <T> New <T>(GraphicsDevice device, T[] initialValue, BufferFlags bufferFlags, GraphicsResourceUsage usage = GraphicsResourceUsage.Default) where T : struct
{
return(New(device, initialValue, bufferFlags, PixelFormat.None, usage));
}
/// <summary>
/// Creates a new <see cref="Buffer" /> instance.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="elementCount">Number of T elment in this buffer.</param>
/// <param name="bufferFlags">The buffer flags to specify the type of buffer.</param>
/// <param name="usage">The usage.</param>
/// <returns>An instance of a new <see cref="Buffer" /></returns>
public static Buffer <T> New <T>(GraphicsDevice device, int elementCount, BufferFlags bufferFlags, GraphicsResourceUsage usage = GraphicsResourceUsage.Default) where T : struct
{
int bufferSize = Utilities.SizeOf <T>() * elementCount;
int elementSize = Utilities.SizeOf <T>();
var description = NewDescription(bufferSize, elementSize, bufferFlags, usage);
return(new Buffer <T>(device, description, bufferFlags, PixelFormat.None, IntPtr.Zero));
}
public void TestGetData(GraphicsProfile profile, GraphicsResourceUsage usage)
{
var testArray = profile >= GraphicsProfile.Level_10_0; // TODO modify this when when supported on openGL
var mipmaps = GraphicsDevice.Platform == GraphicsPlatform.OpenGLES && profile < GraphicsProfile.Level_10_0 ? 1 : 3; // TODO remove this limitation when GetData is fixed on OpenGl ES for mipmap levels other than 0
PerformTest(
game =>
{
const int width = 16;
const int height = width;
var arraySize = testArray ? 2 : 1;
var flags = usage == GraphicsResourceUsage.Default?
new[] { TextureFlags.ShaderResource, TextureFlags.RenderTarget, TextureFlags.RenderTarget | TextureFlags.ShaderResource }:
new[] { TextureFlags.None };
var pixelFormat = PixelFormat.R8G8B8A8_UNorm;
var data = CreateDebugTextureData(width, height, mipmaps, arraySize, pixelFormat, DefaultColorComputer);
foreach (var flag in flags)
{
using (var texture = CreateDebugTexture(game.GraphicsDevice, data, width, height, mipmaps, arraySize, pixelFormat, flag, usage))
CheckDebugTextureData(game.GraphicsContext, texture, width, height, mipmaps, arraySize, pixelFormat, flag, usage, DefaultColorComputer);
}
},
profile);
}
/// <summary>
/// Creates a new 1D <see cref="TextureDescription" /> with a single level of mipmap.
/// </summary>
/// <param name="width">The width.</param>
/// <param name="format">Describes the format to use.</param>
/// <param name="textureFlags">true if the texture needs to support unordered read write.</param>
/// <param name="usage">The usage.</param>
/// <returns>A new instance of 1D <see cref="TextureDescription" /> class.</returns>
/// <remarks>The first dimension of mipMapTextures describes the number of array (Texture1D Array), second dimension is the mipmap, the third is the texture data for a particular mipmap.</remarks>
public static TextureDescription New1D(int width, PixelFormat format, TextureFlags textureFlags = TextureFlags.ShaderResource, GraphicsResourceUsage usage = GraphicsResourceUsage.Immutable)
{
return New1D(width, format, textureFlags, 1, 1, usage);
}
/// <summary>
/// Creates a new 1D <see cref="TextureDescription" />.
/// </summary>
/// <param name="width">The width.</param>
/// <param name="mipCount">Number of mipmaps, set to true to have all mipmaps, set to an int >=1 for a particular mipmap count.</param>
/// <param name="format">Describes the format to use.</param>
/// <param name="textureFlags">true if the texture needs to support unordered read write.</param>
/// <param name="arraySize">Size of the texture 2D array, default to 1.</param>
/// <param name="usage">The usage.</param>
/// <returns>A new instance of 1D <see cref="TextureDescription" /> class.</returns>
public static TextureDescription New1D(int width, MipMapCount mipCount, PixelFormat format, TextureFlags textureFlags = TextureFlags.ShaderResource, int arraySize = 1, GraphicsResourceUsage usage = GraphicsResourceUsage.Default)
{
return New1D(width, format, textureFlags, mipCount, arraySize, usage);
}
/// <summary>
/// Creates a new <see cref="TextureDescription" /> with a single mipmap.
/// </summary>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="format">Describes the format to use.</param>
/// <param name="textureFlags">true if the texture needs to support unordered read write.</param>
/// <param name="arraySize">Size of the texture 2D array, default to 1.</param>
/// <param name="usage">The usage.</param>
/// <returns>A new instance of <see cref="TextureDescription" /> class.</returns>
public static TextureDescription New2D(int width, int height, PixelFormat format, TextureFlags textureFlags = TextureFlags.ShaderResource, int arraySize = 1, GraphicsResourceUsage usage = GraphicsResourceUsage.Default)
{
return New2D(width, height, false, format, textureFlags, arraySize, usage);
}
/// <summary>
/// Creates a new Vertex buffer with <see cref="GraphicsResourceUsage.Default"/> uasge by default.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="size">The size in bytes.</param>
/// <param name="usage">The usage.</param>
/// <param name="bindFlags">The bind flags, can be combined with <see cref="BufferFlags.StreamOutput"/> to use the buffer as a stream output target.</param>
/// <returns>
/// A Vertex buffer
/// </returns>
public static Buffer New(GraphicsDevice device, int size, GraphicsResourceUsage usage = GraphicsResourceUsage.Default, BufferFlags bindFlags = BufferFlags.VertexBuffer)
{
return(Buffer.New(device, size, bindFlags, usage));
}
public void TestCopy(GraphicsProfile profile, GraphicsResourceUsage usageSource)
{
var testArray = profile >= GraphicsProfile.Level_10_0; // TODO modify this when when supported on openGL
var mipmaps = GraphicsDevice.Platform == GraphicsPlatform.OpenGLES && profile < GraphicsProfile.Level_10_0 ? 1 : 3; // TODO remove this limitation when GetData is fixed on OpenGl ES for mipmap levels other than 0
PerformTest(
game =>
{
const int width = 16;
const int height = width;
var arraySize = testArray ? 2 : 1;
var destinationIsStaged = new[] { true, false };
foreach (var destinationStaged in destinationIsStaged)
{
var pixelFormats = new List<PixelFormat> { PixelFormat.R8G8B8A8_UNorm, PixelFormat.R8G8B8A8_UNorm_SRgb, PixelFormat.R8_UNorm };
#if SILICONSTUDIO_XENKO_GRAPHICS_API_OPENGLES
if(!game.GraphicsDevice.HasTextureRG)
pixelFormats.Remove(PixelFormat.R8_UNorm);
#endif
foreach (var pixelFormat in pixelFormats)
{
var computer = pixelFormat.SizeInBytes() == 1 ? (Func<int, int, int, int, int, byte>)ColorComputerR8 : DefaultColorComputer;
var data = CreateDebugTextureData(width, height, mipmaps, arraySize, pixelFormat, computer);
var sourceFlags = usageSource == GraphicsResourceUsage.Default ?
new[] { TextureFlags.ShaderResource, TextureFlags.RenderTarget, TextureFlags.RenderTarget | TextureFlags.ShaderResource } :
new[] { TextureFlags.None };
foreach (var flag in sourceFlags)
{
using (var texture = CreateDebugTexture(game.GraphicsDevice, data, width, height, mipmaps, arraySize, pixelFormat, flag, usageSource))
using (var copyTexture = destinationStaged ? texture.ToStaging(): texture.Clone())
{
game.GraphicsContext.CommandList.Copy(texture, copyTexture);
CheckDebugTextureData(game.GraphicsContext, copyTexture, width, height, mipmaps, arraySize, pixelFormat, flag, usageSource, computer);
}
}
}
}
},
profile);
}
/// <summary>
/// Creates a new Vertex buffer with <see cref="GraphicsResourceUsage.Default"/> usage by default.
/// </summary>
/// <typeparam name="T">Type of the Vertex buffer to get the sizeof from</typeparam>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="vertexBufferCount">Number of vertex in this buffer with the sizeof(T).</param>
/// <param name="usage">The usage.</param>
/// <returns>A Vertex buffer</returns>
public static Buffer <T> New <T>(GraphicsDevice device, int vertexBufferCount, GraphicsResourceUsage usage = GraphicsResourceUsage.Default) where T : struct
{
return(Buffer.New <T>(device, vertexBufferCount, BufferFlags.VertexBuffer, usage));
}
private unsafe Texture CreateDebugTexture(GraphicsDevice device, byte[] data, int width, int height, int mipmaps, int arraySize, PixelFormat format, TextureFlags flags, GraphicsResourceUsage usage)
{
fixed (byte* pData = data)
{
var sizeInBytes = format.SizeInBytes();
var offset = 0;
var dataBoxes = new DataBox[arraySize * mipmaps];
for (int array = 0; array < arraySize; array++)
{
for (int mip = 0; mip < mipmaps; mip++)
{
var w = width >> mip;
var h = height >> mip;
var rowStride = w * sizeInBytes;
var sliceStride = rowStride * h;
dataBoxes[array * mipmaps + mip] = new DataBox((IntPtr)pData + offset, rowStride, sliceStride);
offset += sliceStride;
}
}
return Texture.New2D(device, width, height, mipmaps, format, dataBoxes, flags, arraySize, usage);
}
}
/// <summary>
/// Creates a new <see cref="Buffer" /> instance.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="bufferSize">Size of the buffer in bytes.</param>
/// <param name="elementSize">Size of an element in the buffer.</param>
/// <param name="bufferFlags">The buffer flags to specify the type of buffer.</param>
/// <param name="viewFormat">The view format must be specified if the buffer is declared as a shared resource view.</param>
/// <param name="usage">The usage.</param>
/// <returns>An instance of a new <see cref="Buffer" /></returns>
public static Buffer New(GraphicsDevice device, int bufferSize, int elementSize, BufferFlags bufferFlags, PixelFormat viewFormat, GraphicsResourceUsage usage = GraphicsResourceUsage.Default)
{
viewFormat = CheckPixelFormat(bufferFlags, elementSize, viewFormat);
var description = NewDescription(bufferSize, elementSize, bufferFlags, usage);
return(new Buffer(device).InitializeFromImpl(description, bufferFlags, viewFormat, IntPtr.Zero));
}
private void CheckDebugTextureData(GraphicsContext graphicsContext, Texture debugTexture, int width, int height, int mipmaps, int arraySize,
PixelFormat format, TextureFlags flags, GraphicsResourceUsage usage, Func<int, int, int, int, int, byte> dataComputer)
{
var pixelSize = format.SizeInBytes();
for (int arraySlice = 0; arraySlice < arraySize; arraySlice++)
{
for (int mipSlice = 0; mipSlice < mipmaps; mipSlice++)
{
var w = width >> mipSlice;
var h = height >> mipSlice;
var readData = debugTexture.GetData<byte>(graphicsContext.CommandList, arraySlice, mipSlice);
for (int r = 0; r < h; r++)
{
for (int c = 0; c < w; c++)
{
for (int i = 0; i < pixelSize; i++)
{
var value = readData[(r * w + c) * pixelSize + i];
var expectedValue = dataComputer(c, r, mipSlice, arraySlice, i);
if (!expectedValue.Equals(value))
Assert.Fail("The texture data get at [{0}, {1}] for mipmap level '{2}' and slice '{3}' with flags '{4}', usage '{5}' and format '{6}' is not valid. " +
"Expected '{7}' but was '{8}' at index '{9}'",
c, r, mipSlice, arraySlice, flags, usage, format, expectedValue, value, i);
}
}
}
}
}
}
/// <summary>
/// Creates a new <see cref="Buffer" /> instance from a byte array.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="initialValue">The initial value of this buffer.</param>
/// <param name="elementSize">Size of an element. Must be equal to 2 or 4 for an index buffer, or to the size of a struct for a structured/typed buffer. Can be set to 0 for other buffers.</param>
/// <param name="bufferFlags">The buffer flags to specify the type of buffer.</param>
/// <param name="viewFormat">The view format must be specified if the buffer is declared as a shared resource view.</param>
/// <param name="usage">The usage.</param>
/// <returns>An instance of a new <see cref="Buffer" /></returns>
public static Buffer New(GraphicsDevice device, byte[] initialValue, int elementSize, BufferFlags bufferFlags, PixelFormat viewFormat = PixelFormat.None, GraphicsResourceUsage usage = GraphicsResourceUsage.Immutable)
{
return(new Buffer(device).InitializeFrom(initialValue, elementSize, bufferFlags, viewFormat, usage));
}
/// <summary>
/// Creates a new Cube <see cref="TextureDescription"/>.
/// </summary>
/// <param name="size">The size (in pixels) of the top-level faces of the cube texture.</param>
/// <param name="mipCount">Number of mipmaps, set to true to have all mipmaps, set to an int >=1 for a particular mipmap count.</param>
/// <param name="format">Describes the format to use.</param>
/// <param name="textureFlags">The texture flags.</param>
/// <param name="usage">The usage.</param>
/// <returns>A new instance of <see cref="TextureDescription"/> class.</returns>
public static TextureDescription NewCube(int size, MipMapCount mipCount, PixelFormat format, TextureFlags textureFlags = TextureFlags.ShaderResource, GraphicsResourceUsage usage = GraphicsResourceUsage.Default)
{
return NewCube(size, format, textureFlags, mipCount, usage);
}
internal unsafe Buffer InitializeFrom(byte[] initialValue, int elementSize, BufferFlags bufferFlags, PixelFormat viewFormat = PixelFormat.None, GraphicsResourceUsage usage = GraphicsResourceUsage.Immutable)
{
int bufferSize = initialValue.Length;
viewFormat = CheckPixelFormat(bufferFlags, elementSize, viewFormat);
var description = NewDescription(bufferSize, elementSize, bufferFlags, usage);
return(InitializeFromImpl(description, bufferFlags, viewFormat, (IntPtr)Interop.Fixed(initialValue)));
}
private static TextureDescription NewCube(int size, PixelFormat format, TextureFlags textureFlags, int mipCount, GraphicsResourceUsage usage)
{
var desc = New2D(size, size, format, textureFlags, mipCount, 6, usage);
desc.Dimension = TextureDimension.TextureCube;
return desc;
}
/// <summary>
/// Creates a new 1D <see cref="Texture"/> with a single mipmap.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="width">The width.</param>
/// <param name="format">Describes the format to use.</param>
/// <param name="usage">The usage.</param>
/// <param name="textureFlags">true if the texture needs to support unordered read write.</param>
/// <param name="arraySize">Size of the texture 2D array, default to 1.</param>
/// <returns>
/// A new instance of 1D <see cref="Texture"/> class.
/// </returns>
public static Texture New1D(GraphicsDevice device, int width, PixelFormat format, TextureFlags textureFlags = TextureFlags.ShaderResource, int arraySize = 1, GraphicsResourceUsage usage = GraphicsResourceUsage.Default)
{
return(New1D(device, width, false, format, textureFlags, arraySize, usage));
}
/// <summary>
/// Creates a new Raw buffer with <see cref="GraphicsResourceUsage.Default"/> uasge by default.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="value">The value to initialize the Raw buffer.</param>
/// <param name="additionalBindings">The additional bindings (for example, to create a combined raw/index buffer, pass <see cref="BufferFlags.IndexBuffer" />)</param>
/// <param name="usage">The usage of this resource.</param>
/// <returns>A Raw buffer</returns>
public static Buffer New(GraphicsDevice device, DataPointer value, BufferFlags additionalBindings = BufferFlags.None, GraphicsResourceUsage usage = GraphicsResourceUsage.Default)
{
return(Buffer.New(device, value, 0, BufferFlags.RawBuffer | additionalBindings, usage));
}
/// <summary>
/// Creates a new 1D <see cref="Texture" /> with a single level of mipmap.
/// </summary>
/// <typeparam name="T">Type of the initial data to upload to the texture</typeparam>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="width">The width.</param>
/// <param name="format">Describes the format to use.</param>
/// <param name="usage">The usage.</param>
/// <param name="textureData">Texture data. Size of must be equal to sizeof(Format) * width </param>
/// <param name="textureFlags">true if the texture needs to support unordered read write.</param>
/// <returns>A new instance of <see cref="Texture" /> class.</returns>
/// <remarks>
/// The first dimension of mipMapTextures describes the number of array (Texture Array), second dimension is the mipmap, the third is the texture data for a particular mipmap.
/// </remarks>
public unsafe static Texture New1D <T>(GraphicsDevice device, int width, PixelFormat format, T[] textureData, TextureFlags textureFlags = TextureFlags.ShaderResource, GraphicsResourceUsage usage = GraphicsResourceUsage.Immutable) where T : struct
{
return(New(device, TextureDescription.New1D(width, format, textureFlags, usage), new[] { GetDataBox(format, width, 1, 1, textureData, (IntPtr)Interop.Fixed(textureData)) }));
}
/// <summary>
/// Creates a new 3D <see cref="Texture"/> with a single mipmap.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="depth">The depth.</param>
/// <param name="format">Describes the format to use.</param>
/// <param name="usage">The usage.</param>
/// <param name="textureFlags">true if the texture needs to support unordered read write.</param>
/// <returns>
/// A new instance of 3D <see cref="Texture"/> class.
/// </returns>
public static Texture New3D(GraphicsDevice device, int width, int height, int depth, PixelFormat format, TextureFlags textureFlags = TextureFlags.ShaderResource, GraphicsResourceUsage usage = GraphicsResourceUsage.Default)
{
return(New3D(device, width, height, depth, false, format, textureFlags, usage));
}
/// <summary>
/// Creates a new description from another description but overrides <see cref="Flags"/> and <see cref="Usage"/>.
/// </summary>
/// <param name="desc">The desc.</param>
/// <param name="textureFlags">The texture flags.</param>
/// <param name="usage">The usage.</param>
/// <returns>TextureDescription.</returns>
public static TextureDescription FromDescription(TextureDescription desc, TextureFlags textureFlags, GraphicsResourceUsage usage)
{
desc.Flags = textureFlags;
desc.Usage = usage;
if ((textureFlags & TextureFlags.UnorderedAccess) != 0)
{
desc.Usage = GraphicsResourceUsage.Default;
}
return(desc);
}
/// <summary>
/// Creates a new 3D <see cref="Texture"/>.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="depth">The depth.</param>
/// <param name="mipCount">Number of mipmaps, set to true to have all mipmaps, set to an int >=1 for a particular mipmap count.</param>
/// <param name="format">Describes the format to use.</param>
/// <param name="usage">The usage.</param>
/// <param name="textureFlags">true if the texture needs to support unordered read write.</param>
/// <returns>
/// A new instance of 3D <see cref="Texture"/> class.
/// </returns>
public static Texture New3D(GraphicsDevice device, int width, int height, int depth, MipMapCount mipCount, PixelFormat format, TextureFlags textureFlags = TextureFlags.ShaderResource, GraphicsResourceUsage usage = GraphicsResourceUsage.Default)
{
return(new Texture(device).InitializeFrom(TextureDescription.New3D(width, height, depth, mipCount, format, textureFlags, usage)));
}
/// <summary>
/// Creates a new Argument buffer with <see cref="GraphicsResourceUsage.Default"/> uasge by default.
/// </summary>
/// <typeparam name="T">Type of the Argument buffer to get the sizeof from</typeparam>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="value">The value to initialize the Argument buffer.</param>
/// <param name="usage">The usage of this resource.</param>
/// <returns>A Argument buffer</returns>
public static Buffer <T> New <T>(GraphicsDevice device, ref T value, GraphicsResourceUsage usage = GraphicsResourceUsage.Default) where T : struct
{
return(Buffer.New(device, ref value, BufferFlags.ArgumentBuffer, usage));
}
/// <summary>
/// Creates a new 3D <see cref="Texture" /> with texture data for the firs map.
/// </summary>
/// <typeparam name="T">Type of the data to upload to the texture</typeparam>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="depth">The depth.</param>
/// <param name="format">Describes the format to use.</param>
/// <param name="usage">The usage.</param>
/// <param name="textureData">The texture data, width * height * depth datas </param>
/// <param name="textureFlags">true if the texture needs to support unordered read write.</param>
/// <returns>A new instance of 3D <see cref="Texture" /> class.</returns>
/// <remarks>
/// The first dimension of mipMapTextures describes the number of is an array ot Texture3D Array
/// </remarks>
public static unsafe Texture New3D <T>(GraphicsDevice device, int width, int height, int depth, PixelFormat format, T[] textureData, TextureFlags textureFlags = TextureFlags.ShaderResource, GraphicsResourceUsage usage = GraphicsResourceUsage.Immutable) where T : struct
{
return(New3D(device, width, height, depth, 1, format, new[] { GetDataBox(format, width, height, depth, textureData, (IntPtr)Interop.Fixed(textureData)) }, textureFlags, usage));
}
/// <summary>
/// Creates a new Vertex buffer with <see cref="GraphicsResourceUsage.Immutable"/> uasge by default.
/// </summary>
/// <typeparam name="T">Type of the Vertex buffer to get the sizeof from</typeparam>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="value">The value to initialize the Vertex buffer.</param>
/// <param name="usage">The usage of this resource.</param>
/// <returns>A Vertex buffer</returns>
public static Buffer <T> New <T>(GraphicsDevice device, T[] value, GraphicsResourceUsage usage = GraphicsResourceUsage.Immutable) where T : struct
{
return(Buffer.New(device, value, BufferFlags.VertexBuffer, usage));
}
/// <summary>
/// Creates a new index buffer with <see cref="GraphicsResourceUsage.Default"/> uasge by default.
/// </summary>
/// <typeparam name="T">Type of the index buffer to get the sizeof from</typeparam>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="usage">The usage.</param>
/// <returns>A index buffer</returns>
public static Buffer <T> New <T>(GraphicsDevice device, GraphicsResourceUsage usage = GraphicsResourceUsage.Default) where T : struct
{
return(Buffer.New <T>(device, 1, BufferFlags.IndexBuffer, usage));
}
/// <summary>
/// Creates a new Vertex buffer with <see cref="GraphicsResourceUsage.Immutable"/> uasge by default.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="value">The value to initialize the Vertex buffer.</param>
/// <param name="usage">The usage of this resource.</param>
/// <returns>A Vertex buffer</returns>
public static Buffer New(GraphicsDevice device, DataPointer value, GraphicsResourceUsage usage = GraphicsResourceUsage.Immutable)
{
return(Buffer.New(device, value, 0, BufferFlags.VertexBuffer, usage));
}
/// <summary>
/// Creates a new index buffer with <see cref="GraphicsResourceUsage.Immutable"/> uasge by default.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="value">The value to initialize the index buffer.</param>
/// <param name="is32BitIndex">Set to true if the buffer is using a 32 bit index or false for 16 bit index.</param>
/// <param name="usage">The usage of this resource.</param>
/// <returns>A index buffer</returns>
public static Buffer New(GraphicsDevice device, byte[] value, bool is32BitIndex, GraphicsResourceUsage usage = GraphicsResourceUsage.Immutable)
{
return(Buffer.New(device, value, is32BitIndex ? 4 : 2, BufferFlags.IndexBuffer, PixelFormat.None, usage));
}
/// <summary>
/// Creates a new <see cref="Buffer" /> instance.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="bufferSize">Size of the buffer in bytes.</param>
/// <param name="bufferFlags">The buffer flags to specify the type of buffer.</param>
/// <param name="viewFormat">The view format must be specified if the buffer is declared as a shared resource view.</param>
/// <param name="usage">The usage.</param>
/// <returns>An instance of a new <see cref="Buffer" /></returns>
public static Buffer New(GraphicsDevice device, int bufferSize, BufferFlags bufferFlags, PixelFormat viewFormat, GraphicsResourceUsage usage = GraphicsResourceUsage.Default)
{
return(New(device, bufferSize, 0, bufferFlags, viewFormat, usage));
}
/// <summary>
/// Creates a new constant buffer with a default <see cref="GraphicsResourceUsage.Dynamic"/> usage.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="size">The size in bytes.</param>
/// <param name="usage">The usage.</param>
/// <returns>A constant buffer</returns>
public static Buffer New(GraphicsDevice device, int size, GraphicsResourceUsage usage = GraphicsResourceUsage.Dynamic)
{
return(Buffer.New(device, size, BufferFlags.ConstantBuffer, usage));
}
/// <summary>
/// Creates a new <see cref="Buffer" /> instance.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <typeparam name="T">Type of the buffer, to get the sizeof from.</typeparam>
/// <param name="value">The initial value of this buffer.</param>
/// <param name="bufferFlags">The buffer flags to specify the type of buffer.</param>
/// <param name="viewFormat">The view format must be specified if the buffer is declared as a shared resource view.</param>
/// <param name="usage">The usage.</param>
/// <returns>An instance of a new <see cref="Buffer" /></returns>
public static unsafe Buffer <T> New <T>(GraphicsDevice device, ref T value, BufferFlags bufferFlags, PixelFormat viewFormat, GraphicsResourceUsage usage = GraphicsResourceUsage.Default) where T : struct
{
int bufferSize = Utilities.SizeOf <T>();
int elementSize = ((bufferFlags & BufferFlags.StructuredBuffer) != 0) ? Utilities.SizeOf <T>() : 0;
viewFormat = CheckPixelFormat(bufferFlags, elementSize, viewFormat);
var description = NewDescription(bufferSize, elementSize, bufferFlags, usage);
return(new Buffer <T>(device, description, bufferFlags, viewFormat, (IntPtr)Interop.Fixed(ref value)));
}
/// <summary>
/// Creates a new constant buffer with <see cref="GraphicsResourceUsage.Dynamic"/> usage.
/// </summary>
/// <typeparam name="T">Type of the constant buffer to get the sizeof from</typeparam>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="value">The value to initialize the constant buffer.</param>
/// <param name="usage">The usage of this resource.</param>
/// <returns>A constant buffer</returns>
public static Buffer <T> New <T>(GraphicsDevice device, T[] value, GraphicsResourceUsage usage = GraphicsResourceUsage.Dynamic) where T : struct
{
return(Buffer.New(device, value, BufferFlags.ConstantBuffer, usage));
}
/// <summary>
/// Creates a new <see cref="Buffer" /> instance.
/// </summary>
/// <typeparam name="T">Type of the buffer, to get the sizeof from.</typeparam>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="initialValue">The initial value of this buffer.</param>
/// <param name="bufferFlags">The buffer flags to specify the type of buffer.</param>
/// <param name="viewFormat">The view format must be specified if the buffer is declared as a shared resource view.</param>
/// <param name="usage">The usage.</param>
/// <returns>An instance of a new <see cref="Buffer" /></returns>
public static unsafe Buffer <T> New <T>(GraphicsDevice device, T[] initialValue, BufferFlags bufferFlags, PixelFormat viewFormat, GraphicsResourceUsage usage = GraphicsResourceUsage.Default) where T : struct
{
int bufferSize = Utilities.SizeOf <T>() * initialValue.Length;
int elementSize = Utilities.SizeOf <T>();
viewFormat = CheckPixelFormat(bufferFlags, elementSize, viewFormat);
var description = NewDescription(bufferSize, elementSize, bufferFlags, usage);
return(new Buffer <T>(device, description, bufferFlags, viewFormat, (IntPtr)Interop.Fixed(initialValue)));
}
/// <summary>
/// Creates a new constant buffer with <see cref="GraphicsResourceUsage.Dynamic"/> usage.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="value">The value to initialize the constant buffer.</param>
/// <param name="usage">The usage of this resource.</param>
/// <returns>A constant buffer</returns>
public static Buffer New(GraphicsDevice device, DataPointer value, GraphicsResourceUsage usage = GraphicsResourceUsage.Dynamic)
{
return(Buffer.New(device, value, 0, BufferFlags.ConstantBuffer, usage));
}
/// <summary>
/// Creates a new <see cref="Buffer" /> instance.
/// </summary>
/// <param name="device">The <see cref="GraphicsDevice"/>.</param>
/// <param name="dataPointer">The data pointer.</param>
/// <param name="elementSize">Size of the element.</param>
/// <param name="bufferFlags">The buffer flags to specify the type of buffer.</param>
/// <param name="usage">The usage.</param>
/// <returns>An instance of a new <see cref="Buffer" /></returns>
public static Buffer New(GraphicsDevice device, DataPointer dataPointer, int elementSize, BufferFlags bufferFlags, GraphicsResourceUsage usage = GraphicsResourceUsage.Default)
{
return(New(device, dataPointer, elementSize, bufferFlags, PixelFormat.None, usage));
}
/// <summary>
/// Creates a new <see cref="TextureDescription" />.
/// </summary>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="depth">The depth.</param>
/// <param name="mipCount">Number of mipmaps, set to true to have all mipmaps, set to an int >=1 for a particular mipmap count.</param>
/// <param name="format">Describes the format to use.</param>
/// <param name="textureFlags">true if the texture needs to support unordered read write.</param>
/// <param name="usage">The usage.</param>
/// <returns>A new instance of <see cref="TextureDescription" /> class.</returns>
public static TextureDescription New3D(int width, int height, int depth, MipMapCount mipCount, PixelFormat format, TextureFlags textureFlags = TextureFlags.ShaderResource, GraphicsResourceUsage usage = GraphicsResourceUsage.Default)
{
return New3D(width, height, depth, format, textureFlags, mipCount, usage);
}
