private void RefreshSettings()
    {
        CameraLayerDepths component = base.GetComponent <CameraLayerDepths>();

        if (component != null)
        {
            foreach (ViewDistanceLayer layer in this.ViewDistanceLayers)
            {
                component[layer.Index] = layer.MinimumValue + (render.distance * layer.Range);
            }
        }
    }
Exemple #2
0
    private void RefreshSettings()
    {
        CameraLayerDepths component = base.GetComponent <CameraLayerDepths>();

        if (component)
        {
            CameraSettings.ViewDistanceLayer[] viewDistanceLayers = this.ViewDistanceLayers;
            for (int i = 0; i < (int)viewDistanceLayers.Length; i++)
            {
                CameraSettings.ViewDistanceLayer viewDistanceLayer = viewDistanceLayers[i];
                component[viewDistanceLayer.Index] = viewDistanceLayer.MinimumValue + render.distance * viewDistanceLayer.Range;
            }
        }
    }
    public float this[int layer]
    {
        get
        {
            switch (layer)
            {
            case 0:
            {
                return(this.layer00);
            }

            case 1:
            {
                return(this.layer01);
            }

            case 2:
            {
                return(this.layer02);
            }

            case 3:
            {
                return(this.layer03);
            }

            case 4:
            {
                return(this.layer04);
            }

            case 5:
            {
                return(this.layer05);
            }

            case 6:
            {
                return(this.layer06);
            }

            case 7:
            {
                return(this.layer07);
            }

            case 8:
            {
                return(this.layer08);
            }

            case 9:
            {
                return(this.layer09);
            }

            case 10:
            {
                return(this.layer10);
            }

            case 11:
            {
                return(this.layer11);
            }

            case 12:
            {
                return(this.layer12);
            }

            case 13:
            {
                return(this.layer13);
            }

            case 14:
            {
                return(this.layer14);
            }

            case 15:
            {
                return(this.layer15);
            }

            case 16:
            {
                return(this.layer16);
            }

            case 17:
            {
                return(this.layer17);
            }

            case 18:
            {
                return(this.layer18);
            }

            case 19:
            {
                return(this.layer19);
            }

            case 20:
            {
                return(this.layer20);
            }

            case 21:
            {
                return(this.layer21);
            }

            case 22:
            {
                return(this.layer22);
            }

            case 23:
            {
                return(this.layer23);
            }

            case 24:
            {
                return(this.layer24);
            }

            case 25:
            {
                return(this.layer25);
            }

            case 26:
            {
                return(this.layer26);
            }

            case 27:
            {
                return(this.layer27);
            }

            case 28:
            {
                return(this.layer28);
            }

            case 29:
            {
                return(this.layer29);
            }

            case 30:
            {
                return(this.layer30);
            }

            case 31:
            {
                return(this.layer31);
            }
            }
            throw new ArgumentOutOfRangeException();
        }
        set
        {
            bool flag;
            switch (layer)
            {
            case 0:
            {
                flag = CameraLayerDepths.Set(ref this.layer00, value);
                break;
            }

            case 1:
            {
                flag = CameraLayerDepths.Set(ref this.layer01, value);
                break;
            }

            case 2:
            {
                flag = CameraLayerDepths.Set(ref this.layer02, value);
                break;
            }

            case 3:
            {
                flag = CameraLayerDepths.Set(ref this.layer03, value);
                break;
            }

            case 4:
            {
                flag = CameraLayerDepths.Set(ref this.layer04, value);
                break;
            }

            case 5:
            {
                flag = CameraLayerDepths.Set(ref this.layer05, value);
                break;
            }

            case 6:
            {
                flag = CameraLayerDepths.Set(ref this.layer06, value);
                break;
            }

            case 7:
            {
                flag = CameraLayerDepths.Set(ref this.layer07, value);
                break;
            }

            case 8:
            {
                flag = CameraLayerDepths.Set(ref this.layer08, value);
                break;
            }

            case 9:
            {
                flag = CameraLayerDepths.Set(ref this.layer09, value);
                break;
            }

            case 10:
            {
                flag = CameraLayerDepths.Set(ref this.layer10, value);
                break;
            }

            case 11:
            {
                flag = CameraLayerDepths.Set(ref this.layer11, value);
                break;
            }

            case 12:
            {
                flag = CameraLayerDepths.Set(ref this.layer12, value);
                break;
            }

            case 13:
            {
                flag = CameraLayerDepths.Set(ref this.layer13, value);
                break;
            }

            case 14:
            {
                flag = CameraLayerDepths.Set(ref this.layer14, value);
                break;
            }

            case 15:
            {
                flag = CameraLayerDepths.Set(ref this.layer15, value);
                break;
            }

            case 16:
            {
                flag = CameraLayerDepths.Set(ref this.layer16, value);
                break;
            }

            case 17:
            {
                flag = CameraLayerDepths.Set(ref this.layer17, value);
                break;
            }

            case 18:
            {
                flag = CameraLayerDepths.Set(ref this.layer18, value);
                break;
            }

            case 19:
            {
                flag = CameraLayerDepths.Set(ref this.layer19, value);
                break;
            }

            case 20:
            {
                flag = CameraLayerDepths.Set(ref this.layer20, value);
                break;
            }

            case 21:
            {
                flag = CameraLayerDepths.Set(ref this.layer21, value);
                break;
            }

            case 22:
            {
                flag = CameraLayerDepths.Set(ref this.layer22, value);
                break;
            }

            case 23:
            {
                flag = CameraLayerDepths.Set(ref this.layer23, value);
                break;
            }

            case 24:
            {
                flag = CameraLayerDepths.Set(ref this.layer24, value);
                break;
            }

            case 25:
            {
                flag = CameraLayerDepths.Set(ref this.layer25, value);
                break;
            }

            case 26:
            {
                flag = CameraLayerDepths.Set(ref this.layer26, value);
                break;
            }

            case 27:
            {
                flag = CameraLayerDepths.Set(ref this.layer27, value);
                break;
            }

            case 28:
            {
                flag = CameraLayerDepths.Set(ref this.layer28, value);
                break;
            }

            case 29:
            {
                flag = CameraLayerDepths.Set(ref this.layer29, value);
                break;
            }

            case 30:
            {
                flag = CameraLayerDepths.Set(ref this.layer30, value);
                break;
            }

            case 31:
            {
                flag = CameraLayerDepths.Set(ref this.layer31, value);
                break;
            }

            default:
            {
                throw new ArgumentOutOfRangeException();
            }
            }
            if (flag)
            {
                this.Awake();
            }
        }
    }