public static unsafe RenderCommand SetRenderTargets(DepthStencilView dsv, params RenderTargetView[] rtvArr)
        {
            Assure.NotNull(dsv);
            Assure.False(dsv.ResourceOrViewDisposed, "Depth Stencil View or its resource was disposed.");
            Assure.NotNull(rtvArr);
            Assure.None(rtvArr, rtv => rtv == null, "One or more elements in the render target view array were null.");
            Assure.None(
                rtvArr,
                rtv => rtv.ResourceOrViewDisposed,
                "One or more elements in the render target view array (or their resources) were disposed."
                );
            Assure.LessThanOrEqualTo(rtvArr.Length, MAX_RENDER_TARGETS, "Maximum of " + MAX_RENDER_TARGETS + " render targets permitted.");
            RenderTargetViewHandle *rtvArrPtr = (RenderTargetViewHandle *)AllocAndZeroTemp((uint)(rtvArr.Length * sizeof(RenderTargetViewHandle)));

            for (int i = 0; i < rtvArr.Length; i++)
            {
                rtvArrPtr[i] = rtvArr[i].ResourceViewHandle;
            }

            return(new RenderCommand(
                       RenderCommandInstruction.SetRenderTargets,
                       (IntPtr)rtvArrPtr,
                       (IntPtr)(ResourceViewHandle)dsv.ResourceViewHandle,
                       (uint)rtvArr.Length
                       ));
        }
        internal static unsafe RenderCommand SetRenderTargets(DepthStencilViewHandle dsv, RenderTargetViewHandle rtv)
        {
            RenderTargetViewHandle *rtvPtr = (RenderTargetViewHandle *)AllocAndZeroTemp((uint)sizeof(RenderTargetViewHandle));

            *rtvPtr = rtv;

            return(new RenderCommand(
                       RenderCommandInstruction.SetRenderTargets,
                       (IntPtr)rtvPtr,
                       (IntPtr)(ResourceViewHandle)dsv,
                       1U
                       ));
        }
        internal static unsafe RenderCommand SetRenderTargets(DepthStencilViewHandle dsv, RenderTargetViewHandle rtv1, RenderTargetViewHandle rtv2)
        {
            RenderTargetViewHandle *rtvArrPtr = (RenderTargetViewHandle *)AllocAndZeroTemp(2U * (uint)sizeof(RenderTargetViewHandle));

            rtvArrPtr[0] = rtv1;
            rtvArrPtr[1] = rtv2;

            return(new RenderCommand(
                       RenderCommandInstruction.SetRenderTargets,
                       (IntPtr)rtvArrPtr,
                       (IntPtr)(ResourceViewHandle)dsv,
                       2U
                       ));
        }
        internal static unsafe RenderCommand SetRenderTargets(DepthStencilViewHandle dsv, RenderTargetView rtv)
        {
            Assure.NotNull(rtv);
            Assure.False(
                rtv.ResourceOrViewDisposed,
                "One or more elements in the render target view array (or their resources) were disposed."
                );
            RenderTargetViewHandle *rtvArrPtr = (RenderTargetViewHandle *)AllocAndZeroTemp((uint)(sizeof(RenderTargetViewHandle)));

            *rtvArrPtr = rtv.ResourceViewHandle;


            return(new RenderCommand(
                       RenderCommandInstruction.SetRenderTargets,
                       (IntPtr)rtvArrPtr,
                       (IntPtr)(ResourceViewHandle)dsv,
                       1U
                       ));
        }
        public static unsafe RenderCommand SetRenderTargets(Window renderTarget)
        {
            Assure.NotNull(renderTarget);
            RenderTargetViewHandle *rtvHandlePtr = (RenderTargetViewHandle *)AllocAndZeroTemp((uint)sizeof(RenderTargetViewHandle));

            RenderTargetViewHandle outRTV;
            DepthStencilViewHandle outDSV;

            bool windowStillOpen = renderTarget.GetWindowRTVAndDSV(out outRTV, out outDSV);

            if (!windowStillOpen)
            {
                return(new RenderCommand(RenderCommandInstruction.NoOperation));
            }

            *rtvHandlePtr = outRTV;
            return(new RenderCommand(
                       RenderCommandInstruction.SetRenderTargets,
                       (IntPtr)rtvHandlePtr,
                       (IntPtr)(ResourceViewHandle)outDSV,
                       1U
                       ));
        }
        internal static unsafe RenderCommand SetRenderTargets(Window blackOut, DepthStencilView dsv, params RenderTargetView[] rtvArr)
        {
            Assure.NotNull(rtvArr);
            Assure.None(rtvArr, rtv => rtv == null, "One or more elements in the render target view array were null.");
            Assure.None(
                rtvArr,
                rtv => rtv.ResourceOrViewDisposed,
                "One or more elements in the render target view array (or their resources) were disposed."
                );
            Assure.LessThanOrEqualTo(rtvArr.Length, MAX_RENDER_TARGETS, "Maximum of " + MAX_RENDER_TARGETS + " render targets permitted.");
            Assure.NotNull(dsv);
            Assure.False(dsv.IsDisposed);
            RenderTargetViewHandle *rtvArrPtr = (RenderTargetViewHandle *)AllocAndZeroTemp((uint)((rtvArr.Length + 1) * sizeof(RenderTargetViewHandle)));

            RenderTargetViewHandle outRTV;
            DepthStencilViewHandle outDSV;

            bool windowStillOpen = blackOut.GetWindowRTVAndDSV(out outRTV, out outDSV);

            if (!windowStillOpen)
            {
                return(new RenderCommand(RenderCommandInstruction.NoOperation));
            }

            rtvArrPtr[0] = outRTV;
            for (int i = 1; i < rtvArr.Length + 1; i++)
            {
                rtvArrPtr[i] = rtvArr[i - 1].ResourceViewHandle;
            }

            return(new RenderCommand(
                       RenderCommandInstruction.SetRenderTargets,
                       (IntPtr)rtvArrPtr,
                       (IntPtr)(ResourceViewHandle)dsv.ResourceViewHandle,
                       (uint)rtvArr.Length + 1U
                       ));
        }
Пример #7
0
        public unsafe void TestSetRenderTargets()
        {
            Texture2DArray <TexelFormat.RenderTarget> backBufferArray = TextureFactory.NewTexture2D <TexelFormat.RenderTarget>()
                                                                        .WithWidth(800U)
                                                                        .WithHeight(600U)
                                                                        .WithDynamicDetail(false)
                                                                        .WithMipAllocation(false)
                                                                        .WithMipGenerationTarget(false)
                                                                        .WithMultisampling(false)
                                                                        .WithPermittedBindings(GPUBindings.RenderTarget)
                                                                        .WithUsage(ResourceUsage.Write)
                                                                        .CreateArray(RenderCommand.MAX_RENDER_TARGETS + 1U);

            Texture2D <TexelFormat.DepthStencil> depthStencil = backBufferArray.Clone()
                                                                .WithTexelFormat <TexelFormat.DepthStencil>()
                                                                .WithPermittedBindings(GPUBindings.DepthStencilTarget);

            RenderTargetView[] rtvArr = backBufferArray.Select(tex => tex.CreateRenderTargetView(0U)).ToArray();
            DepthStencilView   dsv    = depthStencil.CreateDepthStencilView(0U);

            RenderCommand testCommand = RenderCommand.SetRenderTargets(dsv, rtvArr.Take((int)RenderCommand.MAX_RENDER_TARGETS).ToArray());

            Assert.AreEqual(RenderCommandInstruction.SetRenderTargets, testCommand.Instruction);
            RenderTargetViewHandle *rtvArrPtr
                = (RenderTargetViewHandle *)new IntPtr(UnsafeUtils.Reinterpret <RenderCommandArgument, long>(testCommand.Arg1, sizeof(long)));

            for (int i = 0; i < RenderCommand.MAX_RENDER_TARGETS; ++i)
            {
                Assert.AreEqual(rtvArr[i].ResourceViewHandle, rtvArrPtr[i]);
            }
            Assert.AreEqual(
                dsv.ResourceViewHandle,
                UnsafeUtils.Reinterpret <IntPtr, DepthStencilViewHandle>(new IntPtr(UnsafeUtils.Reinterpret <RenderCommandArgument, long>(testCommand.Arg2, sizeof(long))), sizeof(DepthStencilViewHandle))
                );
            Assert.AreEqual((RenderCommandArgument)RenderCommand.MAX_RENDER_TARGETS, testCommand.Arg3);

#if !DEVELOPMENT && !RELEASE
            try {
                RenderCommand.SetRenderTargets(null as DepthStencilView, rtvArr.Take((int)RenderCommand.MAX_RENDER_TARGETS).ToArray());
                Assert.Fail();
            }
            catch (AssuranceFailedException) { }

            try {
                RenderCommand.SetRenderTargets(dsv, null);
                Assert.Fail();
            }
            catch (AssuranceFailedException) { }

            try {
                RenderCommand.SetRenderTargets(dsv, rtvArr[0], rtvArr[1], null, rtvArr[2]);
                Assert.Fail();
            }
            catch (AssuranceFailedException) { }

            try {
                RenderCommand.SetRenderTargets(dsv, rtvArr);
                Assert.Fail();
            }
            catch (AssuranceFailedException) { }
#endif

            rtvArr.ForEach(rtv => rtv.Dispose());
            dsv.Dispose();
            backBufferArray.Dispose();
            depthStencil.Dispose();

#if !DEVELOPMENT && !RELEASE
            try {
                RenderCommand.SetRenderTargets(dsv, rtvArr.Take((int)RenderCommand.MAX_RENDER_TARGETS).ToArray());
                Assert.Fail();
            }
            catch (AssuranceFailedException) { }
#endif
        }