一、框架視圖

二、關(guān)鍵代碼

AndroidStatusBar

using System;
using System.Collections.Generic;
using UnityEngine;

/**
 * @author zeh fernando
 * @modify MemoryC_2017-02-05
 */
class AndroidStatusBar
{

    /**
 * Manipulates the system application chrome to change the way the status bar and navigation bar work
 *POSTS FROM :
 *http://zehfernando.com/2015/unity-tidbits-changing-the-visibility-of-androids-navigation-and-status-bars-and-implementing-immersive-mode/
 *[url=http://www.manew.com/thread-100054-1-1.html]http://www.manew.com/thread-100054-1-1.html[/url]
 * References:
 * . http://developer.android.com/reference/android/view/View.html#setSystemUiVisibility(int)
 * . http://forum.unity3d.com/threads/calling-setsystemuivisibility.139445/#post-952946
 * . http://developer.android.com/reference/android/view/WindowManager.LayoutParams.html#FLAG_LAYOUT_IN_SCREEN
 **/

    // Enums
    public enum States
    {
        Unknown,
        Visible,
        VisibleOverContent,
        TranslucentOverContent,
        Hidden,
    }

    // Constants
    private const uint DEFAULT_BACKGROUND_COLOR = 0xff000000;

#if UNITY_ANDROID
    // Original Android flags
    private const int VIEW_SYSTEM_UI_FLAG_VISIBLE = 0;                                        // Added in API 14 (Android 4.0.x): Status bar visible (the default)
    private const int VIEW_SYSTEM_UI_FLAG_LOW_PROFILE = 1;                                // Added in API 14 (Android 4.0.x): Low profile for games, book readers, and video players; the status bar and/or navigation icons are dimmed out (if visible)
    private const int VIEW_SYSTEM_UI_FLAG_HIDE_NAVIGATION = 2;                        // Added in API 14 (Android 4.0.x): Hides all navigation. Cleared when theres any user interaction.
    private const int VIEW_SYSTEM_UI_FLAG_FULLSCREEN = 4;                                // Added in API 16 (Android 4.1.x): Hides status bar. Does nothing in Unity (already hidden if "status bar hidden" is checked)
    private const int VIEW_SYSTEM_UI_FLAG_LAYOUT_STABLE = 256;                        // Added in API 16 (Android 4.1.x): ?
    private const int VIEW_SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION = 512;        // Added in API 16 (Android 4.1.x): like HIDE_NAVIGATION, but for layouts? it causes the layout to be drawn like that, even if the whole view isn't (to avoid artifacts in animation)
    private const int VIEW_SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN = 1024;                // Added in API 16 (Android 4.1.x): like FULLSCREEN, but for layouts? it causes the layout to be drawn like that, even if the whole view isn't (to avoid artifacts in animation)
    private const int VIEW_SYSTEM_UI_FLAG_IMMERSIVE = 2048;                                // Added in API 19 (Android 4.4): like HIDE_NAVIGATION, but interactive (it's a modifier for HIDE_NAVIGATION, needs to be used with it)
    private const int VIEW_SYSTEM_UI_FLAG_IMMERSIVE_STICKY = 4096;                // Added in API 19 (Android 4.4): tells that HIDE_NAVIGATION and FULSCREEN are interactive (also just a modifier)

    private static int WINDOW_FLAG_FULLSCREEN = 0x00000400;
    private static int WINDOW_FLAG_FORCE_NOT_FULLSCREEN = 0x00000800;
    private static int WINDOW_FLAG_LAYOUT_IN_SCREEN = 0x00000100;
    private static int WINDOW_FLAG_TRANSLUCENT_STATUS = 0x04000000;
    private static int WINDOW_FLAG_TRANSLUCENT_NAVIGATION = 0x08000000;
    private static int WINDOW_FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS = -2147483648; // 0x80000000; // Added in API 21 (Android 5.0): tells the Window is responsible for drawing the background for the system bars. If set, the system bars are drawn with a transparent background and the corresponding areas in this window are filled with the colors specified in getStatusBarColor() and getNavigationBarColor()

    // Current values
    private static int systemUiVisibilityValue;
    private static int flagsValue;
#endif

    // Properties
    private static States _statusBarState;
    //        private static States _navigationBarState;

    private static uint _statusBarColor = DEFAULT_BACKGROUND_COLOR;
    //        private static uint _navigationBarColor = DEFAULT_BACKGROUND_COLOR;

    private static bool _isStatusBarTranslucent; // Just so we know whether its translucent when hidden or not
                                                 //        private static bool _isNavigationBarTranslucent;

    private static bool _dimmed;
    // ================================================================================================================
    // INTERNAL INTERFACE ---------------------------------------------------------------------------------------------

    static AndroidStatusBar()
    {
        applyUIStates();
        applyUIColors();
    }

    private static void applyUIStates()
    {
#if UNITY_ANDROID && !UNITY_EDITOR
 
                int newFlagsValue = 0;
                int newSystemUiVisibilityValue = 0;
 
                // Apply dim values
                if (_dimmed) newSystemUiVisibilityValue |= VIEW_SYSTEM_UI_FLAG_LOW_PROFILE;
 
                // Apply color values
//                if (_navigationBarColor != DEFAULT_BACKGROUND_COLOR || _statusBarColor != DEFAULT_BACKGROUND_COLOR) newFlagsValue |= WINDOW_FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS;
                if (_statusBarColor != DEFAULT_BACKGROUND_COLOR) newFlagsValue |= WINDOW_FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS;
 
                // Apply status bar values
                switch (_statusBarState) {
                case States.Visible:
                _isStatusBarTranslucent = false;
                newFlagsValue |= WINDOW_FLAG_FORCE_NOT_FULLSCREEN;
                break;
                case States.VisibleOverContent:
                _isStatusBarTranslucent = false;
                newFlagsValue |= WINDOW_FLAG_FORCE_NOT_FULLSCREEN | WINDOW_FLAG_LAYOUT_IN_SCREEN;
                newSystemUiVisibilityValue |= VIEW_SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN;
                break;
                case States.TranslucentOverContent:
                _isStatusBarTranslucent = true;
                newFlagsValue |= WINDOW_FLAG_FORCE_NOT_FULLSCREEN | WINDOW_FLAG_LAYOUT_IN_SCREEN | WINDOW_FLAG_TRANSLUCENT_STATUS;
                newSystemUiVisibilityValue |= VIEW_SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN;
                break;
                case States.Hidden:
                newFlagsValue |= WINDOW_FLAG_FULLSCREEN | WINDOW_FLAG_LAYOUT_IN_SCREEN;
                if (_isStatusBarTranslucent) newFlagsValue |= WINDOW_FLAG_TRANSLUCENT_STATUS;
                break;
                }
 
                // Applies navigation values
                /*
                switch (_navigationBarState) {
                case States.Visible:
                _isNavigationBarTranslucent = false;
                newSystemUiVisibilityValue |= VIEW_SYSTEM_UI_FLAG_LAYOUT_STABLE;
                break;
                case States.VisibleOverContent:
                // TODO: Side effect: forces status bar over content if set to VISIBLE
                _isNavigationBarTranslucent = false;
                newSystemUiVisibilityValue |= VIEW_SYSTEM_UI_FLAG_LAYOUT_STABLE | VIEW_SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION;
                break;
                case States.TranslucentOverContent:
                // TODO: Side effect: forces status bar over content if set to VISIBLE
                _isNavigationBarTranslucent = true;
                newFlagsValue |= WINDOW_FLAG_TRANSLUCENT_NAVIGATION;
                newSystemUiVisibilityValue |= VIEW_SYSTEM_UI_FLAG_LAYOUT_STABLE | VIEW_SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION;
                break;
                case States.Hidden:
                newSystemUiVisibilityValue |= VIEW_SYSTEM_UI_FLAG_FULLSCREEN | VIEW_SYSTEM_UI_FLAG_HIDE_NAVIGATION | VIEW_SYSTEM_UI_FLAG_IMMERSIVE_STICKY;
                if (_isNavigationBarTranslucent) newFlagsValue |= WINDOW_FLAG_TRANSLUCENT_NAVIGATION;
                break;
                }
                */
                if (Screen.fullScreen) Screen.fullScreen = false;
 
                // Applies everything natively
                setFlags(newFlagsValue);
                setSystemUiVisibility(newSystemUiVisibilityValue);
#endif
    }

    private static void applyUIColors()
    {
#if UNITY_ANDROID && !UNITY_EDITOR
                runOnAndroidUiThread(applyUIColorsAndroidInThread);
#endif
    }

#if UNITY_ANDROID
    private static void runOnAndroidUiThread(Action target)
    {
        using (var unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
        {
            using (var activity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity"))
            {
                activity.Call("runOnUiThread", new AndroidJavaRunnable(target));
            }
        }
    }

    private static void setSystemUiVisibility(int value)
    {
        if (systemUiVisibilityValue != value)
        {
            systemUiVisibilityValue = value;
            runOnAndroidUiThread(setSystemUiVisibilityInThread);
        }
    }

    private static void setSystemUiVisibilityInThread()
    {
        //Debug.Log("SYSTEM FLAGS: " + systemUiVisibilityValue);
        using (var unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
        {
            using (var activity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity"))
            {
                using (var window = activity.Call<AndroidJavaObject>("getWindow"))
                {
                    using (var view = window.Call<AndroidJavaObject>("getDecorView"))
                    {
                        view.Call("setSystemUiVisibility", systemUiVisibilityValue);
                    }
                }
            }
        }
    }

    private static void setFlags(int value)
    {
        if (flagsValue != value)
        {
            flagsValue = value;
            runOnAndroidUiThread(setFlagsInThread);
        }
    }

    private static void setFlagsInThread()
    {
        //Debug.Log("FLAGS: " + flagsValue);
        using (var unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
        {
            using (var activity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity"))
            {
                using (var window = activity.Call<AndroidJavaObject>("getWindow"))
                {
                    window.Call("setFlags", flagsValue, -1); // (int)0x7FFFFFFF
                }
            }
        }
    }

    private static void applyUIColorsAndroidInThread()
    {
        using (var unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
        {
            using (var activity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity"))
            {
                using (var window = activity.Call<AndroidJavaObject>("getWindow"))
                {
                    //Debug.Log("Colors SET: " + _statusBarColor);
                    window.Call("setStatusBarColor", unchecked((int)_statusBarColor));
                    //                                        window.Call("setNavigationBarColor", unchecked((int)_navigationBarColor));
                }
            }
        }
    }

#endif

    // ================================================================================================================
    // ACCESSOR INTERFACE ---------------------------------------------------------------------------------------------
    /*
    public static States navigationBarState {
            get { return _navigationBarState; }
            set {
                    if (_navigationBarState != value) {
                            _navigationBarState = value;
                            applyUIStates();
                    }
            }
    }
*/
    public static States statusBarState
    {
        get { return _statusBarState; }
        set
        {
            if (_statusBarState != value)
            {
                _statusBarState = value;
                applyUIStates();
            }
        }
    }

    public static bool dimmed
    {
        get { return _dimmed; }
        set
        {
            if (_dimmed != value)
            {
                _dimmed = value;
                applyUIStates();
            }
        }
    }

    public static uint statusBarColor
    {
        get { return _statusBarColor; }
        set
        {
            if (_statusBarColor != value)
            {
                _statusBarColor = value;
                applyUIColors();
                applyUIStates();
            }
        }
    }
    /*
    public static uint navigationBarColor {
            get { return _navigationBarColor; }
            set {
                    if (_navigationBarColor != value) {
                            _navigationBarColor = value;
                            applyUIColors();
                            applyUIStates();
                    }
            }
    }
    */
}

ButtonMessage

using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using UnityEngine.SceneManagement;


/// <summary>
/// 異步加載
/// </summary>
public class ButtonMessage : MonoBehaviour
{
    //滑動(dòng)條
    public Slider progress;
    //顯示值

    public Text progressValue;

    //異步加載的場景
    private AsyncOperation op;

    void Awake()
    {
    }

    void Start() {

            op = SceneManager.LoadSceneAsync("Gril");
            //開啟進(jìn)度條
            StartCoroutine(LoadingScene());       
    }
    /// <summary>
    /// 設(shè)置進(jìn)度值
    /// </summary>
    /// <param name="value">參數(shù)名</param>
    private void setProgressValue(int value)
    {
        //獲取進(jìn)度條的值
        progress.value = value;

        //顯示進(jìn)度條的值
        progressValue.text = value + "%";
    }

    private IEnumerator LoadingScene()
    {
        int displayProgress = 0;

        int toProgress = 0;

        op.allowSceneActivation = false; //不允許自動(dòng)加載場景

        while (op.progress < 0.9f)
        {
            toProgress = (int)op.progress * 100;
            while (displayProgress < toProgress)
            {
                ++displayProgress;
                setProgressValue(displayProgress);
                yield return new WaitForEndOfFrame();
            }               
        }

        toProgress = 100;

        while (displayProgress < toProgress)
        {
            ++displayProgress;
            setProgressValue(displayProgress);
            yield return new WaitForEndOfFrame();
        }

        op.allowSceneActivation = true;
    }

   
}

CameraMode

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Vuforia;


/// <summary>
/// 自動(dòng)對焦功能
/// </summary>
public class CameraMode : MonoBehaviour {


    void Start () {
        //一開始自動(dòng)對焦
        //Vuforia.CameraDevice.Instance.SetFocusMode(Vuforia.CameraDevice.FocusMode.FOCUS_MODE_CONTINUOUSAUTO);
        VuforiaARController.Instance.RegisterVuforiaStartedCallback(OnVuforiaStarted);
        VuforiaARController.Instance.RegisterOnPauseCallback(OnPaused);
    }

    void Update () {
        //觸碰的時(shí)候?qū)?        //if (Input.GetMouseButtonUp(0))
        //{
        //    if (Input.touchCount > 0 && Input.GetTouch(0).phase == TouchPhase.Began)
        //    {
        //        Vuforia.CameraDevice.Instance.SetFocusMode(Vuforia.CameraDevice.FocusMode.FOCUS_MODE_CONTINUOUSAUTO);
        //    }
        //}

    }
    private void OnVuforiaStarted()
    {
            CameraDevice.Instance.SetFocusMode(
            CameraDevice.FocusMode.FOCUS_MODE_CONTINUOUSAUTO);
    }

    private void OnPaused(bool paused)
    {
        if (!paused)
        { // resumed
            // Set again autofocus mode when app is resumed
            CameraDevice.Instance.SetFocusMode(
            CameraDevice.FocusMode.FOCUS_MODE_CONTINUOUSAUTO);
        }
    }
}

MyTrackableEventHandler

/*==============================================================================
Copyright (c) 2010-2014 Qualcomm Connected Experiences, Inc.
All Rights Reserved.
Confidential and Proprietary - Protected under copyright and other laws.
==============================================================================*/

using UnityEngine;

namespace Vuforia
{
    /// <summary>
    /// A custom handler that implements the ITrackableEventHandler interface.
    /// </summary>
    public class MyTrackableEventHandler : MonoBehaviour,
                                                ITrackableEventHandler
    {

        //定義音頻
        private AudioSource music;

        //定義動(dòng)畫狀態(tài)機(jī)
        private Animator mAnimator;

        #region PRIVATE_MEMBER_VARIABLES

        private TrackableBehaviour mTrackableBehaviour;

        #endregion // PRIVATE_MEMBER_VARIABLES



        #region UNTIY_MONOBEHAVIOUR_METHODS

        void Start()
        {
            mTrackableBehaviour = GetComponent<TrackableBehaviour>();
            if (mTrackableBehaviour)
            {
                mTrackableBehaviour.RegisterTrackableEventHandler(this);
            }
            //獲取音頻組件忧侧；
            music = this.GetComponent<AudioSource>();

            //獲取動(dòng)畫上組件
            mAnimator = GameObject.FindGameObjectWithTag("Gril").GetComponent<Animator>();
        }

        #endregion // UNTIY_MONOBEHAVIOUR_METHODS



        #region PUBLIC_METHODS

        /// <summary>
        /// Implementation of the ITrackableEventHandler function called when the
        /// tracking state changes.
        /// </summary>
        public void OnTrackableStateChanged(
                                        TrackableBehaviour.Status previousStatus,
                                        TrackableBehaviour.Status newStatus)
        {
            if (newStatus == TrackableBehaviour.Status.DETECTED ||
                newStatus == TrackableBehaviour.Status.TRACKED ||
                newStatus == TrackableBehaviour.Status.EXTENDED_TRACKED)
            {
                OnTrackingFound();
            }
            else
            {
                OnTrackingLost();
            }
        }

        #endregion // PUBLIC_METHODS



        #region PRIVATE_METHODS


        private void OnTrackingFound()
        {
            Renderer[] rendererComponents = GetComponentsInChildren<Renderer>(true);
            Collider[] colliderComponents = GetComponentsInChildren<Collider>(true);

            // Enable rendering:
            foreach (Renderer component in rendererComponents)
            {
                component.enabled = true;
            }

            // Enable colliders:
            foreach (Collider component in colliderComponents)
            {
                component.enabled = true;
            }

            Debug.Log("Trackable " + mTrackableBehaviour.TrackableName + " found");
            //判斷是否在播放 沒播放就播放 有播放就把音量調(diào)到1；
            if (!music.isPlaying)
            {
                //播放音樂挣菲；
                music.Play();
                music.volume = 1;
            }
            else if (music.isPlaying)
            {
                music.volume = 1;
            }

            //播放動(dòng)畫贮喧；
            mAnimator.enabled = true;
            mAnimator.speed = 1;
        }


        private void OnTrackingLost()
        {
            Renderer[] rendererComponents = GetComponentsInChildren<Renderer>(true);
            Collider[] colliderComponents = GetComponentsInChildren<Collider>(true);

            // Disable rendering:
            foreach (Renderer component in rendererComponents)
            {
                component.enabled = false;
            }

            // Disable colliders:
            foreach (Collider component in colliderComponents)
            {
                component.enabled = false;
            }

            Debug.Log("Trackable " + mTrackableBehaviour.TrackableName + " lost");
            //獲取音頻組件；
            music = this.GetComponent<AudioSource>();
            //暫停音樂
           // music.Pause();
            music.volume = 0;

            //獲取動(dòng)畫上組件
            mAnimator = GameObject.FindGameObjectWithTag("Gril").GetComponent<Animator>();
            //暫停動(dòng)畫舔庶；
            mAnimator.speed = 0;
        }

        #endregion // PRIVATE_METHODS
    }
}

SpringBone

using UnityEngine;
using System.Collections;

namespace UnityChan
{
    public class SpringBone : MonoBehaviour
    {
        
        public Transform child;

        
        public Vector3 boneAxis = new Vector3 (-1.0f, 0.0f, 0.0f);
        public float radius = 0.05f;

        
        public bool isUseEachBoneForceSettings = false; 

        
        public float stiffnessForce = 0.01f;

    
        public float dragForce = 0.4f;
        public Vector3 springForce = new Vector3 (0.0f, -0.0001f, 0.0f);
        public SpringCollider[] colliders;
        public bool debug = true;
        
        public float threshold = 0.01f;
        private float springLength;
        private Quaternion localRotation;
        private Transform trs;
        private Vector3 currTipPos;
        private Vector3 prevTipPos;
        
        private Transform org;
        
        private SpringManager managerRef;

        private void Awake ()
        {
            trs = transform;
            localRotation = transform.localRotation;
            
            managerRef = GetParentSpringManager (transform);
        }

        private SpringManager GetParentSpringManager (Transform t)
        {
            var springManager = t.GetComponent<SpringManager> ();

            if (springManager != null)
                return springManager;

            if (t.parent != null) {
                return GetParentSpringManager (t.parent);
            }

            return null;
        }

        private void Start ()
        {
            springLength = Vector3.Distance (trs.position, child.position);
            currTipPos = child.position;
            prevTipPos = child.position;
        }

        public void UpdateSpring ()
        {
            
            org = trs;
            
            trs.localRotation = Quaternion.identity * localRotation;

            float sqrDt = Time.deltaTime * Time.deltaTime;

            //stiffness
            Vector3 force = trs.rotation * (boneAxis * stiffnessForce) / sqrDt;

            //drag
            force += (prevTipPos - currTipPos) * dragForce / sqrDt;

            force += springForce / sqrDt;

            
            Vector3 temp = currTipPos;

            //verlet
            currTipPos = (currTipPos - prevTipPos) + currTipPos + (force * sqrDt);

            
            currTipPos = ((currTipPos - trs.position).normalized * springLength) + trs.position;

            
            for (int i = 0; i < colliders.Length; i++) {
                if (Vector3.Distance (currTipPos, colliders [i].transform.position) <= (radius + colliders [i].radius)) {
                    Vector3 normal = (currTipPos - colliders [i].transform.position).normalized;
                    currTipPos = colliders [i].transform.position + (normal * (radius + colliders [i].radius));
                    currTipPos = ((currTipPos - trs.position).normalized * springLength) + trs.position;
                }


            }

            prevTipPos = temp;

            
            Vector3 aimVector = trs.TransformDirection (boneAxis);
            Quaternion aimRotation = Quaternion.FromToRotation (aimVector, currTipPos - trs.position);
            
            Quaternion secondaryRotation = aimRotation * trs.rotation;
            trs.rotation = Quaternion.Lerp (org.rotation, secondaryRotation, managerRef.dynamicRatio);
        }

        private void OnDrawGizmos ()
        {
            if (debug) {
                Gizmos.color = Color.yellow;
                Gizmos.DrawWireSphere (currTipPos, radius);
            }
        }
    }
}

SpringCollider

using UnityEngine;
using System.Collections;

namespace UnityChan
{
    public class SpringCollider : MonoBehaviour
    {
        //半徑
        public float radius = 0.5f;

        private void OnDrawGizmosSelected ()
        {
            Gizmos.color = Color.green;
            Gizmos.DrawWireSphere (transform.position, radius);
        }
    }
}

SpringManager

using UnityEngine;
using System.Collections;

namespace UnityChan
{
    public class SpringManager : MonoBehaviour
    {
        //Kobayashi
        // DynamicRatio is paramater for activated level of dynamic animation 
        public float dynamicRatio = 1.0f;

        //Ebata
        public float            stiffnessForce;
        public AnimationCurve   stiffnessCurve;
        public float            dragForce;
        public AnimationCurve   dragCurve;
        public SpringBone[] springBones;

        void Start ()
        {
            UpdateParameters ();
        }
    
        void Update ()
        {
#if UNITY_EDITOR
        
        if(dynamicRatio >= 1.0f)
            dynamicRatio = 1.0f;
        else if(dynamicRatio <= 0.0f)
            dynamicRatio = 0.0f;
        //Ebata
        UpdateParameters();
#endif
        }
    
        private void LateUpdate ()
        {
            
            if (dynamicRatio != 0.0f) {
                for (int i = 0; i < springBones.Length; i++) {
                    if (dynamicRatio > springBones [i].threshold) {
                        springBones [i].UpdateSpring ();
                    }
                }
            }
        }

        private void UpdateParameters ()
        {
            UpdateParameter ("stiffnessForce", stiffnessForce, stiffnessCurve);
            UpdateParameter ("dragForce", dragForce, dragCurve);
        }
    
        private void UpdateParameter (string fieldName, float baseValue, AnimationCurve curve)
        {
            var start = curve.keys [0].time;
            var end = curve.keys [curve.length - 1].time;
            //var step  = (end - start) / (springBones.Length - 1);
        
            var prop = springBones [0].GetType ().GetField (fieldName, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);
        
            for (int i = 0; i < springBones.Length; i++) {
                
                if (!springBones [i].isUseEachBoneForceSettings) {
                    var scale = curve.Evaluate (start + (end - start) * i / (springBones.Length - 1));
                    prop.SetValue (springBones [i], baseValue * scale);
                }
            }
        }
    }
}

StateTest

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 顯示手機(jī)狀態(tài)欄的類
/// </summary>
public class StateTest : MonoBehaviour {

    
    /// <summary>
    /// 保留手機(jī)狀態(tài)欄抛蚁，必須放在awake方法中去
    /// </summary>
    void Awake() {
        
        AndroidStatusBar.statusBarState = AndroidStatusBar.States.TranslucentOverContent;
    }

StatusBarTest

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class StatusBarTest : MonoBehaviour
{
    //public Button toggleDimmedButton;
    //public Button visibleButton;
    //public Button visibleOverContentButton;
    //public Button translucentOverContentButton;
    //public Button hiddenButton;
    // Use this for initialization
    void Start()
    {
        ////當(dāng)AndroidStatusBar.dimmed=false時(shí)，狀態(tài)欄顯示所有狀態(tài)及通知圖標(biāo)
        ////當(dāng)AndroidStatusBar.dimmed=true時(shí)惕橙，狀態(tài)欄僅電量和時(shí)間瞧甩，不顯示其他狀態(tài)及通知
        //if (toggleDimmedButton != null)
        //{
        //    toggleDimmedButton.onClick.AddListener(delegate {
        //        AndroidStatusBar.dimmed = !AndroidStatusBar.dimmed;
        //    });
        //}
        ////顯示狀態(tài)欄，占用屏幕最上方的一部分像素
        //if (visibleButton != null)
        //{
        //    visibleButton.onClick.AddListener(delegate {
        //       AndroidStatusBar.statusBarState = AndroidStatusBar.States.Visible;
        //    });
        //}
        //懸浮顯示狀態(tài)欄弥鹦，不占用屏幕像素
        //if (visibleOverContentButton != null)
        //{
        //    visibleOverContentButton.onClick.AddListener(delegate {
                //AndroidStatusBar.statusBarState = AndroidStatusBar.States.VisibleOverContent;
        //    });
        //}
    //    //透明懸浮顯示狀態(tài)欄肚逸，不占用屏幕像素
    //    if (translucentOverContentButton != null)
    //    {
    //        translucentOverContentButton.onClick.AddListener(delegate {
                AndroidStatusBar.statusBarState = AndroidStatusBar.States.TranslucentOverContent;
    //        });
    //    }
    //    //隱藏狀態(tài)欄
    //    if (hiddenButton != null)
    //    {
    //        hiddenButton.onClick.AddListener(delegate {
    //            AndroidStatusBar.statusBarState = AndroidStatusBar.States.Hidden;
    //        });
    //    }
    }

}

三、效果展示