コード例 #1
0
        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();
            });
        }
コード例 #2
0
        public void TestClone()
        {
            // 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
            Texture1DArray <TexelFormat.RGBA32UInt> dstArray = srcArray.Clone().CreateArray(srcArray.ArrayLength);

            // Assert outcome
            Assert.AreEqual(srcArray.IsGlobalDetailTarget, dstArray.IsGlobalDetailTarget);
            Assert.AreEqual(srcArray.IsMipGenTarget, dstArray.IsMipGenTarget);
            Assert.AreEqual(srcArray.IsMipmapped, dstArray.IsMipmapped);
            Assert.AreEqual(srcArray.ArrayLength, dstArray.ArrayLength);
            Assert.AreEqual(srcArray.NumMips, dstArray.NumMips);
            Assert.AreEqual(srcArray.PermittedBindings, dstArray.PermittedBindings);
            Assert.AreEqual(srcArray.Size, dstArray.Size);
            Assert.AreEqual(srcArray.TexelFormat, dstArray.TexelFormat);
            Assert.AreEqual(srcArray.TexelSizeBytes, dstArray.TexelSizeBytes);
            Assert.AreEqual(srcArray.Usage, dstArray.Usage);
            Assert.AreEqual(srcArray.Width, dstArray.Width);

            srcArray.Dispose();
            dstArray.Dispose();
        }
コード例 #3
0
        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();
        }