◆ SetValue() [2/18]

unsafe void Microsoft.Xna.Framework.Graphics.EffectParameter.SetValue ( bool[] value )
inline
Definition at line 1055 of file EffectParameter.cs.
    {
        EffectParameterClass paramClass = _paramClass;
        if (paramClass != 0 && paramClass != EffectParameterClass.Vector && paramClass != EffectParameterClass.Matrix)
        {
            throw new InvalidCastException();
        }
        if (value != null)
        {
            int num = value.Length;
            if (num > 0)
            {
                if (paramClass == EffectParameterClass.Matrix)
                {
                    int columns = _columns;
                    int val = _rows * columns;
                    int count = pElementCollection.Count;
                    if (count == 0)
                    {
                        Matrix valueMatrix = GetValueMatrix();
                        int num2 = Math.Min(value.Length, val);
                        fixed (float* ptr = &System.Runtime.CompilerServices.Unsafe.AsRef<float>(&valueMatrix.M11))
                        {
                            try
                            {
                                int num3 = 0;
                                int num4 = 0;
                                int rows = _rows;
                                if (0 < rows)
                                {
                                    while (num3 < num2)
                                    {
                                        int num5 = 0;
                                        int columns2 = _columns;
                                        if (0 < columns2)
                                        {
                                            while (num3 < num2)
                                            {
                                                bool flag = value[num3];
                                                num3++;
                                                float num6 = ((!flag) ? 0f : 1f);
                                                *(float*)((ref *(_003F*)((num4 * 4 + num5) * 4)) + (ref *(_003F*)ptr)) = num6;
                                                num5++;
                                                columns2 = _columns;
                                                if (num5 >= columns2)
                                                {
                                                    break;
                                                }
                                            }
                                        }
                                        num4++;
                                        rows = _rows;
                                        if (num4 >= rows)
                                        {
                                            break;
                                        }
                                    }
                                }
                                SetValue(valueMatrix);
                            }
                            catch
                            {
                                //try-fault
                                ptr = null;
                                throw;
                            }
                        }
                    }
                    else
                    {
                        Matrix[] valueMatrixArray = GetValueMatrixArray(count);
                        int num7 = Math.Min(value.Length, count * 16);
                        fixed (float* ptr2 = &valueMatrixArray[0].M11)
                        {
                            try
                            {
                                int num8 = 0;
                                int num9 = 0;
                                if (0 < count)
                                {
                                    while (num8 < num7)
                                    {
                                        int num10 = 0;
                                        int rows2 = _rows;
                                        if (0 < rows2)
                                        {
                                            while (num8 < num7)
                                            {
                                                int num11 = 0;
                                                int columns3 = _columns;
                                                if (0 < columns3)
                                                {
                                                    while (num8 < num7)
                                                    {
                                                        bool flag2 = value[num8];
                                                        num8++;
                                                        float num12 = ((!flag2) ? 0f : 1f);
                                                        *(float*)((ref *(_003F*)(((num9 * 4 + num10) * 4 + num11) * 4)) + (ref *(_003F*)ptr2)) = num12;
                                                        num11++;
                                                        columns3 = _columns;
                                                        if (num11 >= columns3)
                                                        {
                                                            break;
                                                        }
                                                    }
                                                }
                                                num10++;
                                                rows2 = _rows;
                                                if (num10 >= rows2)
                                                {
                                                    break;
                                                }
                                            }
                                        }
                                        num9++;
                                        if (num9 >= count)
                                        {
                                            break;
                                        }
                                    }
                                }
                                SetValue(valueMatrixArray);
                            }
                            catch
                            {
                                //try-fault
                                ptr2 = null;
                                throw;
                            }
                        }
                    }
                }
                else
                {
                    int[] array = new int[num];
                    int num13 = 0;
                    if (0 < (nint)array.LongLength)
                    {
                        do
                        {
                            int num14 = (value[num13] ? 1 : 0);
                            array[num13] = num14;
                            num13++;
                        }
                        while (num13 < (nint)array.LongLength);
                    }
                    fixed (void* ptr3 = &System.Runtime.CompilerServices.Unsafe.As<int, void>(ref array[0]))
                    {
                        try
                        {
                            int num15 = *(int*)pEffect + 96;
                            int num16 = ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, sbyte*, int*, uint, int>)(int)(*(uint*)num15))((nint)pEffect, _handle, (int*)ptr3, (uint)value.Length);
                            if (num16 < 0)
                            {
                                throw GraphicsHelpers.GetExceptionFromResult((uint)num16);
                            }
                        }
                        catch
                        {
                            //try-fault
                            ptr3 = null;
                            throw;
                        }
                    }
                }
                goto IL_0296;
            }
        }
        ID3DXBaseEffect* ptr4 = pEffect;
        int num17 = ((delegate* unmanaged[Stdcall, Stdcall]<IntPtr, sbyte*, int*, uint, int>)(int)(*(uint*)(*(int*)ptr4 + 96)))((nint)ptr4, _handle, null, 0u);
        if (num17 < 0)
        {
            throw GraphicsHelpers.GetExceptionFromResult((uint)num17);
        }
        goto IL_0296;
        IL_0296:
        try
        {
            return;
        }
        catch
        {
            //try-fault
            throw;
        }
    }