unity3dapi - CSDN
  • unity3d API汇总

    千次阅读 2015-12-23 10:08:33
    1 using UnityEngine; 2 using System.Collections; 3 4 public class AllFunction : MonoBehaviour 5 { 6 /* 7 API Version: 4.3 8 * Count:60 9 */ 10 11 // Awak
     1 using UnityEngine;
      2 using System.Collections;
      3 
      4 public class AllFunction : MonoBehaviour
      5 {
      6     /*
      7         API Version: 4.3
      8      *  Count:60
      9      */
     10 
     11     // Awake is called when the script instance is being loaded (Since v1.0)
     12     //当一个脚本实例被载入时Awake被调用。一般用于初始化整个实例使用。 在生命周期中只执行一次
     13     public void Awake()
     14     {
     15 
     16     }
     17 
     18     // Update is called every frame, if the MonoBehaviour is enabled (Since v1.0)
     19     /// <summary>
     20     /// 当MonoBehaviour启用时,其Update在每一帧被调用。
     21     ///Update是实现各种游戏行为最常用的函数。
     22     ///为了获取自最后一次调用Update所用的时间,可以用Time.deltaTime。这个函数只有在Behaviour启用时被调用。实现组件功能时重载这个函数。
     23     /// </summary>
     24     public void Update()
     25     {
     26 
     27     }
     28 
     29     // Start is called just before any of the Update methods is called the first time (Since v1.0)
     30     /// <summary>
     31     /// Start仅在Update函数第一次被调用前调用。
     32     ///Start在behaviour的生命周期中只被调用一次。它和Awake的不同是Start只在脚本实例被启用时调用。
     33     ///你可以按需调整延迟初始化代码。Awake总是在Start之前执行。这允许你协调初始化顺序。
     34     ///在所有脚本实例中,Start函数总是在Awake函数之后调用。
     35     /// </summary>
     36     public void Start()
     37     {
     38 
     39     }
     40 
     41     // Reset to default values (Since v1.0)
     42     /// <summary>
     43     /// 重置为默认值。
     44     ///Reset是在用户点击检视面板的Reset按钮或者首次添加该组件时被调用。
     45     ///此函数只在编辑模式下被调用。Reset最常用于在检视面板中给定一个最常用的默认值。
     46     /// </summary>
     47     public void Reset()
     48     {
     49 
     50     }
     51 
     52     // OnWillRenderObject is called once for each camera if the object is visible (Since v2.0)
     53     /// <summary>
     54     /// 如果对象可见每个相机都会调用它。
     55     ///如果MonoBehaviour被禁用,此函数将不被调用。
     56     ///此函数在消隐过程中被调用,在渲染所有被消隐的物体之前被调用。
     57     ///你可以用它来创建具有依赖性的纹理并且只有在被渲染的物体可见时才更新这个纹理。举例来讲,它已用于水组件中。
     58     ///Camera.current将被设置为要渲染这个物体的相机。
     59     /// </summary>
     60     public void OnWillRenderObject()
     61     {
     62 
     63     }
     64 
     65     // This function is called when the script is loaded or a value is changed in the inspector (Called in the editor only). (Since v4.2)
     66     public void OnValidate()
     67     {
     68 
     69     }
     70 
     71     // OnTriggerStay2D is called once per frame for every Collider2D other that is touching the trigger (2D physics only). (Since v4.3)
     72     public void OnTriggerStay2D(Collider2D other)
     73     {
     74 
     75     }
     76 
     77     // OnTriggerStay is called once per frame for every Collider other that is touching the trigger (Since v1.0)
     78     /// <summary>
     79     /// 当碰撞体接触触发器时,OnTriggerStay将在每一帧被调用。
     80     ///这个消息被发送到触发器和接触到这个触发器的碰撞体。注意如果碰撞体附加了一个刚体,也只发送触发器事件。
     81     ///OnTriggerStay可以被用作协同程序,在函数中调用yield语句。
     82     /// </summary>
     83     /// <param name="other"></param>
     84     public void OnTriggerStay(Collider other)
     85     {
     86 
     87     }
     88 
     89     // OnTriggerExit2D is called when the Collider2D other has stopped touching the trigger (2D physics only). (Since v4.3)
     90     public void OnTriggerExit2D(Collider2D other)
     91     {
     92 
     93     }
     94 
     95     // OnTriggerExit is called when the Collider other has stopped touching the trigger (Since v1.0)
     96     /// <summary>
     97     /// 当Collider(碰撞体)停止触发trigger(触发器)时调用OnTriggerExit。
     98     ///这个消息被发送到触发器和接触到这个触发器的碰撞体。注意如果碰撞体附加了一个刚体,也只发送触发器事件。
     99     ///OnTriggerExit可以被用作协同程序,在函数中调用yield语句。
    100     /// </summary>
    101     /// <param name="other"></param>
    102     public void OnTriggerExit(Collider other)
    103     {
    104 
    105     }
    106 
    107     // OnTriggerEnter2D is called when the Collider2D other enters the trigger (2D physics only). (Since v4.3)
    108     public void OnTriggerEnter2D(Collider2D other)
    109     {
    110 
    111     }
    112 
    113     // OnTriggerEnter is called when the Collider other enters the trigger (Since v1.0)
    114     /// <summary>
    115     /// 当Collider(碰撞体)进入trigger(触发器)时调用OnTriggerEnter。
    116     ///这个消息被发送到触发器碰撞体和刚体(或者碰撞体假设没有刚体)。注意如果碰撞体附加了一个刚体,也只发送触发器事件。
    117     ///OnTriggerEnter可以被用作协同程序,在函数中调用yield语句。
    118     /// </summary>
    119     /// <param name="other"></param>
    120     public void OnTriggerEnter(Collider other)
    121     {
    122 
    123     }
    124 
    125     // Called on the server whenever a Network.InitializeServer was invoked and has completed (Since v2.0)
    126     /// <summary>
    127     /// 当Network.InitializeServer被调用并完成时,在服务器上调用这个函数。
    128     /// </summary>
    129     public void OnServerInitialized()
    130     {
    131 
    132     }
    133 
    134     // Used to customize synchronization of variables in a script watched by a network view (Since v2.0)
    135     /// <summary>
    136     /// 在一个网络视图脚本中,用于自定义变量同步。
    137     ///它自动决定被序列化的变量是否应该发送或接收,查看下面的例子获取更好的描述。
    138     ///这个依赖于谁拥有这个物体,例如,所有者发送,其他物体接收。
    139     /// </summary>
    140     /// <param name="info"></param>
    141     /// <param name="stream"></param>
    142     public void OnSerializeNetworkView(NetworkMessageInfo info, BitStream stream)
    143     {
    144 
    145     }
    146 
    147     // OnRenderObject is called after camera has rendered the scene (Since v3.0)
    148     /// <summary>
    149     /// 在相机场景渲染完成后被调用。
    150     ///该函数可以用来渲染你自己的物体,用Graphics.DrawMesh或者其他函数。这个函数类似于OnPostRender,
    151     ///除非OnRenderObject被其他物体用脚本函数调用,否则它是否附于相机都没有关系。
    152     /// </summary>
    153     public void OnRenderObject()
    154     {
    155 
    156     }
    157 
    158     // OnRenderImage is called after all rendering is complete to render image (Since v1.0)
    159     /// <summary>
    160     /// 当完成所有渲染图片后被调用,用来渲染图片后期效果。
    161     ///后期效果处理(仅Unity Pro)。
    162     ///它允许你使用基于着色器的过滤器来处理最终的图像。进入的图片是source渲染纹理。结果是destination渲染纹理。
    163     ///当有多个图片过滤器附加在相机上时,它们序列化地处理图片,将第一个过滤器的目标作为下一个过滤器的源。
    164     ///这个消息被发送到所有附加在相机上的脚本。
    165     /// </summary>
    166     /// <param name="destination"></param>
    167     /// <param name="source"></param>
    168     public void OnRenderImage(RenderTexture destination, RenderTexture source)
    169     {
    170 
    171     }
    172 
    173     // OnPreRender is called before a camera starts rendering the scene (Since v1.0)
    174     /// <summary>
    175     /// 在相机渲染场景之前被调用。
    176     ///只有脚本被附加到相机并被启用时才会调用这个函数。
    177     ///注意:如果你改变了相机的参数(如:fieldOfView),它将只作用于下一帧.应该用OnPreCull代替.OnPreRender可以是一个协同程序,在函数中调用yield语句即可.
    178     /// </summary>
    179     public void OnPreRender()
    180     {
    181 
    182     }
    183 
    184     // OnPreCull is called before a camera culls the scene (Since v1.0)
    185     /// <summary>
    186     /// 在相机消隐场景之前被调用。
    187     ///消隐决定哪个物体对于相机来说是可见的.OnPreCull仅是在这个过程被调用。
    188     ///只有脚本被附加到相机上时才会调用这个函数。
    189     ///如果你想改变相机的参数(比如:fieldOfView或者transform),可以在这里做这些。场景物体的可见性将根据相机的参数在OnPreCull之后确定。
    190     /// </summary>
    191     public void OnPreCull()
    192     {
    193 
    194     }
    195 
    196     // OnPostRender is called after a camera finished rendering the scene (Since v1.0)
    197     /// <summary>
    198     /// 在相机完成场景渲染之后被调用。
    199     ///只有该脚本附于相机并启用时才会调用这个函数。OnPostRender可以是一个协同程序,在函数中调用yield语句即。
    200     ///OnPostRender在相机渲染完所有物体之后被调用。如果你想在相机和GUI渲染完成后做些什么,就用WaitForEndOfFrame协同程序。
    201     /// </summary>
    202     public void OnPostRender()
    203     {
    204 
    205     }
    206 
    207     // Called on the server whenever a player disconnected from the server. (Since v2.0)
    208     /// <summary>
    209     /// 当一个玩家从服务器上断开时在服务器端调用。
    210     /// </summary>
    211     /// <param name="player"></param>
    212     public void OnPlayerDisconnected(NetworkPlayer player)
    213     {
    214         Debug.Log("Clean up after player " + player);
    215         Network.RemoveRPCs(player);
    216         Network.DestroyPlayerObjects(player);
    217     }
    218 
    219     // Called on the server whenever a new player has successfully connected (Since v2.0)
    220     /// <summary>
    221     /// 当一个新玩家成功连接时在服务器上被调用。
    222     /// </summary>
    223     /// <param name="player"></param>
    224     public void OnPlayerConnected(NetworkPlayer player)
    225     {
    226         int playerCount = 0;
    227         // 用玩家的信息构建一个数据结构
    228         Debug.Log("Player " + playerCount + " connected from " + player.ipAddress + ":" + player.port);
    229     }
    230 
    231     // OnParticleCollision is called when a particle hits a collider (Since v1.0)
    232     /// <summary>
    233     /// 当粒子碰到collider时被调用。
    234     ///这个可以用于游戏对象被粒子击中时应用伤害到它上面。
    235     ///这个消息被发送到所有附加到theWorldParticleCollider 的脚本上和被击中的碰撞体上。这个消息只有当你在theWorldParticleCollider 
    236     ///检视面板中启用了sendCollisionMessage 才会被发送。
    237     ///OnParticleCollision 可以被用作协同程序,在函数中调用yield语句。
    238     /// </summary>
    239     /// <param name="other"></param>
    240     public void OnParticleCollision(GameObject other)
    241     {
    242 
    243     }
    244 
    245     // Called on objects which have been network instantiated with Network.Instantiate (Since v2.0)
    246     /// <summary>
    247     /// 当一个物体使用Network.Instantiate进行网络初始化时调用。
    248     ///这对于禁用或启用一个已经初始化的物体组件来说是非常有用的,它们的行为取决于它们是在本地还是在远端。
    249     ///注意: 在NetworkMessageInfo里的networkView属性不能在OnNetworkInstantiate里使用。
    250     /// </summary>
    251     /// <param name="info"></param>
    252     public void OnNetworkInstantiate(NetworkMessageInfo info)
    253     {
    254 
    255     }
    256 
    257     // OnMouseUpAsButton is only called when the mouse is released over the same GUIElement or Collider as it was pressed (Since v3.4)
    258     public void OnMouseUpAsButton()
    259     {
    260 
    261     }
    262 
    263     // OnMouseUp is called when the user has released the mouse button (Since v1.0)
    264     /// <summary>
    265     /// 用户释放鼠标按钮时调用OnMouseUp。
    266     ///OnMouseUp只调用在按下的同一物体上。
    267     /// </summary>
    268     public void OnMouseUp()
    269     {
    270 
    271     }
    272 
    273     // OnMouseOver is called every frame while the mouse is over the GUIElement or Collider (Since v1.0)
    274     /// <summary>
    275     /// 当鼠标悬浮在GUIElement(GUI元素)或Collider(碰撞体)上时调用 OnMouseOver 。
    276     /// </summary>
    277     public void OnMouseOver()
    278     {
    279 
    280     }
    281 
    282     // OnMouseExit is called when the mouse is not any longer over the GUIElement or Collider (Since v1.0)
    283     /// <summary>
    284     /// 当鼠标移出GUIElement(GUI元素)或Collider(碰撞体)上时调用OnMouseExit。
    285     ///OnMouseExit与OnMouseEnter相反。
    286     /// </summary>
    287     public void OnMouseExit()
    288     {
    289 
    290     }
    291 
    292     // OnMouseEnter is called when the mouse entered the GUIElement or Collider (Since v1.0)
    293     /// <summary>
    294     /// 当鼠标进入到GUIElement(GUI元素)或Collider(碰撞体)中时调用OnMouseEnter。
    295     /// 这个函数不会在属于Ignore Raycast的层上调用.
    296     ///它可以被作为协同程序,在函数体内使用yield语句.这个事件将发送到所有附在Collider或GUIElement的脚本上.
    297     ///注意:这个函数在iPhone上无效.
    298     /// </summary>
    299     public void OnMouseEnter()
    300     {
    301         // 附加这个脚本到网格
    302         // 当鼠标经过网格时网格变红色
    303         renderer.material.color = Color.red;
    304     }
    305 
    306     // OnMouseDrag is called when the user has clicked on a GUIElement or Collider and is still holding down the mouse (Since v1.0)
    307     /// <summary>
    308     /// 当用户鼠标拖拽GUIElement(GUI元素)或Collider(碰撞体)时调用 OnMouseDrag 。
    309     ///OnMouseDrag在鼠标按下的每一帧被调用。
    310     ///这个函数不会在属于Ignore Raycast的层上调用。
    311     ///它可以被作为协同程序,在函数体内使用yield语句,这个事件将发送到所有附在Collider或GUIElement的脚本上。
    312     ///注意:此函数在iPhone上无效。
    313     /// </summary>
    314     public void OnMouseDrag()
    315     {
    316 
    317     }
    318 
    319     // OnMouseDown is called when the user has pressed the mouse button while over the GUIElement or Collider (Since v1.0)
    320     /// <summary>
    321     /// 当鼠标在GUIElement(GUI元素)或Collider(碰撞体)上点击时调用OnMouseDown。
    322     /// 这个事件将发送给 Collider 或 GUIElement 上的所有脚本。
    323     /// 这个函数不会在属于Ignore Raycast的层上调用.
    324     ///它可以被作为协同程序,在函数体内使用yield语句,这个事件将发送到所有附在Collider或GUIElement的脚本上。
    325     ///注意:此函数在iPhone上无效。
    326     /// </summary>
    327     public void OnMouseDown()
    328     {
    329         // 点击物体后载入"SomeLevel"关卡.
    330         Application.LoadLevel("SomeLevel");
    331     }
    332 
    333     // Called on clients or servers when reporting events from the MasterServer (Since v2.0)
    334     /// <summary>
    335     /// 当报告事件来自主服务器时在客户端或服务器端调用。
    336     /// 例如:当一个客户列表接收完成或客户注册成功后被调用。
    337     /// </summary>
    338     /// <param name="msEvent"></param>
    339     public void OnMasterServerEvent(MasterServerEvent msEvent)
    340     {
    341         if (msEvent == MasterServerEvent.RegistrationSucceeded)
    342             Debug.Log("Server registered");
    343 
    344         /*
    345             void Start() {
    346                 Network.InitializeServer(32, 25000);
    347             }
    348             void OnServerInitialized() {
    349                 MasterServer.RegisterHost("MyGameVer1.0.0_42", "My Game Instance", "This is a comment and place to store data");
    350             }
    351             void OnMasterServerEvent(MasterServerEvent msEvent) {
    352                 if (msEvent == MasterServerEvent.RegistrationSucceeded)
    353                     Debug.Log("Server registered");
    354 
    355             }
    356 
    357          */
    358     }
    359 
    360     // This function is called after a new level was loaded (Since v1.0)
    361     /// <summary>
    362     /// 当一个新关卡被载入时此函数被调用。
    363     /// "level" 是被加载的关卡的索引。使用菜单项File->Build Settings... 来查看索引引用的是哪个场景。
    364     /// OnLevelWasLoaded可以被用作协同程序,在函数中调用yield语句.
    365     /// </summary>
    366     /// <param name="level">关卡的索引</param>
    367     public void OnLevelWasLoaded(int level)
    368     {
    369         // 当关卡13被加载时打印"Woohoo"
    370         if (level == 13)
    371             print("Woohoo");
    372     }
    373 
    374     // Called when a joint attached to the same game object broke (Since v2.0)
    375     /// <summary>
    376     /// 当附在同一对象上的关节被断开时调用。
    377     ///当一个力大于这个关节的承受力时,关节将被断开。此时OnJointBreak将被调用,应用到关节的力将被传入。之后这个关节将自动从游戏对象中移除并删除。
    378     /// </summary>
    379     /// <param name="breakForce"></param>
    380     public void OnJointBreak(float breakForce)
    381     {
    382         Debug.Log("Joint Broke!, force: " + breakForce);
    383     }
    384 
    385     // OnGUI is called for rendering and handling GUI events (Since v2.0)
    386     /// <summary>
    387     /// 渲染和处理GUI事件时调用。
    388     ///这意味着你的OnGUI程序将会在每一帧被调用。要得到更多的GUI事件的信息查阅Event手册。如果Monobehaviour的enabled属性设为false,OnGUI()将不会被调用。
    389     /// </summary>
    390     public void OnGUI()
    391     {
    392         if (GUI.Button(new Rect(10, 10, 150, 100), "I am a button"))
    393             print("You clicked the button!");
    394 
    395     }
    396 
    397     // Called on clients or servers when there is a problem connecting to the MasterServer (Since v2.0)
    398     /// <summary>
    399     /// 当连接主服务器出现问题时在客户端或服务器端调用.
    400     ///失败原因将作为 NetworkConnectionError 枚举传入.
    401     /// </summary>
    402     /// <param name="info"></param>
    403     public void OnFailedToConnectToMasterServer(NetworkConnectionError info)
    404     {
    405         Debug.Log("Could not connect to master server: " + info);
    406     }
    407 
    408     // Called on the client when a connection attempt fails for some reason (Since v2.0)
    409     /// <summary>
    410     /// 当一个连接因为某些原因失败时在客户端调用。
    411     ///失败原因将作为 NetworkConnectionError 枚举传入。
    412     /// </summary>
    413     /// <param name="error"></param>
    414     public void OnFailedToConnect(NetworkConnectionError error)
    415     {
    416         Debug.Log("Could not connect to server: " + error);
    417     }
    418 
    419     // This function is called when the object becomes enabled and active (Since v1.0)
    420     /// <summary>
    421     /// 当对象变为可用或激活状态时此函数被调用。
    422     /// </summary>
    423     public void OnEnable()
    424     {
    425 
    426     }
    427 
    428     // Implement this OnDrawGizmos if you want to draw gizmos that are also pickable and always drawn (Since v1.0)
    429     /// <summary>
    430     /// 如果你想在物体被选中时绘制gizmos,执行这个函数。
    431     ///Gizmos只在物体被选择的时候绘制。Gizmos不能被点选,这可以使设置更容易。例如:一个爆炸脚本可以绘制一个球来显示爆炸半径
    432     /// </summary>
    433     public void OnDrawGizmosSelected()
    434     {
    435         float explosionRadius = 5.0F;
    436         // 被选中时显示爆炸半径.
    437         Gizmos.color = Color.white;
    438         Gizmos.DrawSphere(transform.position, explosionRadius);
    439 
    440     }
    441 
    442     // Implement this OnDrawGizmosSelected if you want to draw gizmos only if the object is selected (Since v1.0)
    443     /// <summary>
    444     /// 如果你想绘制可被点选的gizmos,执行这个函数。
    445     ///这允许你在场景中快速选择重要的物体。
    446     ///注意: OnDrawGizmos使用相对鼠标坐标。
    447     /// </summary>
    448     public void OnDrawGizmos()
    449     {
    450         //在物体的位置绘制一个灯泡图标
    451         Gizmos.DrawIcon(transform.position, "Light Gizmo.tiff");
    452     }
    453 
    454     // Called on the client when the connection was lost or you disconnected from the server (Since v2.0)
    455     /// <summary>
    456     /// 当失去连接或从服务器端断开时在客户端调用。
    457     /// </summary>
    458     /// <param name="info">网络中断</param>
    459     public void OnDisconnectedFromServer(NetworkDisconnection info)
    460     {
    461         Debug.Log("Disconnected from server: " + info);
    462     }
    463 
    464     // This function is called when the behaviour becomes disabled or inactive (Since v1.0)
    465     /// <summary>
    466     /// 当可编写脚本对象超出范围时调用这个函数。
    467     ///当物体被销毁也将被调用并且可以使用任何清除代码。当编译完成以后重新加载脚本时,OnDisable将被调用,随后脚本已经加载之后,OnEnable被调用。
    468     ///OnDisable不能作为一个协同程序。
    469     /// </summary>
    470     public void OnDisable()
    471     {
    472 
    473     }
    474 
    475     // This function is called when the MonoBehaviour will be destroyed (Since v3.2)
    476     /// <summary>
    477     /// 当MonoBehaviour将被销毁时,这个函数被调用。
    478     ///OnDestroy只会在预先已经被激活的游戏物体上被调用。
    479     ///OnDestroy不能用于协同程序。
    480     /// </summary>
    481     public void OnDestroy()
    482     {
    483 
    484     }
    485 
    486     // OnControllerColliderHit is called when the controller hits a collider while performing a Move (Since v2.0)
    487     /// <summary>
    488     /// 在移动的时,当controller碰撞到collider时OnControllerColliderHit被调用。
    489     /// 它可以用来在角色碰到物体时推开物体。
    490     /// </summary>
    491     /// <param name="hit">控制碰撞器碰撞</param>
    492     public void OnControllerColliderHit(ControllerColliderHit hit)
    493     {
    494         Rigidbody body = hit.collider.attachedRigidbody;
    495         // 没有刚体
    496         if (body == null || body.isKinematic)
    497             return;
    498         // 不推开我们身后的物体
    499         if (hit.moveDirection.y < -0.3F)
    500             return;
    501 
    502         Vector3 pushDir = new Vector3(hit.moveDirection.x, 0, hit.moveDirection.z);
    503         // 如果知道角色移动的速度,你可以用它乘以推动速度(pushPower)
    504         float pushPower = 2.0F;
    505         body.velocity = pushDir * pushPower;
    506 
    507     }
    508 
    509     // Called on the client when you have successfully connected to a server (Since v2.0)
    510     /// <summary>
    511     /// 当你成功连接到服务器时,在客户端调用。
    512     /// </summary>
    513     public void OnConnectedToServer()
    514     {
    515         Debug.Log("Connected to server");
    516     }
    517 
    518     // OnCollisionStay2D is called once per frame for every collider2D/rigidbody2D that is touching rigidbody2D/collider2D (2D physics only). (Since v4.3)
    519     public void OnCollisionStay2D(Collision2D coll)
    520     {
    521 
    522     }
    523 
    524     // OnCollisionStay is called once per frame for every collider/rigidbody that is touching rigidbody/collider (Since v1.0)
    525     /// <summary>
    526     /// 当此collider/rigidbody触发另一个rigidbody/collider时,OnCollisionStay将会在每一帧被调用。
    527     /// 相对于OnTriggerExit,OnCollisionExit传递的是Collision类而不是Collider。
    528     /// Collision包含接触点,碰撞速度等细节。如果在函数中不使用碰撞信息,省略collisionInfo参数以避免不必要的运算.注意如果碰撞体附加了一个非动力学刚体,只发送碰撞事件。
    529     /// OnCollisionStay 可以被用作协同程序,在函数中调用yield语句。
    530     /// </summary>
    531     /// <param name="collisionInfo"></param>
    532     public void OnCollisionStay(Collision collisionInfo)
    533     {
    534         //eg:
    535         // 绘制所有接触点和法线
    536         foreach (ContactPoint contact in collisionInfo.contacts)
    537         {
    538             Debug.DrawRay(contact.point, contact.normal, Color.white);
    539         }
    540 
    541     }
    542 
    543     // OnCollisionExit2D is called when this collider2D/rigidbody2D has stopped touching another rigidbody2D/collider2D (2D physics only). (Since v4.3)
    544     //碰撞停止时候开始触发 仅用于2D物体
    545     public void OnCollisionExit2D(Collision2D coll)
    546     {
    547 
    548     }
    549 
    550     // OnCollisionExit is called when this collider/rigidbody has stopped touching another rigidbody/collider (Since v1.0)
    551     /// <summary>
    552     /// 此collider/rigidbody停止触发另一个rigidbody/collider时,OnCollisionExit将被调用。(即:碰撞停止)
    553     /// 相对于OnTriggerExit,OnCollisionExit传递的是Collision类而不是Collider。
    554     /// Collision包含接触点,碰撞速度等细节。如果在函数中不使用碰撞信息,省略collisionInfo参数以避免不必要的运算.注意如果碰撞体附加了一个非动力学刚体,只发送碰撞事件。
    555     /// OnCollisionExit 可以被用作协同程序,在函数中调用yield语句。
    556     /// </summary>
    557     /// <param name="collision"></param>
    558     public void OnCollisionExit(Collision collision)
    559     {
    560 
    561     }
    562 
    563     // OnCollisionEnter2D is called when this collider2D/rigidbody2D has begun touching another rigidbody2D/collider2D (2D physics only). (Since v4.3)
    564     //当两个物体开始碰撞到另一个物体时候触发 仅用于2D物体
    565     public void OnCollisionEnter2D(Collision2D coll)
    566     {
    567 
    568     }
    569 
    570     // OnCollisionEnter is called when this collider/rigidbody has begun touching another rigidbody/collider (Since v1.0)
    571     /// <summary>
    572     /// 当此collider/rigidbody触发另一个rigidbody/collider时,OnCollisionEnter将被调用。(即:碰撞开始)
    573     /// 相对于OnTriggerEnter,OnCollisionEnter传递的是Collision类而不是Collider。
    574     /// Collision包含接触点,碰撞速度等细节。如果在函数中不使用碰撞信息,省略collisionInfo参数以避免不必要的运算。注意如果碰撞体附加了一个非动力学刚体,只发送碰撞事件。
    575     /// OnCollisionEnter可以被用作协同程序,在函数中调用yield语句。
    576     /// </summary>
    577     /// <param name="collision">碰撞的碰撞器</param>
    578     public void OnCollisionEnter(Collision collision)
    579     {
    580         // 如果碰撞体有较大冲击则。。。。。
    581         //relativeVelocity:两个碰撞物体的相对线性速度(只读)。  magnitude:大小值
    582         if (collision.relativeVelocity.magnitude > 2)
    583         {
    584             //Dosomeing
    585         }
    586     }
    587 
    588     // OnBecameInvisible is called when the renderer is no longer visible by any camera (Since v1.0)
    589     /// <summary>
    590     /// 当renderer(渲染器)在任何相机上都不可见时调用OnBecameInvisible。
    591     /// 这个消息发送到所有附在渲染器的脚本上。 OnBecameVisible 和 OnBecameInvisible可以用于只需要在物体可见时才进行的计算。
    592     /// OnBecameVisible可以被用作协同程序,在函数中调用yield语句。当在编辑器中运行时,场景面板相机也会导致这个函数被调用。
    593     /// </summary>
    594     public void OnBecameInvisible()
    595     {
    596 
    597     }
    598 
    599     // OnBecameVisible is called when the renderer became visible by any camera (Since v1.0)
    600     /// <summary>
    601     /// 当renderer(渲染器)在任何相机上可见时调用OnBecameVisible。
    602     /// 这个消息发送到所有附在渲染器的脚本上。 OnBecameVisible 和 OnBecameInvisible可以用于只需要在物体可见时才进行的计算。
    603     /// OnBecameVisible可以被用作协同程序,在函数中调用yield语句。当在编辑器中运行时,场景面板相机也会导致这个函数被调用。
    604     /// </summary>
    605     public void OnBecameVisible()
    606     {
    607 
    608     }
    609 
    610 
    611 
    612     // If OnAudioFilterRead is implemented, Unity will insert a custom filter into the audio DSP chain (Since v3.5)
    613     public void OnAudioFilterRead(int channels, float[] data)
    614     {
    615 
    616     }
    617 
    618     // Sent to all game objects before the application is quit (Since v1.0)
    619     /// <summary>
    620     /// 在应用退出之前发送给所有的游戏物体。
    621     /// 当用户停止运行模式时在编辑器中调用。当web被关闭时在网页播放器中被调用。
    622     /// </summary>
    623     public void OnApplicationQuit()
    624     {
    625 
    626     }
    627 
    628     // Sent to all game objects when the player pauses (Since v1.0)
    629     /// <summary>
    630     /// 当玩家暂停时发送到所有的游戏物体。
    631     ///OnApplicationPause 可以作为协同程序,在函数中使用yield语句即可。
    632     /// </summary>
    633     /// <param name="pause"></param>
    634     public void OnApplicationPause(bool pause)
    635     {
    636 
    637     }
    638 
    639     // Sent to all game objects when the player gets or looses focus (Since v3.0)
    640     /// <summary>
    641     /// 当玩家获得或失去焦点时发送给所有游戏物体。
    642     ///OnApplicationFocus 可以作为协同程序,在函数中使用yield语句即可。
    643     /// </summary>
    644     /// <param name="focus"></param>
    645     public void OnApplicationFocus(bool focus)
    646     {
    647 
    648     }
    649 
    650     // This callback will be invoked at each frame after the state machines and the animations have been evaluated, but before OnAnimatorIK (Since v4.0)
    651     public void OnAnimatorMove()
    652     {
    653 
    654     }
    655 
    656     // Callback for setting up animation IK (inverse kinematics) (Since v4.0)
    657     public void OnAnimatorIK(int layerIndex)
    658     {
    659 
    660     }
    661 
    662     // LateUpdate is called every frame, if the Behaviour is enabled (Since v1.0)
    663     /// <summary>
    664     /// 当Behaviour启用时,其LateUpdate在每一帧被调用。
    665     /// LateUpdate是在所有Update函数调用后被调用。这可用于调整脚本执行顺序。例如:当物体在Update里移动时,跟随物体的相机可以在LateUpdate里实现。
    666     /// </summary>
    667     public void LateUpdate()
    668     {
    669 
    670     }
    671 
    672 
    673     /// <summary>
    674     /// This function is called every fixed framerate frame, if the MonoBehaviour is enabled (Since v1.0)
    675     /// 当MonoBehaviour启用时,其 FixedUpdate 在每一帧被调用。
    676     /// 每固定帧绘制时执行一次,和update不同的是FixedUpdate是渲染帧执行,
    677     /// 如果你的渲染效率低下的时候FixedUpdate调用次数就会跟着下降。FixedUpdate比较适用于物理引擎的计算,因为是跟每帧渲染有关。Update就比较适合做控制。
    678     /// 处理Rigidbody时,需要用FixedUpdate代替Update。例如:给刚体加一个作用力时,你必须应用作用力在FixedUpdate里的固定帧,而不是Update中的帧。(两者帧长不同)
    679     /// </summary>
    680     public void FixedUpdate()
    681     {
    682 
    683     }
    684 
    685 
    686     /***********************
    687      * 
    688      * 以下为MonoBehaviour下的方法
    689      */
    690 
    691 
    692     /// <summary>
    693     /// 取消这个MonoBehaviour上的所有调用。
    694     /// </summary>
    695     public void CancelInvokes()
    696     {
    697 
    698     }
    699 
    700     /// <summary>
    701     /// 在time秒调用methodName方法;简单说,根据时间调用指定方法名的方法
    702     /// 从第一次调用开始,每隔repeatRate时间调用一次.
    703     /// </summary>
    704     /// <param name="methodName">方法名(不用带括号)</param>
    705     /// <param name="time">第一次调用方法(methodName)的时间</param>
    706     /// <param name="repeatRate">每次循环调用方法(methodName)间隔时间</param>
    707     public void InvokeRepeating(string methodName, float time, float repeatRate)
    708     {
    709 
    710     }
    711     /// <summary>
    712     /// 在time秒调用methodName方法;简单说,根据时间调用指定方法名的方法.
    713     /// </summary>
    714     /// <param name="methodName">方法名(不用带括号)</param>
    715     /// <param name="time">第一次调用方法(methodName)的时间</param>
    716     public void Invoke(string methodName, float time)
    717     {
    718 
    719     }
    720     /// <summary>
    721     /// 某指定函数是否在等候调用。
    722     /// </summary>
    723     /// <param name="methodName">函数名</param>
    724     public void IsInvoking(string methodName)
    725     {
    726     }
    727     /// <summary>
    728     /// 停止这个动作中名为methodName的所有协同程序。
    729     ///请注意只有StartCoroutine使用一个字符串方法名时才能用StopCoroutine停用之.
    730     /// </summary>
    731     /// <param name="methodName">方法名</param>
    732     public void StopCoroutine(string methodName)
    733     {
    734     }
    735     /// <summary>
    736     /// 停止所有动作的协同程序。
    737     /// </summary>
    738     public void StopCoroutine()
    739     {
    740 
    741     }
    742     /// <summary>
    743     /// 开始协同程序。
    744     /// 一个协同程序在执行过程中,可以在任意位置使用yield语句。yield的返回值控制何时恢复协同程序向下执行。
    745     /// 协同程序在对象自有帧执行过程中堪称优秀。协同程序在性能上没有更多的开销。StartCoroutine函数是立刻返回的,但是yield可以延迟结果。直到协同程序执行完毕。
    746     ///用javascript不需要添加StartCoroutine,编译器将会替你完成.但是在C#下,你必须调用StartCoroutine。
    747     /// </summary>
    748     /// <param name="routine"></param>
    749     public void StartCoroutine(IEnumerator routine)
    750     {
    751 
    752     }
    753 }
    复制代码
    展开全文
  • Unity3D入门 UnityAPI常用方法和类

    千次阅读 2018-08-17 20:26:50
    这里只列举了一部分,更多的看Scripting API using System.Collections; using System.Collections.Generic; using UnityEngine; public class API02Time : MonoBehaviour { // Use this for initialization ...

    时间函数:

    这里只列举了一部分,更多的看Scripting API

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class API02Time : MonoBehaviour {
    
    	// Use this for initialization
    	void Start () {
            Debug.Log("Time.deltaTime:" + Time.deltaTime);//完成最后一帧(只读)所需的时间(秒)
            Debug.Log("Time.fixedDeltaTime:" + Time.fixedDeltaTime);//执行物理和其他固定帧速率更新(如MonoBehaviour的FixedUpdate)的间隔,以秒为单位。
            Debug.Log("Time.fixedTime:" + Time.fixedTime);//最新的FixedUpdate启动时间(只读)。这是自游戏开始以来的时间单位为秒。
            Debug.Log("Time.frameCount:" + Time.frameCount);//已通过的帧总数(只读)。
            Debug.Log("Time.realtimeSinceStartup:" + Time.realtimeSinceStartup);//游戏开始后以秒为单位的实时时间(只读)。
            Debug.Log("Time.smoothDeltaTime:" + Time.smoothDeltaTime);//平滑的时间(只读)。
            Debug.Log("Time.time:" + Time.time);//此帧开头的时间(仅读)。这是自游戏开始以来的时间单位为秒。
            Debug.Log("Time.timeScale:" + Time.timeScale);//时间流逝的尺度。这可以用于慢动作效果。
            Debug.Log("Time.timeSinceLevelLoad:" + Time.timeSinceLevelLoad);//此帧已开始的时间(仅读)。这是自加载上一个级别以来的秒时间。
            Debug.Log("Time.unscaledTime:" + Time.unscaledTime);//此帧的时间尺度无关时间(只读)。这是自游戏开始以来的时间单位为秒。
    
            float time0 = Time.realtimeSinceStartup;
            for(int i = 0; i < 1000; i++)
            {
                Method();
            }
            float time1 = Time.realtimeSinceStartup;
            Debug.Log("总共耗时:" + (time1 - time0));
    	}
    
        void Method()
        {
            int i = 2;
            i *= 2;
            i *= 2;
        }
    }
    

    GameObject:

    创建物体的3种方法:
        1 构造方法    
        2 Instantiate   可以根据prefab 或者 另外一个游戏物体克隆
        3 CreatePrimitive  创建原始的几何体

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class API03GameObject : MonoBehaviour {
    
    	void Start () {
            // 1 第一种,构造方法
            GameObject go = new GameObject("Cube");
            // 2 第二种
            //根据prefab 
            //根据另外一个游戏物体
            GameObject.Instantiate(go);
            // 3 第三种 创建原始的几何体
            GameObject.CreatePrimitive(PrimitiveType.Plane);
            GameObject go2 = GameObject.CreatePrimitive(PrimitiveType.Cube);
    	}
    }
    

    AddComponent:添加组件,可以添加系统组件或者自定义的脚本

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class API03GameObject : MonoBehaviour {
    
    	void Start () {
            GameObject go = new GameObject("Cube");
            go.AddComponent<Rigidbody>();//添加系统组件
            go.AddComponent<API01EventFunction>();//添加自定义脚本
    	}
    }
    

    禁用和启用游戏物体:
        activeSelf:自身的激活状态
        activeInHierarchy:在Hierarchy的激活状态
        SetActive(bool):设置激活状态

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class API03GameObject : MonoBehaviour {
    
    	void Start () {
            GameObject go = new GameObject("Cube");
            Debug.Log(go.activeInHierarchy);
            go.SetActive(false);
            Debug.Log(go.activeInHierarchy);
    	}
    }
    

    游戏物体查找:

    Find:按名称查找GameObject并返回它
    FindObjectOfType:根据类型返回类型的第一个活动加载对象
    FindObjectsOfType:根据类型返回类型的所有活动加载对象的列表
    FindWithTag:根据标签返回一个活动的GameObject标记。如果没有找到GameObject,则返回NULL。
    FindGameObjectsWithTag:根据标签返回活动游戏对象标记的列表。如果没有找到GameObject,则返回空数组。
    transform.Find

    GameObject.Find和transform.Find的区别: 
    public static GameObject Find(string name); 
    适用于整个游戏场景中名字为name的所有处于活跃状态的游戏对象。如果在场景中有多个同名的活跃的游戏对象,在多次运行的时候,结果是固定的。

    public Transform Find(string name); 
    适用于查找游戏对象子对象名字为name的游戏对象,不管该游戏对象是否是激活状态,都可以找到。只能是游戏对象直接的子游戏对象。

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class API03GameObject : MonoBehaviour {
    
    	void Start () {
            Light light = FindObjectOfType<Light>();
            light.enabled = false;
            Transform[] ts = FindObjectsOfType<Transform>();
            foreach (Transform t in ts)
            {
                Debug.Log(t);
            }
    
            GameObject mainCamera = GameObject.Find("Main Camera");
            GameObject[] gos = GameObject.FindGameObjectsWithTag("MainCamera");
            GameObject gos1 = GameObject.FindGameObjectWithTag("Finish");
    	}
    }
    

    游戏物体间消息的发送:

        BroacastMessage:发送消息,向下传递(子)
        SendMessage:发送消息,需要目标target
        SendMessageUpwards:发送消息,向上传递(父)

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class API04Message : MonoBehaviour {
        private GameObject son;
    	
    	void Start () {
            son = GameObject.Find("Son");
    
            // 向下传递消息  
            // SendMessageOptions.DontRequireReceiver表示可以没有接收者
            //BroadcastMessage("Test", null, SendMessageOptions.DontRequireReceiver);
            // 广播消息
            son.SendMessage("Test", null, SendMessageOptions.DontRequireReceiver);
            // 向上传递消息	
            //SendMessageUpwards("Test", null, SendMessageOptions.DontRequireReceiver);
    	}
    	
    }
    

    查找游戏组件:

    GetComponet(s):查找单个(所有)游戏组件
    GetComponet(s)InChildren:查找children中单个(所有)游戏组件
    GetComponet(s)InParent:查找parent中单个(所有)游戏组件

    注意:如果是查找单个,若找到第一个后,直接返回,不再向后查找

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class API05GetComponent : MonoBehaviour {
    
    	void Start () {
            Light light = this.transform.GetComponent<Light>();
            light.color = Color.red;
    	}
    	
    }
    

    函数调用Invoke:

        Invoke:调用函数
        InvokeRepeating:重复调用
        CancelInvoke:取消调用
        IsInvoking:函数是否被调用

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class API06Invoke : MonoBehaviour {
    
    	void Start () {
            // Invoke(函数名,延迟时间)
            //Invoke("Attack", 3);	
    
            // InvokeRepeating(函数名,延迟时间,调用间隔)
            InvokeRepeating("Attack", 4, 2);
    
            // CancelInvoke(函数名)
            //CancelInvoke("Attack");
    	}
    
        void Update()
        {
            // 判断是否正在循环执行该函数
            bool res = IsInvoking("Attack");
            print(res);
        }
    
        void Attack()
        {
            Debug.Log("开始攻击");
        }
    }
    

    协同程序:

        定义使用IEnumerator
        返回使用yield
        调用使用StartCoroutine
        关闭使用StopCoroutine
                    StopAllCoroutine
        延迟几秒:yield return new WaitForSeconds(time);

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class API08Coroutine : MonoBehaviour
    {
        public GameObject cube;
        private IEnumerator ie;
    
        void Start()
        {
            print("协程开启前");
            StartCoroutine(ChangeColor());
            //协程方法开启后,会继续运行下面的代码,不会等协程方法运行结束才继续执行
            print("协程开启后");
        }
    
        void Update()
        {
            if (Input.GetKeyDown(KeyCode.Space))
            {
                ie = Fade();
                StartCoroutine(ie);
            }
            if (Input.GetKeyDown(KeyCode.S))
            {
                StopCoroutine(ie);
            }
        }
    
        IEnumerator Fade()
        {
            for (; ; )
            {
                Color color = cube.GetComponent<MeshRenderer>().material.color;
                Color newColor = Color.Lerp(color, Color.red, 0.02f);
                cube.GetComponent<MeshRenderer>().material.color = newColor;
                yield return new WaitForSeconds(0.02f);
                if (Mathf.Abs(Color.red.g - newColor.g) <= 0.01f)
                {
                    break;
                }
            }
        }
    
        IEnumerator ChangeColor()
        {
            print("hahaColor");
            yield return new WaitForSeconds(3);
            cube.GetComponent<MeshRenderer>().material.color = Color.blue;
            print("hahaColor");
            yield return null;
        }
    }
    

    鼠标相关事件函数:

        OnMouseDown:鼠标按下
        OnMouseUp:鼠标抬起
        OnMouseDrag:鼠标拖动
        OnMouseEnter:鼠标移上
        OnMouseExit:鼠标移开
        OnMouseOver:鼠标在物体上
        OnMouseUpAsButton:鼠标移开时触发,且移上和移开在同一物体上才会触发

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class API08OnMouseEventFunction : MonoBehaviour {
    
        void OnMouseDown()
        {
            print("Down"+gameObject);
        }
        void OnMouseUp()
        {
            print("up" + gameObject);
        }
        void OnMouseDrag()
        {
            print("Drag" + gameObject);
        }
        void OnMouseEnter()
        {
            print("Enter");
        }
        void OnMouseExit()
        {
            print("Exit");
        }
        void OnMouseOver()
        {
            print("Over");
        }
        void OnMouseUpAsButton()
        {
            print("Button" + gameObject);
        }
    	
    }
    

    Mathf类:

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class API09Mathf : MonoBehaviour {
    
        public Transform cube;
        public int a = 8;
        public int b = 20;
        public float t = 0;
        public float speed = 3;
        void Start()
        {
            /* 静态变量 */
            // 度数--->弧度
            print(Mathf.Deg2Rad);
            // 弧度--->度数
            print(Mathf.Rad2Deg);
            // 无穷大
            print(Mathf.Infinity);
            // 无穷小
            print(Mathf.NegativeInfinity);
            // 无穷小,接近0    
            print(Mathf.Epsilon);
            // π
            print(Mathf.PI);
    
    
            /* 静态方法 */
            // 向下取整
            Debug.Log(Mathf.Floor(10.2F));
            Debug.Log(Mathf.Floor(-10.2F));
    
            // 取得离value最近的2的某某次方数
            print(Mathf.ClosestPowerOfTwo(2));//2
            print(Mathf.ClosestPowerOfTwo(3));//4
            print(Mathf.ClosestPowerOfTwo(4));//4
            print(Mathf.ClosestPowerOfTwo(5));//4
            print(Mathf.ClosestPowerOfTwo(6));//8
            print(Mathf.ClosestPowerOfTwo(30));//32
    
            // 最大最小值
            print(Mathf.Max(1, 2, 5, 3, 10));//10
            print(Mathf.Min(1, 2, 5, 3, 10));//1
    
            // a的b次方
            print(Mathf.Pow(4, 3));//64 
            // 开平方根
            print(Mathf.Sqrt(3));//1.6
    
            cube.position = new Vector3(0, 0, 0);
        }
    
        void Update()
        {
            // Clamp(value,min,max):把一个值限定在一个范围之内
            cube.position = new Vector3(Mathf.Clamp(Time.time, 1.0F, 3.0F), 0, 0);
            Debug.Log(Mathf.Clamp(Time.time, 1.0F, 3.0F));
    
            // Lerp(a,b,t):插值运算,从a到b的距离s,每次运算到这个距离的t*s
            // Lerp(0,10,0.1)表示从0到10,每次运动剩余量的0.1,第一次运动到1,第二次运动到0.9...
            //print(Mathf.Lerp(a, b, t));
    
            float x = cube.position.x;
            //float newX = Mathf.Lerp(x, 10, Time.deltaTime);
            // MoveTowards(a,b,value):移动,从a到b,每次移动value
            float newX = Mathf.MoveTowards(x, 10, Time.deltaTime*speed);
            cube.position = new Vector3(newX, 0, 0);
    
            // PingPong(speed,distance):像乒乓一样来回运动,速度为speed,范围为0到distance
            print(Mathf.PingPong(t, 20));
            cube.position = new Vector3(5+Mathf.PingPong(Time.time*speed, 5), 0, 0);
        }
        
    }
    

    Input类:

        静态方法:
            GetKeyDown(KeyCode):按键按下
            GetKey(KeyCode):按键按下没松开
            GetKeyUp(KeyCode):按键松开
                KeyCode:键盘按键码,可以是键码(KeyCode.UP),也可以是名字("up")
            GetMouseButtonDown(0 or 1 or 2):鼠标按下
            GetMouseButton(0 or 1 or 2):鼠标按下没松开
            GetMouseButtonUp(0 or 1 or 2):鼠标松开
                0:左键    1:右键      2:中键
            GetButtonDown(Axis):虚拟按键按下
            GetButton(Axis):虚拟按键按下没松开
            GetButtonUp(Axis):虚拟按键松开
                Axis:虚拟轴名字
            GetAxis(Axis):返回值为float,上面的是返回bool
                cube.Translate(Vector3.right * Time.deltaTime * Input.GetAxis("Horizontal")*10);
        静态变量:
            anyKeyDown:任何键按下(鼠标+键盘)
            mousePosition:鼠标位置

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class API10Input : MonoBehaviour {
    
        void Update()
        {
            if (Input.GetKeyDown(KeyCode.Space))
            {
                print("KeyDOwn");
            }
            if (Input.GetKeyUp(KeyCode.Space))
            {
                print("KeyUp");
            }
            if (Input.GetKey(KeyCode.Space))
            {
                print("Key");
            }
    
    
            if (Input.GetMouseButton(0))
                Debug.Log("Pressed left click.");
    
    
            if (Input.GetMouseButtonDown(0))
                Debug.Log("Pressed left click.");
    
    
            if (Input.GetButtonDown("Horizontal"))
            {
                print("Horizontal Down");
            }
    
            // GetAxis:这样使用有加速减速效果,如果是速度改变等情况不会突变
            //this.transform.Translate(Vector3.right * Time.deltaTime * Input.GetAxis("Horizontal") * 10);
    
            //GetAxisRaw:没有加速减速效果,速度改变等情况直接突变
            this.transform.Translate(Vector3.right * Time.deltaTime * Input.GetAxisRaw("Horizontal") * 10);
    
    
            if (Input.anyKeyDown)
            {
                print("any key down");
            }
    
            print(Input.mousePosition);
    
        }
    }
    

    Input输入类之触摸事件:  推荐使用Easytouch插件

        Input.touches.Length:触摸点个数

        Input.touches[i]:获取第i个触摸点信息

        touch1.position:触摸点位置

        touch1.phase:触摸点状态

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class TouchTest : MonoBehaviour {
    
    	// Update is called once per frame
    	void Update () {
            //Debug.Log(Input.touches.Length);
            if (Input.touches.Length > 0)
            {
                Touch touch1 = Input.touches[0];
                //touch1.position;
                TouchPhase phase  = touch1.phase;
            }
    	}
    }
    

    Vector2

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class API11Vector2 : MonoBehaviour {
    
        void Start()
        {
            /* 静态变量 */
    
            // up,down,left,right,one,zero:分别表示点(0,1)(0,-1)(-1,0)(1,0)(1,1)(0,0)
            print(Vector2.down);
            print(Vector2.up);
            print(Vector2.left);
            print(Vector2.right);
            print(Vector2.one);
            print(Vector2.zero);
    
            // x,y:x坐标,y坐标(如果有一个向量Vector2 vec,也可以使用vec[0]和vec[1]来表示x和y坐标)
            Vector2 vec1 = new Vector2(3, 4);
            Debug.Log("x:" + vec1.x);
            Debug.Log("x:" + vec1[0]);
            Debug.Log("y:" + vec1.y);
            Debug.Log("x:" + vec1[1]);
    
            // magnitude:向量的长度
            Debug.Log(vec1.magnitude);
    
    		// sqrMagnitude:向量的长度的平方(即上面的没开根号前,如果只是用来比较的话,不需要开根号)
            Debug.Log(vec1.sqrMagnitude);
    
            // normalized:返回该向量的单位化向量(如果有一向量,返回一个新向量,方向不变,但长度变为1)
            Debug.Log(vec1.normalized);
    
    		// normalize:返回自身,自身被单位化
            vec1.Normalize();
            Debug.Log("x:" + vec1.x);
            Debug.Log("y:" + vec1.y);
    
            // 向量是结构体,值类型,需要整体赋值
            transform.position = new Vector3(3, 3, 3);
            Vector3 pos = transform.position;
            pos.x = 10;
            transform.position = pos;
    
    
            /* 静态方法 */
    
            // Angle(a,b):返回两个向量的夹角
            Vector2 a = new Vector2(2, 2);
            Vector2 b = new Vector2(3, 4);
            Debug.Log(Vector2.Angle(a, b));
    
            // ClampMagnitude(a,length):限定长度,如果a>length,将向量a按比例缩小到长度为length
            Debug.Log(Vector2.ClampMagnitude(b, 2));
    
            // Distance(a,b):返回两个向量(点)之间的距离
            Debug.Log(Vector2.Distance(a, b));
    
            // Lerp(a,b,x):在向量a,b之间取插值。最终值为(a.x + a.x * (b.x - a.x), a.y + a.y * (b.y - a.y))
            Debug.Log(Vector2.Lerp(a, b, 0.5f));
            Debug.Log(Vector2.LerpUnclamped(a, b, 0.5f));
    
            // Max,Min:返回两向量最大最小
            Debug.Log(Vector2.Max(a, b));
    
            // + - * /:向量之间可以加减,不能乘除,可以乘除普通数字
            Vector2 res = b - a;//1,2
            print(res);
            print(res * 10);
            print(res / 5);
            print(a + b);
            print(a == b);
    
        }
    
    
        public Vector2 a = new Vector2(2, 2);
        public Vector2 target = new Vector2(10, 3);
        void Update()
        {
            // MoveTowards(a,b,speed):从a到b,速度为speed
            a = Vector2.MoveTowards(a, target, Time.deltaTime);
        }
    
    }
    

    Random:随机数

        静态方法:
            Range(a,b):生成>=a且<b的随机数    若a和b都为整数,则生成整数
            InitState(seed):使用随机数种子初始化状态
                Random.InitState((int)System.DateTime.Now.Ticks);
        静态变量:
            value:生成0到1之间的小数,包括0和1   
            state:获取当前状态(即随机数种子)    
            rotation:获取随机四元数
            insideUnitCircle:在半径为1的圆内随机生成位置(2个点)
                transition.position = Random.insideUnitCircle * 5;  在半径为5的圆内随机生成位置
            insideUnitSphere:在半径为1的球内随机生成位置(3个点)
                cube.position = Random.insideUnitSphere * 5;

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class API12Random : MonoBehaviour {
    
        void Start()
        {
            Random.InitState((int)System.DateTime.Now.Ticks);
            print(Random.Range(4, 10));
            print(Random.Range(4, 5f));
    
        }
        void Update()
        {
            if (Input.GetKeyDown(KeyCode.Space))
            {
                print(Random.Range(4, 100));
                print((int)System.DateTime.Now.Ticks);
            }
            //cube.position = Random.insideUnitCircle * 5;
            this.transform.position = Random.insideUnitSphere * 5;
        }
    }
    

    四元数Quaternion

    一个物体的transform组件中,rotation是一个四元数

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class API13Quaternion : MonoBehaviour {
    
        void Start()
        {
            // rotation:四元数
    	    // eulerAngles:欧拉角,rotation中的x,y,z
            //this.transform.rotation = new Vector3(10, 0, 0);  错误,左边是四元数,右边是欧拉角
            this.transform.eulerAngles = new Vector3(10, 0, 0);
            print(this.transform.eulerAngles);
            print(this.transform.rotation);
    
    
            // Euler:将欧拉角转换为四元数
            // eulerAngles:将四元数转换为欧拉角
            this.transform.eulerAngles = new Vector3(45, 45, 45);
            this.transform.rotation = Quaternion.Euler(new Vector3(45, 45, 45));
            print(this.transform.rotation.eulerAngles);
        }
    
        public Transform player;
        public Transform enemy;
        void Update()
        {
            // LookRotation:控制Z轴的朝向,一般处理某个物体望向某个物体  案例:主角望向敌人
            // Lerp:插值,比Slerp快,但当角度太大的时候,没Slerp效果好
            // Slerp:插值         案例:主角缓慢望向敌人
            if (Input.GetKey(KeyCode.Space))
            {
                Vector3 dir = enemy.position - player.position;
                dir.y = 0;
                Quaternion target = Quaternion.LookRotation(dir);
                player.rotation = Quaternion.Lerp(player.rotation, target, Time.deltaTime);
            }
        }
    }
    

    刚体Rigibody

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class API14RigidbodyPosition : MonoBehaviour {
    
        public Rigidbody playerRgd;
        public Transform enemy;
        public int force = 10;
    
        void Update()
        {
            // position:可以使用刚体的position来改变位置,突然改变
            playerRgd.position = playerRgd.transform.position + Vector3.forward * Time.deltaTime * 10;
    
            // MovePosition(Vector3 position):移动到目标位置,有插值的改变
            playerRgd.MovePosition(playerRgd.transform.position + Vector3.forward * Time.deltaTime * 10);
    
            // rotation:可以使用刚体的rotation来控制旋转
            // MoveRotation:旋转,有插值的改变
            if (Input.GetKey(KeyCode.Space))
            {
                Vector3 dir = enemy.position - playerRgd.position;
                dir.y = 0;
                Quaternion target = Quaternion.LookRotation(dir);
                playerRgd.MoveRotation(Quaternion.Lerp(playerRgd.rotation, target, Time.deltaTime));
            }
    
            // AddForce:给物体添加一个力
            playerRgd.AddForce(Vector3.forward * force);
        }
    }
    

    Camera

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class API15Camera : MonoBehaviour {
    
        private Camera mainCamera;
    
        void Start()
        {
            // 获取摄像机
            //mainCamera= GameObject.Find("MainCamera").GetComponent<Camera>();
            mainCamera = Camera.main;
        }
    
        void Update()
        {
            // ScreenPointToRay:把鼠标点转换为射线
            Ray ray = mainCamera.ScreenPointToRay(Input.mousePosition);
    
            // 射线碰撞到的游戏物体
            RaycastHit hit;
            bool isCollider = Physics.Raycast(ray, out hit);  //射线检测
            // 如果碰撞到物体,输出物体名字
            if (isCollider)
            {
                Debug.Log(hit.collider);
            }
    
            Ray ray = mainCamera.ScreenPointToRay(new Vector3(200, 200, 0));
            Debug.DrawRay(ray.origin, ray.direction * 10, Color.yellow);
        }
    }
    

    Application类

    Application Datapath:

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class API16Application_xxxPath : MonoBehaviour {
        void Start()
        {
            // 数据路径,工程路径
            print(Application.dataPath);
            // 可以通过文件流读取的数据
            // 注:单独创建StreamingAssets文件夹,在此文件夹中的数据打包的时候不会进行处理
            print(Application.streamingAssetsPath);
            // 持久化数据
            print(Application.persistentDataPath);
            // 临时缓冲数据
            print(Application.temporaryCachePath);
        }
    }
    

    Application 常用:

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    using UnityEngine.SceneManagement;
    
    public class API17Application : MonoBehaviour {
    
        void Start()
        {
            print(Application.identifier);// 标识 
            print(Application.companyName);// 公司名
            print(Application.productName);// 产品名字
            print(Application.installerName);// 安装名
            print(Application.installMode);
            print(Application.isEditor);
            print(Application.isFocused);
            print(Application.isMobilePlatform);
            print(Application.isPlaying);
            print(Application.isWebPlayer);
            print(Application.platform);
            print(Application.unityVersion);
            print(Application.version);
            print(Application.runInBackground);
    
            Application.Quit();// 退出应用
            Application.OpenURL("www.sikiedu.com");// 打开一个网址
            //Application.CaptureScreenshot("游戏截图");  // 弃用
            UnityEngine.ScreenCapture.CaptureScreenshot("游戏截图");//  截图,参数是保存截图的名字
    
        }
    
        void Update()
        {
            if (Input.GetKeyDown(KeyCode.Space))
            {
                //UnityEditor.EditorApplication.isPlaying = false;
                SceneManager.LoadScene(1);
            }
        }
    }
    

    场景管理SceneManager:

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    using UnityEngine.SceneManagement;
    
    public class API18SceneManager : MonoBehaviour {
    
        void Start()
        {
            // 当前加载的场景数量
            print(SceneManager.sceneCount);
            // 在BuildSetting里的场景数量
            print(SceneManager.sceneCountInBuildSettings);
            // 得到当前场景  通过name可以获得名字
            print(SceneManager.GetActiveScene().name);
            // 根据index获取场景,注意index只能是已经加载场景的
            print(SceneManager.GetSceneAt(0).name);
    
            SceneManager.activeSceneChanged += OnActiveSceneChanged;
            SceneManager.sceneLoaded += OnSceneLoaded;
        }
    
        // 场景改变事件(要卸载的场景,要加载的场景)
        void OnActiveSceneChanged(Scene a, Scene b)
        {
            print(a.name);
            print(b.name);
        }
    
        // 加载场景(加载的场景,加载的模式)
        void OnSceneLoaded(Scene a, LoadSceneMode mode)
        {
            print(a.name + "" + mode);
        }
    
        void Update()
        {
    
            if (Input.GetKeyDown(KeyCode.Space))
            {
                // LoadScene:加载场景,可以通过名字或者序号加载 
                // LoadSceneAsync:异步加载,可以取得加载场景的进度
                //SceneManager.LoadScene(1);
                //SceneManager.LoadScene("02 - MenuScene");
                print(SceneManager.GetSceneByName("02 - MenuScene").buildIndex);
                SceneManager.LoadScene(1);
            }
    
        }
    }
    

    射线检测:

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class Player : MonoBehaviour {
    	
    	void Update () {
    		// 创建一条射线:new Ray(起点,方向);
            Ray ray = new Ray(transform.position+transform.forward, transform.forward);
    
    		// 检测碰撞:返回值表示是否碰撞到物体    Physics.Raycast(射线[, 距离]);
            //bool isCollider = Physics.Raycast(ray);    	//无限距离
            //bool isCollider = Physics.Raycast(ray, 1);    //检测1米距离
    		
    		// 检测碰撞到哪个物体:  Physics.Raycast(射线, 碰撞信息);
            RaycastHit hit;
            //bool isCollider = Physics.Raycast(ray, out hit);
    		
    		// 碰撞检测时只检测某些层:  Physics.Raycast(射线, 距离, 检测层);
    		// Mathf.Infinity表示无限距
            bool isCollider = Physics.Raycast(ray, Mathf.Infinity, LayerMask.GetMask("Enemy1", "Enemy2", "UI"));
            
            Debug.Log(isCollider);
            //Debug.Log(hit.collider);
            //Debug.Log(hit.point);
    		
    		//注:射线检测的重载方法有很多,不止以上几种
    		//注:如果是2D的射线检测,要使用Physics2D.Raycast(),使用时要保证物体添加了2D碰撞器 
    		//注:上面的方法只会检测碰撞到的第一个物体,如果要检测碰撞到的所有物体,使用RaycastAll(),返回RaycastHit数组 
        }
    }
    

    UGUI事件监听:3种方法

    1 拖拽:

    2 代码添加:

    using System.Collections;
    using System.Collections.Generic;
    using System;
    using UnityEngine;
    using UnityEngine.UI;
    
    public class UIEventManager : MonoBehaviour {
    
        public GameObject btnGameObject;
        public GameObject sliderGameObject;
        public GameObject dropDownGameObject;
        public GameObject toggleGameObject;
    
    	// Use this for initialization
    	void Start () {
            btnGameObject.GetComponent<Button>().onClick.AddListener(this.ButtonOnClick);
            sliderGameObject.GetComponent<Slider>().onValueChanged.AddListener(this.OnSliderChanged);
            dropDownGameObject.GetComponent<Dropdown>().onValueChanged.AddListener(this.OnDropDownChanged);
            toggleGameObject.GetComponent<Toggle>().onValueChanged.AddListener(this.OnToggleChanged);
        }
    
        void ButtonOnClick()
        {
            Debug.Log("ButtonOnClick");
        }
        void OnSliderChanged(float value)
        {
            Debug.Log("SliderChanged:" + value);
        }
        void OnDropDownChanged(Int32 value)
        {
            Debug.Log("DropDownChanged:" + value);
        }
        void OnToggleChanged(bool value)
        {
            Debug.Log("ToggleChanged:" + value);
        }
    
        // Update is called once per frame
        void Update () {
    		
    	}
    }
    

    3 通过实现接口:通过这种方式,只能监听当前UGUI组件

        鼠标相关事件或拖拽相关事件的实现

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    using UnityEngine.UI;
    using UnityEngine.EventSystems;
    using System;
    //interface
    public class UIEventManager2 : MonoBehaviour//, IPointerDownHandler,IPointerClickHandler,IPointerUpHandler,IPointerEnterHandler,IPointerExitHandler
        ,IBeginDragHandler,IDragHandler,IEndDragHandler,IDropHandler
    {
        public void OnBeginDrag(PointerEventData eventData)
        {
            Debug.Log("OnBeginDrag");
        }
    
        public void OnDrag(PointerEventData eventData)
        {
            Debug.Log("OnDrag");
        }
    
        public void OnDrop(PointerEventData eventData)
        {
            Debug.Log("OnDrop");
        }
    
        public void OnEndDrag(PointerEventData eventData)
        {
            Debug.Log("OnEndDrag");
        }
    
        public void OnPointerClick(PointerEventData eventData)
        {
            Debug.Log("OnPointerClick");
        }
    
        public void OnPointerDown(PointerEventData eventData)
        {
            Debug.Log("OnPointerDown");
        }
    
        public void OnPointerEnter(PointerEventData eventData)
        {
            Debug.Log("OnPointerEnter");
        }
    
        public void OnPointerExit(PointerEventData eventData)
        {
            Debug.Log("OnPointerExit");
        }
    
        public void OnPointerUp(PointerEventData eventData)
        {
            Debug.Log("OnPointerUp");
        }
    }
    

    WWW类:下载专用

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class WWWTest : MonoBehaviour {
    
        public string url = "https://ss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=2622066562,1466948874&fm=27&gp=0.jpg";
        IEnumerator Start()
        {
            WWW www = new WWW(url);
            yield return www;
            Renderer renderer = GetComponent<Renderer>();
            renderer.material.mainTexture = www.texture;
        }
    }
    

    角色控制器CharacterController:物体需要添加Character Controller组件

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class PlayerCC : MonoBehaviour {
    
        public float speed = 3;
        private CharacterController cc;
    
    	// Use this for initialization
    	void Start () {
            cc = GetComponent<CharacterController>();
            
    	}
    	
    	void Update () {
            float h = Input.GetAxis("Horizontal");
            float v = Input.GetAxis("Vertical");
            cc.SimpleMove(new Vector3(h, 0, v) * speed);//有重力效果
            //cc.Move(new Vector3(h, 0, v) * speed * Time.deltaTime);//无重力效果
            Debug.Log(cc.isGrounded);//是否在地面
    	}
        private void OnControllerColliderHit(ControllerColliderHit hit)//自带的检测碰撞事件
        {
            Debug.Log(hit.collider);
        }
    }
    

    网格Mesh和材质Material

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class MeshAndMat : MonoBehaviour {
        public Mesh mesh;
        private Material mat;
    
    	void Start () {
            //GetComponent<MeshFilter>().sharedMesh = mesh;//改变网格,样子跟着变
            //Debug.Log(GetComponent<MeshFilter>().mesh == mesh);//改变网格,样子不变
            mat = GetComponent<MeshRenderer>().material;
            
    	}
    	
    	void Update () {
            mat.color = Color.Lerp(mat.color, Color.red, Time.deltaTime);//改变材质颜色
    	}
    }
    

    unity 4.x   5.x   2017的异同

        GetComponent<Rigidbody2D>() 代替 rigidbody2D
        GetComponent<Rigidbody>() 代替 rigidbody
        GetComponent<AudioSource>() 代替 audio

        Unity 5.3:
        ParticleSystem main = smokePuff.GetComponent<ParticleSystem>();
        main.startColor
        Unity 5.5+:
        ParticleSystem.MainModule main = smokePuff.GetComponent<ParticleSystem>().main;
        main.startColor

        SceneManagement 代替 Application

        OnLevelWasLoaded() 在 Unity 5中被弃用了,使用OnSceneLoaded代替

    		public class UnityAPIChange : MonoBehaviour {
    			private Rigidbody rgd;
    			void Start () {
    				rgd = GetComponent<Rigidbody>();
    				SceneManager.sceneLoaded += this.OnSceneLoaded;
    			}
    			void OnSceneLoaded(Scene scene, LoadSceneMode mode)
    			{
    
    			}
    			
    			void Update () {
    				//rigidbody.AddForce(Vector3.one);
    				//rgd.AddForce(Vector3.one);
    				//audio.Play();//弃用的
    				//GetComponent<AudioSource>().Play();
    				//GetComponent<Rigidbody2D>();
    
    				//GetComponent<MeshRenderer>();
    
    				//Application.LoadLevel("Level2");
    				SceneManager.LoadScene("Scene2");
    				Scene scene = SceneManager.GetActiveScene();
    				SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex);
    			}
    
    			private void OnLevelWasLoaded(int level)  弃用
    			{
    				
    			}
    		}

     

    展开全文
  • Unity3D常用API

    千次阅读 2017-08-13 14:36:26
    Unity3D常用API总结一. MonoBehaviour类及查询API MonoBehaviour是每个脚本的基类. MonoBehaviour常用方法及调用顺序 //最开始调用,做一些初始化工作。建议少用,此刻物体可能还没有实例化出来,会影响程序执行...

    Unity3D常用API总结

    一. MonoBehaviour类及查询API

    MonoBehaviour是每个脚本的基类.

    MonoBehaviour常用方法及调用顺序

       //最开始调用,做一些初始化工作。建议少用,此刻物体可能还没有实例化出来,会影响程序执行顺序。
        void Awake(){}
        // 不是很紧急的初始化,一般放在Start里面来做。仅在Update函数第一次被调用前调用。
        void Start(){}
        //用户点击检视面板的Reset按钮或者首次添加该组件时被调用。此函数只在编辑模式下被调用。Reset最常用于在检视面板中给定一个最常用的默认值。
        void Reset(){}
        // 每一帧调用一次,帧间隔时间有可能改变。
        void Update(){}
        //以相同时间间隔调用,用在力学更新效果中。执行在Update之前。
        void FixedUpdate(){}
        //在Update和FixedUpdate调用之后调用。一般人物的移动放在Update中,而摄像机的跟进变化放到FixedUpdate中。确保两个独立,一前一后,不产生错误。
        void LateUpdate(){}
    
        //On开头的方法,是由其他事件触发调用的。
        //物体被删除时调用
        void OnDestroy(){}
        //物体启用时被调用
        void OnEnable(){}
        //物体被禁用时调用
        void OnDisable(){}
        //这个函数会每帧调用好几次(每个事件一次),GUI显示函数只能在OnGUI中调用
        void OnGUI(){}

    下图是单个脚本内部方法的调用顺序:
    这里写图片描述

    查询API:游戏蛮牛Unity3D-API

    二. Input类及脚本字段属性在检视面板中的运用

    输入系统的接口.
    getaxis、getkey、getbutton、getjoystick等函数。

    为了提高输入方式在代码中的效率,推荐用GetButton()方法,而不是GetKey().GetButton根据不同的设备进行对应的按键输入,比如手柄,PC,手机 etc.

    Unity中定制按钮的方式
    Edit–>project setting–>Input
    具体按键设定规则见:Unity圣典Input输入

    GetKey()、GetKeyDown()、GetKeyUp()方法:

        // 每一帧调用一次,帧间隔时间有可能改变。
        void Update()
        {
            //KeyCode为枚举类
            //GetKey方法:只要按下就会执行 直到不按 执行不止一次
            Input.GetKey(KeyCode.A);
            //GetKeyDown:按下按键执行 执行一次
            Input.GetKeyDown(KeyCode.A);
            //GetKeyDown:按下后松开按键执行 执行一次
            Input.GetKeyUp(KeyCode.A);
            //以上方法返回布尔值
        }

    GetButton()、GetButtonDown()、GetButtonUp()方法:

        // 每一帧调用一次,帧间隔时间有可能改变。
        void Update()
        {
            //GetButton方法括号中的值为buttonName(按钮别称) 可在相关文档中查阅
            //GetButton方法:只要按下就会执行 直到不按 执行不止一次
            Input.GetButton("Jump");
            //GetButtonDown:按下按键执行 执行一次
            Input.GetButtonDown("Jump");
            //GetButtonDown:按下后松开按键执行 执行一次
            Input.GetButtonUp("Jump");
            //以上方法返回布尔值
        }

    GetAxis() 获取轴

    根据坐标轴名称返回虚拟坐标系中的值。
    使用控制器和键盘输入时此值范围在-1到1之间。如果坐标轴设置为鼠标运动增量,鼠标增量乘以坐标轴灵敏度的范围将不是-1到1 。

    C#脚本:

    // A very simplistic car driving on the x-z plane.
    // 一个十分简单的在x-z平面的驾车例子
    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public float speed = 10.0F;//移动速度
        public float rotationSpeed = 100.0F;//旋转速度
    
        void Update() {
            // Get the horizontal and vertical axis.
            //获取横向和纵向坐标轴
            // By default they are mapped to the arrow keys.
            //默认情况下他们关联到方向键上
            // The value is in the range -1 to 1
            //值的范围是在-1到1之间
            float translation = Input.GetAxis("Vertical") * speed;
            float rotation = Input.GetAxis("Horizontal") * rotationSpeed;
    
            // Make it move 10 meters per second instead of 10 meters per frame...
            // 使它每帧移动10米变为每秒移动10米...
            translation *= Time.deltaTime;
            rotation *= Time.deltaTime;
    
            // Move translation along the object's z-axis
            //沿着z轴平移对象
            transform.Translate(0, 0, translation);
    
            // Rotate around our y-axis
            //以我们的y轴为中心旋转
            transform.Rotate(0, rotation, 0);
        }
    }
    // Performs a mouse look.
    //执行一个鼠标观察
    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public float horizontalSpeed = 2.0F;
        public float verticalSpeed = 2.0F;
        void Update() {
            // Get the mouse delta. This is not in the range -1...1
            //获取鼠标增量,范围不在-1...1
            float h = horizontalSpeed * Input.GetAxis("Mouse X");
            float v = verticalSpeed * Input.GetAxis("Mouse Y");
            transform.Rotate(v, h, 0);
        }
    }

    GetJoystickNames() 获取控制杆名称列表

    返回一个用来描述已连接的控制杆的字符串集合。
    它可以用在用户输入设置界面 –这样,你就可以把显示的标签”Joystick 1”换成意义更明确的名字像”Logitech WingMan”,读取不同控制器的值,你需要分别为各个控制器的数字指定指方向轴如果你想将其使用在输入设置中。

    C#脚本:

    // Prints a joystick name if movement is detected.
    //如果检测到移动就输出一个控制杆名称
    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Update() {
            // requires you to set up axes "Joy0X" - "Joy3X" and "Joy0Y" - "Joy3Y" in the Input Manger
            //你需要在输入管理器中设置方向轴"Joy0X" - "Joy3X""Joy0Y" - "Joy3Y"
            int i = 0;
            while (i < 4) {
                if (Mathf.Abs(Input.GetAxis("Joy" + i + "X")) > 0.2F || Mathf.Abs(Input.GetAxis("Joy" + i + "Y")) > 0.2F)
                    Debug.Log(Input.GetJoystickNames()[i] + " is moved");
    
                i++;
            }
        }
    }

    脚本字段属性在检视面板中的运用:

    // Prints a joystick name if movement is detected.
    //如果检测到移动就输出一个控制杆名称
    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        //public修饰的变量可以在检视面板中显示
        //private修饰的不能显示
    
        //可以显示的GameObject类型的数组 
        //在检视面板中有Size(数组大小)和Element(元素)两个属性
        public GameObject[] gameObject = new GameObject[10];
    
        //可以显示的一个Rigidbody类型的变量
        public Rigidbody rigidbody = new Rigidbody();
    
        //不能显示的string类型字符串
        private string NPCName = "Max";
    
        //可以显示的int类型数值
        public int Score = 11;
    
        //自动补全 在脚本中定义的初始值会在检视面板中显示
        public int Number { get; set; }
    
        void strat(){}
        void update(){}
    }

    三.Time类及单例模式实现

    常用Time.deltaTime

    在Update/LateUpdate中打印Time.deltaTime时间是不固定的,是一个动态变化值,是前两帧之间时间的差值。

    在FixedUpdate中打印Time.deltaTime时间是固定的。

    deltaTime() 增量时间

    以秒计算,完成最后一帧的时间(只读)。
    使用这个函数使和你的游戏帧速率无关。

    放在Update()函数中的代码是以帧来执行的.如果我们需要物体的移动以秒来执行.我们需要将物体移动的值乘以Time.deltaTime。

    如果你加或减一个每帧改变的值,你应该与Time.deltaTime相乘。当你乘以Time.deltaTime实际表示:每秒移动物体10米,而不是每帧10米。

    当从MonoBehaviour的FixedUpdate里调用时,返回固定帧速率增量时间(fixedDeltaTime)。

    请注意从OnGUI里你不应该依赖于Time.deltaTime,因为OnGUI可以在每帧被多次调用并且每个调用deltaTime将持有相同的值,直到下一帧再次更新。

    C#脚本:

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Update() {
            // Move the object 10 meters per second!
            //每秒移动物体10米
            float translation = Time.deltaTime * 10;
            transform.Translate(0, 0, translation);
        }
    }

    单例模式singleton

    单例仅允许被实例一次,这就保证了他在各个程序模块间的唯一性。

    //一般使用单例模式时,类名可能为GameManager
    //通常用于控制游戏流程 哪个关卡 哪一步 角色信息的记录
    //排行榜 积分表等
    //在游戏中,单例模式一般在数据的保存和读取时用到
    private static ModelLocator instance;
    public static ModelLocator getInstance{
        get{
            if(instance==null){
                instance=new ModelLocator();
            }
            return instance;
        }
    }

    详细的Unity中单例模式的应用,百度”Unity中的单例模式”
    二周目的时候详细补充在这

    四.GameObject类和对象,多种查找GO的方法

    gameObject(g小写)代表当前脚本挂载的游戏对象本身。
    若使用this.xxx的话调用的是脚本本身而不是游戏对象

    GameObject(G大写)代表游戏对象类。

    查找GO并赋值Find族函数:

    private GameObject go;

    go = GameObject.Find(“Cube”);//根据名字查找对象

    go = GameObject.FindGameObjectWithTag(string tag);//根据标签查找

    go.activeSelf 游戏物体是否被激活(true or false)

    go.activeInHierarchy 游戏物体所处层级的父级是否被激活(true or false)


    理解游戏组件和游戏对象的关系

    创建一个cube,并不是创建一个cube对象,而是创建了挂载着filter和renderer组件的对象


    五.Destroy方法和Transform对象(包括对象移动)

    Destroy方法:

    销毁一个游戏物体。
    Destroy(go);
    Destroy(go, 3);//等待3s销毁

    Transform对象:

    位置transform.position(注意是小写t,是monobehaviour类中的默认字段,表示当前脚本挂在的游戏物体的transform信息)

    旋转transform.rotation
    缩放transform.scale
    向量及运算 Vector3

    在Unity中为左手坐标系
    这里写图片描述

    移动对象:

    Transform.Translate

    Transform.Rotate

    transform.position.x获取x轴坐标

    Mathf.PingPong 乒乓
    让数值t在 0到length之间往返。t值永远不会大于length的值,也永远不会小于0。
    返回值将在0和length之间来回移动。

    //Mathf.PingPong 乒乓 例子
    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Update() {
        // Set the x position to loop between 0 and 3
        //设置x位置循环在0和3之间
            transform.position = new Vector3(Mathf.PingPong(Time.time, 3), transform.position.y, transform.position.z);
        }
    }

    六.Lerp插值运算

    插值运算:位置Vector3.Lerp 旋转Vector3.Slerp
    Quaternion targetrotation = Quaternion.LookRotation(player.position - transform.position);
    //根据初始和目标位置计算出对应的旋转角度

    插值运算不仅仅可以作为位置、旋转、缩放等计算,还可以做为灯光亮度等的差值计算,也就是说只要是从一个确定状态渐进过渡到另一个确定状态的计算,都可以用到插值运算。
    位置插值:三维向量
    Vector3 targetpostion = player.position + new Vector3(0, 2.42f, -2.42f);
    transform.position = Vector3.Lerp(transform.position, targetpostion, speed * Time.deltaTime);
    旋转插值:三维角度
    Quaternion targetrotation = Quaternion.LookRotation(player.position - transform.position);
    transform.rotation = Quaternion.Slerp(transform.rotation, targetrotation, speed * Time.deltaTime);
    灯光亮度插值:浮点值
    public float newIntensity = 5;
    light.intensity = Mathf.Lerp(light.intensity, newIntensity, speed * Time.deltaTime);
    //light.intensity位当前灯光的值
    颜色插值:
    Color.Lerp(currentColor, newColor, speed * Time.deltaTime);
    其他比如Material.Lerp、Mathf.InverseLerp等,可以通过查手册了解。

    七.Instantiate实例化prefab对象

    所有的C#对象都是继承于object类,包括int、float这些函数类型,当然也包括Monobehaviour、GameObject这些类。

    static function Instantiate(original: Object, position: Vector3, rotation: Quaternion): Object;
    
    public GameObject Spawn() 
    {
        /* 生成prefab的实例化,因为默认是object类型,所以需要强转为GameObject */
        return GameObject.Instantiate(prefab, transform.position, transform.rotation) as GameObject;
    }

    其他方法:
    GameObject.GetComponent:通过游戏物体获取其组件
    CharacterController cc = this.GetComponent();
    Animator animator = this.GetComponent();
    Component.GetComponent:通过游戏物体的组件获取其其他组件Transform player = GameObject.FindGameObjectWithTag(Tags.player).transform;
    PlayerATKAndDamage playerAtkAndDamage = player.GetComponent();
    //PlayerATKAndDamage是一个脚本AddForce:添加力AddTurque:添加扭矩

    八.协同(协程)以及yield

    一般用来在脚本中增加延时效果。因为在Start()或者Update()中是不能直接延时的(WaitForSecond())等待某个操作结束之后再执行代码字符串做为参数:

    void Start () 
    {
        StartCoroutine("DoSomething", 2.0);
        yield WaitForSeconds (1);//可以在任意位置使用yield语句。yield的返回值控制何时恢复协同程序向下执行。这里等待1s之后才会接着执行下面的语句。
        StopCoroutine("DoSomething");
    }
    
    void DoSomething (float someParameter) 
    {
        while (true) 
        {
            print("DoSomething Loop");
            // 停止协同程序的执行并返回到主循环直到下一帧.
            yield;
        }
    }

    IEnumerator做为参数:

    IEnumerator Start()
    {
        StartCoroutine("DoSomething", 2.0F); //StartCoroutine(DoSomething(2.0F)); 使用IEnumerator做参数不能用StopCoroutine停用。
        yield return new WaitForSeconds(1);
        StopCoroutine("DoSomething"); //请注意只有StartCoroutine使用一个字符串方法名时才能用StopCoroutine停用之。
    }
    
    IEnumerator DoSomething(float someParameter)
    {
        while (true) {
            print("DoSomething Loop");
            yield return null;
        }
    }

    开启协同:
    StartCoroutine(string methodName):字符串作为参数可以开启线程并在协程结束前终止线程;开启协程时最多只能传递一个参数,并且性能消耗会更大一点
    StartCoroutine(IEnumerator routine):只能等待协程的结束而不能随时终止(除非使用StopAllCoroutines()方法)
    中止协同:
    StopCoroutine(string methodName):中止一个协同,只能终止该MonoBehaviour中的协同程序
    StopAllCoroutines():中止所有协同,只能终止该MonoBehaviour中的协同程序
    将协同程序所在gameobject的active属性设置为false,当再次设置active为ture时,协同程序并不会再开启。

    yield

    yiled:和协同密切相关的一个概念,一个协同程序在执行过程中,可以在任意位置使用yield语句。yield的返回值控制何时恢复协同程序向下执行。
    yield不可单独使用

      需要与return配合使用,例如:

      1 yield return 0; //等0帧

      2 yield return 1; //等1帧

      3 yield return WaitForSeconds(3.0); //等待3秒

     4 yield return null;//立即返回调用点
    

      所有使用yield的函数必须将返回值类型设置为IEnumerator类型,例如:
      

    IEnumerator DoSomeThingInDelay() {...}

    当然,你也可以把Start()返回值定义为IEnumerator类型,那么在Start里面也可以使用yield延时返回,但不推荐这样做:

    IEnumerator Start()
    {
        StartCoroutine("DoSomething", 2.0F); //StartCoroutine(DoSomething(2.0F)); 使用IEnumerator做参数不能用StopCoroutine停用。
        yield return new WaitForSeconds(1);
        StopCoroutine("DoSomething"); //请注意只有StartCoroutine使用一个字符串方法名时才能用StopCoroutine停用之。
    }

    你也可以把StartCoroutine和yiled return结合起来使用,保证函数执行顺序,这样调用能保证,init1,init2,init3一个一个的执行,不至于出现后面执行的代码引用一个前面未初始化的变量:

    IEnumerator Init()
    {
        yield return StartCoroutine(init1());
        Debug.Log("init1 finish");
        yield return StartCoroutine(init2());
        Debug.Log("init2 finish");
        yield return StartCoroutine(init3());
        Debug.Log("init3 finish");
    }
    
    IEnumerator init1()
    {
        // 模拟初始化
        yield return new WaitForSeconds(2);//
    }
    IEnumerator init2()
    {
        // do somthing..
        yield return new WaitForSeconds(2);//
    }
    IEnumerator init2()
    {
        // do somthing..
        yield return new WaitForSeconds(2);//
    }

    相关的api总结文章有:
    个人开发Unity3d游戏中常用API函数

    展开全文
  • Unity3d中文API文档

    2020-07-29 14:21:49
    这个是Unity圣典的本地文档,下载这个资源后可以当做普通文件来离线浏览网页,就是可以断网查看UnityAPI
  • unity3d最新中文api

    2020-07-21 09:56:30
    unity3d最新中文apiunity3d最新中文apiunity3d最新中文apiunity3d最新中文api
  • Unity3D中文api开发手册

    2020-07-30 23:31:48
    该手册用于帮助你学习怎样使用Unity,从基础到高级技术。你可以从头到尾阅读来系统学习或仅作为一个参考。
  • Unity API - A

    千次阅读 2017-02-09 20:09:48
    Unity API - A

    废话不多说,一针见血,go!
    一起来看 API


    AccelerationEvent 加速度事件

    描述设备的加速度状态

    AccelerationEvent.acceleration 加速度 加速度的值。

    AccelerationEvent.deltaTime 增量时间 经过一段时间至最后加速度测量

    Editor AlphabeticalSort 字母排序

    AlphabeticalSort .content
    内容形象化字母排序方法

    AnchoredJoint2D 2D锚关节

    AnchoredJoint2D.anchor 有关节组件的对象上的关节锚点。

    AnchoredJoint2D.autoConfigureConnectedAnchor 是否自动计算连接的锚?
    为真时,connectedAnchor属性将自动计算来匹配锚属性的世界位置。为假时,连接的锚位置使用connectedAnchor属性配置。

    AnchoredJoint2D.connectedAnchor 第二个对象上的关节锚点(即,不具有关节组件的那个)。

    AndroidInput 安卓输入

    AndroidInput.GetSecondaryTouch 获取二次触摸
    返回对象代表一个特定在一个二次触摸板的触摸状态

    AndroidInput 安卓输入
    AndroidInput离屏(off-screen)触摸输入支持提供支持,就像touchpad

    AndroidInput.secondaryTouchEnabled 启用二次触摸
    这个属性表示系统是否提供二次触摸输入

    AndroidInput.secondaryTouchHeight 二次触摸高度
    这个属性表示二次触摸板的高度

    AndroidInput.secondaryTouchWidth 二次触摸宽度
    这个属性表示二次触摸板的宽度

    AndroidInput.touchCountSecondary 二次触摸数
    二次触摸数。确保不会改变整个帧数

    AndroidJavaClass 安卓Java类

    AndroidJavaClass.AndroidJavaClass 构造安卓Java类
    从类名className构造一个AndroidJavaClass

    例一
    查找类的类型,并分配一个特定类型的java.lang.Class对象

    //尝试搜集som的Java垃圾
    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        void Start() {
            AndroidJavaClass jc = new AndroidJavaClass("java.lang.System");
            jc.CallStatic("gc");
        }
    }

    例二

    //检索该产品/硬件的制造商
    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        void Start() {
            AndroidJavaClass jc = new AndroidJavaClass("android.os.Build");
            string manufacturer = jc.Get<string>("MANUFACTURER");
        }
    }

    AndroidJavaObject 构造安卓Java对象

    AndroidJavaObject.AndroidJavaObject 构造安卓Java对象
    基于类名,构造一个AndroidJavaObject

    例一
    查找类的类型,分配一个对象,并运行指定的构造方法

    //创建一个java.lang.String对象,持有该字符串"some string"
    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        void Start() {
            AndroidJavaObject jo = new AndroidJavaObject("java.lang.String", "some string");
        }
    }

    例二

    //内嵌类必须使用/$分割
    //这里我们创建了一个LayoutParams对象,带有指定的宽度和高度
    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        void Start() {
            int width = 300;
            int height = 150;
            AndroidJavaObject jo = new AndroidJavaObject("android/view/ViewGroup$LayoutParams", width, height);
        }
    }

    AndroidJavaObject.Call 调用
    在对象上调用一个Java方法(非静态)

    调用一个方法,返回类型为void

    /*创建一个android.content.res.Configuration对象并调用setToDefaults */
    using UnityEngine;
    using System.Collections;
    
    public class Example : MonoBehaviour {
        void Start() {
            AndroidJavaObject jo = new AndroidJavaObject("android.content.res.Configuration");
            jo.Call("setToDefaults");
        }
    }

    AndroidJavaObject.Call.< ReturnType> 调用返回类型
    在一个对象上,调用一个Java方法

    调用一个Java方法带有一个non-void返回类型

    //创建一个java.lang.String对象,持有字符串some string,并检索的它的哈希码
    using UnityEngine;
    using System.Collections;
    
    public class Example : MonoBehaviour {
        void Start() {
            AndroidJavaObject jo = new AndroidJavaObject("java.lang.String", "some string");
            int hash = jo.Call<int>("hashCode");
        }
    }

    AndroidJavaObject.CallStatic 静态调用
    调用一个静态Java方法

    调用一个静态方法,返回类型为void

    //创建一个android.os.Binder对象并调用静态方法flushPendingCommands().
    using UnityEngine;
    using System.Collections;
    
    public class Example : MonoBehaviour {
        void Start() {
            AndroidJavaObject jo = new AndroidJavaObject("android.os.Binder");
            jo.CallStatic("flushPendingCommands");
        }
    }

    AndroidJavaObject.CallStatic.< ReturnType> 调用静态返回类型
    在一个类上,调用一个静态Java方法

    调用一个静态Java方法带有一个non-void返回类型

    //创建一个java.lang.String对象,并调用静态方法valueOf(浮点值)
    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        void Start() {
            AndroidJavaObject jo = new AndroidJavaObject("java.lang.String");
            string valueString = jo.CallStatic<string>("valueOf", 42.0);
        }
    }

    AndroidJavaObject.Dispose 处理
    IDisposable回调函数

    AndroidJavaObject.Get.< FieldType> 获取域类型
    获取一个对象上的域值(非静态)

    一般参数定义域类型

    //创建一个android.os.Message对象并检索域what的默认值
    using UnityEngine;
    using System.Collections;
    
    public class Example : MonoBehaviour {
        void Start() {
            AndroidJavaObject jo = new AndroidJavaObject("android.os.Message");
            int valueString = jo.Get<int>("what");
        }
    }

    AndroidJavaObject.GetRawClass 获取原始类
    检索原始类指向Java对象

    AndroidJavaObject.GetRawObject 获取原始对象
    检索原始对象指向Java对象

    AndroidJavaObject.GetStatic.< FieldType> 获取静态域类型
    获取一个对象类型上的静态域值

    一般参数定义域类型

    //创建一个用户提供的类对象org.example.StaticFields
    //并获取域globalName的字符串值
    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        void Start() {
            AndroidJavaObject jo = new AndroidJavaObject("org.example.StaticFields");
            string globalName = jo.GetStatic<string>("globalName");
        }
    }

    AndroidJavaObject 安卓Java对象
    AndroidJavaObject是Unity表示一个java.lang.Object的泛型实例

    可以用作type-less接口来实例任意Java类

    AndroidJavaObject.Set.< FieldType> 设置域类型
    在一个对象上设置域的值(非静态)

    一般参数定义域类型

    //创建一个android.text.format.Time对象,并设置allDay域为true
    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        void Start() {
            AndroidJavaObject jo = new AndroidJavaObject("android.text.format.Time");
            jo.Set<bool>("allDay", true);
        }
    }

    AndroidJavaObject.SetStatic.< FieldType> 设置静态域类型
    设置一个对象类型上的静态域值

    一般参数定义域类型

    /** 创建一个用户提供的类对象org.example.StaticFields并设置域globalName的值 **/
    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        void Start() {
            AndroidJavaObject jo = new AndroidJavaObject("org.example.StaticFields");
            jo.Set<string>("globalName", "this_is_the_name");
        }
    }

    AndroidJavaProxy 安卓Java代理

    这个类可以用来实现任何Java接口。任何Java虚拟机调用代理对象上匹配的接口将自动传递到C #实现。

    // Opens an android date picker dialog and grabs the result using a callback.
    private static DateTime selectedDate = DateTime.Now;
    class DateCallback : AndroidJavaProxy
    {
        public DateCallback() : base("android.app.DatePickerDialog$OnDateSetListener") { }
        void onDateSet(AndroidJavaObject view, int year, int monthOfYear, int dayOfMonth)
        {
            selectedDate = new DateTime(year, monthOfYear+1, dayOfMonth);
        }
    }
    void OnGUI ()
    {
        if (GUI.Button(new Rect (15, 15, 450, 75), string.Format("{0:yyyy-MM-dd}", selectedDate)))
        {
            var activity = new AndroidJavaClass("com.unity3d.player.UnityPlayer").GetStatic<AndroidJavaObject>("currentActivity");
            activity.Call("runOnUiThread", new AndroidJavaRunnable(() =>
            {
                new AndroidJavaObject("android.app.DatePickerDialog", activity, new DateCallback(), selectedDate.Year, selectedDate.Month-1, selectedDate.Day).Call("show");
            }));
        }
    }

    AndroidJavaProxy .AndroidJavaProxy
    实现Java接口的代理。

    AndroidJavaProxy.javaInterface
    Java接口实现的代理。

    AndroidJavaProxy.Invoke
    由java vm调用当一个方法被调用的java代理接口

    AndroidJNI 安卓JNI miss

    AndroidJNIHelper 安卓JNI辅助器 miss

    Animation 动画

    Animation.AddClip 添加剪辑
    给动画添加一个名称为newName的动画剪辑

    在播放的firstFrame和lastFrame之间添加动画剪辑
    新的动画剪辑也会被添加到名称为newName的动画中

    addLoopFrame: 是否在第一帧之后添加一个额外的帧?如果你在制作一个循环的动画,那么可以打开这个选项 如果那么名称的动画剪辑已经存在,那么会被新的动画剪辑覆盖
    例一
    添加walk动画剪辑

    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        public AnimationClip walkClip;
        public Animation anim;
        void Start() {
            anim = GetComponent<Animation>();
            anim.AddClip(walkClip, "walk");
        }
    }

    例二

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        {
            // 把默认的动画剪辑拆分成一个shoot,walk和idle的动画
            animation.AddClip(animation.clip, "shoot", 0, 10);
            // walk和idle动画剪辑会在结尾被添加一个额外的循环帧(动画播放到结尾再跳转到第1帧循环播放)
            animation.AddClip(animation.clip, "walk", 11, 20, true);
            animation.AddClip(animation.clip, "idle", 21, 30, true);
        }
    }

    Low Animation.animateOnlyIfVisible 可见时动画
    用户看不到当前动画的时候停止播放
    改为Animation.cullingType

    Animation.animatePhysics 是否物理动画
    动画会在物理循环过程中被执行。这个选项只有在结合运动学刚体的时候才有用

    Animation.Blend 混合
    在接下来的几秒内混合名称为name的动画直到targetWeight(动态调节动画状态之间的权重(比例)产生相应的叠加动画)
    其他动画的播放将不会受到影响。

    Animation.clip 剪辑
    默认的动画剪辑

    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        public Animation anim;
        IEnumerator Start() {
            anim = GetComponent<Animation>();
            anim.Play(anim.clip.name);
            yield return new WaitForSeconds(anim.clip.length);
        }
    }

    Animation.CrossFade 淡入淡出
    在一定时间内淡入名称为name的动画并且淡出其他动画

    如果模式是PlayMode.StopSameLayer,在同一层的动画将在动画淡入的时候淡出。如果模式是PlayMode.StopAll,所有动画将在淡入的时候淡出

    如果动画没有被设置成循环,它将停止并且在播放完成之后倒带至开始
    例一

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        {   
            // 淡入walk循环并且淡出同一层的所有其他动画
            // 在0.2秒之内完成淡入淡出
            animation.CrossFade("Walk", 0.2F);
        }
    }

    例二
    让一个角色包含Run和Idle动画,并且在玩家想移动的时候在他们之间淡入淡出

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Update() 
        {
            if (Mathf.Abs(Input.GetAxis("Vertical")) > 0.1F)
                animation.CrossFade("Run");
            else
                animation.CrossFade("Idle");
        }
    }

    Animation.CrossFadeQueued 淡入淡出队列
    在前一个动画播放完成之后淡入淡出下一个动画

    动画在播放前复制自身,因此你可以再相同的动画间渐变,这可用来重叠两个相同的动画 例如你可能有一个挥剑的动画,玩家快速挥动了2次,你可以回放这个动画并从开始播放它,但会跳帧

    下面是可用的queue modes:
    如果queue为QueueMode.CompleteOthers这个动画只在所有其他动画都停止播放时才开始。
    如果queue为QueueMode.PlayNow这个动画将以一个复制的动画状态立即开始播放

    动画播放完成后它将自动清除它自己。在它播放完成后使用赋值的动画将导致一个异常

    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        public Animation anim;
        void Start() {
            anim = GetComponent<Animation>();
        }
        void Update() {
            if (Input.GetButtonDown("Fire1"))
                anim.CrossFadeQueued("shoot", 0.3F, QueueMode.PlayNow);
    
        }
    }

    Animation.GetClipCount 获取剪辑数
    取得当前动画的动画剪辑数量

    Animation 动画
    animation组件用于播放动画

    你可以给动画组件添加动画帧并且在你的脚本里面控制动画的播放 Unity里面的动画系统基于重量并且支持动画混合(Blending),添加动画,动画混合(Mixing),标签和所有动画播放比率的全权控制

    如果想播放一个简单的动画,可以使用Animation.Play;
    如果想在动画之间交叉淡入,可以使用Animation.CrossFade;
    如果想改变动画模式(循环,一次,乒乓),可以改变动画导入设置里面的动画帧的WrapMode,或者在运行时改变AnimationState.wrapMode的值;
    AnimationState可以用于改变动画的层,修改播放速度,并且直接控制混合与合成

    动画也支持枚举,所以你可以像这样在AnimationStates之间循环

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {
            foreach (AnimationState state in animation) {
                state.speed = 0.5F;
            }
        }
    }

    Animation.this [string name] 动画状态
    返回名称为name的动画状态

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {
            // 取得walk动画状态并设置其速度
            animation["walk"].speed = 2.0F;
            // 取得run动画状态并设置其重量(取得run动画状态并设置其权重(官方叫偏移量))
            animation["run"].weight = 0.5F;
        }
    }

    Animation.isPlaying 是否在播放?
    是否在播放任何动画?

    例一
    只在我们没有播放一个动画的时候,播放它。

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void OnMouseEnter() 
        {
            if (!animation.isPlaying)
            animation.Play();
    
        }
    }

    例二
    名为name的动画正在播放吗?

    仅当不播放名为name的动画时,播放动画

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void OnMouseEnter() 
        {
            if (!animation.IsPlaying("mouseOverEffect"))
                animation.Play("mouseOverEffect");
    
        }
    }

    Animation.Play 播放
    不带有任何混合的播放动画。

    如果模式是PlayMode.StopSameLayer,那么所有在同一个层的动画将停止播放 如果模式是PlayMode.StopAll,那么所有当前在播放的动画将停止播放

    如果动画已经在播放过程中,别的动画将停止但是动画不会回退到开始位置

    如果动画不能被播放(没有动画剪辑或者没有默认动画),Play()将返回false

    例一

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {   
            // 播放默认动画
            animation.Play();
        }
    }

    例二

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake()
        {
            // 播放walk动画 - 停止同一层的其他动画
            animation.Play("walk");
            // 播放walk动画 - 停止其他动画
            animation.Play("walk", PlayMode.StopAll);
        }
    }

    Animation.playAutomatically 自动播放
    是否在开始的时候自动播放默认的动画(Animation.clip)

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {
            animation.playAutomatically = true;
        }
    }

    Animation.PlayQueued 播放队列
    在前一个动画播放完成之后直接播放下一个动画。

    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        public Animation anim;
        void Start() {
            anim = GetComponent<Animation>();
        }
        void Update() {
            if (Input.GetButtonDown("Fire1"))
                anim.PlayQueued("shoot", QueueMode.PlayNow);
    
        }
    }

    Animation.RemoveClip 移除剪辑
    从动画列表移除剪辑(去掉剪辑和所有基于这个剪辑的动画状态)

    Animation.Rewind 倒回

    例一
    倒回名称为name的动画

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {   
            // 倒回walk动画到开始
            animation.Rewind("walk");
        }
    }

    例二
    倒回所有动画

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {   
            // 倒回所有动画到开始
            animation.Rewind();
        }
    }

    Animation.Sample 采样
    在当前状态对动画进行采样

    当你明确想设置一些动画状态并且对它取样一次的时候有用。(**??)

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {
            // 设置一些状态
            animation["MyClip"].time = 2.0F;
            animation["MyClip"].enabled = true;
            // 取样动画
            animation.Sample();
            animation["MyClip"].enabled = false;
        }
    }

    Animation.Stop 停止
    停止所有当前Animation正在播放的动画

    停止一个动画会让动画重回开始位置

    例一

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {   
            //停止所有动画
            animation.Stop();
        }
    }

    例二

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {   
            //停止walk动画
            animation.Stop("walk");
        }
    }

    Low Animation.SyncLayer 同步层
    同步某层的动画的播放速度

    在混合两个循环动画的时候,他们通常有不同的长度 比如一个走路的动画通常比一个跑步的动画要长 当混合他们的时候,你需要确定走路和跑步动画发生的时候脚的位置要在同一时间走动 换句话说,这两个动画播放速度要被调整一致,以便动画的同步 SyncLayer函数将根据动画的混合权重来计算同一层中动画的平均正常播放速度 然后它会给同一层的所有动画应用这个播放速度

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {
            // 把walk和run动画放到同一层,然后同步他们的速度
            animation["walk"].layer = 1;
            animation["run"].layer = 1;
            animation.SyncLayer(1);
        }
    }

    Animation.wrapMode 循环模式
    动画剪辑播放完成之后,应该如何操作?

    WrapMode.Default:从动画剪辑中读取循环模式(默认是Once)
    WrapMode.Once:当时间播放到末尾的时候停止动画的播放
    WrapMode.Loop:当时间播放到末尾的时候重新播放从开始播放
    WrapMode.PingPong:在开始和结束之间来回播放
    WrapMode.ClampForever:播放动画 当播放到结尾的时候,动画总是处于最后一帧的采样状态

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {
            animation.wrapMode = WrapMode.Loop;
        }
    }

    Animation.cullingType 剔除类型
    控制动画组件的剔除类型。

    Animation.localBounds 本地边界
    在本地坐标空间这个动画的动画组件的AABB。(**??)

    AnimationClip 动画剪辑

    AnimationClip.AddEvent 添加动画事件
    给剪辑添加动画事件

    AnimationClip.AnimationClip 动画剪辑
    创建一个新的动画剪辑

    AnimationClip.ClearCurves 清除曲线
    从剪辑清除所有曲线(清除所有动画轨迹)

    AnimationClip.frameRate 帧速率
    被取样关键帧的帧速率(帧速率应该是帧频的意思 也就是一秒多少帧 通过这个可以来控制动画在一定时间内的播放速度)

    using UnityEngine;
    using System.Collections;
    
    public class ExampleScript : MonoBehaviour
    {
        public Animation anim;
    
        void Update()
        {
            //打印动画剪辑的帧速率
            print(anim["walk"].clip.frameRate);
        }
    }

    AnimationClip 动画剪辑
    储存基于动画的关键帧

    AnimationClip.length 动画长度
    动画的长度,以秒计算

    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        public Animation anim;
        IEnumerator Start() {
            anim = GetComponent<Animation>();
            anim.Play();
            yield return new WaitForSeconds(anim.clip.length);
        }
    }

    AnimationClip.SetCurve 设置曲线
    给动画指定曲线一个特殊的属性
    如果曲线为null,曲线将被移除,如果曲线属性已经存在,曲线将被替换

    例一
    动画transform位置的x轴坐标

    using UnityEngine;
    using System.Collections;
    
    [RequireComponent(typeof(Animation))]
    public class ExampleClass : MonoBehaviour {
        public Animation anim;
        void Start() {
            anim = GetComponent<Animation>();
            //创建曲线
            AnimationCurve curve = AnimationCurve.Linear(0, 1, 2, 3);
            AnimationClip clip = new AnimationClip();
            clip.legacy = true;
            //创建曲线的剪辑
            clip.SetCurve("", typeof(Transform), "localPosition.x", curve);
            //点击并播放剪辑
            anim.AddClip(clip, "test");
            anim.Play("test");
        }
    }

    例二
    动画颜色的通道和主要纹理的水平偏移(**??)

    using UnityEngine;
    using System.Collections;
    
    [RequireComponent(typeof(Animation))]
    public class ExampleClass : MonoBehaviour {
        public Animation anim;
        void Start() {
            anim = GetComponent<Animation>();
            AnimationClip clip = new AnimationClip();
            clip.legacy = true;
            clip.SetCurve("", typeof(Material), "_Color.a", new AnimationCurve(new Keyframe(0, 0, 0, 0), new Keyframe(1, 1, 0, 0)));
            clip.SetCurve("", typeof(Material), "_MainTex.offset.x", AnimationCurve.Linear(0, 1, 2, 3));
            anim.AddClip(clip, clip.name);
            anim.Play(clip.name);
        }
    }

    AnimationClip.wrapMode 循环模式
    在动画状态设置使用的默认循环模式

    AnimationClip.events 事件列表用于该剪辑的动画事件。

    AnimationClip.humanMotion 人类运动
    如果该动画包含的曲线是人类骨骼,返回true。

    AnimationClip.legacy 传统
    设置为真,AnimationClip将使用传统动画组件(而不是动画),

    using UnityEngine;
    using System.Collections;
    
    public class animFov : MonoBehaviour {
    
        void Start () {
    
            AnimationClip fovc = new AnimationClip();
            AnimationCurve curve = AnimationCurve.Linear(0.0f, 60.0f, 10.0f, 90.0f);
            fovc.SetCurve ("",typeof(Camera), "field of view", curve);
            fovc.legacy = true;
            GetComponent<Animation>().AddClip(fovc, "animfov");
    
            GetComponent<Animation>().Play("animfov");
    
        }
    }

    AnimationClip.localBounds 本地边界
    动画组件在本地坐标空间这个动画剪辑的AABB也被附加。(**??)

    AnimationClip.EnsureQuaternionContinuity 确保四元数连续性
    为了保证更好的四元数插值,调用这个函数完成后设置动画曲线
    该函数重新调整四元数键来确保最短路径插补。

    AnimationClip.SampleAnimation 采样动画
    在给定的时间采样动画,为任意动画的属性。

    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        public AnimationClip clip;
        void Update() {
            clip.SampleAnimation(gameObject, clip.length - Time.time);
        }
    }

    Editor AnimationClipCurveData 动画剪辑曲线数据

    动画剪辑曲线数据包含了特定动画剪辑曲线需要的全部信息。 该动画曲线是附加到游戏物体上的 组件/ 材质 / 骨骼动画 的特定属性.

    AnimationClipCurveData.curve 曲线
    实际的动画曲线。

    AnimationClipCurveData.path 路径
    游戏对象的路径 /骨骼的路径。

    AnimationClipCurveData.propertyName 属性名
    被动画处理的属性名

    AnimationClipCurveData.type 类型
    组件/材质 的类型

    AnimationClipPair 动画剪辑对

    该类定义一对剪辑用于动画重写控制。

    AnimationClipPair.originalClip 原始剪辑
    控制器的原始剪辑。

    AnimationClipPair.overrideClip 重写动画剪辑 重写动画剪辑。
    重写动画剪辑。

    Editor AnimationClipCurveData 动画剪辑曲线数据

    AnimationClipCurveData.curve 曲线
    当前的动画曲线

    AnimationClipCurveData 动画剪辑曲线数据
    一个AnimationClipCurveData对象包含所有的信息需要明确一个明确的AnimationClip曲线。曲线动画一个组件的特定属性 /游戏对象的附加材质 /骨骼动画。

    AnimationClipCurveData.path 轨迹
    带有动画的游戏对象/骨骼的运动轨迹

    AnimationClipCurveData.propertyName 属性名称
    带有动画的属性名称

    Low AnimationClipCurveData.target 目标
    带有动画的组件/材质

    AnimationClipCurveData .type
    带有动画的组件/材质

    AnimationCurve 动画曲线

    AnimationCurve.AddKey 添加键
    在曲线中添加一个新键.(添加帧,然后修改当前帧的信息 可以实现动画的流畅播放。例如你有个from to的position循环动画 正常的话是两帧 从from播放到to之后 它会直接再次跳到from)

    AnimationCurve.AnimationCurve 动画曲线
    根据任意数量的关键帧创建一个动画曲线.(**??)

    一个渐入渐出的动画曲线(切线都是平直的)

        using UnityEngine;
        using System.Collections;
    
        public class AnimCurveExample : MonoBehaviour
        {
            public AnimationCurve curve ;
    
            void Start()
            {
                curve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(1, 1));
                curve.preWrapMode = WrapMode.PingPong;
                curve.postWrapMode = WrapMode.PingPong;
            }
    
            void Update()
            {
                transform.position = new Vector3(transform.position.x, curve.Evaluate(Time.time), transform.position.z);
            }
        }

    AnimationCurve.EaseInOut 淡入淡出
    一个渐入渐出的曲线, 开始于timeStart, valueStart 终止于 timeEnd, valueEnd

    AnimationCurve.Evaluate 求值
    曲线在某时刻的值.(**??)

    AnimationCurve 动画曲线
    动画曲线.让你在给定时间插入关键帧和数值的曲线(**??)

    AnimationCurve.this [int index] 操作索引
    在索引中检索键(**??)

    AnimationCurve.keys 所有键
    在动画曲线中定义的所有键

    使一个游戏对象跟随一个二次函数在X,Y轴

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        private AnimationCurve anim;
        private Keyframe[] ks;
        void Start() 
        {
            ks = new Keyframe[50];
            int i = 0;
            while (i < ks.Length) 
            {
                ks[i] = new Keyframe(i, i * i);
                i++;
            }
            anim = new AnimationCurve(ks);
        }
        void Update() 
        {
            transform.position = new Vector3(Time.time, anim.Evaluate(Time.time), 0);
        }
    }

    AnimationCurve.length 长度
    曲线中键的数量

    AnimationCurve.Linear 直线
    一条直线,开始于timeStart, valueStart 终止于 timeEnd, valueEnd

    AnimationCurve.MoveKey 改变键
    移除索引处的关键帧并插入键

    AnimationCurve.postWrapMode 循环模式之后
    最后一帧关键帧之后动画的行为

    AnimationCurve.preWrapMode 循环模式之前
    第一帧关键帧之前动画的行为

    AnimationCurve.RemoveKey 删除键
    移除一个键

    AnimationCurve.SmoothTangents 平滑切线
    平滑索引处关键帧的切线

    AnimationEvent 动画事件

    AnimationEvent 动画事件
    AnimationEvent类似于SendMessage让你调用一个脚本函数,这个脚本是动画播放的一部分

    AnimationEvent.animationState 动画状态
    该事件引发的动画状态(只读)

    AnimationEvent.animatorClipInfo 动画器剪辑信息
    与此事件有关的动画器剪辑信息(只读)

    AnimationEvent.animatorStateInfo 动画器状态信息
    有关该事件的动画器状态信息(只读)

    AnimationEvent.floatParameter 动画器状态信息
    浮点型参数,储存在该事件中并发送给函数。

    AnimationEvent.functionName 函数名
    被调用的函数的名称。

    AnimationEvent.intParameter 整数参数
    整数型参数,储存在事件中并发送给函数

    AnimationEvent.isFiredByAnimator 是否有动画器触发
    如果该动画事件已经由Animator组件触发,返回true

    AnimationEvent.isFiredByLegacy 是否有旧版动画触发
    如果该动画事件已经由Animation组件触发,返回true

    AnimationEvent.messageOptions 消息选项
    如果选项设置为 SendMessageOptions.RequireReceiver (默认),当消息没有被任何组件接收时打印一个错误信息

    AnimationEvent.objectReferenceParameter 引用对象参数
    储存在事件中的引用对象参数,并发送给函数

    AnimationEvent.stringParameter 字符串参数
    储存在该事件中的字符串参数,并发送给函数

    AnimationEvent.time 时间
    引发该事件的时间点。

    AnimationEvent.AnimationEvent 新建动画事件
    新建动画事件

    Low AnimationInfo 动画信息

    AnimationInfo.clip 剪辑
    被播放的动画剪辑

    AnimationInfo.weight 权重
    动画剪辑的权重。

    Editor AnimationMode 动画模式 miss

    AnimationState 动画状态

    AnimationState.AddMixingTransform 添加混合变换
    加入一个动画变换。这使你减少创建动画的工作量

    例一
    不用路径增加一个混合transform

    using UnityEngine;
    using System.Collections;
    
    public class ExampleScript : MonoBehaviour
    {
        public Animation anim;
        public Transform shoulder;
    
        void Start()
        {
            // Add mixing transform
            anim["wave_hand"].AddMixingTransform(shoulder);
        }
    }

    例二
    用路径增加一个混合transform

    using UnityEngine;
    using System.Collections;
    
    public class ExampleScript : MonoBehaviour
    {
        public Animation anim;
    
        void Start()
        {
            // Adds a mixing transform using a path instead
            Transform mixTransform = transform.Find("root/upper_body/left_shoulder");
    
            // Add mixing transform
            anim["wave_hand"].AddMixingTransform(mixTransform);
        }
    }

    AnimationState.RemoveMixingTransform
    动画删除一个变换

    AnimationState.blendMode 混合模式
    使用哪种混合模式?

    设置leanLeft动画为相加混合

    using UnityEngine;
    using System.Collections;
    
    public class ExampleScript : MonoBehaviour
    {
        public Animation anim;
    
        void Start()
        {
            // Set the leanLeft animation to blend additively
            anim["leanLeft"].blendMode = AnimationBlendMode.Additive;
        }
    }

    AnimationState.clip 剪辑

    打印动画剪辑的帧率到控制台

    using UnityEngine;
    using System.Collections;
    
    public class ExampleScript : MonoBehaviour
    {
        public Animation anim;
    
        void Update()
        {
            // Prints the frame rate of the animation clip to the console
            print(anim["walk"].clip.frameRate);
        }
    }

    AnimationState.enabled 是否启用?
    启动/禁止动画

    启用行走动作循环

    using UnityEngine;
    using System.Collections;
    
    public class ExampleScript : MonoBehaviour
    {
        public Animation anim;
    
        void Start()
        {
            // Enable the walk cycle
            anim["Walk"].enabled = true;
            anim["Walk"].weight = 1.0f;
        }
    }

    AnimationState 动画状态
    完全控制动画混合

    Low AnimationState.layer
    动画层。当计算最终混合权重时,高层的动画优先获得他们优先分发的权重

    置walk 和 run动画到层1

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {
            animation["Walk"].layer = 1;
            animation["Run"].layer = 1;
        }
    }

    AnimationState.length 长度
    动画剪辑的长度,单位是秒

    打印walk动画的长度

    using UnityEngine;
    using System.Collections;
    
    public class ExampleScript : MonoBehaviour
    {
        public Animation anim;
    
        void Start()
        {
            // Print the length of the walk animation in seconds
            print(anim["Walk"].length);
        }
    }

    AnimationState.name 名称
    动画的名称

    AnimationState.normalizedSpeed 规范化速度
    规范化播放速度

    同步run 和walk的速度

    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        public Animation anim;
        void Start() {
            anim = GetComponent<Animation>();
            anim["Run"].normalizedSpeed = anim["Walk"].speed;
        }
    }

    AnimationState.normalizedTime 规范化时间
    动画当前规范化时间

    快进到动画中部

    using UnityEngine;
    using System.Collections;
    
    public class ExampleScript : MonoBehaviour
    {
        public Animation anim;
    
        void Start()
        {
            // Fast forward to the middle of the animation
            anim["Walk"].normalizedTime = 0.5f;
        }
    }

    AnimationState.speed 速度
    动画的播放速度。1为正常速度

    using UnityEngine;
    using System.Collections;
    
    public class ExampleScript : MonoBehaviour
    {
        public Animation anim;
    
        void Start()
        {
            // 向后走
            anim["Walk"].speed = -1.0f;
    
            // 2倍加速播放
            anim["Walk"].speed = 2.0f;
        }
    }

    AnimationState.time 时间
    动画当前时间

    将walk动画置为初始

    using UnityEngine;
    using System.Collections;
    
    public class ExampleScript : MonoBehaviour
    {
        public Animation anim;
    
        void Start()
        {
            // Rewind the walk animation
            anim["Walk"].time = 0.0f;
        }
    }

    AnimationState.weight 权重
    它计算动画曲线的混合权重

    启用行走动作循环

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public Animation anim;
        public void Awake() 
        {
            anim["Walk"].enabled = true;
            anim["Walk"].weight = 1.0F;
        }
    }

    AnimationState.wrapMode 循环模式
    动画的循环模式

    设置walk动画的wrapMode模式为循环播放

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public Animation anim;
        public void Awake() 
        {
            anim["Walk"].wrapMode = WrapMode.Loop;
        }
    }

    Editor AnimationUtility 动画工具

    AnimationUtility.CalculateTransformPath 计算变换路径
    计算从初始transform到目标transform的路径

    Low AnimationUtility.GetAllCurves 获取所有曲线
    从一个特定动画剪辑中检索所有曲线(**??)
    改为 AnimationUtility.GetCurveBindings

    AnimationUtility.GetAnimatableBindings
    返回所有的可以做成动画绑定特定的游戏对象。

    根GameObject不需要一个实际的根,但必须是更高层次的目标。 目标和根GameObject也可能是相同的

    Low AnimationUtility.GetAnimatableProperties 获取动画属性
    返回一个列表,包含着附加到游戏物体的动画物体(包含材质)

    Low AnimationUtility.GetAnimatablePropertiesForObject 获取物体动画属性
    返回一个列表,包含着附加到游戏物体上的特定动画的动画属性

    AnimationUtility.GetAnimatedObject
    返回指向的动画对象绑定

    Low AnimationUtility.GetAnimationClips 获取动画剪辑列表
    返回动画组件中被引用的动画剪辑数组

    AnimationUtility.GetAnimationEvents 获取动画事件列表(**??)
    检索动画剪辑相关的所有动画事件

    AnimationUtility.GetCurveBindings
    返回所有浮动曲线绑定当前存储在剪辑。
    统一有两种类型的动画:浮动和对象引用。 曲线是一个典型的曲线变化浮动浮动属性。 对象引用“曲线”是一个构造的对象引用属性。

    这个方法只返回浮动曲线绑定。 看到 AnimationUtility.GetObjectReferenceCurveBindings 对于对象引用曲线。

    using UnityEditor;
    using UnityEngine;
    
    // Editor window for listing all float curves in an animation clip
    public class ClipInfo : EditorWindow
    {
        private AnimationClip clip;
    
        [MenuItem ("Window/Clip Info")]
        static void Init ()
        {
            GetWindow (typeof (ClipInfo));
        }
    
        public void OnGUI()
        {
            clip = EditorGUILayout.ObjectField ("Clip", clip, typeof (AnimationClip), false) as AnimationClip;
    
            EditorGUILayout.LabelField ("Curves:");
            if (clip != null)
            {
                foreach (var binding in AnimationUtility.GetCurveBindings (clip))
                {
                    AnimationCurve curve = AnimationUtility.GetEditorCurve (clip, binding);
                    EditorGUILayout.LabelField (binding.path + "/" + binding.propertyName + ", Keys: " + curve.keys.Length);
                }
            }
        }
    }

    AnimationUtility.GetEditorCurve 获取编辑器曲线(**??)
    Unity自动混合曲线坐标,缩放,旋转

    AnimationUtility.GetFloatValue 获取浮点值
    用在一个特定游戏物体上进行曲线值采样的方式检索当前浮点数值(**??)

    AnimationUtility.GetObjectReferenceCurve
    返回对象引用绑定指向曲线。

    与浮动曲线不同,对象引用曲线没有额外的元数据。 因此关键帧返回的数组,而非一个奇异曲线对象。

    AnimationUtility.GetObjectReferenceCurveBindings
    返回所有对象引用曲线绑定当前存储在剪辑。

    统一有两种类型的动画:浮动和对象引用。 曲线是一个典型的曲线变化浮动浮动属性。 对象引用“曲线”是一个构造的对象引用属性。

    该方法只返回对象引用绑定

    using UnityEditor;
    using UnityEngine;
    
    // Editor window for listing all object reference curves in an animation clip
    public class ClipInfo : EditorWindow
    {
        private AnimationClip clip;
    
        [MenuItem ("Window/Clip Info")]
        static void Init ()
        {
            GetWindow (typeof (ClipInfo));
        }
    
        public void OnGUI()
        {
            clip = EditorGUILayout.ObjectField ("Clip", clip, typeof (AnimationClip), false) as AnimationClip;
    
            EditorGUILayout.LabelField ("Object reference curves:");
            if (clip != null)
            {
                foreach (var binding in AnimationUtility.GetObjectReferenceCurveBindings (clip))
                {
                    ObjectReferenceKeyframe[] keyframes = AnimationUtility.GetObjectReferenceCurve (clip, binding);
                    EditorGUILayout.LabelField (binding.path + "/" + binding.propertyName + ", Keys: " + keyframes.Length);
                }
            }
        }
    }

    AnimationUtility 动画工具
    编辑器工具函数,用于修改动画剪辑

    Low AnimationUtility.InAnimationMode 是否在动画模式
    如果当前编辑器在动画模式则返回true

    AnimationUtility.SetAdditiveReferencePose
    设置添加剂参考姿势 referenceClip 在 时间 对于动画短片 剪辑 。

    默认情况下任何动画剪辑中使用添加剂层使用构成0时刻来定义参考姿势。 这是一个很大的限制的参考姿势需要剪辑。
    这个函数允许你改变这种行为和使用一个引用从任何片段构成

    AnimationUtility.SetAnimationClips 设置动画剪辑列表
    设置动画组件中被引用的动画剪辑数组

    AnimationUtility.SetAnimationEvents 设置动画事件列表
    替换动画剪辑中所有的动画事件

    AnimationUtility.SetEditorCurve 设置编辑器曲线
    Unity自动混合曲线坐标,缩放,旋转

    AnimationUtility .SetObjectReferenceCurve
    添加、修改或删除一个对象引用曲线在一个给定的剪辑。

    统一有两种类型的动画:浮动和对象引用。 曲线是一个典型的曲线变化浮动浮动属性。 对象引用“曲线”是一个构造的对象引用属性。

    该方法用于浮动曲线。

    AnimationUtility.StartAnimationMode 开始动画模式
    开始动画模式,如使用动画编辑器

    AnimationUtility.StopAnimationMode 停止动画模式
    停止动画模式,如使用动画编辑器

    AnimationUtility.onCurveWasModified
    时触发一个动画曲线在一个动画剪辑已经被修改

    Animator 动画器

    Animator.angularVelocity 角速度
    获得上一帧计算的阿凡达角速度

    Animator.applyRootMotion 应用根运动
    是否应用根运动?
    运动是对象整体移动来影响,远离它的起点,但运动是由动画自己创建,而不是通过Transform来改变位置。注意,当脚本执行MonoBehaviour.OnAnimatorMove函数时,applyRootMotion没有影响。

    Animator.avatar 化身
    获取或设置当前的Avatar

    Animator.bodyPosition 身体位置
    身体质量中心的位置
    该位置是对象局部的位置

    Animator.bodyRotation 身体旋转
    该身体质量中心的旋转
    该旋转是对象的局部旋转

    Animator.cullingMode 剔除模式
    控制动画器组件的剔除模式

    Animator.deltaPosition 增量位置
    获取上一帧avatar的增量位置

    Animator.deltaRotation 增量旋转
    获取上一帧avatar的增量旋转

    Animator.feetPivotActive 脚轴心点激活
    混合身体质量中心与脚质量中心的轴心点。0%表示混合轴心点在身体的质量中心;100%表示混合轴心点在脚的轴心点

    Animator.gravityWeight 重力
    基于当前播放的动画的当前重力

    Animator.hasRootMotion 是否根运动
    如果当前绑定已经是根运动,返回真

    Animator.hasTransformHierarchy 是否是变换层级
    如果该对象已经是变换层级,返回真
    基于模型导入器中的优化游戏对象开关

    Animator.humanScale 人形缩放
    返回当前人形绑定Avatar的缩放,(如果绑定是generic,默认为1)
    此缩放相对于Unity的默认Avatar。

    Animator.isHuman 是否是人形
    如果当前的绑定是人形的,返回真;如果是generic(普通)的则返回假。

    Animator.isInitialized
    返回动画是否初始化成功

    using UnityEngine;
    
    public class CheckAndRebind : MonoBehaviour {
        Animator animator;
    
        void Start()
        {
            animator = GetComponent<Animator>();
    
            if (!animator.isInitialized)
                animator.Rebind();
        }
    }

    Animator.isMatchingTarget 是否匹配目标
    如果自动匹配是激活的

    Animator.isOptimizable 是否优化
    如果当前的绑定是AnimatorUtility.OptimizeTransformHierarchy优化的。

    Animator.layerCount 层数
    该动画器控制器的层数

    Animator.leftFeetBottomHeight 左脚底高度
    获得左脚底的高度

    void LateUpdate()
    {
        if(animator)
        {
            Vector3 leftFootT = animator.GetIKPosition(AvatarIKGoal.LeftFoot);
            Quaternion leftFootQ = animator.GetIKRotation(AvatarIKGoal.LeftFoot);
    
            Vector3 leftFootH = new Vector3(0, -animator.leftFeetBottomHeight, 0);
    
            Vector3 pos = leftFootT + leftFootQ * leftFootH;
            Debug.Log(pos);
        }
    }

    Animator.linearVelocityBlending 线性速度混合
    当linearVelocityBlending 设置为true,根运动速度和角速度将线性混合。

    Animator.parameters 参数列表
    当linearVelocityBlending 设置为true,根运动速度和角速度将线性混合

    Animator.pivotPosition 轴心点位置
    获得当前轴心点的位置
    该轴心点是avatar的左右脚之间最稳定的轴心点

    Animator.pivotWeight 轴心点权重
    获得轴心点的权重
    该轴心点是avatar的左右脚之间最稳定的轴心点。值为0时,左脚是最稳定的轴心点;值为1时,右脚是最稳定的轴心点

    Animator.playbackTime 播放时间
    在记录缓冲区设置播放位置
    当在播放模式(见StartPlayback),该值用于控制缓冲区当前的播放位置(秒)。该值的范围在recorderStartTime 和recorderStopTime之间

    Animator.recorderMode 记录器模式
    获得动画器记录器的模式

    Animator.recorderStartTime 记录开始时间
    缓冲区第一帧的开始时间,相对于StartRecording被调用时的帧
    例如,如果我们已在第10帧开始记录,缓存是5帧长。如果缓存没有被初始化(StartRecording没被调用),该属性值将为-1。

    Animator.recorderStopTime 记录停止时间
    记录剪辑的结束时间,相对于StartRecording被调用的帧。
    例如,如果我们在第10秒开始记录,在第15秒结束记录,那么该值将会是5。如果缓存没有被初始化(StartRecording没被调用),该属性值将为-1。

    Animator.rightFeetBottomHeight 右脚底高度
    获取右脚底的高度

    void LateUpdate()
    {
        if(animator)
        {
            Vector3 rightFootT = animator.GetIKPosition(AvatarIKGoal.RightFoot);
            Quaternion rightFootQ = animator.GetIKRotation(AvatarIKGoal.RightFoot);
    
            Vector3 rightFootH = new Vector3(0, -animator.rightFeetBottomHeight, 0);
    
            Vector3 pos = rightFootT + rightFootQ * rightFootH; Debug.Log(pos); } 
    } 

    Animator.rootPosition 根位置
    根位置,该游戏对象的位置

    Animator.rootRotation 根旋转
    根旋转,该游戏对象的旋转角度

    Animator.runtimeAnimatorController 运行时动画器控制器
    AnimatorController的运行时代表,用来控制Animator。

    Animator.speed 速度
    动画器的播放速度。1表示正常播放速度

    Animator.stabilizeFeet 稳定脚
    过渡和混合时,脚自动稳定

    Animator.targetPosition 目标位置
    返回由SetTarget(AvatarTarget targetIndex, float targetNormalizedTime))指定的目标的位置。
    当帧在SetTarget调用计算后,该位置才有效。

    Animator.updateMode 更新模式
    该动画器的指定更新模式

    Animator.velocity 速度
    获得上帧计算的阿凡达速度

    Animator.ApplyBuiltinRootMotion 应用内置根运动
    应用默认的根运动。使用 OnAnimatorMove 或 StateMachineBehaviour.OnStateMove

    Animator.CrossFade 淡入淡出
    在当前状态和目标状态之间创建一个动态过渡
    这两个状态需在同一层
    不能再同步层改变当前状态,你需要在索引层来改变它

    Animator.CrossFadeInFixedTime 固定时间淡入淡出
    两个状态必须在同一层
    不能再同步层改变当前状态,你需要在索引层来改变它

    Animator.GetAnimatorTransitionInfo 获取动画器过渡信息
    获取指定AnimatorController层的过渡信息
    仅在过渡持续期间有效

    Animator.GetBehaviour 获得行为
    返回匹配类型T或派生自T的首个状态机行为,如果没有找到返回null

    public class RunBehaviour : StateMachineBehaviour {
    
        // OnStateUpdate is called at each Update frame between OnStateEnter and OnStateExit callback
        override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) 
        {
            if (animator.GetComponent<Recorder>().enabled && !animator.GetComponent<Recorder>().isRecording) return;
    
            Transform transform = animator.GetComponent<Transform>();
    
            RaycastHit hitInfo;
            Vector3 dir = transform.TransformDirection(Vector3.forward);
            if (Physics.Raycast(transform.position + new Vector3(0, 1.5f, 0), dir, out hitInfo, 10))
            {
                if (hitInfo.collider.tag == "Obstacle")
                {
                    animator.GetBehaviour<SlideBehaviour>().target = transform.position + 1.25f * hitInfo.distance * dir;
                    if(hitInfo.distance < 6)
                        animator.SetTrigger("Slide");
                }
            }
        }
    }
    
    public class SlideBehaviour : StateMachineBehaviour {
    
        public Vector3 target;
    
        public float slideMatchTargetStart = 0.11f;
        public float slideMatchTargetStop = 0.40f;
    
        // OnStateUpdate is called at each Update frame between OnStateEnter and OnStateExit callback
        override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
            animator.MatchTarget(target, new Quaternion(), AvatarTarget.Root, new MatchTargetWeightMask(new Vector3(1, 0, 1), 0), slideMatchTargetStart, slideMatchTargetStop);
        }
    }

    Animator.GetBehaviours 获得行为列表
    返回匹配类型T或派生自T的所有状态机行为,如果没有找到返回nul

    using UnityEngine;
    using System.Collections;
    
    // An example StateMachineBehaviour.
    public class BreathBehaviour : StateMachineBehaviour {
    
        public bool  fastBreath;
    
        // OnStateUpdate is called at each Update frame between OnStateEnter and OnStateExit callback
        override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {
            animator.SetBool("FastBreath", fastBreath);
        }
    }
    
    
    public class RunBehaviour : StateMachineBehaviour {
    
        // OnStateUpdate is called at each Update frame between OnStateEnter and OnStateExit callback
        override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) 
        {
            BreathBehaviour[] breathBehaviours = animator.GetBehaviours<BreathBehaviour>();
            for(int i=0;i<breathBehaviours.Length();i++)
                 breathBehaviours[i].fastBreath = true;
        }
    }

    Animator.GetBoneTransform 获取骨骼变换
    返回人形骨骼ID映射的变换

    Animator.GetBool 获取布尔
    获取布尔参数的值

    Animator.GetCurrentAnimationClipState 获取当前动画剪辑状态
    获取当前状态播放的当前动画信息列表

    Animator.GetCurrentAnimatorStateInfo 获取当前动画器状态信息
    获取指定的AnimatorController层的当前状态信息

    Animator.GetFloat 获取浮点数
    获取一个浮点数参数的值

    Animator.GetIKHintPosition 获得IKHint位置
    获得IKHint的位置。

    Animator.GetIKHintPositionWeight 获得IKHint位置权重
    获取IK Hint的过渡的权重。 (0表示IK之前的原始动画,1表示在Hint)。

    Animator.GetIKPosition 获取IK位置
    获取IK目标的位置
    IK goal是指定身体部分的目标旋转和位置。Unity可以计算怎么移动该部分从开始点向目标(如,从动画获得的当前位置和旋转)。
    此函数获取世界坐标指定目标的当前位置

    Animator.GetIKPositionWeight 获取IK位置权重
    获取IK目标的过渡权重(0表示IK之前的原始动画,1表示目标的动画)
    IK goal是指定身体部分的目标旋转和位置。Unity计算从开始点怎么移动该部分到目标(如,从动画获得的当前位置和旋转)。
    该点由IK计算也受从开始到目标之间的权重值范围0~1的值影响。此函数返回当前目标位置的权重值

    Animator.GetIKRotation 获取IK旋转
    获取IK目标的旋转
    IK goal是指定身体部分的目标旋转和位置。Unity可以计算怎么移动该部分从开始点向目标(如,从动画获得的当前位置和旋转)
    此函数获取世界坐标指定目标的当前旋转。

    Animator.GetIKRotationWeight 获取IK旋转权重
    获取IK目标的旋转权重(0表示IK之前的旋转,1表示IK目标的旋转)
    IK goal是指定身体部分的目标旋转和位置。Unity可以计算怎么移动该部分从开始点向目标(如,从动画获得的当前位置和旋转)。
    该旋转由IK计算也受从开始到目标之间的权重值范围0~1的值影响。此函数返回当前目标旋转的权重值。

    Animator.GetInteger 获取整数
    获取整数参数的值

    Animator.GetLayerName 获取层名称
    获取该层的名称。

    Animator.GetLayerWeight 获取层权重
    过去该层的当前权重

    Animator.GetNextAnimationClipState 获取下个动画剪辑的状态
    获取当前播放动画信息列表的下个状态
    仅在过渡期间有效

    Animator.GetNextAnimatorStateInfo 获取下个动画器状态信息
    获取指定的AnimatorController层上的下个状态信息
    仅在过渡期间有效

    Animator.HasState 有状态?
    如果在动画器控制器是当前动画状态返回true

    Animator.InterruptMatchTarget 中断匹配目标
    中断目标自动匹配
    CompleteMatch 将使游戏对象在下一帧完全匹配目标

    Animator.IsInTransition 是否在过渡
    指定的AnimatorController层是否在过渡

    Animator.IsParameterControlledByCurve
    如果参数是由动画的附加曲线控制,返回真

    Animator.MatchTarget 匹配目标
    自动调节该对象的位置和旋转,因此,在当前状态是在指定的进度时,AvatarTarget达到matchPosition
    目标匹配仅工作与基本层(索引为0)

    Animator.Play 播放
    播放一个状态
    这个可以用于同步带有音频的动画或同步在网络上的动画

    Animator.PlayInFixedTime 以固定时间播放
    与animator.crossfade相同,但在目标状态的持续时间和偏移是在固定的时间
    两个状态必须在同一层。
    不能再同步层改变当前状态,你需要在索引层来改变它。

    Animator.Rebind 重新绑定
    重新绑定动画器的所有动画的属性和网格数据
    这个函数用于当你手动通过脚本修改对象的层级时使用,像合并网格或交换一个完整的变换层级。

    Animator.ResetTrigger 重设触发
    重设该触发参数为假
    这个触发参数就像布尔参数,但该参数一旦重设到false,该参数就已经消耗了一个过渡状态

    Animator.SetBool 设置布尔
    设置一个布尔参数的值

    Animator.SetFloat 设置浮点数
    设置一个浮点数的值

    Animator.SetIKHintPosition 设置IKHint位置
    设置IK Hint位置

    Animator.SetIKHintPositionWeight 设置IKHint位置权重
    设置IK hint过渡权重(0表示IK之前的原始动画,1表示在hint)

    Animator.SetIKPosition 设置IK位置
    设置一个IK goal的位置
    K goal是指定身体部分的目标旋转和位置。Unity计算从开始点怎么移动该部分到目标(如,从动画获得的当前位置和旋转)。
    这个函数设置在世界坐标最终的目标位置;实际的点是在身体部件结束,也受从开始和目标IK目标之间的指定的权重参数影响(值的范围在0~1).

    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        public Transform objToPickUp;
        private Animator animator;
        void Start() {
            animator = GetComponent<Animator>();
        }
        void OnAnimatorIK(int layerIndex) {
            float reach = animator.GetFloat("RightHandReach");
            animator.SetIKPositionWeight(AvatarIKGoal.RightHand, reach);
            animator.SetIKPosition(AvatarIKGoal.RightHand, objToPickUp.position);
        }
    }

    Animator.SetIKPositionWeight 设置IK位置权重
    设置IK goal的过渡权重(0表示IK之前的原始动画,1表示目标动画)
    IK goal是指定身体部分的目标旋转和位置。Unity计算从开始点怎么移动该部分到目标(如,从动画获得的当前位置和旋转)。
    此函数来确定从开始到目标位置之间设置范围0~1的IK目标的权重值。此位置本身是使用SetIKPosition设置。

    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        public Transform objToPickUp;
        private Animator animator;
        void Start() {
            animator = GetComponent<Animator>();
        }
        void OnAnimatorIK(int layerIndex) {
            float reach = animator.GetFloat("RightHandReach");
            animator.SetIKPositionWeight(AvatarIKGoal.RightHand, reach);
            animator.SetIKPosition(AvatarIKGoal.RightHand, objToPickUp.position);
        }
    }

    Animator.SetIKRotation 设置IK旋转
    设置IK goal的旋转
    IK goal是指定身体部分的目标旋转和位置。Unity可以计算怎么移动该部分从开始点向目标(如,从动画获得的当前位置和旋转)。
    这个函数设置在世界坐标最终的目标位置;实际的旋转是在身体部件结束,也受从开始和目标IK目标之间的指定的权重参数影响(值的范围在0~1).

    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        public Transform objToAimAt;
        private Animator animator;
        void Start() {
            animator = GetComponent<Animator>();
        }
        void OnAnimatorIK(int layerIndex) {
            Quaternion handRotation = Quaternion.LookRotation(objToAimAt.position - transform.position);
            animator.SetIKRotationWeight(AvatarIKGoal.RightHand, 1.0F);
            animator.SetIKRotation(AvatarIKGoal.RightHand, handRotation);
        }
    }

    Animator.SetIKRotationWeight 设置IK旋转权重
    设置IK goal的旋转权重(0表示IK之前的旋转,1表示IK目标旋转)。
    IK goal是指定身体部分的目标旋转和位置。Unity计算从开始点怎么移动该部分到目标(如,从动画获得的当前位置和旋转)。
    此函数来确定从开始到目标位置之间设置范围0~1的IK目标的权重值。此目标本身是使用SetIKRotation设置。

    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        public Transform objToAimAt;
        private Animator animator;
        void Start() {
            animator = GetComponent<Animator>();
        }
        void OnAnimatorIK(int layerIndex) {
            Quaternion handRotation = Quaternion.LookRotation(objToAimAt.position - transform.position);
            animator.SetIKRotationWeight(AvatarIKGoal.RightHand, 1.0F);
            animator.SetIKRotation(AvatarIKGoal.RightHand, handRotation);
        }
    }

    Animator.SetInteger 设置整数
    设置一个整数参数的值

    Animator.SetLayerWeight 设置层权重
    设置该层的当前权重

    Animator.SetLookAtPosition 设置注视的位置
    设置注视的位置

    Animator.SetLookAtWeight 设置注视权重
    设置注视的权重

    Animator.SetTarget 设置目标
    设置AvatarTarget和targetNormalizedTime 用于当前状态
    一旦该帧被计算,该位置和旋转可以使用targetPosition和targetRotation进行查询

    Animator.SetTrigger 设置触发器
    设置一个要激活的触发器参数
    触发器是参数,大多数行为像布尔,但当它们被用在过渡时,重置为无效

    Animator.StartPlayback 开始播放
    在播放模式设置动画
    在该模式,动画器不是从游戏逻辑更新以及被控制,而是设置时间的值。注意,时间不会自动进度这里,你必须从playbackTime显式操纵它。PlaybackRecordedFrame应该用于播放记录的数据。

    Animator.StartRecording 开始记录
    设置动画器的记录模式并分配frameCount大小的圆形缓冲区
    再调用该函数之前,记录器在缓冲区开始收集达到frameCount帧。注意,这不可能开始播放,直到调用了StopRecording时停止。

    Animator.StopPlayback 停止播放
    停止动画器播放模式。当播放停止时,Avatar恢复从游戏逻辑获得控制权

    Animator.StopRecording 停止记录
    停止动画器记录模式
    在当前状态调用StopRecording将锁定记录缓冲区的内容。数据被保留为以后使用startplayback播放

    Animator.Update 更新
    基于deltaTime计算动画器
    用此函数更新动画器,不能很好的工作于物理引擎或其他系统,通常是由游戏循环计算

    Animator.StringToHash 字符串到哈希
    从字符串生成一个参数ID。
    ID是用于参数的存取器优化(setters 和 getters)。

    AnimatorClipInfo 动画器剪辑信息

    有关动画器播放和动画混合的剪辑信息

    AnimatorClipInfo.clip 剪辑
    返回动画器播放的动画剪辑

    AnimatorClipInfo.weight 权重
    返回动画器混合该剪辑的混合权重

    AnimatorControllerParameter 动画器控制器参数

    用于脚本和控制器之间的通信。某些参数可以在脚本和控制器中设置,而其他参数基于动画剪辑的自定义曲线控制并可以使用脚本API进行采样

    AnimatorControllerParameter.defaultBool 默认布尔
    用于该参数的默认布尔值

    AnimatorControllerParameter.defaultFloat 默认浮点数
    用户该参数的默认浮点数值

    AnimatorControllerParameter.defaultInt 默认整数
    用户该参数的默认整数值

    AnimatorControllerParameter.name 名称
    该参数的名称

    AnimatorControllerParameter.nameHash 该名称哈希
    返回基于该参数名称的哈希

    AnimatorControllerParameter.type 类型
    该参数的类型

    AnimatorOverrideController 动画器重写控制器

    控制AnimatorOverrideController的接口
    AnimatorOverrideController 用来重写给定avatar的控制器的某些动画剪辑

    Animator animator = GetComponent<Animator>();
    
    AnimatorOverrideController overrideController = new AnimatorOverrideController();
    
    animator.runtimeAnimatorController = overrideController; 

    AnimatorOverrideController .clips
    返回的列表及剪辑从控制器及其覆盖剪辑

    AnimatorOverrideController .runtimeAnimatorController
    控制器AnimatorOverrideController覆盖

    AnimatorOverrideController.this[string]
    返回重写剪辑如果设置或原始剪辑命名的名字

    AnimatorStateInfo 动画器状态信息

    有关当前或下一个状态的动画器信息
    AnimatorStateInfo.fullPathHash 完整路径哈希
    该状态的完整路径哈希值。

    AnimatorStateInfo.length 长度
    该状态的当前持续长度
    当该状态包含混合树时,表示多少秒的变化

    AnimatorStateInfo.loop 循环
    在此状态的所有动画必须循环

    AnimatorStateInfo.normalizedTime 归一化时间
    该状态的归一化时间
    整数部分是时间状态的已循环数。小数部分是当前循环的百分比进程(0-1)。

    AnimatorStateInfo.shortNameHash 短名称哈希
    使用Animator.StringToHash生成的哈希值。传递的字符串不包含父层的名字

    AnimatorStateInfo.speed速度
    动画的播放速度。 1是正常的播放速度。

    AnimatorStateInfo.speedMultiplier
    这种状态的速度倍增。

    负面的乘数将向后播放动画速度。 如果没有参数被设置为这个速度 AnimatorState ,默认值是1

    AnimatorStateInfo.tagHash 标签的哈希
    该状态的标签
    该哈希由Animator.StringToHash生成

    AnimatorStateInfo.IsName 是否此名称
    在状态机激活的状态的名字是否匹配name
    该name应该是Layer.Name这样的形式,例如,Base.Idle

    AnimatorStateInfo.IsTag 是否此标签
    在状态机的激活状态的标签是否匹配tag。

    AnimatorTransitionInfo 动画器过渡信息

    动画器的当前有关过渡信息

    AnimatorTransitionInfo.anyState 任意状态
    如果任意状态或Animator.CrossFade()在过渡,返回true

    AnimatorTransitionInfo.fullPathHash 完整路径哈希
    过渡的唯一完整路径名称

    AnimatorTransitionInfo.nameHash 名称的哈希
    该过渡的唯一名称

    AnimatorTransitionInfo.normalizedTime
    该过渡的归一化时间。0.0~1.0

    AnimatorTransitionInfo.userNameHash 用户名称哈希
    该过渡的用户指定的名称。

    AnimatorTransitionInfo.IsName 是否此名称
    该激活过渡的名称是否匹配name

    AnimatorTransitionInfo.IsUserName 是否此用户名称
    该激活过渡的名称是否匹配userName

    AnimatorUtility 动画器工具

    AnimatorUtility.DeoptimizeTransformHierarchy 再优化变换层级
    该函数将重建GameObject下的所用transform层级
    当运行时调用该函数将重新初始化该动画器

    AnimatorUtility.OptimizeTransformHierarchy 优化变换层级
    该函数将移除GameObject下的所有层级,该动画器将直接写入变换矩阵到蒙皮网格矩阵以节省更多的CPU运算
    您可以有选择地地提供变换名称的列表,这个功能将在GameObject下创建一个扁平化的变换层次结构
    这个函数在运行时调用将重新初始化该动画器

    Application 应用程序

    Application.absoluteURL 绝对URL
    到web播放器数据文件夹的绝对路径

    检测你的数据文件是否被移动到其他的服务器
    或是被链接到其他地方

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Start() 
        {
            bool isPirated = false;
            if (Application.isWebPlayer) 
            {               //源文件
            if (Application.srcValue != "game.unity3d")
                isPirated = true;
    
            if (String.Compare(Application.absoluteURL, "http://www.website.com/Game/game.unity3d", true) != 0)
                isPirated = true;
    
            if (isPirated)
                print("Pirated web player");
    
            }
        }
    }

    Application.AdvertisingIdentifierCallback
    委托方法获取广告ID

    Application.backgroundLoadingPriority 后台加载优先级
    后台装载线程优先级

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {   //装载尽可能多的数据传输速率,因此帧将下降
            //加载时显示出良好的快速进度条
            Application.backgroundLoadingPriority = ThreadPriority.High;
            //加载数据速度非常慢,尽量不影响游戏性能的
            //在游戏进行时有很好的后台加载
            Application.backgroundLoadingPriority = ThreadPriority.Low;
        }
    }

    Application.bundleIdentifier
    返回应用程序在运行时包标识符

    Application.CancelQuit 取消退出
    取消退出。这可以用来在退出游戏的时候显示一个退出画面

    延迟2秒退出。
    在这段时间内加载退出画面

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
                     //启动显示超时
        public float showSplashTimeout = 2.0F;
        private bool allowQuitting = false;
        void Awake() 
        {   // 需要在多个关卡中使用的游戏物体
            DontDestroyOnLoad();
        }
        void OnApplicationQuit() 
        {       // 如果我们还没有加载到最后的退出画面           
            if (Application.loadedLevelName.ToLower() != "finalsplash")
                StartCoroutine("DelayedQuit");
            // 如果我们还没有加载到最后的退出画面
            if (!allowQuitting)
                Application.CancelQuit();
    
        }
        IEnumerator DelayedQuit() 
        {
            Application.LoadLevel("finalsplash");
            // 等待showSplashTimecout
            yield return new WaitForSeconds(showSplashTimeout);
            // 然后退出
            allowQuitting = true;
            Application.Quit();
        }
    }

    Application.CanStreamedLevelBeLoaded 流关卡被加载
    流模式加载的关卡是否被加载?

    例一
    检查如果索引为1的关卡可以被加载
    如果能被加载就加载它

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Update() 
        {
            if (Application.CanStreamedLevelBeLoaded(1))
                Application.LoadLevel(1);
    
        }
    }

    例二
    检查如果Level1可以加载,如果能加载就加载它

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Update() 
        {
            if (Application.CanStreamedLevelBeLoaded("Level1"))
                Application.LoadLevel("Level1");
    
        }
    }

    Application.CaptureScreenshot 截屏
    捕捉屏幕作为一个PNG文件保存在路径filename。简单来说就是截屏

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void OnMouseDown() 
        {
            Application.CaptureScreenshot("Screenshot.png");
        }
    }

    Application.cloudProjectId
    一个独特的云项目标识符。 这对每一个项目都是独一无二的(只读)

    Application.companyName
    返回应用程序的公司名称(只读)

    Application.dataPath 数据路径
    包含游戏数据文件夹的路径

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {   // 打印到数据文件夹的路径
            print(Application.dataPath);
        }
    }

    Application.ExternalCall 外部调用
    调用一个包含在网页中的函数(只用于Web Player)

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {   // 调用网页上的MyFunction1并不使用参数
            Application.ExternalCall("MyFunction1");
            //调用网页上的MyFunction2并使用字符串参数
            Application.ExternalCall("MyFunction2", "Hello from Unity!");
            //调用网页上的MyFunction3并使用几个不同类型的参数
            Application.ExternalCall("MyFunction3", "one", 2, 3.0F);
        }
    }
    

    被调用的在HTML中的函数只需要使用标准的语法即可

    <script language="JavaScript" type="text/javascript">
    <!--  
    
    // 使用来自Unity的调用,这将接受
    // "Hello from Unity!" 做为参数
    function MyFunction2( arg )
        {
            alert( arg );
        }
    -->
    </script>

    Application.ExternalEval 外部运行
    调用包含在网页中的片段脚本函数(只用于Web Player)

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {   //返回前一页
            Application.ExternalEval("history.back()");
        }
    }

    Application.HasProLicense
    统一激活与职业执照吗?

    Application.HasUserAuthorization
    检查用户是否已批准使用的摄像头或麦克风在Web的球员。

    这是用来检查前一个调用的结果 Application.RequestUserAuthorization 。 显式的用户同意使用功能是只需要在Web的球员。 在其他的构建 目标,这个函数始终返回true。

    Application.genuine
    返回false如果应用程序更改后以任何方式。

    否则返回true

    Application.genuineCheckAvailable
    如果应用程序完整性可以确认返回true。

    否则返回false

    Application.GetStreamProgressForLevel 获取关卡的流进度
    (下载的进度是多少?)

    例一
    在文本框打印在场景1里下载了多少?
    当完成时,打印”Level 1 has been fully streamed!”

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public float percentageLoaded = 0;
        void Update() 
        {
            if (Application.GetStreamProgressForLevel(1) == 1)
                guiText.text = "Level at index 1 has been fully streamed!";
            else 
            {
                percentageLoaded = Application.GetStreamProgressForLevel(1) * 100;
                guiText.text = percentageLoaded.ToString();
            }
        }
    }

    例二
    在文本框打印在场景”Level1”里下载了多少?
    当完成时,打印”Level 1 has been fully streamed!”

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
                     //加载百分比
        public float percentageLoaded = 0;
        void Update() 
        {
            if (Application.GetStreamProgressForLevel("Level1") == 1)
                guiText.text = "Level 1 has been fully streamed!";
            else 
            {
                percentageLoaded = Application.GetStreamProgressForLevel("Level1") * 100;
                guiText.text = percentageLoaded.ToString();
            }
        }
    }

    Application 应用程序
    访问应用程序的运行时数据

    Application.installMode
    返回应用程序安装模式(只读)

    Application.internetReachability
    返回类型的网络可达性目前可能在设备上。

    这个属性是有用的区分快速和手持设备上 廉价的无线网络连接从运营商网络

    Application.isConsolePlatform
    是当前运行时平台一个已知主机平台

    Application.isEditor 是否编辑器
    是在Unity编辑器内运行?

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {
            if (Application.isEditor)
                print("We are running this from inside of the editor!");
    
        }
    }

    Low Application.isLoadingLevel 正在加载关卡?
    是否正在加载某些关卡
    改为 SceneManager.LoadSceneAsync

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {
            print(Application.isLoadingLevel);
        }
    }

    Application.isMobilePlatform
    是当前运行时平台一个已知的移动平台。

    请注意 :在Windows上存储应用这个属性始终返回true

    Application.isPlaying 是否播放
    当在任何种类的播放器时,返回真

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {
            if (Application.isPlaying)
                print("In player or playmode");
    
        }
    }
    

    Application.isShowingSplashScreen
    检查是否显示闪屏。

    返回true,如果应用程序显示闪屏

    Application.isWebPlayer 是否网页播放器
    是否在一个网页播放器中运行?

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {
            if (Application.isWebPlayer)
                print("We are running this from inside of the web player!");
    
        }
    }

    Low Application.levelCount 关卡数
    可用的关卡总数
    改为 SceneManager.sceneCountInBuildSettings
    随机加载一个关卡

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {                                                     //为什么要减一
            Application.LoadLevel(Random.Range(0, Application.levelCount - 1));
        }
    }

    Low Application.loadedLevel 加载的关卡
    最后加载的关卡索引,关卡也就是一个独立的场景
    改为 SceneManager

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {   //打印当前场景的代号(索引号)
            print(Application.loadedLevel);
        }
    }

    Low Application.loadedLevelName 加载的关卡名字
    最后加载的关卡的名字
    改为 SceneManager

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {   //打印当前场景名字
            print(Application.loadedLevelName);
        }
    }

    Low Application.LoadLevel 加载关卡
    加载关卡,也就是加载一个新的场景
    改为 SceneManager.LoadScene
    例一
    加载索引为 0 的关卡

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {   
            Application.LoadLevel(0);
        }
    }
    

    例二
    加载名为”HighScore”的关卡

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {
            Application.LoadLevel("HighScore");
        }
    }

    Low Application.LoadLevelAdditive 累加关卡
    累加一个关卡,也就是说,加载一个新的场景,当前场景不会被销毁
    改为 SceneManager.LoadScene

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {   //加载关卡索引为1的关卡
            Application.LoadLevelAdditive(1);
            //加载名为MoreStuff的关卡
            Application.LoadLevel("MoreStuff");
        }
    }

    Low Application.LoadLevelAdditiveAsync 异步累加关卡
    在后台异步累加关卡,也就是说在后台非同步加载新的场景,但当前的场景不会被销毁
    改为 SceneManager.LoadSceneAsync

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        IEnumerator Start() 
        {   //加载名为MyAddLevel的场景
            AsyncOperation async = Application.LoadLevelAdditiveAsync("MyAddLevel");
            yield return async;
            Debug.Log("Loading complete");
        }
    }

    Low Application.LoadLevelAsync 异步加载关卡
    在后台异步加载关卡,也就是说,在后台非同步加载新的场景
    改为 SceneManager.LoadSceneAsync

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        IEnumerator Start() 
        {   //加载名为MyBigLevel的场景
            AsyncOperation async = Application.LoadLevelAsync("MyBigLevel");
            yield return async;
            Debug.Log("Loading complete");
        }
    }

    Application.LogCallback 日志回调
    用RegisterLogCallback来使用这个委托类型,去监控什么得到记录了

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public string output = "";
        public string stack = "";
        void OnEnable() 
        {
            Application.RegisterLogCallback(HandleLog);
        }
        void OnDisable() 
        {   //当对象超出范围,删除回调
            Application.RegisterLogCallback(null);
        }
        void HandleLog(string logString, string stackTrace, LogType type) 
        {
            output = logString;
            stack = stackTrace;
        }
    }

    Application.OpenURL 打开网址
    在浏览器中打开url

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Start() 
        {
            Application.OpenURL("http://3d.ceeger.com/");
        }
    }

    Application.persistentDataPath 持久数据路径
    包含一个持久数据目录的路径

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Awake() 
        {   //打印该路径到持久数据文件夹
            print(Application.persistentDataPath);
        }
    }

    Application.platform 平台
    返回游戏运行的平台

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Start() 
        {
            if (Application.platform == RuntimePlatform.WindowsPlayer)
                print("Do something special here!");
    
        }
    }

    Application.Quit 退出
    退出应用程序。在编辑器或者web播放器中退出被忽略

    Low Application.RegisterLogCallback 注册日志回调
    在一个日志信息上注册一个委托来被调用

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public string output = "";
        public string stack = "";
        void OnEnable() 
        {
            Application.RegisterLogCallback(HandleLog);
        }
        void OnDisable() 
        {   //当对象超出范围,删除回调
            Application.RegisterLogCallback(null);
        }
        void HandleLog(string logString, string stackTrace, LogType type) 
        {
            output = logString;
            stack = stackTrace;
        }
    }

    Low Application.RegisterLogCallbackThreaded 线程的注册日志回调
    在一个日志信息上注册一个委托来被调用

    Application .RequestAdvertisingIdentifierAsync
    请求广告ID iOS、Android和Windows商店

    using System;
    using UnityEngine;
    
    public class SampleMonoBehaviour : MonoBehaviour
    {
        public void InvokeOnAdvertisingIdentifierCallback(string advertisingId, bool trackingEnabled, string error)
        {
           Debug.Log (" InvokeOnAdvertisingIdentifierCallback  " + advertisingId + " " + trackingEnabled + " " + error);
        }
    
        public void Start()
        {
            Application.RequestAdvertisingIdentifierAsync (
              (string advertisingId, bool trackingEnabled, string error) =>
                { Debug.Log ("advertisingId " + advertisingId + " " + trackingEnabled + " " + error); }
            );
        }
    }

    Application.RequestUserAuthorization
    请求授权使用摄像头或者麦克风在Web的球员。

    出于安全考虑(避免实施web播放器监视用户),我们需要 你有用户显式地允许这些功能在web的球员。 要做到这一点,你所需要的 调用应用程序。 RequestUserAuthorization,向用户显示一个对话框, 并等待操作完成之前能够使用这些特性。 使用 Application.HasUserAuthorization 查询操作的结果。

    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        IEnumerator Start() {
            yield return Application.RequestUserAuthorization(UserAuthorization.WebCam | UserAuthorization.Microphone);
            if (Application.HasUserAuthorization(UserAuthorization.WebCam | UserAuthorization.Microphone)) {
            } else {
            }
        }
    }

    Application.runInBackground 后台运行
    应用程序在后台时是否应该被运行?

    让游戏在后台时也运行

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {
            Application.runInBackground = true;
        }
    }

    Application.srcValue 源文件
    相对于html文件的web播放器数据文件的路径

    检测你的数据文件是否被移到其他的服务器
    或是被链接到其他地方

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Start() 
        {
            bool isPirated = false;
            if (Application.isWebPlayer) 
            {
                if (Application.srcValue != "game.unity3d")
                    isPirated = true;
    
                if (String.Compare(Application.absoluteURL, "http://www.website.com/Game/game.unity3d", true) != 0)
                    isPirated = true;
    
                if (isPirated)
                    print("Pirated web player");
    
            }
        }
    }

    Application.stackTraceLogType
    堆栈跟踪日志记录选项。 默认值是 StackTraceLogType.ScriptOnly 。

    有用,当你想要更多的调试信息输出到日志消息时日志。 例如,如果您设置 StackTraceLogType.Full 本地和管理堆栈跟踪信息将打印

    Application.streamedBytes 字节流
    我们从主Unity网页流中下载了多少字节

    输出到一个节界面文本,显示加载了多少字节流

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Update() 
        {
            guiText.text = "Streamed Bytes: " + Application.streamedBytes.ToString();
        }
    }

    Application.streamingAssetsPath
    包含StreamingAssets文件夹的路径(只读)。

    如果你有一个“StreamingAssets”文件夹中的资产项目的文件夹,这将是 复制到你的播放器构建和在给定的路径 Application.streamingAssetsPath。

    请注意,在某些平台上不可能直接访问StreamingAssets文件夹 因为没有文件系统访问的web平台,因为它被压缩 进了。 在Android上的apk文件。 在这些平台上,将返回一个url,可以使用 使用WWW类

    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        public string filePath = System.IO.Path.Combine(Application.streamingAssetsPath, "MyFile");
        public string result = "";
        IEnumerator Example() {
            if (filePath.Contains("://")) {
                WWW www = new WWW(filePath);
                yield return www;
                result = www.text;
            } else
                result = System.IO.File.ReadAllText(filePath);
        }
    }

    Application.systemLanguage 系统语言
    用户操作系统正在运行的语言

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {   //系统使用的实际语言打印到界面文本
            guiText.text = Application.systemLanguage.ToString();
        }
    }

    Application.targetFrameRate 目标帧速率
    命令游戏尝试以一个特定的帧率渲染(手游60)

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Awake() 
        {   //使游戏尽可能快的运行,在web播放器里
            Application.targetFrameRate = 300;
        }
    }

    Application.temporaryCachePath 临时数据路径
    包含一个临时数据/缓存目录的路径

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Awake() 
        {
            //打印路径到临时数据文件夹
    print(Application.temporaryCachePath);
        }
    }

    Application.unityVersion 版本
    用于播放内容的Unity运行时版本

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public void Awake() 
        {
            print("Version of the runtime: " + Application.unityVersion);
        }
    }

    Application.version
    返回应用程序版本号(只读)

    Application.webSecurityEnabled 网页安全模式
    指示是否webplayer的安全模式是否被启用

    AreaEffector2D 区域二维效果器

    在一个区域内使用力

    当源 Collider2D 触发器,效应将部队只要目标 Collider2D 重叠的来源。 当源 对撞机 不是一个触发器,只要目标效应将部队 Collider2D 只是接触源。

    这与源效应主要是为了工作 Collider2D 设置为触发器,这样的目标 Collider2D 可以定义的重叠区域。

    AreaEffector2D.angularDrag
    刚体角拖申请。

    的 angularDrag 系数是除了标准的应用 Rigidbody2D 角阻力系数提供额外的角阻力效应区。

    AreaEffector2D.drag
    线性阻力刚体申请。

    的 拖 系数是除了标准的应用 Rigidbody2D 阻力系数效应地区提供额外的阻力。

    AreaEffector2D.forceAngle
    力的角度应用。

    实际的角度将取决于不同 useGlobalAngle 是真或假。

    AreaEffector2D.forceMagnitude
    应用力的大小

    AreaEffector2D.forceTarget
    的目标效应适用于任何力量

    AreaEffector2D.forceVariation
    力的大小的变化。

    一个随机的值介于0到 forceVariation 使用和添加到力大小。 的 forceVariation 可以是负随机减少力大小

    AreaEffector2D.useGlobalAngle
    应该 forceAngle 使用全局空间?

    当真正的, forceAngle 在全球空间中指定。 当假的, forceAngle 在局部空间中指定。

    Other Array数组

    Array.Add 添加
    在数组末尾加入一个值

    var arr = new Array ("Hello");
    arr.Add("World");
    //打印结果"Hello", "World"
    print (arr);

    Array.Array 数组

    例一
    创建一个固定大小的数组

    var arr = new Array(5);
    //创建一个长度为5的新数组
    Debug.Log(arr.length);

    例二
    初始化一个JavaScript数组从一个.Net数组

    var intArray : int[] = new int[5];
    //创建一个长度为5的空数组
    var convertedArray : Array = new Array(intArray);
    //转换为JavaScript数组
    for (var i = 0; i < convertedArray.length; i++) 
    {
        Debug.Log("ConvertedArray[" +i + "]: " + convertedArray[i]);
        //打印数组
    }

    例三
    创建一个空数组

    var arr = new Array ();
    
    // Add one element //添加一个元素
    arr.Push ("Hello");
    // print the first element ("Hello")//打印第一个元素
    print(arr[0]);

    Array.Clear 清空
    清空数组,数组的长度将变为0

    var hello = new Array ("Hello", "World");
    hello.Clear();
    //hello数组被清空,为0元素

    Array.Concat 连接
    连接两个或更多数组,这个方法不会改变现有的数组,返回连接后数组的一个拷贝

    function Start () 
    {
        var arr = new Array ("Hello", "World");
        var arr2 = new Array ("!");
        // joined now contains all 3 strings //连接arr和arr2数组
        var joined = arr.Concat(arr2);
        // prints "Hello","World","!" //打印数组,两个数组中的3个字符串连接一起被输出。
        print(joined);
    }

    Array 数组
    数组允许你在一个变量中储存多个对象

    例一
    这里是一个你能用数组类做什么的基本的例子

    function Start () 
    {
        var arr = new Array ();
        // 添加一个元素
        arr.Push ("Hello");
        // 打印第一个元素"Hello"
        print(arr[0]);
        // 调整数组大小
        arr.length = 2;
        // 把 "World" 赋给第二个元素
        arr[1] = "World";
        // 遍历这个数组
        for (var value : String in arr) 
        {
            print(value);
        }
    }

    例二
    这里是一个如何使用内置数组的基本例子

    var values : float[];
    
    function Start () 
    {
        // 遍历数组
        for (var value in values) 
        {
            print(value);
        }
        // 由于我们不能调整内置数组的大小, 我们必须重新创建一个数组来调整其大小
        values = new float[10];
        // 给第二个元素赋值
        values[1] = 5.0;
    }

    例三

    function Start () 
    {
        var array = new Array (Vector3(0, 0, 0), Vector3(0, 0, 1));
        array.Push(Vector3(0, 0, 2));
        array.Push(Vector3(0, 0, 3));
        // 复制JS数组到内置数组
        var builtinArray : Vector3[] = array.ToBuiltin(Vector3);
        // 将内置数组赋给JS数组
        var newarr = new Array (builtinArray);
        // newarr包含相同的元素作为数组
        print (newarr);
    }

    Array.Join 连接
    连接数组中的内容到一个字符串。字符串的分隔符由seperator 指定

    function Start () 
    {
        var arr = new Array ("Hello", "World");
    
        // 打印结果 "Hello, World" ,由数组中的两个字符串变为现在的一个字符串。
        print(arr.join(", "));
    }

    Array.length 长度
    数组的长度属性, 返回或设置数组中元素的数量

    function Start () 
    {
        var arr = Array ("Hello", "World");
        // 打印数组的长度,现在为2
        print(arr.Length);
        // 重设数组的长度到5
        arr.length = 5;
    }

    Array.Pop 移除
    移除数组最后一个元素并返回它

    var arr = new Array ("Hello", "World");
    //移除末尾的一个元素
    arr.Pop();
    // 打印结果只有"Hello"
    print (arr);

    Array.Push 挤入
    在数组末尾添加值,并返回新的数组长度

    var arr = new Array ("Hello");
    arr.Push("World");
    //在数组末尾添加一个元素
    // 打印结果为"Hello", "World"
    print(arr);

    Array.RemoveAt 移除索引元素
    从数组中移除位于索引的元素

    var arr = new Array ("Hello", "and good morning", "World");
    // 移除第2号元素,"and good morning",,数组是从0开始的,1就是第二号了。
    arr.RemoveAt(1);
    //打印结果为"Hello,World"
    print (arr);

    Low Array.Reverse 反转
    反转数组中所有元素的顺序

    var hello = new Array ("Hello", "World");
    hello.Reverse();
    // 打印结果为 World, Hello
    print(hello);

    Array.Shift 移除第一个元素
    删除数组中的第一个元素,并返回被删除元素的值

    var arr = new Array ("Ceeger","Hello", "World");
    //移除第一个元素
    arr2 = arr.Shift();
    //arr2输出结果为Ceeger,移除第一个元素返回这个元素
    print (arr2);
    //arr输出结果为 "Hello,World"
    print (arr);

    Array.Sort 排序
    排序所有元素

    例一

    var hello = new Array ("c", "a", "b");
    hello.Sort();
    print(hello);
    // 打印结果按字母顺序排列 a, b, c

    例二

    var hello = new Array ("unity", "中国", "钓鱼岛","圣典","3D","人民","大家");
    hello.Sort();
    print(hello);
    // 打印结果为 3D,unity,中国,人民,圣典,大家,钓鱼岛,看样子数字排在最前面,字母紧随其后,其他语言垫底,貌似中文的排序是按照字母倒序

    Array.Unshift 首位添加
    在数组开始位置添加一个或多个元素并返回新的数组长度

    var arr = new Array ("圣", "典");
    arr.Unshift("中文手册", "Unity");
    // 打印结果为"中文手册,Unity,圣,典"
    print(arr);

    AssetBundle 资源包

    AssetBundle.Contains 包含(**??)
    检查是否一个AssetBundle包含一个特定的对象。

    如果一个对象被返回true 的名字 包含在AssetBundle,否则假

    AssetBundle 资源包
    AssetBundles让你通过WWW类流式加载额外的资源并在运行时实例化它们。AssetBundles通过BuildPipeline.BuildAssetBundle创建

    IEnumerator Start () 
    {
        WWW www = new WWW("http://myserver/myBundle.unity3d");
        yield return www;
    
        // Get the designated main asset and instantiate it.
        Instantiate(www.assetBundle.mainAsset);
    }

    AssetBundle.GetAllAssetNames
    返回所有AssetBundle资产名称。

    只适用于正常AssetBundles(AssetBundle non-streamed场景),否则返回空字符串数组

    AssetBundle.GetAllScenePaths
    返回所有现场资产路径(路径*。 AssetBundle统一资产)。

    只适用于流场景AssetBundles,否则返回空字符串数组

    Low AssetBundle.Load 加载
    从bundle中加载名为name的对象
    改为 AssetBundle.LoadAsset

    Low AssetBundle.LoadAll 加载全部
    加载所有包含在asset bundle中且继承自type的对象
    改为 AssetBundle.LoadAllAssets

    Low AssetBundle.LoadAsync 异步加载
    异步地从bundle中加载被指定类型的名为name的对象
    改为 AssetBundle.LoadAssetAsync

    AssetBundle.LoadAssetWithSubAssets
    加载和子资产与资产 的名字 的包

    AssetBundle.LoadAssetWithSubAssetsAsync
    加载次级资产与资产 的名字 异步的包

    AssetBundle.LoadFromFile
    同步负载AssetBundle从磁盘上的文件中。

    函数支持任何压缩类型的包。 在的情况下 lzma 压缩,数据将被解压缩内存。 未压缩的和chunk-compressed包可以直接从磁盘读取。

    相比 LoadFromFileAsync ,这个版本是同步的,不会返回,直到它完成创建AssetBundle对象。

    这是最快的方法来加载一个AssetBundle。

    using UnityEngine;
    using System.Collections;
    
    public class LoadFromFileExample : MonoBehaviour
    {
        void Start ()
        {
            var myLoadedAssetBundle = AssetBundle.LoadFromFile(Path.Combine(Application.streamingAssetsPath, "myassetBundle"));
            if (myLoadedAssetBundle == null)
            {
                Debug.Log("Failed to load AssetBundle!");
                return;
            }
    
            var prefab = myLoadedAssetBundle.LoadAsset<GameObject>("MyObject");
            Instantiate(prefab);
    
            myLoadedAssetBundle.Unload(false);
        }
    }

    AssetBundle.LoadFromFileAsync
    异步加载一个AssetBundle从磁盘上的文件。

    函数支持任何压缩类型的包。 在的情况下 lzma 压缩,数据将被解压缩内存。 未压缩的和chunk-compressed包可以直接从磁盘读取。

    这是最快的方法来加载一个AssetBundle

    using UnityEngine;
    using System.Collections;
    
    public class LoadFromFileAsyncExample : MonoBehaviour
    {
        IEnumerator Start ()
        {
            var bundleLoadRequest = AssetBundle.LoadFromFileAsync(Path.Combine(Application.streamingAssetsPath, "myassetBundle"));
            yield return bundleLoadRequest;
    
            var myLoadedAssetBundle = bundleLoadRequest.assetBundle;
            if (myLoadedAssetBundle == null)
            {
                Debug.Log("Failed to load AssetBundle!");
                yield break;
            }
    
            var assetLoadRequest = myLoadedAssetBundle.LoadAssetAsync<GameObject>("MyObject");
            yield return assetLoadRequest;
    
            GameObject prefab = assetLoadRequest.asset as GameObject;
            Instantiate(prefab);
    
            myLoadedAssetBundle.Unload(false);
        }
    }

    AssetBundle.LoadFromMemory
    同步创建一个AssetBundle内存区域。

    使用这个方法来创建一个AssetBundle从一个字节数组。 这是非常有用的,当你下载的数据加密和未加密需要创建AssetBundle字节。

    相比 LoadFromMemoryAsync ,这个版本是同步的,不会返回,直到它完成创建AssetBundle对象

    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        byte[] MyDecription(byte[] binary) {
            byte[] decrypted;
            return decrypted;
        }
        IEnumerator Start() {
            WWW www = new WWW("http://myserver/myBundle.unity3d");
            yield return www;
            byte[] decryptedBytes = MyDecription(www.bytes);
            AssetBundle assetBundle = AssetBundle.LoadFromMemory(decryptedBytes);
        }
    }

    AssetBundle.LoadFromMemoryAsync
    创建一个异步AssetBundle内存区域。

    使用这个方法来创建一个异步AssetBundle从字节数组。 这是非常有用的,当你已经下载了数据加密使用WWW和需要创建的AssetBundle加密字节。

    相比 LoadFromMemory ,这个版本将执行AssetBundle压缩在一个后台线程,并且不会立即创建AssetBundle对象

    AssetBundle.mainAsset 主资源
    主资源在构建资源boundle时指定

    该功能可以方便的找到bundle内的主资源

    IEnumerator Start () {
        WWW www = new WWW("http://myserver/myBundle.unity3d");
        yield return www;
    
        // Get the designated main asset and instantiate it.
        Instantiate(www.assetBundle.mainAsset);
    }

    AssetBundle.Unload 卸载
    卸载所有包含在bundle中的对象

    (等待个0.5秒到1秒之后再进行Unload。这样就不会出现instantiate渲染中就运行unload的情况了)

    AssetBundleCreateRequest 资源包创建请求

    异步创建一个请求 AssetBundle

    AssetBundleCreateRequest.assetBundle 资源包
    资产对象被加载(只读)。

    注意,之前访问资产 结束 是真的将摊位加载过程。

    AssetBundleManifest 资源包名单

    清单中的所有assetBundle构建

    AssetBundleManifest.GetAllAssetBundles 获取所有资源包
    得到所有的AssetBundles清单

    AssetBundleManifest.GetAllAssetBundlesWithVariant 获取所有变体资源包
    得到所有与变体AssetBundles清单

    AssetBundleManifest.GetAllDependencies 获取所有依赖关系
    得到所有的依赖AssetBundles

    AssetBundleManifest.GetAssetBundleHash 获取资源包哈希值
    得到给定AssetBundle散列

    AssetBundleManifest.GetDirectDependencies 获得直接依赖关系
    得到给定AssetBundle AssetBundles直接依赖

    AssetBundleRequest 资源包请求

    AssetBundleRequest.asset
    正在加载的资源物体

    AssetBundleRequest.allAssets
    资产与子资产被加载对象。 (只读)

    注意,之前访问资产 结束 是真的将摊位加载过程

    AssetBundleRequest 资源包请求
    从一个资源包(AssetBundle)异步加载请求

    Editor AssetDatabase 资源数据库

    AssetDatabase.AddObjectToAsset 添加对象到资源
    将objectToAdd这个对象添加到指定路径上的现有资源

    例一

    @MenuItem("GameObject/Create Material")
    static function CreateMaterial () 
    {
        //新建一个简单的材质资源
        var material = new Material (Shader.Find("Specular"));(这个是?)
        AssetDatabase.CreateAsset(material, "Assets/MyMaterial.mat");
    
        //添加一个动画剪辑到材质上
        var animationClip = new AnimationClip ();
        animationClip.name = "My Clip";
        AssetDatabase.AddObjectToAsset(animationClip, material);
    
        //在新建一个对象后重新导入资源
        //否则这个更改只会在保存工程时才显示
        AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(animationClip));
    
        //打印新建的资源
        Debug.Log(AssetDatabase.GetAssetPath(material));
    }

    例二

    @MenuItem("GameObject/Create Material")
    static function CreateMaterial () 
    {
        //新建一个新的材质资源
        var material = new Material (Shader.Find("Specular"));
        AssetDatabase.CreateAsset(material, "Assets/MyMaterial.mat");
    
        //添加一个动画剪辑到材质上
        var animationClip = new AnimationClip ();
        animationClip.name = "My Clip";
        AssetDatabase.AddObjectToAsset(animationClip, material);
    
        //添加对象后重新导入资源
        //否则这个更改只会在保存工程时才显示
        AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(animationClip));
        //打印新建的资源
        Debug.Log(AssetDatabase.GetAssetPath(material));
    }

    AssetDatabase.AssetPathToGUID 资源路径转GUID(**??)
    返回指定路径path下资源的GUID(全局唯一标识符)

    using UnityEngine;
    using UnityEditor;
    
    public class Example : MonoBehaviour {
        [MenuItem("AssetDatabase/AssetPathToGUID")]
        static void Doit() {
            var t = AssetDatabase.AssetPathToGUID("Assets/texture.jpg");
            Debug.Log(t);
        }
    }

    AssetDatabase.ClearLabels 清除标签
    移除资源上所有的标签

    Low AssetDatabase.CompleteLabel 完成的标签(**??)
    返回符合给定前缀的所有标签

    AssetDatabase.Contains 包含
    资源中是否存在该对象?

    AssetDatabase.CopyAsset 复制资源
    复制指定路径的资源文件到一个新的路径

    AssetDatabase.CreateAsset 新建资源
    在指定的路径新建资源

    @MenuItem("GameObject/Create Material")
    static function CreateMaterial () 
    {
        //新建一个简单的材质资源
        var material = new Material (Shader.Find("Specular"));
        AssetDatabase.CreateAsset(material, "Assets/MyMaterial.mat");
    
        //打印新建资源的路径
        Debug.Log(AssetDatabase.GetAssetPath(material));
    }

    AssetDatabase.CreateFolder
    创建一个新的文件夹

    string guid = AssetDatabase.CreateFolder("Assets", "My Folder");
    string newFolderPath = AssetDatabase.GUIDToAssetPath(guid);

    AssetDatabase.DeleteAsset 删除资源
    删除指定路径的资源文件

    AssetDatabase.ExportPackage 导出包
    导出assetPahtNames定义的资源到一个unitypackage里,并命名filename

    AssetDatabase.FindAssets
    使用一个搜索过滤器字符串搜索资产数据库。

    你可以搜索名称、标记和类型(类名)。
    “名称”:过滤文件名(不扩展)资产。 单词由空格分隔被视为单独的名称搜索。 使用引用多个单词分组到单个搜索。

    “标签”:使用关键字“l”。 过滤由多个标签将返回资产如果只有一个资产标签相匹配(或)

    “类型”:使用关键字“t”。 超过一种类型的过滤将返回资产如果只有一个类型匹配(或)。 类型可以是内置类型e。 g“Texture2D”类名或用户脚本。 如果所有的资产都想要的:使用“对象”作为所有资产来源于对象。

    搜索是大小写不敏感

    using UnityEngine;
    using UnityEditor;
    
    public class Example {
    
        [MenuItem("Test/FindAssetsUsingSearchFilter")]
        static void FindAssetsUsingSearchFilter() {
            // Find all assets labelled with 'concrete' :
            string[] guids = AssetDatabase.FindAssets ("l:concrete");
    
            foreach (string guid in guids) {
                Debug.Log (AssetDatabase.GUIDToAssetPath(guid));
            }
    
            // Find all Texture2Ds that have 'co' in their filename, that are labelled with 'concrete' or 'architecture' and are placed in 'MyAwesomeProps' folder
            string[] lookFor = new string[] {"Assets/MyAwesomeProps"};
            string[] guids2 = AssetDatabase.FindAssets ("co l:concrete l:architecture t:texture2D", lookFor);
    
            foreach (string guid in guids2) {
                Debug.Log (AssetDatabase.GUIDToAssetPath(guid));
            }
        }
    }

    AssetDatabase.GenerateUniqueAssetPath 生成唯一资源路径
    给一个资源创建一个新的唯一路径

    AssetDatabase.GetAllAssetBundleNames
    资产数据库中返回所有AssetBundle名称

    using UnityEditor;
    using UnityEngine;
    
    public class GetAssetBundleNames
    {
        [MenuItem ("Assets/Get Asset Bundle names")]
        static void GetNames ()
        {
            var names = AssetDatabase.GetAllAssetBundleNames();
            foreach (var name in names)
                Debug.Log ("Asset Bundle: " + name);
        }
    }

    AssetDatabase.GetAssetOrScenePath
    返回路径名相对于资产存储的项目文件夹。

    所有路径是相对于项目文件夹,例如:“资产/ MyTextures / hello.png” 当一个游戏对象是一个场景的一部分,现场返回路径。

    AssetDatabase.GetAssetPath 获取资源路径
    返回相对于工程资源位置的路径名

    @MenuItem("GameObject/Create Material")
    static function CreateMaterial () 
    {
        //新建一个简单的材质资源
        var material = new Material (Shader.Find("Specular"));
        AssetDatabase.CreateAsset(material, "Assets/MyMaterial.mat");
    
        //打印新建资源的路径
        Debug.Log(AssetDatabase.GetAssetPath(material));
    }

    AssetDatabase.GetAssetPathFromTextMetaFilePath
    得到与文本相关的资产文件的路径。 元文件

    AssetDatabase.GetAssetPathsFromAssetBundle
    获得资产的路径已标有给定assetBundle名字。

    所有路径是相对于项目文件夹,例如:“资产/ MyTextures / hello.png”。

    AssetDatabase.GetAssetPathsFromAssetBundleAndAssetName
    把资产从给定的assetBundle路径名称和资产名称

    AssetDatabase.GetCachedIcon 获取缓存的图标
    为指定路径的资源检索一个图标

    AssetDatabase.GetDependencies 获取相关资源列表
    已知资源pathName,返回与它有依赖关系的所有资源列表

    AssetDatabase.GetLabels 获取标签列表
    返回给定资源拥有的所有标签

    AssetDatabase.GetSubFolders
    给定一个目录的绝对路径,该方法将返回一个数组的所有子目录

    AssetDatabase.GetTextMetaFilePathFromAssetPath
    得到的路径文本。 元与资产相关文件

    AssetDatabase.GetUnusedAssetBundleNames
    返回所有未使用的assetBundle资产数据库名称

    AssetDatabase.GUIDToAssetPath GUID转资源路径(**??)
    将GUID(全局唯一标识符)转换为对应的资源路径

    AssetDatabase 资源数据库
    AssetDatabase是一个对资源进行读写和各种操作的接口

    AssetDatabase.ImportAsset 导入资源
    导入指定路径的资源

    AssetDatabase.ImportPackage 导入包
    将packagePath下的资源包导入到当前工程

    AssetDatabase.IsForeignAsset
    资产是一个外国资产吗?

    AssetDatabase.IsMainAsset 是否主资源(**??)
    资产是一个主要资产项目窗口吗?

    例如导入的模型有一个游戏对象作为其根和几个网格和儿童游戏对象 处于扩张状态。 根游戏对象是主要的资产,在这种情况下

    AssetDatabase.IsNativeAsset
    资产是原生资产吗?

    AssetDatabase.IsOpenForEdit
    使用IsOpenForEdit确定资产是否打开编辑的版本控制。

    用于禁用编辑器控件

    AssetDatabase.IsSubAsset
    另一个资产的资产组成部分吗?

    一些资产可能的另一个资产(例如,一个程序上的材料可以部分材料包)。 这个函数以这种方式告诉如果一个资产是次级。

    AssetDatabase.IsValidFolder
    给定一个绝对路径文件夹,否则返回true,如果存在,则返回false

    AssetDatabase.LoadAllAssetRepresentationsAtPath
    返回所有资产表示 assetPath 。

    资产表示对象的资产在项目视图中可见。 所有路径是相对于项目文件夹,例如:“资产/ MyTextures / hello.png”

    AssetDatabase.LoadAllAssetsAtPath 指定路径加载所有资源
    返回指定路径assetPath下的所有资源对象数组

    using UnityEngine;
    using UnityEditor;
    
    public class Example : MonoBehaviour {
    
        [MenuItem("AssetDatabase/loadAllAssetsAtPath")]
        static void Doit() {
            Object[] data;
            data = AssetDatabase.LoadAllAssetsAtPath("Assets/MyMaterial.mat");
    
            foreach (Object o in data) {
                Debug.Log(o);
            }
    
            // outputs:
            //  MyClip (UnityEngine.AnimationClip)
            //  MyMaterial (UnityEngine.Material)
        }
    }

    AssetDatabase.LoadAssetAtPath 指定路径加载资源
    返回在指定位置assetPath下第一个类型是type的资源对象

    using UnityEngine;
    using UnityEditor;
    
    public class MyPlayer : MonoBehaviour {
        [MenuItem("AssetDatabase/LoadAssetExample")]
        static void ImportExample() {
            Texture2D t = (Texture2D)AssetDatabase.LoadAssetAtPath("Assets/Textures/texture.jpg", typeof(Texture2D));
        }
    }

    AssetDatabase.LoadMainAssetAtPath 指定路径加载主资源
    返回指定路径assetPath下的主资源

    AssetDatabase.MoveAsset 移动资源
    将一个资源文件从一个文件夹移动到另外一个文件夹

    AssetDatabase.MoveAssetToTrash 移动资源到回收站
    将指定路径的资源移动到回收站

    AssetDatabase.OpenAsset 打开资源
    用关联的程序打开资源文件

    AssetDatabase.Refresh 刷新
    重新导入有更新的资源

    AssetDatabase.RemoveAssetBundleName
    删除assetBundle名称从资产数据库。 forceRemove标志用于表明如果你想删除它甚至在使用

    AssetDatabase.RemoveUnusedAssetBundleNames
    删除所有未使用的assetBundle资产数据库名称

    AssetDatabase.RenameAsset 重命名资源
    重命名资源文件

    AssetDatabase.SaveAssets 保存资源
    将所有未保存的资源更改写入磁盘

    AssetDatabase.SetLabels 设置标签列表
    替换资源的标签列表

    AssetDatabase.StartAssetEditing 开始资源编辑
    开始资源导入。它可以让你把多个资源导入组合成一个更大的导入

    AssetDatabase.StopAssetEditing 停止资源编辑
    停止资源导入。这可以让你把多个资源导入组合成一个更大的导入

    AssetDatabase.ValidateMoveAsset 验证移动资源
    检查一个资源文件是否可以从一个文件夹移动到另外一个。(并不是真的移动这个文件)(这样做的目的是啥)

    AssetDatabase.WriteImportSettingsIfDirty
    将导入设置写入磁盘。

    为了使缓存服务器导入资产

    Editor AssetImporter 资源导入器 miss

    Editor AssetPostprocessor 资源处理器 miss

    Low AssetStore 资源商店 miss

    AsyncOperation 异步操作

    异步操作协同程序

    AsyncOperation.allowSceneActivation
    允许的场景被激活就准备好了。

    使用时结合LoadLevelAsync & LoadLevelAsyncAdditive它允许你 推迟的实际活动现场。 (和卸载以前的场景)。

    当 allowSceneActivation 设置为false,那么进步是停在0.9。 的 结束 然后保持在错误的。 当 allowSceneActivation 被设置为true 结束 可以完成。

    AsyncOperation.isDone 异步操作 完成
    有操作完成了吗?

    AsyncOperation.priority 异步操作 优先权
    优先权,让你调整异步操作调用将被执行的顺序

    AsyncOperation.progress 异步操作 进度
    操作的进度是多少?

    AudioChorusFilter 音频合声滤波器 miss

    AudioClip 音频剪辑 miss

    AudioConfiguration 音频配置 miss

    AudioDistortionFilter 音频失真滤波器 miss

    AudioEchoFilter 音频回声滤波器 miss

    AudioHighPassFilter 音频高通滤波器 miss

    Editor AudioImporter 音频导入器 miss

    AudioListener 音频侦听器

    表示三维空间的一个侦听器
    这个类实现像麦克风一样的设备。它记录周围的声音并通过玩家的扬声器播放。在场景中只能有一个侦听器。

    AudioListener.pause 暂停
    该音频系统的暂停状态

    AudioListener.volume 音量
    控制该游戏的声音音量(0.0~1.0)。

    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        void Example() {
            AudioListener.volume = 0.5F;
        }
    }

    AudioListener.velocityUpdateMode 速度更新模式
    可让你设置Audio Listener是否应该用固定或动态更新

    AudioLowPassFilter 音频低通滤波器 miss

    AudioReverbFilter 音频混响滤波器 miss

    AudioReverbZone 音频混响区 miss

    AudioSettings 音频设置 miss

    AudioSource 音频源

    表示在3D空间中的音频源

    AudioSource.bypassEffects 直通效果(**??)
    直通效果(从过滤器组件或全局监听过滤器应用)

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Awake() 
        {   //关闭所有应用到这个音频监听器的音频效果
            audio.bypassEffects = false;
        }
    }

    AudioSource.bypassListenerEffects
    当设定全球影响AudioListener不会被应用到音频信号由AudioSource生成。 不适用,如果AudioSource玩成一个混合组

    AudioSource.bypassReverbZones
    当设置不路线的信号从一个AudioSource进入全球混响与混响区

    AudioSource.clip 剪辑
    默认播放的音频剪辑

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public AudioClip otherClip;
        IEnumerator Awake() 
        {   //播放默认的声音
            audio.Play();
            //等待音频完成
            yield return new WaitForSeconds(audio.clip.length);
            //分配其他剪辑并播放
            audio.clip = otherClip;
            audio.Play();
        }
    }

    AudioSource.dopplerLevel 多普勒级别
    设置这个AudioSource的多普勒缩放

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Awake() 
        {   //不使用多普勒效果
            audio.dopplerLevel = 0;
        }
    }

    AudioSource.GetOutputData 获取输出数据
    返回一个当前播放源的输出数据

    AudioSource.GetSpectrumData 获取声谱数据
    返回当前播放源的声谱数据

    AudioSource.ignoreListenerPause
    允许AudioSource即使AudioListener玩。 暂停被设置为true。 这是有用的声音或背景音乐暂停菜单菜单元素。

    这个属性只能通过脚本并不是序列化。

    AudioSource.ignoreListenerVolume 忽略监听器音量
    这使音频源不考虑音频监听器的音量

    AudioSource.isPlaying 正在播放?
    剪辑现在正在播放?

    当音频组件被停止播放,播放otherClip

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public AudioClip otherClip;
        void Update() {
            if (!audio.isPlaying) 
            {
                audio.clip = otherClip;
                audio.Play();
            }
        }
    }

    AudioSource.loop 循环
    音频剪辑循环播放?

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Awake() 
        {   //停止循环该声音
            audio.loop = false;
        }
    }

    AudioSource.maxDistance 最大距离
    (对数衰减)最大距离是一个声音停止衰减的距离

    AudioSource.minDistance 最小距离
    在最小距离内,AudioSource将停止增大音量

    AudioSource.mute 静音
    是否静音音频源 Mute是设置音量为0,取消静音是恢复原来的音量

    在每次用户按下空格键,静音开关这个变换的声音

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Update() 
        {
            if (Input.GetKeyDown(KeyCode.Space))
                if (audio.mute)
                    audio.mute = false;
                else
                    audio.mute = true;
    
        }
    }

    Low AudioSource.pan 平衡调整
    设置一个通道平衡调整线性位置,只工作于2D剪辑
    改为 AudioSource.panStereo

    在用户每次按下空格键,从左到右声道切换声音

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public bool panOnLeft = false;
        void Update() 
        {
            if (Input.GetKeyDown(KeyCode.Space))
                if (panOnLeft) 
                {
                    panOnLeft = false;
                    audio.pan = 1;(平衡右移)
                } 
                else 
                {
                    panOnLeft = true;
                    audio.pan = -1;
                }
    
        }
        void Awake() 
        {
            audio.pan = 1;
        }
    }

    Low AudioSource.panLevel 平衡调整级别
    设置多少,3D引擎在通道上有效果
    改为 AudioSource.spatialBlend

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Awake() 
        {   //在两个通道 (2D)听到音频剪辑
            audio.panLevel = 0;
        }
    }

    AudioSource.panStereo
    锅一个立体的方式播放声音(左或右)。 这只适用于单声道或立体声的声音
    值的范围从-1.0到1.0。

    -1.0 =全部离开 0.0 =中心 1.0 =完全正确

    AudioSource.Pause 暂停

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Awake() 
        {
            audio.Pause();
        }
    }

    AudioSource.pitch 音调
    音频源的音调

    在给定的秒数降低音调

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public int startingPitch = 4;
        public int timeToDecrease = 5;
        void Start() 
        {
            audio.pitch = startingPitch;
        }
        void Update() 
        {
            if (audio.pitch > 0)
                audio.pitch -= Time.deltaTime * startingPitch / timeToDecrease;
    
        }
    }

    AudioSource.Play 播放
    播放剪辑

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Awake() 
        {   // Delay a clip by 1 sec (44100 samples) 延迟一个剪辑1秒
            audio.Play();
            audio.Play(44100);(数据什么意思)
        }
    }

    AudioSource.PlayDelayed
    扮演 剪辑 延迟秒中指定。

    AudioSource.PlayClipAtPoint 在指定位置播放剪辑
    在指定位置播放剪辑。播放完成后自动消除音频源

    例一
    正在播放声音的音频源被返回

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public AudioClip clip;
        void Awake() 
        {
            AudioSource.PlayClipAtPoint(clip, new Vector3(5, 1, 2));
        }
    }

    例二
    如果想进一步控制播放

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public AudioClip theClip;
        AudioSource PlayAudioClip(AudioClip clip, Vector3 position, float volume) 
        {
            GameObject go = new GameObject("One shot audio");
            go.transform.position = position;
            AudioSource source = go.AddComponent<AudioSource>();
            source.clip = clip;
            source.volume = volume;
            source.Play();
            Destroy(go, clip.length);
            return source;
        }
        void Awake() 
        {
            PlayAudioClip(theClip, transform.position, 1);
        }
    }

    AudioSource.playOnAwake 唤醒时播放
    如果设置为true,音频源将在Awake时自动播放

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Awake() 
        {
            if (!audio.playOnAwake)
                audio.Play();
                //如果没有在Awake设置时,播放剪辑
    
        }
    }

    AudioSource.PlayOneShot 播放一个音频剪辑
    播放一个音频剪辑

    当碰到什么东西时,播放音频剪辑

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        public AudioClip impact;
        void OnCollisionEnter() 
        {
            audio.PlayOneShot(impact);
        }
    }

    AudioSource.PlayScheduled
    扮演 剪辑 在一个特定时间AudioSettings的绝对时间线上。 dspTime读取。

    这是首选方法缝合AudioClips音乐播放器,因为它是独立的帧速率,使音响系统有足够的时间准备播放的声音从媒体获取它的开幕式和缓冲花大量的时间(流),而不引起突然的CPU峰值

    using UnityEngine;
    using System.Collections;
    
    [RequireComponent(typeof(AudioSource))]
    public class ExampleClass : MonoBehaviour {
        public float bpm = 140.0F;
        public int numBeatsPerSegment = 16;
        public AudioClip[] clips = new AudioClip[2];
        private double nextEventTime;
        private int flip = 0;
        private AudioSource[] audioSources = new AudioSource[2];
        private bool running = false;
        void Start() {
            int i = 0;
            while (i < 2) {
                GameObject child = new GameObject("Player");
                child.transform.parent = gameObject.transform;
                audioSources[i] = child.AddComponent<AudioSource>();
                i++;
            }
            nextEventTime = AudioSettings.dspTime + 2.0F;
            running = true;
        }
        void Update() {
            if (!running)
                return;
    
            double time = AudioSettings.dspTime;
            if (time + 1.0F > nextEventTime) {
                audioSources[flip].clip = clips[flip];
                audioSources[flip].PlayScheduled(nextEventTime);
                Debug.Log("Scheduled source " + flip + " to start at time " + nextEventTime);
                nextEventTime += 60.0F / bpm * numBeatsPerSegment;
                flip = 1 - flip;
            }
        }
    }

    AudioSource.SetScheduledStartTime 设置定时开始时间
    更改已定时播放的声音将开始的时间。

    AudioSource.SetSpatializerFloat 设置空间化浮点数
    设置一个附加到音频源的自定义空间化效果的一个用户自定义参数

    AudioSource.priority 优先权
    设置AudioSource的优先权

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Awake() 
        {   //如果没有硬件资源来虚拟化它,屏蔽这个声音
            audio.priority = 256;//256?
        }
    }

    AudioSource.rolloffMode 衰减模式
    设置/获取AudioSource随着距离衰减

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Awake() 
        {
            audio.rolloffMode = AudioRolloffMode.Linear;
        }
    }

    AudioSource.SetCustomCurve 设置自定义曲线
    设置给定AudioSourceCurveType类型的自定义曲线

    AudioSource.SetScheduledEndTime 设置定时结束时间
    更改已定时播放的声音将结束的时间。注意取决于时间,不是所有的重定时请求被满足

    using UnityEngine;
    using System.Collections;
    
    [RequireComponent(typeof(AudioSource))]
    public class ExampleClass : MonoBehaviour
    {
        public AudioClip sourceClip;
        private AudioSource audio1;
        private AudioSource audio2;
        private AudioClip cutClip1;
        private AudioClip cutClip2;
        private float overlap = 0.2F;
        private int len1 = 0;
        private int len2 = 0;
        void Start()
        {
            GameObject child;
            child = new GameObject("Player1");
            child.transform.parent = gameObject.transform;
            audio1 = child.AddComponent<AudioSource>();
            child = new GameObject("Player2");
            child.transform.parent = gameObject.transform;
            audio2 = child.AddComponent<AudioSource>();
            int overlapSamples;
            if (sourceClip != null)
            {
                len1 = sourceClip.samples / 2;
                len2 = sourceClip.samples - len1;
                overlapSamples = (int)(overlap * sourceClip.frequency);
                cutClip1 = AudioClip.Create("cut1", len1 + overlapSamples, sourceClip.channels, sourceClip.frequency, false, false);
                cutClip2 = AudioClip.Create("cut2", len2 + overlapSamples, sourceClip.channels, sourceClip.frequency, false, false);
                float[] smp1 = new float[(len1 + overlapSamples) * sourceClip.channels];
                float[] smp2 = new float[(len2 + overlapSamples) * sourceClip.channels];
                sourceClip.GetData(smp1, 0);
                sourceClip.GetData(smp2, len1 - overlapSamples);
                cutClip1.SetData(smp1, 0);
                cutClip2.SetData(smp2, 0);
            }
            else
            {
                overlapSamples = (int)overlap * cutClip1.frequency;
                len1 = cutClip1.samples - overlapSamples;
                len2 = cutClip2.samples - overlapSamples;
            }
        }
        void OnGUI()
        {
            if (GUI.Button(new Rect(10, 50, 230, 40), "Trigger source"))
                audio1.PlayOneShot(sourceClip);
    
            if (GUI.Button(new Rect(10, 100, 230, 40), "Trigger cut 1"))
                audio1.PlayOneShot(cutClip1);
    
            if (GUI.Button(new Rect(10, 150, 230, 40), "Trigger cut 2"))
                audio1.PlayOneShot(cutClip2);
    
            if (GUI.Button(new Rect(10, 200, 230, 40), "Play stitched"))
            {
                audio1.clip = cutClip1;
                audio2.clip = cutClip2;
                double t0 = AudioSettings.dspTime + 3.0F;
                double clipTime1 = len1;
                clipTime1 /= cutClip1.frequency;
                audio1.PlayScheduled(t0);
                audio1.SetScheduledEndTime(t0 + clipTime1);
                Debug.Log("t0 = " + t0 + ", clipTime1 = " + clipTime1 + ", cutClip1.frequency = " + cutClip1.frequency);
                Debug.Log("cutClip2.frequency = " + cutClip2.frequency + ", samplerate = " + AudioSettings.outputSampleRate);
                audio2.PlayScheduled(t0 + clipTime1);
                audio2.time = overlap;
            }
        }
    }

    AudioSource.spatialBlend 空间混合
    设置该音频源由3D空间计算(衰减,多普勒等)被影响多少。0.0使声音完全2D,1.0使声音完全3D。

    AudioSource.spatialize 空间化
    启用或禁用空间化。
    自定义空间化效果通过头相关变换函数(HRTF)改善声音传播的更真实,使听众通过头部的过滤器和耳朵之间的微小延迟更能感觉到声音的方向

    AudioSource.spread 扩散
    设置3d stereo的扩散角或扬声器空间的多声道声音

    当任意AudioSource通过这个变换,将设置它为单通道,并且退出后恢复值到3D效果
    确定音频源有一个碰撞器

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void OnTriggerEnter(Collider other) 
        {
            if (other.audio)
                other.audio.spread = 0;
    
        }
        void OnTriggerExit(Collider other) {
            if (other.audio)
                other.audio.spread = 360;
    
        }
    }

    AudioSource.Stop 停止
    停止播放该剪辑

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Awake() 
        {
            audio.Stop();
        }
    }

    AudioSource.time 时间
    以秒为单位的播放位置

    以秒为单位,打印音频源已经播放所用的时间。
    按Return键,开始播放,看看如何获取重新启动的时间

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Update() 
        {
            if (Input.GetKeyDown(KeyCode.Return)) {
                audio.Stop();
                audio.Play();
            }
            Debug.Log(audio.time);
        }
    }

    AudioSource.timeSamples 时间取样
    在PCM取样的播放位置(**??)

    以秒为单位,打印音频源已经播放所用的取样时间。
    按Return键,开始播放,看看如何获取重新启动的时间

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Update() 
        {
            if (Input.GetKeyDown(KeyCode.Return)) {
                audio.Stop();
                audio.Play();
            }
            Debug.Log(audio.timeSamples);
        }
    }

    AudioSource.velocityUpdateMode 速度更新模式
    AudioSource是否应该以固定或动态的方式更新?

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Awake() 
        {
            audio.velocityUpdateMode = AudioVelocityUpdateMode.Fixed;
        }
    }

    AudioSource.volume 音量
    音频源的音量

    using UnityEngine;
    using System.Collections;
    
    public class example : MonoBehaviour {
        void Awake() 
        {
            audio.volume = 0.2F;
        }
    }

    AudioSource.UnPause 取消暂停
    取消该音频源已暂停的播放

    Avatar 化身

    Avatar.isHuman 是否人形
    如果Avatar是个有效的人形avatar返回真

    Avatar.isValid 是否有效
    如果此Avatar是一个有效的mecanim avatar返回真

    AvatarBuilder 化身构造器

    从用户脚本构造avatar的类。

    AvatarBuilder.BuildGenericAvatar 构建通用化身
    创建一个新的通用avatar。

    using UnityEngine;
    using System.Collections;
    
    public class ExampleClass : MonoBehaviour {
        void Start() {
            GameObject go  = Selection.activeGameObject;
    
            if (go != null && go.GetComponent("Animator") != null) {
                Avatar  avatar  = AvatarBuilder.BuildGenericAvatar(go, "");
                avatar.name = "Bob";
                Debug.Log(avatar.isHuman ? "is human" : "is generic");
    
                Animator animator  = go.GetComponent<Animator>() as Animator;
                animator.avatar = avatar;
            }
        }
    }

    AvatarBuilder.BuildHumanAvatar 构造人类化身
    创建一个人类化身

    …end

    展开全文
  • Unity 实现依赖注入

    千次阅读 2018-05-10 10:50:58
    【ASP.Net MVC3 】使用Unity 实现依赖注入 新项目还是要用MVC3,team 计划使用 Unity。看了一下网上的资料,都是比较老的了,官网也没什么好的指引。MVC也在更新,Unity也在更新。花了1天半时间去MSDN,P&P...
  • Unity接高德SDK(Android) 项目中需要定位两个玩家之间的距离并且显示每个玩家精确的位置,刚开始本想使用Unity自带的定位系统来进行定位,然后加上淘宝的IP定位来获取玩家的位置,但是由于淘宝的IP获取位置不够...
  • Unity Playable API

    2019-09-27 21:01:38
    Playable api,提供了“可播放”对象的播放,混合,流程框架 不多说,上文档吧 微信 Unity公众号 ,简单介绍 https://mp.weixin.qq.com/s?__biz=MzU5MjQ1NTEwOA==&mid=2247493316&idx=1&sn=7e4fef834...
  • Unityunity3d 获取手机地理位置

    千次阅读 2016-11-30 11:03:27
    怎么用unity3d 获取手机地理位置呢?unity的某些场景中,如果需要定位地理位置的话,但是unity却没有提供相应的接口。对于安卓(这里举例,IOS暂没研究)这个时候只能用java写个获取地理位置的方法,然后与unity交互...
  • UnityUnity中的异步编程技术详解

    万次阅读 2017-06-21 00:50:12
    异步编程技术对于很多手游开发者来说,都是不可避免的话题,...本文将由Unity技术支持工程师刘伟贤,为大家分享Unity中的一些异步编程技术,来释放硬件的潜能。其实众多的Unity游戏性能负荷集中在主线程。从Unity 5.
  • unity使用的第三方工具

    千次阅读 2016-07-31 23:09:58
    关于Unity3D怎么用之类的教程在网上一找一大堆,想看教程之类的就不用看这篇文章了。我想做的是从使用Unity3D所看到的表象(表),摸透其设计原则和组织结构(里)。到现在以来做了不少工作了,现在理一下思路,将所...
  • 1 AssetBundles(资源包) An AssetBundle is an archive file containing platform specific Assets (Models, Textures, Prefabs, Audio clips, and even entire Scenes) that can be loaded at runtime....
  • 使用Unity 实现依赖注入

    千次阅读 2013-09-05 09:24:14
    新项目还是要用MVC3,team 计划使用 Unity。看了一下网上的资料,都是比较老的了,官网也没什么好的指引。MVC也在更新,Unity也在更新。花了1天半时间去MSDN,P&P查资料,整理了一下分享给大家。言归正传: ...
  • Unity3D基础笔迹

    千次阅读 2017-09-01 18:26:01
    Create Empty 挂在脚本 充当游戏控制器 GameControler获取脚本挂在的游戏对象 属性gameObject.name gameObject.tag获取游戏对象的 激活状态 & 修改状态gameObject.activeSelf gameObject.SetActive(false);...
  • unity实现依赖注入

    千次阅读 2014-02-06 16:20:06
    新项目还是要用MVC3,team 计划使用 Unity。看了一下网上的资料,都是比较老的了,官网也没什么好的指引。MVC也在更新,Unity也在更新。花了1天半时间去MSDN,P&P查资料,整理了一下分享给大家。言归正传: 什么...
  • 2.打开Unity的Profiler,选择Memory,运行项目,果然此项目一直在创建Texture,如下图所示。 3.找了一会儿,发现是点击翻页按钮时,占用的内存一直在增加,于是查看这个按钮的代码,果然发现了问题,方法里...
  • unity获取到网络时间和本地时间

    千次阅读 2018-11-26 16:35:15
    做一个时间的显示,unity有获取到系统时间的api DateTime 当时考虑到网络游戏几个人的时间还是统一比较好,因此做了一个获取网络时间 上代码 获取到网络时间 先做定义,链接地址是腾讯官网的地址,内容只有一个text...
  • 现在新版的Unity(印象中是从5.3开始)已经提供了原生的Json库,以前一直使用LitJson,研究了一下Unity用的JsonUtility工具类的使用,发现使用还挺方便的,所以打算把项目中的Json库换成Unity原生的。在Unity3D开发...
1 2 3 4 5 ... 20
收藏数 562
精华内容 224
热门标签
关键字:

unity3dapi