public void TestReadAndReadAll()
{
// Define variables and constants
const uint WIDTH_TX = 512U;
Texture1D <TexelFormat.RGBA32Int> srcTex = TextureFactory.NewTexture1D <TexelFormat.RGBA32Int>()
.WithInitialData(
Enumerable.Range(0, (int)TextureUtils.GetSizeTexels(true, WIDTH_TX))
.Select(i => new TexelFormat.RGBA32Int {
R = i, G = i * 2, B = i * 3, A = i * 4
})
.ToArray()
)
.WithMipAllocation(true)
.WithPermittedBindings(GPUBindings.None)
.WithUsage(ResourceUsage.StagingRead)
.WithWidth(WIDTH_TX);
TexelFormat.RGBA32Int[] readAllData = srcTex.ReadAll();
for (int i = 0, curMipIndex = 0; i < readAllData.Length; ++curMipIndex)
{
var readData = srcTex.Read((uint)curMipIndex);
for (int j = 0; j < readData.Width; ++j, ++i)
{
Assert.AreEqual(readData[j], readAllData[i]);
}
}
srcTex.Dispose();
}
public void TestCopyTo()
{
LosgapSystem.InvokeOnMaster(() => {
// Define variables and constants
const uint WIDTH_TX = 512U;
const uint NUM_TEXELS_TO_COPY = 25U;
const uint FIRST_TEXEL_TO_COPY = 25U;
const uint SRC_MIP_INDEX = 1U;
const uint DST_MIP_INDEX = 3U;
const uint DST_WRITE_OFFSET = 15U;
const uint DATA_VALUE_START_R = 512U + FIRST_TEXEL_TO_COPY;
Texture1D <TexelFormat.RGBA32Int> srcTex = TextureFactory.NewTexture1D <TexelFormat.RGBA32Int>()
.WithDynamicDetail(false)
.WithInitialData(
Enumerable.Range(0, (int)TextureUtils.GetSizeTexels(true, WIDTH_TX))
.Select(i => new TexelFormat.RGBA32Int {
R = i, G = i * 2, B = i * 3, A = i * 4
})
.ToArray()
)
.WithMipAllocation(true)
.WithMipGenerationTarget(false)
.WithPermittedBindings(GPUBindings.ReadableShaderResource)
.WithUsage(ResourceUsage.Immutable)
.WithWidth(WIDTH_TX);
// Set up context
// Execute
Texture1D <TexelFormat.RGBA32Int> dstTex = srcTex.Clone()
.WithUsage(ResourceUsage.StagingRead)
.WithPermittedBindings(GPUBindings.None);
srcTex.CopyTo(
dstTex,
new SubresourceBox(FIRST_TEXEL_TO_COPY, FIRST_TEXEL_TO_COPY + NUM_TEXELS_TO_COPY),
SRC_MIP_INDEX,
DST_MIP_INDEX,
DST_WRITE_OFFSET
);
// Assert outcome
TexelArray1D <TexelFormat.RGBA32Int> copiedData = dstTex.Read(DST_MIP_INDEX);
for (int i = 0; i < NUM_TEXELS_TO_COPY; ++i)
{
Assert.AreEqual(DATA_VALUE_START_R + i, copiedData[i + (int)DST_WRITE_OFFSET].R);
Assert.AreEqual((DATA_VALUE_START_R + i) * 2, copiedData[i + (int)DST_WRITE_OFFSET].G);
Assert.AreEqual((DATA_VALUE_START_R + i) * 3, copiedData[i + (int)DST_WRITE_OFFSET].B);
Assert.AreEqual((DATA_VALUE_START_R + i) * 4, copiedData[i + (int)DST_WRITE_OFFSET].A);
}
srcTex.Dispose();
dstTex.Dispose();
});
}
public void TestGenerateMips()
{
LosgapSystem.InvokeOnMaster(() => {
// Define variables and constants
const uint WIDTH_TX = 256U;
const uint HEIGHT_TX = 128U;
const uint ARR_LEN = 4U;
Texture2DArray <TexelFormat.RGBA8UNorm> sourceTex = TextureFactory.NewTexture2D <TexelFormat.RGBA8UNorm>()
.WithWidth(WIDTH_TX)
.WithHeight(HEIGHT_TX)
.WithMipAllocation(true)
.WithMipGenerationTarget(true)
.WithPermittedBindings(GPUBindings.ReadableShaderResource | GPUBindings.RenderTarget)
.WithUsage(ResourceUsage.Write)
.CreateArray(ARR_LEN);
Texture2DArray <TexelFormat.RGBA8UNorm> copyDestTex = sourceTex.Clone()
.WithUsage(ResourceUsage.StagingRead)
.WithPermittedBindings(GPUBindings.None)
.WithMipGenerationTarget(false)
.CreateArray(ARR_LEN);
// Set up context
for (uint u = 0U; u < ARR_LEN; u++)
{
sourceTex[u].Write(
// ReSharper disable PossibleLossOfFraction No one cares
Enumerable.Range(0, (int)TextureUtils.GetSizeTexels(false, WIDTH_TX, HEIGHT_TX))
.Select(i => new TexelFormat.RGBA8UNorm {
R = 0f, G = 0.33f, B = 0.67f, A = 1f
}).ToArray(),
// ReSharper restore PossibleLossOfFraction
new SubresourceBox(0U, WIDTH_TX, 0U, HEIGHT_TX),
0U
);
}
// Execute
sourceTex.GenerateMips();
sourceTex.CopyTo(copyDestTex);
// Assert outcome
for (uint u = 0U; u < ARR_LEN; u++)
{
for (uint i = 1U; i < TextureUtils.GetNumMips(WIDTH_TX, HEIGHT_TX); ++i)
{
IEnumerable <TexelFormat.RGBA8UNorm> outData = copyDestTex[u].Read(i);
// ReSharper disable CompareOfFloatsByEqualityOperator Exact equality is fine here
Assert.IsTrue(outData.Any(texel => texel.R != 0f || texel.G != 0f || texel.B != 0f || texel.A != 0f));
// ReSharper restore CompareOfFloatsByEqualityOperator
}
}
sourceTex.Dispose();
copyDestTex.Dispose();
});
}
public void TestCopyTo()
{
LosgapSystem.InvokeOnMaster(() => {
// Define variables and constants
const uint MIP0_WIDTH = 512U;
const uint ARRAY_LENGTH = 10U;
Texture1DArray <TexelFormat.RGBA32UInt> srcArray = TextureFactory.NewTexture1D <TexelFormat.RGBA32UInt>()
.WithDynamicDetail(false)
.WithInitialData(
Enumerable.Repeat(
Enumerable.Range(0, (int)TextureUtils.GetSizeTexels(true, MIP0_WIDTH))
.Select(i => (uint)i)
.Select(i => new TexelFormat.RGBA32UInt {
R = i, G = i * 2, B = i * 3, A = i * 4
}),
(int)ARRAY_LENGTH
)
.Flatten()
.ToArray()
)
.WithMipAllocation(true)
.WithMipGenerationTarget(false)
.WithPermittedBindings(GPUBindings.ReadableShaderResource)
.WithUsage(ResourceUsage.Immutable)
.WithMipAllocation(true)
.WithUsage(ResourceUsage.Write)
.WithWidth(MIP0_WIDTH)
.CreateArray(ARRAY_LENGTH);
// Set up context
Texture1DArray <TexelFormat.RGBA32UInt> dstArray = srcArray.Clone()
.WithUsage(ResourceUsage.StagingRead)
.WithPermittedBindings(GPUBindings.None)
.CreateArray(srcArray.ArrayLength);
srcArray.CopyTo(dstArray);
var data = dstArray[4].ReadAll();
// Execute
for (int i = 0, curMipIndex = 0; i < data.Length; ++curMipIndex)
{
for (int j = 0; j < dstArray.MipWidth((uint)curMipIndex); ++j, ++i)
{
Assert.AreEqual((uint)i, data[i].R);
Assert.AreEqual((uint)i * 2, data[i].G);
Assert.AreEqual((uint)i * 3, data[i].B);
Assert.AreEqual((uint)i * 4, data[i].A);
}
}
// Assert outcome
srcArray.Dispose();
dstArray.Dispose();
});
}
public void TestReadWrite()
{
// Define variables and constants
const uint WIDTH_TX = 512U;
const uint HEIGHT_TX = 512U;
const uint TARGET_MIP_INDEX = 2U;
const uint DATA_WRITE_OFFSET_U = 10U;
const uint DATA_WRITE_OFFSET_V = 10U;
const uint DATA_WRITE_SQUARE_SIZE = 80U;
Texture2D <TexelFormat.RGBA32UInt> srcTex = TextureFactory.NewTexture2D <TexelFormat.RGBA32UInt>()
.WithInitialData(
Enumerable.Range(0, (int)TextureUtils.GetSizeTexels(true, WIDTH_TX, HEIGHT_TX))
.Select(i => (uint)i)
.Select(i => new TexelFormat.RGBA32UInt {
R = i, G = i * 2, B = i * 3, A = i * 4
})
.ToArray()
)
.WithMipAllocation(true)
.WithPermittedBindings(GPUBindings.None)
.WithUsage(ResourceUsage.StagingReadWrite)
.WithWidth(WIDTH_TX)
.WithHeight(HEIGHT_TX);
srcTex.ReadWrite(data => {
for (uint u = DATA_WRITE_OFFSET_U; u < DATA_WRITE_OFFSET_U + DATA_WRITE_SQUARE_SIZE; ++u)
{
for (uint v = DATA_WRITE_OFFSET_V; v < DATA_WRITE_OFFSET_V + DATA_WRITE_SQUARE_SIZE; ++v)
{
data[(int)u, (int)v] = new TexelFormat.RGBA32UInt {
R = u, G = v, B = u + v, A = u - v
};
}
}
},
TARGET_MIP_INDEX);
var readData = srcTex.Read(TARGET_MIP_INDEX);
for (uint u = DATA_WRITE_OFFSET_U; u < DATA_WRITE_OFFSET_U + DATA_WRITE_SQUARE_SIZE; ++u)
{
for (uint v = DATA_WRITE_OFFSET_V; v < DATA_WRITE_OFFSET_V + DATA_WRITE_SQUARE_SIZE; ++v)
{
Assert.AreEqual(u, readData[(int)u, (int)v].R);
Assert.AreEqual(v, readData[(int)u, (int)v].G);
Assert.AreEqual(u + v, readData[(int)u, (int)v].B);
Assert.AreEqual(u - v, readData[(int)u, (int)v].A);
}
}
srcTex.Dispose();
}
public void TestClone()
{
// Define variables and constants
const uint WIDTH_TX = 128U;
const uint HEIGHT_TX = 256U;
const uint DEPTH_TX = 16U;
Texture3D <TexelFormat.Int8> srcTex = TextureFactory.NewTexture3D <TexelFormat.Int8>()
.WithDynamicDetail(false)
.WithInitialData(
Enumerable.Range(0, (int)TextureUtils.GetSizeTexels(true, WIDTH_TX, HEIGHT_TX, DEPTH_TX))
.Select(i => new TexelFormat.Int8 {
Value = (sbyte)i
})
.ToArray()
)
.WithMipAllocation(true)
.WithMipGenerationTarget(false)
.WithPermittedBindings(GPUBindings.None)
.WithUsage(ResourceUsage.StagingRead)
.WithWidth(WIDTH_TX)
.WithHeight(HEIGHT_TX)
.WithDepth(DEPTH_TX);
// Set up context
// Execute
Texture3D <TexelFormat.Int8> destNoCopy = srcTex.Clone(false);
Texture3D <TexelFormat.Int8> destCopy = srcTex.Clone(true);
// Assert outcome
Assert.AreEqual(srcTex.IsGlobalDetailTarget, destNoCopy.IsGlobalDetailTarget);
Assert.AreEqual(srcTex.IsMipGenTarget, destNoCopy.IsMipGenTarget);
Assert.AreEqual(srcTex.IsMipmapped, destNoCopy.IsMipmapped);
Assert.AreEqual(srcTex.NumMips, destNoCopy.NumMips);
Assert.AreEqual(srcTex.PermittedBindings, destNoCopy.PermittedBindings);
Assert.AreEqual(srcTex.Size, destNoCopy.Size);
Assert.AreEqual(srcTex.TexelFormat, destNoCopy.TexelFormat);
Assert.AreEqual(srcTex.TexelSizeBytes, destNoCopy.TexelSizeBytes);
Assert.AreEqual(srcTex.Usage, destNoCopy.Usage);
Assert.AreEqual(srcTex.Width, destNoCopy.Width);
TexelFormat.Int8[] copiedData = destCopy.ReadAll();
for (int i = 0; i < copiedData.Length; ++i)
{
Assert.AreEqual((sbyte)i, copiedData[i].Value);
}
srcTex.Dispose();
destNoCopy.Dispose();
destCopy.Dispose();
}
public void TestClone()
{
// Define variables and constants
const uint WIDTH_TX = 512U;
Texture1D <TexelFormat.RGBA32Int> srcTex = TextureFactory.NewTexture1D <TexelFormat.RGBA32Int>()
.WithDynamicDetail(false)
.WithInitialData(
Enumerable.Range(0, (int)TextureUtils.GetSizeTexels(true, WIDTH_TX))
.Select(i => new TexelFormat.RGBA32Int {
R = i, G = i * 2, B = i * 3, A = i * 4
})
.ToArray()
)
.WithMipAllocation(true)
.WithMipGenerationTarget(false)
.WithPermittedBindings(GPUBindings.None)
.WithUsage(ResourceUsage.StagingRead)
.WithWidth(WIDTH_TX);
// Set up context
// Execute
Texture1D <TexelFormat.RGBA32Int> destNoCopy = srcTex.Clone(false);
Texture1D <TexelFormat.RGBA32Int> destCopy = srcTex.Clone(true);
// Assert outcome
Assert.AreEqual(srcTex.IsGlobalDetailTarget, destNoCopy.IsGlobalDetailTarget);
Assert.AreEqual(srcTex.IsMipGenTarget, destNoCopy.IsMipGenTarget);
Assert.AreEqual(srcTex.IsMipmapped, destNoCopy.IsMipmapped);
Assert.AreEqual(srcTex.NumMips, destNoCopy.NumMips);
Assert.AreEqual(srcTex.PermittedBindings, destNoCopy.PermittedBindings);
Assert.AreEqual(srcTex.Size, destNoCopy.Size);
Assert.AreEqual(srcTex.TexelFormat, destNoCopy.TexelFormat);
Assert.AreEqual(srcTex.TexelSizeBytes, destNoCopy.TexelSizeBytes);
Assert.AreEqual(srcTex.Usage, destNoCopy.Usage);
Assert.AreEqual(srcTex.Width, destNoCopy.Width);
TexelFormat.RGBA32Int[] copiedData = destCopy.ReadAll();
for (int i = 0; i < copiedData.Length; ++i)
{
Assert.AreEqual(i, copiedData[i].R);
Assert.AreEqual(i * 2, copiedData[i].G);
Assert.AreEqual(i * 3, copiedData[i].B);
Assert.AreEqual(i * 4, copiedData[i].A);
}
srcTex.Dispose();
destCopy.Dispose();
destNoCopy.Dispose();
}
public void TestArrayElementsAreIdentical()
{
// Define variables and constants
const uint MIP0_WIDTH = 512U;
const uint ARRAY_LENGTH = 10U;
Texture1DArray <TexelFormat.RGBA32UInt> srcArray = TextureFactory.NewTexture1D <TexelFormat.RGBA32UInt>()
.WithDynamicDetail(true)
.WithInitialData(
Enumerable.Repeat(
Enumerable.Range(0, (int)TextureUtils.GetSizeTexels(true, MIP0_WIDTH))
.Select(i => (uint)i)
.Select(i => new TexelFormat.RGBA32UInt {
R = i, G = i * 2, B = i * 3, A = i * 4
}),
(int)ARRAY_LENGTH
)
.Flatten()
.ToArray()
)
.WithMipAllocation(true)
.WithMipGenerationTarget(false)
.WithPermittedBindings(GPUBindings.ReadableShaderResource)
.WithUsage(ResourceUsage.Immutable)
.WithMipAllocation(true)
.WithUsage(ResourceUsage.Write)
.WithWidth(MIP0_WIDTH)
.CreateArray(ARRAY_LENGTH);
// Set up context
// Execute
// Assert outcome
foreach (Texture1D <TexelFormat.RGBA32UInt> arrayElement in srcArray)
{
Assert.AreEqual(srcArray.IsGlobalDetailTarget, arrayElement.IsGlobalDetailTarget);
Assert.AreEqual(srcArray.IsMipGenTarget, arrayElement.IsMipGenTarget);
Assert.AreEqual(srcArray.IsMipmapped, arrayElement.IsMipmapped);
Assert.AreEqual(srcArray.NumMips, arrayElement.NumMips);
Assert.AreEqual(srcArray.PermittedBindings, arrayElement.PermittedBindings);
Assert.AreEqual(srcArray.Size / srcArray.ArrayLength, arrayElement.Size);
Assert.AreEqual(srcArray.TexelFormat, arrayElement.TexelFormat);
Assert.AreEqual(srcArray.TexelSizeBytes, arrayElement.TexelSizeBytes);
Assert.AreEqual(srcArray.Usage, arrayElement.Usage);
Assert.AreEqual(srcArray.Width, arrayElement.Width);
}
srcArray.Dispose();
}
public Texture2DBuilder <TTexel> WithInitialData(ArraySlice <byte> initialDataRaw)
{
var handle = GCHandle.Alloc(initialDataRaw.ContainingArray, GCHandleType.Pinned);
TTexel[] actualInitData = new TTexel[TextureUtils.GetSizeTexels(mipAllocation, width, height)];
try {
UnsafeUtils.CopyGenericArray <TTexel>(handle.AddrOfPinnedObject() + (int)initialDataRaw.Offset, actualInitData, texelSizeBytes);
}
finally {
handle.Free();
}
return(WithInitialData(actualInitData));
}
public void TestCloneWithInitData()
{
// Define variables and constants
const uint MIP0_WIDTH = 512U;
const uint ARRAY_LENGTH = 10U;
Texture1DArray <TexelFormat.RGBA32UInt> srcArray = TextureFactory.NewTexture1D <TexelFormat.RGBA32UInt>()
.WithDynamicDetail(false)
.WithInitialData(
Enumerable.Range(0, (int)TextureUtils.GetSizeTexels(true, MIP0_WIDTH) * (int)ARRAY_LENGTH)
.Select(i => (uint)i)
.Select(i => new TexelFormat.RGBA32UInt {
R = i, G = i * 2, B = i * 3, A = i * 4
})
.ToArray()
)
.WithMipAllocation(true)
.WithMipGenerationTarget(false)
.WithPermittedBindings(GPUBindings.None)
.WithUsage(ResourceUsage.StagingRead)
.WithWidth(MIP0_WIDTH)
.CreateArray(ARRAY_LENGTH);
// Set up context
// Execute
var cloneArray = srcArray.Clone(true).CreateArray(ARRAY_LENGTH);
// Assert outcome
uint curVal = 0U;
foreach (Texture1D <TexelFormat.RGBA32UInt> texture1D in cloneArray)
{
TexelFormat.RGBA32UInt[] texData = texture1D.ReadAll();
for (int i = 0; i < texData.Length; i++)
{
Assert.AreEqual(curVal, texData[i].R);
Assert.AreEqual(curVal * 2, texData[i].G);
Assert.AreEqual(curVal * 3, texData[i].B);
Assert.AreEqual(curVal * 4, texData[i].A);
++curVal;
}
}
cloneArray.Dispose();
srcArray.Dispose();
}
public void TestGetSizeTexels()
{
// Define variables and constants
// Set up context
// Execute
// Assert outcome
Assert.AreEqual(1000U, TextureUtils.GetSizeTexels(false, 10U, 10U, 10U));
Assert.AreEqual(1000U, TextureUtils.GetSizeTexels(false, 10U, 10U, 10U));
Assert.AreEqual(4096U, TextureUtils.GetSizeTexels(false, 16U, 16U, 16U));
Assert.AreEqual(2341U, TextureUtils.GetSizeTexels(true, 16U, 16U, 8U));
}
public void TestReadWrite()
{
// Define variables and constants
const uint WIDTH_TX = 512U;
const uint TARGET_MIP_INDEX = 4U;
const uint DATA_WRITE_OFFSET = 10U;
const uint DATA_WRITE_COUNT = 10U;
Texture1D <TexelFormat.RGBA32UInt> srcTex = TextureFactory.NewTexture1D <TexelFormat.RGBA32UInt>()
.WithInitialData(
Enumerable.Range(0, (int)TextureUtils.GetSizeTexels(true, WIDTH_TX))
.Select(i => (uint)i)
.Select(i => new TexelFormat.RGBA32UInt {
R = i, G = i * 2, B = i * 3, A = i * 4
})
.ToArray()
)
.WithMipAllocation(true)
.WithPermittedBindings(GPUBindings.None)
.WithUsage(ResourceUsage.StagingReadWrite)
.WithWidth(WIDTH_TX);
srcTex.ReadWrite(data => {
for (uint i = DATA_WRITE_OFFSET; i < DATA_WRITE_OFFSET + DATA_WRITE_COUNT; ++i)
{
data[(int)i] = new TexelFormat.RGBA32UInt {
R = i, G = i * 3, B = i * 6, A = i * 9
};
}
},
TARGET_MIP_INDEX);
var readData = srcTex.Read(TARGET_MIP_INDEX);
for (uint i = DATA_WRITE_OFFSET; i < DATA_WRITE_OFFSET + DATA_WRITE_COUNT; ++i)
{
Assert.AreEqual(i, readData[(int)i].R);
Assert.AreEqual(i * 3, readData[(int)i].G);
Assert.AreEqual(i * 6, readData[(int)i].B);
Assert.AreEqual(i * 9, readData[(int)i].A);
}
srcTex.Dispose();
}
public void TestReadAndReadAll()
{
// Define variables and constants
const uint WIDTH_TX = 32U;
const uint HEIGHT_TX = 16U;
const uint DEPTH_TX = 16U;
Texture3D <TexelFormat.RGBA32Int> srcTex = TextureFactory.NewTexture3D <TexelFormat.RGBA32Int>()
.WithInitialData(
Enumerable.Range(0, (int)TextureUtils.GetSizeTexels(true, WIDTH_TX, HEIGHT_TX, DEPTH_TX))
.Select(i => new TexelFormat.RGBA32Int {
R = i, G = i * 2, B = i * 3, A = i * 4
})
.ToArray()
)
.WithMipAllocation(true)
.WithPermittedBindings(GPUBindings.None)
.WithUsage(ResourceUsage.StagingRead)
.WithWidth(WIDTH_TX)
.WithHeight(HEIGHT_TX)
.WithDepth(DEPTH_TX);
TexelFormat.RGBA32Int[] readAllData = srcTex.ReadAll();
for (int i = 0, curMipIndex = 0; i < readAllData.Length; ++curMipIndex)
{
var readData = srcTex.Read((uint)curMipIndex);
for (int w = 0; w < readData.Depth; ++w)
{
for (int v = 0; v < readData.Height; ++v)
{
for (int u = 0; u < readData.Width; ++u, ++i)
{
Assert.AreEqual(readData[u, v, w].R, readAllData[i].R);
Assert.AreEqual(readData[u, v, w].G, readAllData[i].G);
Assert.AreEqual(readData[u, v, w].B, readAllData[i].B);
Assert.AreEqual(readData[u, v, w].A, readAllData[i].A);
}
}
}
}
srcTex.Dispose();
}
public void TestCopyTo()
{
LosgapSystem.InvokeOnMaster(() => {
// Define variables and constants
const uint WIDTH_TX = 512U;
Texture1D <TexelFormat.RGBA32Int> srcTex = TextureFactory.NewTexture1D <TexelFormat.RGBA32Int>()
.WithDynamicDetail(false)
.WithInitialData(
Enumerable.Range(0, (int)TextureUtils.GetSizeTexels(true, WIDTH_TX))
.Select(i => new TexelFormat.RGBA32Int {
R = i, G = i * 2, B = i * 3, A = i * 4
})
.ToArray()
)
.WithMipAllocation(true)
.WithMipGenerationTarget(false)
.WithPermittedBindings(GPUBindings.ReadableShaderResource)
.WithUsage(ResourceUsage.Immutable)
.WithWidth(WIDTH_TX);
// Set up context
// Execute
Texture1D <TexelFormat.RGBA32Int> dstTex = srcTex.Clone()
.WithUsage(ResourceUsage.StagingRead)
.WithPermittedBindings(GPUBindings.None);
srcTex.CopyTo(dstTex);
// Assert outcome
TexelFormat.RGBA32Int[] copiedData = dstTex.ReadAll();
for (int i = 0; i < copiedData.Length; ++i)
{
Assert.AreEqual(i, copiedData[i].R);
Assert.AreEqual(i * 2, copiedData[i].G);
Assert.AreEqual(i * 3, copiedData[i].B);
Assert.AreEqual(i * 4, copiedData[i].A);
}
srcTex.Dispose();
dstTex.Dispose();
});
}
public void TestCopyTo()
{
LosgapSystem.InvokeOnMaster(() => {
// Define variables and constants
const uint WIDTH_TX = 256U;
const uint HEIGHT_TX = 32U;
const uint DEPTH_TX = 32U;
const uint NUM_TEXELS_TO_COPY_PER_ROW = 25U;
const uint FIRST_TEXEL_TO_COPY_IN_ROW = 25U;
const uint NUM_ROWS_TO_COPY_PER_SLICE = 5U;
const uint FIRST_ROW_TO_COPY_IN_SLICE = 1U;
const uint NUM_SLICES_TO_COPY = 10U;
const uint FIRST_SLICE_TO_COPY = 4U;
const uint SRC_MIP_INDEX = 1U;
const uint DST_MIP_INDEX = 1U;
const uint DST_WRITE_OFFSET_X = 15U;
const uint DST_WRITE_OFFSET_Y = 2U;
const uint DST_WRITE_OFFSET_Z = 0U;
const float DATA_VALUE_ADDITION_W = (float)(HEIGHT_TX >> 1) * (float)(WIDTH_TX >> 1);
const float DATA_VALUE_ADDITION_V = (float)(WIDTH_TX >> 1);
const float DATA_VALUE_START_R =
WIDTH_TX * HEIGHT_TX * DEPTH_TX
+ FIRST_TEXEL_TO_COPY_IN_ROW
+ DATA_VALUE_ADDITION_V * FIRST_ROW_TO_COPY_IN_SLICE
+ DATA_VALUE_ADDITION_W * FIRST_SLICE_TO_COPY;
TexelFormat.RGBA32Float[] initialData = Enumerable.Range(0, (int)TextureUtils.GetSizeTexels(true, WIDTH_TX, HEIGHT_TX, DEPTH_TX))
.Select(i => new TexelFormat.RGBA32Float {
R = (float)i, G = (float)i * 2f, B = (float)i * 4f, A = (float)i * 8f
})
.ToArray();
Texture3D <TexelFormat.RGBA32Float> srcTex = TextureFactory.NewTexture3D <TexelFormat.RGBA32Float>()
.WithDynamicDetail(false)
.WithInitialData(initialData)
.WithMipAllocation(true)
.WithMipGenerationTarget(false)
.WithPermittedBindings(GPUBindings.ReadableShaderResource)
.WithUsage(ResourceUsage.Immutable)
.WithWidth(WIDTH_TX)
.WithHeight(HEIGHT_TX)
.WithDepth(DEPTH_TX);
// Set up context
// Execute
Texture3D <TexelFormat.RGBA32Float> dstTex = srcTex.Clone()
.WithUsage(ResourceUsage.StagingRead)
.WithPermittedBindings(GPUBindings.None);
SubresourceBox targetBox = new SubresourceBox(
FIRST_TEXEL_TO_COPY_IN_ROW, FIRST_TEXEL_TO_COPY_IN_ROW + NUM_TEXELS_TO_COPY_PER_ROW,
FIRST_ROW_TO_COPY_IN_SLICE, FIRST_ROW_TO_COPY_IN_SLICE + NUM_ROWS_TO_COPY_PER_SLICE,
FIRST_SLICE_TO_COPY, FIRST_SLICE_TO_COPY + NUM_SLICES_TO_COPY
);
srcTex.CopyTo(
dstTex,
targetBox,
SRC_MIP_INDEX,
DST_MIP_INDEX,
DST_WRITE_OFFSET_X,
DST_WRITE_OFFSET_Y,
DST_WRITE_OFFSET_Z
);
// Assert outcome
TexelArray3D <TexelFormat.RGBA32Float> copiedData = dstTex.Read(DST_MIP_INDEX);
for (int w = 0; w < NUM_SLICES_TO_COPY; ++w)
{
for (int v = 0; v < NUM_ROWS_TO_COPY_PER_SLICE; ++v)
{
for (int u = 0; u < NUM_TEXELS_TO_COPY_PER_ROW; ++u)
{
var thisTexel = copiedData[u + (int)DST_WRITE_OFFSET_X, v + (int)DST_WRITE_OFFSET_Y, w + (int)DST_WRITE_OFFSET_Z];
Assert.AreEqual((float)(DATA_VALUE_START_R + u + v * DATA_VALUE_ADDITION_V + w * DATA_VALUE_ADDITION_W), thisTexel.R);
Assert.AreEqual((float)(DATA_VALUE_START_R + u + v * DATA_VALUE_ADDITION_V + w * DATA_VALUE_ADDITION_W) * 2f, thisTexel.G);
Assert.AreEqual((float)(DATA_VALUE_START_R + u + v * DATA_VALUE_ADDITION_V + w * DATA_VALUE_ADDITION_W) * 4f, thisTexel.B);
Assert.AreEqual((float)(DATA_VALUE_START_R + u + v * DATA_VALUE_ADDITION_V + w * DATA_VALUE_ADDITION_W) * 8f, thisTexel.A);
}
}
}
srcTex.Dispose();
dstTex.Dispose();
});
}
/// <summary>
/// Creates a new <see cref="Texture3D{TTexel}"/> with the supplied builder parameters.
/// </summary>
/// <remarks>
/// In debug mode, this method will check a large number of <see cref="Assure">assurances</see>
/// on the builder parameters before creating the resource.
/// </remarks>
/// <returns>A new <see cref="Texture3D{TTexel}"/>.</returns>
public unsafe override Texture3D <TTexel> Create()
{
Assure.True(Usage != ResourceUsage.Immutable || InitialData != null, "You must supply initial data to an immutable resource.");
Assure.False(
(Usage == ResourceUsage.Immutable || Usage == ResourceUsage.DiscardWrite) && permittedBindings == GPUBindings.None,
"An immutable or discard-write resource with no permitted bindings is useless."
);
Assure.False(
Usage.GetUsage() == 0x3 && permittedBindings != GPUBindings.None,
"Staging resources can not be bound to the pipeline."
);
Assure.False((Usage == ResourceUsage.DiscardWrite || Usage == ResourceUsage.Immutable) &&
((permittedBindings & GPUBindings.RenderTarget) > 0 ||
(permittedBindings & GPUBindings.DepthStencilTarget) > 0 ||
(permittedBindings & GPUBindings.WritableShaderResource) > 0),
"Can not bind an immutable or discard-write texture as a render target or depth stencil target, or as a GPU-writeable shader resource."
);
Assure.GreaterThan(width, 0U, "Please specify a width for the texture.");
Assure.GreaterThan(height, 0U, "Please specify a height for the texture.");
Assure.GreaterThan(depth, 0U, "Please specify a depth for the texture.");
Assure.False(
mipAllocation && !MathUtils.IsPowerOfTwo(width),
"Can not create mipmapped texture with any non-power-of-two (NPOT) dimension. " +
"Dimensions: " + width + "x" + height + "x" + depth + "."
);
Assure.False(
mipAllocation && !MathUtils.IsPowerOfTwo(height),
"Can not create mipmapped texture with any non-power-of-two (NPOT) dimension. " +
"Dimensions: " + width + "x" + height + "x" + depth + "."
);
Assure.False(
mipAllocation && !MathUtils.IsPowerOfTwo(depth),
"Can not create mipmapped texture with any non-power-of-two (NPOT) dimension. " +
"Dimensions: " + width + "x" + height + "x" + depth + "."
);
Assure.False(
mipAllocation && Usage == ResourceUsage.DiscardWrite,
"Can not allocate mips on a discard-write texture."
);
Assure.False(
mipGenerationTarget && !mipAllocation,
"Can not generate mips without allocating space for them."
);
Assure.False(
mipGenerationTarget &&
((permittedBindings & GPUBindings.RenderTarget) == 0x0 || (permittedBindings & GPUBindings.ReadableShaderResource) == 0x0),
"To make a texture a viable mip generation target, it must be created with the RenderTarget and ReadableShaderResource GPU bindings."
);
Assure.False(
mipGenerationTarget && InitialData != null,
"Can not supply initial data to a mip generation target."
);
Assure.True(
InitialData == null ||
(InitialData.Value.Length == TextureUtils.GetSizeTexels(mipAllocation, width, height, depth)),
"Initial data is of incorrect length (" + (InitialData != null ? InitialData.Value.Length : 0) + ") for this resource. " +
"It should have a length of: " + TextureUtils.GetSizeTexels(mipAllocation, width, height, depth) + "."
);
Assure.False(dynamicDetail && Usage.GetUsage() == 0x3, "Can not create a dynamic-detail staging resource.");
Assure.False(
(permittedBindings & GPUBindings.DepthStencilTarget) == GPUBindings.DepthStencilTarget &&
texelFormat != TexelFormat.DSV_FORMAT_CODE,
"Can not create a depth-stencil target with any texel format other than " + typeof(TexelFormat.DepthStencil).Name + "."
);
Texture3DResourceHandle outResourceHandle;
GCHandle?pinnedInitData = null;
GCHandle?pinnedDataHandle = null;
IntPtr initialDataPtr = IntPtr.Zero;
InitialResourceDataDesc[] dataArr = null;
if (InitialData != null)
{
pinnedInitData = GCHandle.Alloc(InitialData.Value.ContainingArray, GCHandleType.Pinned);
dataArr = InitialResourceDataDesc.CreateDataArr(
pinnedInitData.Value.AddrOfPinnedObject() + (int)(InitialData.Value.Offset * texelSizeBytes),
1U,
numMips,
width,
height,
depth,
texelSizeBytes
);
pinnedDataHandle = GCHandle.Alloc(dataArr, GCHandleType.Pinned);
initialDataPtr = pinnedDataHandle.Value.AddrOfPinnedObject();
}
try {
InteropUtils.CallNative(NativeMethods.ResourceFactory_CreateTexture3D,
RenderingModule.Device,
width,
height,
depth,
(InteropBool)mipAllocation,
texelFormat,
Usage.GetUsage(),
Usage.GetCPUUsage(),
(PipelineBindings)permittedBindings,
(InteropBool)mipGenerationTarget,
(InteropBool)dynamicDetail,
initialDataPtr,
dataArr != null ? (uint)dataArr.Length : 0U,
(IntPtr)(&outResourceHandle)
).ThrowOnFailure();
}
finally {
if (pinnedDataHandle != null)
{
pinnedDataHandle.Value.Free();
}
if (pinnedInitData != null)
{
pinnedInitData.Value.Free();
}
}
return(new Texture3D <TTexel>(
outResourceHandle,
Usage,
TextureUtils.GetSize(texelSizeBytes, mipAllocation, width, height, depth),
permittedBindings,
mipGenerationTarget,
dynamicDetail,
width,
height,
depth,
texelSizeBytes,
mipAllocation,
numMips,
0U
));
}
public void TestCreationWithInitialData()
{
// Define variables and constants
const uint TEXTURE_WIDTH = 1 << 6;
const uint TEXTURE_HEIGHT = 1 << 4;
const uint TEXTURE_DEPTH = 1 << 3;
Texture3DBuilder <TexelFormat.RGBA8UInt> texBuilder = TextureFactory.NewTexture3D <TexelFormat.RGBA8UInt>()
.WithUsage(ResourceUsage.StagingRead)
.WithPermittedBindings(GPUBindings.None)
.WithWidth(TEXTURE_WIDTH)
.WithHeight(TEXTURE_HEIGHT)
.WithDepth(TEXTURE_DEPTH);
TexelFormat.RGBA8UInt[] initialDataA = new TexelFormat.RGBA8UInt[TEXTURE_WIDTH * TEXTURE_HEIGHT * TEXTURE_DEPTH];
TexelFormat.RGBA8UInt[] initialDataB = new TexelFormat.RGBA8UInt[TextureUtils.GetSizeTexels(true, TEXTURE_WIDTH, TEXTURE_HEIGHT, TEXTURE_DEPTH)];
Texture3D <TexelFormat.RGBA8UInt> testTextureA, testTextureB;
TexelArray3D <TexelFormat.RGBA8UInt> texAData;
TexelArray3D <TexelFormat.RGBA8UInt>[] texBData = new TexelArray3D <TexelFormat.RGBA8UInt> [TextureUtils.GetNumMips(TEXTURE_WIDTH, TEXTURE_HEIGHT, TEXTURE_DEPTH)];
// Set up context
for (uint i = 0; i < initialDataA.Length; ++i)
{
initialDataA[i].R = (byte)i;
initialDataA[i].G = (byte)(i * 2);
initialDataA[i].B = (byte)(i * 3);
initialDataA[i].A = (byte)(i * 4);
}
testTextureA = texBuilder.WithInitialData(initialDataA).Create();
uint mipWidth = TEXTURE_WIDTH;
uint mipHeight = TEXTURE_HEIGHT;
uint mipDepth = TEXTURE_DEPTH;
uint texelIndex = 0U;
while (mipWidth > 1U || mipHeight > 1U || mipDepth > 1U)
{
for (uint w = 0; w < mipDepth; ++w)
{
for (uint v = 0; v < mipHeight; ++v)
{
for (uint u = 0; u < mipWidth; ++u, ++texelIndex)
{
initialDataB[texelIndex].R = (byte)(u + mipWidth + v + mipHeight + w + mipDepth);
initialDataB[texelIndex].G = (byte)(u + mipWidth + v + mipHeight + w + mipDepth * 2);
initialDataB[texelIndex].B = (byte)(u + mipWidth + v + mipHeight + w + mipDepth * 3);
initialDataB[texelIndex].A = (byte)(u + mipWidth + v + mipHeight + w + mipDepth * 4);
}
}
}
mipWidth = Math.Max(1U, mipWidth >> 1);
mipHeight = Math.Max(1U, mipHeight >> 1);
mipDepth = Math.Max(1U, mipDepth >> 1);
}
initialDataB[initialDataB.Length - 1] = new TexelFormat.RGBA8UInt {
R = 3, G = 4, B = 5, A = 6
};
testTextureB = texBuilder.WithMipAllocation(true).WithInitialData(initialDataB).Create();
// Execute
texAData = testTextureA.Read(0U);
for (uint i = 0; i < texBData.Length; ++i)
{
texBData[i] = testTextureB.Read(i);
}
// Assert outcome
for (uint i = 0; i < texAData.Width; ++i)
{
Assert.AreEqual((byte)i, initialDataA[i].R);
Assert.AreEqual((byte)(i * 2), initialDataA[i].G);
Assert.AreEqual((byte)(i * 3), initialDataA[i].B);
Assert.AreEqual((byte)(i * 4), initialDataA[i].A);
}
for (uint mipIndex = 0U; mipIndex < testTextureB.NumMips; ++mipIndex)
{
for (uint w = 0; w < testTextureB.MipDepth(mipIndex); ++w)
{
for (uint v = 0; v < testTextureB.MipHeight(mipIndex); ++v)
{
for (uint u = 0; u < testTextureB.MipWidth(mipIndex); ++u)
{
Assert.AreEqual((byte)(u + testTextureB.MipWidth(mipIndex) + v + testTextureB.MipHeight(mipIndex) + w + testTextureB.MipDepth(mipIndex)), texBData[mipIndex][u, v, w].R);
Assert.AreEqual((byte)(u + testTextureB.MipWidth(mipIndex) + v + testTextureB.MipHeight(mipIndex) + w + testTextureB.MipDepth(mipIndex) * 2), texBData[mipIndex][u, v, w].G);
Assert.AreEqual((byte)(u + testTextureB.MipWidth(mipIndex) + v + testTextureB.MipHeight(mipIndex) + w + testTextureB.MipDepth(mipIndex) * 3), texBData[mipIndex][u, v, w].B);
Assert.AreEqual((byte)(u + testTextureB.MipWidth(mipIndex) + v + testTextureB.MipHeight(mipIndex) + w + testTextureB.MipDepth(mipIndex) * 4), texBData[mipIndex][u, v, w].A);
}
}
}
}
testTextureA.Dispose();
testTextureB.Dispose();
}
public override uint GetSizeTexels(uint mipIndex)
{
return(TextureUtils.GetSizeTexels(false, MipWidth(mipIndex)));
}