public unsafe void Update_ThenCopySingleMip_Succeeds_R16UNorm()
{
TextureDescription desc = TextureDescription.Texture2D(
1024, 1024, 3, 1, PixelFormat.R16_UNorm, TextureUsage.Staging);
Texture src = RF.CreateTexture(desc);
Texture dst = RF.CreateTexture(desc);
ushort[] data = Enumerable.Range(0, 256 * 256).Select(i => (ushort)i).ToArray();
fixed(ushort *dataPtr = data)
{
GD.UpdateTexture(src, (IntPtr)dataPtr, 256 * 256 * sizeof(ushort), 0, 0, 0, 256, 256, 1, 2, 0);
}
CommandList cl = RF.CreateCommandList();
cl.Begin();
cl.CopyTexture(src, dst, 2, 0);
cl.End();
GD.SubmitCommands(cl);
GD.WaitForIdle();
MappedResource map = GD.Map(dst, MapMode.Read, 2);
ushort * mappedFloatPtr = (ushort *)map.Data;
for (int y = 0; y < 256; y++)
{
for (int x = 0; x < 256; x++)
{
uint mapIndex = (uint)(y * (map.RowPitch / sizeof(ushort)) + x);
ushort value = (ushort)(y * 256 + x);
Assert.Equal(value, mappedFloatPtr[mapIndex]);
}
}
}
public unsafe void Map_NonZeroMip_3D()
{
Texture tex3D = RF.CreateTexture(TextureDescription.Texture3D(
40, 40, 40, 3, PixelFormat.R8_G8_B8_A8_UNorm, TextureUsage.Staging));
MappedResourceView <RgbaByte> writeView = GD.Map <RgbaByte>(tex3D, MapMode.Write, 2);
for (int z = 0; z < 10; z++)
{
for (int y = 0; y < 10; y++)
{
for (int x = 0; x < 10; x++)
{
writeView[x, y, z] = new RgbaByte((byte)x, (byte)y, (byte)z, 1);
}
}
}
GD.Unmap(tex3D, 2);
MappedResourceView <RgbaByte> readView = GD.Map <RgbaByte>(tex3D, MapMode.Read, 2);
for (int z = 0; z < 10; z++)
{
for (int y = 0; y < 10; y++)
{
for (int x = 0; x < 10; x++)
{
Assert.Equal(new RgbaByte((byte)x, (byte)y, (byte)z, 1), readView[x, y, z]);
}
}
}
GD.Unmap(tex3D, 2);
}
public void NoDepthTarget_ClearAllColors_Succeeds()
{
Texture colorTarget = RF.CreateTexture(
TextureDescription.Texture2D(1024, 1024, 1, 1, PixelFormat.R32_G32_B32_A32_Float, TextureUsage.RenderTarget));
Framebuffer fb = RF.CreateFramebuffer(new FramebufferDescription(null, colorTarget));
CommandList cl = RF.CreateCommandList();
cl.Begin();
cl.SetFramebuffer(fb);
cl.ClearColorTarget(0, RgbaFloat.Red);
cl.End();
GD.SubmitCommands(cl);
GD.WaitForIdle();
Texture staging = RF.CreateTexture(
TextureDescription.Texture2D(1024, 1024, 1, 1, PixelFormat.R32_G32_B32_A32_Float, TextureUsage.Staging));
cl.Begin();
cl.CopyTexture(
colorTarget, 0, 0, 0, 0, 0,
staging, 0, 0, 0, 0, 0,
1024, 1024, 1, 1);
cl.End();
GD.SubmitCommands(cl);
GD.WaitForIdle();
MappedResourceView <RgbaFloat> view = GD.Map <RgbaFloat>(staging, MapMode.Read);
for (int i = 0; i < view.Count; i++)
{
Assert.Equal(RgbaFloat.Red, view[i]);
}
GD.Unmap(staging);
}
public unsafe void Update_ThenMapRead_SingleMip_Succeeds_R16UNorm(bool useArrayOverload)
{
Texture texture = RF.CreateTexture(
TextureDescription.Texture2D(1024, 1024, 3, 1, PixelFormat.R16_UNorm, TextureUsage.Staging));
ushort[] data = Enumerable.Range(0, 256 * 256).Select(i => (ushort)i).ToArray();
fixed(ushort *dataPtr = data)
{
if (useArrayOverload)
{
GD.UpdateTexture(texture, data, 0, 0, 0, 256, 256, 1, 2, 0);
}
else
{
GD.UpdateTexture(texture, (IntPtr)dataPtr, 256 * 256 * sizeof(ushort), 0, 0, 0, 256, 256, 1, 2, 0);
}
}
MappedResource map = GD.Map(texture, MapMode.Read, 2);
ushort * mappedUShortPtr = (ushort *)map.Data;
for (int y = 0; y < 256; y++)
{
for (int x = 0; x < 256; x++)
{
uint mapIndex = (uint)(y * (map.RowPitch / sizeof(ushort)) + x);
ushort value = (ushort)(y * 256 + x);
Assert.Equal(value, mappedUShortPtr[mapIndex]);
}
}
}
public unsafe void Update_WithOffset_2D()
{
Texture tex2D = RF.CreateTexture(TextureDescription.Texture2D(
100, 100, 1, 1, PixelFormat.R8_G8_B8_A8_UNorm, TextureUsage.Staging));
RgbaByte[] data = new RgbaByte[50 * 30];
for (uint y = 0; y < 30; y++)
{
for (uint x = 0; x < 50; x++)
{
data[y * 50 + x] = new RgbaByte((byte)x, (byte)y, 0, 1);
}
fixed(RgbaByte *dataPtr = &data[0])
{
GD.UpdateTexture(
tex2D, (IntPtr)dataPtr, (uint)(data.Length * sizeof(RgbaByte)),
50, 70, 0,
50, 30, 1,
0, 0);
}
MappedResourceView <RgbaByte> readView = GD.Map <RgbaByte>(tex2D, MapMode.Read);
for (int y = 0; y < 30; y++)
{
for (int x = 0; x < 50; x++)
{
Assert.Equal(new RgbaByte((byte)x, (byte)y, 0, 1), readView[x + 50, y + 70]);
}
}
}
public void Map_ThenRead_MultipleArrayLayers()
{
Texture src = RF.CreateTexture(TextureDescription.Texture2D(
10, 10, 1, 10, PixelFormat.R8_G8_B8_A8_UNorm, TextureUsage.Staging));
for (uint layer = 0; layer < src.ArrayLayers; layer++)
{
MappedResourceView <RgbaByte> writeView = GD.Map <RgbaByte>(src, MapMode.Write, layer);
for (int y = 0; y < src.Height; y++)
{
for (int x = 0; x < src.Width; x++)
{
writeView[x, y] = new RgbaByte((byte)x, (byte)y, (byte)layer, 1);
}
}
GD.Unmap(src, layer);
}
for (uint layer = 0; layer < src.ArrayLayers; layer++)
{
MappedResourceView <RgbaByte> readView = GD.Map <RgbaByte>(src, MapMode.Read, layer);
for (int y = 0; y < src.Height; y++)
{
for (int x = 0; x < src.Width; x++)
{
Assert.Equal(new RgbaByte((byte)x, (byte)y, (byte)layer, 1), readView[x, y]);
}
}
GD.Unmap(src, layer);
}
}
public unsafe void MapWrite_ThenMapRead_3D()
{
Texture tex3D = RF.CreateTexture(TextureDescription.Texture3D(
10, 10, 10, 1, PixelFormat.R8_G8_B8_A8_UNorm, TextureUsage.Staging));
MappedResourceView <RgbaByte> writeView = GD.Map <RgbaByte>(tex3D, MapMode.Write);
for (int z = 0; z < tex3D.Depth; z++)
{
for (int y = 0; y < tex3D.Height; y++)
{
for (int x = 0; x < tex3D.Width; x++)
{
writeView[x, y, z] = new RgbaByte((byte)x, (byte)y, (byte)z, 1);
}
}
}
GD.Unmap(tex3D);
MappedResourceView <RgbaByte> readView = GD.Map <RgbaByte>(tex3D, MapMode.Read, 0);
for (int z = 0; z < tex3D.Depth; z++)
{
for (int y = 0; y < tex3D.Height; y++)
{
for (int x = 0; x < tex3D.Width; x++)
{
Assert.Equal(new RgbaByte((byte)x, (byte)y, (byte)z, 1), readView[x, y, z]);
}
}
}
GD.Unmap(tex3D);
}
public unsafe void MapWrite_ThenMapRead_1D()
{
if (!GD.Features.Texture1D)
{
return;
}
Texture tex1D = RF.CreateTexture(
TextureDescription.Texture1D(100, 1, 1, PixelFormat.R16_UNorm, TextureUsage.Staging));
MappedResourceView <ushort> writeView = GD.Map <ushort>(tex1D, MapMode.Write);
Assert.Equal(tex1D.Width, (uint)writeView.Count);
for (int i = 0; i < writeView.Count; i++)
{
writeView[i] = (ushort)(i * 2);
}
GD.Unmap(tex1D);
MappedResourceView <ushort> view = GD.Map <ushort>(tex1D, MapMode.Read);
for (int i = 0; i < view.Count; i++)
{
Assert.Equal((ushort)(i * 2), view[i]);
}
GD.Unmap(tex1D);
}
public unsafe void Update_ThenMapRead_Succeeds_R8_G8_SNorm()
{
Texture texture = RF.CreateTexture(
TextureDescription.Texture2D(8, 8, 1, 1, PixelFormat.R8_G8_SNorm, TextureUsage.Staging));
byte[] data = Enumerable.Range(0, 8 * 8 * 2).Select(i => (byte)i).ToArray();
fixed(byte *dataPtr = data)
{
GD.UpdateTexture(texture, (IntPtr)dataPtr, 8 * 8 * sizeof(byte) * 2, 0, 0, 0, 8, 8, 1, 0, 0);
}
MappedResource map = GD.Map(texture, MapMode.Read, 0);
byte * mappedBytePtr = (byte *)map.Data;
for (int y = 0; y < 8; y++)
{
for (int x = 0; x < 8; x++)
{
uint index0 = (uint)(y * map.RowPitch + x * 2);
byte value0 = (byte)(y * 8 * 2 + x * 2);
Assert.Equal(value0, mappedBytePtr[index0]);
uint index1 = (uint)(index0 + 1);
byte value1 = (byte)(value0 + 1);
Assert.Equal(value1, mappedBytePtr[index1]);
}
}
}
public void Update_MultipleMips_1D()
{
if (!GD.Features.Texture1D)
{
return;
}
Texture tex1D = RF.CreateTexture(TextureDescription.Texture1D(
100, 5, 1, PixelFormat.R8_G8_B8_A8_UNorm, TextureUsage.Staging));
for (uint level = 0; level < tex1D.MipLevels; level++)
{
MappedResourceView <RgbaByte> writeView = GD.Map <RgbaByte>(tex1D, MapMode.Write, level);
for (int i = 0; i < writeView.Count; i++)
{
writeView[i] = new RgbaByte((byte)i, (byte)(i * 2), (byte)level, 1);
}
GD.Unmap(tex1D, level);
}
for (uint level = 0; level < tex1D.MipLevels; level++)
{
MappedResourceView <RgbaByte> readView = GD.Map <RgbaByte>(tex1D, MapMode.Read, level);
for (int i = 0; i < readView.Count; i++)
{
Assert.Equal(new RgbaByte((byte)i, (byte)(i * 2), (byte)level, 1), readView[i]);
}
GD.Unmap(tex1D, level);
}
}
public unsafe void Update_ThenMapRead_Succeeds_R32Float(bool useArrayOverload)
{
Texture texture = RF.CreateTexture(
TextureDescription.Texture2D(1024, 1024, 1, 1, PixelFormat.R32_Float, TextureUsage.Staging));
float[] data = Enumerable.Range(0, 1024 * 1024).Select(i => (float)i).ToArray();
fixed(float *dataPtr = data)
{
if (useArrayOverload)
{
GD.UpdateTexture(texture, data, 0, 0, 0, 1024, 1024, 1, 0, 0);
}
else
{
GD.UpdateTexture(texture, (IntPtr)dataPtr, 1024 * 1024 * 4, 0, 0, 0, 1024, 1024, 1, 0, 0);
}
}
MappedResource map = GD.Map(texture, MapMode.Read, 0);
float * mappedFloatPtr = (float *)map.Data;
for (int y = 0; y < 1024; y++)
{
for (int x = 0; x < 1024; x++)
{
int index = y * 1024 + x;
Assert.Equal(index, mappedFloatPtr[index]);
}
}
}
public void Map_Succeeds_R32_G32_B32_A32_UInt()
{
Texture texture = RF.CreateTexture(
TextureDescription.Texture2D(1024, 1024, 1, 1, PixelFormat.R32_G32_B32_A32_UInt, TextureUsage.Staging));
MappedResource map = GD.Map(texture, MapMode.ReadWrite, 0);
GD.Unmap(texture, 0);
}
public void ResourceSet_IncompatibleSet_Fails()
{
DeviceBuffer infoBuffer = RF.CreateBuffer(new BufferDescription(16, BufferUsage.UniformBuffer));
DeviceBuffer orthoBuffer = RF.CreateBuffer(new BufferDescription(64, BufferUsage.UniformBuffer));
ShaderSetDescription shaderSet = new ShaderSetDescription(
new VertexLayoutDescription[]
{
new VertexLayoutDescription(
new VertexElementDescription("Position", VertexElementSemantic.Position, VertexElementFormat.Float2),
new VertexElementDescription("Color_UInt", VertexElementSemantic.Color, VertexElementFormat.UInt4))
},
new Shader[]
{
TestShaders.Load(RF, "UIntVertexAttribs", ShaderStages.Vertex, "VS"),
TestShaders.Load(RF, "UIntVertexAttribs", ShaderStages.Fragment, "FS")
});
ResourceLayout layout = RF.CreateResourceLayout(new ResourceLayoutDescription(
new ResourceLayoutElementDescription("InfoBuffer", ResourceKind.UniformBuffer, ShaderStages.Vertex),
new ResourceLayoutElementDescription("Ortho", ResourceKind.UniformBuffer, ShaderStages.Vertex)));
ResourceLayout layout2 = RF.CreateResourceLayout(new ResourceLayoutDescription(
new ResourceLayoutElementDescription("InfoBuffer", ResourceKind.UniformBuffer, ShaderStages.Vertex),
new ResourceLayoutElementDescription("Tex", ResourceKind.TextureReadOnly, ShaderStages.Fragment)));
ResourceLayout layout3 = RF.CreateResourceLayout(new ResourceLayoutDescription(
new ResourceLayoutElementDescription("InfoBuffer", ResourceKind.UniformBuffer, ShaderStages.Vertex)));
Texture tex = RF.CreateTexture(TextureDescription.Texture2D(16, 16, 1, 1, PixelFormat.R32_G32_B32_A32_Float, TextureUsage.Sampled));
TextureView texView = RF.CreateTextureView(tex);
ResourceSet set = RF.CreateResourceSet(new ResourceSetDescription(layout, infoBuffer, orthoBuffer));
ResourceSet set2 = RF.CreateResourceSet(new ResourceSetDescription(layout2, infoBuffer, texView));
ResourceSet set3 = RF.CreateResourceSet(new ResourceSetDescription(layout3, infoBuffer));
GraphicsPipelineDescription gpd = new GraphicsPipelineDescription(
BlendStateDescription.SingleOverrideBlend,
DepthStencilStateDescription.Disabled,
RasterizerStateDescription.Default,
PrimitiveTopology.PointList,
shaderSet,
layout,
new OutputDescription(null, new OutputAttachmentDescription(PixelFormat.B8_G8_R8_A8_UNorm)));
Pipeline pipeline = RF.CreateGraphicsPipeline(ref gpd);
CommandList cl = RF.CreateCommandList();
cl.Begin();
cl.SetPipeline(pipeline);
cl.SetGraphicsResourceSet(0, set);
Assert.Throws <VeldridException>(() => cl.SetGraphicsResourceSet(0, set2)); // Wrong type
Assert.Throws <VeldridException>(() => cl.SetGraphicsResourceSet(0, set3)); // Wrong count
}
public void NoColorTarget_ClearColor_Fails()
{
Texture depthTarget = RF.CreateTexture(
TextureDescription.Texture2D(1024, 1024, 1, 1, PixelFormat.R16_UNorm, TextureUsage.DepthStencil));
Framebuffer fb = RF.CreateFramebuffer(new FramebufferDescription(depthTarget));
CommandList cl = RF.CreateCommandList();
cl.Begin();
cl.SetFramebuffer(fb);
Assert.Throws <VeldridException>(() => cl.ClearColorTarget(0, RgbaFloat.Red));
}
public void NoDepthTarget_ClearDepth_Fails()
{
Texture colorTarget = RF.CreateTexture(
TextureDescription.Texture2D(1024, 1024, 1, 1, PixelFormat.R32_G32_B32_A32_Float, TextureUsage.RenderTarget));
Framebuffer fb = RF.CreateFramebuffer(new FramebufferDescription(null, colorTarget));
CommandList cl = RF.CreateCommandList();
cl.Begin();
cl.SetFramebuffer(fb);
Assert.Throws <VeldridException>(() => cl.ClearDepthStencil(1f));
}
public void Dispose_Framebuffer()
{
Texture t = RF.CreateTexture(TextureDescription.Texture2D(1, 1, 1, 1, PixelFormat.R32_G32_B32_A32_Float, TextureUsage.RenderTarget));
Framebuffer fb = RF.CreateFramebuffer(new FramebufferDescription(null, t));
GD.WaitForIdle(); // Required currently by Vulkan backend.
fb.Dispose();
Assert.True(fb.IsDisposed);
Assert.False(t.IsDisposed);
t.Dispose();
Assert.True(t.IsDisposed);
}
public void Dispose_Texture()
{
Texture t = RF.CreateTexture(TextureDescription.Texture2D(1, 1, 1, 1, PixelFormat.R32_G32_B32_A32_Float, TextureUsage.Sampled));
TextureView tv = RF.CreateTextureView(t);
GD.WaitForIdle(); // Required currently by Vulkan backend.
tv.Dispose();
Assert.True(tv.IsDisposed);
Assert.False(t.IsDisposed);
t.Dispose();
Assert.True(t.IsDisposed);
}
public void NonZeroMipLevel_ClearColor_Succeeds()
{
Texture testTex = RF.CreateTexture(
TextureDescription.Texture2D(1024, 1024, 11, 1, PixelFormat.R32_G32_B32_A32_Float, TextureUsage.RenderTarget));
Framebuffer[] framebuffers = new Framebuffer[11];
for (uint level = 0; level < 11; level++)
{
framebuffers[level] = RF.CreateFramebuffer(
new FramebufferDescription(null, new[] { new FramebufferAttachmentDescription(testTex, 0, level) }));
}
CommandList cl = RF.CreateCommandList();
cl.Begin();
for (uint level = 0; level < 11; level++)
{
cl.SetFramebuffer(framebuffers[level]);
cl.ClearColorTarget(0, new RgbaFloat(level, level, level, 1));
}
cl.End();
GD.SubmitCommands(cl);
GD.WaitForIdle();
Texture readback = RF.CreateTexture(
TextureDescription.Texture2D(1024, 1024, 11, 1, PixelFormat.R32_G32_B32_A32_Float, TextureUsage.Staging));
cl.Begin();
cl.CopyTexture(testTex, readback);
cl.End();
GD.SubmitCommands(cl);
GD.WaitForIdle();
uint mipWidth = 1024;
uint mipHeight = 1024;
for (uint level = 0; level < 11; level++)
{
MappedResourceView <RgbaFloat> readView = GD.Map <RgbaFloat>(readback, MapMode.Read, level);
for (uint y = 0; y < mipHeight; y++)
{
for (uint x = 0; x < mipWidth; x++)
{
Assert.Equal(new RgbaFloat(level, level, level, 1), readView[x, y]);
}
}
GD.Unmap(readback, level);
mipWidth = Math.Max(1, mipWidth / 2);
mipHeight = Math.Max(1, mipHeight / 2);
}
}
public void ResourceSet_IncorrectTextureUsage_Fails()
{
ResourceLayout layout = RF.CreateResourceLayout(new ResourceLayoutDescription(
new ResourceLayoutElementDescription("TV0", ResourceKind.TextureReadWrite, ShaderStages.Vertex)));
Texture t = RF.CreateTexture(TextureDescription.Texture2D(64, 64, 1, 1, PixelFormat.R8_G8_B8_A8_UNorm, TextureUsage.Sampled));
TextureView tv = RF.CreateTextureView(t);
Assert.Throws <VeldridException>(() =>
{
ResourceSet set = RF.CreateResourceSet(new ResourceSetDescription(layout, tv));
});
}
public unsafe void Copy_Compressed_Texture(PixelFormat format, uint blockSizeInBytes, uint srcX, uint srcY, uint copyWidth, uint copyHeight)
{
if (!GD.GetPixelFormatSupport(format, TextureType.Texture2D, TextureUsage.Sampled))
{
return;
}
Texture copySrc = RF.CreateTexture(TextureDescription.Texture2D(
64, 64, 1, 1, format, TextureUsage.Staging));
Texture copyDst = RF.CreateTexture(TextureDescription.Texture2D(
copyWidth, copyHeight, 1, 1, format, TextureUsage.Staging));
const int numPixelsInBlockSide = 4;
const int numPixelsInBlock = 16;
uint totalDataSize = copyWidth * copyHeight / numPixelsInBlock * blockSizeInBytes;
byte[] data = new byte[totalDataSize];
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)i;
}
fixed(byte *dataPtr = data)
{
GD.UpdateTexture(copySrc, (IntPtr)dataPtr, totalDataSize, srcX, srcY, 0, copyWidth, copyHeight, 1, 0, 0);
}
CommandList cl = RF.CreateCommandList();
cl.Begin();
cl.CopyTexture(
copySrc, srcX, srcY, 0, 0, 0,
copyDst, 0, 0, 0, 0, 0,
copyWidth, copyHeight, 1, 1);
cl.End();
GD.SubmitCommands(cl);
GD.WaitForIdle();
uint numBytesPerRow = copyWidth / numPixelsInBlockSide * blockSizeInBytes;
MappedResourceView <byte> view = GD.Map <byte>(copyDst, MapMode.Read);
for (uint i = 0; i < data.Length; i++)
{
uint viewRow = i / numBytesPerRow;
uint viewIndex = (view.MappedResource.RowPitch * viewRow) + (i % numBytesPerRow);
Assert.Equal(data[i], view[viewIndex]);
}
GD.Unmap(copyDst);
}
public unsafe void Update_NonMultipleOfFourWithCompressedTexture_2D()
{
Texture tex2D = RF.CreateTexture(TextureDescription.Texture2D(
2, 2, 1, 1, PixelFormat.BC1_Rgb_UNorm, TextureUsage.Staging));
byte[] data = new byte[16];
fixed(byte *dataPtr = &data[0])
{
GD.UpdateTexture(
tex2D, (IntPtr)dataPtr, (uint)data.Length,
0, 0, 0,
4, 4, 1,
0, 0);
}
}
public unsafe void Update_NonStaging_3D()
{
Texture tex3D = RF.CreateTexture(TextureDescription.Texture3D(
16, 16, 16, 1, PixelFormat.R8_G8_B8_A8_UNorm, TextureUsage.Sampled));
RgbaByte[] data = new RgbaByte[16 * 16 * 16];
for (int z = 0; z < 16; z++)
for (int y = 0; y < 16; y++)
{
for (int x = 0; x < 16; x++)
{
int index = (int)(z * tex3D.Width * tex3D.Height + y * tex3D.Height + x);
data[index] = new RgbaByte((byte)x, (byte)y, (byte)z, 1);
}
}
fixed(RgbaByte *dataPtr = data)
{
GD.UpdateTexture(tex3D, (IntPtr)dataPtr, (uint)(data.Length * Unsafe.SizeOf <RgbaByte>()),
0, 0, 0,
tex3D.Width, tex3D.Height, tex3D.Depth,
0, 0);
}
Texture staging = RF.CreateTexture(TextureDescription.Texture3D(
16, 16, 16, 1, PixelFormat.R8_G8_B8_A8_UNorm, TextureUsage.Staging));
CommandList cl = RF.CreateCommandList();
cl.Begin();
cl.CopyTexture(tex3D, staging);
cl.End();
GD.SubmitCommands(cl);
GD.WaitForIdle();
MappedResourceView <RgbaByte> view = GD.Map <RgbaByte>(staging, MapMode.Read);
for (int z = 0; z < tex3D.Depth; z++)
for (int y = 0; y < tex3D.Height; y++)
{
for (int x = 0; x < tex3D.Width; x++)
{
Assert.Equal(new RgbaByte((byte)x, (byte)y, (byte)z, 1), view[x, y, z]);
}
}
}
public void ClearColorTarget_OutOfRange_Fails()
{
TextureDescription desc = TextureDescription.Texture2D(
1024, 1024, 1, 1, PixelFormat.R32_G32_B32_A32_Float, TextureUsage.RenderTarget);
Texture colorTarget0 = RF.CreateTexture(desc);
Texture colorTarget1 = RF.CreateTexture(desc);
Framebuffer fb = RF.CreateFramebuffer(new FramebufferDescription(null, colorTarget0, colorTarget1));
CommandList cl = RF.CreateCommandList();
cl.Begin();
cl.SetFramebuffer(fb);
cl.ClearColorTarget(0, RgbaFloat.Red);
cl.ClearColorTarget(1, RgbaFloat.Red);
Assert.Throws <VeldridException>(() => cl.ClearColorTarget(2, RgbaFloat.Red));
Assert.Throws <VeldridException>(() => cl.ClearColorTarget(3, RgbaFloat.Red));
}
public void Copy_WithOffsets_2D(TextureUsage srcUsage, TextureUsage dstUsage)
{
Texture src = RF.CreateTexture(TextureDescription.Texture2D(
100, 100, 1, 1, PixelFormat.R8_G8_B8_A8_UNorm, srcUsage));
Texture dst = RF.CreateTexture(TextureDescription.Texture2D(
100, 100, 1, 1, PixelFormat.R8_G8_B8_A8_UNorm, dstUsage));
RgbaByte[] srcData = new RgbaByte[src.Height * src.Width];
for (int y = 0; y < src.Height; y++)
{
for (int x = 0; x < src.Width; x++)
{
srcData[y * src.Width + x] = new RgbaByte((byte)x, (byte)y, 0, 1);
}
}
GD.UpdateTexture(src, srcData, 0, 0, 0, src.Width, src.Height, 1, 0, 0);
CommandList cl = RF.CreateCommandList();
cl.Begin();
cl.CopyTexture(
src,
50, 50, 0, 0, 0,
dst,
10, 10, 0, 0, 0,
50, 50, 1, 1);
cl.End();
GD.SubmitCommands(cl);
GD.WaitForIdle();
Texture readback = GetReadback(dst);
MappedResourceView <RgbaByte> readView = GD.Map <RgbaByte>(readback, MapMode.Read);
for (int y = 10; y < 60; y++)
{
for (int x = 10; x < 60; x++)
{
Assert.Equal(new RgbaByte((byte)(x + 40), (byte)(y + 40), 0, 1), readView[x, y]);
}
}
GD.Unmap(readback);
}
public unsafe void Update_ThenMapRead_1D()
{
Texture tex1D = RF.CreateTexture(
TextureDescription.Texture1D(100, 1, 1, PixelFormat.R16_UNorm, TextureUsage.Staging));
ushort[] data = Enumerable.Range(0, (int)tex1D.Width).Select(i => (ushort)(i * 2)).ToArray();
fixed(ushort *dataPtr = &data[0])
{
GD.UpdateTexture(tex1D, (IntPtr)dataPtr, (uint)(data.Length * sizeof(ushort)), 0, 0, 0, tex1D.Width, 1, 1, 0, 0);
}
MappedResourceView <ushort> view = GD.Map <ushort>(tex1D, MapMode.Read);
for (int i = 0; i < view.Count; i++)
{
Assert.Equal((ushort)(i * 2), view[i]);
}
GD.Unmap(tex1D);
}
public void Copy_WitOffsets_2D()
{
Texture src = RF.CreateTexture(TextureDescription.Texture2D(
100, 100, 1, 1, PixelFormat.R8_G8_B8_A8_UNorm, TextureUsage.Staging));
Texture dst = RF.CreateTexture(TextureDescription.Texture2D(
100, 100, 1, 1, PixelFormat.R8_G8_B8_A8_UNorm, TextureUsage.Staging));
MappedResourceView <RgbaByte> writeView = GD.Map <RgbaByte>(src, MapMode.Write);
for (int y = 0; y < src.Height; y++)
{
for (int x = 0; x < src.Width; x++)
{
writeView[x, y] = new RgbaByte((byte)x, (byte)y, 0, 1);
}
}
GD.Unmap(src);
CommandList cl = RF.CreateCommandList();
cl.Begin();
cl.CopyTexture(
src,
50, 50, 0, 0, 0,
dst, 10, 10, 0, 0, 0,
50, 50, 1, 1);
cl.End();
GD.SubmitCommands(cl);
GD.WaitForIdle();
MappedResourceView <RgbaByte> readView = GD.Map <RgbaByte>(dst, MapMode.Read);
for (int y = 10; y < 60; y++)
{
for (int x = 10; x < 60; x++)
{
Assert.Equal(new RgbaByte((byte)(x + 40), (byte)(y + 40), 0, 1), readView[x, y]);
}
}
GD.Unmap(dst);
}
public void Copy_DifferentMip_1DTo2D()
{
if (!GD.Features.Texture1D)
{
return;
}
Texture tex1D = RF.CreateTexture(
TextureDescription.Texture1D(200, 2, 1, PixelFormat.R16_UNorm, TextureUsage.Staging));
Texture tex2D = RF.CreateTexture(
TextureDescription.Texture2D(100, 10, 1, 1, PixelFormat.R16_UNorm, TextureUsage.Staging));
MappedResourceView <ushort> writeView = GD.Map <ushort>(tex1D, MapMode.Write, 1);
Assert.Equal(tex2D.Width, (uint)writeView.Count);
for (int i = 0; i < writeView.Count; i++)
{
writeView[i] = (ushort)(i * 2);
}
GD.Unmap(tex1D, 1);
CommandList cl = RF.CreateCommandList();
cl.Begin();
cl.CopyTexture(
tex1D, 0, 0, 0, 1, 0,
tex2D, 0, 5, 0, 0, 0,
tex2D.Width, 1, 1, 1);
cl.End();
GD.SubmitCommands(cl);
GD.DisposeWhenIdle(cl);
GD.WaitForIdle();
MappedResourceView <ushort> readView = GD.Map <ushort>(tex2D, MapMode.Read);
for (int i = 0; i < tex2D.Width; i++)
{
Assert.Equal((ushort)(i * 2), readView[i, 5]);
}
GD.Unmap(tex2D);
}
public void ExplicitOffsets(uint firstOffset, uint secondOffset, uint thirdOffset, uint fourthOffset, int stride, bool succeeds)
{
Texture outTex = RF.CreateTexture(
TextureDescription.Texture2D(1, 1, 1, 1, PixelFormat.R32_G32_B32_A32_Float, TextureUsage.RenderTarget));
Framebuffer fb = RF.CreateFramebuffer(new FramebufferDescription(null, outTex));
VertexLayoutDescription vertexLayoutDesc = new VertexLayoutDescription(
new VertexElementDescription("A_V3", VertexElementSemantic.TextureCoordinate, VertexElementFormat.Float3, firstOffset),
new VertexElementDescription("B_V4", VertexElementSemantic.TextureCoordinate, VertexElementFormat.Float4, secondOffset),
new VertexElementDescription("C_V2", VertexElementSemantic.TextureCoordinate, VertexElementFormat.Float2, thirdOffset),
new VertexElementDescription("D_V4", VertexElementSemantic.TextureCoordinate, VertexElementFormat.Float4, fourthOffset));
if (stride > 0)
{
vertexLayoutDesc.Stride = (uint)stride;
}
ShaderSetDescription shaderSet = new ShaderSetDescription(
new VertexLayoutDescription[]
{
vertexLayoutDesc
},
TestShaders.LoadVertexFragment(RF, "VertexLayoutTestShader"));
try
{
RF.CreateGraphicsPipeline(new GraphicsPipelineDescription(
BlendStateDescription.SingleOverrideBlend,
DepthStencilStateDescription.Disabled,
RasterizerStateDescription.Default,
PrimitiveTopology.TriangleList,
shaderSet,
Array.Empty <ResourceLayout>(),
fb.OutputDescription));
}
catch when(!succeeds)
{
}
}
public unsafe void Update_ThenMapRead_3D()
{
Texture tex3D = RF.CreateTexture(TextureDescription.Texture3D(
10, 10, 10, 1, PixelFormat.R8_G8_B8_A8_UNorm, TextureUsage.Staging));
RgbaByte[] data = new RgbaByte[tex3D.Width * tex3D.Height * tex3D.Depth];
for (int z = 0; z < tex3D.Depth; z++)
{
for (int y = 0; y < tex3D.Height; y++)
{
for (int x = 0; x < tex3D.Width; x++)
{
int index = (int)(z * tex3D.Width * tex3D.Height + y * tex3D.Height + x);
data[index] = new RgbaByte((byte)x, (byte)y, (byte)z, 1);
}
}
fixed(RgbaByte *dataPtr = data)
{
GD.UpdateTexture(tex3D, (IntPtr)dataPtr, (uint)(data.Length * Unsafe.SizeOf <RgbaByte>()),
0, 0, 0,
tex3D.Width, tex3D.Height, tex3D.Depth,
0, 0);
}
MappedResourceView <RgbaByte> view = GD.Map <RgbaByte>(tex3D, MapMode.Read, 0);
for (int z = 0; z < tex3D.Depth; z++)
{
for (int y = 0; y < tex3D.Height; y++)
{
for (int x = 0; x < tex3D.Width; x++)
{
Assert.Equal(new RgbaByte((byte)x, (byte)y, (byte)z, 1), view[x, y, z]);
}
}
}
GD.Unmap(tex3D);
}
public void CreatePipelines_DifferentInstanceStepRate_Succeeds()
{
Texture colorTex = RF.CreateTexture(TextureDescription.Texture2D(1, 1, 1, 1, PixelFormat.R8_G8_B8_A8_UNorm, TextureUsage.RenderTarget));
Framebuffer framebuffer = RF.CreateFramebuffer(new FramebufferDescription(null, colorTex));
ShaderSetDescription shaderSet = new ShaderSetDescription(
new VertexLayoutDescription[]
{
new VertexLayoutDescription(
24,
0,
new VertexElementDescription("Position", VertexElementSemantic.TextureCoordinate, VertexElementFormat.Float2),
new VertexElementDescription("Color_UInt", VertexElementSemantic.TextureCoordinate, VertexElementFormat.UInt4))
},
TestShaders.LoadVertexFragment(RF, "UIntVertexAttribs"));
ResourceLayout layout = RF.CreateResourceLayout(new ResourceLayoutDescription(
new ResourceLayoutElementDescription("InfoBuffer", ResourceKind.UniformBuffer, ShaderStages.Vertex),
new ResourceLayoutElementDescription("Ortho", ResourceKind.UniformBuffer, ShaderStages.Vertex)));
GraphicsPipelineDescription gpd = new GraphicsPipelineDescription(
BlendStateDescription.SingleOverrideBlend,
DepthStencilStateDescription.Disabled,
RasterizerStateDescription.Default,
PrimitiveTopology.PointList,
shaderSet,
layout,
framebuffer.OutputDescription);
Pipeline pipeline1 = RF.CreateGraphicsPipeline(ref gpd);
Pipeline pipeline2 = RF.CreateGraphicsPipeline(ref gpd);
gpd.ShaderSet.VertexLayouts[0].InstanceStepRate = 4;
Pipeline pipeline3 = RF.CreateGraphicsPipeline(ref gpd);
gpd.ShaderSet.VertexLayouts[0].InstanceStepRate = 5;
Pipeline pipeline4 = RF.CreateGraphicsPipeline(ref gpd);
}