◆ SetRenderTargets() [2/2]

unsafe void Microsoft.Xna.Framework.Graphics.GraphicsDevice.SetRenderTargets	(	RenderTargetBinding *	pBindings,
		int	renderTargetCount )
inlineprivate
Definition at line 1824 of file GraphicsDevice.cs.
    {
        IntPtr intPtr = (IntPtr)pComPtr;
        Helpers.CheckDisposed(this, intPtr);
        if (renderTargetCount == currentRenderTargetCount)
        {
            int num = 0;
            if (0 >= renderTargetCount)
            {
                return;
            }
            RenderTargetBinding[] array = currentRenderTargetBindings;
            int num2 = System.Runtime.CompilerServices.Unsafe.SizeOf<RenderTargetBinding>();
            RenderTargetBinding* ptr = pBindings;
            while (ptr->_renderTarget == array[num]._renderTarget && ptr->_cubeMapFace == array[num]._cubeMapFace)
            {
                num++;
                ptr = (RenderTargetBinding*)(num2 + (byte*)ptr);
                if (num >= renderTargetCount)
                {
                    return;
                }
            }
            if (num >= renderTargetCount)
            {
                return;
            }
        }
        int maxRenderTargets = _profileCapabilities.MaxRenderTargets;
        if (renderTargetCount > maxRenderTargets)
        {
            _profileCapabilities.ThrowNotSupportedException(FrameworkResources.ProfileMaxRenderTargets, maxRenderTargets);
        }
        int num3 = 0;
        if (0 < renderTargetCount)
        {
            do
            {
                Texture renderTarget = ((RenderTargetBinding*)(System.Runtime.CompilerServices.Unsafe.SizeOf<RenderTargetBinding>() * num3 + (byte*)pBindings))->_renderTarget;
                if (renderTarget != null)
                {
                    IntPtr intPtr2 = (IntPtr)renderTarget.GetComPtr();
                    Helpers.CheckDisposed(renderTarget, intPtr2);
                    if (renderTarget.GraphicsDevice == this)
                    {
                        if (num3 > 0)
                        {
                            int num4 = 0;
                            if (0 < num3)
                            {
                                int num5 = System.Runtime.CompilerServices.Unsafe.SizeOf<RenderTargetBinding>();
                                RenderTargetBinding* ptr2 = pBindings;
                                do
                                {
                                    if (renderTarget != ptr2->_renderTarget)
                                    {
                                        num4++;
                                        ptr2 = (RenderTargetBinding*)(num5 + (byte*)ptr2);
                                        continue;
                                    }
                                    throw new ArgumentException(FrameworkResources.CannotSetAlreadyUsedRenderTarget);
                                }
                                while (num4 < num3);
                            }
                            if (!RenderTargetHelper.IsSameSize(renderTarget, pBindings->_renderTarget))
                            {
                                throw new ArgumentException(FrameworkResources.RenderTargetsMustMatch);
                            }
                        }
                        num3++;
                        continue;
                    }
                    throw new InvalidOperationException(FrameworkResources.InvalidDevice);
                }
                throw new ArgumentException(FrameworkResources.NullNotAllowed);
            }
            while (num3 < renderTargetCount);
        }
        if (currentRenderTargetCount <= 0)
        {
            savedBackBufferClearFlags = lazyClearFlags;
        }
        else
        {
            if (lazyClearFlags != 0)
            {
                ClearDirtyBuffers();
            }
            int num6 = 0;
            if (0 < currentRenderTargetCount)
            {
                do
                {
                    ResolveRenderTarget(num6);
                    num6++;
                }
                while (num6 < currentRenderTargetCount);
            }
        }
        int num7 = 0;
        willItBlend = true;
        currentViewport = default(Viewport);
        currentViewport.MaxDepth = 1f;
        if (renderTargetCount <= 0)
        {
            IDirect3DSurface9* ptr3 = null;
            IDirect3DDevice9* ptr4 = pComPtr;
            ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, uint, uint, _D3DBACKBUFFER_TYPE, IDirect3DSurface9**, int>)(int)(*(uint*)(*(int*)ptr4 + 72)))((nint)ptr4, 0u, 0u, (_D3DBACKBUFFER_TYPE)0, &ptr3);
            IDirect3DDevice9* ptr5 = pComPtr;
            num7 = ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, uint, IDirect3DSurface9*, int>)(int)(*(uint*)(*(int*)ptr5 + 148)))((nint)ptr5, 0u, ptr3);
            if (ptr3 != null)
            {
                IDirect3DSurface9* intPtr3 = ptr3;
                ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, uint>)(int)(*(uint*)(*(int*)intPtr3 + 8)))((nint)intPtr3);
                ptr3 = null;
            }
            if (num7 >= 0)
            {
                ptr5 = pComPtr;
                num7 = ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, IDirect3DSurface9*, int>)(int)(*(uint*)(*(int*)ptr5 + 156)))((nint)ptr5, pImplicitDepthSurface);
            }
            if (pInternalCachedParams.RenderTargetUsage == RenderTargetUsage.DiscardContents)
            {
                lazyClearFlags = 7;
            }
            else
            {
                lazyClearFlags = savedBackBufferClearFlags;
            }
            currentViewport.Width = pInternalCachedParams.BackBufferWidth;
            currentViewport.Height = pInternalCachedParams.BackBufferHeight;
        }
        else
        {
            lazyClearFlags = 0;
            int num8 = 0;
            if (0 < renderTargetCount)
            {
                do
                {
                    Texture renderTarget2 = ((RenderTargetBinding*)(System.Runtime.CompilerServices.Unsafe.SizeOf<RenderTargetBinding>() * num8 + (byte*)pBindings))->_renderTarget;
                    RenderTargetHelper renderTargetHelper = RenderTargetHelper.FromRenderTarget(renderTarget2);
                    currentRenderTargets[num8] = renderTargetHelper;
                    ref RenderTargetBinding reference = ref currentRenderTargetBindings[num8];
                    reference = System.Runtime.CompilerServices.Unsafe.Read<RenderTargetBinding>(System.Runtime.CompilerServices.Unsafe.SizeOf<RenderTargetBinding>() * num8 + (byte*)pBindings);
                    renderTarget2.isActiveRenderTarget = true;
                    if (!renderTargetHelper.willItBlend)
                    {
                        willItBlend = false;
                        whyWontItBlend = renderTargetHelper.format;
                    }
                    if (num7 >= 0)
                    {
                        IDirect3DSurface9* renderTargetSurface = renderTargetHelper.GetRenderTargetSurface(((RenderTargetBinding*)(System.Runtime.CompilerServices.Unsafe.SizeOf<RenderTargetBinding>() * num8 + (byte*)pBindings))->_cubeMapFace);
                        IDirect3DDevice9* ptr6 = pComPtr;
                        num7 = ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, uint, IDirect3DSurface9*, int>)(int)(*(uint*)(*(int*)ptr6 + 148)))((nint)ptr6, (uint)num8, renderTargetSurface);
                        if (renderTargetSurface != null)
                        {
                            ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, uint>)(int)(*(uint*)(*(int*)renderTargetSurface + 8)))((nint)renderTargetSurface);
                        }
                        if (num7 >= 0 && num8 == 0)
                        {
                            IDirect3DDevice9* ptr7 = pComPtr;
                            num7 = ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, IDirect3DSurface9*, int>)(int)(*(uint*)(*(int*)ptr7 + 156)))((nint)ptr7, renderTargetHelper.pDepthSurface);
                        }
                    }
                    if (renderTargetHelper.usage == RenderTargetUsage.DiscardContents)
                    {
                        int num9 = (lazyClearFlags |= 1);
                        if (num8 == 0)
                        {
                            lazyClearFlags = num9 | 6;
                        }
                    }
                    else if (renderTargetHelper.pRenderTargetSurface != null && (renderTargetHelper.isCubemap || renderTarget2.renderTargetContentsDirty) && num7 >= 0)
                    {
                        if (_insideScene)
                        {
                            IDirect3DDevice9* intPtr4 = pComPtr;
                            ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, int>)(int)(*(uint*)(*(int*)intPtr4 + 168)))((nint)intPtr4);
                        }
                        IDirect3DSurface9* destinationSurface = renderTargetHelper.GetDestinationSurface(((RenderTargetBinding*)(System.Runtime.CompilerServices.Unsafe.SizeOf<RenderTargetBinding>() * num8 + (byte*)pBindings))->_cubeMapFace, 0);
                        IDirect3DSurface9* pRenderTargetSurface = renderTargetHelper.pRenderTargetSurface;
                        IDirect3DDevice9* ptr8 = pComPtr;
                        int num10 = ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, IDirect3DSurface9*, tagRECT*, IDirect3DSurface9*, tagRECT*, _D3DTEXTUREFILTERTYPE, int>)(int)(*(uint*)(*(int*)ptr8 + 136)))((nint)ptr8, destinationSurface, null, pRenderTargetSurface, null, (_D3DTEXTUREFILTERTYPE)0);
                        num7 = ((num10 < 0) ? _003CModule_003E.D3DXLoadSurfaceFromSurface(pRenderTargetSurface, null, null, destinationSurface, null, null, uint.MaxValue, 0u) : num10);
                        if (destinationSurface != null)
                        {
                            ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, uint>)(int)(*(uint*)(*(int*)destinationSurface + 8)))((nint)destinationSurface);
                        }
                        if (num7 >= 0)
                        {
                            renderTarget2.renderTargetContentsDirty = false;
                        }
                        if (_insideScene)
                        {
                            IDirect3DDevice9* intPtr5 = pComPtr;
                            ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, int>)(int)(*(uint*)(*(int*)intPtr5 + 164)))((nint)intPtr5);
                        }
                    }
                    num8++;
                }
                while (num8 < renderTargetCount);
            }
            currentViewport.Width = currentRenderTargets[0].width;
            currentViewport.Height = currentRenderTargets[0].height;
        }
        int num11 = renderTargetCount;
        if (renderTargetCount < currentRenderTargetCount)
        {
            do
            {
                currentRenderTargets[num11] = null;
                currentRenderTargetBindings[num11] = default(RenderTargetBinding);
                if (num11 > 0)
                {
                    IDirect3DDevice9* ptr9 = pComPtr;
                    ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, uint, IDirect3DSurface9*, int>)(int)(*(uint*)(*(int*)ptr9 + 148)))((nint)ptr9, (uint)num11, null);
                }
                num11++;
            }
            while (num11 < currentRenderTargetCount);
        }
        currentRenderTargetCount = renderTargetCount;
        lazyClearFlags = (int)DefaultClearOptions & lazyClearFlags;
        if (num7 < 0)
        {
            throw GraphicsHelpers.GetExceptionFromResult((uint)num7);
        }
    }