◆ GetValueBooleanArray()

unsafe bool[] Microsoft.Xna.Framework.Graphics.EffectParameter.GetValueBooleanArray ( int count )
inline
Definition at line 1408 of file EffectParameter.cs.
    {
        //Discarded unreachable code: IL_0277
        if (count <= 0)
        {
            throw new ArgumentOutOfRangeException();
        }
        bool[] array = new bool[count];
        if (_paramClass == EffectParameterClass.Matrix)
        {
            int columns = _columns;
            int val = _rows * columns;
            int count2 = pElementCollection.Count;
            if (count2 == 0)
            {
                Matrix valueMatrix = GetValueMatrix();
                int num = Math.Min(count, val);
                fixed (float* ptr = &System.Runtime.CompilerServices.Unsafe.AsRef<float>(&valueMatrix.M11))
                {
                    try
                    {
                        int num2 = 0;
                        int num3 = 0;
                        int rows = _rows;
                        if (0 < rows)
                        {
                            while (num2 < num)
                            {
                                int num4 = 0;
                                int columns2 = _columns;
                                if (0 < columns2)
                                {
                                    while (num2 < num)
                                    {
                                        int num5 = ((*(float*)((ref *(_003F*)((num3 * 4 + num4) * 4)) + (ref *(_003F*)ptr)) != 0f) ? 1 : 0);
                                        array[num2] = (byte)num5 != 0;
                                        num2++;
                                        num4++;
                                        columns2 = _columns;
                                        if (num4 >= columns2)
                                        {
                                            break;
                                        }
                                    }
                                }
                                num3++;
                                rows = _rows;
                                if (num3 >= rows)
                                {
                                    break;
                                }
                            }
                        }
                    }
                    catch
                    {
                        //try-fault
                        ptr = null;
                        throw;
                    }
                }
            }
            else
            {
                Matrix[] valueMatrixArray = GetValueMatrixArray(count2);
                int num6 = Math.Min(count, count2 * 16);
                fixed (float* ptr2 = &valueMatrixArray[0].M11)
                {
                    try
                    {
                        int num7 = 0;
                        int num8 = 0;
                        if (0 < count2)
                        {
                            while (num7 < num6)
                            {
                                int num9 = 0;
                                int rows2 = _rows;
                                if (0 < rows2)
                                {
                                    while (num7 < num6)
                                    {
                                        int num10 = 0;
                                        int columns3 = _columns;
                                        if (0 < columns3)
                                        {
                                            while (num7 < num6)
                                            {
                                                int num11 = ((*(float*)((ref *(_003F*)(((num8 * 4 + num9) * 4 + num10) * 4)) + (ref *(_003F*)ptr2)) != 0f) ? 1 : 0);
                                                array[num7] = (byte)num11 != 0;
                                                num7++;
                                                num10++;
                                                columns3 = _columns;
                                                if (num10 >= columns3)
                                                {
                                                    break;
                                                }
                                            }
                                        }
                                        num9++;
                                        rows2 = _rows;
                                        if (num9 >= rows2)
                                        {
                                            break;
                                        }
                                    }
                                }
                                num8++;
                                if (num8 >= count2)
                                {
                                    break;
                                }
                            }
                        }
                    }
                    catch
                    {
                        //try-fault
                        ptr2 = null;
                        throw;
                    }
                }
            }
        }
        else
        {
            ID3DXBaseEffect* ptr3 = pEffect;
            System.Runtime.CompilerServices.Unsafe.SkipInit(out _D3DXPARAMETER_DESC d3DXPARAMETER_DESC);
            int num12 = ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, sbyte*, _D3DXPARAMETER_DESC*, int>)(int)(*(uint*)(*(int*)ptr3 + 16)))((nint)ptr3, _handle, &d3DXPARAMETER_DESC);
            if (num12 < 0)
            {
                throw GraphicsHelpers.GetExceptionFromResult((uint)num12);
            }
            int num13 = System.Runtime.CompilerServices.Unsafe.As<_D3DXPARAMETER_DESC, int>(ref System.Runtime.CompilerServices.Unsafe.AddByteOffset(ref d3DXPARAMETER_DESC, 40)) >>> 2;
            int[] array2 = new int[num13];
            fixed (void* ptr4 = &System.Runtime.CompilerServices.Unsafe.As<int, void>(ref array2[0]))
            {
                try
                {
                    int num14 = ((count >= num13) ? num13 : count);
                    int num15 = *(int*)pEffect + 100;
                    int num16 = ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, sbyte*, int*, uint, int>)(int)(*(uint*)num15))((nint)pEffect, _handle, (int*)ptr4, (uint)num14);
                    if (num16 < 0)
                    {
                        throw GraphicsHelpers.GetExceptionFromResult((uint)num16);
                    }
                    int num17 = 0;
                    if (0 < num14)
                    {
                        do
                        {
                            int num18 = ((array2[num17] != 0) ? 1 : 0);
                            array[num17] = (byte)num18 != 0;
                            num17++;
                        }
                        while (num17 < num14);
                    }
                }
                catch
                {
                    //try-fault
                    ptr4 = null;
                    throw;
                }
            }
        }
        return array;
    }