CopyData< T >() [1/2]

unsafe void Microsoft.Xna.Framework.Graphics.TextureCube.CopyData< T > ( CubeMapFace cubeMapFace, int level, Rectangle? rect, T[] data, int startIndex, int elementCount, uint options, [MarshalAs(UnmanagedType.U1)] bool isSetting )

inlineprivate

Type Constraints

T

:

struct

Definition at line 91 of file TextureCube.cs.

                                                                                                                                                                                                         : struct
    {
        IntPtr intPtr = (IntPtr)pComPtr;
        Helpers.CheckDisposed(this, intPtr);
        if (data != null && data.Length != 0)
        {
            if (isActiveRenderTarget)
            {
                throw new InvalidOperationException(FrameworkResources.MustResolveRenderTarget);
            }
            if (isSetting)
            {
                int num = 0;
                GraphicsDevice parent = _parent;
                if (0 < parent.Textures._maxTextures)
                {
                    do
                    {
                        if (parent.Textures[num] != this)
                        {
                            num++;
                            parent = _parent;
                            continue;
                        }
                        throw GraphicsHelpers.GetExceptionFromResult(2147500036u);
                    }
                    while (num < parent.Textures._maxTextures);
                }
                int num2 = 0;
                GraphicsDevice parent2 = _parent;
                if (0 < parent2.VertexTextures._maxTextures)
                {
                    do
                    {
                        if (parent2.VertexTextures[num2] != this)
                        {
                            num2++;
                            parent2 = _parent;
                            continue;
                        }
                        throw GraphicsHelpers.GetExceptionFromResult(2147500036u);
                    }
                    while (num2 < parent2.VertexTextures._maxTextures);
                }
            }
            IDirect3DCubeTexture9* ptr = pComPtr;
            System.Runtime.CompilerServices.Unsafe.SkipInit(out _D3DSURFACE_DESC d3DSURFACE_DESC);
            int num3 = ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, uint, _D3DSURFACE_DESC*, int>)(int)(*(uint*)(*(int*)ptr + 68)))((nint)ptr, (uint)level, &d3DSURFACE_DESC);
            if (num3 < 0)
            {
                throw GraphicsHelpers.GetExceptionFromResult((uint)num3);
            }
            Helpers.ValidateCopyParameters(data.Length, startIndex, elementCount);
            System.Runtime.CompilerServices.Unsafe.SkipInit(out uint dwFormatSize);
            System.Runtime.CompilerServices.Unsafe.SkipInit(out uint dwElementSize);
            Texture.GetAndValidateSizes<T>(&d3DSURFACE_DESC, &dwFormatSize, &dwElementSize);
            System.Runtime.CompilerServices.Unsafe.SkipInit(out uint dwLockWidth);
            System.Runtime.CompilerServices.Unsafe.SkipInit(out uint dwLockHeight);
            Texture.GetAndValidateRect(&d3DSURFACE_DESC, &dwLockWidth, &dwLockHeight, rect);
            Texture.ValidateTotalSize(&d3DSURFACE_DESC, dwLockWidth, dwLockHeight, dwFormatSize, dwElementSize, (uint)elementCount);
            tagRECT* ptr2 = null;
            Rectangle rectangle = default(Rectangle);
            if (rect.HasValue)
            {
                rectangle = rect.Value;
                ptr2 = (tagRECT*)(int)(ref rectangle);
                if (ptr2 != null)
                {
                    *(int*)((byte*)ptr2 + 8) += *(int*)ptr2;
                    *(int*)((byte*)ptr2 + 12) += *(int*)((byte*)ptr2 + 4);
                }
            }
            int num5;
            System.Runtime.CompilerServices.Unsafe.SkipInit(out _D3DLOCKED_RECT d3DLOCKED_RECT);
            if (System.Runtime.CompilerServices.Unsafe.As<_D3DSURFACE_DESC, int>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset(ref d3DSURFACE_DESC, 12)) == 0)
            {
                if (!isSetting)
                {
                    GraphicsDevice parent3 = _parent;
                    GraphicsDevice graphicsDevice = parent3;
                    GraphicsDevice graphicsDevice2 = parent3;
                    GraphicsDevice graphicsDevice3 = parent3;
                    int num4 = *(int*)GraphicsAdapter.pComPtr + 40;
                    if (((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, uint, _D3DDEVTYPE, _D3DFORMAT, uint, _D3DRESOURCETYPE, _D3DFORMAT, int>)(int)(*(uint*)num4))((nint)GraphicsAdapter.pComPtr, graphicsDevice3.Adapter.adapter, graphicsDevice2._deviceType, _003CModule_003E.ConvertXnaFormatToWindowsAdapterFormat(graphicsDevice.Adapter.CurrentDisplayMode.Format), 1u, (_D3DRESOURCETYPE)3, *(_D3DFORMAT*)(&d3DSURFACE_DESC)) < 0)
                    {
                        throw new InvalidOperationException(FrameworkResources.CannotUseFormatTypeAsManualWhenLocking);
                    }
                }
                IDirect3DSurface9* ptr3 = null;
                IDirect3DTexture9* ptr4 = null;
                IDirect3DSurface9* ptr5 = null;
                IDirect3DDevice9* ptr6 = _parent.pComPtr;
                num5 = ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, uint, uint, uint, uint, _D3DFORMAT, _D3DPOOL, IDirect3DTexture9**, void**, int>)(int)(*(uint*)(*(int*)ptr6 + 92)))((nint)ptr6, System.Runtime.CompilerServices.Unsafe.As<_D3DSURFACE_DESC, uint>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset(ref d3DSURFACE_DESC, 24)), System.Runtime.CompilerServices.Unsafe.As<_D3DSURFACE_DESC, uint>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset(ref d3DSURFACE_DESC, 28)), 1u, 0u, *(_D3DFORMAT*)(&d3DSURFACE_DESC), (_D3DPOOL)2, &ptr4, null);
                if (num5 >= 0)
                {
                    num5 = ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, uint, IDirect3DSurface9**, int>)(int)(*(uint*)(*(int*)ptr4 + 72)))((nint)ptr4, 0u, &ptr3);
                    if (num5 >= 0)
                    {
                        ptr = pComPtr;
                        num5 = ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, _D3DCUBEMAP_FACES, uint, IDirect3DSurface9**, int>)(int)(*(uint*)(*(int*)ptr + 72)))((nint)ptr, (_D3DCUBEMAP_FACES)cubeMapFace, (uint)level, &ptr5);
                        if (num5 >= 0)
                        {
                            if (isSetting)
                            {
                                if (ptr2 != null && (*(int*)ptr2 != 0 || *(int*)((byte*)ptr2 + 4) != 0 || *(int*)((byte*)ptr2 + 8) != System.Runtime.CompilerServices.Unsafe.As<_D3DSURFACE_DESC, int>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset(ref d3DSURFACE_DESC, 24)) || *(int*)((byte*)ptr2 + 12) != System.Runtime.CompilerServices.Unsafe.As<_D3DSURFACE_DESC, int>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset(ref d3DSURFACE_DESC, 28))))
                                {
                                    num5 = _003CModule_003E.D3DXLoadSurfaceFromSurface(ptr3, null, null, ptr5, null, null, 1u, 0u);
                                }
                                if (num5 >= 0)
                                {
                                    num5 = ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, _D3DLOCKED_RECT*, tagRECT*, uint, int>)(int)(*(uint*)(*(int*)ptr3 + 52)))((nint)ptr3, &d3DLOCKED_RECT, ptr2, 0u);
                                    if (num5 >= 0)
                                    {
                                        try
                                        {
                                            Texture.CopyData((void*)(int)System.Runtime.CompilerServices.Unsafe.As<_D3DLOCKED_RECT, uint>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset(ref d3DLOCKED_RECT, 4)), *(int*)(&d3DLOCKED_RECT), data, startIndex, elementCount, &d3DSURFACE_DESC, dwLockWidth, dwLockHeight, isSetting);
                                        }
                                        finally
                                        {
                                            IDirect3DSurface9* intPtr2 = ptr3;
                                            num5 = ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, int>)(int)(*(uint*)(*(int*)intPtr2 + 56)))((nint)intPtr2);
                                        }
                                        if (num5 >= 0)
                                        {
                                            num5 = _003CModule_003E.D3DXLoadSurfaceFromSurface(ptr5, null, ptr2, ptr3, null, ptr2, 1u, 0u);
                                        }
                                    }
                                }
                            }
                            else
                            {
                                num5 = _003CModule_003E.D3DXLoadSurfaceFromSurface(ptr3, null, ptr2, ptr5, null, ptr2, 1u, 0u);
                                if (num5 >= 0)
                                {
                                    num5 = ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, _D3DLOCKED_RECT*, tagRECT*, uint, int>)(int)(*(uint*)(*(int*)ptr3 + 52)))((nint)ptr3, &d3DLOCKED_RECT, ptr2, 0u);
                                    if (num5 >= 0)
                                    {
                                        try
                                        {
                                            Texture.CopyData((void*)(int)System.Runtime.CompilerServices.Unsafe.As<_D3DLOCKED_RECT, uint>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset(ref d3DLOCKED_RECT, 4)), *(int*)(&d3DLOCKED_RECT), data, startIndex, elementCount, &d3DSURFACE_DESC, dwLockWidth, dwLockHeight, isSetting: false);
                                        }
                                        finally
                                        {
                                            IDirect3DSurface9* intPtr3 = ptr3;
                                            num5 = ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, int>)(int)(*(uint*)(*(int*)intPtr3 + 56)))((nint)intPtr3);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                if (ptr5 != null)
                {
                    IDirect3DSurface9* intPtr4 = ptr5;
                    ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, uint>)(int)(*(uint*)(*(int*)intPtr4 + 8)))((nint)intPtr4);
                    ptr5 = null;
                }
                if (ptr3 != null)
                {
                    IDirect3DSurface9* intPtr5 = ptr3;
                    ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, uint>)(int)(*(uint*)(*(int*)intPtr5 + 8)))((nint)intPtr5);
                    ptr3 = null;
                }
                if (ptr4 != null)
                {
                    IDirect3DTexture9* intPtr6 = ptr4;
                    ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, uint>)(int)(*(uint*)(*(int*)intPtr6 + 8)))((nint)intPtr6);
                    ptr4 = null;
                }
            }
            else
            {
                ptr = pComPtr;
                num5 = ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, _D3DCUBEMAP_FACES, uint, _D3DLOCKED_RECT*, tagRECT*, uint, int>)(int)(*(uint*)(*(int*)ptr + 76)))((nint)ptr, (_D3DCUBEMAP_FACES)cubeMapFace, (uint)level, &d3DLOCKED_RECT, ptr2, options);
                if (num5 >= 0)
                {
                    try
                    {
                        Texture.CopyData((void*)(int)System.Runtime.CompilerServices.Unsafe.As<_D3DLOCKED_RECT, uint>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset(ref d3DLOCKED_RECT, 4)), *(int*)(&d3DLOCKED_RECT), data, startIndex, elementCount, &d3DSURFACE_DESC, dwLockWidth, dwLockHeight, isSetting);
                    }
                    finally
                    {
                        ptr = pComPtr;
                        num5 = ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, _D3DCUBEMAP_FACES, uint, int>)(int)(*(uint*)(*(int*)ptr + 80)))((nint)ptr, (_D3DCUBEMAP_FACES)cubeMapFace, (uint)level);
                    }
                }
            }
            if (_parent.IsDeviceLost)
            {
                if (isSetting)
                {
                    return;
                }
                fixed (T* ptr7 = &data[startIndex])
                {
                    try
                    {
                        uint num6 = (uint)(System.Runtime.CompilerServices.Unsafe.SizeOf<T>() * elementCount);
                        // IL initblk instruction
                        System.Runtime.CompilerServices.Unsafe.InitBlock(ptr7, 0, num6);
                    }
                    catch
                    {
                        //try-fault
                        ptr7 = null;
                        throw;
                    }
                }
            }
            else
            {
                if (num5 < 0)
                {
                    throw GraphicsHelpers.GetExceptionFromResult((uint)num5);
                }
                if (isSetting && this is IDynamicGraphicsResource dynamicGraphicsResource)
                {
                    dynamicGraphicsResource.SetContentLost(isContentLost: false);
                }
            }
            return;
        }
        throw new ArgumentNullException("data", FrameworkResources.NullNotAllowed);
    }

References Microsoft.Xna.Framework.Graphics.GraphicsDevice._deviceType, Microsoft.Xna.Framework.Graphics.TextureCollection._maxTextures, Microsoft.Xna.Framework.Graphics.GraphicsResource._parent, Microsoft.Xna.Framework.Graphics.GraphicsAdapter.adapter, Microsoft.Xna.Framework.Graphics.GraphicsDevice.Adapter, Microsoft.Xna.Framework.FrameworkResources.CannotUseFormatTypeAsManualWhenLocking, Microsoft.Xna.Framework.Helpers.CheckDisposed(), Microsoft.Xna.Framework.Graphics.GraphicsAdapter.CurrentDisplayMode, Microsoft.Xna.Framework.Graphics.DisplayMode.Format, Microsoft.Xna.Framework.Graphics.Texture.GetAndValidateRect(), Microsoft.Xna.Framework.Graphics.GraphicsHelpers.GetExceptionFromResult(), System.Runtime.CompilerServices.Unsafe.InitBlock(), Microsoft.Xna.Framework.Graphics.Texture.isActiveRenderTarget, Microsoft.Xna.Framework.Graphics.GraphicsDevice.IsDeviceLost, Microsoft.Xna.Framework.FrameworkResources.MustResolveRenderTarget, Microsoft.Xna.Framework.FrameworkResources.NullNotAllowed, System.options, Microsoft.Xna.Framework.Graphics.GraphicsAdapter.pComPtr, Microsoft.Xna.Framework.Graphics.GraphicsDevice.pComPtr, Microsoft.Xna.Framework.Graphics.TextureCube.pComPtr, System.startIndex, Microsoft.Xna.Framework.Graphics.GraphicsDevice.Textures, Microsoft.Xna.Framework.Helpers.ValidateCopyParameters(), Microsoft.Xna.Framework.Graphics.Texture.ValidateTotalSize(), and Microsoft.Xna.Framework.Graphics.GraphicsDevice.VertexTextures.