public void UpdateZoomDescriptors(float normalizedDeZoom)
    {
        if (this.ZoomDescriptors == null || this.ZoomDescriptors.Length == 0)
        {
            return;
        }
        float num = this.ZoomLimitHysteresis;

        if (this.CurrentZoomDescriptorName == StaticString.Empty || normalizedDeZoom == 0f)
        {
            num = 0f;
        }
        for (int i = 0; i < this.NormalizedDeZoomDescriptors.Length; i++)
        {
            NormalizedDeZoomDescriptor normalizedDeZoomDescriptor = this.NormalizedDeZoomDescriptors[i];
            if (normalizedDeZoomDescriptor.MinimumValue + num <= normalizedDeZoom && normalizedDeZoom < normalizedDeZoomDescriptor.MaximumValue - num && this.CurrentZoomDescriptorName != normalizedDeZoomDescriptor.ZoomDescriptor.Name)
            {
                this.ChangeCurrentZoomDescriptor(normalizedDeZoomDescriptor.ZoomDescriptor.Name);
            }
        }
    }
    public void TrimZoomDescriptors(float maximumNormalizedDeZoom)
    {
        if (this.ZoomDescriptors == null || this.ZoomDescriptors.Length == 0)
        {
            return;
        }
        if (base.WorldViewTechnique == null || base.WorldViewTechnique.WorldMovementSettings == null)
        {
            return;
        }
        if (maximumNormalizedDeZoom <= 0f)
        {
            Diagnostics.LogError("Invalid maximum normalized [de]zoom value ({0}), should be > 0.0f.", new object[]
            {
                maximumNormalizedDeZoom
            });
            maximumNormalizedDeZoom = 0f;
        }
        List <NormalizedDeZoomDescriptor> list = new List <NormalizedDeZoomDescriptor>();

        for (int i = 0; i < this.ZoomDescriptors.Length; i++)
        {
            ZoomDescriptor zoomDescriptor = this.ZoomDescriptors[i];
            try
            {
                float minimumNormalizedDeZoom   = this.ConvertToNormalizedDeZoomValue(zoomDescriptor.MinimumValue, maximumNormalizedDeZoom);
                float maximumNormalizedDeZoom2  = this.ConvertToNormalizedDeZoomValue(zoomDescriptor.MaximumValue, maximumNormalizedDeZoom);
                NormalizedDeZoomDescriptor item = new NormalizedDeZoomDescriptor(zoomDescriptor, maximumNormalizedDeZoom2, minimumNormalizedDeZoom);
                list.Add(item);
            }
            catch
            {
            }
        }
        list.Sort(new DefaultLayerController.SortNormalizedDeZoomDescriptorByValue());
        int  num  = 12;
        bool flag = true;

        while (flag)
        {
            flag = false;
            for (int j = 0; j < list.Count; j++)
            {
                if (j == 0)
                {
                    list[j].MinimumValue = 0f;
                }
                else if (list[j].MinimumValue <= 0f)
                {
                    list[j].MinimumValue = list[j - 1].MaximumValue;
                }
                else if (list[j].MinimumValue < list[j - 1].MaximumValue)
                {
                    if (list[j - 1].ZoomDescriptor.IsOptional ^ !list[j].ZoomDescriptor.IsOptional)
                    {
                        float num2 = (list[j - 1].MaximumValue + list[j].MinimumValue) * 0.5f;
                        list[j - 1].MaximumValue = num2;
                        list[j].MinimumValue     = num2;
                    }
                    else if (list[j - 1].ZoomDescriptor.IsOptional)
                    {
                        list[j - 1].MaximumValue = list[j].MinimumValue;
                    }
                    else
                    {
                        list[j].MinimumValue = list[j - 1].MaximumValue;
                    }
                }
                else if (list[j].MinimumValue > list[j - 1].MaximumValue)
                {
                    if (list[j - 1].ZoomDescriptor.IsOptional ^ !list[j].ZoomDescriptor.IsOptional)
                    {
                        float num3 = (list[j - 1].MaximumValue + list[j].MinimumValue) * 0.5f;
                        list[j - 1].MaximumValue = num3;
                        list[j].MinimumValue     = num3;
                    }
                    else if (list[j - 1].ZoomDescriptor.IsOptional)
                    {
                        list[j - 1].MaximumValue = list[j].MinimumValue;
                    }
                    else
                    {
                        list[j].MinimumValue = list[j - 1].MaximumValue;
                    }
                }
                if (list[j].MaximumValue >= maximumNormalizedDeZoom)
                {
                    list[j].MaximumValue = maximumNormalizedDeZoom;
                }
            }
            if (--num < 0)
            {
                Diagnostics.LogWarning("The maximum number of iterations has been reached; the zoom descriptors cannot be trimmed any better...");
                break;
            }
            if (list.Count > 1)
            {
                for (int k = 0; k < list.Count; k++)
                {
                    if (list[k].MaximumValue - list[k].MinimumValue <= this.MinimalRange)
                    {
                        if (list[k].ZoomDescriptor.IsOptional)
                        {
                            if (k == 0)
                            {
                                list[k + 1].MinimumValue = 0f;
                            }
                            else if (k == list.Count - 1)
                            {
                                list[k - 1].MaximumValue = maximumNormalizedDeZoom;
                            }
                            else if (list[k - 1].ZoomDescriptor.IsOptional ^ !list[k + 1].ZoomDescriptor.IsOptional)
                            {
                                float num4 = (list[k - 1].MaximumValue + list[k + 1].MinimumValue) * 0.5f;
                                list[k - 1].MaximumValue = num4;
                                list[k + 1].MinimumValue = num4;
                            }
                            else if (list[k - 1].ZoomDescriptor.IsOptional)
                            {
                                list[k - 1].MaximumValue = list[k + 1].MinimumValue;
                            }
                            else
                            {
                                list[k + 1].MinimumValue = list[k - 1].MaximumValue;
                            }
                        }
                        else
                        {
                            flag = true;
                            if (k == 0)
                            {
                                float num5 = list[k].MinimumValue + this.MinimalRange;
                                list[k].MaximumValue     = num5;
                                list[k + 1].MinimumValue = num5;
                            }
                            else if (k == list.Count - 1)
                            {
                                float num6 = list[k].MaximumValue - this.MinimalRange;
                                list[k - 1].MaximumValue = num6;
                                list[k].MinimumValue     = num6;
                            }
                            else
                            {
                                float num7 = (list[k - 1].MaximumValue + list[k].MinimumValue) * 0.5f;
                                float num8 = (list[k].MaximumValue + list[k + 1].MinimumValue) * 0.5f;
                                list[k - 1].MaximumValue = num7;
                                list[k].MinimumValue     = num7;
                                list[k].MaximumValue     = num8;
                                list[k + 1].MinimumValue = num8;
                            }
                        }
                    }
                }
            }
        }
        this.NormalizedDeZoomDescriptors = list.ToArray();
        this.theMaximumNormalizedDeZoom  = maximumNormalizedDeZoom;
    }