Unity API - A_unity animation 的 add loop frame

废话不多说，一针见血，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");
    }
}
1
2
3
4
5
6
7
8
9
10

例二

//检索该产品/硬件的制造商
using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void Start() {
        AndroidJavaClass jc = new AndroidJavaClass("android.os.Build");
        string manufacturer = jc.Get<string>("MANUFACTURER");
    }
}
1
2
3
4
5
6
7
8
9
10

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");
    }
}
1
2
3
4
5
6
7
8
9

例二

//内嵌类必须使用/$分割
//这里我们创建了一个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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

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");
    }
}
1
2
3
4
5
6
7
8
9
10

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");
    }
}
1
2
3
4
5
6
7
8
9
10

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");
    }
}
1
2
3
4
5
6
7
8
9
10

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);
    }
}
1
2
3
4
5
6
7
8
9
10

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");
    }
}
1
2
3
4
5
6
7
8
9
10

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");
    }
}
1
2
3
4
5
6
7
8
9
10
11

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);
    }
}
1
2
3
4
5
6
7
8
9
10

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");
    }
}
1
2
3
4
5
6
7
8
9
10

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");
        }));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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");
    }
}
1
2
3
4
5
6
7
8
9
10
11

例二

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11

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

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

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    {   
        // 淡入walk循环并且淡出同一层的所有其他动画
        // 在0.2秒之内完成淡入淡出
        animation.CrossFade("Walk", 0.2F);
    }
}
1
2
3
4
5
6
7
8
9
10

例二
让一个角色包含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");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

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);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

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

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void OnMouseEnter() 
    {
        if (!animation.isPlaying)
        animation.Play();

    }
}
1
2
3
4
5
6
7
8
9
10
11

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

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void OnMouseEnter() 
    {
        if (!animation.IsPlaying("mouseOverEffect"))
            animation.Play("mouseOverEffect");

    }
}
1
2
3
4
5
6
7
8
9
10
11

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

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

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

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

例一

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   
        // 播放默认动画
        animation.Play();
    }
}
1
2
3
4
5
6
7
8
9
10

例二

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake()
    {
        // 播放walk动画 - 停止同一层的其他动画
        animation.Play("walk");
        // 播放walk动画 - 停止其他动画
        animation.Play("walk", PlayMode.StopAll);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        animation.playAutomatically = true;
    }
}
1
2
3
4
5
6
7
8
9

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);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

Animation.Rewind 倒回

例一
倒回名称为name的动画

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   
        // 倒回walk动画到开始
        animation.Rewind("walk");
    }
}
1
2
3
4
5
6
7
8
9
10

例二
倒回所有动画

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   
        // 倒回所有动画到开始
        animation.Rewind();
    }
}
1
2
3
4
5
6
7
8
9
10

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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

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

例一

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   
        //停止所有动画
        animation.Stop();
    }
}
1
2
3
4
5
6
7
8
9
10

例二

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   
        //停止walk动画
        animation.Stop("walk");
    }
}
1
2
3
4
5
6
7
8
9
10

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

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;
    }
}
1
2
3
4
5
6
7
8
9

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11

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");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

例二
动画颜色的通道和主要纹理的水平偏移（**？？）

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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");

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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);
    }
}
1
2
3
4
5
6
7
8
9

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);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

例二
用路径增加一个混合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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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;
    }
}
1
2
3
4
5
6
7
8
9
10

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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;
    }
}
1
2
3
4
5
6
7
8
9
10

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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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;
    }
}
1
2
3
4
5
6
7
8
9
10
11

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

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public Animation anim;
    public void Awake() 
    {
        anim["Walk"].wrapMode = WrapMode.Loop;
    }
}
1
2
3
4
5
6
7
8
9
10

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);
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

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);
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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); } 
} 
1
2
3
4
5
6
7
8
9
10
11

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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; 
1
2
3
4
5

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");

        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

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

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Update() 
    {
        if (Application.CanStreamedLevelBeLoaded(1))
            Application.LoadLevel(1);

    }
}
1
2
3
4
5
6
7
8
9
10
11

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Update() 
    {
        if (Application.CanStreamedLevelBeLoaded("Level1"))
            Application.LoadLevel("Level1");

    }
}
1
2
3
4
5
6
7
8
9
10
11

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void OnMouseDown() 
    {
        Application.CaptureScreenshot("Screenshot.png");
    }
}
1
2
3
4
5
6
7
8
9

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

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

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   // 打印到数据文件夹的路径
        print(Application.dataPath);
    }
}
1
2
3
4
5
6
7
8
9

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

<script language="JavaScript" type="text/javascript">
<!--  

// 使用来自Unity的调用，这将接受
// "Hello from Unity!" 做为参数
function MyFunction2( arg )
    {
        alert( arg );
    }
-->
</script>
1
2
3
4
5
6
7
8
9
10
11

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   //返回前一页
        Application.ExternalEval("history.back()");
    }
}
1
2
3
4
5
6
7
8
9

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();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

例二
在文本框打印在场景”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();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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!");

    }
}
1
2
3
4
5
6
7
8
9
10
11

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        print(Application.isLoadingLevel);
    }
}
1
2
3
4
5
6
7
8
9

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");

    }
}
1
2
3
4
5
6
7
8
9
10
11
12

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!");

    }
}
1
2
3
4
5
6
7
8
9
10
11

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));
    }
}
1
2
3
4
5
6
7
8
9

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   //打印当前场景的代号（索引号）
        print(Application.loadedLevel);
    }
}
1
2
3
4
5
6
7
8
9

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   //打印当前场景名字
        print(Application.loadedLevelName);
    }
}
1
2
3
4
5
6
7
8
9

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   
        Application.LoadLevel(0);
    }
}
1
2
3
4
5
6
7
8
9
10

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        Application.LoadLevel("HighScore");
    }
}
1
2
3
4
5
6
7
8
9

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");
    }
}
1
2
3
4
5
6
7
8
9
10
11

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");
    }
}
1
2
3
4
5
6
7
8
9
10
11

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");
    }
}
1
2
3
4
5
6
7
8
9
10
11

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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Start() 
    {
        Application.OpenURL("http://3d.ceeger.com/");
    }
}
1
2
3
4
5
6
7
8
9

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Awake() 
    {   //打印该路径到持久数据文件夹
        print(Application.persistentDataPath);
    }
}
1
2
3
4
5
6
7
8
9

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

using UnityEngine;
using System.Collections;

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

    }
}
1
2
3
4
5
6
7
8
9
10
11

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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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); }
        );
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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 {
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

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

让游戏在后台时也运行

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        Application.runInBackground = true;
    }
}
1
2
3
4
5
6
7
8
9

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");

        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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();
    }
}
1
2
3
4
5
6
7
8
9

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   //系统使用的实际语言打印到界面文本
        guiText.text = Application.systemLanguage.ToString();
    }
}
1
2
3
4
5
6
7
8
9

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Awake() 
    {   //使游戏尽可能快的运行，在web播放器里
        Application.targetFrameRate = 300;
    }
}
1
2
3
4
5
6
7
8
9

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Awake() 
    {
        //打印路径到临时数据文件夹
print(Application.temporaryCachePath);
    }
}
1
2
3
4
5
6
7
8
9
10

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        print("Version of the runtime: " + Application.unityVersion);
    }
}
1
2
3
4
5
6
7
8
9

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);
1
2
3
4

Array.Array 数组

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

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

例二
初始化一个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]);
    //打印数组
}
1
2
3
4
5
6
7
8
9

例三
创建一个空数组

var arr = new Array ();

// Add one element //添加一个元素
arr.Push ("Hello");
// print the first element ("Hello")//打印第一个元素
print(arr[0]);
1
2
3
4
5
6

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

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

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);
}
1
2
3
4
5
6
7
8
9

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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

var values : float[];

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

例三

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);
}
1
2
3
4
5
6
7
8
9
10
11
12

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

function Start () 
{
    var arr = new Array ("Hello", "World");

    // 打印结果 "Hello, World" ，由数组中的两个字符串变为现在的一个字符串。
    print(arr.join(", "));
}
1
2
3
4
5
6
7

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

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

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

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

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

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

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

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

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

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

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

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

Array.Sort 排序
排序所有元素

例一

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

例二

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

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

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

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);
}
1
2
3
4
5
6
7
8

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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);
}
1
2
3
4
5
6
7

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));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

例二

@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));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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);
    }
}
1
2
3
4
5
6
7
8
9
10

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));
}
1
2
3
4
5
6
7
8
9
10

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

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

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));
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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));
}
1
2
3
4
5
6
7
8
9
10

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)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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));
    }
}
1
2
3
4
5
6
7
8
9

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;
    }
}
1
2
3
4
5
6
7
8

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;
    }
}
1
2
3
4
5
6
7
8
9

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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Awake() 
    {   //不使用多普勒效果
        audio.dopplerLevel = 0;
    }
}
1
2
3
4
5
6
7
8
9

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();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Awake() 
    {   //停止循环该声音
        audio.loop = false;
    }
}
1
2
3
4
5
6
7
8
9

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;

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Low AudioSource.panLevel 平衡调整级别
设置多少，3D引擎在通道上有效果
改为 AudioSource.spatialBlend

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Awake() 
    {   //在两个通道 (2D)听到音频剪辑
        audio.panLevel = 0;
    }
}
1
2
3
4
5
6
7
8
9

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();
    }
}
1
2
3
4
5
6
7
8
9

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;

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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);（数据什么意思）
    }
}
1
2
3
4
5
6
7
8
9
10

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));
    }
}
1
2
3
4
5
6
7
8
9
10

例二
如果想进一步控制播放

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

AudioSource.playOnAwake 唤醒时播放
如果设置为true，音频源将在Awake时自动播放

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Awake() 
    {
        if (!audio.playOnAwake)
            audio.Play();
            //如果没有在Awake设置时，播放剪辑

    }
}
1
2
3
4
5
6
7
8
9
10
11
12

AudioSource.PlayOneShot 播放一个音频剪辑
播放一个音频剪辑

当碰到什么东西时，播放音频剪辑

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public AudioClip impact;
    void OnCollisionEnter() 
    {
        audio.PlayOneShot(impact);
    }
}
1
2
3
4
5
6
7
8
9
10

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;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

AudioSource.SetScheduledStartTime 设置定时开始时间
更改已定时播放的声音将开始的时间。

AudioSource.SetSpatializerFloat 设置空间化浮点数
设置一个附加到音频源的自定义空间化效果的一个用户自定义参数

AudioSource.priority 优先权
设置AudioSource的优先权

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Awake() 
    {   //如果没有硬件资源来虚拟化它，屏蔽这个声音
        audio.priority = 256;//256？
    }
}
1
2
3
4
5
6
7
8
9

AudioSource.rolloffMode 衰减模式
设置/获取AudioSource随着距离衰减

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Awake() 
    {
        audio.rolloffMode = AudioRolloffMode.Linear;
    }
}
1
2
3
4
5
6
7
8
9

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;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

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;

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

AudioSource.Stop 停止
停止播放该剪辑

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Awake() 
    {
        audio.Stop();
    }
}
1
2
3
4
5
6
7
8
9

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

AudioSource.velocityUpdateMode 速度更新模式
AudioSource是否应该以固定或动态的方式更新？

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Awake() 
    {
        audio.velocityUpdateMode = AudioVelocityUpdateMode.Fixed;
    }
}
1
2
3
4
5
6
7
8
9

AudioSource.volume 音量
音频源的音量

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Awake() 
    {
        audio.volume = 0.2F;
    }
}
1
2
3
4
5
6
7
8
9

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;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

AvatarBuilder.BuildHumanAvatar 构造人类化身
创建一个人类化身

…end