unity3d 粒子系统弹幕

2015-06-18 09:08:26 u010019717 阅读数 4763
  • Unity 值得看的500+ 技术内容列表

    Unity3D是由Unity Technologies开发的一个让玩家轻松创建诸如三维视频游戏、建筑可视化、实时三维动画等类型互动内容的多平台的综合型游戏开发工具,是一个全面整合的专业游戏引擎。

孙广东   2015.6.15

对于逗比的游戏、无厘头、可以让大家吐糟的游戏,如果有弹幕的功能是极好的。

使用U5和 UGUI 目前实现的很简陋而已。

    /// <summary>
    /// 实现看视频时的弹幕效果
    /// </summary>
    public class DanMu : MonoBehaviour
    {
        //public Text[] texts;
        public GameObject textPrefab;

        [Tooltip("满屏的个数")] public int num;

        private Queue<GameObject> Texts = new Queue<GameObject>();
        private bool isDanmuOn = true;
        private IEnumerator coroutine;


        // Use this for initialization
        void Start()
        {
            for (int i = 0; i < num; i++)
            {
                GameObject obj = Instantiate(textPrefab, transform.position, Quaternion.identity) as GameObject;
                obj.SetActive(false);
                obj.transform.SetParent(transform);
                obj.transform.localScale = Vector3.one;
                Texts.Enqueue(obj);
            }
            coroutine = DanmuAnimation();
            StartCoroutine(coroutine);
        }

        private IEnumerator DanmuAnimation()       
        {
            while (true)
            {
                GameObject obj = Texts.Dequeue();
                if (obj)
                {
                    obj.transform.localPosition = new Vector3(1071, Random.Range(-512, 512));
                    obj.GetComponent<Text>().text = DanMuStrings[Random.Range(0, DanMuStrings.Length)];
                    obj.GetComponent<Text>().color = TextColors[Random.Range(0, TextColors.Length)];
                    obj.SetActive(true);

                    obj.GetComponent<DanMuText>().Reset(Texts);
                }

                yield return new WaitForSeconds(0.2f);                
            }
        }

        /// <summary>
        /// 弹幕的开关
        /// </summary>
        public void DanMuToggle(Toggle toggle)
        {
            if (toggle.isOn)
            {
                isDanmuOn = true;
                StartCoroutine(coroutine);
                MyDebugLog.Log("弹幕开!!!!!");
            }
            else
            {
                isDanmuOn = false;
                DOTween.KillAll();
                StopCoroutine(coroutine);
                // Texts.Clear();
                foreach (var text in transform.GetComponentsInChildren<DanMuText>())                  // 只能得到被激活的对象而已, 得不到全部?  所以不用Clear()直接把这些在外面的入队就行
                {
                    Texts.Enqueue(text.gameObject);
                    text.gameObject.SetActive(false);
                }
                MyDebugLog.Log("弹幕关!!!!!个数: " + Texts.Count);
            }
        }

        [HideInInspector]
        public string[] DanMuStrings =
        {
            "这个剧情也太雷人了吧!",
            "还是好莱坞的电影经典啊,这个太次了",
            "是电锯惊魂的主角,尼玛",
            "这个游戏还是很良心的么",
            "卧槽还要花钱,这一关也太难了",
            "这个游戏好棒偶",
            "全是傻逼",
            "求约:13122785566",
            "最近好寂寞啊,还是这个游戏好啊",
            "难道玩游戏还能撸",
            "办证:010 - 888888",
            "为什么女主角没有死?",
            "好帅呦,你这个娘们儿",
            "欠揍啊,东北人不知道啊",
            "我去都是什么人啊,请文明用语",
            "这个还是不错的",
            "要是胸再大点就更好了",
            "这个游戏必须顶啊",
            "怎么没有日本动作爱情片中的角色呢?",
            "好吧,这也是醉了!",
            "他只想做一个安静的美男子!"
        };

        public Color[] TextColors;
    }


和挂在 Text预制体上的 脚本:

    /// <summary>
    /// 
    /// </summary>
    public class DanMuText : MonoBehaviour
    {

        public void Reset(Queue<GameObject> Texts)
        {
            transform.DOLocalMoveX(-1366, 4f).OnComplete(() =>
            {
                gameObject.SetActive(false);
                Texts.Enqueue(gameObject);
            });
        }
    }





2013-12-17 18:44:01 UnSkyToo 阅读数 6781
  • Unity 值得看的500+ 技术内容列表

    Unity3D是由Unity Technologies开发的一个让玩家轻松创建诸如三维视频游戏、建筑可视化、实时三维动画等类型互动内容的多平台的综合型游戏开发工具,是一个全面整合的专业游戏引擎。

我写博客喜欢做完一个东西,一口气写很多章。。。貌似这样不太好啊~


到这里,我们似乎该让主角上场了,好就让我们来显示一颗子弹吧~

慢着,显示子弹之前,我们需要小小的抽象一下,把游戏中所有能显示的物体抽象成GameObject,好处是什么?好处是看起来很帅。。

当然不是,好处简单来说,整合公共部分、利于管理~~好吧我也不知道好处。。。。

/// <summary>
	/// Description of GameObject.
	/// </summary>
	public class GameObject
	{
		public Vector2 Position;
		public Box BoxCollider;
		
		protected int Width;
		protected int Height;
		protected int HalfWidth;
		protected int HalfHeight;
		
		public GameObject()
		{
		}
		
		public virtual void Update(float elapsedTime)
		{
			
		}
		
		public virtual void Render(Graphics g)
		{
			
		}
	}

封装了一些基础属性和方法~~特别说明下:HalfWidth和HalfHeight只是用于计算的时候少一个除法,可以不需要的,后面的代码会看到

对了,特别说明下:一般的坐标系是以左上角为(0,0)点,向右为X正方向,向下为Y正方向。

而这个游戏是以屏幕的中间为远点,绘制图片的时候也是,以图片的中间为绘制点。。。至于为什么这样。。我当时脑抽了,忘了为什么了

接下来就是主角

/// <summary>
	/// Description of GameBullet.
	/// </summary>
	public class GameBullet : GameObject
	{
		public bool IsOwn; // 是否为自己的子弹
		public int Type; // 子弹样式
		public int Color; // 子弹颜色(0-6)
        public float ActiveDelay; // 延迟多久激活
        
        public Vector2 Speed;
        public Vector2 Accel;
        
        public bool IsLive; // 是否存活
        
		public GameBullet(bool isOwn, Vector2 position, Vector2 speed, Vector2 accel, int type, int color, float activeDelay)
		{
			this.IsOwn = isOwn;
			this.Type = type;
			this.Color = color;
			this.ActiveDelay = activeDelay;
			
			this.Position = position;
			this.Speed = speed;
			this.Accel = accel;
			
			this.IsLive = true;
			
			this.Width = Data.BulletsSize[type].Width;
			this.Height = Data.BulletsSize[type].Height;
			this.HalfWidth = this.Width / 2;
			this.HalfHeight = this.Height / 2;
			
			this.BoxCollider = new Box((int)position.X, (int)position.Y, this.Width, this.Height);
		}
		
		public override void Update(float elaspedTime)
		{
			if ( IsLive == false )
			{
				return;
			}

            if (ActiveDelay > 0)
            {
                ActiveDelay -= elaspedTime;
                return;
            }
			
            Speed += (Accel * elaspedTime);
            Position += (Speed * elaspedTime);
            
            BoxCollider.X = (int)Position.X;
            BoxCollider.Y = (int)Position.Y;
			
			if ( Position.X < 0 || Position.Y < 0 || Position.X > Config.ScreenWidth || Position.Y > Config.ScreenHeight )
			{
				IsLive = false;
			}
		}
		
		public override void Render(Graphics g)
		{
			if ( IsLive == false || ActiveDelay > 0)
			{
				return;
			}
			
			g.DrawImage(Data.BulletsSource[this.Type],
			            new Rectangle((int)Position.X - HalfWidth, (int)Position.Y - HalfHeight, Width, Height),
			            new Rectangle(this.Color * Width, 0, Width, Height),
			            GraphicsUnit.Pixel);
			
			if ( Config.IsDebug && Config.IsShowBox )
			{
				g.DrawRectangle(Pens.Green, BoxCollider.ToRectangle());
			}
		}
	}

唯一要说明的是Update方法的这两句

Speed += (Accel * elaspedTime);
Position += (Speed * elaspedTime);

通过速度和加速度来更新子弹的位置,并且在后面同步更新碰撞盒的位置


这里用简单的物理知识来模拟了一下粒子的运行~其实可以做的更复杂一点,比如线速度角速度。

我们这里学习用,就简单一点。东方系列就比较复杂了


子弹肯定不止一个,而且有自己的和敌人的

所以需要一个管理类,用于管理一堆子弹

public class GameBulletManager
	{
		private GameScene mScene;
		private List<GameBullet> mBullets;
		
		public GameBulletManager(GameScene scene)
		{
			this.mScene = scene;
			this.mBullets = new List<GameBullet>();
		}
		
		public void AddBullet(GameBullet bullet)
		{
			mBullets.Add(bullet);
		}
		
		public void Update(float elapsedTime)
		{
			// 检测子弹的碰撞
            for (int i = 0; i < mBullets.Count; i++)
            {
                mBullets[i].Update(elapsedTime);

                if (mBullets[i].IsLive == false)
                {
                    mBullets.RemoveAt(i);
                    i--;
                    continue;
                }
                
                if ( mBullets[i].IsOwn == false ) // 不是自己的子弹
                {
	                if ( mScene.Player1.Collide(mBullets[i].BoxCollider, 1) == true )
	                {
	                	GameBombManager.AddBomb(mBullets[i].Position, false, 0.5f);
	                	mBullets.RemoveAt(i);
	                	i--;
	                	continue;
	                }
                }
                else
                {
                	if ( mScene.EnemyManager.Collide(mBullets[i].BoxCollider, 1) == true )
                	{
                		GameBombManager.AddBomb(mBullets[i].Position, false, 0.5f);
                		mBullets.RemoveAt(i);
                		i--;
                		continue;
                	}
                	if ( mScene.BossManager.Collide(mBullets[i].BoxCollider, 1) == true )
                	{
                		GameBombManager.AddBomb(mBullets[i].Position, false, 0.5f);
                		mBullets.RemoveAt(i);
                		i--;
                		continue;
                	}
                }
            }
		}
		
		public void Render(Graphics g)
		{
			foreach (GameBullet bullet in mBullets)
            {
                bullet.Render(g);
            }
			
			if ( Config.IsDebug )
			{
				g.DrawString("Bullets:" + mBullets.Count.ToString(), Data.NormalFont, Brushes.Red, 300, 0);
			}
		}
	}

这里面没有遇到的类暂且不管。

大体上就是用一个List来保存所有GameBullet~~更新和绘制也是一个循环

唯一要做的就是检测子弹和其余单位是否碰撞了,碰撞的话要添加爆炸效果,然后移除这个子弹


好,现在你可以添加几个子弹来玩玩了。

比如,创建一个直线上升的子弹

AddBullet(new Bullet(false, new Vector2(0, 0), new Vector2(0, -300), Vector2.Zero, 0, 0, 0);

创建一个斜着飞的子弹

AddBullet(new Bullet(false, new Vector2(0, 0), new Vector2(300, -300), Vector2.Zero, 0, 0, 0);

创建一个越飞越快的子弹

AddBullet(new Bullet(false, new Vector2(0, 0), new Vector2(0, -300), new Vector2(0, -100), 0, 0, 0);

大概就是这样

2015-12-15 23:05:48 xiaocainiao_2015 阅读数 1468
  • Unity 值得看的500+ 技术内容列表

    Unity3D是由Unity Technologies开发的一个让玩家轻松创建诸如三维视频游戏、建筑可视化、实时三维动画等类型互动内容的多平台的综合型游戏开发工具,是一个全面整合的专业游戏引擎。

最近在弄一个3d弹幕类游戏,美术给的子弹都是多个粒子系统的叠加,大量的子弹以及特效造成了系统的卡顿、丢帧严重。想来想去,无奈只好想出歪招,把粒子系统作为一个武器,粒子作为子弹,除了效果不好些,却也解决了问题。今天就写写粒子碰撞时遇到的问题。

首先,作为子弹,碰撞是不可少的。要是粒子也带碰撞,可以按下图进行设置。其中,Collision部分必须勾上,才会产生碰撞。如果要在脚本中能够接受到碰撞信息,则必须勾选上Send Collision Message部分。
这里写图片描述

Collision中一些参数:
1、Dampen:抑制(0~1),选这个为1时(完全抑制),碰撞之后,阻止了粒子,可以使碰撞的粒子消失;
2、Bounce:反弹(0~2),选完这个之后,可以让产生碰撞的粒子以某个角度反弹出去;
3、Lifetime Loss:生命周期损失(0~1),碰撞之后让粒子损失百分比的生命周期,为1时(生命周期完全损失),可以使粒子消失;
4、Min Kill Speed:最小清除速度,设置值越大,粒子发生碰撞之后被移除的速度越快,当达到某个值之后,可以近似碰撞之后立即消失。
综上说,如果要想粒子碰到物体就消失,则有三种方式,即设置Dampen为1;设置Lifetime Loss为1;设置较大的Min Kill Speed值。

在脚本中,可以通过OnParticleCollision(GameObject other)获得具体的碰撞信息(注意other为粒子系统,而不是某个粒子)。虽然知道怎么使用,但是期间还是走了很多歪路。要想OnParticleCollision真的能检测到信息,首先得保证碰撞物有rigidbody和collider,而且collider还不能勾选isTrigger选项。即便这样,我还是遇到不能检测到的情况,理由是还是给粒子带上速度(为毛啊~~)。

在ParticleSystem中必不能检测到每次发出的Particle是哪个,所以要想更新粒子,可以调用GetParticles和SetParticles方式进行设置。补充的说,如果要检测具体某个粒子的碰撞位置怎么办呢?可以使用GetCollisionEvents这个方法:

int safeLength = PS.GetSafeCollisionEventSize();
ParticleCollisionEvent[] collisionEvents;
collisionEvents = new ParticleCollisionEvent[safeLength];

int numCollisionEvents = PS.GetCollisionEvents(this.gameObject, collisionEvents);
int i = 0;
while (i < numCollisionEvents)
{
    Debug.Log(collisionEvents[i].intersection);
    GameObject.Instantiate(O, collisionEvents[i].intersection, Quaternion.identity);
    i++;
}

就写这么多吧,以后在进行补充….

2018-07-04 15:36:35 q764424567 阅读数 3027
  • Unity 值得看的500+ 技术内容列表

    Unity3D是由Unity Technologies开发的一个让玩家轻松创建诸如三维视频游戏、建筑可视化、实时三维动画等类型互动内容的多平台的综合型游戏开发工具,是一个全面整合的专业游戏引擎。

一、前言

这篇文章是分析UGUI的各种原理,包括层级渲染,事件触发,布局等,教程也比较详细,转过来有空研究一下.

二、原文

原文地址:https://mp.weixin.qq.com/s/ZaYrH9QzxaS5nMg3Kn3Eig
原文作者:克森
原文出处:微信公众号克森空间

三、正文


Unity UGUI 原理篇(一):Canvas 渲染模式

目标

了解各种不同UI Render Mode

使用环境与版本

Window 7
Unity 5.2.5

Render Mode

UI渲染的方式,有以下三种

  • Screen Space – Overlay:萤幕空间 – 覆盖

  • Screen Space – Camera:萤幕空间 – 摄影机

  • World Space:世界座标空间

Screen Space - Overlay
这里写图片描述
在此模式下不会参照到Camera,UI直接显示在任何图形之上

  • 1.Pixel Perfect:可以使图像更清晰,但是有额外的性能开销,如果在有大量UI动画时,动画可能会不平顺

  • 2.Sort Order:深度值,该值越高显示越前面

Screen Space - Camera
这里写图片描述
使用一个Camera作为参照,将UI平面放置在Camera前的一定距离,因为是参照Camera,如果萤幕大小、分辨率、Camera视锥改变时UI平面会自动调整大小。如果Scene中的物件(GameObject)比UI平面更靠近摄影机,就会遮挡到UI平面。

  • 1.Render Camera:用于渲染的摄影机

  • 2.Plane Distance:与Camera的距离

  • 3.Sorting Layer:Canvas属于的排序层,在 Edit->Project Setting->Tags and Layers->Sorting Layers 进行新增,越下方的层显示越前面

  • 4.Order in Layer:Canvas属于的排序层下的顺序,该值越高显示越前面

World Space
这里写图片描述
把物体当作世界座标中的平面(GameObject),也就是当作3D物件,显示3D UI

  • 1.Event Camera:处理UI事件(Click、Drag)的Camera,所设定的Camera才能触发事件

参考资料
Unity – Manual: Canvas

http://docs.unity3d.com/Manual/class-Canvas.html


Unity UGUI 原理篇(二):Canvas Scaler 缩放核心

目标

  • 1.了解各种不同 UI Scale Mode
  • 2.Pixels Per Unit 每单位像素
  • 3.Canvas Scale Factor 缩放因子
  • 4.Reference Resolution(预设屏幕大小)
  • 5.Screen Size丶Canvas Size 之间的关系与算法

使用环境 与 版本

Window 7

Unity 5.2.4

Canvas Scaler

Canvas Scaler是Unity UI系统中,控制UI元素的总体大小和像素密度的Compoent,Canvas Scaler的缩放比例影响著Canvas下的元素,包含字体大小和图像边界。

Size

  • Reference Resolution:预设萤幕大小

  • Screen Size:目前萤幕大小
    这里写图片描述
    Canvas Size:Canvas Rect Transform 宽高
    这里写图片描述
    Scale Factor

http://docs.unity3d.com/ScriptReference/Canvas-scaleFactor.html

用于缩放整个Canvas,而且调整Canvas Size与Screen Size一样

先来看一段官方代码

CanvasScaler.cs

protected void SetScaleFactor(float scaleFactor)
{
    if (scaleFactor == m_PrevScaleFactor)
        return;
 
    m_Canvas.scaleFactor = scaleFactor;
    m_PrevScaleFactor = scaleFactor;
}

程式码可以看出,Canvas Scaler 透过设定Canvas下的Scale Factor,缩放所有在此Canvas下的元素

当Scale Factor为1时,Screen Size (800600)、Canvas Size(800600),图片大小1倍

这里写图片描述
这里写图片描述
当Scale Factor为2时,Screen Size (800600)、Canvas Size(400300),图片大小2倍
这里写图片描述
这里写图片描述
在当Scale Factor为2时,Scale Factor 会调整整个Canvas 的大小,并让他的大小跟Screen Size一样,运算后Canvas Size放大2倍,刚好等于Screen Size,而底下的图片会放大2倍

UI Scale Mode

Constant Pixel Size
Canvas Size 始终等于 Screen Size,透过Scale Factor直接缩放所有UI元素
这里写图片描述

    1. Scale Factor:透过此Factor缩放所有在此Canvas下的元素
    1. Reference Pixels Per Unit:

先介绍图片档设定中的Pixels Per Unit,意思是在这张Sprite中,世界座标中的一单位由几个Pixel组成
这里写图片描述
这边使用的测试图片为原始大小100100 的图档,这边统称测试图
这里写图片描述
举例来说,场景中有一个1
1 Cube ,与一个Sprite图片指定为测试图,两者的Transform Scale 都为 1
当 Pixels Per Unit=100,每单位由 100 Pixel组成,Sprite 是100100 Pixels,那 Sprite 在世界座标中大小就会变成 100/100 * 100/100 = 11 Unit
这里写图片描述
(左:Cube ,右:Sprite)

当 Pixels Per Unit=10,每单位由 10 Pixel组成,Sprite 是100100 Pixels,那 Sprite 在世界座标中大小就会变成 100/10 * 100/10 = 1010 Unit
这里写图片描述
(左:Cube,右:Sprite)
结论:

  • Unity中一单位等于 100 Pixels
  • 由此可以推导出公式:

Sprite 在世界座标中大小 = 原图大小(Pixels) / Pixels Per Unit

让我们回到 Reference Pixels Per Unit,官方解释是,如果图片档有设定Pixels Per Unit,则会将Sprite 的 1 pixel 转换成 UI 中的 1 pixel

Image.cs

public float pixelsPerUnit
{
    get
    {
        float spritePixelsPerUnit = 100;
        if (sprite)
            spritePixelsPerUnit = sprite.pixelsPerUnit;
 
        float referencePixelsPerUnit = 100;
        if (canvas)
            referencePixelsPerUnit = canvas.referencePixelsPerUnit;
 
        return spritePixelsPerUnit / referencePixelsPerUnit;
    }
}

上面官方程式码,可以看出 Image 透过 spritePixelsPerUnit / referencePixelsPerUnit 方式算出新的 pixelsPerUnit

Image.cs

public override void SetNativeSize()
{
    if (overrideSprite != null)
    {
        float w = overrideSprite.rect.width / pixelsPerUnit;
        float h = overrideSprite.rect.height / pixelsPerUnit;
        rectTransform.anchorMax = rectTransform.anchorMin;
        rectTransform.sizeDelta = new Vector2(w, h);
        SetAllDirty();
    }
}

在设定 Image 图片大小时,是把 宽高 / pixelsPerUnit

实作一下,建立一个Canvas参数如下

这里写图片描述
Canvas底下建立一个Image,Sprite设定为测试图,参数如下
这里写图片描述
这边做4种不同的测试:测试方式是修改 Reference Pixels Per Unit 与 Pixels Per Unit 后,点下 Image Compoent 的 Set Native Size来设定图片原始大小,藉此看到图片变化.
这里写图片描述
■ 上表可以看出当数值改变时,图片预设大小也会改变

■ 由此可以推导出公式

UI大小 = 原图大小(Pixels) / (Pixels Per Unit / Reference Pixels Per Unit)

Scale With Screen Size:
透过设定的Reference Resolution(预设萤幕大小)来缩放

  1. Reference Resolution:预设萤幕大小

  2. Screen Match Mode:缩放模式

先来看官方的算法

CanvasScaler.cs

Vector2 screenSize = new Vector2(Screen.width, Screen.height);
 
float scaleFactor = 0;
switch (m_ScreenMatchMode)
{
    case ScreenMatchMode.MatchWidthOrHeight:
    {
        // We take the log of the relative width and height before taking the average.
        // Then we transform it back in the original space.
        // the reason to transform in and out of logarithmic space is to have better behavior.
        // If one axis has twice resolution and the other has half, it should even out if widthOrHeight value is at 0.5.
        // In normal space the average would be (0.5 + 2) / 2 = 1.25
        // In logarithmic space the average is (-1 + 1) / 2 = 0
        float logWidth = Mathf.Log(screenSize.x / m_ReferenceResolution.x, kLogBase);
        float logHeight = Mathf.Log(screenSize.y / m_ReferenceResolution.y, kLogBase);
        float logWeightedAverage = Mathf.Lerp(logWidth, logHeight, m_MatchWidthOrHeight);
        scaleFactor = Mathf.Pow(kLogBase, logWeightedAverage);
        break;
    }
    case ScreenMatchMode.Expand:
    {
        scaleFactor = Mathf.Min(screenSize.x / m_ReferenceResolution.x, screenSize.y / m_ReferenceResolution.y);
        break;
    }
    case ScreenMatchMode.Shrink:
    {
        scaleFactor = Mathf.Max(screenSize.x / m_ReferenceResolution.x, screenSize.y / m_ReferenceResolution.y);
        break;
    }
}

a. Expand(扩大):将Canvas Size进行宽或高扩大,让他高于Reference Resolution,计算如下

scaleFactor = Mathf.Min(screenSize.x / m_ReferenceResolution.x, screenSize.y / m_ReferenceResolution.y);

意思是分别算出长宽 ,”Screen Size” 佔了 “Reference Resolution” 的比例,在求小的

举例来说,Reference Resolution为1280720,Screen Size为800600

ScaleFactor Width: 800/1280=0.625

ScaleFactor Height:600/720=0.83333

套用ScaleFactor公式:Canvas Size = Screen Size / Scale Factor

Canvas Width:800 / 0.625 = 1280

Canvas Height:600 / 0.625 = 960

Canvas Size 为 1280*960,高度从720变成了960,最大程度的放大(显示所有元素)

这里写图片描述
b. Shrink(收缩):将Canvas Size进行宽或高收缩,让他低于Reference Resolution,计算如下

scaleFactor = Mathf.Max(screenSize.x / m_ReferenceResolution.x, screenSize.y / m_ReferenceResolution.y);

意思是分别算出长宽 ,”Screen Size” 佔了 “Reference Resolution” 的比例,在求大的

举例来说,Reference Resolution为1280720,Screen Size为800600

ScaleFactor Width: 800/1280=0.625

ScaleFactor Height:600/720=0.83333

套用ScaleFactor公式:Canvas Size = Screen Size / Scale Factor

Canvas Width:800 / 0.83333 = 960

Canvas Height:600 / 0.83333 = 720

Canvas Size 为 960*720,宽度从1280变成了960,最大程度的缩小
这里写图片描述

c. Match Width or Height:根据Width或Height进行混合缩放,计算如下

float logWidth = Mathf.Log(screenSize.x / m_ReferenceResolution.x, kLogBase);
float logHeight = Mathf.Log(screenSize.y / m_ReferenceResolution.y, kLogBase);
float logWeightedAverage = Mathf.Lerp(logWidth, logHeight, m_MatchWidthOrHeight);
scaleFactor = Mathf.Pow(kLogBase, logWeightedAverage);

分别对ScaleFactor Width、Height取对数后,再进行平均混合,那为什麽不直接使用March对Width、Height进行混合呢??,让我们来比较一下

假设Reference Resolution为400300,Screen Size为200600 大小关系是

Reference Resolution Width 是 Screen Size Width的2倍

Reference Resolution Height 是 Screen Size 的0.5倍

看起来会像下图
这里写图片描述
当March为0.5时,ScaleFactor应该要是 1 (拉平)

ScaleFactor Width: 200/400=0.5

ScaleFactor Height:600/300=2

一般混合:

ScaleFactor = March * ScaleFactor Width + March * ScaleFactorHeight

ScaleFactor = 0.5 * 0.5 + 0.5 * 2 = 1.25

对数混合:

logWidth:log2(0.5) = -1

logHeight:log2(2) = 1

logWeightedAverage:0

ScaleFactor:20 = 1

scaleFactor一般混合为1.25,对数混合为1,结果很明显,使用对数混合能更完美的修正大小

Constant Physical Size

透过硬体设备的Dpi(Dots Per Inch 每英吋点数),进行缩放
这里写图片描述

  1. Physical Unit:使用的单位种类

这里写图片描述

2.Fallback Screen DPI:备用Dpi,当找不到设备Dpi时,使用此值

3.Default Sprite DPI:预设的图片Dpi

float currentDpi = Screen.dpi;
float dpi = (currentDpi == 0 ? m_FallbackScreenDPI : currentDpi);
float targetDPI = 1;
switch (m_PhysicalUnit)
{
    case Unit.Centimeters: targetDPI = 2.54f; break;
    case Unit.Millimeters: targetDPI = 25.4f; break;
    case Unit.Inches:      targetDPI =     1; break;
    case Unit.Points:      targetDPI =    72; break;
    case Unit.Picas:       targetDPI =     6; break;
}
 
SetScaleFactor(dpi / targetDPI);
SetReferencePixelsPerUnit(m_ReferencePixelsPerUnit * targetDPI / m_DefaultSpriteDPI);

结论

■ ScaleFactor 为 “目前硬体dpi” 佔了 “目标单位” 的比例

■ ReferencePixelsPerUnit 要与目前的Dpi在运算求出新的值,再传入Canvas中求出大小,公式如下:

新的 Reference Pixels Per Unit = Reference Pixels Per Unit * Physical Unit / Default Sprite DPI

UI大小 = 原图大小(Pixels) / (Pixels Per Unit / 新的 Reference Pixels Per Unit)
参考资料
■ Unity – Manual: Canvas

http://docs.unity3d.com/Manual/class-Canvas.html


Unity UGUI 原理篇(三):RectTransform

目标

1.理解 RectTransform Component
2.Anchor(锚点)
3.Pivot(支点)
4.Blue Print Mode 与 Raw Edit Mode

使用环境 与 版本

Window 7

Unity 5.2.4

RectTransform

这里写图片描述
RectTransform 是 Transform 的 2D 对应 Component,Transform 表示单个点,RectTransform 表示一个2D矩形(UI空间),如果父子物体都有RectTransform,那麽子物体可以指定在父物体矩形中的位置与大小,简单来说RectTransform 就是定义UI元素的位置、旋转、大小

Anchor (锚点)

这里写图片描述
物体的锚点(对齐点),如果父子都有 RectTransform 情况下,子物体可以依据 Anchor 对齐到父物体,又分为 Min 与 Max 位置,如下图物体四周有4个三角形
这里写图片描述
这里写图片描述

Anchor位置座标与关系
当我们使用滑鼠点选4个三角形调整Anchor时,会贴心的出现比例讯息,此比例是子物体在父物体中的缩放比例
这里写图片描述
这里写图片描述
当Canvas 下有1张图 Anchor Min 与 Anchor Max 皆为 (0.5 , 0.5),如下左图部分

如果将Anchor Min调整为(0.3, 0.5) ,Anchor Max调整为 (0.5, 0.7),如下右图部分

注意看 左图 Pos X、Pos Y、Width、Height ,会改变为 右图 Left、Top、Right、Buttom
这里写图片描述
因为当 Anchor 在同一点时,显示的是物体的座标与大小,当 Anchor 不在同一点时(此时会形成矩形),显示的会是 Anchor 矩形填充空间,如下图,(P.S.在我们移动物体时会贴心的显示目前与 Anchor 距离关系)
这里写图片描述
上面看完一定还是不了解怎麽运作,让我们来透过实例了解一下
Canvas 下有5张图,Anchor Min 与 Anchor Max 皆为 (0.5 , 0.5),物体的位置会对齐到父物体的中心,当父物体大小改变时,情形如下
这里写图片描述
Canvas 下有1张图,Anchor Min 与 Anchor Max 皆为 (0.0, 1.0),物体的位置会对齐到父物体的左上角,当父物体大小改变时,情形如下,物体会固定在左上角
这里写图片描述
Canvas 下有1张图,Anchor Min 为 (0.0, 0.0), Anchor Max 为 (1.0, 0.0),物体的位置会对齐到父物体的左下角与右下角,当父物体大小改变时,情形如下,物体宽度会随著父物体改变
这里写图片描述
由上面的几个实例可以知道,子物体会依据所设定 Anchor 对齐到父物体,当父物体大小改变时,透过 Anchor 更新子物体,上面有提到当我们点选4个三角形调整Anchor时,画面会贴心的出现比例讯息,相信有经验的人一定知道该比例的用意,此比例就是子物体在父物体中的缩放比例,以下举例
原来数值
Parent Size (400, 350)

Image Size (120, 105)

Anchor Min 为 (0.2, 0.5), Anchor Max 为 (0.5, 0.8)
这里写图片描述
Parent Size 一半时数值
Parent Size (200, 175)

Image Size (60, 52.5)
Image Size Width =400 * 50% * 30% = 60
Image Size Height =350 * 50% * 30% = 52.5
Anchor Min 为 (0.2, 0.5), Anchor Max 为 (0.5, 0.8)

经由上面可以得知父物体在缩小2倍后,父物体透过子物体的 Anchor 比例更新子物体,透过这种方式,我们可以达到不同萤幕解析度自动改变UI大小与位置
Anchor Presets
这里写图片描述
点选 RectTransform 左上角,可以开启Anchor Presets 工具,这边列出了常用的 Anchor ,可以快速套用,按住Shift 可以连同 Pivot 一起改变,按住 Alt 可以连同位置一起改变
Pivot (支点)
物体自身的支点,影响物体的旋转、缩放、位置,改变 UI Pivot 必须先开启控制面板的 Pivot 按钮,如下图
这里写图片描述

当 Pivot (0.5, 0.5)
这里写图片描述
当 Pivot (0, 1)
这里写图片描述

Blue Print Mode(蓝图模式) 、 Raw Edit Mode(原始编辑模式)
这里写图片描述

Blue Print Mode (蓝图模式)
忽略了物体的 Local Rotation 和 Local Scale,方便以原来的旋转与大小调整物体
这里写图片描述
这里写图片描述
Raw Edit Mode (原始编辑模式)
在 Inspector 中调整 Pivot 和 Anchor 时,物体会维持目前的位置与大小(Inspector 中数值部分),调整情形如下,请注意数值部分

Inspector 中调整 Pivot
这里写图片描述
Inspector 中调整 Anchor
这里写图片描述
参考资料
■ Unity – Manual: Basic Layout

http://docs.unity3d.com/Manual/UIBasicLayout.html

■ UnityのuGUIのレイアウト调整机能について解说してみる(RectTransform入门)

http://tsubakit1.hateblo.jp/entry/2014/12/19/033946


Unity UGUI 原理篇(四): Event System Manager 事件与触发

目标

1.Event System 事件系统
2.Input Module 输入控制
3.Graphic Raycaster
4.Physics Raycaster 与 Physics 2D Raycaster

使用环境 与 版本

Window 7

Unity 5.2.4

Event System

在建立出UI时,Unity会自动帮我们建立Event System物件,此物件是基于滑鼠、触摸、键盘的输入方式,传送 Event 到 Object 上,物件下有3个组件,分别为.Event System Manager、Standalone Input Module、Touch Input Module
这里写图片描述
1.Event System Manager
这里写图片描述
控管所有Event,负责将滑鼠、触摸、键盘输入方式(Input Module) 与 被选中的 Object 互相协调,每个 “Update” Event System 都会接收所有呼叫,并判断出这一瞬间要使用哪种Input Modules
Event System Info
当按下Play后,点选Event System物件,会在inspector显示 选中物件、位置、接收事件的Camera等等资讯
.这里写图片描述
First Selected

执行时第一次要选择的Object,例如:选择为 InputField (输入框) 后 ,按下Play后就会将游标 Force 在 InputField 上

Send Navigation Events

是否开启UI导航功能,导航功能是可以用键盘的 “上”、”下”、”左”、”右”、”Cancel(Esc)”、”Sumit(Enter)” 控制选择的UI

举例:如果画面上有多个选单按钮,我们可以设定按钮上的 Navigation Options 这裡使用Explicit方式,来指定按下键盘 “上”、”下”、”左”、”右” 要选取哪一个物件

Select On Up :当键盘按下 “上” 键后要选择的物件,Down、Left、Right 不多做赘述
这里写图片描述
Visualize Buttin: 按下Visualize可以看到物件指向的黄线
这里写图片描述
Drag Threshold

Drag Event灵敏度,越低越灵敏

2.Standalone Input Module
这里写图片描述
电脑输入控制模组,主要影响著滑鼠与键盘的输入,使用 Scene 中的 Raycasters 计算哪个元素被点中,并传递 Event

Horizontal Axis

代表 Input Module 中的 Horizontal Axis,可以被设定为 Input Manager 中的值,Vertical Axis、Submit Button、Cancel Button 不多做赘述

Input Actions Per Second

每秒能输入的最大按钮与滑鼠次数

Repeat Delay

重複输入的延迟

事件执行完整流程

键盘输入

1.Move Event:透过 input manager 验证输入 axis、left、right、up、down 按钮,传递给 selected object

2.Submit 、Cancel Button:物件已经 Preesed (按下)时,透过 input manager 验证输入 submit 、cancel 按钮,传递给 selected object

滑鼠输入

1.如果是新的按下

a.传送 PointerEnter event

b.传送 PointerPress event

c.将 drag 相关暂存

e.传送 BeginDrag event

f.设定Event system中的 selected object 为按下的Object

2.如果是持续按下(Drag)

a.处理移动相关

b.传送 Drag event

c.处理 Drag 时跨到其他物体的 PointerEnter event、PointerExit event

3.如果是释放(滑鼠放开)

a.传送 PointerUp event

b.如果滑鼠放开与按下时的物件一样,传送 PointerClick event

c.如果有 drag 相关暂存,传送 Drop event

d.传送EndDrag event

4.滑鼠中键滚轮传送scroll event

3.Touch Input Module

这里写图片描述
触摸输入模组,主要用于移动设备上,可以透过Touch、Drag的方式响应,使用 Scene 中的 Raycasters 计算哪个元素被点中,并传递 Event

事件执行完整流程

与Standalone Input Module 的滑鼠输入一样,滑鼠点下想成触摸即可

4.Event System 触发流程

1.使用者输入(滑鼠、触摸、键盘)

2.透过 Event System Manager 决定使用 Standalone 还是 Touch Input Module

3.决定使用的 Input Module 后,透过 Scene 中的 Raycasters 计算哪个元素被点中

4.传送Event

Graphic Raycaster (图形 射线检测员)

组件位置:Unity Menu Item → Component → Event → Graphic Raycaster
这里写图片描述
建立 Canvas 物件时下的其中一个 Component,Raycaster 会观察 Canvas下所有图形,并检测是否被击中,射线检测其实就是指定位置与方向后,投射一条隐形线并判断是否有碰撞体在线上,射线检测这点官方已经有详细说明,这裡用于判断是否点选到UI图形

Ignore Reversed Graphics:

背对著画面的图形,射线检测是否要忽略此图形

举例:当图形Y轴进行旋转180后,此时是背对著画面,这时是如果有打勾,就会忽略不检测此图形

Blocked Objects 、 Blocking Mask:

主要用于当Canvas Component Render Mode 使用 World Space 或是 Camera Space 时,UI 前有 3D 或是 2D Object 时,将会阻碍射线传递到 UI 图形

Blocked Objects 阻碍射线的 Object 类型

Blocking Mask 勾选的 Layer 将会阻碍射线

举例:如果画面上有一个 Button 与 Cube 位置故意重叠,现在点击重叠之处会发现 Button 还是会被触发
这里写图片描述
如果将Cube 的 Layer 改为 Test01 ,Blocked Objects 设定为 Three D,Blocking Mask 只勾选 Test01,再次点选重叠区域,会发现 Cube 会阻碍射线检测,此时按钮会接收不到射线,当然也不会有反应
这里写图片描述

Physics Raycaster (物理物件 射线检测员)
组件位置:Unity Menu Item → Component → Event → Physics Raycaster

透过 Camera 检测 Scene 中的 3D GameObject(必须有 Collider Component),有实现 Event Interfaces 接口的物件将会接收到 Message 通知,例如能让 3D GameObject 能接收 点下Event 或是 拖拉Event 等等……,看更多 Event 请点我

接下来让我们透过实例理解

1.建立 EventSystem,进行 Event 处理

物件位置:Unity Menu Item → GameObject → UI → EventSystem

2.Camera下增加 Physics Raycaster Component,用来观察射线
这里写图片描述
3.实现 Event Interfaces 接口,这裡有两种方式,一种是建立 Script 直接实作 Interfaces ,一种是使用Event Trigger Component

第一种 建立 Script 直接实作 Interfaces

a.建立一个 Script,实作 Event Interfaces

EventTest.cs

using UnityEngine;
using UnityEngine.EventSystems;
 
public class EventTest : MonoBehaviour, IPointerDownHandler
{
    public void OnPointerDown(PointerEventData eventData)
    {
        print(gameObject.name);
    }
}

Line. 2:using UnityEngine.EventSystems 汇入命名空间

Line. 4:继承 Event Interfaces,这裡是IPointerDownHandler(点下事件),看更多 Event 请点我

Line. 6~8:实作方法,传入 PointerEventData 为事件资料

b.建立一个3D物件(此称为Cube),并增加 BoxCollider Component

这里写图片描述
c.将 Script 放至 Cube 下,Inspector 中会出现 Intercepted Events 资讯,显示出正在监听的 Event
这里写图片描述
d.此时点击 Cube 就会通知 OnPointerDown 方法并传入事件资讯

第二种 使用Event Trigger Component 实作 Interfaces

a.建立一个 Script,实作方法,用于接收 Event Trigger 通知

EventTriggerTest.cs

using UnityEngine;
using UnityEngine.EventSystems;
 
public class EventTriggerTest : MonoBehaviour
{
    //BaseEventData 動態傳入事件資訊
    public void OnPointerDown(BaseEventData eventData)
    {
        print("OnPointerDown--BaseEventData");
    }
 
    //純呼叫
    public void OnPointerDown()
    {
        print("OnPointerDown--non");
    }
 
    //傳入int
    public void OnPointerDown(int i)
    {
        print("OnPointerDown--int");
    }
}

Line. 2:using UnityEngine.EventSystems 汇入命名空间

Line. 6~8:实作方法,这边实作3种

b.建立一个3D物件(此称为Cube),并增加 BoxCollider Component
这里写图片描述
c.将 Script 放至 Cube 下

d.Cube 下加入 Event Trigger Component,主要接收来至 Event System 的 Event ,并呼叫有实作的 Event

组件位置:Unity Menu Item → Component → Event → Event Trigger

e.点选 Add New Event Type 选择要实作的 Event 类型 ,这裡使用PointerDown(点下事件)举例
这里写图片描述
f.此时会新增一个UnityEvents,是一种透过编辑器设定的方式,设定 Event 触发时要通知的方法与属性,详细可以参考以下,这边简单说明

胡乱说‧随便写 – Unity:使用 UnityEngine.Events 让程式更灵活、稳定

Unity – Manual: UnityEvents

点下 “+” 按钮后,拖入要通知的Scene GameObject,Unity Event 就会寻找此 GameObject 上所有 Public 的方法与属性 ,就可以新增 Event 触发时 “通知的方法” 与 “预修改属性”

g.GameObject 拖入 Cube,通知方法设定 Script 中的3个方法
这里写图片描述
h.此时点击 Cube 就会触发 PointerDown ,通知 Script 中的3个方法

4.实作注意点:

■ Scene 必需有 EventSystem GameObject

■ Camera 必需有 Physics Raycaster Component

■ 3D GameObject 必须有 Collider Component

■ 实作 Event Interfaces 的方式,一种是建立 Script 直接实作 Interfaces ,一种是使用 Event Trigger Component,由上面实作可以知道,使用 Event Trigger 的方式可以使用编辑器设定,设定触发时的 “通知方法” 与 “修改属性”,且更为弹性

Physics 2D Raycaster
组件位置:Unity Menu Item → Component → Event → Physics 2D Raycaster

跟 Physics Raycaster 只差在于,Physics 2D Raycaster 是检测 Scene 中的 2D GameObject,当然 GameObject 上必须有 Collider2D Component,这边不再赘述

后记
我们透过输入的方式不同与 Raycaster 的关系,理解了整个 Event System 触发流程,而且也知道怎麽实作 Event 与应用 Event,不管是3D、2D、UI物件都可以方便的套用,大大提升开发速度、简化语法,可说是非常方便的功能

参考资料
■ Unity – Manual: Event System

http://docs.unity3d.com/Manual/EventSystem.html

■ Unity – Manual: UnityEvents

http://docs.unity3d.com/Manual/UnityEvents.html

■ Unity – Raycasting

http://unity3d.com/cn/learn/tutorials/modules/beginner/physics/raycasting

■ 胡乱说‧随便写 – Unity:使用 UnityEngine.Events 让程式更灵活、稳定

http://godstamps.blogspot.tw/2015/10/unity-unityengineevents.html


Unity UGUI 原理篇(五):Auto Layout 自动布局

目标

1.Auto Layout System 架构
2.Layout Element 元素大小
3.Horizontal丶Vertical丶Grid Layout Group 元素排列
4.Content Size 与 Aspect Ratio Fitter 大小控制

使用环境 与 版本

Window 7

Unity 5.2.4

Auto Layout System

Auto Layout System 是基于 Rect Transform Layout System 之上的系统,自动调整一个或多个的元素大小、位置、间格,又分为 Layout Controllers(父物件) 与 Layout Elements(子物件) 两部分,一个简单的 Auto Layout 架构如下 (此处介绍理论,实作留到后面)
这里写图片描述
Layout Element (子物件)
这里写图片描述
这里写图片描述
点选UI后,可以在 Inspector 最下方切换为 Layout Properties 看到资讯
这里写图片描述
这里写图片描述
Layout Controllers 透过不同的佈局方式,取得 Layout Element size 分配子物件,基本原则如下

首先分配 Minimum Size

如果还有足够空间,分配 Preferred Size

如果还有额外空间,分配 Flexible Size

从以下图片可以看出图片宽度的增长方式 (此处介绍理论,实作留到后面)
这里写图片描述
这里写图片描述
首先分配 Minimum Size (300,红色部分)

如果还有足够空间,分配 Preferred Size (300~500,绿色部分)

如果还有额外空间,分配 Flexible Size:1 (500~700,蓝色部分)

比较特别的是 Flexible,他是代表著整个大小的比例,如果 Layout 下有2个物体,分别给 Flexible 设定为 0.3 与 0.7,那比例就会变成下图 (3:7)
这里写图片描述
另外要注意的是,Text、Image Component 会根据内容大小自动分配 Preferred Size

Layout Controllers (父物件)
Layout Group

不会控制 Layout Controllers (父物件)自身大小,而是控制子物件大小与位置,在大多数情况下,根据每个元素的 minimum、preferred、flexible 大小分配适当的空间,layout group 之间也可以嵌套,又分为 Horizontal(水平)、Vertical(垂直)、Grid(格状) 3种

Horizontal Layout Group
这里写图片描述
水平方向(Width) 排列子物件

组件位置:Unity Menu Item → Component → Layout → Horizontal Layout Group

Padding:填充内部空间

Spacing:每个元素间格

Child Alignment:当没有填满全部空间时,子物件对齐位置

Child Force Expand:强制控制子物件填满空间

透过实例理解各参数:

A.开新 Scene
Unity Menu Item → File → New Scene

B.新增一个 Canvas
Unity Menu Item → GameObject → UI → Canvas

C.Canvas 下新增空物件,做为 Layout Controllers (以下简称父物件)

D.父物件增加 Horizontal Layout Group Component
Unity Menu Item → Component → Layout → Horizontal Layout Group

E.父物件下建立5个 Button(子物件),完成后如下,当大小改变时会自动分配子物件大小
这里写图片描述
F.此时在 Button 的 Rect Transform Component 就不能进行调整,因为我们已经透过 Horizontal Layout Group 进行分配空间,在 Rect Transform 会显示目前被哪个 Layout Group 控制
这里写图片描述
G.将 Padding 数值调整如图,可以看出填充区域
这里写图片描述
H.将 Spacing 数值调整如图,可以看出元素区间
这里写图片描述
I.接下来我们将5个 Button 增加 Layout Element Component 覆盖预设大小,用于手动设定每个元素的大小
组件位置:Unity Menu Item → Component → Layout → Layout Element

J.此时将 Horizontal Layout Group 的 Child Force Expand Width 取消勾选,不强制子物件填满额外空间,而是透过 Layout Element 手动设定

K.这裡使用几种不同的设定,来理解 Horizontal Layout Group 是怎麽取得 Layout Element size 分配子物件

■ 复习一下子物件大小分配方式,如果不清楚请回去上面 Layout Elements 部分

首先分配 Minimum Size

如果还有足够空间,分配 Preferred Size

如果还有额外空间,分配 Flexible Size

■ 将5个 Button 的 Layout Element Min Width 分别改为 20、30、40、50、60,此时可以看出每个 Button 宽度分佈,改变父物件大小时子物件大小并不会改变,因为只有分配 Min Width,并不会分配额外有效空间
这里写图片描述
此时改变 Horizontal Layout Group 的 Child Alignment,可以看出元素对齐
这里写图片描述
父物件 Layout Properties Min Width = 5个按钮宽(20+30+40+50+60=200) + Spacing(40) + Padding Left、Right(20) = 260
这里写图片描述
■ 现在将第1个 Button 的 Layout Element 数值调整如图
这里写图片描述
这边设定 Preferred Width 为 100

1.首先分配 Minimum Size(20)

2.空间足够的情况下,将会分配剩下的 Preferred Size (20~100 空间),如下所示
这里写图片描述
■ 现在将第1个 Button 的 Layout Element 数值调整如图
这里写图片描述
这边设定 Flexible Width 为 1

1.首先分配 Minimum Size(20)

2.如果还有足够空间,将会分配剩下的 Preferred Size (20~100 空间)

3.如果还有额外空间,分配剩下 Flexible Size,如下所示
这里写图片描述
■ 现在将 Horizontal Layout Group 的 Child Force Expand Width 勾选,让子物件强制填满

1.首先分配 Minimum Size(20)

2.如果还有足够空间,将会分配剩下的 Preferred Size (20~100 空间)

3.如果还有额外空间,分配剩下元素 Flexible Size 与 Child Force Expand Width
这里写图片描述
结论:
上面我们看到,所有元素会先被分配 Minimum Size,接下来还有足够空间,将会分配剩下的 Preferred Size,最后才是 Flexible Size 与 Child Force Expand Width

至此我们了解到 Horizontal Layout Group 是怎麽取得 Layout Element size 分配子物件

###Vertical Layout Group
这里写图片描述
垂直方向(Height) 排列子物件,与 Horizontal Layout Group 只差在水平或是垂直,这边不在赘述

组件位置:Unity Menu Item → Component → Layout → Vertical Layout Group

###Grid Layout Group
这里写图片描述
网格方式排列子物件

组件位置:Unity Menu Item → Component → Layout → Grid Layout Group

Padding:填充内部空间

Cell Size:每个元素的宽高
这里写图片描述
Spacing:每个元素间格

Start Corner:开始排列的角落(位置),又分为 “左上”、”右上”、”左下”、”右下”,请仔细看元素数字
这里写图片描述
Start Axis:”水平” 或是 “垂直” 排列,请仔细看元素数字
这里写图片描述
Child Alignment:当没有填满全部空间时,子物件对齐位置

Constraint:排列限制

Flexible:自动根据大小弹性排列

Fixed Column Count:限制排列 “行数(直)”

Fixed Row Count:限制排列 “列数(横)”

Layout Fitter

控制著 Layout Controllers 自身大小,大小取决于子物件,或是设定的大小比例,又分为 Content Size Fitter 与 Aspect Ratio Fitter

Content Size Fitter

这里写图片描述
控制著 Layout Controllers (父物件)自身大小,大小取决于子物件的 Minimum 或是 Preferred 大小,能透过 Pivot 改变缩放方向

组件位置:Unity Menu Item → Component → Layout → Content Size Fitter

Horizontal、Vertical Fit:水平、垂直 适应调整

None 不调整

Min Size 根据子物件的 Minimum 大小进行调整

Preferred Size 根据子物件的 Preferred 大小进行调整

透过实例理解:

如果我们现在有一个需求,必需要让 “父物件大小” 根据 “子物件大小” 进行缩放,完成如下 (方便明显看出父物件大小,增加黑色外框)
这里写图片描述
A.开新 Scene
Unity Menu Item → File → New Scene

B.新增一个 Canvas
Unity Menu Item → GameObject → UI → Canvas

C.Canvas 下新增空物件,做为 Layout Controllers (以下简称父物件)

D.父物件增加 Horizontal Layout Group Component
Unity Menu Item → Component → Layout → Horizontal Layout Group

这时如果增加 Button(子物件),上面有提到,Horizontal Layout Group 会根据子物件的 Layout Element 进行分配子物件大小,而不会修改父物件本身的大小,如下所示 (方便明显看出父物件大小,增加黑色外框)
这里写图片描述
E.父物件下增加 Button(子物件),并增加 Layout Element Component 覆盖预设大小,Minimum Width 调整为 100
组件位置:Unity Menu Item → Component → Layout → Layout Element

F.父物件增加 Content Size Fitter Component,Horizontal Fit 调整为 Min Size,透过子物件 Minimum Width 调整父物件本身大小 (Horizontal 方向其实就是取得子物件 Width)
这里写图片描述
G.此时如果 Button 複製增加,父物件本身的大小也会跟著改变,如下所示
这里写图片描述
H.调整父物件的 pivot,可以控制缩放方向,如下所示
这里写图片描述
I.通过上面实例,我们首先使用 Horizontal Layout Group 排列子物件,并在子物件增加 Layout Element 覆盖预设大小,最后透过 Content Size Fitter 取得子物件 Layout Element 设定父物件大小,至此父物件大小就会根据子物件大小进行缩放

###Aspect Ratio Fitter
这里写图片描述
控制著 Layout Controllers 自身大小,按照物件宽高比调整大小,能透过 pivot 改变缩放方向

组件位置:Unity Menu Item → Component → Layout → Aspect Ratio Fitter

Aspect Mode:调整模式

None:不调整

Width Controls Height:

基于 Width 为基准,依据比例改变 Height
这里写图片描述
当 Width 改变时,Height 会依比例改变
这里写图片描述
Height Controls Width:

基于 Height 为基准,依据比例改变 Width

这里写图片描述
当 Height 改变时,Width 会依比例改变
这里写图片描述
Fit In Parent:依据比例将 宽高、位置、anchors自动调整,使此图形大小在父物件中完全贴齐,此模式可能不会包覆所有空间

调整比例 (方便明显看出父物件增加黑底)

这里写图片描述
调整父物件大小,物体会依据比例贴齐父物件
这里写图片描述
Envelope Parent:依据比例将 宽高、位置、anchors自动调整,使此图形大小完全包覆父物件,此模式可能会超出空间

调整比例 (方便明显看出父物件增加黑框)
这里写图片描述
调整父物件大小,物体会依据比例包覆父物件
这里写图片描述
Aspect Ratio:比例,此数值为 宽/高

差别:

Content Size Fitter 是透过子物件自动进行调整大小

Aspect Ratio Fitter 是透过数值(宽高比)进行调整

后记
Auto Layout System 可以快速、方便的排列多个 UI,当大小改变时会自动调整内容,也能应用在多层崁套下,在日后调整与修改上也是非常方便与直觉,是 UI 系统中必学的功能之一 !!

参考资料
■ Unity – Manual- Auto Layout

http://docs.unity3d.com/Manual/UIAutoLayout.html

■ Unity – Manual- Auto Layout_UI Reference

http://docs.unity3d.com/Manual/comp-UIAutoLayout.html


Unity:UGUI 应对各种萤幕自动调整大小及位置

UGUI自适应

以前曾经发佈过两篇有关 GUI 自动调整的文章「Unity 自动调整 GUI 缩放比例及位置」以及「Unity:应对各种萤幕比例自动调整画面缩放及位置」,
自从 Unity 于 4.6 版发佈了新的 GUI 系统(UGUI)之后,使用 Unity 製作 UI 变得更为简单方便,同时也比较不需要依赖第三方製作的 UI 工具了,在事件系统上也有了一些革新,UI 事件与 Component 之间变得更加视觉化,彼此间的藕合度大大降低,而使得使用上更为弹性,虽然,UGUI 解决了许多以前 UI 製作上面的问题,但实际开发时,还是有些部分需要使用者做些调整。

在 Unity 4.6 发佈之后,UGUI 相关的游戏物件,不像一般的游戏物件使用 Transform,而是 Rect Transform,其中多了宽、高以及 Anchors、Pivot 等栏位,这些栏位对 UI 製作的视觉化设计上有很大的帮助,而其中的 Anchors 更是让 UI 整体应对于各种不同比例画面有著更加强大及弹性的控制权。

如果在 Unity 的 Game view 使用 Free Asspect 观察画面时,任意的拉动视窗边缘去调整画面比例,可以发现 UGUI 本身是并不会移动位置或缩放大小,如果将 320x480 变为 480x320,就有可能使 UI 被画面边缘切掉,这时候 Anchors 就能发挥很大的用处,使得 UI 图片或按钮等元素都能跟随画面比例的改变而变更其宽高大小,但其美中不足的是文字并不会因此跟随改变大小,当然,如果文字有勾选 Best Fit 的话,也会有自动变更 Size 的效果,只是,按钮、图片等 UI 元素跟随画面比例改变,也改变了本身的宽高比例,但文字却只是改变 Font Size,所以,当画面比例改变了,图片变形了,文字并未跟著变形,那麽文字与其他 UI 之间的距离或是按钮边缘与按钮内的文字的间隙就可能会发生奇怪的变化,这些都是我们所不希望看到的,所以,最好的状况应该是,当画面比例改变了,UI 的图片、文字、按钮等文字都能维持原本的长宽比例自动缩放大小及位置。

这里写图片描述
正常的纵向画面
这里写图片描述
转为横向时,画面被切掉了
这里写图片描述
为 UI 设置好 Anchors
这里写图片描述
转为横向后,UI 自动变形调整,但文字不同

当在场景中建立第一个 UGUI 的游戏物件时,一定会先自动建立 Canvas 的游戏物件,在这个物件中,预设配置了 Canvas、Canvas Scaler、Graphic Raycaster 这三个 Component,其中的 Canvas Scaler 正是用来控制 UGUI 整体的缩放,所以只要依照以下步骤,就能达到最基本的依照原比例调整 UI 的目的:

  • 1.让所有的 UI 的 Anchors 维持在预设值(0.5)。
  • 2.将 Canvas Scaler 的 Ui Scale Mode 栏位设置为 Scale With Screen Size。
  • 3.在 Reference Resolution 栏位输入基础解析度的宽(X)、高(Y)。
  • 4.Screen Match Mode 栏位选择 Match Width Or Height。
  • 5.如果画面为横向,Match 栏位选输入 0,如果画面为纵向,Match 栏位输入 1。

这里写图片描述
让 Anchors 维持在预设值 0.5
这里写图片描述
设置 Canvas Scaler 的相关栏位

如此,当画面从纵向转为横向,GUI 就会自动维持原比例调整其大小及位置。
这里写图片描述
转为横向画面,UI 的比例及位置不变

但是,这是在比例相同直接横向转纵向时才会如此理想,当遇到比例不同的画面,例如原本是 iPhone 4 的 640x960 设计的 UI 佈局,遇上了 iPhone 5 的 640x1136 画面,就会发生左右两边被切掉的情形。
这里写图片描述
当比例不同时,边缘被切掉了

这时我们就必须将 Canvas 游戏物件的 Canvas Scaler componet 的 Match 栏位改为 0,使其 UI 依照原本比例缩放调整到画面内。
这里写图片描述
调整 Canvas Scaler 的 Match 使被切掉的部分回到画面内。

为了因应可能遇到各种未知的画面比例(特别是 Android 以及桌机平台),我们可以为 Canvas 挂上包含以下这一段程式码的 component 来自动调整 Canvas Scaler component 的 Match 栏位。

void Awake(){

    CanvasScaler canvasScaler = GetComponent<CanvasScaler>();

    float screenWidthScale = Screen.width / canvasScaler.referenceResolution.x;
    float screenHeightScale = Screen.height / canvasScaler.referenceResolution.y;
 
    canvasScaler.matchWidthOrHeight = screenWidthScale > screenHeightScale ? 1 : 0;
}

完成以上的工作,将来在 UI 製作上就会轻鬆很多,如果没有特殊需求,基本上不需要动到 UI 的 Anchors 值,大部份都只是单纯的调整 UI 大小及位置就行了,面对各种画面比例,也将维持原设计的佈局自动调整,另外,如果需要製作 UI 的动态缩放、位移等等使画面更生动的话,以变更其 Local space 的数值为主,那麽比例缩放的部分都不需要特别去考虑,Canvas Scaler 会帮我们处理。

不过,有一个例外,目前是无法使用此办法解决的,就是当 UI 文字使用了 Rich Text 的 Size 标签去指定文字大小时,文字的大小是不会受到 Canvas Scaler 影响的,它指定了绝对的文字 Size,这一点要特别注意。

附带一提,除了 UI 佈局以及变化之外,有时候也会想在 UI 上做些粒子特效,或是让非 GUI 的游戏物件在画面上与 UI 呈现互动的效果,此时,只要把 Canvas 游戏物件的 Canvas component 的 Render Mode 栏位改为 Screen Space - Camera 并设定好 Render Camera 及 Plane Distance 的内容,那麽放置于 UI 平面与其指定的 Camera 中间的物件就可以显示于 UI 之上与其互动,如果是 Sprite 游戏物件,则可以依据 Sorting Layer 与 GUI 之间调整前后顺序;不过,当遇到自动调整过的 GUI 画面,这些非 GUI 的游戏物件大小及位置可能会与预期的不同,为了避免此情况发生,可以参考之前发佈过的文章内容「Unity:应对各种萤幕比例自动调整画面缩放及位置」(该文章是Unity4.3版本的,所有就没给大伙们搞过来)去调整 Camera。
这里写图片描述
改变 Canvas 的 Render Mode 为 Screen Space - Camera

PS:目前使用 Unity 版本为 5.0.1f1。


Unity:制作 UGUI 的 UI 流程管理机制

为什么需要UI流程管理机制

自从 Unity 4.6 发布新 GUI 系统之后,Unity 终于有个比较完整的视觉化编辑 UI 工具可以使用,于是,我们可以很方便、直觉的在画面上添加按钮,使用拖曳、下拉选单等几个动作就能设置好 UI 事件应该执行哪个 GameObject 上的哪个 Component 中的功能,所以透过 UI 去触发我们自己撰写的程式功能也变得非常简便,但是整个游戏内容可能会有相当多的画面,不同的 UI 按钮或行为将转向不同的画面,也需要开启不同 UI 视图,如果没有规划好 UI 画面的动线规则,在複杂的画面转换间,将可能会发生很难维护的情形,甚至在未来多次的变更修改后产生不必要的 Bug 而使得 UI 画面动线变得相当混乱。

不管 UI 做得多漂亮、多华丽,反馈、排版、效果等这些细工做得多好,如果整体架构、动线流程出错了,做了那么多细工的辛苦就会白费掉,因为,会让玩家迷路的 UI 动线,使用起来就是会不舒服;即使使用 UI 的动线设计都没问题,但没有规划一致性的流程管理,在制作及维护上也容易造成一些困扰。

举例来说,大部份的 UI 画面都会有个「返回」按钮可以回到前一个画面,当这个 UI 画面是从 A 画面进来时,应该可以返回到 A 画面,从 B 画面进来时,应该可以返回到 B 画面,就像我们平常使用网页浏览器一样,不管目前的页面是从哪裡进来的,按下「上一页」就是会回到进来目前网页之前的那个网页,UI 上的「返回」按钮也是一样的功能,只是,这个返回是个按钮,它会被我们设置执行某个 Component 的某个功能,透过这个功能来使它开启某个 UI 画面,所以,我们很直觉的就会有点像写死的程式一样,A 画面进入 B 画面,所以点击 B 画面的返回按钮就是开启 A 画面,如果,C 画面也可以进入 B 画面呢?那麽就做个暂存纪录让 B 画面判断是从 A 还是 C 画面进入的,或者进入 B 画面的同时,通知 B 画面说是从哪裡进来的,此时,第一个问题来了,每当多出一个会进入到 B 画面的画面,B 画面的返回按钮功能就要进行修改来达到正确的判断;第二个问题,假设 A、B 画面都可以进入 C 画面,C 画面可以进入 A、D 画面,A、D 画面都可以进入 B 画面… 等等较深入的交叉动线,新增一个 UI 画面或者更动到某个 UI 画面流程,就几乎全部画面的返回键都要进行修改,这种工程实在太浩大了,牵一髮而动全身的维护状况是最容易产生未知 Bug 的。

有于此,设计的 UI 流程管理机制至少要满足两个条件:

  • 玩家使用时不会迷路。
  • 不管未来变更多少画面,都不需要修改或维护返回按钮。

要满足这两个条件,有一个最直接的做法,也就是前面提到的,网页浏览器的「上一页」功能,这个功能是如何实现的呢?概念其实就是浏览纪录,也就是说我们只要把玩家操作时,所切换过的 UI 画面依序记录下历程,再依序返回,这样子,玩家使用时不会迷路,我们在制作及维护时,也不需要为每个画面的返回按钮客制化。

流程上的概念没问题了,另外就是一些其他要注意的部分:

  • 每个 UI 画面间的进场和退场动态,
  • 进退场画面进行中时,UI 事件不能有作用。
  • 退场 UI 画面即使游戏画面上看不到,也不应该让它持续执行。

前面写了那麽多,最重要的还是如何实作,以下是整个实作过程的影片,影片内并没有太详细说明,所以,在下面的文章内容提供进一步的详细解说:

UI 画布的基本结构

先决定我们要使用怎么样的画面比例、解析度来编排制作 UI,通常会跟 Game view 设置好要预览的画面相同
这里写图片描述
建立 UI 的主画布(Canvas),并在其 Canvas Scaler 设置好 Ui Scale Mode 以及 Reference Resolution,这主要是为了使将来 UI 面临不同画面比例的装置时,可以有基本的自适应调整

这里写图片描述

接下来,每个 UI 画面都应该另外建立 Canvas,并将画面内的其他 UI 元件放置在该 Canvas 之下,如此前面主画布里设置好的 Canvas Scaler 也将直接适用于其下的每个 UI 画面,另外,这麽做的另一个好处是,之后可以直接变更 Canvas 的 Sort Order 来排列 UI 画面的前后顺序。同时,每个画面除了 UI 元件之外,还需要使用 Image 制作一个覆盖全画面大小的「透明遮挡层」,并放置于其它 UI 元件之上,平常处于 GameObject 被关闭的状态,当 UI 画面在进行进场、退场动态时,才将它开启,这样可以保护 UI 的 Button 不会被点击到。
这里写图片描述

制作动画

制作 UI 画面的进场、退场动画档分别命名为 Open、Closed,最简单的就是淡入、淡出或者是放大、缩小的方式,当然,也可以设计更丰富的动画效果,最重要的是,进、退场动画档播放期间要记得开启前面製作的「透明遮挡层」。
这里写图片描述
动画播放期间开启「透明遮挡层」

设置动画控制

当我们为 UI 画面制作好进场、退场的动画档之后,开启 Animator view,可以发现 Unity 已经自动帮我们在 Animator 建立两个与动画档相同名称的动画状态(State)。
这里写图片描述
预设,Unity 会自动将 AnimationClip 放到 Animator 做为 state

接着,从 Open 状态建立 Transition 连接到 Closed 状态,并在 Inspector view 设置其中的过渡条件,由于 Unity 预设会认为两个动画状态之间的转换是需要混合过程的(例如,人物角色閒置的动作转换到跑步动作),这个混合过程会牺牲一点动画档本身的播放时间,在 UI 画面转换的动画并不需要这种混合过程,所以在此,我们可以直接将过渡时间 Transition Duration 设置为 0,让它很明确的播放 Closed 动画;由于,Open 状态并不需要播放结束之后马上转换到 Closed 状态,而是等待程式通知 Animator 触发 Out 参数才转换到 Closed 状态,所以,在此也要取消勾选 Has Exit Time,并且在 Conditions 设置一个过渡条件 Out。
这里写图片描述
设置 Transition 裡的几个相关栏位

然后,再从 Closed 状态建立 Transition 连接到 Exit 状态,并在 Inspector view 设置过渡时间 Transition Duration 为 0,把 Exit Time 设置为 1,为什麽要这样做呢?理论上,当 Closed 播放完毕之后,UI 画面就会完成退场的动作,在它下次进场之前,都不需要去理会它,但为了不让不在游戏画面中的 UI 画面继续执行,浪费效能资源,我们会希望完成退场之后,可以将这些 UI 画面整个 GameObject 都关闭,所以,我们后续会撰写 Animator 的 State 专用的 StateMachineBehaviour script来做这件事,而 StateMachineBehaviour 的 OnStateExit 是在状态结束「之后」才会被呼叫,所以,如果没有为 Closed 建立 Transition 连接出来的话,StateMachineBehaviour 的 OnStateExit 将不会执行,另外,Exit Time 是以 0 到 1 来代表整个动画时间从开始到结束的时间点,我们希望 Closed 是能够明确的播放到结束时间才真的结束,所以在此的 Exit Time 才直接设置为 1。
这里写图片描述
设置好正确的时间值

由于,在 Unity 裡建立动画档时,预设会认为该动画是要重複循环播放的,所以,我们还要另外手动找出 Open 及 Closed 动画档,并在 Inspector view 裡将 Loop Time 取消勾选。
这里写图片描述
取消 Loop Time

###动画状态脚本
这部分,最主要的是要让 UI 画面退场之后,也能同时将它的 GameObject 整个关闭掉,以往,我们是在 GameObject 挂上我们自已写的 Script,并在製作动画档时,在 Animation view 加入 Event,自从 Unity 5.0 发佈后,就不再需要这麽麻烦,我们可以直接点选 Animator view 裡的任意状态,并在 Inspector view 中点击 Add Behaviour 按钮,建立 Animator 状态专用的 Script,如此就可以直接透过撰写这个 Script 的内容来对 Animator 裡的状态针对状态开始、进行中、结束… 等等的时机进行其他操作,因此,我们要让 UI 画面退场之后关闭本身 GameObject,只需要为 Closed 建立 StateMachineBehaviour 并在 OnStateExit 加入简短的一行程式码即可。
这里写图片描述
为 Animator 的 State 加入 Behaviour

using UnityEngine;

public class UIStateClosed : StateMachineBehaviour {

    override public void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) {

        animator.gameObject.SetActive(false);
    }
}

UI流程管理脚本

接下来算是重头戏了,做完前面的工作,剩下的就是靠这个 Script 去做主要的管理,而这个 Script 主要做哪些工作呢?我们将其列出如下:

  1. 建立一个列表来纪录 UI 画面历程,用来将曾经进入的 UI 画面依序记录下来,以方便依序返回。
  2. 先将第一个开启的 UI 画面记录到历程中,当历程只剩下一笔时,就不能再返回。
  3. 不可以进入与目前 UI 画面相同的画面。
  4. 即将要进入或返回的目标画面必须移到最上层。
  5. 往前进入的目标画面必须记录到历程中。
  6. 返回时,必须要将目前画面从历程纪录中移除。

另外,之前的文章「Unity:认识 Tag 与 Layer 的差异与应用」曾提到过程式码中应该避免写死的字串值,所以,这个 Script 因为会使用到 Animator 的 Parameters 中设定的名称来通知 Animator 转换到 Closed 状态,所以也需要宣告一个 public 栏位来设置该名称。

有了以上的工作需求,我们就可以撰写出如下的程式码:

using UnityEngine;
using System.Collections.Generic;

public class UIManager : MonoBehaviour {

    public GameObject startScreen;
    public string outTrigger;
    private List<GameObject> screenHistory;

    void Awake(){

        this.screenHistory = new List<GameObject>{this.startScreen};
    }

    public void ToScreen(GameObject target){

        GameObject current = this.screenHistory[this.screenHistory.Count - 1];

        if(target == null || target == current) return;

        this.PlayScreen(current , target , false , this.screenHistory.Count);
        this.screenHistory.Add(target);
    }

    public void GoBack(){

        if(this.screenHistory.Count > 1){

            int currentIndex = this.screenHistory.Count - 1;
            this.PlayScreen(this.screenHistory[currentIndex] , this.screenHistory[currentIndex - 1] , true , currentIndex - 2);
            this.screenHistory.RemoveAt(currentIndex);
        }
    }

    private void PlayScreen(GameObject current , GameObject target , bool isBack , int order){

        current.GetComponent<Animator>().SetTrigger(this.outTrigger);

        if(isBack){

            current.GetComponent<Canvas>().sortingOrder = order;

        }else{

            current.GetComponent<Canvas>().sortingOrder = order - 1;
            target.GetComponent<Canvas>().sortingOrder = order;
        }

        target.SetActive(true);
    }
}

套用

完成以上的工作以及程式撰写之后,只要建立一个空的 GameObject 并将 UIManager script 挂上去,在 Start Screen 栏位放入第一个要显示的 UI 画面 GameObject,在 Out Trigger 填写跟 Animator 设置的 Trigger 参数相同的名称。
这里写图片描述
设置 Start Screen 及 Out Trigger 栏位

然后,在每个 UI 的 Button 中的 On Click 设置附有这个 UIManager script 的 GameObject,如果按钮是要前往下一个画面,则在下拉选单选择 ToScreen 并在其参数栏位设置目标 UI 画面的 GameObject。如果按钮是要返回上一个画面,则在下拉选单选择 GoBack。

这里写图片描述
前往下个 UI 画面,选择 ToScreen
这里写图片描述
设置好下个 UI 画面的 GameObject
这里写图片描述
返回上个 UI 画面,选择 GoBack

接下来,执行时,就能将每个进入的画面历程记录下来,并在每次返回时依序返回上一个画面,每个即将显示的 UI 画面也将会是在游戏画面的最上层,而不会被遮挡到,同时,在画面的进、退场动态期间也不会被不小心按到按钮而跳到非预期的画面;由于,动线被定义为从哪裡进去就从哪裡返回,所以,使用者在众多的画面浏览间,会比较直觉的操作而不容易迷路,同时,因为画面历程的纪录,返回按钮一律透过 GoBack 去处理时,将来不管是新增多少 UI 画面,或是 UI 画面流程如何改变,返回功能都不需要再进行任何修改,也可以返回到正确的画面。

以上,这个简单的 UI 流程管理机制算是完成了,之后,我们如果对于 UI 执行转换动作的逻辑要进行变更(例如,目标画面的排序规则),则只需要修改 UIManager 裡面的 PlayScreen;如果,要换成别的进场、退场动画效果,也只需要替换掉 Animator 裡面各状态的 motion;如果做了多种版本的 UIManager 并存于同一个专案或场景中,也可直接变更 UI 裡 Button 的 On Click 设置,整个机制相当的弹性,但是,玩家操作上却不至于混乱,在后续维护上也将会更为轻松。

案例工程:http://pan.baidu.com/s/1sk9bnGh 密码:do7y

PS:目前使用 Unity 版本为 5.1.0f3


Unity:使用 UnityEngine.Events 让程式更灵活、稳定

自从 Unity 4.6 发佈新的 GUI 系统之后,我们可以从所建立的 GUI Control 发现新的事件栏位,例如,建立一个 Button,可以从 Inspector 视窗裡面的 On Click 栏位指定当按钮被点击时要去执行那一个 GameObject 上的哪个 Component 的功能,使得按钮事件可以更视觉化、更弹性的编辑,当然,其他的 GUI Control 也都有类似的栏位可以做这样的设置,而这个栏位则是由 UnityEngine.Events 底下的 UnityEvent 型别所产生的,我们自己所製作的 Component 同样也可以提供这样的栏位,使可以视觉化编辑,以及让程式更加弹性。

在此影片使用两个范例来示范作法,透过画面操作以及语音的说明,相信可以更加了解到

首先,简单来说明一下 Unity 写作程式的基础,就是当我们在 Project 视窗建立我们自己的 Script 之后,将这个 Script 附加到 GameObject 之上,就会成为该 GameObject 的 Component,通常,变数栏位(Field)如果是使用 public 修饰字来宣告,而其型别是可序列化的话,在 Inspector 视窗就会产生可以设定其值的栏位,这是因为 Unity 本身预设会对 public 栏位自动序列化的关系。
这里写图片描述
public 的变数栏位会出现在 Inspector 视窗,可供编辑。

可是,如果 Class 裡所宣告的栏位并没有要提供给外部存取的话,使用 public 修饰字就有些不恰当,所以,当使用 private 或 protected 等其他修饰字来宣告时,如果,希望该栏位变数也可以在 Inspector 视窗出现可编辑的栏位,可以在它的上一行插入 SerializeField 的 Attribute(特性),那麽 Unity 就知道这个栏位是要序列化使可以在 Inspector 视窗编辑。

这里写图片描述
有 SerializeField 的 private 变数栏位也会出现在 Inspector 视窗。

如果,要製作像是 UGUI 的 Button 那样的事件栏位,最基本的就是要在程式档最上方加个 using UnityEngine.Events,然后只要是使用 UnityEvent 为型别宣告的栏位,都会有个像是 Button 那样的事件栏位。
这里写图片描述
UnityEvent 型别的变数栏位,在 Inspector 视窗会出现事件栏位。

这个 UnityEvent 栏位在编辑器上的编辑相当弹性,当目标 Component 裡面含有使用 public 宣告的属性(Property)或方法(Method),并且传入值的型别为 bool、int、float、string 其中一种的话,就能直接在这裡选择并提供传入的值,而且可以设置多个不同型别的目标,并在之后程式执行时直接呼叫执行,另外,如果 Method 并没有宣告传入参数的话,在此也可以选择设置,如果是宣告两个以上的参数,在这边的选单就不会出现了。

虽然 UnityEvent 栏位相当方便和弹性,不过,它所传入的值是在编辑器上面设置的,而且只能设置一个值,如果,我们的 Component 中的程式想要直接提供参数值给目标的话,光靠 UnityEvent 就没办法做到,幸好,UnityEngine.Events 除了 UnityEvent 之外,还另外提供了四个泛型类给我们扩充使用。

我们在影片中的两个范例可以看到,其中的 PassEvents Script 专门用来撰写扩充 UnityEvent 泛型类的新事件型别,相关资料可以参考官方文件的 UnityEngine.Events 相关资料,例如 UnityEvent。总共有 UnityEvent、UnityEvent<T0,T1>、UnityEvent<T0,T1,T2>、UnityEvent<T0,T1,T2,T3> 这四个可供扩充,其实,他们所具备的功能都是一样的,只是,能接受的参数数量不同而已,也就是说,我们可以透过继承这几个泛型类来宣告我们自己需求的参数型别的 UnityEvent,而且可容纳的参数数量可以有一到四个。例如:

[System.Serializable]
public class PassString : UnityEvent<string>{}

[System.Serializable]
public class PassColor : UnityEvent<Color>{}

因为,所宣告的 class 希望用于宣告栏位变数时,可以显示于 Inspector 视窗,除了使用 SerializeField 标示在栏位上面之外,该型别也必须是可序列化的才行,所以,还要在 class 上方也加上 System.Serializable。

到这裡,我们就能够使用自己定义的 UnityEvent 来宣告事件栏位,并使它可以显示于 Inspector 视窗。

###1. Simple Computer
第一个范例裡,主要是製作一个简单的计算器来示范 UnityEngine.Events 的用法以及所带来的好处;製作任何东西之前,一定要先了解到这个东西的使用目的以及功能有哪些,所以,我们先用简单的 UI 排出一个运算式的样子,这个运算式提供了两个输入栏位、一个运算符号的文字、一个显示计算结果的文字,以及四个运算功能按钮。
这里写图片描述
在此,我们先定义计算器的基本功能:

  • 点击运算功能按钮,会依照计算种类去改变运算符号的文字。
  • 点击运算功能按钮之后,在 UI 显示计算结果文字。

功能相当简单,所以,我们直接在 Project 视窗建立一个 C# Script 就差不多能处理全部的功能,先将此 Script 命名为 MyComputer。

由于,最后会将计算结果转换为字串传给 UI 去显示,在这裡会使用到 UnityEvent 去传递资料,只是一般的 UnityEvent 并无法直接在程式呼叫时就带入参数,所以我们还需要使用前面提到的做法来宣告可以带字串参数的 UnityEvent,因为,宣告这个衍生类只需要写一行,而且,将来还可能会宣告好几个这种带不同参数的 UnityEvent,所以,我们还要在 Project 视窗建立一个名为 PassEvents 的 C# Script,专门用来写这些 Class 用,如果分类好,这支 Script 还可以直接拿到其他专案中使用。

在 PassEvents Script 裡面,首先,由于是要製作 UnityEngine.Events 的那些泛型类的衍生类,所以,最开头一定要先写一行 using UnityEngine.Events,接下来,在这个示范裡只会用到传递字串,所以,先只宣告一个能传递字串的 Class 就好。

using UnityEngine.Events;

[System.Serializable]
public class PassString : UnityEvent<string>{}

别忘了 System.Serializable,否则,在 Inspector 视窗会看不到栏位。

而在 MyComputer Script 之中,我们这个简单计算器主要就是对两个计算值计算出结果而已,配合 UI 的使用,所接收到的值原本会是字串,但我们在程式中却必须做为数值来计算,所以,先宣告两个仅限内部存取的栏位来暂存传入的数值,这个数值的来源,则是要由 UGUI 的 InputField 的 Edit End 事件传过来的,当然,我们在 MyComputer Script 裡面,并不用管那麽多,只要提供两个 Property 让外部可以把字串传入就行了,管他是谁要传进来的,只要提供入口,并且把传入的字串转为数值暂存下来,这样其他计算功能就能计算了。

因为 MyComputer Script 的工作主要工作就是接收计算资料并计算出结果传递出去,所以,我们需要宣告每个计算结果的事件,来表达事情的发生,至于,最后会把结果传给谁,其实,并不需要 MyComputer 去管。

目前,我们定义 MyComputer Script 只做加、减、乘、除四个计算功能,于是,就直接将获得的数值计算出结果,并将结果转为字串后,透过 Invoke 来呼叫执行个别对应的事件,那麽计算器的基本功能就算完成了。

private float _value1;
private float _value2;

[SerializeField]
private PassString onAdd;
[SerializeField]
private PassString onSubtract;
[SerializeField]
private PassString onMultiply;
[SerializeField]
private PassString onDivide;

public string value1{
    set{
        float.TryParse(value , out this._value1);
    }
}

public string value2{
    set{
        float.TryParse(value , out this._value2);
    }
}

public void Add(){

    this.onAdd.Invoke((this._value1 + this._value2).ToString());
}

public void Subtract(){

    this.onSubtract.Invoke((this._value1 - this._value2).ToString());
}

public void Multiply(){

    this.onMultiply.Invoke((this._value1 * this._value2).ToString());
}

public void Divide(){

    if(this._value2 == 0) return;

    this.onDivide.Invoke((this._value1 / this._value2).ToString());
}

因此,获得以上的程式码,其中,除法 Divide() 的部分要特别注意,因为,除法裡的除数不得为零,不然,会发生错误,所以计算之前要先判断一下,如果除数为零,就不要执行后面的计算。

写好 MyComputer Script 的内容之后,在 Unity 中,先建立一个空物件并且赋予它 MyComputer 成为它的 Component,这时候,可以很明显地从 Inspector 视窗看到分别为加、减、乘、除的事件栏位。
这里写图片描述
MyConputer 出现加、减、乘、除的事件栏位。

接下来就可以在 UI 以及 MyComputer 间设置彼此之间的关系,首先,需要让 UI 输入的值可以传递给 MyComputer,所以,要从两个 InputField 中的 End Edit 事件分别设置将输入的字串传给 MyComputer 的 value1 以及 value2 两个 Property。
这里写图片描述
Value1 Field 输入的字串传给 MyComputer 的 value1
这里写图片描述
Value2 Field 输入的字串传给 MyComputer 的 value2

在这裡可以发现这个 End Edit 其实也是跟我们所宣告的 PassString 一样的东西,设置好之后,不需要在 Inspector 视窗上设置传入什麽字串,因为,这个 End Edit 事件是当 InputField 中的文字输入完毕后,按下 Enter 或者点击 UI 文字栏位外的地方,使它不能被输入文字时,而视为文字输入完毕时被呼叫执行的,当他被呼叫执行时,就会将其输入的文字透过这个事件而传递出去,所以,这裡设置完毕之后,只要 UI 上的文字栏位输入完毕后,都会将所输入的内容传递给 MyComputer,而 MyComputer 则如我们程式中所写的一样,将收到的字串转为数值暂存下来。

接下来,就是个别选择 UI 上分别代表加、减、乘、除功能的按钮,并在它们的 On Click 事件栏位设置执行 MyComputer 裡面相对应的计算功能。
这里写图片描述
Button + 的 On Click 事件执行 MyComputer 的 Add()
这里写图片描述
Button - 的 On Click 事件执行 MyComputer 的 Subtract()
这里写图片描述
Button x 的 On Click 事件执行 MyComputer 的 Multiply()
这里写图片描述
Button / 的 On Click 事件执行 MyComputer 的 Divide()

而这个 On Click 事件,相信大家都非常熟悉,就是按钮被点击时触发执行。正确来说,应该是点击按钮之后,并在同一个按钮之内放开按钮才会执行。

到这裡,UI 已可将输入的资料提供给 MyComputer,并将需要执行的功能要求 MyComputer 去进行,然后,我们就要来为 MyComputer 设置它的加、减、乘、除事件,使得 UI 可以显示出结果。

回想一下我们前面写的计算器主要功能,第一步,要让计算符号改变,所以,每个计算事件,都要设置事件发生时去改变 UI 上的计算符号文字,在这裡,虽然 MyComputer 的计算事件预设是会由程式裡面传递出结果,但 UnityEvent 栏位本身就能直接传入静态参数,所以,我们的程式码裡面不用为那些计算功能撰写有关改变运算符号的部分,只要直接在 Inspector 视窗上面设置就行了。

第二步,则是要让 UI 上显示出计算结果,由于 MyComputer 程式码裡面直接将计算结果的字串传给了个别对应的事件,所以,直接为每个事件设置他们的目标是 UI 上显示结果的 Text 即可。
这里写图片描述
每个计算功能事件让 UI 变更运算符号以及显示计算结果

这样子,每当 MyComputer 执行计算时,就会把字串传递给 UI 显示出来。
这里写图片描述
计算结果的画面

现在,计算器需求的功能齐全了,我们可能还想要做些更细微的调整,例如,在输入的值未改变的情况下,已经执行过的计算的,就不想要再次计算,所以,要将该功能按钮关闭。在 UGUI 的 Button 中,有一个 Interactable 栏位,是用来管理使用者与按钮之间的互动开关,当它被关闭时,Button 就会失去作用而呈现较暗的颜色,所以,我们在这边可以制订一个功能是当计算结果出来之后,把所对应的功能按钮上的 Interactable 关闭,而这个功能完全不用去修改程式码,只要再次去为每个计算功能的事件栏位加入执行目标即可。
这里写图片描述
计算结果之后关闭按钮。
这里写图片描述
计算过的按钮都关闭了。

虽然,按钮在计算之后可以被关闭了,可是,如果输入数值的栏位内容被改变了,应该还要有可以重新计算的机会,所以,需要有个能让按钮被重新打开的功能,这时候,其实我们可以直接在两个输入资料的 InputField 的 End Edit 事件对每个按钮执行开启 Interactable 的动作,只是,如果计算器有很多个功能按钮、以及有很多个输入栏位的话,要一个一个慢慢设置,执行流程会太过分散了。

所以,我们可以想像成 MyComputer 除了负责计算之外,还提供一个状态重置的功能,这个状态重置的功能本身并不执行任何事情,只是呼叫执行状态重置事件,那麽,设置在这个事件上的目标功能,只要状态重置的功能被呼叫执行,它们都会被执行,所以,我们在 MyComputer Script 要再加上以下的程式码:

[SerializeField]
private UnityEvent onResetStatus;

public void ResetStatus(){

    this.onResetStatus.Invoke();
}

而在 Unity 编辑器中,我们就可以让 MyComputer 的状态重置事件(On Reset Status)栏位,设置开启四个功能按钮的 Intractable。
这里写图片描述
状态重置时,再次启用按钮。

如此,两个 InputField 的 End Edit 事件则是指定执行 MyComputer 的状态重置功能即可。

这里写图片描述
End Edit 事件指定执行 MyComputer 的 ResetStatus()。

虽然,影片中状态重置事件是让按钮重新启用,但到这边也可以任意变更状态重置事件所要执行的动作,例如,让计算结果文字变成问号,那麽,当每次输入栏位重新被输入完毕之后,不但被停用的按钮会重新启用,也会使结果文字变成问号,等按下功能按钮之后才显示正确的结果。

既然有了状态重置的功能,那麽,我们是不是可以只让当前计算出结果的按钮被停用,其它按钮是启用的状态呢?这样就不用一定要重新在输入栏位输入资料完毕才能启用按钮。在做这个功能之前,要先解释一下,每个事件栏位可以指定多个执行目标,而这些执行目标其实是有执行顺序的,它会在执行完第一个之后才会执行第二个,一个一个往下执行。

因此,我们要做这个功能就不需要去修改程式码,而能直接变更各计算功能的事件内容以及顺序,让每次执行计算之后先执行状态重置,然后才显示计算结果、停用当前的计算按钮、变更运算符号。

这里写图片描述
更改为先执行状态重置之后,才去执行其他行为。

到这裡,简单的计算器功能将告一段落,我们可以发现 MyComputer Script 的程式码相当的独立,只是提供传入资料的入口让传入的资料可以暂存下来,以及提供计算功能给外部执行,并将执行结果丢到事件中,至于,谁会传入资料、谁会执行计算功能、谁会回应事件的执行,通通不需要去管,因此,如果全部的事件栏位都未设置目标,当被要求执行计算时,它也能照常执行计算,而不会因为未设置目标而发生错误,而究竟事件目标应该是谁,基本上,MyComputer 也不需要知道,一切就在 Inspector 视窗上,依照实际需求去设置或变更即可。

状态重置的部分也是一样,MyComputer Script 只负责提供状态重置功能并执行状态重置事件,至于,谁要求状态重置、状态重置到底要做些什麽,都不用去管。

这样,就可以让程式撰写变得相当简洁,而实际使用上的弹性变化却非常的大,另外,因为一些需求功能的变更不需要依赖修改程式码达成,除了节省程式编译的时间之外,也可避免因为修改程式码的人为失误而发生错误,最重要的是,因为 MyComputer Script 根本就不需要知道谁要执行它的功能,以及它的事件最后会去执行什麽目标功能,所以,也使程式间的藕合度降到最低,如果将这种做法的 Script 移到其它专案中使用,也不用特别顾虑会与其它什麽程式有关联而发生许多缺漏的情形。

以下是 MyComputer.cs 的完整内容:

using UnityEngine;
using UnityEngine.Events;

public class MyComputer : MonoBehaviour {

    private float _value1;
    private float _value2;

    [SerializeField]
    private PassString onAdd;
    [SerializeField]
    private PassString onSubtract;
    [SerializeField]
    private PassString onMultiply;
    [SerializeField]
    private PassString onDivide;
    [SerializeField]
    private UnityEvent onResetStatus;

    public string value1{
        set{
            float.TryParse(value , out this._value1);
        }
    }

    public string value2{
        set{
            float.TryParse(value , out this._value2);
        }
    }

    public void Add(){

        this.onAdd.Invoke((this._value1 + this._value2).ToString());
    }

    public void Subtract(){

        this.onSubtract.Invoke((this._value1 - this._value2).ToString());
    }

    public void Multiply(){

        this.onMultiply.Invoke((this._value1 * this._value2).ToString());
    }

    public void Divide(){
        if(this._value2 == 0) return;
        this.onDivide.Invoke((this._value1 / this._value2).ToString());
    }

    public void ResetStatus(){

        this.onResetStatus.Invoke();
    }
}

###2. Sphere Control
第二个范例裡,设计了五个球体个别使用相同的 Componet,但却因为实际使用时设置的不同,直接反应出不同的行为,并且示范如何让 UnityEvent 除了传递参数之外,也能带回资料。

首先,在场景中建立好五个球体,这只是 Unity 预设的原生物件,预设上,Unity 会个别为它们赋予 Sphere Collider,以及预设的 Material,Material 的 Shader 则是 Unity 5 的 Standand Shader,这部分,我们都不需要做任何更改。
这里写图片描述
原生物件球体的 Componet。
这里写图片描述
在此,定义了几个球体的功能需求:

  • 球体可以被点击触发。
  • 球体可以弹跳起来。
  • 球体可以变色。

依据这几个需求,先在 Project 视窗分别建立它们个别的 C# Script,并个别命名为 SphereTouch、SphereJump、SphereDiscolor。

先来写 SphereTouch 的程式码,SphereTouch 只提供让使用者透过滑鼠点击球体时的事件反应而已,所以,SphereTouch 会有一个 UnityEvent 事件栏位,以及实作 Unity 内建的 OnMouseDown,只要 GameObject 本身有 Collider 的 Componet,当滑鼠在 GameObject 上按下按键时,就可以触发 OnMouseDown 执行其内容,而其内容裡,只是直接呼叫 UnityEvent 事件栏位执行而已,至于点击之后要反应什麽行为,那是别人的事。

using UnityEngine;
using UnityEngine.Events;

public class SphereTouch : MonoBehaviour {

    [SerializeField]
    private UnityEvent onTouch;

    public void DoTouch(){

        this.onTouch.Invoke();
    }

    void OnMouseDown(){

        this.DoTouch();
    }
}

看到这个程式码可能觉得奇怪,为什麽不在 OnMouseDown 裡面直接 Invoke 呢?其实,这只是要让 SphereTouch 多提供一个外部功能,让其他物件也可以传达点击讯息进来,例如,A 物件被滑鼠点击,然后它的 On Touch 事件栏位设置去执行 B、C、D 物件的 DoTouch 功能,那麽就可以一个物件被点击,四个物件同时做出反应。

再来是 SphereJump 的程式码,让球体跳动的行为可以有很多做法,例如使用 Unity 的动画系统去做,或者给予物体一个往上的推力,再让它因为重力而落下,不过,这边为了简化操作步骤,直接用程式码让它靠移动位置来达到跳动的效果,而这个跳动的动作,说穿了就是从原位置移动到一个指定高度的位置,再移动回来原来的位置,至于,要跳多高、移动速度多快,预先并不确定,所以,首先需要宣告两个可以在 Inspector 视窗设置的数值栏位,让我们可以在编辑器调整目标高度及跳动速度。

[SerializeField]
private float hight = 1;
[SerializeField]
private float speed = 5;

另外,在跳动的行为进行中,如果马上又被要求跳动,就会跳到一半又往上跳,这样的行为是有问题的,所以必须要设置一个状态纪录,当动作进行中,不接受再次的跳动要求,等到动作完毕之后才能再次接受并执行要求的行为。

private enum Status{

    None,
    Moving
}

private Status _status = Status.None;

因为我们这裡要做的跳动行为其实是两个移动行为的组合,所以要先写个可以提供物体本身从起点移动到终点的功能,两点间的移动,直接透过 Unity 内建的 Vector3.Lerp 就可以达成。

private IEnumerator Move(Vector3 source , Vector3 target){

    float t = 0;

    while(t < 1){

        transform.position = Vector3.Lerp(source , target , t);
        t += Time.deltaTime * this.speed;

        yield return null;
    }

    transform.position = target;
}

Vector3.Lerp 的 t 是介于 0 到 1 的值,我们可以把它当作是起点到终点的进度位置来看待,0 是起点,1 是终点。因为实际执行时每次刷新画面的时间都不一样,所以,我们不能让 t 随著时间的推移增加固定的值,而应该要为我们预计增加的值(即是速度)乘上 Time.deltaTime,于是,我们在这裡透过 yield return null 让 while 迴圈每经过一个 frame 才执行一次,当 t 超过 1 的时候,表示已经到达终点,即可结束迴圈。

要完成移动还有最后的步骤,就是 Vector3.Lerp 最后一次执行时,不可能刚刚好 t = 1,所以,最后还要校正一下位置到正确的终点位置,如此,移动行为才算是真正完成。

在这裡要特别注意的是,这个 Method 所回传的是 IEnumerator,代表它是做为 Coroutine 来使用,所以才可以在其内部使用 yield 来控制一些流程和时间,而要呼叫这个 Method 执行则需要使用 StartCoroutine 来执行。

接下来要做跳的动作,就是跳动开始时,变更状态为移动中,然后,取得起点和终点的位置,先执行起点移动到终点,执行完之后,再执行终点移动到起点的行为,等待动作完成之后,跳动就结束了,所以,就可以再将状态改回 None 的状态。

private IEnumerator DoJump(){

    this._status = Status.Moving;

    Vector3 source = transform.position;
    Vector3 target = source;
    target.y += this.hight;

    yield return StartCoroutine(this.Move(source , target));
    yield return StartCoroutine(this.Move(target , source));

    this._status = Status.None;
}

既然跳动行为已经写好,那麽就要提供一个让外部呼叫的功能,当被外部呼叫执行时,先判断有没有在跳动中,没有的话就执行跳动。

public void Jump(){

    if(this._status == Status.None) StartCoroutine(this.DoJump());
}

如此,SphereJump 就算完成了,它并没有使用到 UnityEvent 事件,主要负责被呼叫执行动作而已,当然,视需求还是可以另外帮它补上基本事件,例如,开始跳动、跳动中、跳动结束。不过,这个示范中并没有用到,所以在此省略。

以下为 SphereJump.cs 的内容:

using UnityEngine;
using System.Collections;

public class SphereJump : MonoBehaviour {

    private enum Status{

        None,
        Moving
    }

    [SerializeField]
    private float hight = 1;
    [SerializeField]
    private float speed = 5;

    private Status _status = Status.None;

    public void Jump(){

        if(this._status == Status.None) StartCoroutine(this.DoJump());
    }

    private IEnumerator Move(Vector3 source , Vector3 target){

        float t = 0;

        while(t < 1){

            transform.position = Vector3.Lerp(source , target , t);
            t += Time.deltaTime * this.speed;

            yield return null;
        }

        transform.position = target;
    }

    private IEnumerator DoJump(){

        this._status = Status.Moving;

        Vector3 source = transform.position;
        Vector3 target = source;
        target.y += this.hight;

        yield return StartCoroutine(this.Move(source , target));
        yield return StartCoroutine(this.Move(target , source));

        this._status = Status.None;
    }
}

在撰写 SphereDiscolor 之前,我们要先回到 PassEvents Script 档裡面,宣告一个能够用来传递颜色参数的 UnityEvent。

[System.Serializable]
public class PassColor : UnityEvent<Color>{}

在 SphereDiscolor 中,先宣告用来暂存 Material 以及 Material 的颜色的两个变数栏位,然后,也宣告一个用来设置球体预设颜色的栏位,在 Awake 中取得球体本身的 Material 暂存下来,并使用所设置的预设颜色改变球体的颜色。

private Material _material;
private Color _color;

[SerializeField]
private Color color = Color.white;

void Awake(){

    this._material = GetComponent<Renderer>().material;
    this.DefaultColor();
}

public void DefaultColor(){

    this._material.color = this.color;
    this._color = this.color;
}

同样的,改变为预设颜色的功能,也是独立做为可提供外部呼叫执行的功能。

然后,改变球体颜色的功能,我们分别宣告了直接改变为指定颜色的功能以及改变为随机颜色的功能,都是可提供给外部呼叫执行。

在此,也宣告了一个可以传递颜色值的 UnityEvent 事件栏位,当颜色被改变的时候,事件就会被执行,并且将所改变的颜色传递出去,所以,当球体颜色被改变时,可以让它引发其它行为,甚至是提供一个颜色去影响被引发的行为。

[SerializeField]
private PassColor onChangeColor;

void Awake(){

    this._material = GetComponent<Renderer>().material;
    this.DefaultColor();
}

public void DefaultColor(){

    this._material.color = this.color;
    this._color = this.color;
}

public void Discolor(Color color){

    this._material.color = color;
    this._color = color;
    this.onChangeColor.Invoke(color);
}

public void RandomColor(){

    this.Discolor(new Color(Random.value , Random.value , Random.value));
}

到这裡,这个范例的程式撰写部分暂告一段落,回到 Unity 画面,为每个球体加入这三个 Script 做为 Component。

在这裡可能会有疑问,为什麽要分成三个 Script,而不写在同一个 Script 中呢?因为,Unity 的游戏物件所具备的功能是 Component 导向的,具备哪些 Component 就能拥有什麽样的功能,拔除哪个 Component,该游戏物件就不具备哪个功能,所以,我们将功能分开来独立不同的 Script 来撰写,每个 Script 只要提供本身的功能就好了,不要去牵扯到其他的功能,那麽,当球体拥有 SphereTouch Component 时,他就可被点击,没有的话就无法被点击,当球体拥有 SphereJump 时,它就具备跳动的功能,这样,我们就能明确的为游戏物件抽换并改变其能力。

所以,当每个球体都具备变色功能时,变色功能有个预设颜色栏位会将球体于 Play Mode 开始时变更为其所指定的初始颜色。

接著,当每个球体都具有被触发功能时,我们就能为其指定当球体被触发时要引发什麽行为,如影片所示,我们可以为每个球体指定被点击触发时,去要求它的下一颗球跳起来,要求它的前一颗球随机改变颜色。

这里写图片描述
第 2 颗球设置被点击时,第三颗球跳起来,第一颗球随机改变颜色。

而最后一颗球被点击触发时,则是让前四颗球回到初始颜色。
这里写图片描述
第五颗球被点击时,前四颗球改变成初始颜色。

然后,我们也可以为第二颗球设置当它颜色被改变时,影响其他颗球的颜色。
这里写图片描述
第二颗球变色的时候,让第一颗球和第五颗球改变为随机的颜色。

在此,我们再次体验到,单纯写好 Script 提供的功能,不用在程式码中指定它人的行为,而能在编辑器中自由变更的好处以及功能弹性。

虽然,UnityEvent 可以直接在 Inspector 视窗指定一个固定值传递给某个 Component 的功能并执行它,也可以透过程式码使用 Invoke 呼叫执行并传递参数进去,但是,它却无法像我们平常呼叫执行一般的 Method 那样回传资料,似乎有点美中不足之感。

接下来,我们就来讨论如何也让 UnityEvent 带回资料,其实,这主要就是利用参考型别物件在参数间传送并不是传送实值的原理,来达到带回资料的目的。也就是说,我们可以透过实例化一个参考型别物件,传入 UnityEvent 的参数中,当这个物件内含的资料在 UnityEvent 所执行的功能中有任何变更后,在呼叫执行 UnityEvent 事件的这一方也可以从原本的物件获得改变后的资料。

只是,为了带回不同的型别的资料而宣告许多不同的 Class,似乎太麻烦了,因此,我们最好是可以製作一个通用的 Class,专门用来做为传递资料的持有者物件。所以,可以建立了一个名为 PassHolder 的 C# Script,专门用来做这件事。

public class PassHolder {

    public object value{set; private get;}

    public T GetValue<T>(){

        if(this.value == null) return default(T);

        return (T)this.value;
    }
}

因为,所有的型别都是直接或间接继承自 Object(这裡所指的并不是 Unity 的 Object),所以,宣告一个 Property 统一接收任何型别的物件,然后,利用泛型方法的宣告方式,来取出所储存的资料,这裡只是很简单的判断有没有资料,如果没有资料则传回预计要取得的型别预设值。如此,这个 class 的物件就能通用存取任何型别的资料。

有了这样的 class,那麽就可以拿 SphereDiscolor 来实验看看;先来为 SphereDiscolor 加入交换颜色的功能。当然,要宣告能够传递 PassHolder 的 UnityEvent 事件栏位之前,还是要先回到 PassEvents 的 Script 档中,加入宣告可传递颜色以及 PassHolder 两个参数的型别。

[System.Serializable]
public class PassColorReturn : UnityEvent<Color , PassHolder>{}

这个功能要做的是,当它被呼叫执行时会透过交换颜色事件把自己的颜色传送出去,并透过 PassHolder 带回对方的颜色来改变自己的颜色。

而我们目前的范例裡,能被改变颜色的就属 SphereDiscolor 了,所以,再帮它加入另一个改变颜色的功能是除了接受目标颜色之外,还要能接收 PassHolder 物件,因此,除了拿接收到的颜色为自己变色之外,也要把原本的颜色写入到 PassHolder 中,那么呼叫执行这个变色功能的彼方,也就能收到所要带回去的颜色值。

[SerializeField]
private PassColorReturn onSwapColor;

public void SwapColor(){

    PassHolder holder = new PassHolder();
    this.onSwapColor.Invoke(this._color , holder);
    this.Discolor(holder.GetValue<Color>());
}

public void Discolor(Color color , PassHolder holder){

    holder.value = this._color;
    this.Discolor(color);
}

完成之后,我们在 Unity 编辑器的 Inspector 视窗中,就可以直接在 On Swap Color 的事件栏位指定要跟哪颗球交换颜色。
这里写图片描述
当第四颗球被点击时,使第五颗球跳起来、第三颗球改变颜色、要求自己执行交换颜色并指明与第一颗球交换颜色。

如此,几支程式、简短的程式码,只是定义它们本身的功能,以及什麽时候呼叫该执行的事件,而不需要特别指定所影响的型别及功能是什麽,而能在 Inspector 视窗中,很弹性的为具备同样 Component 的 GameObject 配置出完全不同的行为。也不会让程式中因为型别不对或参数数量不符合而出现错误,使得程式执行及设计上变得更弹性、更稳定,也让程式码内容变得更简洁,逻辑更清晰。在维护上以及流程调整上也会变得更视觉化、更清楚一些。

过去曾经发佈「Unity:使用 UGUI 的 ScrollRect 製作虚拟摇杆」的文章与影片,其中为虚拟摇杆传递操作行为的事件就是 UnityEngine.Events 的应用,善用这些做法,所写的程式复用性以及扩充性将会大大提高。

好了,有关 UnityEngine.Events 的说明及示范解说,到此结束,如果,你喜欢这个文章或所展示的影片,请帮忙介绍给你的朋友,也别忘了订阅影片频道以及来粉丝专页按个讚,谢谢!

UnityEvent官方文档:

http://docs.unity3d.com/ScriptReference/Events.UnityEvent.html

目前版本 Unity 5.2.1f1

2012-02-01 09:06:56 wangxfvc 阅读数 14349
  • Unity 值得看的500+ 技术内容列表

    Unity3D是由Unity Technologies开发的一个让玩家轻松创建诸如三维视频游戏、建筑可视化、实时三维动画等类型互动内容的多平台的综合型游戏开发工具,是一个全面整合的专业游戏引擎。

Unity3D 脚本参考
核心提示:一、脚本概览这是一个关于Unity 内部脚本如何工作的简单概览。Unity 内
部的脚本,是通过附加自定义脚本对象到游戏物体组成的。在脚本对象内部不同志的函数被
特定的事件调用。最常用的列在下面:Update:这个函数在渲染一帧之前被调用,这里是大
部分游戏行为代码被执行的地方,除了物理代码。FixedUpd...
一、脚本概览
这是一个关于Unity 内部脚本如何工作的简单概览。
Unity 内部的脚本,是通过附加自定义脚本对象到游戏物体组成的。在脚本对象内部不同志
的函数被特定的事件调用。最常用的列在下面:
Update:
这个函数在渲染一帧之前被调用,这里是大部分游戏行为代码被执行的地方,除了物理代码。
FixedUpdate:
这个函数在每个物理时间步被调用一次,这是处理基于物理游戏的地方。
在任何函数之外的代码:
在任何函数之外的代码在物体被加载的时候运行,这个可以用来初始化脚本状态。
注意:文档的这个部份假设你是用Javascript,参考用C#编写获取如何使用C#和Boo 编写
脚本的信息。
你也能定义事件句柄,它们的名称都以On 开始,(例如OnCollisionEnter),为了查看完整的
预定义事件的列表,参考MonoBehaviour 文档。
概览:常用操作
大多数游戏物体的操作是通过游戏物体的Transform 或Rigidbody 来做的,在行为脚本内部
它们可以分别通过transform 和rigidbody 访问,因此如果你想绕着Y 轴每帧旋转5 度,你可
以如下写:
function Update(){
transform.Rotate(0,5,0);
}
如果你想向前移动一个物体,你应该如下写:
function Update(){
transform.Translate(0,0,2);
}
概览:跟踪时间
Time 类包含了一个非常重要的类变量,称为deltaTime,这个变量包含从上一次调用Update
或FixedUpdate(根据你是在Update 函数还是在FixedUpdate 函数中)到现在的时间量。
所以对于上面的例子,修改它使这个物体以一个恒定的速度旋转而不依赖于帧率:
function Update(){
transform.Rotate(0,5*Time.deltaTime,0);
}
移动物体:
function Update(){
transform. Translate (0, ,0,2*Time.deltaTime);
}
如果你加或是减一个每帧改变的值, 你应该将它与Time.deltaTime 相乘。当你乘以
Time.deltaTime 时,你实际的表达:我想以10 米/秒移动这个物体不是10 米/帧。这不仅仅
是因为你的游戏将独立于帧而运行,同时也是因为运动的单位容易理解。( 米/秒)
另一个例子,如果你想随着时间增加光照的范围。下面的表达式,以2 单位/秒改变半
径。
function Update (){
light.range += 2.0 * Time.deltaTime;
}
当通过力处理刚体的时候,你通常不必用Time.deltaTime,因为引擎已经为你考虑到了这一
点。
概览:访问其他组件
组件被附加到游戏物体,附加Renderer 到游戏物体使它在场景中渲染,附加一个Camera 使
它变为相机物体,所有的脚本都是组件,因为它们能被附加到游戏物体。
最常用的组件可以作为简单成员变量访问:
Component 可如下访问
Transform transform
Rigidbody rigidbody
Renderer renderer
Camera camera (only on camera objects)
Light light (only on light objects)
Animation animation
Collider collider
…等等。
对于完整的预定义成员变量的列表。查看Component,Behaviour 和MonnoBehaviour 类文档。
如果游戏物体没有你想取的相同类型的组件,上面的变量将被设置为null。
任何附加到一个游戏物体的组件或脚本都可以通过GetComponent 访问。
transform.Translate(0,3,0);
//等同于
GetComponent(Transform).Translate(0, 1, 0);
注意transfom 和Transform 之间大小写的区别,前者是变量(小写),后者是类或脚本名称
(大写)。大小写不同使你能够从类和脚本名中区分变量。
应用我们所学,你可以使用GetComponent 找到任何附加在同一游戏物体上的脚本和组件,
请注意要使用下面的例子能够工作,你需要有一个名为OtherScript 的脚本,其中包含一个
DoSomething 函数。OtherScript 脚本必须与下面的脚本附加到相同的物体上。
//这个在同一游戏物体桑找到名为OtherScript 的脚本
//并调用它上加的DoSomething
function Update(){
otherScript = GetComponent(OtherScript);
otherScript.DoSomething();
}
概览:访问其它游戏物体
大多数高级的代码不仅需要操作一个物体,Unity 脚本接口有各种方法来找到并访问其他游
戏物体和组件。在下面,我们假定有个一名为OtherScript,js 的脚本附加到场景的游戏物体
上。
var foo = 5;
function DoSomething ( param : String) {
print(param + " with foo: " + foo);
}
1.通过检视面板赋值引用
你可以通过检视面板赋值变量到任何物体
//变换拖动到target 的物体
var target : Transform;
function Update ()
{
target.Translate(0, 1, 0);
}
你也可以在检视面板中公开到其他物体的引用,下面你可以拖动一个包含的游戏物体到检视
面板中的target 槽。
//设置在检视面板中赋值的target 变量上的foo,调用DoSomething
var target : OtherScript;
function Update ()
{
//设置target 物体的foo 变量
target.foo = 2;
// 调用target 上的DoSomething
target.DoSomething("Hello");
}
2.通过物体层次定位
对于一个已经存在的物体,可以通过游戏物体的Transform 组件来找到子和父物体;
//找到脚本所附加的
//游戏物体的子“Hand”
transform.Find("Hand").Translate(0, 1, 0);
一旦在层次视图中找到这个变换,你可以使用GetComponent 来获取其他脚本,
//找到名为“Hand”的子
//在附加到它上面的OtherScript 中,设置foo 为2;
transform.Find("Hand").Translate(0, 1, 0);
//找到名为“Hand”的子
//然后应用一个力到附加在hand 上的刚体
transform.Find("Hand").GetComponent(OtherScript).DoSomething("Hello");
// 找到名为“Hand”的了
// 然后应用一个力到附加在hand 上的刚体
transform.Find("Hand").rigidbody.AddForce(0, 10, 0);
你可以循环所有的子,
//变换的所有子向上移动10 个单位
for (var child : Transform in transform)
{
child.Translate(0, 1, 0);
}
参考Transform 类文档获取更多信息。
3.根据名称或标签定位.
你可以使用GameObject.FindWithTag 和GameObject.FindGameObjectsWithTag 搜索具有特定
标签的游戏物体,使用GameObject.Find 根据名称查找物体。
function Start ()
{
// 按照名称
var go = GameObject.Find("SomeGuy");
go.transform.Translate(0, 1, 0);
// 按照标签
var player = GameObject.FindWithTag("Player");
player.transform.Translate(0, 1, 0);
}
你可以在结果上使用GetComponent,在找到的游戏物体上得到任何脚本或组件。
function Start ()
{
// 按名称
var go = GameObject.Find("SomeGuy");
go.GetComponent(OtherScript).DoSomething();
// 按标签
var player = GameObject.FindWithTag("Player");
player.GetComponent(OtherScript).DoSomething();
}
一些特殊的物体有快捷方式,如主相机使用Camera.main。
4.作为参数传递
一些事件消息在事件包含详细信息。例如,触发器事件传递碰撞物体的Collider 组件到处理
函数。
OnTriggerStay 给我们一个到碰撞器的引用。从这个碰撞器我们可以获取附加到其上的刚体。
function OnTriggerStay( other : Collider ) {
// 如果另一个碰撞器也有一个刚体
// 应用一个力到它上面
if (other.rigidbody) {
other.rigidbody.AddForce(0, 2, 0);
}
}
或者我们可以通过碰撞器获取附加在同一个物体上的任何组件。
function OnTriggerStay( other : Collider ) {
// 如果另一个碰撞器附加了OtherScript
// 调用它上面的DoSomething
// 大多数时候碰撞器不会附加脚本
// 所以我们需要首先检查以避免null 引用异常
if (other.GetComponent(OtherScript)) {
other.GetComponent(OtherScript).DoSomething();
}
}
注意通过上述例子中的other 变量,你可以访问碰撞物体中的任何组件。
5.一种类型的所有脚本
使用Object.FindObjectsOfType 找到所有具有相同类或脚本名称的物体, 或者使用
Object.FindObjectOfType.找到这个类型的第一个物体。
function Start ()
{
// 找到场景中附加了OtherScript 的任意一个游戏物体
var other : OtherScript = FindObjectOfType(OtherScript);
other.DoSomething();
}
概览:向量
Unity 使用Vector3 类同一表示全体3D 向量,3D 向量的不同组件可以通过想x,y 和z 成员
变量访问。
var aPosition : Vector3;
aPosition.x = 1;
aPosition.y = 1;
aPosition.z = 1;
你也能够使用Vector3 构造函数来同时初始化所有组件。
var aPosition = Vector3(1, 1, 1);
Vector3 也定义了一些常用的变量值。
var direction = Vector3.up; // 与Vector3(0, 1, 0);相同
单个向量上的操作可以使用下面的方式访问:
someVector.Normalize();
使用多个向量的操作可以使用Vector3 类的数;
theDistance = Vector3.Distance(oneVector, otherVector);
(注意你必须在函数名之前写Vector3 来告诉JavaScript 在哪里找到这个函数,这适用于所
有类函数)
你也可以使用普通数学操作来操纵向量。
combined = vector1 + vector2;
查看Vector3 类文档获取完整操纵和可用属性的列表。
概览:成员变量& 全局变量变量
定义在任何函数之外的变量是一个成员变量。在Unity 中这个变量可以通过检视面板来访问,
任何保存在成员变量中的值也可以自动随工程保存。
var memberVariable = 0.0;
上面的变量将在检视面板中显示为名为"Member Variable"的数值属性。
如果你设置变量的类型为一个组件类型(例如Transform, Rigidbody, Collider,任何脚本名称,
等等)然后你可以在检视面板中通过拖动一个游戏物体来设置它们。
var enemy : Transform;
function Update()
{
if ( Vector3.Distance( enemy.position, transform.position ) < 10 );
print("I sense the enemy is near!");
}
}
你也可以创建私有成员变量。私有成员变量可以用来存储那些在该脚本之外不可见的状态。
私有成员变量不会被保存到磁盘并且在检视面板中不能编辑。当它被设置为调试模式时,它
们在检视面板中可见。这允许你就像一个实时更新的调试器一样使用私有变量。
private var lastCollider : Collider;
function OnCollisionEnter( collisionInfo : Collision ) {
lastCollider = collisionInfo.other;
}
全局变量
你也可以使用static 关键字创建全局变量
这创造了一个全局变量,名为someGlobal
// 'TheScriptName.js'中的一个静态变量
static var someGlobal = 5;
// 你可以在脚本内部像普通变量一样访问它
print(someGlobal);
someGlobal = 1;
为了从另一个脚本访问它,你需要使用这个脚本的名称加上一个点和全局变量名。
print(TheScriptName.someGlobal);
TheScriptName.someGlobal = 10;
概览:实例化
实例化,复制一个物体。包含所有附加的脚本和整个层次。它以你期望的方式保持引用。到
外部物体引用的克隆层次将保持完好,在克隆层次上到物体的引用映射到克隆物体。
实例化是难以置信的快和非常有用的。因为最大化地使用它是必要的。
例如, 这里是一个小的脚本,当附加到一个带有碰撞器的刚体上时将销毁它自己并实例化
一个爆炸物体。
var explosion : Transform;
// 当碰撞发生时销毁我们自己
// 并生成给一个爆炸预设
function OnCollisionEnter (){
Destroy (gameObject);
var theClonedExplosion : Transform;
theClonedExplosion = Instantiate(explosion, transform.position, transform.rotation);
}
实例化通常与预设一起使用
概览:Coroutines & Yield
在编写游戏代码的时候,常常需要处理一系列事件。这可能导致像下面的代码。
private var state = 0;
function Update()
{
if (state == 0) {
// 做步骤0
state = 1;
return;
}
if (state == 1) {
// 做步骤1
state = 2;
return;
}
// …
}
更方便的是使用yield 语句。yield 语句是一个特殊类型的返回,这个确保在下次调用时该函
数继续从该yield 语句之后执行。
while(true) {
// 做步骤0
yield; //等待一帧
// 做步骤1
yield; //等待一帧
// ...
}
你也可以传递特定值给yield 语句来延迟Update 函数的执行,直到一个特定的事件发生。
// 做一些事情
yield WaitForSeconds(5.0); //等待5 秒
//做更多事情…
可以叠加和连接coroutines。
这个例子执行Do,在调用之后立即继续。
Do ();
print ("This is printed immediately");
function Do ()
{
print("Do now");
yield WaitForSeconds (2);
print("Do 2 seconds later");
}
这个例子将执行Do 并等待直到它完成,才继续执行自己。
//链接coroutine
yield StartCoroutine("Do");
print("Also after 2 seconds");
print ("This is after the Do coroutine has finished execution");
function Do ()
{
print("Do now");
yield WaitForSeconds (2);
print("Do 2 seconds later");
}
任何事件处理句柄都可以是一个coroutine
注意你不能在Update 或FixedUpdate 内使用yield,但是你可以使用StartCoroutine 来开始一
个函数。
参考YieldInstruction, WaitForSeconds, WaitForFixedUpdate, Coroutine and
MonoBehaviour.StartCoroutine 获取更多使用yield 的信息。
概览:用C#编写脚本
除了语法,使用C#或者Boo 编写脚本还有一些不同。最需要注意的是:
1.从MonoBehaviour 继承
所有的行为脚本必须从MonoBehaviour 继承(直接或间接)。在Javascript 中这自动完成,但
是必须在C#或Boo 脚本中显示申明。如果你在Unity 内部使用Asset -> Create -> C Sharp/Boo
Script 菜单创建脚本,创建模板已经包含了必需的定义。
public class NewBehaviourScript : MonoBehaviour {...} // C#
class NewBehaviourScript (MonoBehaviour): ... # Boo
2.使用Awake 或Start 函数来初始化
Javascript 中放置在函数之外的代码,在C#或Boo 中要放置在Awake 或Start 中。
Awake 和Start 的不同是Awake 在场景被加载时候运行,而Start 在第一次调用Update 或
FixedUpdate 函数之前被调用,所有Awake 函数在任何Start 函数调用之前被调用。
3.类名必须与文件名相同
Javascript 中,类名被隐式地设置为脚本的文件名(不包含文件扩展名)。在c#和Boo 中必
须手工做。
4.在C#中Coroutines 有不同语法。
Coroutines 必有一个IEnumerator 返回类型,并且yield 使用yield return… 而不是yield…
using System.Collections;
using UnityEngine;
public class NewBehaviourScript : MonoBehaviour {
// C# coroutine
IEnumerator SomeCoroutine ()
{
// 等一帧
yield return 0;
//等两秒
yield return new WaitForSeconds (2);
}
}
5.不要使用命名空间
目前Unity 还不支持将代码放置在一个命名空间中,这个需要将会出在未来的版本中。
6.只有序列化的成员变量会显示在检视面板中
私有和保护成员变量只在专家模式中显示,属性不被序列化或显示在检视面板中。
7.避免使用构造函数
不要在构造函数中初始化任何变量,使用Awake 或Start 实现这个目的。即使是在编辑模式
中Unity 也自动调用构造函数,这通常发生在一个脚本被编译之后,因为需要调用构造函数
来取向一个脚本的默认值。构造函数不仅会在无法预料的时刻被调用,它也会为预设或未激
活的游戏物体调用。
单件模式使用构造函数可能会导致严重的后果,带来类似随机null 引用异常。
因此如果你想实现,如,一个单件模式,不要使用构造函数,而是使用Awake。其实上,没
有理由一定要在继续自MononBehaviour 类的构造函数中写任何代码。
概览:最重要的类
Javascript 中可访问的全局函数或C#中的基类
移动/旋转物体
动画系统
刚体
FPS 或第二人称角色控制器
概览:性能优化
1.使用静态类型
在使用Javascript 时最重要的优化是使用静态类型而不是动态类型,Unity 使用一种叫做类型
推理的技术来自自动转换Javascript 为静态类型编码而不需要你做任何工作。
var foo=5;
在上面的例子里foo 会自动被推断为一个整型值。因此,Unity 可能使用大量的编译时间来
优化。而不使用耗时的动态名称变量查找等。这就是为什么Unity 比其他在JavaScript 的实
现平均快20 倍的原因之一。
唯一的问题是,有时并非一切都可以做类型推断。Unity 将会为这些变量重新使用动态类型。
通过回到动态类型,编写JavaScript 代码很简单。但是这也使得代码运行速度较慢。
让我们看一些例子:
function Start ()
{
var foo = GetComponent(MyScript);
foo.DoSomething();
}
这里foo 将是动态类型,因此调用DoSomething 函数将使用较长时间,因为foo 的类型是未
知的,它必须找出它是否支持DoSomething 函数,如果支持,调用它。
function Start ()
{
var foo : MyScript = GetComponent(MyScript);
foo.DoSomething();
}
这里我们强制foo 为指定类型,你将获得更好的性能。
2.使用#pragma strict
当然现在问题是,你通常没有意识到你在使用动态类型。#pragma strict 解决了这个!简单的
在脚本顶部添加#pragma strict。然后,unity 将在脚本中禁用动态类型,强制使用静态类型,
如果一个类型未知。Unity 将报告编译错误。那么在这种情况下foo 将在编译时产生一个错
误:
#pragma strict
function Start ()
{
var foo = GetComponent(MyScript);
foo.DoSomething();
}
3.缓存组件查找
另一个优化是组件缓存。不幸的是该优化需要一点编码,并且不一定是值得的,但是如
果你的脚本是真的用了很长时间了,你需要把最后一点表现出来,这是一个很好的优化。
当你访问一个组件通过GetComponent 或访问变量,Unity 会通过游戏对象找到正确的组件。
这一次可以很容易地通过缓存保存在一个私有变量里引用该组件。
简单地把这个:
function Update ()
{
transform.Translate(0, 0, 5);
}
变成:
private var myTransform : Transform;
function Awake ()
{
myTransform = transform;
}
function Update ()
{
myTransform.Translate(0, 0, 5);
}
后者的代码将运行快得多,因为Unity 没有找到变换在每一帧游戏组件中的对象。这同样适
用于脚本组件,在你使用GetComponent 代替变换或者其它的东西。
4.使用内置数组
内置数组的速度非常快,所以请使用它们。
而整列或者数组类更容易使用,因为你可以很容易地添加元素,他们几乎没有相同的速度。
内置数组有一个固定的尺寸,但大多数时候你事先知道了最大的大小在可以只填写了以后。
关于内置数组最好的事情是,他们直接嵌入在一个结构紧凑的缓冲区的数据类型没有任何额
外的类型信息或其他开销。因此,遍历是非常容易的,作为一切缓存在内存中的线性关系。
private var positions : Vector3[];
function Awake ()
{
positions = new Vector3[100];
for (var i=0;i<100;i++)
positions[i] = Vector3.zero;
}
5.如果你不需要就不要调用函数
最简单的和所有优化最好的是少工作量的执行。例如,当一个敌人很远最完美的时间就是敌
人入睡时可以接受。直到玩家靠近时什么都没有做。这是种缓慢的处理方式的情况:
function Update ()
{
// 早期进行如果玩家实在是太遥远。
if (Vector3.Distance(transform.position, target.position) > 100)
return;
perform real work work...
}
这不是一个好主意,因为Unity 必须调用更新功能,而你正在执行工作的每一个帧。一个比
较好的解决办法是禁用行为直到玩家靠近。有3 种方法来做到这一点:
1.使用OnBecameVisible 和OnBecameInvisible。这些回调都是绑到渲染系统的。只要任何相
机可以看到物体,OnBecameVisible 将被调用,当没有相机看到任何一个,OnBecameInvisible
将被调用。这种方法在很多情况下非常有用,但通常在AI 中并不是特别有用,因为只要你
把相机离开他们敌人将不
可用。
function OnBecameVisible () {
enabled = true;
}
function OnBecameInvisible ()
{
enabled = false;
}
2.使用触发器。一个简单的球形触发器会工作的非常好。一旦你离开这个影响球你将得到
OnTriggerEnter/Exit 调用。
function OnTriggerEnter (c : Collider)
{
if (c.CompareTag("Player"))
enabled = true;
}
function OnTriggerExit (c : Collider)
{
if (c.CompareTag("Player"))
enabled = false;
}
3.使用协同程序。Update 调用的问题是它们每帧中都发生。很可能会只需要每5 秒检检查一
次到玩家的距离。这应该会节省大量的处理周期。
概览:脚本编译(高级)
Unity 编译所有的脚本为.NET dll 文件,.dll 将在运行时编译执行。
这允许脚本以惊人的速度执行。这比传统的javascript 快约20 倍。比原始的C++代码慢大约
50%。在保存的时候,Unity 将花费一点时间来编译所有脚本,如果Unity 还在编译。你可
以在Unity 主窗口的右下角看到一个小的旋转进度图标。
脚本编译在4 个步骤中执行:
1.所有在"Standard Assets", "Pro Standard Assets" 或"Plugins"的脚本被首先编译。
在这些文件夹之内的脚本不能直接访问这些文件夹之外脚本。
不能直接引用或它的变量,但是可以使用GameObject.SentMessage 与它们通信。
2.所有在"Standard Assets/Editor", "Pro Standard Assets/Editor" 或"Plugins/Editor"的脚本被首
先编译。
如果你想使用UnityEditor 命名空间你必须放置你的脚本在这些文件夹中,例如添加菜单项
或自定义的向导,你都需要放置脚本到这些文件夹。
这些脚本可以访问前一组中的脚本。
3.然后所有在"Editor"中的脚本被编译。
如果你想使用UnityEditor 命名空间你必须放置你的脚本在这些文件夹中。例如添加菜单单
项或自定义的向导,你都需要放置脚本到这些文件夹。
这些脚本可以访问所有前面组中的脚本,然而它们不能访问后面组中的脚本。
这可能会是一个问题,当编写编辑器代码编辑那些在后面组中的脚本时。有两个解决方法:
1、移动其他脚本到"Plugins"文件夹2、利用JavaScript 的动态类型,在javascript 中你不需
要知道类的类型。在使用GetComponent 时你可以使用字符串而不是类型。你也可以使用
SendMessage,它使用一个字符串。
4.所有其他的脚本被最后编译
所有那些没有在上面文件夹中的脚本被最后编译。
所有在这里编译的脚本可以访问第一个组中的所有脚本("Standard Assets","Pro
Standard Assets" or "Plugins")。这允许你让不同的脚本语言互操作。例如,如果你想创建一
个JavaScript。它使用一个C#脚本;放置C#脚本到"Standard Assets"文件夹并且JavaScript 放
置在"Standard Assets"文件夹之外。现在JavaScript 可以直接引用c#脚本。
放置在第一个组中的脚本,将需要较长的编译时间,因为当他们被编译后,第三组需要被重
新编译。因此如果你想减少编译时间,移动那些不常改变的到第一组。经常改变的到第四
组。
二、运行时类
AnimationCurve

动画曲线,在给定的时间添加关键帧并确定曲线。
变量
◆ var keys : Keyframe[]
描述:定义在动画曲线中的所有键。这让你从数组中清理,添加或移除键。
如果键没有按照时间顺序,它们会在赋值的时候自动排序。
◆ var length : int
描述:曲线中键的数量(只读)。
◆ var preWrapMode : WrapMode
描述:第一帧之前动画的行为。
◆ var this[index : int] : Keyframe
描述:取向索引为index 的键(只读)。
构造函数
◆ static function AnimationCurve(params keys : Keyframe[]) : AnimationCurve
描述:从任意数量的关键帧创建一个动画曲线。
该函数从可变数量的Keyframe 参数创建一个曲线,如果你想从一个关键帧数组中创建一个
曲线,创建一个空的曲线并指定keys 属性。
//一个慢退慢出的动画曲线(切线都是平的)。
var curve = new AnimationCurve(Keyframe(0, 0), Keyframe(1, 1);
function Update ()
{
transform.position.x = Time.time;
transform.position.y = curve.Evaluate(Time.time);
}
◆ static function AnimationCurve () : AnimationCurve
描述:创建一个空的动画曲线
函数
◆ function AddKey (time : float, value : float) : int
描述:添加一个新的键到曲线。
平滑切线将被自动为该键的计算,返回该键的索引,如果因为在同一时间上已经有另一个关
键帧而不能添加键,将返回-1。
◆ function AddKey (key : Keyframe) : int
描述:添加一个新的键到曲线。
返回该键的索引,如果因为在同一时间上已经有另一个关键帧而不能添加键,将返回-1。
◆ function Evaluate (time : float) : float
描述:该动画曲线在time 的值。
◆ function MoveKey (index : int, key : Keyframe) : int
描述:移除index 处的关键帧并插入键。
如果一个关键帧已经存在于key-time,老的关键帧位置时间key[index].time/将被用来替换,
这对于在一个曲线编辑器中拖动关键帧是一个理想的行为,移动它后返回关键帧的索引。
◆ function RemoveKey (index : int) : void
描述:移除一个键
◆ function SmoothTangents (index : int, weight : float) : void
描述:平滑位于index 处的关键帧的进出切线。
权值为0 时平均切线。
类方法
◆ static function EaseInOut (timeStart : float, valueStart : float, timeEnd : float, valueEnd :
float) : AnimationCurve
描述:一个渐进渐出的曲线,开始于timeStart,valueStart 并结束于timeEnd, valueEnd.
◆ static function Linear (timeStart : float, valueStart : float, timeEnd : float, valueEnd : float) :
AnimationCurve
描述:一个直线,开始于timeStart,valueStart 并结束于timeEnd, valueEnd.
AnimationEvent

AnimationEvent 类似于SendMessage 让你调用一个脚本函数,这个脚本是动画播放的一部分。
变量
◆ var animationState : AnimationState
描述:引发这个事件的动画状态。
当这个方法在动画事件回调之外被调用用时返回null。
◆ var date:string
描述:存储在动画剪辑中的字符串数据并将被发送到动画事件。
◆ var functionName : string
描述:被调用的函数的名称
这与调用gameObject.SendMessage(animationEvent.functionName,animationEvent)相同;
◆ var messageOptions :SendMessageOptions
描述:如果选项被设置为SendMessageOptions.RequireReceiver(缺省),当消息没有被任何
组件接收时将打印一个错误消息。
◆ var time:float
描述:该事件被引发的时间。
构造函数
◆ static function AnimationEvent () : AnimationEvent
描述:创建一个新的动画事件
AnimationState

AnimationState 完全控制动画混合。
在大多数情况下Animation 接口就足够了,并且更容易使用。如果你需要完全控制动画播放
过程中的混合时,使用AnimationState。
当动画播放时,AnimationState 允许你修改速度,权值。时间和层。也可以设置动画合成和
wrapMode
动画
变量
◆ var blendMode : AnimationBlendMode
描述:使用哪个混合模式?
// 设置leanLeft 动画为附加混合
animation["leanLeft"].blendMode = AnimationBlendMode.Additive;
◆ var clip :AnimationClip
描述:该动画状态播放的剪辑。
// 打印动画剪辑的帧频到控制台
print(animation[“walk”]clio.frameRate);
◆ var enabled : bool
描述:启用/禁用动画
对于需要考虑任何影响的动画,权值需要设置成为一个大于零的值。如果动画被禁用,时间
将暂停直到动画再次启用。
// 启用walk 循环
animation["Walk"].enabled = true;
animation["Walk"].weight = 1.0;
◆ var layer : int
描述:动画的层。在计算混合权值时,位于较高层的动画将首先获得它们的权值。
只有较高层的动画没有使用完全全部权值时,较低层的动画才能接收混合权值。
// 放置walk 和run 动画在层1
animation["Walk"].layer = 1;
animation["Run"].layer = 1;
◆ var length : float
描述:动画剪辑的长度,以秒计。
// 打印Walk 动画的长度
print (animation["Walk"].length);
◆ var name :string
描述:动画的名称。
◆ var normalizedSpeed : float
描述:归一化播放速度。
这最常用于混合两个动画时同步播放速度。在多数情况下使用animation.SyncLayer 是更容
易也更好
// 同步run 和walk 速度
animation["Run"].normalizedSpeed = animation["Walk"].speed;
◆ var normalizedTime : float
描述:动画的当前归一化时间。
1 为动画的末端。0.5 为动画的中部。
// 快进到动画的中部
animation["Walk"].normalizedTime = 0.5;
◆ var speed : float
描述:动画的播放速度。1 为正常播放速度。
负的播放速度将回放动画。
// 向后走
animation["Walk"].speed = -1.0;
// 以双倍速度行走
animation["Walk"].speed = 2;
◆ var time :float
描述:动画的当前时间
如果时间大于长度它将按照wrapMode 回绕。该值可以大于动画的长度。看这种情况下播放
模式将在采样前重映射时间。这个值从0 到无穷。
// 回退walk 动画
animation["Walk"].time = 0.0;
◆ var weight : float
描述:动画的权值
// 设置walk 动画的混合权值为0.5
animation["Walk"].weight = 0.5;
◆ var wrapMode : WrapMode
描述:动画的回绕模式
默认的wrapMode 被初始化为在Animation 组件中设置的回绕模式值。
// 设置walk 动画回绕模式为循环
animation["Walk"].wrapMode = WrapMode.Loop;
函数
◆ function AddMixingTransform (mix : Transform, recursive : bool = true) : void
描述:添加应该被动画的变换。这允许你缩减需要创建的动画数量。
例如你可能有一个挥手的动画。你可能想在一个空闲角色或行走的角色上播放挥手动画。那
么你需要为空闲和行走分别创建挥手动画。运用合成挥手动画,它将由肩膀完全控制。但是
下半身不会受它的影响,继续播放空闲或行走动画。因此你只需要一个挥手动画。
如果recursive 为真,所有mix 变换的子也都将被动画。如果你不调用AddMixingTransform,
所有动画曲线将被使用。
// 使用路径添加混合
var shoulder : Transform;
animation["wave_hand"].AddMixingTransform(shoulder);
function Start ()
{
//使用路径添加混合变换
var mixTransform = transform.Find("root/upper_body/left_shoulder");
animation["wave_hand"].AddMixingTransform(mixTransform);
}
Application

访问应用程序的运行时数据。
这个类包含静态的方法来查找相关的信息并控制运行时数据。
类变量
◆ static var absoluteURL : string
描述:到web 播放器数据文件夹的绝对路径(只读)。
Application.absoluteURL 和Application.srcValue 允许你检测unityWeb 数据文件是否被移动或
链接接到其他位置。你也许想保护这两者来防止盗用数据文件的行为。
// 检测你的数据文件是否被移动到其他的服务器
// 或是被链接到其他地方
function Start ()
{
var isPirated = false;
if (Application.platform == RuntimePlatform.WindowsWebPlayer ||Application.platform ==
RuntimePlatform.OSXWebPlayer)
{
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");
}
}
◆ static var dataPath : string
描述:包含游戏数据文件夹的路径(只读)。
这个值依赖于运行的平台:
Unity 编辑器: <工程文件夹的路径>/Assets
Mac 播放器: <到播发器应用的路径>/Contents
Win 播放器: < 包含可执行播发器的文件夹的路径>\Data
Dasboard 窗口: < dashboard widget bundle 的路径>
Web 播放器: 到播放器数据文件夹的绝对路径(没有实际的数据文件名称)
// 打印到数据文件夹的路径
Print(Application.dataPath);
◆ static var isEditor : bool
描述:是在Unity 编辑器内运行?(只读)
如果游戏从Unity 编辑器中运行,返回真;如果从其他部署目标运行返回假。
if (Application.isEditor)
{
print("We are running this from inside of the editor!");
}
◆ static var isLoadingLevel : bool
描述:正在加载某些关卡?(只读)
LoadLevel 和LoadLevelAdditive 不会立即发生一个新的关卡在当前游戏帧之后被加载。如
果关卡加载所请求的帧已经完成isLoadingLevel 返回true。
参见:LoadLevel,LoadLevelAdditive
◆ static var isPlaying : bool
描述:在任何类型的播放器中时返回真(只读)。
在Unity 编辑器中,如果处于播放模式时返回真。
if (Application.isPlaying)
{
print("In player or playmode");
}
◆ static var levelCount : int
描述:可用的总关卡数(只读)。
// 加载一个随机的关卡
Application.LoadLevel (Random.Range(0, Application.levelCount-1));
◆ static var loadedLevel : int
描述:最后一个被加载的关卡的索引(只读)。
print (Application.loadedLevel);
◆ static var loadedLevelName : string
描述:最后一个被加载的关卡的名称(只读)。
print (Application.loadedLevelName);
◆ static var platform : RuntimePlatform
描述:返回游戏运行的平台(只读)。
如果你要做一些平台相关的操作使用这个属性。参见:RuntimePlatform
function Start ()
{
if (Application.platform == RuntimePlatform.WindowsPlayer)
print ("Do something special here!");
}
◆ static var runInBackground : bool
描述:应用程序在后太时是否应该被运行?
默认为假(当程序在后台时暂停)。
// 让游戏运行,即使是在后台
Application.runInBackground = true;
◆ static var srcValue : string
描述:相对于html 文件的web 播放器数据文件的路径(只读)。
这是被写到html 文件中的路径,它是作为object 的src 参数和cmbed 标签。因此如果它是
绝对url,srcvalue 将含有绝对路径。
Application.absoluteURL 和Application.srcValue 允许你检测你的unityWeb 数据文件是否被
移动或链接到其他位置。你也许想保护这两者来阻止盗用数据文件的行为。
// 检测你的数据文件是否被移到其他的服务器
// 或是被链接到其他地方
function Start ()
{
Var isPirated = false;
if (Application.platform == RuntimePlatform.WindowsWebPlayer ||Application.platform ==
RuntimePlatform.OSXWebPlayer)
{
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");
}
}
◆ static var streamedBytes : int
描述:我们从主Unityweb 流中下载了多少字节(只读)。
在web 播放器中这将返回到目前为止已经下载的压缩字节数。在独立模式或编辑器中
这个总是返回零。
参见:GetStreamProgressForLevel 函数
◆ static var targetFrameRate : int
描述:命令游戏尝试以一个特定的帧率渲染。
设置targetFrameRate 为-1(默认)使独立版游戏尽可能快的渲染,并且web 播放器游戏以
50-60 帧/秒渲染,取决于平台。
注意设置targetFrameRate 不会保证帧率,会因为平台的不同而波动,或者因为计算机太慢
而不能取得这个帧率。
在编辑器中targetFrameRate 被忽略。
◆ static var unityVersion : string
描述:用于播放内容的Unity 运行时版本。
类方法
◆ static function CancelQuit () : void
描述:取消退出。这可以用来在退出游戏的时候显示一个退出画面。
这个函数只工作在播发器中,在web 播放器或编辑器中不做任何事。
// 延迟2 秒退出。
// 在这段时间内加载退出画面
var showSplashTimeout = 2.0;
private var allowQuitting = false;
function Awake () {
// 需要在多个关卡中使用的游戏物体
DontDestroyOnLoad (this);
}
function OnApplicationQuit () {
// 如果我们还没有加载到最后的退出画面
if (Application.loadedLevelName.ToLower()!= "finalsplash")
StartCoroutine("DelayedQuit");
// Don't allow the user to exit until we got permission in
if (!allowQuitting)
Application.CancelQuit();
}
function DelayedQuit ()
{
Application.LoadLevel("finalsplash");
// 等待showSplashTimecout
yield WaitForSeconds(showSplashTimeout);
// 然后退出
allowQuitting = true;
Application.Quit();
}
◆ static function CanStreamedLevelBeLoaded(levelIndex : int) : bool
描述:可以加载流式关卡了吗?
参见:GetStreamProgressForLevel 函数。
◆ static function CanStreamedLevelBeLoaded(levelName : string) : bool
描述:可以加载流式关卡了吗?
参见:GetStreamProgressForLevel 函数。
◆ static function CaptureScreenshot(filename : string) : void
描述:截取屏幕为PNG 文件放置在路径filename。
如果文件已经存在,它将被覆盖。如果在web 播放器或者Dashboard 窗口中使用该函数,它
将不做任何事情。
function OnMouseDown () {
Application.CaptureScreenshot("Screenshot.png");
}
◆ static function ExternalCall(functionName:string,params args:object[]):void
描述:调用一个包含中网页中的函数(只用于Web Player)。
调用包含在网页中名为functionNameJavaScript 函数,并传递给定的参数。支持原始的数据
类型(string, int, float, char)和这些类型的数字。如何其他的对象被转化为字符串(使用
ToString 方法)并作为字符串传递。
传递的参数数量是可变的。
// 调用网页上的MyFunction1 并不使用参数。
Application.ExternalCall ("MyFunction1");
//调用网页上的MyFunction2 并使用字符串参数。
Application.ExternalCall ("MyFunction2", "Hello from Unity!");
//调用网页上的MyFunction3 并使用几个不同类型的参数。
Application.ExternalCall ("MyFunction3", "one", 2, 3.0);
被调用的在HTML 中的函数只需要使用标准的语法即可,例如:
<script language="JavaScript" type="text/javascript">
<!—
// 使用来自Unity 的调用,这将接受
// "Hello from Unity!" 做为参数
function MyFunction2( arg )
{
alert( arg );
}
-->
</script>
See Also: Browser to Unity communication, Application.ExternalEval.
◆ static function ExternalEval (script : string) : void
描述:调用包含在网页中的片段脚本函数(只用于Web Player)。
这将执行包含在网页中JavaScript 片段script
// 导航到前一个页面
Application.ExternalEval ("history.back()");
See Also: Browser to Unity communication, Application.ExternalCall.
◆ static function GetStreamProgressForLevel(levelIndex : int) : float
描述:下载了多少?
在web 播放器中这将返回这个关卡的进度。
参见:CanStreamedLevelBeLoaded
◆ static function GetStreamProgressForLevel (levelName : string) : float
描述:下载了多少?[ 0......1]
在web 播放器中这将返回关卡的进度。
参见:CanStreamedLeverlBeLoaded 函数。
◆ static function LoadLevel(index : int) : void
描述:加载关卡。
这个函数按照索引加载关卡。在Unity 中使用File->Build Settings.....菜单可以看到所有关卡
的索引列表。在你能过加载关卡之前你必须将它添加到游戏使用关卡列表中。在Unity 中使
用File->Build Settings.....并添加你需要的关卡到关卡列表中。
//加载索引为0 的关卡
Application . LoadLevel(0);
当加载崭新的关卡时,所有已经加载的游戏物体都将被销毁。如果你想让物体在被加载新
关卡时不被销毁,使用Object.DontDestroyOnLoad 。
◆ Static function LoadLevel( name : string) : void
描述:按照它的名称加载关卡。
在你能够加载关卡之前你必须将它添加到游戏使用的关卡列表中。在Unity 中使用
File->Build Settings..... 并添加你需要的关卡到关卡列表中。关卡被加载所有激活物体上的
MonoBehaviour . OnLevelWasLoaded 都被调用。
// 加载名为“HighScore”的关卡。
Application . LoadLevel("HighScore");
当加载新的关卡时,所有已经加载的游戏物体都将被销毁。如果你想让物体在加载新
关卡时不被销毁,使用Object. DontDestroyOnLoad。
◆ static function LoadLevelAdditive ( index : int ) : void
◆ static function LoadLevelAdditive (name : string ) : void
描述:额外地加载一个关卡。
不同于LoadLevel,LoadLeavelAdditive 不会销毁当前关卡中的物体。新关卡中的物体
将被添加到当前关卡。这对于创建连续的虚拟世界时非常有用的,当你走过时更多的内
荣被加载。
◆ static function OpenURL( url : string ) : void
描述:在浏览器中打开url 。
在编辑器或者独立播放器模式下,这将在缺省的浏览器中使用新页打开url 。这将是浏
览器位于前端。
但在网页中执行时,包含插件的页将被重定向到url 。
Function Start ( ) {
Application . OpenURL ("http://unity3d.com");
}
◆ Static function Quit ( ) : void
描述:退出应用程序。在编辑器或者web 播放器中退出被忽略。
//当用户点击escape 时退出播放器
Function Update ( ){
If ( Input GetKey ( "escape" )){
Application . Quit ( ) ;
}
}
Array

数组允许你将多个对象存储在一个变量中。
Array 类只能用于JavaScript 。更多关于C#或JavaScript 中ArrayLists ,字典或哈希表的信
息参考MSDN 。
这是一个基本的例子,说明可以使用一个数组类做什么
function Start( )
{
var arr = new Array ( ) ;
arr.Push ("Hello"); //添加一个元素
Print(arr[ 0]); //打印第一个元素
arr length = 2 ; //调整数组大小
arr [ 1] = "World"; //将“World”赋给第二个元素
for (var value : String in arr) //遍历这个数组
{
Print ( value );
}
}
Unity 中有两种类型的数组,内置数组和普通的JavaScript 数组。
内置的数组(原始的.NET 数组),是非常快速和有效的但是它们不能被调整大小。
它们是静态类型的,这允许它们在检视面板中被编辑。这是如何使用内置数组的简单例子。
//在检视面板中公开一个浮点数组,你可以在那里编辑它
var value : float[ ];
Function Start ( )
{
//遍历数组
for ( var value in values){
Print ( value );
}
//因为我们不能调整内置数组的大小
//我们必须重新创建一个数组来调整它的大小
value = new float[ 10 ];
value[ 1 ] = 5.0;//给第二个元素赋值
}
内置数组在性能相关的代码中非常有用的(使用Unity 的JavaScript 和内置数组可以非常容易
使用mesh interface 在一秒内处理两万个顶点。) 另一方面,普通的JavaScript 数组可以调
整大小,排序并可以做所有你期望的数组类的操作。JavaScript 数组不显示在检视面板中。
你可以容易地在JavaScript 数组和内置数组之间转换。
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 与array 包含相同的元素
print ( newarr );
}
注意按照Unity 的命名规则下面所有函数均大写开头。为方便JavaScript 用户, Unity 数组
类也接受小写函数。
变量
◆ var length : int
描述:数组的长度属性,返回或设置数组中元素的数量。
function Start ( )
{
var arr = Array ( "Hello" , "World" ) ;
print (arr . length ) ; //打印两个
arr . Length = 5 ; //调整数组的大小为5
}
函数
◆ function Add ( value : object ) : void
描述:添加value 到数组末端。
var arr = new Array ("Hello");
arr.Add (" World ");
Print ( arr ); //打印"Hello ","World"
◆ function Clear ( ) : void
描述: 清空数组。数组的长度将为零。
var hello = new Array ("Hello ","World ");
hello.Clear ( ) ; //现在hello 包含零个元素
◆ function Concat ( array :Array , optionalArray0: Array, optionalArray1 : Array):Array
描述:连接两个或多个数组。这个方法不会改变已有的数字并返回连接后的数组拷贝
function Start ( ) {
var arr = new Array ("Hello","World"):
var arr2 = new Array ("!");
var joined = arr.Concat ( arr2 ); //现在jointed 包含所有3 个字符串
Print ( joined ); //打印"Hello","World","!"
}
◆ function Join ( seperator :string ) : String
描述:链接数组内容为一个字符串。元素将被seperator 字符串分割,并返回数组的拷贝
function Start ( ){
var arr = new Array ("Hello" , "World");
print ( arr . join (" , "));//打印"Hello,World"
}
◆ function Pop ( ) : object
描述:移除数组最后一个元素并返回它。
var arr = new Array ("Hello ","World");
arr . Pop ( );
print ( arr );//只打印"Hello"
◆ function Push (value : object) : int
描述: 添加value 到数组末端。并返回新数组长度。
var arr = new Array ("Hello");
arr.Push ("World");
print ( arr );//打印"Hello","World"
◆ function RemoveAt (index : int ) : void
描述:从数组中移除索引为index 的元素。
var arr = new Array ("Hello" , " and good morning" , "World ");
arr.Remove ( 1 ) ; //移除"and good morning"
print ( arr );//打印" Hello World "
◆ function Reverse () : Array
描述:颠倒数组中所有元素顺序。
var hello = new Array (" Hello " ," World ") ;
hello Reverse( ) ;
print (hello);//打印World,Hello
◆ function Shift ( ) :object
描述:移除数组的第一个元素并返回它。
var arr = new Array ( " Hello " , " World ");
arr . Shift ( ) ;
print ( " World " ) ; //现在arr 只包含" World "
◆ function Sort( ) : Array
描述:排序所有数组元素
var hello = new Array ( " e " ," a " ," b ");
hello . Sort ( ) ;
print ( hello ) ;// 打印a ,b ,c
◆ function Unshift ( newElement : object , optionalElement : object ) : int
描述: Unshift 添加一个或多个元素到数组的开始位置并返回新的数组长度。
var arr = new Array (" Hello "," World ");
arr . Unshift (" This "," is ");
print ( arr ) ;//打印This,is,Hello,World
BitStream

BitStream 类表示序列化的变量,打包到一个流中。
数据可以被序列化,传输,然后远端使用这个类接受。参考Network View component reference
获取关于网络同步的信息和Network. OnSerializeNetworkView 函数获取更多信息。
变量
◆ var isReading : bool
描述:这个BitStream 现在在被读吗?
参考Network. OnSerializeNetworkView
◆ var isWriting : bool
描述:这个BitStream 现在在被写吗?
参考Network. OnSerializeNetworkView
函数
◆ function Serialize (ref value : bool ) : void
◆ function Serialize (ref value : char ) : void
◆ function Serialize (ref value : short) : void
◆ function Serialize (ref value : int ) : void
◆ function Serialize (ref value : float , maxDelta : float = 0.00001F) : void
◆ function Serialize (ref value : Quaternion, maxDelta : float = 0.00001F) : void
◆ function Serialize (ref value : Vector3, maxDelta : float = 0.00001F) : void
◆ function Serialize (ref value : NetworkPlayer ) : void
◆ function Serialize (ref viewID: NetworkViewID ) : void
描述:BitStream 类可以序列化几个不同类型的变量。
包含:bool , char , short , int , float , Quaternion , Vector3 和NetworkPlayer
注意serialize ( char )系列化一个字节,因此,它只能用于0......255 之间的字符。
BoneWeight
结构
网格上一个顶点的蒙皮骨骼权值
每个被蒙皮的点至多有四个骨头。所有权值的和应该为1。权值和骨骼索引应该被以权值递
减的顺序定义。如果一个顶点被少于四个骨骼影响,剩下的权值应该为0。
参见:Mesh.boneWeights 变量。
变量
◆ var boneIndex0 : int
描述:第一个骨骼的索引。
参见:weight0 .
◆ var boneIndex1 : int
描述:第二个骨骼的索引。
参见:weight1.
◆ var boneIndex2 : int
描述:第三个骨骼的索引。
参见:weight2 .
◆ var boneIndex3 : int
描述:第四个骨骼的索引。
参见:weight3 .
◆ var weight0 : float
描述:第一个骨骼的蒙皮权值。
参见:boneIndex0.
◆ var weight1 : float
描述:第二个骨骼的蒙皮权值。
参见:boneIndex1.
◆ var weight2 : float
描述:第三个骨骼的蒙皮权值。
参见:boneIndex2.
◆ var weight3 : float
描述:第四个骨骼的蒙皮权值。
参见:boneIndex3.
Bounds
结构
代表一个轴对齐包围盒。
一个轴对齐包围盒,简称为AABB,是与坐标轴对齐的box 并且完全包围一些物体。因为这
个box 不会绕着轴旋转,所以它可以只用center 和extents 定义,或者用min 和max 点定义。
Bounds 被Collider.bounds,Mesh.bounds,Renderer.bounds 使用。
变量
◆var center : Vector3
描述:包围盒子的中心
◆var extents : Vector3
描述:box 的宽度。这个总是size 的一半
◆var max : Vector3
描述:box 的最大点。这个总是等于center + extents。
◆var min : Vector3
描述:box 的最小点。这个总是等于center - extents。
◆var size : Vector3
描述:box 的总大小。这个总是extents 的二倍。
size.x 是宽度, size.y 是高度, size.z 是长度。
构造函数
◆static function Bounds ( center : Vector3 , size : Vector3 ) : Bounds
描述:用给定的center 和总size 创建新的Bounds。Bounds extents 将是给定size 的一半。
var bounds = Bounds ( Vector3.zero , Vector3(1,2,1));//在原点常见柱状包围盒
函数
◆function Contains ( point : Vector3 ) : bool
描述:point 包含在这个包围盒中吗?
◆function Encapsulate ( point : Vector3 ) : void
描述:增大Bounds 以包含这个point.
◆function Encapsulate ( bounds : Bounds ) : void
描述:增大bounds 来封装另一个bounds。
◆function Expand ( amount : float ) : void
描述:沿着每个面按照amount 增加它的size 来扩展这个bounds。
◆function Expand ( amount : Vector3 ) : void
描述:沿着每个面按照amount 增加它的size 来扩展这个bounds。
◆function IntersectRay ( ray : Ray ) : bool
描述:ray 与这个包围盒相交吗?
◆function IntersectRay ( ray : Ray , out distance : float ) : bool
描述:ray 与这个包围盒相交吗?
当IntersectRay 返回真,distance 将是到射线源点的距离。
◆function SetMinMax ( min : Vector3, max : Vector3 ) : void
描述:设定边界为盒子的min 和max 值。
使用这个函数要比分别指定min 和max 更快。
◆function SqrDistance ( point : Vector3 ) : float
描述: 点到这个包围盒的最小平方距离。
◆function ToString ( ) : string
描述:返回一个格式化好的字符串
collision

描述碰撞
Collision 信息被传递到Collider . OnCollisionEnter , Collider . OnCollisionStay 和
Collider.OnCollisionExit 事件。参见: ContactPoint.
变量
◆var collider : Collider
描述:碰撞到的Collider ( 只读).
为了得到所有被碰撞到的碰撞器的细节,你需要迭代接触点( contacts 属性)。
◆var contacts : ContactPoint [ ]
描述:接触点由物理引擎产生。
每个contact 包含一个接触点,法线和两个发生碰撞的碰撞器(参考ContactPoint)。在
OnCollisionStay 或者OnCollisionEnter 内可以确保contacts 有至少一个元素。
function OnCollisionStay ( collision : Collision ){
//检查碰到碰撞器是否有刚体
//然后使用一个力
for ( var contact : ContactPoint in collision . contacts ) {
print ( contact.thisCollider . name + "hit" + contact . otherCollider .name );
//可视化接触点
Debug.DrawRay ( contact . point , contact . normal, Color .white ) ;
}
}
//一枚手榴弹,在击中一个表面时初始化一个爆炸预设,然后销毁它
var explosionPrefab : Transform;
function OnCollisionEnter( collision : Collision ){
//旋转这个物体使y 轴面沿着表面法线的方向
var contact = collision . contact [ 0 ];
var rot = Quaternion . FromToRotation ( Vector3.up , contact . normal ) ;
var pos = contact . point ;
Instantiate ( explosionPrefab , pos , rot ) ;
Destory ( gameObject );//销毁这个投射物
}
◆var gameObject : GameObject
描述:/ gameObject / 是与之碰撞的物体(只读)
◆var relativeVelocity : Vector3
描述: 两个碰撞物体的相对线形速度(只读)。
//当以较大的速度碰到一个物体时播放声音
function OnCllisionEnter ( collision : Collision ) {
if ( collision . relativeVelocity . magnitude > 2 )
audio .Play ( );
}
◆var rigibody : Rigidbody
描述:碰撞到的Rigidbody(只读),如果碰到的物体是一个没有附加刚体的碰撞器,返回
null
//让所有碰到的刚体向上飞
function OnCollisionStay ( collision : Collision ) {
//检查碰到的碰撞器是否有一个刚体,然后使用力
if ( collision . rigidbody ){
collision . rigidbody .AddForce ( Vector3 . up * 15 ) ;
}
}
◆var transform : Transform
描述:碰撞到的物体的Transform(只读)。
如果碰到一个带有Rigidbody 的碰撞器,transform 将是所有附加刚体的变换。如果碰到了一
个没有刚体的碰撞器,transform 将是所有附加碰撞器的变换。
color
结构
表示RGBA 颜色。
这个结构被用在整个Unity 中传递颜色。每个颜色组件是一个0 到1 之间的浮点数。
组件(r ,g ,b )在RGB 颜色空间内定义一个颜色。Alpha 组件(a)透明性- alpha 为0 是完全
不透明,alpha 为1 是完全透明。
变量
◆var a : float
描述:颜色的Alpha 组件。
var color = Color . white ;
color . a = 0 ;
◆var b : float
描述:颜色的蓝色组件。
var color = Color .white;
color .b = 0 ;
◆var g : float
描述:颜色的绿色组件
var color = Color . white ;
color . g = 0 ;
◆var grayscale : float
描述:颜色的灰度值(只读)
var color = Color ( 3 , 4 ,6 ) ;
print ( color . grayscale ) ;
◆var r : float
描述:颜色的红色组件。
var color = Color . white ;
color . r = 0
◆var this [ index : int ] : float
描述:分别使用[ 0 ] ,[ 1 ] ,[ 2 ] ,[ 3 ]访问r ,g , b ,a 组件。
Color p ;
p [ 1 ] = 5 ;//与p .g = 5 相同
构造函数
◆static function Color ( r : float , g : float , b : float, a: float ) : Color
描述:用给定的r , g , b , a ,组件构建一个新的颜色。
var color = Color ( 0.2 , 0.3 , 0.4 , 0.5 ) ;
◆static function Color ( r : float , g : float , b : float ) : Color
描述:用给定的r , g , b 组件构建一个新的颜色并设置a 为1
var color = Color (0.2 , 0.3 , 0.4 ) ;
函数
◆function ToString ( ):string
描述:返回格式化好的这个颜色的字符串。
print ( Color .white ) ;
类变量
◆static var black : Color
描述:黑色。RGBA 为( 0 , 0 , 0 , 1 ).
◆static var blue : Color
描述:蓝色。RGBA 为( 0 , 0 , 1 , 1 ).
◆static var clear : Color
描述:完全透明。RGBA 为( 0 ,0, 0, 0 ).
◆static var eyan : Color
描述:青色。RGBA 为( 0 , 1 , 1 , 1 ).
◆static var gray : Color
描述:灰色。RGBA 为( 5 , 5 , 5 , 1 ).
◆static var green : Color
描述:绿色。RGBA 为(0, 1 , 0, 1 ).
◆static var grey : Color
描述:英式拼法为gray。RGBA 为(0.5 , 0.5 , 0.5 , 1 ).
◆static var magenta : Color
描述:紫红色。RGBA 为(1 , 0 , 1 , 1 ).
◆static var red : Color
描述:全红。RGBA 为(1 , 0 , 0, 1 ).
◆static var white : Color
描述:全白。RGBA 为(1 , 1 , 1 , 1 ).
◆static var yellow : Color
描述:黄色。RGBA 是怪异的(1 , 235/255 , 4/255 , 1 ),但是这个颜色看起来非常好!
类方法
◆static function Lerp ( a : Color , b : Color , t : float ) : Color
描述:在颜色a 和颜色b 之间按照t 插值。
/ t /被限定到0 和1 之间,当t 为0 时返回a . 当t 为1 时返回b
◆static operator * ( a : Color , b : Color) : Color
描述:乘两个颜色,每个组件被分别乘。
◆static operator * ( a : Color , b : float) : Color
描述:用浮点数b 乘以颜色a。每个组件被分别乘。
◆static operator * ( a : float , b : Color) : Color
描述:用浮点数b 乘以颜色a。每个组件被分别乘。
◆static operator + ( a : Color , b : Color) : Color
描述:加两个颜色,每个组件被分别加。
◆static operator - ( a : Color , b : Color) : Color
描述:从颜色a 中减去颜色b。每个组件被分别减。
◆static operator / ( a : Color , b : float) : Color
描述:乘用浮点数b 除以a。每个组件被分别除。
◆static implicit function Color ( v : Vectro4 ) : Color
描述:Colors 可以被隐式转化为Vector4,或由它转化而来。
◆static implicit function Vector4 ( c : Color ) : Vector4
描述:Colors 以被隐式的转化为Vector4,或由它转化而来。
ContactPoint
结构
描述:碰撞发生的接触点。
接触点被存储在collision 结构中, 参见collision , collision . OnCollisionEnter,
Collision . OnCollisionStay , Collision . OnCollisionExit.
变量
◆var normal : Vector3
描述:接触点的法线
◆var otherCollider : Collider
描述:碰撞中的另一个碰撞器
◆var point : Vector3
描述:接触点
◆var thisCollider : Collider?
描述:碰撞中的第一个碰撞器
ControllerColliderHit

ControllerColliderHit 被CharacterController . OnControllerColliderHit 使用来给出详细的关于
碰撞和如何处理它们的信息。
变量
◆var collider : Collider
描述:被控制器碰到的碰撞器。
◆var controller : CharacterController
描述:碰到该碰撞器的控制器。
◆var gameObject : GameObject
描述:被控制器碰到的游戏物体。
◆var moveDirection : Vector3
描述:从胶囊的中心到接触点的大致方向。
这可以用来找到一个合理的方向将力应用到接触的刚体。
◆var moveLength : float
描述:角色碰到这个碰撞器时已经行走了多远。
注意这可能不同于你传递到CharacterController . Move 的。因为所有的移动都是被碰撞器制
约的。
◆var normal : Vector3
描述:在世界空间中碰撞表面的法线。
◆var point : Vector3
描述:世界空间中的碰撞点。
◆var rigidbody : Rigidbody
描述:被控制器碰到的刚体。
如果没有接触一个刚体而是一个静态碰撞器时为null。
◆var transform : Transform
描述:被控制器碰到的变换。
Debug

一个类,包含用于开发游戏时的调试方法。
类变量
◆static var isDebugBuild : bool
描述:在Build Settings....对话框中,有一个被称为"strip debug symbols"的复选框。
如果它被选择isDebugBuild 将为关。在编辑器中isDebugBuild 总是返回真,建议在发布游
戏的时候移除所有对Debug .Log 的调用,这样你就能够容易的发布带有调试输出的测试版,
而最终版没有调试输出。
//只有这是调试版时,记录调试信息
if ( Debug .isDebugBuild ) {
Debug . Log ( " Something bad happened ! " ) ;
}
类方法
◆static function Break ( ) : void
描述:暂停编辑器
Debug . Break ( ) ;
◆static function DrawLine ( start:Vector3, end: Vector3, color : Color = Color . white ) : void
描述:从point 开始到end 用颜色绘制一条线。
这个线将被绘制在编辑器的场景视图中。如果在游戏视图中启用了gizmo 绘制,这个线也
将被绘制在这里。
//从世界坐标的原点到点( 1 , 0 , 0 )绘制一条红色的线
function Update ( ) {
Debug . DrawLine ( Vector3 . Zero , new Vector3 ( 1 , 0 , 0 ), Color . red ) ;
}
◆static function DrawRay ( start:Vector3, dir : Vector3, color : Color = Color . white ) : void
描述:从start 到start+dir 用颜色绘制一条线。
//绘制一条10 米长的线从position,沿着变换的z 轴向前。
function Update ( ) {
var forward = transform . TransformDirection ( Vector3 . forward ) * 10 ;
Debug . DrawRay ( transform . position .Vector3 . forward * 10 , Color . green );
}
◆static function Log ( message : object ) : void
描述:记录message 到Unity 控制台。
Debug . Log ( "Hello");
◆static function Log ( message : object . context : Object ) : void
描述:记录message 到Unity 控制台。
当你在控制台中选择消息的时候一个到上下文物体的链接将被绘制。这是非常有用的。如果
你想知道那个物体发生了错误。
Debug . Log ( "Hello" , gameObject ) ;
◆static function LogError ( message : object ) : void
描述:Debug . Log 的一个变体,用来记录错误信息到控制台。
var memberVariable : Transform ;
if ( memberVariable == null )
Debug . LogError ( " memberVariable must be set to point to a Transform. ") ;
◆static function LogError ( message : object , context : Object ) : void
描述:Debug . Log 的一个变体,用来记录错误信息到控制台。
等你在控制台中选择消息的时候一个到上下文物体的链接将被绘制。这是非常有用的, 如
果你想知道那个发生了错误。
var memberVariable : Transform ;
if ( memberVariable == null )
Debug . LogError ( "memberVariable must be set to point to a Transform " , this ) ;
◆static function LogWarning ( message : object ) : void
描述:Debug . Log 的一个变体,用来记录警告信息到控制台。
◆static function LogWarning ( message : object , context : Object ) : void
描述:Debug . Log 的一个变体,用来记录警告信息到控制台。
当你选择控制台中的一个消息时,一个到上下文物体的连接将被绘制。这是非常有用
的, 如果你想知道那个物体发生了错误
Event

一个UnityGUI 事件。
对应于用户的输入事件(按键,鼠标事件),或者是UnityGUI 布局或渲染事件。
对于每个事件OnGUI 在脚本中被调用;因此OnGUI 在每帧中被潜在调用多次。
Event . current 对应于OnGUI 调用“当前”事件。
参见:GUIScripting Guide
变量
◆var alt : bool
描述:Alt/Option 键被按住?(只读)
在windows 下,如果Alt 键被按下返回真。在Mac 下,如果Option 键被按下返回真。
◆var button : int
描述:哪个鼠标键被按下
0 表示左键,1 表示右键。2 表示中键。在EventType . MouseDown ,EventType .MouseUp
事件中使用。
◆var capsLock : bool
描述:Caps Lock 处于打开状态?(只读)
如果Caps Lock 为打开返回真
◆var character : char
描述:输入的字符
在EventType . KeyDown 事件中使用,注意EventType . KeyUp 事件不包含字符,只包含
Event . keyCode .
参见:Event . keyCode.
◆var command : bool
描述:Command/Windows 键被按住?(只读)
在Windows 下,如果Windows 键被按下返回真。在Mac 下,如果Command 键被按下返回
真。
◆var control : bool
描述:Control 被按下?(只读)
如果Control 被按下返回真。
◆var delta : Vector2
描述:与上次事件相比,鼠标的相对移动。
在EventType .MouseMove,EventType .MouseDrag,,EventType .ScrollWheel 时间中使用。
参见:Event . mousePosition
◆var functionKey : bool
描述:当前按下的键是功能键?(只读)
如果当前按下的键是方向键,翻页键,退格键等等时返回真,如果这个键需要特殊处理才能
用与文本编辑时,functionKey 为打开。
◆var isKey : bool
描述:这个事件是键盘事件?(只读)
◆var isMouse : bool
描述:这个事件是鼠标事件?(只读)
◆var keyCode : KeyCode
描述:用于键盘事件的原始键代码
在EventType . KeyDown 和EventType . KeyUp 事件中使用;返回匹配物理键盘的KeyCode
值,使用这个来处理光标,功能键等等。
参见:Event . character 。
◆var mousePosition : Vector2
描述:鼠标位置
在EventType . MouseMove 和EventType . MouseDrag 事件中使用。
参见:Event . delta
◆var numeric : bool
描述:当前按下的数字的键?(只读)
使用这个表示区分主&数字键。
◆var shift : bool
描述:Shift 被按下?(只读)
如果Shift 被按下返回真。
函数
◆function GetTypeForControl ( controlID : int ) : EventType
参数
controlID 查询的控件ID 。从GUIUtilty . GetControlID ( ) 获取。参考
EventType 获取可能值的列表。
描述:为给定的控件ID 获取一个过滤的事件类型。
这个函数可以用来实现鼠标锁和键盘焦点。
◆function Use ( ) : void
描述:使用这个事件。
当已经使用了一个事件时调用这个方法。事件类型将被设置为EventType . Used。使其他
GUI 元素忽略它。
类变量
◆static var current : Event
描述:现在被处理的当前事件。
类方法
◆static function KeyboardEvent ( key : string ) : Event
描述:创建一个键盘事件。
这可用于检查某个键是否被按下。可能带有调整器。key 字符串是键的名称(与输入管理
器中的相同),可以使用任意数量的调整器前缀:& = Alternate , ^ = Controler, % = Command ,
# = Shift 例如:&f12 = Alternate +F12., " ^[ 0 ] " = Control +keypad0
function OnGUI ( ) {
GUILayout . Lable ( " Press Enter To Start Game ") ;
if ( Event . current . Equals ( Event . KeyboardEvent ("[enter]")))
Application . LoadLevel ( 1 )
if(Event current Equals(Event KeybordEvent("return") ))
Print( "I said enter ,not return – try the keypad" );
}
GL

底层图像库。
使用这个类操作激活的变换矩阵,发送与OpengGL 立即模式相同的渲染命令并做一些其他
的底层图像操作。注意,在所有情况下使用Graphics.DrawMesh 比任何使用立即模式绘制更
有效。
这个类只限于Unity Pro.
类变量
◆ static var LINES: int
描述:用于Begin 的模式:绘制直线。
参见:GL . Begin, GL . End.
◆ static var modelview:Matrix4x4
描述:当前模型视矩阵。
给这个变量赋值等同于OpenGL 中的glLoadMatrix(mat);在其他图形API 中对应的功能被模
拟。
改变模型视矩阵覆盖当前相机的视参数, 因此最常用的是使用GL.PushMatrix 和
GL.PopMatrix 来保存和恢复矩阵。
读取这个变量返回当前模型视矩阵。
◆ static var QUADS:int
描述:用于Begin 的模式:绘制四边形
参见:GL.Begin,GL.End.
◆ static var TRIANGLE_STRIP:int
描述:用于Begin 的模式:绘制三角面
参见:GL.Begin,GL.End.
◆ static var TRIANGLES:int
描述:用于Begin 的模式:绘制三角形
参见:GL.Begin,GL.End.
类方法
◆ static function Begin(mode:int) : void
参数
mode 绘制的几何体:可以是TRIANGLES,TRIANGLE_STRIP,QUADS 或
LINES.
描述:开始绘制3D 几何体
这个对应OpenGL 中的glBegin,在其他图形API 中相同的功能被模拟,在GL.Begin 和
GL.End 之间,可以调用GL .Veriex,GL.Color,GL.TexCoord 和其他立即模式绘制函数。
在绘制你自己的几何体时,你应该注意它们的裁剪。裁剪规则可能会因为不同的图形API
而不同。在大多数情况下在shader 中使用Cull Off 命令是安全的。
参见:GL.End.
◆ static function Clear(clearDepth:bool,clearColor:bool,backgroudColor):void
参数
clearDepth 应该清除深度缓存?
clearColor 应该清除颜色缓存?
backgroudColor 颜色被清理为什么,只有当clearColor 为true 时使用.
描述:清除当前渲染缓存
这将清除屏幕或激活的RenderTexture.
◆ static function Color(c : Color) : void
描述:设置当前顶点颜色
这个对应OpenGL 中的glColor4f(c. r,c.g,c.b,c.a):在其他图形中API 中相同的功能被模拟,
为了使逐顶点颜色可以在不同的硬件上工作,你需要使用绑定了颜色通道的shader。参考
BindChannels 文档.
这个函数只在GL.Begin 和GL.End 函数之间调用.
◆ static function End( ) : void
描述:结束绘制3D 几何体
这个对应OpenGL 中的glEnd;在其他图形API 中相同的功能被模拟.
参见:GL.Begin.
◆ static function LoadIdentity( ) : void
描述:加载单位矩阵到当前模型视矩阵。
这个函数覆盖当前相机的视参数,因此最常用的是使用GL.PushMatrix 和GL.PopMatrix
来保存和恢复矩阵。
◆ static function LoadOrtho( ) : void
描述:辅助函数用来设置一个正交透视变换
调用LoadOrtho 知道,视锥从(0,0,-1) 变化到(1,1,100).
◆ static function LoadPixelMatrix( ) : void
描述:设置一个用于像素修正渲染的矩阵。
这个设置模型视和投影矩阵,因此X,Y 坐标直接映射到像素。(0,0)位于当前相机
视口的左下角。Z 坐标从-1 到+100
这个函数覆盖当前相机的参数,因此最常用的是使用GL.PushMatrix 和GL.PopMatrix
来保存和恢复矩阵。
◆ static function LoadPixelMatrix(left:float,right:float,bottom:float,top:float):void
描述:设置一个矩阵的像素正确渲染。
这样设置投影矩阵点以便X、Y 坐标图直接像素化。(0,0)在底部左侧当前摄像机的视角。
Z 坐标是从-1 到+100。
这个函数覆盖了相机的参数,所以通常你要保存和恢复矩阵就使用GLPushMatrix 和
GL.PopMatrix。
◆ static function LoadProjectionMatrix (mat : Matrix4x4) : void
描述:加载到当前任意矩阵投影矩阵。
这个函数重写当前摄像机的投影参数, 所以通常你要保存和恢复投影矩阵就使用
GLPushMatrix 和GL.PopMatrix。
◆ static function MultiTexCoord (unit : int, v : Vector3) : void
描述:设置当前纹理坐标(v.x,v.y,v.z)实际的纹理单元。
在OpenGL 中glMultiTexCoord 为特定的纹理单元如果多纹理是可用的。在其他图形的API
中相同的功能进行了仿真。
这个函数只能被称为介于GL.Begin 和GL.End 功能之间。
◆ static function MultiTexCoord2 (unit : int, x : float, y : float) : void
描述:设置当前纹理坐标(x,y)的为实际纹理单元。
在OpenGL 中glMultiTexCoord 为特定的纹理单元如果多纹理是可用的。在其他图形的API
中相同的功能进行了仿真。
这个函数只能被称为介于GL.Begin 和GL.End 功能之间。
◆ static function MultiTexCoord3(unit : int, x : float, y : float, z : float) :void
描述:设置当前纹理坐标(x,y,z)的为实际纹理单元。
在OpenGL 中glMultiTexCoord 为特定的纹理单元如果多纹理是可用的。在其他图形的API
中相同的功能进行了仿真。
这个函数只能被称为介于GL.Begin 和GL.End 功能之间。
◆ static function MultMatrix (mat : Matrix4x4) : void
描述:复制当前的点矩阵和其中的一个说明。
相当于glMultMatrix(垫在)OpenGL; 在其他图形API 的相应功能是相仿的。
换点矩阵覆盖当前相机视图的参数, 所以通常你要保存和恢复投影矩阵就使用
GLPushMatrix 和GL.PopMatrix。
◆ static function PopMatrix () : void
描述:恢复了投影和点矩阵的矩阵堆栈的顶部。
换投影矩阵点覆盖当前相机视图的参数。这些矩阵可以用GLPushMatrix 和GL.PopMatrix 来
保存和恢复。
参见:PushMatrix 函数。
◆ static function PushMatrix () : void
描述:节约双方投影矩阵对点和矩阵堆栈。
换投影矩阵点覆盖当前相机视图的参数。这些矩阵可以用GLPushMatrix 和
GL.PopMatrix 来保存和恢复。
参见:PopMatrix 函数
◆ static function SetRevertBackfacing(revertBackFaces : bool) : void
描述:选择是否翻转隐面剔除,是(真)或者不是(假)
◆ static function TextCoord (v : Vector3) : void
描述:为所有纹理单元设置当前纹理坐标(v.x, v.y, v.z)
这个对应于OpengGL 中用于所有纹理单元的glMultiTexCoord 或者多纹理不可用时的
glTexCoord,在其他的图形API 中仿真了相同的功能。
这个函数只在GL.Begin 和GL.End 函数之间调用。
◆ static function TexCoord2(x : float, y : float) : void
描述:为所有纹理单元设置当前纹理坐标(x, y)
这个对应于OpengGL 中用于所有纹理单元的glMultiTexCoord 或者多纹理不可用时的
glTexCoord,在其他的图形API 中仿真了相同的功能。
, 这个函数只在GL.Begin 和GL.End 函数之间调用。
◆ static function TexCoord3(x : float, y : float, z : float) : void
描述:为所有纹理单元设置当前纹理坐标(x, y, z)
这个对应于OpengGL 中用于所有纹理单元的glMultiTexCoord 或者多纹理不可用时的
glTexCoord,在其他的图形API 中仿真了相同的功能。
这个函数只在GL.Begin 和GL.End 函数之间调用。
◆ static function Vertex(v : Vector3) : void
描述:提交顶点
这个对应OpenGL 中的glVertex3f(v.x, v.y.v.z); 在其他图形API 中相同的功能被模拟。
这个函数只在GL.Begin 和GL.End 函数之间调用。
◆ static function Vertex3(x : float, y : float, z : float) : void
描述:提交顶点
这个对应OpenGL 中的glVertex3f(x, y, z); 在其他图形API 中相同的功能被模拟。
这个函数只在GL.Begin 和GL.End 函数之间调用。
◆ static function Viewport(pixelRect : Rect) : void
描述:设置渲染视口
所有的渲染都被限制在pixelRect 之内。
GUIContent

GUI 元素的内容
这个与GUIStyle 紧密相关,GUIContent 定义渲染什么而GUIStyle 定义如何渲染。
参见:GUIStyle
变量
◆ var image : Texture
描述:包含图标的图像
◆ var text : string
描述:包含的文本
◆ var tooltip : string
描述:这个元素的提示
与这个内容相关的提示。读取GUItooltip 来获取当前用户指向的GUI 元素的提示。
构造函数
◆ static function GUIContent() : GUIContent
描述:用于所有形状和尺寸的GUIContent 的构造函数
构建一个空的GUIContent。
◆ static function GUIContent(text : string) : GUIContent
描述:构建一个只包含文本的GUIContent 物体。
使用GUI 是,你不需要为一个简单的文本字符创建GUIContents – 这两行代码功能等效:
function OnGUI()
{
GUI.Button(Rect(0, 0, 100, 20), “Click Me”);
GUI.Button(Rect(0, 30, 100, 20), GUIContent(“Click Me”));
}
◆ static function GUIContent(image : Texture) : GUIContent
描述:构建一个只包含图片的GUIContent 对象。
var icon : Texture;
function OnGUI()
{
GUI.Button(Rect(0, 0, 100, 20), GUIContent(icon));
}
◆ static function GUIContent(text : string, image : Texture) : GUIContent
描述:构建一个包含text 和图片的GUIContent 对象
var icon : Texture;
function OnGUI()
{
GUI.Button(Rect(0, 0, 100, 20), GUIContent(“Click me”, icon));
}
◆ static function GUIContent(text : string, tooltip : string) : GUIContent
描述:构建一个包含text 的GUIContent,当用户鼠标悬停在它上面的时候,全局GUI.tooltip
被设置为tooltip。
function OnGUI()
{
GUI.Button(Rect(0, 0, 100, 20), GUIContent(“Click me”, “This is a tooltip.”));
//如果用户指向这个按钮,全局提示被设置
GUI.Label(Rect(0, 40, 100, 40), GUI.tooltip);
}
◆ static function GUIContent(image : Texture, tooltip : string) : GUIContent
描述:构建一个包含图片的GUIContent,当用户鼠标悬停在它上面的时候,全局GUItooltip
被设置为tooltip。
◆ static function GUIContent(text : string, image : Texture, tooltip : string) : GUIContent
描述:构建一个包含text 和image 的GUIContent,,当用户鼠标悬停在它上面的时候,全局
GUItooltip 被设置为tooltip。
◆ static function GUIContent(src : GUIContent) : GUIContent
描述:从另一个GUIContent 构建一个GUIContent。
GUILayoutOption

内部类用来传递布局选项给GUILayout 函数,不要直接使用这些,而是在GUILayout 类的
布局函数中构造它们。
参见:
GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth,
GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth,
GUILayout.ExpandHeight
GUILayoutUtility

用于实现并扩展GUILayout 类的工具函数。
使用这个类制作你自己的GUI 布局代码
类方法
◆ static function BeginGroup(GroupName : string) : void
◆ static function BeginLayoutGroup(style : GUIStyle, options : GUILayoutOption[],
LayoutType : System.Type) : GUILayoutGroup
描述:普通的辅助函数– 当创建一个布局组的时候使用这个。它将确保所有的事情都正确
的排列。
style : 组选项的风格
option : 使用的布局选项
LayoutType : 创建的布局组的类型
◆ static function EndGroup(groupName : string) : void
◆ static function GetAspectRect(aspect : float) : Rect
◆ static function GetAspectRect(aspect : floar, style : GUIStyle) : Rect
◆ static function GetAspectRect(aspect : float, params options : GUILayoutOption[]) : Rect
◆ static function GetAspectRect(aspect : float, style : GUIStyle, params options :
GUILayoutOption[]) : Rect
参数
aspect 这个元素的宽高比(宽/高)
style 一个可选的风格。如果指定风格的padding 将被添加到返回举行的尺寸并且这个风格
的margin 将被用于间距。
options 一个可选的布局选项的列表,它用来指定额外的布局属性。任何在这里设置的值将
覆盖由Style 定义的设置。参见GUILayout.Width, GUILayout.Height, GUILayout.MinWidth,
GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight,
GUILayout.ExpandWidth, GUILayout.ExpandHeight.
返回Rect – 控制的矩形
描述:用一个制定的宽高比获取一个矩形。
◆ static function GetRect(content : GUIContent, style : GUIStyle, params options :
GUILayoutOption[]) : Rect
参数
content 让出空间所显示的内容
style 用于布局的GUIStyle
options 一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将
覆盖由style 定义的设置。参见:GUILayout.Width, GUILayout.Height, GUILayout.MinWidth,
GUILayout.MaxWidth, GUILayout.MinHeight, GUILAyout.MaxHeight,
GUILayout.ExpandWidth, GUILayout.ExpandHeight
返回Rect – 一个足够大的矩形区域用来包含用/style/渲染时的/content/。
描述:获取一个以特定风格显示内容的矩形。
◆ static function GetRect(width : float, height : float) : Rect
◆ static function GetRect(width : float, height : float, params options : GUILayoutOption[]) :
Rect
◆ static function GetRect(width : float, height : float, style : GUIStyle, params options :
GUILayoutOption[]) : Rect
参数
width 你想要的区域的宽度
height 你想要的区域的高度
style 用了布局的可选GUIStyle,如果指定,风格的padding 将被添加到尺寸并且它的margin
将被用于间距
options 一个可选的布局选项的列表,它用来指定额外的布局属性。任何在这里设置的值将
覆盖由style 定义的设置。
参见:GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth,
GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth,
GUILayout.ExpandHeight.
返回Rect – 用于放置控件的矩形
描述:用一个固定的内容区域获取一个矩形
◆ static function GetRect(minWidth : float, maxWidth : float, minHeight : float, maxHeight :
float) : Rect
◆ static function GetRect(minWidth : float, maxWidth : float, minHeight : float, maxHeight :
float, style : GUIStyle) : Rect
◆ static function GetRect(minWidth : float, maxWidth : float, minHeight : float, maxHeight :
float, params options : GUILayerOption[]) : Rect
◆ static function GetRect(minWidth : float, maxWidth : float, minHeight : float, maxHeight :
float, style : GUIStyle, paramas option : GUILayoutOption[]) : Rect
参数
minWidth 传回区域的最小宽度
maxWidth 传回区域的最大宽度
minHeight 传回区域的最小高度
maxHeight 传回区域的最大宽度
style 一个可选的风格。如果指定,风格的padding 将被添加到尺寸并且它的margin 将被用
于间距
options 一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将
覆盖由style 定义的设置。
参见:GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth,
GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth,
GUILayout.ExpandHeight.
返回Rect – 一个矩形区域在两个轴上的尺寸介于minWidth 和maxWidth 之间
描述:从布局系统获取一个可扩展的矩形,矩形的尺寸将在min 和max 值之间。
GUILayout

GUILayout 是用于UnityGUI 自动布局的类。
参见:GUI Layout tutoria
类方法
◆ static function BeginArea(screenRect : Rect) : void
◆ static function BeginArea(screenRect : rect, text : string) : void
◆ static function BeginArea(screenRect : Rect, image : Texture) : void
◆ static function BeginArea(screenRect : Rect, content : GUIContent) : void
◆ static function BeginArea(screenRect : Rect, style : GUIStyle) : void
◆ static function BeginArea(screenRect : Rect, text : string, style : GUIStyle) : void
◆ static function BeginArea(screenRect : Rect, image : Texture, style : GUIStyle) : void
◆ static function BeginArea(screenRect : Rect, content : GUIContent, style : GUIStyle) : void
参数
text 可选的显示在该区域中的文本
image 可选的显示在该区域中的纹理
content 可选的在该区域顶部显示的文本,图片和提示
style 使用的风格。如果留空,空的GUIStyle(GUIStyle.none)将被使用,给出一个透明的背
景。参见:EndArea
描述:在屏幕的固定区域开始一个GUI 空间的GUILayout 块。
默认的,任何使用GUILayout 制作的GUI 空间都放置在屏幕的左上角。如果你想在任一区
域放置一系列自动布局的控件,使用GUILayout.BeginArea 定义一个新的区域以便自动布局
系统可以使用它。
function OnGUI()
{
GUILayout.BeginArea(Rect(200, 200, 100, 100));
GUILayout.Button(“Click me”);
GUILayout.Button(“Or me”);
GUILayout.EndArea();
}
在混合GUILayout 代码是这个函数是非常有用的。必须与EndArea 调用匹配。BeginArea /
EndArea 不能嵌套。
◆ static function BeginHorizontal(params options : GUILayoutOption[]): void
◆ static function BeginHorizontal(style : GUIStyle, params options : GUILayoutOption[]): void
参数
style 这个风格用于背景图片和填充值。如果留空,背景是透明的。
options 一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这个设置的值将
覆盖由style 定义的设置。
参见: GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth,
GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth,
GUILayout.ExpandHeight
描述:开始一个水平控件组。
所有在这个元素内部渲染的空间将被一个接一个的水平放置,改组必须调用EndHorizontal
关闭。
◆ static function BeginScrollView(scrollPosition : Vector2, params options :
GUILayoutOption[]) : Vector2
◆ static function BeginScrollView(scrollPosition : Vector2, horizontalScrollbar : GUIStyle,
verticalScrollbar : GUIStyle, params options : GUILayoutOption[]) : Vector2
◆ static function BeginScrollView(scrollPosition : Vector2, alwaysShowHorizontal : bool,
alwaysShowVertical : bool, params options : GUILayoutOption[]) : Vector2
◆ static function BeginScrollView(scrollPosition : Vector2, style : GUIStyle) : Vector2
◆ static function BeginScrollView(scrollPosition : Vector2, alwaysShowHorizontal : bool,
alwaysShowVertical : bool, horizontalScrollbar : GUIStyle, verticalScrollbar : GUIStyle, params
options : GUILayoutOption[]) : Vector2
◆ static function BeginScrollView(scrollPosition : Vector2, alwaysShowHorizontal : bool,
alwaysShowVertical : bool, horizontalScrollbar : GUIStyle, verticalScrollbar : GUIStyle,
background : GUIStyle, params options : GUILayoutOption[]) : Vector2
参数:
scrollPostion 用来显示的位置
alwaysShowHorizontal 可选的参数用来总是显示水平滚动条。如果为假或者留空,它将只
在ScrollView 中的内容比滚动视宽时显示。
alwaysShowVertical 可选的参数用来总是显示垂直滚动条。如果为假或者留空,它将只在
ScrollView 中的内容比滚动视高时显示。
horizontalScrollbar 用于水平滚动条的可选GUIStyle。如果不设置,将使用当前GUISkin 的
horizontalScrollbar。
verticalScrollbar 用于垂直滚动条的可选GUIStyle。如果不设置,将使用当前GUISken 的
verticalScrollbar 风格。
返回Vector2 – 修改过的scrollPosition。回传这个变量,如下的例子:
描述:开始一个自动布局滚动视。
自动布局滚动视,将使用任何你放置在它们中的内容并正常显示出来。如果他不适合,将显
示滚动条,BeginScrollView 的调用总是与EndScrollView 的调用匹配。
//这个变量对于空间来说就是这个滚动视查看子元素的位置。
var scrollPosition : Vector2;
//显示在滚动视中的字符串,下面两个按钮添加,清除这个字符串。
var longString = “This is a long-ish string”;
function OnGUI()
{
//开始一个滚动视,所有矩形被自动计算。
//它将使用任何可用的空间并确保内容排列正确
//这是小的最后两参数来强制滚动条出现
scrollPosition = GUILayout.BeginScrollView(scrollPosition, GUILayout.Width(100),
GUILayout.Height(100));
//添加一个简单的标签到滚动视内部。注意
//滚动条如何与文字换行正确的工作。
GUILayout.Height(longString);
//添加一个按钮来消除字符串。这个是在滚动区域内部,因此它
//也将被滚动。注意按钮如何变窄为垂直滚动条留出空间
if(GUILayout.Button(“Clear”)
longString = “”;
//结束我们上面开始的滚动条
GUILayout.EndScrollView();
//现在我们在滚动视外边添加一个按钮– 这将显示在滚动区域的下边
if(GUILayout.Button(“Add MoreText”))
{
longString += “\nHere is another line.”;
}
◆ static function Box(params option : GUILayoutOption[]) : void
◆ static function Box(style : GUIStyle, params option : GUILayoutOption[]) : void
参数
style 这个风格将用于背景图片和填充值,如果留空,背景是透明的。
options 一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将
覆盖由style 定义的设置。
参见:GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth,
GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth,
GUILayout.ExpandHeight.
描述:开始一个垂直控件组。
所有在这个元素内部渲染的空间将被一个接一个地垂直放置。改组必须调用EndVertical 关
闭。
◆ static function Box(image : Texture, params option : GUILayoutOption[]) : void
◆ static function Box(text : string, params option : GUILayoutOption[]) : void
◆ static function Box(contend : GUIContent, params option : GUILayoutOption[]) : void
◆ static function Box(image : Texture, style : GUIStyle, params option : GUILayoutOption[]) :
void
◆ static function Box(text : string, style : GUIStyle, params option : GUILayoutOption[]) : void
◆ static function Box(contend : GUIContent, style : GUIStyle, params option :
GUILayoutOption[]) : void
参数
text 显示在该box 上的文本
image 显示在该box 上的Texture
content 用于这个box 的文本,图形和提示
style 使用的风格。如果不设置,将使用当前的GUISkin 的box 风格。
options 一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将
覆盖由style 定义的设置。
参见:GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth,
GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth,
GUILayout.ExpandHeight.
描述:制作一个自动布局box
这将制作一个实心box,如果你想制作一个包含一些内容的box,使用一个子组函数的
风格参数(BeginHorizontal, BeginVertical, 等等)
◆ static function Button(image : Texture, params options : GUILayoutOption[]) : bool
◆ static function Button(text : string, params options : GUILayoutOption[]) : bool
◆ static function Button(content : GUIContent, params options : GUILayoutOption[]) : bool
◆ static function Button(image : Texture, style : GUIStyle, params options : GUILayoutOption[]) :
bool
◆ static function Button(text : string, style : GUIStyle, params options : GUILayoutOption[]) :
bool
◆ static function Button(content : GUIContent, style : GUIStyle, params options :
GUILayoutOption[]) : bool
参数
text 显示在该按钮上的文本
image 显示在该按钮上的Texture
content 用于这个按钮的文本,图形和提示。
style 使用的风格。如果不设置,将使用当前的GUISkin 的button 风格。
options 一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将
覆盖由style 定义的设置。
参见:GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth,
GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth,
GUILayout.ExpandHeight
返回bool – true 当用户单击按钮时。
描述:制作一个简单的按钮,用户点击它们的时候就会有事情发生。
◆ static functioin EndArea() : void
描述:关闭由BeginArea 开始的GUILayout 块
◆ static function EndHorizontal() : void
描述:关闭一个开始于BeginHorizontal 的组
◆ static functioin EndScrollView() : void
描述:结束由BeginScrollView 调用开始的滚动视。
◆ static functioin EndVertical() : void
描述:关闭一个开始于BeginVertical 的组
◆ static functioin ExpandHeight(expand : bool) : GUILayoutOption
描述:传递给一个空间的选项来允许或不允许垂直扩展。
◆ static functioin ExpandWidth(expand : bool) : GUILayoutOption
描述:传递给一个空间的选项来允许或不允许水平扩展。
◆ static functioin FlexibleSpace() : void
描述:插入一个灵活的空格元素
灵活的空格用来填充一个布局中任何遗漏的空间。
◆ static functioin Height(height : float) : GUILayoutOption
描述:传递给空间的选项以便给它一个绝对高度。
◆ static functioin HorizontalScrollbar(value : float, size : float, leftValue : float, rightValue : float,
params options : GUILayoutOption[]) : float
◆ static functioin HorizontalScrollbar(value : float, size : float, leftValue : float, rightValue : float,
style : GUIStyle, params options : GUILayoutOption[]) : float
参数
value 在min 和max 之间的位置
size 能看见多大?
leftValue 滚动条左端的值
rightValue 滚动条右端的值
style 用于滚动条背景的风格。如果不设置,将使用当前GUISkin 的horizontalScrollbar
options 一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将
覆盖由style 定义的设置。
参见:GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth,
GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth,
GUILayout.ExpandHeight
返回floar – 修改后的值。这可以通过拖动这个滚动条,或者单击两端的箭头来改变。
描述:一个水平滚动条。滚动条可以用来滚动文档。大多数情况下,你会使用滚动视代替。
找到额外的元素:
在滚动条两端的按钮将在当前皮肤中搜索“leftButton”和“rightButton”作为风格,滚动条的滑
块(你拖动的东西)将搜索并使用名为“thumb”的风格。
//这将使用下面的风格名来决定该按钮的尺寸/位置
//MyScrollbarleftButton - 用于左侧按钮的风格位置
//MyScrollbarrightButton - 用于右侧按钮的风格位置
//MyScrollbarthumb - 用于滑块的风格名称
scrollPos = GUILayout.HorizontalScrollbar(scrollPos, 1, 0, 100, “MyScrollbar”);
◆ static functioin HorizontalSlider(value : float, leftValue : float, rightValue : float, params
options : GUILayoutOption[]) : float
◆ static functioin HorizontalSlider(value : float, leftValue : float, rightValue : float, slider :
GUIStyle, thumb : GUIStyle, params options : GUILayoutOption[]) : float
参数
value 滑块显示的值。这个决定可拖动滑块的位置。
leftValue 滑杆左端的值。
rightValue 滑杆右边的值。
slider 用于显示拖动区域的GUIStyle。如果不设置,将使用当前GUISkin 的horizontalSlider。
thumb 用于显示拖动块的GUISkin 。如果不设置, 将使用当前的GUISkin 的
horizontalSliderThumb
options 一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将
覆盖由style 定义的设置。
参见:GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth,
GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth,
GUILayout.ExpandHeight.
返回float – 被用户设置的值。
描述:一个用户可以拖动的滑杆。可以在min 和max 之间取一个值。
◆ static function Label(image : Texture, params options : GUILayoutOption[]) : void
◆ static function Label(text : string, params options : GUILayoutOption[]) : void
◆ static function Label(content : GUIContent, params options : GUILayoutOption[]) : void
◆ static function Label(image : Texture, style : GUIStyle, params options : GUILayoutOption[]) :
void
◆ static function Label(text : string, style : GUIStyle, params options : GUILayoutOption[]) :
void
◆ static function Label(content: GUIContent, style : GUIStyle, params options :
GUILayoutOption[]) : void
参数
text 显示在该标签上的文本。
image 显示在标签上的Texture。
content 用于这个标签的文本,图形和提示。
style 使用的风格。如果不设置。将使用当前GUISkin 的label。
options 一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将
覆盖由style 定义的设置。
参见:GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth,
GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth,
GUILayout.ExpandHeight.
描述:制作一个自动布局label
标签没有用户交互。不会获取鼠标点击并总是以普通风格渲染。如果你想制作一个可视化
响应用户输出的控件,使用一个Box 控件。
◆ static function MaxHeight(maxHeight : float) : GUILayoutOption
描述:传递给控件的选项来指定一个最大高度。
◆ static function MaxWidth(maxWidth : float) : GUILayoutOption
描述:传递给控件的选项来指定一个最大宽度。
◆ static function MinHeight(minHeight : float) : GUILayoutOption
描述:传递给控件的选项来指定一个最小高度。
◆ static function MinWidth(minWidth : float) : GUILayoutOption
描述:传递给控件的选项,来指定一个最小宽度
◆ static function PasswordField(password : string, maskChar : char, params options :
GUILayoutOption[]) : string
◆ static function PasswordField(password : string, maskChar : char, maxLength : int, params
options : GUILayoutOption[]) : string
◆ static function PasswordField(password : string, maskChar : char, style : GUIStyle, params
options : GUILayoutOption[]) : string
◆ static function PasswordField(password : string, maskChar : char, maxLength : int, style :
GUIStyle, params options : GUILayoutOption[]) : string
参数
password 用于编辑的密码。这个函数返回值应该被赋回这个字符串。如下的例子。
maskChar 用来隐藏密码的字符。
maxLength 字符串的最大长度。如果不设置,用户可以一直输入。
style 使用的风格。如果不设置,将使用当前GUISkin 的textField 风格。
返回string – 编辑过的密码。
描述:制作一个用户可以输入密码的文本域。
var passwordToEdit = “My Password”;
function OnGUI()
{// 制作一个密码与来调整stringToEdit。
passwordToEdit = GUILayout.PasswordField(passwordToEdit, “*”, 25);
}
◆ static function RepeatButton(image : Texture, params options : GUILayoutOption[]) : bool
◆ static function RepeatButton(text : string, params options : GUILayoutOption[]) : bool
◆ static function RepeatButton(content : GUIContent, params options : GUILayoutOption[]) :
bool
◆ static function RepeatButton(image : Texture, style : GUIStyle, params options :
GUILayoutOption[]) : bool
◆ static function RepeatButton(text : string, style : GUIStyle, params options :
GUILayoutOption[]) : bool
◆ static function RepeatButton(content : GUIContent, style : GUIStyle, params options :
GUILayoutOption[]) : bool
参数
text 显示在该按钮上的文本。
image 显示在该按钮上的Texture。
content 用于这个按钮的文本,图形和提示。
style 使用的风格,如果不设置,将使用当前GUISkin 的button 风格。
options 一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将
覆盖由style 定义的设置。
参见:GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth,
GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth,
GUILayout.ExpandHeight.
返回bool - /true/当用户按住按钮时
描述:制作一个重复按钮,只要用户按住鼠标这个按钮一直返回真。
◆ static function SeletionGrid(selected : int, texts : string[], xCount : int, params options :
GUILayoutOption[]) : int
◆ static function SeletionGrid(selected : int, images : Texture[], xCount : int, params options :
GUILayoutOption[]) : int
◆ static function SeletionGrid(selected : int, contents : GUIContent[], xCount : int, params
options : GUILayoutOption[]) : int
◆ static function SeletionGrid(selected : int, texts : string[], xCount : int, style : GUIStyle, params
options : GUILayoutOption[]) : int
◆ static function SeletionGrid(selected : int, images : Texture[], xCount : int, style : GUIStyle,
params options : GUILayoutOption[]) : int
◆ static function SeletionGrid(selected : int, contents : GUIContent[], xCount : int, style :
GUIStyle, params options : GUILayoutOption[]) : int
参数
selected 选择按钮的索引
texts 显示在按钮的字符串数组。
images 在按钮上纹理数组
contents 用于按钮的文本,图形和提示。
xCount 在水平方向多少个元素,元素将被缩放来适应,除非风格定义了一个fixedWidth,
空间高度将由元素的数量决定。
style 使用的风格。如果不设置,将使用当前GUISkin 的button 风格。
options 一个可选的布局选项的列表,它用来指定额外的布局属性。任何在这里设置的值将
覆盖由style 定义的设置。
参见:GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth,
GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth,
GUILayout.ExpandHeight.
返回int – 选择按钮的索引
描述:制作一个选择网格
◆ static function Space(pixel : float) : void
描述:在当前布局组中插入一个空格
空格的方向依赖与使用这个命令时当前所在布局组。如果在垂直组,空格是垂直的。
function OnGUI()
{
GUILayout.Button(“I’m the first button”);
//在两个按钮间插入20 像素
GUILayout.Space(20);
}
GUILayout.Button(“I’m a bit futher down”);
}
在水平组,pixels 将是水平的;
function OnGUI()
{
//开始水平组以便显示水平空格
GUILayout.BeginHorizontal(“box”);
GUILayout.Button(“I’m the first button”);
//在两个按钮间插入20 像素
GUILayout.Space(20);
GUILayout.Button(“I’m to the right”);
//结束上面开始的水平组
GUILayout.EndHorizontal();
}
◆ static function TextArea(text : string, params options : GUILayoutOption[]) : string
◆ static function TextArea(text : string, maxLength : int, params options : GUILayoutOption[]) :
string
◆ static function TextArea(text : string, style : GUIStyle, params options : GUILayoutOption[]) :
string
◆ static function TextArea(text : string, maxLength : int, style : GUIStyle, params options :
GUILayoutOption[]) : string
参数
text 用于编辑的文本。这个函数返回值应该被赋回这个字符串。如下的例子。
maxLength 字符串的最大长度。如果不设置,用户可以一直输入。
style 使用的风格。如果不设置,则使用当前GUISkin 的textField 风格。
options 一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将
覆盖由style 定义的设置。
参见:GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth,
GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth,
GUILayout.ExpandHeight.
返回string – 编辑过的字符串。
描述:制作一个多行文本域。这里用户可以编辑这个字符串。
◆ static function TextField(text : string, params options : GUILayoutOption[]) : string
◆ static function TextField (text : string, maxLength : int, params options : GUILayoutOption[]) :
string
◆ static function TextField (text : string, style:GUIStyle, params options : GUILayoutOption[]) :
string
◆ static function TextField (text : string, maxLength : int, style : GUIStyle, params options :
GUILayoutOption[]) : string
参数
text 用于编辑的文本。这个函数返回值应该被赋回这个字符串,如下的例子。
maxLength 字符串的最大长度。如果不设置,用户可以一直输入。
style 使用的风格。如果不设置,将使用当前的GUISkin 的textArea
options 一个可选的布局选项的列表,它用来指定额外的布局属性。任何在这里设置的值将
覆盖由style 定义的设置。
参见:GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth,
GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth,
GUILayout.ExpandHeight.
返回string – 编辑过的字符串。
描述:制作一个单行文本域。这里用户可以编辑这个字符串。
var stringToEdit = “Hello, world”;
function OnGUI()
{
//制作一个文本域来调整stringToEdit
stringToEdit = GUILayout.TextField(stringToEdit, 25);
}
◆ static function Toogle(value : bool, image : Texture, params options : GUILayoutOption[]) :
bool
◆ static function Toogle(value : bool, text : string, params options : GUILayoutOption[]) : bool
◆ static function Toogle(value : bool, content : GUIContent, params options :
GUILayoutOption[]) : bool
◆ static function Toogle(value : bool, image : Texture, style : GUIStyle, params options :
GUILayoutOption[]) : bool
◆ static function Toogle(value : bool, text : string, style : GUIStyle, params options :
GUILayoutOption[]) : bool
◆ static function Toogle(value : bool, content : GUIContent, style : GUIStyle, params options :
GUILayoutOption[]) : bool
参数
value 按钮是打开或关闭
text 显示在该按钮上的文本
image 显示在该按钮上的Texture
content 用于这个按钮的文本,图形和提示
style 使用的风格。如果不设置,将使用当前GUISkin 的button 风格。
options 一个可选的布局选项的列表,它用来指定额外的布局属性。任何在这里设置的值将
覆盖由style 定义的设置。
参见:GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth,
GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth,
GUILayout.ExpandHeight.
返回bool – 按钮的新值
描述:制作一个on/off 开关按钮。
◆ static function Toolbar(selected: int, texts : string[], params options : GUILayoutOption[]) : int
◆ static function Toolbar(selected: int, images : Texture[], params options : GUILayoutOption[]) :
int
◆ static function Toolbar(selected: int, contents: GUIContent[], params options :
GUILayoutOption[]) : int
◆ static function Toolbar(selected: int, texts : string[], style : GUIStyle, params options :
GUILayoutOption[]) : int
◆ static function Toolbar(selected: int, image : Texture[],style : GUIStyle, params options :
GUILayoutOption[]) : int
◆ static function Toolbar(selected: int, content : GUIContent[],style : GUIStyle, params options :
GUILayoutOption[]) : int
参数
selected 选择按钮的索引
texts 显示在按钮上的字符串数组
images 在按钮上的纹理数组
contents 用于按钮的文本,图形和提示数组
style 使用的风格。如果不设置,将使用当前GUISkin 的button 风格。
options 一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将
覆盖由style 定义的设置。
参见:GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth,
GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth,
GUILayout.ExpandHeight.
返回int – 选择按钮的索引
描述:制作一个工具栏
◆ static function VerticalScrollbar(value: float, size : float, topValue : float, buttomValue : float,
params options : GUILayoutOption[]) : float
◆ static function VerticalScrollbar(value: float, size : float, topValue : float, buttomValue : float,
style : GUIStyle, params options : GUILayoutOption[]) : float
参数
value 在min 和max 之间的位置
size 能看见多大?
topValue 滚动条顶端的值
bottomValue 滚动条底端的值
style 用于滚动条背景的风格。如果不设置,将使用当前GUISkin 的horizontalScrollbar。
options 一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将
覆盖由style 定义的设置。
参见:GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth,
GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth,
GUILayout.ExpandHeight.
返回float – 修改后的值。这可以通过拖动这个滚动条,或者单击两端的箭头来改变。
描述:制作一个垂直滚动条。滚动条可以用来滚动文档。大多数情况下,你会使用scollView
代替。
找到额外的元素:
在滚动条两端的按钮将在当前皮肤中搜索“upbutton”和“downbutton”作为风格。滚动条的滑
块(你拖动的东西)将搜索并使用名为thumb 的风格。
//这将使用下面的风格名来决定该按钮的尺寸/位置
//MyVerticalScrollbarupbutton – 用于顶端按钮的风格名称
//MyVerticalScrollbardownbutton – 用于底端按钮的风格名称
//MyScrollbarthumb – 用于滑块的风格名称
scrollPos = GUILayout.HorizontalScrollbar(scrollPos, 1, 0, 100, “MyVerticalScrollbar”);
◆ static function VerticalSlider(value : floar, leftValue : float, rightValue : float, params options :
GUILayoutOption[]) : float
◆ static function VerticalSlider(value : floar, leftValue : float, rightValue : float, slider : GUIStyle,
thumb : GUIStyle, params options : GUILayoutOption[]) : float
参数
value 滑杆显示的值。这个决定可拖动滑块的位置。
topValue 滑杆顶端的值。
downValue 滑杆底端的值。
slider 用于显示拖动区域的GUIStyle。如果不设置,将使用当前GUISkin 的horizontalSlider。
thumb 用于显示拖动块的GUIStyle 。如果不设置, 将使用当前的GUISkin 的
horizontalSliderThumb。
options 一个可选的布局选项的列表,它用来指定额外的布局属性。任何在这里设置的值将
覆盖由style 定义的设置。
参见:GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth,
GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth,
GUILayout.ExpandHeight.
◆ static function Width(width : float) : GUILayoutOption
描述:传递给控件的选项以便给它一个绝对宽度
◆ static function Window(id : int, screenRect : Rect, func : GUIWindowFunction, text : string) :
Rect
◆ static function Window(id : int, screenRect : Rect, func : GUIWindowFunction, image :
Texture) : Rect
◆ static function Window(id : int, screenRect : Rect, func : GUIWindowFunction, content :
GUIContent) : Rect
◆ static function Window(id : int, screenRect : Rect, func : GUIWindowFunction, text : string,
style : GUIStyle) : Rect
◆ static function Window(id : int, screenRect : Rect, func : GUIWindowFunction, image :
Texture, style : GUIStyle) : Rect
◆ static function Window(id : int, screenRect : Rect, func : GUIWindowFunction, content :
GUIContent, style : GUIStyle) : Rect
参数
id 用于每个窗口唯一的ID。这是用于接口的ID。
clientRect 屏幕上用于窗口的矩形区域。布局系统将试图使窗体在他内部。如果不能,它将
调整矩形去适应它
func 在窗体内部创建GUI 的函数。这个函数必须使用一个函数– 当前创建GUI 的窗体id。
image 用于在标题栏上显示图片的Texture。
content 用于这个窗口的文本,图形和提示。
style 使用的风格。如果不设置,将使用当前GUISkin 的button 风格。
options 一个可选的布局选项的列表,它用来指定额外的布局属性。任何在这里设置的值将
覆盖由style 定义的设置。
参见:GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth,
GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth,
GUILayout.ExpandHeight.
返回Rect – 窗口位于举行位置。这个可能与你传入的一个具有不同位置和尺寸。
描述:制作一个弹出窗口。它的内容是自动布局的。
窗口浮动在普通GUI 控件之上。具有单击激活的特点并可以有选择的随意被用户拖动。不
像其他的控件,你需要传递给他们一个独立的功能并放置在窗口中这儿是一个小例子来帮助
你开始:
var windowRect = Rect(20, 20, 120, 50);
function OnGUI()
{
//注册窗口,注意第三个参数
windowRect = GUILayout.Window(0, windowsRect, DoMyWindow, “My Window”);
}
//制作窗口内容
function DoMyWindow(windowed : int)
{
//这个按钮将调整以适应物体
if(GUILayout.Button(“Hello World”))
print(“Get a click”);
}
你传入的客户区域只是作为一个参考,为了对窗口使用额外的限制。闯入一些额外的布局选
项。用在这里的一个将覆盖尺寸的计算。这是一个简单的例子。
var windowRect = Rect(20, 20, 120, 50);
function OnGUI()
{
//注册窗口,这里我们指示布局系统必须使窗体为100 像素宽。
windowRect = GUILayout.Window(0, windowRect, DoMyWindow, “My Window”,
GUILayout.width(100));
}
//制作窗体内容
function DoMyWindow(windowID : int)
{
//这个按钮大小不能适应这个窗体
//通常,这个窗体将被扩展以便适应这个按钮。但是由于GUILayout.Width 将只允//许窗体为
100 像素宽
if(GUILayout.Button(“Please click me a lot”))
print(“Get a click”);
}
GUISettings

用于GUI 如何表现的通用设置。
这些被所有在GUISkin 中的元素共享。
变量
◆ var cursorColor : Color
描述:文本域中光标的颜色。
◆ var cursorFlashSpeed : float
描述:文本域指示的闪动速度。
这个是闪动/秒。如果设置为0,闪动将被禁用。如果设置为-1,闪动速度将匹配系统的默
认速度。
◆ var doubleClickSelectsWord : bool
描述:文本域中双击是否选择单词。
◆ var selectionColor : Color
描述:文本域中选择矩形的颜色。
◆ var tripleClickSelectsLine : bool
描述:文本域中点击鼠标三次是否选择整行文本。
GUIStyleState

为GUIStyle 物体使用的给定状态的一个特定值。
GUIStyle 包含用于显示GUI 元素的所有值
变量
◆ var background : Texture2D
描述:在这个状态中被GUI 元素使用的背景图片。
◆ var textColor : Color
描述:在这个状态中被GUI 元素使用的文本颜色。
GUIStyle

GUI 元素的风格位置
这个类包含一个GUI 元素如何被渲染的所有信息。它包含用于字体,图标位置,背景图标,
和间距的信息。它不包含关于它包含什么的信息– 仅仅定义用这个风格渲染的文本如何被
显示。它不定义这个元素可以发生什么交互,但是定义了用于交互的显示设置。
一个GUIStyle 的设置。这是模仿一个CSS 样式。它包含下列事项的设置:
背景图片
这些被渲染在空间后面。不同的图像可以被指定为正常显示。当用户将鼠标放在元素上时
的显示,当使用者按下选择– 以及当元素被打开,如触发按钮,下面的这些都被称为风格
的状态。参见:normal, hover, active, onNormal, onHover, onActive – 这些包含每个状态的背
景图片,文本颜色属性。
文本渲染
这个风格都可以定义一个字体渲染,以及文本对齐,换行和剪裁的设置,它也定了该风格
元素不同状态的文本颜色参考: font, alignment, wordWrap, normal, hover, active, onHover,
onActive
图标位置
GUIStyle 可以渲染文本,图标或者两者兼而有之。GUIStyle 定义渲染时这两者间的相关位
置(这可以强制它只显示他们其中之一)。参见:imagePosition
尺寸和间距选项
GUIStyle 包含填充,边缘和边界。这些不严格地对应类似命名的CSS 属性。一个GUIStyle
可以选择的定义一个固定的宽度和高度。参见: margin, padding, border, fixedWidth,
fixedHieght
变量
◆ var active : GUIStyleState
描述:空间被按下时的渲染设置。
◆ var alignment : TextAnchor
描述:文本对齐
◆ var border : RectOffset
描述:所有背景图片的边界。
这个对应于GUITexture 的边界设置。它只影响渲染的背景图像,不影响定位。
◆ var clipOffset : Vector2
描述:用于该GUIStyle 内容的剪裁偏移。
◆ var clipping : TextClipping
描述:当渲染的内容相对于给定的区域太大时做什么
◆ var contentOffset : Vector2
描述:用于该GUIStyle 内容的像素偏移。
◆ var fixedHeight : float
描述:如果非0,任何用这个风格渲染的GUI 元素将有这里指定的高度。
◆ var fixedWidth : float
描述:如果非0,任何用这个风格渲染的GUI 元素将有这里指定的宽度。
◆ var focused : GUIStyleState
描述:元素获得键盘焦点时的渲染设置。
◆ var font : Font
描述:用于渲染的字体。如果null,当前的GUISkin 的默认字体将被使用。
◆ var hover : GUIStyleState
描述:鼠标悬停在控件时的渲染设置。
◆ var imagePosition : ImagePosition
描述:GUIContent 的图片和文本如何组合。
◆ var lineHeight : float
描述:这个风格一行文本的高度。以像素为单位。(只读)
◆ var margin : RectOffset
描述:以这种风格渲染的元素和任何其他GUI 元素之间的边界。
这个只影响自动布局。(参见: GUILayout)
◆ var name : string
描述:GUIStyle 的名称。用来基于名称获取它们。
◆ var normal : GUIStyleState
描述:组建正常显示是渲染设置。
◆ var onActive : GUIStyleState
描述:元素被打开并具有键盘焦点时的渲染设置。
◆ var onFocused : GUIStyleState
描述:元素被打开并被按下时的渲染设置。
◆ var onHover : GUIStyleState
描述:控件被打开并且鼠标悬停在它上面时的渲染设置
◆ var onNormal : GUIStyleState
描述:控件被打开时的渲染设置。
◆ var overflow : RectOffset
描述:添加到背景图片的额外间距。
这可用于如果你的图片要投射一个阴影,并且向扩展背景图片超出使用这个风格的制定
GUI 元素的矩形时。
◆ var padding : RectOffset
描述:从GUIStyle 边界到内容开始的间距
◆ var stretchHeight : bool
描述:这个风格的GUI 元素可以被垂直拉伸以便更好的布局么?
◆ var stretchWidth : bool
描述:这个风格的GUI 元素可以被水平拉伸以便更好的布局么?
◆ var wordWrap : bool
描述:文本换行?
这将导致任何包含的文本被换行以便适应控件的宽度。
构造函数
◆ static function GUIStyle() : GUIStyle
描述:
◆ static function GUIStyle(other:GUIStyle) : GUIStyle
描述:
函数
◆ function CalcHeight(content : GUIContent, width : float) : float
描述:当渲染content 并制定width 时这个元素的高度。
◆ function CalcMinMaxHeight (content : GUIContent, outminWidth : float, outmaxWidth :
float) : void
描述:计算以这个风格渲染的content 的最大最小宽度。
被GUILayout 使用来正确处理换行。
◆ function CalcScreenSize(contentSize : Vector2) : Vector2
描述:计算用这个风格格式化的元素的尺寸,和一个给定的内容空格。
◆ function CalcSize(content : GUIContent) : Vector2
描述:如果内容使用这个风格渲染,计算某些内容的尺寸。
这个函数不考虑换行。要做到这点,你需要确定宽度,然后打调用CalcHeight 分配计算出
wordwrapped 高度。
◆ function Draw(position : Rect, isHover: bool, isActive : bool, on : bool, hasKeyboardFocus :
bool) : void
描述:
◆ function Draw(position : Rect, text : string, isHover: bool, isActive : bool, on : bool,
hasKeyboardFocus : bool) : void
描述:用GUIStyle 绘制一个文本字符串。
◆ function Draw(position : Rect, image : Texture, isHover: bool, isActive : bool, on : bool,
hasKeyboardFocus : bool) : void
描述:用GUIStyle 绘制图片。如果图片太大,它将被缩小。
◆ function Draw(position : Rect, content : GUIContent, isHover: bool, isActive : bool, on : bool,
hasKeyboardFocus : bool) : void
描述:用GUIStyle 绘制文本和图片。如果图片太大,它将被缩小。
◆ function Draw(position : Rect, content : GUIContent, controlID : int, on : bool = false) : void
描述:GUI 代码中使用的主要绘制函数。
◆ function DrawCursor(position : Rect, content : GUIContent, controlID : int, Character : int) :
void
描述:用选定的内容绘制这个GUIStyle
◆ function DrawWithTextSelection(position : Rect, content : GUIContent, controlID : int,
firstSelectedCharacter : int, lastSelectedCharacter : int) : void
描述:用选定的内容绘制这个GUIStyle
◆ function GetCursorPixelPosition(position : Rect, content : GUIContent, cursorStringIndex :
int) : Vector2
描述:获取给定字符串索引的像素位置。
◆ function GetCursorStringIndex(postion : Rect, content : GUIContent, cursorPixelPosition :
Vector2) : int
描述:当用户在cursorPixelPosition 处点击时获取光标位置(索引到内容文本)这部计算内
容中任何图片。
类变量
◆ static var none : GUIStyle
描述:空GUIStyle 的快捷方式。
这个风格不包含装饰而仅仅以缺省字体渲染所有东西。
function OnGUI()
{ //制作一个没有装饰的按钮
GUI.Button(“I’m very bare”, GUIStyle.none);
}
类方法
◆ static implicit function GUIStyle(str : string) : GUIStyle
描述:从当前皮肤获取一个名为GUI 风格。
GUIUtility

用于制作新GUI 空间的工具类。
除非从头开始创建自己的GUI 控件,否则你不需要使用这些函数。
类变量
◆ static var hotControl : int
描述:当前具有特点的控件controlID。
热点空间是临时激活的一个控件。当用于在一个按钮上按下鼠标时,它变为热点。当一个
控件具有热点时,其他控件不允许响应鼠标事件。一旦用户鼠标示范,这个控件设置
hotControl 为0 以便表明其他控件可以响应用户输入。
◆ static var keyboardControl : int
描述:具有键盘焦点控件的controlID。
类方法
◆ static function GetControlID(focus : FocusType) : int
◆ static function GetControlID(hint : int, focus : FocusType) : int
◆ static function GetControlID(content : GUIContent, focus : FocusType) : int
描述:为一个控件获取唯一ID。
◆ static function GetControlID(focus : FocusType, position : Rect) : int
◆ static function GetControlID(hint : int, focus : FocusType, position : Rect) : int
◆ static function GetControlID(content : GUIContent, focus : FocusType, position : Rect) : int
描述:为一个控件获取唯一ID。
◆ static function GetStateObject(t : type, controlID : int) : object
描述:从一个controlID 获取一个状态对象。
这将返回一个可重用的状态对象,它的controlID 是唯一的。如果没有,一个新的将被创建
并添加到ControlID。
◆ static function GUIToScreenPoint(guiPoint : Vector2) : Vector2
描述:将一个点从GUI 位置转化为屏幕空间。
参见:GUIUtility, ScreenToGUIPoint
◆ static function MoveNextAndScroll(forward: bool) : void
描述:只允许从OnGUI 内部调出GUI 函数
◆ static function QueryStateObject(t: Type, controlID : int) : object
描述:从一个controlID 获取一个存在的状态物体。
这个返回一个可回收的状态物体。这个物体具有唯一的controlID。如果没有,这个函数将
返回null。
◆ static function RotateAroundPivot(angle: float, pivotPoint : Vector2) : void
描述:使GUI 围绕一个点旋转的辅助函数。
修改GUI.matrix 来绕着pivotPoint 旋转所有的GUI 元素angel 度。
参见:GUI.matrix, ScaleAroundPivot
◆ static function ScaleAroundPivot(scale: Vector2, pivotPoint: Vector2) : void
描述:使GUI 围绕一个点缩放的辅助函数。
修改GUI,.matrix 来绕着pivotPoint 缩放所有的GUI 元素angel 度。
参见:GUI.matrix, RotateAroundPivot
◆ static function ScreenToGUIPoint(screenPoint : Vector2) : object
描述:将一个点从屏幕空间转化为GUI 位置。
用于反转计算GUIToScreenPoint 的值。
参见:GUIUtility.GUIToScreenPoint。
GUI

GUI 类是Unity GUI 的手工定位接口
参见:GUI tutorial
类变量
◆ static var backgroundColor : Color
描述:全局的修改由GUI 渲染的所有元素的背景颜色。
这个获取多个color。
参见:contentColor, color
◆ static var changed : bool
描述:有任何控件的输入数据改变吗?
◆ static var color : Color
描述:全局的修改GUI 颜色。
这将影响背景和文本颜色。
参见:backgroundColor, contentColor
◆ static var contentColor : Color
描述:修改由GUI 渲染的所有文本的颜色。
这个获取多个color。
参见:backgroundColor : Color
◆ static var depth : int
描述:当前执行的GUI 行为的排序深度
当你有不同的脚本同时运行时。设置这个来决定顺序。
◆ static var enabled : bool
描述:GUI 启用了?
设置这个值为假将禁用所有GUI 交互。所有的控件将以半透明方式绘制。并将不响应用户
输入。
//这个值跟踪扩展的选项是否可以被打开。
var allOptions = true;
//两个扩展选项
var extended1 = true;
var extended2 = true;
function OnGUI()
{
//制作一个开关控件以便允许用户编辑扩展的选项
allOptions = GUI.Toogle(Rect(0, 0, 150, 20), allOptions, “Edit All Options”);
//将它的值赋给GUIEnabled – 如果上面的复选框被禁用
//这些GUI 元素将
GUIenabled = allOptions
//这两个控件只在上面的按钮为On 时启用。
extended1 = GUI.Toogle(Rect(20, 20, 130, 20), extended1, “Extended Option 1”);
extended2 = GUI.Toogle(Rect(20, 40, 130, 30), extended2, “Extended Option 2”);
//使用条件语句,以使GUI 代码可以再次启用
GUI.enabled = true;
//制作一个OK 按钮
if(GUI.Button(Rect(0, 60, 150, 20), “OK”))
print(“user clicked ok”);
}
◆ static var matrix : Matrix4x4
描述:GUI 变换矩阵
◆ static var skin : GUISkin
描述:使用的全局皮肤
你可以在任何时候设置这个来改变GUI 的外观。如果设置为null,这个皮肤将使用默认的
Unity 皮肤。
◆ static var tooltip : string
描述:鼠标移动到空间上的提示信息(只读)。
创建GUI 空间是。你可以给他传递一个提示。这可以通过改变内容参数来制作一个自定义
GUIContent 物体,而不是仅仅传递一个字符串。
但鼠标经过带有提示性的控件时,它设置全局的GUI.tooltip 值为传入得知。在OnGUI 代
码的末端,你可以制作一个标签来显示GUI.tooltip 的值。
function OnGUI()
{
//制作一个按钮,它使用自定义GUI.Content 参数来传递提示。
GUI.Button(Rect(10, 10, 100, 20), GUIContent(“Click me”, “This is the tooltip”));
//显示鼠标指向或具有键盘焦点的控件提示
GUI.Button(Rect(10, 55, 100, 20), “No tooltip here”);
}
你可以使用元素的次序来创建’层次化的’提示
function OnGUI()
{
//这个box 比随后的许多元素大,并且它有一个提示。
GUI.Box(Rect(5, 35, 110, 75), GUIContent(“Box”, “this box has a tooltip”));
这个按钮在box 内部,但是没有提示,因此它不会覆盖这个box 的提示。
GUI.Button(Rect(10, 55, 100, 20), “No tooltip here”);
这个按钮在box 内部,并且有一个提示,因此它会覆盖这个box 的提示。
GUI.Button(Rect(10, 80, 100, 20), GUIContent(“I have a tooltip”, “This button overrides the
box”));
//最后,显示来自鼠标指向或具有键盘焦点的提示
GUI.Label(Rect(10, 40, 100, 40), GUI.tooltip);
}
Tooltip 也能用来实现一个OnMouseOver/OnMouseOut 消息系统:
var lastTooltip = “”;
function OnGUI()
{
GUILayout.Button(GUIContent(“Play Game”, “Button1”));
GUILayout.Button(GUIContent(“Quit”, “Button2”));
if(Event.current.type == EventType.repaint && GUI.tooltip! = lastTooltip)
{
if(lastTooltip != “”)
SendMessage(lastTooltip + “OnMouseOut”, SendMessageOptions, DontRequireReceiver);
if(GUI.tooltip != “”)
SendMessage(GUI.tooltip + “OnMouseOut”, SendMessageOptions, DontRequireReceiver);
lastTool\tip = GUI.tooltip;
}
}
类方法
◆ static function BeginGroup(position : Rect) : void
◆ static function BeginGroup(position : Rect, text : string) : void
◆ static function BeginGroup(position : Rect, image : Texture) : void
◆ static function BeginGroup(position : Rect, content : GUIContent) : void
◆ static function BeginGroup(position : Rect, style : GUIStyle) : void
◆ static function BeginGroup(position : Rect, text : string, style : GUIStyle) : void
◆ static function BeginGroup(position : Rect, image : Texture, style : GUIStyle) : void
◆ static function BeginGroup(position : Rect, content : GUIContent, style : GUIStyle) : void
参数
position 屏幕用于组的矩形区域。
text 显示在该组上的文本。
image 显示在该组上的Texture。
content 用于这个组的文本,图形和提示。如果提供,任何鼠标点击被组捕获,并且如果没
有设置,不会渲染背景,和传递鼠标点击。
style 用于背景的风格。
描述:
开始组,必须与EndGroup 调用匹配。
当你开始一个组时,用于GUI 控件的坐标系统被设置为(0, 0)是组的左上角。所有控件被附
加到组。组可以嵌套– 如果使用,子被附加到他们的父。
当你在屏幕上移动一组GUI 元素是这是非常有用的。一个普通的用法是设计你的菜单以适
合一个特定的屏幕的尺寸。然后在更大的显示器上居中显示GUI。
function OnGUI()
{
//约束所有的绘图在屏幕中心800*600 的区域
GUI.BeginGroup(new Rect(Screen.width / 2 – 400, Screen.height / 2 – 300, 800, 600));
//在由BeginGroup 定义的新坐标空间中绘制一个box
//注意,现在(0,0)已经被移动了
GUI.Box(new Rect(0, 0, 800, 600), “This box is new centered! – Here you would put your main
menu”);
//需要用一个EndGroup 来匹配所有的BeginGroup 调用。
GUI.EndGroup();
}
参见:matrix, BeginScrollView
◆ static function BeginScrollView(position : Rect, scrollPostion: Vector2, viewRect : Rect) :
Vector2
◆ static function BeginScrollView(position : Rect, scrollPostion: Vector2, viewRect : Rect,
alwaysShowHorizontal : bool, alwaysShowVertical : bool) : Vector2
◆ static function BeginScrollView(position : Rect, scrollPostion: Vector2, viewRect : Rect,
horizontalScrollbar : GUIStyle, verticalScrollbar : GUIStyle) : Vector2
◆ static function BeginScrollView(position : Rect, scrollPostion: Vector2, viewRect : Rect,
alwaysShowHorizontal : bool, alwaysShowVertical : bool, horizontalScrollbar : GUIStyle,
verticalScrollbar : GUIStyle) : Vector2
参数
position 屏幕上用了ScrollView 的矩形区域
scrollPosition 用来显示的位置。
viewRect 用在滚动视内部的矩形。
alwaysShowHorizontal 可选的参数用来总是显示水平滚动条。如果为假或不设置,它只在
clientRect 比position 宽的时候显示
alwaysShowVertical 可选的参数用来总是显示垂直滚动条。如果为假或不设置,它只在
clientRect 比position 长的时候显示。
horizontalScrollbar 用于水平滚动条的可选GUIStyle,如果不设置,将使用当前GUISkin 的
horizontalScrollbar.
verticalScrollbar 用于水平滚动条的可选GUIStyle,如果不设置,将使用当前GUISkin 的
verticalScrollbar.
返回Vector2 – 修改过的scrollPosition 回传这个变量。如下的例子。
描述:在你的GUI 中开始滚动视。
ScrollViews 让你在屏幕上制作一个较小的区域。使用放置在ScrollView 边上的滚动条来查
看一个较大的区域。
//滚动视口的位置
var smallPosition = Vector2.zero;
function OnGUI()
{
//一个绝对位置的例子。制作一个具有较大区域的滚动视。
//并将它放置在一个小的矩形中。
scrollPosition = GUI.BeginScrollView(Rect(10, 300, 100, 100), scrollPosition, Rect(0, 0, 220,
200));
//制作四个按钮– 每个角上有一个,由BeginScrollView 最后一个参数定义的坐标系统。
GUI.Button(Rect(0, 0, 100, 20), “Top-left”);
GUI.Button(Rect(0, 0, 100, 20), “Top-right”);
GUI.Button(Rect(0, 0, 100, 20), “Bottom-left”);
GUI.Button(Rect(0, 0, 100, 20), “Bottom-right”);
//结束前面开始滚动视
GUI.EndScrollView();
}
◆ static function Box(position : Rect, text : string) : void
◆ static function Box(position : Rect, image : Texture) : void
◆ static function Box(position : Rect, content : GUIContent) : void
◆ static function Box(position : Rect, text : string, style : GUIStyle) : void
◆ static function Box(position : Rect, image : Texture, style : GUIStyle) : void
◆ static function Box(position : Rect, content : GUIContent, style : GUIStyle) : void
参数
position 屏幕上用于box 的矩形区域
text 显示在该box 上的文本
image 显示在该box 上的Texture
content 用于这个box 的文本,图形和提示
style 使用的风格。如果不设置,将使用当前GUISkin 的box 风格。
描述:制作一个图形box。
◆ static function BringWindowToBack(windowID: int) : void
参数
windowID 在window 调用中创建窗体时使用的唯一标识。
描述:将特定的窗口放到浮动窗口的后面。
◆ static function BringWindowToFront(windowID: int) : void
参数
windowID 在Window 调用中创建窗体时使用的唯一标识。
描述:将特定的窗口放到浮动窗口的前面。
◆ static function Button(position : Rect, text : string) : bool
◆ static function Button(position : Rect, image : Texture) : bool
◆ static function Button(position : Rect, content : GUIContent) : bool
◆ static function Button(position : Rect, text : string, style : GUIStyle) : bool
◆ static function Button(position : Rect, image : Texture, style : GUIStyle) : bool
◆ static function Button(position : Rect, content : GUIContent, style : GUIStyle) : bool
参数
position 屏幕上用于按钮的矩形区域
text 显示在该按钮上的文本
image 显示在该按钮上的Texture
content 用于这个按钮的文本,图形和提示
style 使用的风格。如果不设置,将使用当前GUISkin 的button 风格。
返回bool - /true/当用户单击按钮时
描述:制作一个简单的按钮,用户点击它们的时候,就会有些事情发生。
◆ static function DragWindow(position : Rect) : void
参数
position 可以拖动的窗口部分。这个被附加到实际窗口。
描述:让窗口可拖动。
插入这个函数的在你的窗口代码中使窗口可拖动。
var windowRect = Rect(20, 20, 120, 50);
function OnGUI()
{
//注册窗体
windowRect = GUI.Window(0, windowRect, DoMyWindow, “My Window");
}
//制作窗体内容
function DoMyWindows(windowID : int)
{
//制作一个非常长的矩形,高20 像素。
//这将使得窗口可以调整大小,通过顶部的标题栏– 不管它有多宽。
GUI.DragWindow(Rect(0, 0, 10000, 20));
}
◆ static function DragWindow() : void
如果你想将整个窗体背景作为一个可拖动区域,不使用参数并将DragWindow 放置到整体
函数的最后。
这意味着任何其他类型的控件将首先被处理并且拖动将只在没有其他控件获得焦点时使
用。
◆ static function DrawTexture(position : Rect, image : Texture, scaleMode : ScaleMode =
stretchToFill, alphaBlend : bool = true, imageAspect : float = 0) : void
参数
position 在屏幕上绘制一个内部包含有纹理的矩形。
image 需要被绘制的纹理。
scaleMode 定义了当矩形的长宽比和内部图像的长宽比不同时如何缩放图像。
alphaBlend 定义了alpha 值是否参与图像的混合(默认为真)。如果为假,图像将会被绘
制并显示。
imageAspect 源图像的的长宽比。如果是0(默认值),则使用图像自身的长宽比。
描述:在一个矩形内部绘制一个纹理。
参见:GUI.color, GUI.contentColor
◆ static function EndGroup() : void
描述:结束一个组
参见:BeginGroup()。
◆ static function EndScrollView : void
描述:结束一个由BeginScrollView 开始的滚动视。
◆ static function FocusControl(name : string) : void
描述:把键盘焦点转移到定义的控件。
参见:SetNextControlName, GetNameOfFocusedControl。
var username = "username";
function OnGUI ()
{ // 设置一个文本域中内部名称
GUI.SetNextControlName ("MyTextField");
// Make the actual text field.
username = GUI.TextField (Rect (10,10,100,20), username);
// If the user presses this button, keyboard focus , will move.
if (GUI.Button (Rect (10,40,80,20), "Move Focus"))
GUI.FocusControl ("MyTextField");
}
◆ static function FocusWindow(windowID : int) : void
参数:
windowID 当调用Window 而创建的窗口的标识符。
描述:使一个窗口被激活。
参见:GUI.UnfocusWindow
◆ static function GetNameOfFocusedControl() : string
描述:返回当前激活的控件的名字。控件的名字是由SetNextControlName 函数创建的。当
有名字的控件被激活时,函数返回它的名字;否则的话返回一个空字符串。
var login = "username";
var login2 = "no action here";
function OnGUI ()
{
GUI.SetNextControlName ("user");
login = GUI.TextField (Rect (10,10,130,20), login);
login2 = GUI.TextField (Rect (10,40,130,20), login2);
if (Event.current.Equals (Event.KeyboardEvent ("return")) &&
GUI.GetNameOfFocusedControl () == "user")
{
Debug.Log ("Login");
}
if (GUI.Button (new Rect (150,10,50,20), "Login"))
Debug.Log ("Login");
}
参见:SetNextControlName, FocusControl
login2 = GUI.TextField(new Rect(10, 40, 130, 20), login2);
if(Event.current.Equals(Event.KeyboardEvent.(“return”))&&GUI.GetNameOfFocusedControl()
== “user”)
Debug.log(“Login”);
if(GUI.Button(new Rect(150, 10, 50, 20), “Login”))
Debug.log(“Login”);
}
参见:SetNextControlName
◆ static function HorizontalScrollbar(position : Rect, value : float, size : float, leftValue : float,
rightValue : float) : bool
◆ static function HorizontalScrollbar(position : Rect, value : float, size : float, leftValue : float,
rightValue : float, style : GUIStyle) : bool
参数
position 屏幕上用于滚动条的矩形区域
value 在min 和max 之间的位置
size 能看见多大?
leftValue 滚动条左边的值
rightValue 滚动条右边的值
style 用于滚动条背景的风格。如果不设置,将使用当前GUISkin 的horizontalScrollbar。
返回float – 修改后的值。这可以通过拖动这个滚动条,或者单击两端的箭头来改变。
描述:制作一个水平滚动条。滚动条可以用来滚动文档。大多数情况下,你会使用scrollViews
代替。
找到额外的元素:
在滚动条两端的按钮将在当前皮肤中搜索”leftbutton”和”rightbutton”作为风格。滚动条的滑
块(你拖动的东西)将搜索并使用名为“thumb”的风格。
//这将使用下面的风格名来决定该按钮的尺寸/位置
//MyScrollbarrightbutton – 用于左侧按钮的风格名称
//MyScrollbarleftbutton – 用于右侧按钮的风格名称
//MyScrollbarthumb – 用于滑块的风格名称
scrollPos = HoriztontalScrollbar(Rect(0, 0, 100, 20), scrollPos, 1, 0, 100, “My Scrollbar”);
◆ static function HorizontalSlider(position : Rect, value : float, leftValue : float, rightValue :
float) : float
◆ static function HorizontalSlider(position : Rect, value : float, leftValue : float, rightValue :
float, slider : GUIStyle, thumb : GUIStyle) : float
参数
position 屏幕上用于滑杆的矩形区域
value 滑杆显示的值。这个决定可拖动的位置。
leftValue 滑杆左边的值
rightValue 滑杆右边的值
slider 用于显示拖动区域的GUIStyle 。如果不设置, 将使用当前GUISkin 的
horizontalSlider。
thumb 用于显示拖动块的GUIStyle 。如果不设置, 将使用当前GUISkin 的
horizontalSliderThumb。
返回float – 被用户设置的值。
描述:一个用户可以拖动的滑杆。可以在min 和max 只见改变一个值。
◆ static function Label(position : Rect, text : string) : void
◆ static function Label(position : Rect, image : Texture) : void
◆ static function Label(position : Rect, content : GUIContent) : void
◆ static function Label(position : Rect, text : string, style : GUIStyle) : void
◆ static function Label(position : Rect, image : Texture, style : GUIStyle) : void
◆ static function Label(position : Rect, content : GUIContent, style : GUIStyle) : void
参数
position 屏幕上用于标签的矩形区域
text 显示在该标签上的文本
image 显示在该标签上的Texture
content 用于这个标签的文本,图形和提示
style 使用的风格。如果不设置,将使用当前GUISkin 的label
描述:在屏幕上制作一个文本或者纹理标签.
标签没有用户交互,不会获取鼠标点击并总是以普通风格渲染。如果你想制作一个可视化
响应用户输入的控件,使用一个Box 控件。
例如:绘制一个传统的Hello world 字符串
function OnGUI
{
GUI.Label(Rect(10, 10, 100, 20), “Hello world”);
}
例如:在屏幕上绘制一个纹理。标签也用于显示纹理,而不仅是字符串。简单传递一个纹
理。
var textureToDisplay : Texture2D;
function OnGUI()
{
GUI.Label(Rect(10, 40, textureToDisplay.width, textureToDiplay.height), textureToDisplay);
}
◆ static function PasswordField(position : Rect, password : string, markChar : char) : string
◆ static function PasswordField(position : Rect, password : string, markChar : char,
maxLength : int) : string
◆ static function PasswordField(position : Rect, password : string, markChar : char, style :
GUIStyle) : string
◆ static function PasswordField(position : Rect, password : string, markChar : char, markChar :
char, style : GUIStyle) : string
参数
position 屏幕上用于文本的矩形区域
password 用于编辑的密码。这个函数返回值应该被赋回这个字符串。如下的例子。
markChar 用来隐藏密码的字符。
maxLength 字符串的最大长度。如果不设置,用户可以一直输入。
style 使用的风格。不过不设置,将那个使用当前GUISkin 的textField 风格。
返回string – 编辑过的密码
描述:制作一个用户可以输入密码的文本域。
var passwordToEdit = “My Password”;
function OnGUI()
{
//制作一个文本来调整stringToEdit。
passwordToEdit = GUI.PasswordField(Rect(10, 10, 200, 20), passwordToEdit, “*”, 25);
}
◆ static function RepeatButton(position : Rect, text : string) : bool
◆ static function RepeatButton(position : Rect, image : Texture) : bool
◆ static function RepeatButton(position : Rect, content : GUIContent) : bool
◆ static function RepeatButton(position : Rect, text : string, style : GUIStyle) : bool
◆ static function RepeatButton(position : Rect, image : Texture, style : GUIStyle) : bool
◆ static function RepeatButton(position : Rect, content : GUIContent, style : GUIStyle) : bool
参数
position 屏幕上用于按钮的矩形区域
text 显示在该按钮上的文本
image 显示在该按钮上的Texture
content 用于这个按钮的文本,图形和提示
style 使用的风格。不过不设置,将那个使用当前GUISkin 的button 风格。
返回bool - /true/当用户单击按钮时。
描述:制作一个按钮。当用户按住它时一直是激活的。
◆ static function ScrollTo(position : Rect) : void
描述:滚动所有包含在scrollview 中的数据以便position 可见。
◆ static function SelectionGrid (position : Rect, selected : int, texts : string[], xCount : int) : int
◆ static function SelectionGrid (position : Rect, selected : int, images : Texture[], xCount : int) :
int
◆ static function SelectionGrid (position : Rect, selected : int, content : GUIContent[], xCount :
int) : int
◆ static function SelectionGrid (position : Rect, selected : int, texts : string[], xCount : int, style :
GUIStyle) : int
◆ static function SelectionGrid (position : Rect, selected : int, images : Texture[], xCount : int,
style : GUIStyle) : int
◆ static function SelectionGrid (position : Rect, selected : int, content : GUIContent[], xCount :
int, style : GUIStyle) : int
参数
position 屏幕上用于网格的矩形区域。
selected 选择的网格按钮的索引
texts 显示在网格按钮上的字符串数组
images 显示在网格按钮上的纹理数组
contents 用于这个网格按钮的文本,图形和提示数组
xCount 在水平方向有多少个像素。空间将被缩放来适应,除非风格定义了一个fixWidth。
style 使用的风格。如果不设置,将使用当前GUISkin 的button 风格。
返回int – 选择按钮的索引。
描述:制作一个按钮网络。
◆ static function SetNextControlName(name : string) : void
描述:设置下一个控件的名称。
这是接下来的控件被注册。
◆ static function TextArea(position : Rect, text : string) : string
◆ static function TextArea(position : Rect, text : string, maxLength : int) : string
◆ static function TextArea(position : Rect, text : string, style : GUIStyle) : string
◆ static function TextArea(position : Rect, text : string, maxLength : int, style : GUIStyle) :
string
参数
position 屏幕上用于文本的矩形区域
text 用于编辑的文本。这个函数返回值应该被赋回这个字符串。如下的例子。
maxLength 字符串的最大长度。如果不设置,用户可以一直输入。
style 使用的风格。如果不设置,将使用当前GUISkin 的textArea。
返回string – 编辑过的字符串
描述:制作一个多行文本区域。这里用户可以编辑这个字符串。
var stringToEdit = “Hello World\nI’ve got 2 lines…”;
function OnGUI()
{
//制作一个多行文本区域来调整stringToEdit
stringToEdit = GUI.TextArea(Rect(10, 10, 200, 100), stringToEdit, 200);
}
◆ static function TextField(position : Rect, text : string) : string
◆ static function TextField(position : Rect, text : string, maxLength : int) : string
◆ static function TextField(position : Rect, text : string, style : GUIStyle) : string
◆ static function TextField(position : Rect, text : string, maxLength : int, style : GUIStyle) :
string
参数
position 屏幕上用于文本的矩形区域
text 用于编辑的文本。这个函数返回值应该被赋回这个字符串。如下的例子。
maxLength 字符串的最大长度。如果不设置,用户可以一直输入。
style 使用的风格。如果不设置,将使用当前GUISkin 的textField 风格。
返回string – 编辑过的字符串
描述:制作一个单行文本域。这里用户可以编辑这个字符串。
var stringToEdit = “Hello World”;
function OnGUI()
{
//制作一个文本域来调整stringToEdit
stringToEdit = GUI.TextField(Rect(10, 10, 200, 20), stringToEdit, 25);
}
◆ static function Toggle(position : Rect, value : bool, text : string) : bool
◆ static function Toggle(position : Rect, value : bool, image : Texture) : bool
◆ static function Toggle(position : Rect, value : bool, content : GUIContent) : bool
◆ static function Toggle(position : Rect, value : bool, text : string, style : GUIStyle) : bool
◆ static function Toggle(position : Rect, value : bool, image : Texture, style : GUIStyle) : bool
◆ static function Toggle(position : Rect, value : bool, content : GUIContent, style : GUIStyle) :
bool
参数
position 屏幕上用于按钮的矩形区域
value 这个按钮是打开的或关闭
text 显示在该按钮上的文本
image 显示在该按钮上的Texture
content 用于这个按钮的文本,图形和提示
style 使用的风格。如果不设置,将使用当前GUISkin 的toggle 风格。
返回bool – 按钮的新值
描述:制作一个on/off 开关按钮
◆ static function Toolbar(position : Rect, selected : int, texts : string[]) : int
◆ static function Toolbar(position : Rect, selected : int, images : Texture[]) : int
◆ static function Toolbar(position : Rect, selected : int, contents : GUIContent[]) : int
◆ static function Toolbar(position : Rect, selected : int, texts : string, style : GUIStyle[]) : int
◆ static function Toolbar(position : Rect, selected : int, images : Texture, style : GUIStyle[]) :
int
◆ static function Toolbar(position : Rect, selected : int, contents : GUIContent[], style :
GUIStyle) : int
参数
position 屏幕上用于工具栏的矩形区域
selected 选择按钮的索引
texts 显示在该工具栏上的字符串数组
images 显示在工具栏按钮上的纹理数组
contents 用于这个工具栏的文本,图形和提示数组。
style 使用的风格。如果不设置,将使用当前GUISkin 的button 风格。
返回int – 选择按钮的索引
描述:制作一个工具栏
◆ static function UnfocusWindows() : void
描述:从所有窗体上移除焦点。
◆ static function VerticalScrollbar(position : Rect, value : float, size : float, topValue : float,
buttonValue : float) : float
◆ static function VerticalScrollbar(position : Rect, value : float, size : float, topValue : float,
buttonValue : float, style : GUIStyle) : float
参数
position 屏幕上用于滚动条的矩形区域。
value 在min 和max 之间的位置。
size 能看见多大?
topValue 滚动条顶端的值
bottomValue 滚动条底端的值
style 使用的风格。如果不设置,将使用当前GUISkin 的horizontalScrollbar 风格。
返回float – 修改后的值。这可以通过拖动这滚动条,或者单击两端的箭头来改变。
描述:制作一个垂直滚动条。滚动条可以用来滚动文档。大多数情况下,你会使用scrollViews
代替。
找到额外的元素:
在滚动条两端的按钮将在当前皮肤中搜索“upbutton”和“downbutton”作为风格。滚动条的滑
块(你拖动的东西)将搜索并使用名为“thumb”的风格。
//这将使用下面的风格名来决定该按钮的尺寸位置。
//MyVertScrollbarupbutton – 用于上端按钮的风格名称。
//MyVertScrollbardownbutton – 用于下端按钮的风格名称。
//MyVertScrollbarthumb – 用于滑块的风格名称。
scrollPos = HorizontalScrollbar(Rect(0, 0, 100, 20), scrollPos, 1, 0, 100, “MyVertScrollbar”);
◆ static function VerticalSlider(position : Rect, value : float, topValue : float, buttonValue :
float) : float
◆ static function VerticalSlider(position : Rect, value : float, topValue : float, buttonValue : float,
slider : GUIStyle, thumb : GUIStyle) : float
参数
position 屏幕上用于滑杆的矩形区域。
value 滑杆显示的值。这个决定可移动滑块的位置。
topValue 滑杆顶端的值
bottomValue 滑杆底端的值
slider 用于显示拖动区域的GUIStyle。如果不设置,将使用当前GUISkin 的horizontalSlider。
thumb 用于显示土洞区域的GUIStyle 。如果不设置, 将使用当前GUISkin 的
horizontalSliderThumb。
返回float – 被用户设置的值。
描述:一个用户可以拖动的垂直滑杆。可以在min 和max 之间改变一个值。
◆ static function Window(id : int, position : Rect, func : WindowFunction, text : string) : Rect
◆ static function Window(id : int, position : Rect, func : WindowFunction, image : Texture) :
Rect
◆ static function Window(id : int, position : Rect, func : WindowFunction, content :
GUIContent) : Rect
◆ static function Window(id : int, position : Rect, func : WindowFunction, text : string, style :
GUISytle) : Rect
◆ static function Window(id : int, position : Rect, func : WindowFunction, image : Texture,
style : GUIStyle) : Rect
◆ static function Window(id : int, clientRect : Rect, func : WindowFunction, title : GUIContent,
style : GUIStyle) : Rect
参数
id 用于每个窗口的唯一ID。这是用于接口的ID。
clientRect 屏幕上用于组的矩形区域。
func 在窗体内部创建GUI 的函数。这个函数必须使用一个函数– 当前创建GUI 的窗体
id
text 作为窗体标签的文本。
image 用于在标题栏上显示图片的Texture
content 用于这个窗口的文本,图形和提示。
style 用于窗口的可选风格。如果不设置,将使用当前GUISkin 的window。
返回Rect – 窗口位于的矩形位置
描述:制作一个弹出窗口
窗口浮动在普通GUI 控件之上,具有单击激活的特点并可以有选择的随意被端用户拖动。
不像其他的控件,你需要传递给他们一个独立的功能并放置在窗口中。注意:如果你使用
GUILayout 在窗口中放置你的组件,你应该使用GUILayout.Window。这是一个小例子帮助
你开始:
var windowRect = Rect(20, 20, 120, 50);
function OnGUI()
{
//注册窗口。注意第三个参数。
windowRect = GUI.Window(0, windowRect, DoMyWindow, “My Window”);
}
//制作窗口内容
function DoMyWindow(windowID : int)
{
if(GUI.Button(Rect(10, 20, 100, 20), ”Hello World”))
print(“Get a click”);
}
你可以使用相同的函数来创建多个窗口。需要确保每个窗口有一个自己的ID。例如:
var windowRect0 = Rect(20, 20, 120, 50);
var windowRect1 = Rect(20, 100, 120, 50);
function OnGUI()
//注意窗口。我们创建了两个使用相同函数的窗体
//注意他们的ID 不同。
windowRect0 = GUI.Window(0, windowRect0, DoMyWindow, “My Window”);
windowRect1 = GUI.Window(1, windowRect1, DoMyWindow, “My Window”)
}
//制作窗口内容
function DoMyWindow(windowID : int)
{
if(GUI.Button(Rect(10, 20, 100, 20), “Hello World”))
print(“Get a click in window ” + windowID);
//使窗口可以被拖动
GUI.DragWindow(Rect(0, 0, 10000, 10000));
}
停止显示窗口,简单的在DoGUI 函数内停止调用GUI.Window。
//布尔变量以决定是否显示窗口
//从游戏GUI,脚本,检视面板中或者其他地方改变这个决定窗口是否可见。
var doWindow() = true;
//制作窗口内容
function OnGUI()
{
//制作一个开关变量来隐藏或显示窗口
doWindow() = GUI.Toggle(Rect(10, 10, 100, 20), doWindow(), “Window 0”);
//确保仅在doWindow()为真时调用GUI.Window
if(doWindow())
GUI.Window(0, Rect(110, 10, 200, 60), DoWindow(), “Basic Window”);
}
为了使窗口从自动GUI 获取它的尺寸,使用GUILayout.Window。
调用顺序
窗口需要从后向前绘制。在其他窗口顶部的窗口需要在其他窗口之后绘制。这就意味着你
不能指望你的DoWindow 函数以任何特定的顺序被调用。为了让这个能够工作,当你的创
建窗口时下面值被存储(使用Window 函数),当DoWindow 被调用时取回:GUI.skin,
GUI.enabled, GUI.color, GUI.backgroundColor, GUI.contentColor, GUI.matrix
这就是说很容易像这样制作彩色窗口:
var windowRect0 = Rect(20, 20, 120, 50);
var windowRect1 = Rect(20, 100, 120, 50);
function OnGUI()
{
//这里我们制作了2 个窗口,在这个之前设置GUI.color 的值。
GUI.color = Color.red;
windowRect0 = GUI.Window(0, windowRect0, DoMyWindow, “Red Window”);
GUI.color = Color.green;
windowRect1 = GUI.Window(1, windowRect1, DoMyWindow, “Green Window”);
}
//制作窗口内容
//GUI.color 的值被设置为窗口被创建之前的值。
function DoMyWindow(windowID : int)
{
if(GUI.Button(Rect(10, 20, 100, 20), “Hello world!”))
print(“Got a click in window with color ” + GUI.color);
//使窗口可以被拖动
GUI.DragWindow(Rect(0, 0, 10000, 10000));
}
提示:你可以使用GUI.color 的alpha 组件来淡入淡出窗口。
参见:DragWindow, BringWindowToFront, BringWindowToBack
GeometryUtility

用于普通集合功能的工具类
类方法
◆ static function CalculateFrusturnPlanes(camera : Camera) : Plane[]
描述:计算视锥平面
这个函数取给定的相机视锥并返回它的六个面。
参见:Plane, GeometryUtility.TestPlanesAABB
◆ static function CalculateFrusturnPlanes(worldToProjection : Matrix4x4) : Plane[]
描述:计算视锥平面
这个函数返回由给定的视和投影矩阵定义的视锥的六个面。
参见:Plane, GeometryUtility.TestPlanesAABB
◆ static function TestPlanesAABB(planes : Plane[], bounds : Bounds) : bool
描述:如果包围盒在平面数组内部返回真。
如果包围盒在平面内部或者与任何平面交互返回真。
参见:GeometryUtility.CalculateFrusturnPlanes。
Gizmos

Gizmos 用于场景中给出一个可视化的调试或辅助设置。
所有的Gizmos 绘制都必须在脚本的OnDrawGizmos 或OnDrawGizmosSelected 函数中完成。
OnDrawGizmos 在每一帧都被调用。所有在OnDrawGizmos 内部渲染的Gizmos 都是可见的。
OnDrawGizmosSelected 尽在脚本所附加的物体被选中时调用。
类变量
◆ static var color : Color
描述:设置下次绘制的Gizmos 的颜色。
function OnDrawGizmosSelected()
{
//在物体的前方绘制一个5 米长的线
Gizmos.color = Color.red;
var direction = transform.TransformDirection(Vector3.forward) * 5;
Gizmos.DrawRay(transform.position, direction);
}
◆ static var matrix : Matrix4x4
描述:设置用于渲染所有gizmos 的矩阵。
类方法
◆ Static function DrawCube(center:Vector3,size:Vector3):void
描述:用center 和size 绘制一个立方体.
Function OnDrawGizmosSelected(){
//在变换位置处绘制一个变透明的蓝色立方体
Gizmos.color=Color(1,0,0,5);
Gizmos.DrawCube(transform.position,Vector3(1,1,1));
}
◆ Static function DrawGUITexture(screenRect:Rect,texture:Texture,mat:Material=null):void
描述:在屏幕坐标下绘制一个纹理。用于GUI 背景。
◆ Static function
DrawGUITexture(screenRect:Rect,texture:Texture,leftBorder:int,rightBorder:int,topBorder:int,bot
tomBorder:int,mat:Material=null):void
描述:在屏幕坐标下绘制一个纹理。用于GUI 背景。
◆ Static function Drawicon(center:Vector3,name:string):void
描述:在世界位置center 处绘制一个图标.
这个图标被命名为name 并放置在Assets/Gizmos 文件夹或Unity.app/Resoutces 文件
夹.DrawIcon 允许你在游戏中快速选择重要的物体。
//在物体位置处绘制光源灯泡图标.
//因为我们在OnDrawGizmos 函数内部调用它,在场景视图中
//这个图标总是可点选的.
function OnDrawGizmos(){
Gizmos DrawIcon(transform.position,”Light Gizmo.tiff”);
}
◆ Static function DrawLine(from:Vector3,to:Vector3):void
描述:绘制一条线从from 到to.
Var Larget:Transform;
function OnDrawGizmosSelected(){
if(target != null)
{
//从transform 到target 绘制一条蓝色的线
Gizmos.color = Color.blue;
Gizmos.DrawLine(transform.position,target.position);
}
}
◆ static function DrawRay(r:Ray):void
static function DrawRay(from:Vector3,direction:Vector3):void
描述:绘制一个射线从from 开始到from + direction.
◆ function OnDrawGizmosSelected(){
Gizmos.color = Color.red;
Direction = transform.TransformDirection(Vector3.forward)*5;
Gizmos.DrawRay(transform.positon,direction);
}
◆ Static function DrawSphere(center:Vector3,radius:flont):void
描述:用center 和randins 绘制一个球体.
Function OnDrawGizmosSelected(){
//在变换位置处绘制一个黄色的球体
Gizmos.color = Color.yellow;
Gizmos.DrawSphere(transtorm.position,1);
}
◆ Static function DrawWireCube(center:Vector3, size: Vector3):void
描述:用center 和radius 绘制一个线框立方体.
Function OnDrawGizmosSelected(){
//在变换位置处绘制一个黄色立方体
Gizmos.color = Color.yellow;
Gizmos.DrawWireCube (transtorm.position, Vector3(1,1,1));
}
◆ Static function DrawWireSphere(center:Vector3,radius:float):void
描述:用center 和radius 绘制一个线框球体.
Var explosionRadius = 5.0;
Function OnDrawGizmosSelected(){
//选中的时候显示爆炸路劲
Gizmos.color = Color.white;
Gizmos.DrawSphere(transtorm.position,explpsionRadius);
}
Graphics

Unity 绘制函数的原始接口。
这个是高级快捷地进去Unity 优化网格绘制的地方。只限于Unity Pro.
类方法
◆ static function DrawMesh(mesh:Mesh, position: Vector3, rotation: Quaternion, material:
Material, layer: int, camera: Camera=null, submeshIndex: int, properties:
MaterialPropertyBlock=null): void
◆ static function DrawMesh(mesh:Mesh,matrix:Matrix4x4,material:Material,layer:int,
camera:Camera = null,submeshIndex:int,properties:MaterialPropertyBlock=null):
void
参数
mesh 用于绘制的Mesh.
position 网格的位置。
rotation 网格的旋转。
matrix 网格的变换矩阵(由位置,旋转和变换x 组合)
material 使用的Material.
layer 使用的Layer.
Camera 如果是null(缺省),该网格将在所有相机中被绘制,否则它将
只会在给定的相机中渲染。
submeshIndex 那个子网格被渲染。这只是在网格使用了多个材质的时候
使用。
Properties 在网格绘制前应用到才子的额外材质属性。参考
MaterialPropertyBlock.
描述:绘制一个网格
DrawMesh 在一帧中绘制一个网格。这个网格将受到光照的影响,可以投射接收阴影并
被投射器影响。就像它是某个物体的一部分。他可以绘制于所有相机,或者只是特定的一些
相机
在你想创建人景的网格,而又不想过多的创建和管理游戏物体的时候使用DrawMesh.注意,
DrawMesh 不会立即绘制网格;它仅仅提交它用于渲染。网格将被作为普通渲染过程的一部
分。如果想立即绘制一个网格。使用Graphics.DrawMeshNow。
因为DrawMesh 不会立即绘制网格,在调用这个函数之间修改材质属性并会使材质使用它
们。如果你想绘制一系列相同材质的网格,但是稍微有些不同的属性(例如,改变每个网格
的颜色),那么使用MaterialPropertyBlock 参数。
参见:MateralPropertyBlock.
◆ Static function DrawMeshNow(mesh:Mesh,position:Vector3,rotation:Quatemion):void
描述:在给定的position,用给定的rotation 绘制一个mesh。
这个函数将设置模型视矩阵并绘制网络。当前设置材质的pass 可以被使用(参考Setpass)
◆ Static function
DrawMeshNow(mesh:Mesh,position:Vector3,rotation:Quatemion,materallndex:int):void
描述:在给定的position,用给定的rotation 和一个materialIndex 绘制一个mesh.
◆ Static function DrawMeshNow(mesh:Mesh,matrx:Matrix4x4):void
描述:用给定的matrix 绘制一个mesh.
如果这个矩阵有一个负的缩放这个函数将不会正确渲染物体。
◆ Static function DrawMeshNow(mesh:Mesh,matrx:Matrix4x4,materialIndex:int):void
描述:用给定的matrix 和materialIndex 绘制一个mesh.
如果这个矩阵有一个负的缩放这个函数将不会正确渲染物体。
◆ Static function DrawTexture(screenRect:Rect,texture:Texture,mat:Material = null):void
描述:在屏幕坐标下绘制一个纹理。
◆ Static function
DrawTexture(screenRect:Rect,texture:Texture,leftBorder:int,rughtBord:int,topBorder:int,bottomB
order:int,mat:Material=null):void
描述:在屏幕坐标下绘制一个纹理。
◆ Static function
DrawTexture(screenRect:Rect,texture:Texture,sourceRect:Rect,leftBorder:int,rughtBord:int,topBo
rder:int,bottomBorder:int,mat:Material=null):void
描述:在屏幕坐标下绘制一个纹理
◆ static function
DrawTexture(screenReet:Rect,texture:Texture,sourceRect:Rect,leftBordr:int.rightBrder:int.topBor
der:int,bottomBorder:int,color:Bolor,mat:Material=null):void
描述:在屏幕坐标下绘制一个纹理。
Hashtable

函数
◆ function Add(key:Object, value:Object):void
描述:添加指定的键和值到哈希表。
◆ function Clear():void
描述:数量被设置为0,并且从该集合中元素到其他对象的引用也将被释放,容量没有改变。
///这个方法是O(n)操作,这里n 是元素数量。
◆ function Contains(key:object):bool
描述:决定该哈希表中是否包含指定的键。
◆ function ContainsKey (key:object):bool
描述:从哈希表中移除指定键的元素。
◆ function Remove(key:object):void
描述:从哈希表中移除指定键的元素。
HostData

这个是用来保存单个主机信息的数据结构。
从master 服务器取回的主机列表,使用这个类表示单个主机。
变量
◆ var comment:string
描述:一个多用途的注释(可以保存数据)
◆ var conneetedfPlaycrs:int
描述:当前连接的玩家
◆ var gameName:stting
描述:游戏的名称(像John Doe's Game)
◆ var gameType:string
描述:游戏类型(像MyUniqueGameType)
◆ var ip:string[]
描述:服务器IP 地址
◆ var passwordProtected:bool
描述:服务器需要密码吗?
◆ var playerLimit:int
描述:最大玩家限制
◆ var port:int
描述:服务器端口
◆ var nseNat:bool
描述:这个服务器需要NAT 穿透吗?
input

到输入系统的接口。
使用这个类读取在Input Manager 中设置的轴。
使用Input.GetAxis 用下面的缺省轴读取轴心:"Horizontal"和"Vertical"被映射到摇杆,A,
W,S,D 和方向键,"Mouse X"和"Mouse Y"被映射到鼠标添量,"Fire1","Fine2","Fine3"映射
到Ctrl,Alt,Cmd 键和鼠标的三键或腰杆按钮。新的输入轴可以在Input Manager 中添加。
如果你在为任何一种运动行为使用输入,那么使用Inpur.GetAxis。它给你一种平滑的可配置
的输入,这个输入可以被映射到键盘,摇杆或鼠标。
使用Input.GetButton 用于像事件一样的行为,不要将它用于移动,Input.GetAxis 将使脚本代
码更小更简单。
类变量
◆ static var anyKey:bool
描述:当前按住了任何键或鼠标按钮吗?(读取)
◆ static var anyKeyDown:bool
描述:用户按下任何键或鼠标按钮返回(Rend Only)。直到用户释放所用键/按钮并再次接
下任何键/按钮时才返回真。
◆ static var input: String
描述:返回这一帧中键盘的输入(只读)。
只有ASCII 可以包含在inputString 中。
该字符串可以包含两个能被处理的特殊字符:字符“\b”代表退格。
*符"\n"表示回车。
//显示如何从键盘读取输入
//(例如,用户输入它的名字)。
//你需要附加这个脚本到一个GUTText 物体。function Updarc(){
for (var c;char in Input inputString){
//退格,移除最后一个字符
if(c=="\b") {
iftguiText.Lcngth.text.Substring(0,guiText.text Length-1);
}
//结束
efse if (e=="\n"){
prinr("Uscr cntered his name:"+guiText,text);
}
//正常的文本输入.附加到尾部
elsc
}
guiText.text+=c;
}
}
}
◆ static var mousePosition:Vcctor3
描述:当前鼠标在像素坐标下的位置。
屏幕或窗体的左下为(0,0),屏幕或窗体的左上为(Screen.width,Screen.height).
var particle:GamcObject,
function Update() {
if (lnput,GctButtonDown{"Firel")){
//从当前鼠标坐标处创建一个射线
var ray=Camera.main.ScreenPointToRay(Input mousePositicn);
if{Physics.Raycast(ray)) {
//如果碰到创建一个粒子
Instontiatc(particlc,transfonn.position,transfonn.rotation);
}
}
}
类方法
◆ static function CetAxis(axinName:string):float
描述:设置由axinName 确实虚拟轴的值。
对于键盘和摇杆输入,这个值将在-1...1。
一个非常简单的行驶在x-z 平面的汽车。
var spced=10.0;
var cotatinnSpeed=100.0;
function update()
}
//获取水平和垂直轴,
//默认滴它们被映射到方向键
//这个值的范围在-1 到1
var transtation=loput.getaxis("vertical")*spccd;
var rotation=inpul getaxis ("horizontal"*rotarionspeed)
//使它以10 米/秒速度移动而不是10 米/帧
translation*=time delta time
//沿着物体的Z 轴移动变换
transtorm.transtate(1010translation);
//绕着Y 轴旋转
transform.rotate(0.rotation.0);
}
//指定一个鼠标查看
var horizontalspccd=2.0;
var verticelspeed=2.0
function update()
{
获取鼠标增量,这个没有在范围-1...1 之间
var h=horizontalspeed*inpul.getaxis("mouse X");
var v=verticalspeed*input.getaxis("mouse Y");
transform.rotate(v.h.0);
}
◆static function getaxisraw(axisname:string):float
描述:设置由axisname 确定虚拟轴的值,并且没有使用平滑过滤,
对于键盘和摇杆输入,这个值将在-1...1 的范围内。因为输入没有被平滑,
总是-1,0 或1.如果你想自己处理所有键盘输入的平滑,这个是很有用的。
function update(){
var speed=input.getaxisraw("horizoatal"*time deta time);
transform rotate(0.speed.0);
}
◆static function getbutton(button name:string):bool
描述:当时由button name 确定的虚按钮被按住时返回真。
考虑自动开火-这个将在按钮被按住时一直返回真。
//如果每0.5 秒实例化一个projcctile,
//如果firel 按钮(默认为Ctrl)被按下
var projectile:game object;
var firerate=0.5;
private var nextfire=0.0;
function update()
{
fi(input getbutton("firel")&&time.time>nextfire){
nextfire=time.time+firerate;
clone=instantiate(peojecctile,teansform,position,transffrm,rotation);
}
}
只有使用这个实现事件行为例如,射击,使用input.getaxis 用于任意类型的移动行为
◆static function getbuttondown(button name:steing):bool
描述:当由:button name 确定的虚拟按钮被按下时返回真。
知道用户释放并再次按下时返回真。
//当用户按下firel 按钮时实黎化一个projcctile
var projectile:gameobject;
function update(){
if(input getbution down("firel")){
elone=instantiate(projectile,transforrn,position.transforn.rotinon);
}
}
只使用这个实现事件行为例如,射击,使用lnput.GetAxis 用于任意类型的移动行为。
◆ static function GetButton Up(buttonName:string):bool
描述:当由buttonName 确定的虚拟按钮被释放时返回真.
直到用户按下按钮并再次松开时返回真。
//当用户按下Fire;按钮时实例化一个projectile.
var projectile:GameObject;
function Update O;
if(lnput GetButtonUp("Firel")){
clcne=lnstantiate{projectile,transtorm.position,transform.rotation);
}
}
只使用这个实现事件行为例如,射击。使用lnput.GetAXis 用于任意类型的移动行为,
◆ static funcrion GetKey(name:string):bool
描述:当用户按住由name 确定的键时返回真,考虑自动开火。
键标识列表参考输入管理器。在处理输入时建议使用lnput.GetAxis 和lnput.GetButton
因为它允许端用户定义这些键.
funcrion Update(){
if(lnput.GetKey("up")){
print("up arrow key is held down");
}
if(lnput.GetKey("down"))
}
print("down arrow key is held down");
}
}
◆ static junction GetKey(key:keyGode):bool
描述:当用户按住由key KeyCode 枚举参数确定的键时返回真.
funcrion Update(){
if(lnput.GetKey(KeyCode.UpArrow))}
print("up arrow key is held down");
}
if(lnput.GetKey(KeyCode.DownArrow)){
print("down arrow key is held down");
}
}
◆ static function GetkeyDown(name:string):bool
描述:当用户开始按下由name 确的键时返回真.
直到用户释放按钮并再次按下时返回真.
键标示列表参考lnput Manager.在处理输入时建议使用lnput.GetAxis 和Input.GetBUtton
function Update();
if(input GetkeyDown("space"))
print("space key was pressed");
}
}
static function GetKeyDown(Key:KeyCode):bool
描述:当用户按下由Key KeyCode 枚举参数确定的键时返回真.
function Update();
if{lnput GetKeyDown(KeyCode.Space))
print("space key was pressed");
}
}
◆ static function GetKeyUp(name:sting):bool
描述:当用户释放由name 确定的键时返向真.
直到用户按下按钮并再次松开时返向真。
键标示列表参考lntpot Manager.在处理输入时建议使用lnput.GetAxis 和lnput.GetButton
因为它允许端用户定义这些键.
function Update();{
if(lnput.GetKeyUp("space");
}
}
◆ static function GetKeyUP(Key:KeyCode):bool
描述:当用户释放由Key KeyCde 校举参数确定的键时返回真.
function Update(){
if(lnput,GetKeyUp(KeyCode.Space));
print("space key was feleased");
}
}
◆ statie function GetMouseButton(button:int):bool
描述:返回给定的鼠标按钮是否被按住。
/button/值为0 表示左键,1 表示右键,2 表示中键.
◆ statie function GetMouseButtonDown(button:int)bool
描述:用户按下给定的鼠标按钮时返回真.
直到用户释放按钮并再次按下它时才返回真.button 值为0 表示中键左键,1 表示右键,2 表
示中键.
◆ statie function GetMouseButtonUp(button:int)bool
描述:用户释放给定的鼠标按钮时返回真.
直到用户释放按钮并再次释放它时才返回真.button 值为0 表示中键左键,1 表示右键,2 表
示中键.
◆ statie function ResetlnputAxes();Void
描述:重置所有输入。在ReaetlnputAxes 之后所有轴将返回0 并且所有按钮返回0.
这可用于当重生玩家,并且当你不想任何来自键盘的输入还处于按下时。
lnpu.ReaetlnputAxes();
jointDrive
结构
关节如何沿着本地X 轴移动
变量
◆ var maximumForce:float
描述:用于向指定的方向推动物体的力的量。仅在Mode 包含Velocity 时使用。
◆ var mode:jointDriveMode
描述:驱动是否尝试到这个位置和/或速度.
◆ var positionDamper:float
描述:位置弹簧的阻力强度,只用于mode 包含位置的时候.
◆ var positionSpring:float
描述:朝着定义的方向推动的一个阻力强度。只用于mode 包含位置的时候.
Jointlimits
结构
jointlimits 被Hingejoint 使用来限制关节角度.
参见:Hingejoint
变量
◆ var max:float
描述:关节的上限。当关节角度或位置的上限。
关节将使用力来约束它。
//设置最小链接角度为20 度
hingejoint.limits.max=40;
◆ var maxBounce:float
描述:当关节碰到关节的上限时关节的弹力。
//设置关节反弹时的上限
hingejoint.limits.maxBounce=1;
◆ var min:float
描述:关节的下限。当关节角度或位置的下限。
关节将使用力来约束它。
//设置最小链接角度为20 度
hingejoint.limits.min=20;
◆ var minBounce:float
描述:当关节碰到关节的下限时关节的弹力。
//关节反弹时的下限
hingejoint.limits.minBounce=1;
jointMotor
结构
jointMotor 用来旋转一个关节
例如:Hingejoint 可以被告知以制定的速度和力旋转。关节然后用给定的最大力试图到达这
个速度,参见:
变量
◆ var force:float
描述:动力将应用最大为force 的力以便取得targetvelocity
◆ var freeSpin:bool
描述:如果freeSpin 被启用动力将只加速而不会减速
◆ var targetvelocity:float
描述:动力将应用最大为force 的力以便取得targetvelocity
Jointspring
结构
变量
◆ var damper:float
描述:用语阻尼弹簧的阻尼力。
◆ var spring:float
描述:用于达到目标位置的弹力
◆ var targetposition:float
描述:关节试图到达的目的位置
这里一个hingehoint 目标位置是目标角度
Keyframe
结构
一个关键帧它可以插入动画的曲线
变量
◆ var in tangent:float
描述:在曲线上从下一个点到这个点时描述切线。
参加:outtangent
◆ var outtangent:float
描述:在曲线上从这个点到下一个点时描述切线。
参见:intangent
◆ var time:float
描述:关键帧时间
在一个2D 图形中,你可以把这当做x 值
参见:value
◆ var value:float
描述:该动画曲线在关键帧处的值
参见:time
构造函数
◆ static function keyframe(time:float,value:float):keyfranie
描述:创建一个关键帧
◆ static function keyframe(time:float,value:float,intangent:float,outangent:float):keyframe
描述:创建一个关键帧
layermask
结构
layermask 允许你在检视面板中显示layermask 弹出菜单
类似与camera,cullingmask。layermasks 可以选择性地过滤物体,例如当投射射线,
//使用层蒙板投射一个射线
//它可以在检视面板中修改
var mask larermask=
function Update(){
if(Physics.Raycast(transform.position, transform.forward, 100, mask.value))
{
Debug.Log(“Hit something”;
}
}
变量
◆ var valuc:vin
描述:转化层蒙板的值为一个整形值
//使用层蒙板投射一个射线
//它可以在检视面板中修改
var mask:lnyermask=-1
fonction update(){
if{physics.rayeast(transforn.position.transform.forwatd.100.mask.value))
{
Debug
}
}
类方法
◆ static function LayerToName(layer :in):string
描述:给定一个层的数字。返回内置的或在tag Maneger 中定义的层名称。
◆ static function NameToLayer(layerName :string):int
描述:给定一个层的名字。返回内置的或在tag Maneger 中定义的层索引。
◆ static implicit function LayerMask(intva1:int):layermask
描述:隐式转化一个整数位已个层蒙板
Lightmapdata

光照贴图数据
一个场景可以有多个光照贴图储存在这里,renderer 组建可以使用这些光照贴图,这就使得
它能够在多个物体上使用相同的材质,而每个物体可以使用不同的光照贴图或同一个光照贴
图的不同部分。
参见,linghrmapsettings 类renderer lightmapindex 属性
变量
◆ var lightmap:texture2D
描述:光照贴图的纹理
参见:lightmspsettings 类renderer lighunaplndex 属性
linghtmapsettings

储存这个场景的光照图
一个场景可以有多个光照贴图储存在这里,renderer 组件可以使用这些光照贴图,这就使得
它能够在多个物体上使用相同的材质,而每个物体可以使用不同的光照贴图或同一个光照贴
图的不同部分。
参见:lightmapdata 类renderer.lightmaplndex 属性
类变量
◆ sartic var lightmaps:lightmapdata[]
描述:光照贴图数组
参见:lightmapdata 类renderer.lightmaplndex 属性。
Masterserver
类,主服务器用来使服务器和客服端匹配。
你可以建立以个游戏主机或为你的游戏类型取回主机列表。这里的这个函数用来与主服务器
通信,主服务器位于不同的服务器上,如果必要这个服务器可以被定制,主服务器的概览和
技术描述:参见master server manual page
类变量
◆ static var dedicatedserver:bool
描述:申明这台机器为专用服务器。
如果作为一个服务器运行,连接数定义了玩家的数量,当在主服务器上注册的时候这个被报
告,默认情况下主服务器假定这个实例不是专用服务器,因此玩家数会增加1(占用服务器
上的一个\“chent”\)如果不希望,这个变量可以设置为假,然后知有连接数被报告为玩家数。
function startserver{}{
nerwork lnitializeserver(32.25002):
masrerserver.dedicatedserver=true;
masterserver.registerhost("myuniquegametype","johndoes game","133tgame for all");
}
◆static var ip address:string
描述:主服务器的IP 地址。
默认地这个是由unity 技术运行的服务器。
function
masterserver ip address="127.0.0.1";
master server.port=10002;
}
◆static var port:int
描述:主服务器的链接端口。
默认地这个是由unity 技术云顶的服务器,
masterserver.ipaddress="127.0.0.1";
master server.port=100021;
}
◆static var updaterate:int
描述:为主服务器主机信息更新设置最小更新速率。
通常,主机更新只在主机信息被改变的时候发生(如连接的玩家)。更新率定义了主机更新
之间的最小时间量,缺省值为60 秒(检查更新)因此,如果以个主机更新呗发送然后一些
域在10 秒后改变,然后更新可能会在50 秒之后发送(在下一次检查到改变的时候)。如果
这个被设置为0,以后就没有更新被发送,只发送初始注册信息。
function startserver()
{
network lnitialigeserver(32.25002);
//在初始化注册之后没有主机信息更新
Masterserver.updaterate=0;
masterserver,registerhost("myuniquegametype","johndoes game","133tgame forall");
}
类方法
◆static function clearhostlist():void
描述:清楚由masterserver.pollhostlist 接收到的主机列表。
如果你想更新列表并想确保你不使用较旧的数据时,使用这个,
function awakc()
{
//确保类表是空的并请求一个新的列表
masterserver clearhostlist();
masterserver.requesthostlist("myuniquegametype");
}
function lpdate()
{
//如果任何主机被接收,显示游戏名称,再次清理主机列表,}
if(masterserver.pollhostlist(),length!=0){
var hostdata;hostdata[]=masterserver.pollhostlist();
for(var i:int=0;i<hostdata.length;i++){
debug,log("game name:"+hostdata[i]gamename);
}
masterserver,clearhostlist()
}
}
◆static function pollhostlist():hostdata[]
描述:使用master server.requeshostlist 接收最新的主机列表
使用masterserver.clearhostlist 清理当前主机列表。这样你可以确定返回的列表时最新的。
function awaket(){
//确保列表时空的并请求一个新的列表
masterserver .clearhostlist();
masterserver.requesrhostlist("larustest"):
;
function update()
;
//如果任何主机被接收,显示游戏名称,再次清理主机列表;
if(masterserver.pollhostlist()length!=0){
varhostdata hostdata[]=masterserver.pollhostlist();
for(var i:int=0;i<hostdata.length;i++){
debug.log("game name"+hostdata[i].gamename);
}
masterserver.clearhostlist()
}
◆static function registerhost(gametypename:string,gamename:string.comment:string=""):void
描述:在主服务器注册这个服务器。
如果主服务器地址信息尚未改变,缺省的主服务器将被使用。
function ongui()
{
if(guilayout.button("stnrt server")){
//如果没有公有IP 地址,使用NAT 穿透
network。usenat=!network.havepublicaddrss();
network.lnitializeserver(32.25002);
masterserver.registerhost("myuniquegametype","johndoes game","133tgame for all");
}
}
◆static function RequestHosList(gameTypeName:string):void
描述:从主服务器请求一个主机列表。
当它完成的时候,这个列表可以通过MasterServer.PollHcstList 使用。
function Awakc(){
//确保列表时空的并请求一个新的列表
MastcrScrver.RequestHostList();
MastcrScrver.RequestHostList("LarusTcst");
}
function Update()
}
//如果任何主机被接收,显示游戏名称,再次清理主机列表。
if(MastcrScrvcr.PollHcstLisx().length!=0)}
var hostData:HostData[]=MasterSer.pollHostList();
for (var i:int=();i<hostData.length;i++){
Debug.Log("Game namc;"+hostData[i].gamceName);
}
MastcrScrvcr.ClearHostList();
}
}
static function UnregisterHost():void
描述:从主服务器注销这个服务器。
如果服务器没有被注销或已经被注销,不做任何事。
function OnGUt() {
if(GUILayout.Button("Disconnect")){
Nctwork,Disconnect();
NastcrServer.UnregisterHost();
}
}
MaterialPropertyBlock

应用的一块材质值。
MateriaIPropcrtyBlock 被Graphics.DrawMesh 使用。当你想用相同的材质(但有稍微有些不
同的属性)绘制多个物体时,使用这个。例如,如果你想稍微改变每个网络的颜色时。
出于性能原因,属性块只能包含有限数量的属性值。两个4x4 矩阵,六个向量颜色或12 个
浮点数可以存储在这个块中,存储空间时共享,所以存储一个矩阵留下两倍少的空间来
存储向量和浮点数。
Graphics。DrawMesh 拷贝传递的属性块,因此最有效的方法是使用它来创建一个快并为所
有DrawMesh 调用使用它。使用Clear 来清除块的值,AddFloat,AddVector,AddColot,
AddMatrix 来添加值。
参见:Graphics,DrawMesh,Matcrial。
函数
◆ function AddColor(name:string,value:Colo):void
◆ function AddColor(nameID:int,value:Colo):void
描述:添加一个颜色材质属性。
出于性能原因,属性块只能包含有限量的属性值。两个4x4 矩阵,六个向量/颜色或12 个浮
点数可以存储在这个块中。存储空间时共享,使用存储一个矩阵留下两个倍少的空间来存储
向量和浮点数。当块的存储空间填满后,额外的Add 调用将被忽略。
使用nameID 的函数变量体更快,如果你重复添加相同名称的属性,使用Shader.propertyToID
来获取不同的标示,并传递这个标示到AddColor。
◆ function AddFloat(name:string,value:float):void
◆ function AddFloat(nameID:int,value:float):void
描述:添加一个浮点材质属性。
出于性能原因,属性块只能包含有限数量的属性值。两个4x4 矩形,六个向量/颜色或存12
个浮点数可以存储在这个块中,存储空间是共享,所以存储一个矩阵留下两倍少的空间来存
储向量和浮点数。当块的存储空间填满后,额外的Add 调用将被忽略。
使用nameID 的函数变体更快,如果你重复添加相同名称的属性,使用Shader.PropertyToID
来获取不同的标示,并传递这个标示到AddFloat。
◆ function AddMatrix(name:string,value:Matrix4x4):void
◆ function AddMatrix(nameID:int,value:Matrix4x4):void
描述:添加一个矩阵材质属性。
处于性能原因,属性块只能包含有限数量的属性值。两个4x4 矩阵,六个向量/颜色或12 个
浮点数可以存储在这个块中。存储空间时共享,所以存储一个矩阵留下两倍少的空间来存储
向量和浮点数。当块的存储空间填满后,额外的Add 调用将被忽略。
使用nameID 的函数变体更快,如果你重复添加相同名称的属性,使用Shader.PropertyToID
来获取不同的标示,并传递这个标示到AddMatrix。
◆ function AddVector(name:string,value:Vector4):void
◆ function AddVector(nameID:int,value:Vector4):void
描述:添加一个向量材质属性。
出于性能原因,属性块只能包含有限数量的属性值。两个4x4 矩阵,六个向量/颜色或12 个
浮点数可以存储在这个块中。存储空间是共享,所以存储一个矩阵留下两倍少的空间来存储
向量和浮点数。当块的存储空间填满后,额外的Add 调用将被忽略。
使用nameID 的函数变体更快,如果你重复添加相同名称的属性,使用
Shader.ProrertyToLD 来获取不同的标示,并传递这个标示到AddVector。
◆ function Clear():void
描述,清除材质属性值。
GrawMesh 拷贝传递的属性块,因此最有效的方式是使用它来创建一个块并为
所有DrawMesh 调用使用它。使用Clear 来清除块的
值,ADDFloat,AddVector,AddColor,AddMatrix 来添加值.
Mathf
结构
常用数学函数的集合。
类变量
◆ static var Deg2Rad:float
描述:度到弧度的转化常量(只读)。
这个等于(PI*2)/360.
//转化30 度为弧度
var deg=30.0;
var od=dcg*Mathf.Deg2Rad;
参见:Rad2Deg 常量。
◆ static varEpsilon:float
描述:一个小的浮点数值(只读)
比较小于它的值没有多人意见,因为浮点数是不精确的。
print(MathfEpsilon);
◆ static var Infinity:float
描述:表示正无穷(只读).
◆ static var NegativeIntinity:float
描述:表示负无穷(只读).
◆ staic var PI:float
描述:3.14159265358979...值(只读).
◆ static var Rad2deg:float
描述:弧度到度的转化常量(只读).
这个等于360、(PI*2).
转化1 弧度为度
var rad=1.0;
var deg=rad*Mathf.Rad2Deg.
参见:Deg2Rad 常量
类方法
◆ staric function Abs(f:float):float
描述:返回f 的绝对值。
//打印10.5
print(Mathf.Abs(-10.5)).
◆ staric function Abs(value:int):int
描述:返回value 的绝对值。
//打印10
print(Mathf.Abs(-10));
◆ staric function Acos(f:float):float
描述:返回f 的反余弦_一个弧度角它的余弦是f.
print(Mathf.AcOS(0.5);
◆ staric function Approximately(a:float,b:float):bool
描述:比较两个浮点数值看看它们是否近似。
由于浮点数值不精确,不建议使用等操作来比较它们。例如,1.0==10.0/10.0 也许不会返回
真。
if(Mathf.Approximately(1.0,10.0/10.0))
print("same");
◆ static function Asin(f:float):float
描述:返回f 的反正弦_一个弧度角它的正弦是f.
print(Matht.Asin(0.5));
◆ staric function Atan(f:float):float
描述:返回f 的反切_一个弧度角它的正切是f.
print(Mathf.Atan(0.5));
◆ staic function Atan2(y:float,x:float):float
描述:返回一个弧度角它的Tan 为y/x。
返回的值是一个角度,该角表示x 轴和开始于零并终结在(x,y)处的向量之间的角度。
//通常使用transform.lookAt.
//但这可以给你更多的对角度的控制
vartatget:Transform;
function Update()
{
var relativ=transfom.lnverseTeansformPoint(target.position);
var angle=Mathf.Atan2(reative,reative.z)*Mathf.Rad2Deg;
transform.Rotate(0,angle,0);
}
◆ static function Ceil(f:fioat):float
描述:返回大于等于f 的最小整数.
◆ static function CeilTolnt(f:fioat):int
描述:返回大于等于f 的最小整数.
◆ static function Clamp(value:float,min:float,max:float):float
描述:在一个最小的浮点数和最大的浮点数之间截剪。
//随着时间设置变换位置
//但是不会小于1 或大于3
function Update()
{
transtorm,position.x=Mathf.Clamp(lime.time.1.0,3.0);
}
◆ staric function Clamp(value:int,min:int,max:int):int
描述:在min 和max 之间裁剪值并返回裁剪后的值。
//在1 到3 之间裁剪10,
//打印3 到控制台
prnt(Mathf.Clamp(10,1,3))
◆ static function Clamp01(value;float):float
描述:在0 和1 之间裁剪值并返回裁剪后的值。
//随着时间设置变换位置
//但是不会小于0 或大于1
function Update(){
transform.position.x=Mathf.Clamp01(Time.time);
}
◆ staic function ClosestPowerOflwo(value:int):int
描述:返回最直接的2 的幂次值。
例如。7 返回8 或者19 返回16
◆ staric function Cos(f:float):float
描述:返回弧度f 的余弦值.
print(Mathf.Cos(3));
◆ staic function EXP(power:float):float
描述:返回e 的特定次幂。
print(Mathf.Cos(6));
◆ static function Floor(f:float):float
描述:返回小于f 的最大整数.
◆ static function FloorTolnt(f:float):int
描述:返回小于f 的最大整数.
◆ static function lnverseLerp(from:float,to:float,value:float):float
描述:在两个值之间计算Lerp 参数.
varwalkSpeed=5.0;
varunSpeed=10.0;
var speed=8.0;
//参数现在是3/5
vvar parameter=Mathf.laverseLerp(walkSpeed,runSpeed,speed);
◆ staic tunchon Lerp(a:float,b:float,t:float):float
描述:基本t 在a 到b 之间插值。t 本裁剪到0 到1 之间。
当t 为0 时返回from . 当t 为1 时返回to .当t=0.5 时返回a 和b 的平均。
var minimum = 10.0;
var maximum = 20.0;
// 在一秒内从minimum 渐变到maximum
Function Update()
{
transform.position.x = Mathf.lerp(minimum,maximum,Time.time);
}
◆ static function LerpAngle(a:float,b:float,t:float):float
描述:与Lerp 相同,但是当它们可绕360 度时确保插值正确,
变量a 和b 被认为是度。
//以2 为底6 的对数
//打印2.584963
print(Mathf.Log(6,2));
◆ static function Log(f:float):float
描述:返回一个数以自然(以e 为底)对数。
//10 的自然对数
//打印4.60517
print(Mathf.Log(10));
◆ static function Log10(f:float):float
描述:返回一个数以10 为底的对数。
//以10 为底100 的对数
//打印2
print(Mathf.Log10(100));
◆ static function Max(a:float,b:float):float
描述:返回两个值中较大的一个。
//打印2
print(Mathf.Max(1,2));
◆ static function Max(a:int,b:int):int
描述:返回两个值中较大的一个。
//打印2
print(Mathf.Max(1,2));
◆ static function Min(a:float,b:float):float
描述:返回两个值中较小的一个。
//打印1
print(Mathf.Min(1,2));
◆ static function Min(a:int,b:int):int
描述:返回两个值中较小的一个。
//打印1
print(Mathf.Min(1,2));
◆ static function PingPong(t:float,length:float):float
描述:来回改变t 值,t 值不会超过length,也不会小于0,只会在length 和0 之间循环。
function Update()
{
//让x 位置在0 到3 之间循环
transform.position.x = Mahtf.PingPong(Time.time,3);
}
◆ static function Pow(f:float,p:float):float
描述:返回f 的p 次方。
print(Mahtf.Pow(6,1.8));
◆ static function Repeat(t:float,length:float):float
描述:使t 值循环,不大于length 不小于0。它与操作模板类似,但可以使用浮点数。
function Update()
{
//让x 位置在0 到3 之间循环
transform.position.x = Mahtf.Repeat(Time.time,3);
}
◆ static function Sign(f:float):float
描述:返回f 的符号。
当f 为正或为0 则返回1,为负返回-1。
◆ static function Sin(f:float):float
描述:返回以f 为弧度的sin 值。
print(Mahtf.Sin(3));
◆ static function SmoothDamp(current:float,target:float,ref
currentVelocity:float,smoothTime:float,maxSpeed:float = Mahtf.Infinity,deltaTime:float
=Time.deltaTime):float
描述:逐步的向期望值变化。
这个值就像被一个不会崩溃的弹簧防震器所影响。这个函数可以用来平滑任何类型的值,位
置,颜色,标量。最常用于让一个跟随摄像机的速度变的平滑。
current 就是当前位置。target 是我们希望达到的位置。currentVelocity 是当前速度,这个值在
你访问这个函数的时候会被随时修改。smoothTime 是要到达目标位置的近似时间,实际到
达目标时要快一些。maxSpeed 可以让你随意的设定最大速度。deltaTime 是上次访问该函
数到现在的时间。缺省为Time.deltaTime。
//平滑到目标高度
var target : Transform;
var smoothTime = 0.3;
private var yVelocity = 0.0;
function Update ()
{
var newPosition = Mathf.SmoothDamp(transform.position.y, target.position.y,yVelocity,
smoothTime);
transform.position.y = newPosition;
}
◆ Static function SmoothDampAngle(current: float, target: float, ref currentVelocity): float,
smoothTime: float, maxSpeed: float=Mathf.Infinity, deltaTime: float=Time.deltaTime): float
描述: 基于Game Programming Gems4 章节1.10
随着时间逐渐的改变一个角度为目的的角度。这个值被像弹簧阻尼一样的函数平滑。这个函
数可以用来平滑任何一种值,位置,颜色,标量。最常见的是平滑一个跟随摄像机。
current 是当前位置。target 是我们试图到达的位置。currentVelocity 是当前速度,这个值在每
次你调用这个函数的时候都被修改。smoothTime 是到达目的地近似时间,实际的时间将更
短。maxSpeed 为允许的最大速度。deltaTime 为从上次调用该函数到现在的时间。缺省为
Time.deltaTime。
//一个简单的平滑跟随摄像机。
//跟随目标的朝向
var target : Transform;
var smooth = 0.3;
var distance = 5.0;
private var yVelocity = 0.0;
function Update ()
{
//从目前的y 角度变换到目标y 角度
var yAngle = Mathf.SmoothDampAngle(transform.eulerAngles.y,target.eulerAngles.y, yVelocity,
smooth);
//target 的位置
var position = target.position;
//然后,新角度之后的距离便宜
position += Quaternion.Euler(0, angle, 0) * Vector3 (0, 0, -distance);
//应用位置
transform.position = position;
//看向目标
transform.LookAt(target);
}
◆ static function SmoothStep (from : float, to : float, t : float) : float
描述:在min 与max 中插值并在限定处渐入渐出
◆ static function Sqrt (f : float) : float
描述:返回f 的平方根
print(Mathf.Sqrt(10));
◆ static function Tan (f : float) : float
描述:返回弧度f 的正切值
print(Mathf.Tan(0.5));
Matrix4x4
一个标准的4x4 变换矩阵。
一个变换矩阵可以执行任意的线形3D 变换(例如,评议,旋转,缩放,切边等等)并且偷
师变化使用齐次坐标。脚本中很少使用矩阵:最常用Vector3,Quaternion,而且Transform
类的功能更简单。单纯的矩阵用于特殊情况,如设置非标准相机投影。
参考任何图形学教程获取关于变换矩阵的深入揭示。
在Unity 中,Matrix4x4 被Transform,Camera,Material 和GL 函数使用。
变量
◆ var inverse : Matrix4x4
描述:返回该矩阵的逆(只读)
如果用原始矩阵诚意逆矩阵结果为identity 矩阵。
如果一些矩阵以一个特定的方式变换响亮, 逆矩阵可以将他们变换回去。例如
worldToLoclaMatrix 和localToWorldMatrix 是互逆的。
◆ var this[row : int,column : int]:float
描述:访问[row,column]处的元素。
row 和column 必须在0 到3 之间,矩阵是一个4x4 的数组,你可以通过使用这个函数访问
单个的元素。
注意标准数学符号-row 是第一个索引。
◆ var this[index : int]:float
描述:按顺序索引存取元素(包括在0..15)
矩阵是一个4x4 的数组,所以它的总数为16,。你可以使用一维索引来存取单个元素。index
是row+column*4
◆ var transpose : Matrix4x4
描述:返回这个矩阵的转置(只读)。
转置矩阵是将原矩阵行列交换得到的(沿主对角线翻转)
函数
◆ function GetColumn(i : int):Vector4
描述:获取矩阵的一列。
第i 列作为Vector4 返回,i 必须在0 到3 之间。
参见:SetColumn
◆ function GetRow(i : int):Vector4
描述:返回矩阵的一行。
第i 行作为Vector4 返回,i 必须在0 到3 之间。
参见:SetRow
◆ function MultiplyPoint (v : Vector3):Vector3
描述:通过这个矩阵变换位置。
返回由任意矩阵变化得到的位置v。如果这个矩阵是一个正规的3D 变换矩阵,使用
MultiplyPoint3x4 比它更快。MultiplyPoint 是较慢的,但是能处理投影变换。
参见:MultiplyPoint,MultiplyVector。
◆ function MultiplyPoint3x4(v : Vector3):Vector3
描述:通过这个矩阵变换位置(快)。
返回由当前变换矩阵变换得到的位置v。这个函数是MultiplyPoint 的快速版,但是它只能处
理常规的3D 变化。Multiplypoint 是较慢的,但是能处理投影变换。
参见:MultiplyPoint,MultiplyVector。
◆ function MultiplyVector(v : Vector3):Vector3
描述:通过这个矩阵变换方向。
这个函数类似于MultiplyPoint,但它是变换方向而不是位置。变换方向时,只考虑矩阵的旋
转部分。
参见:MultiplyPoint,MultiplyPoint3x4。
◆ function SectColumn(i : int,v:vector4):void
描述:设置矩阵的一列。
使用这个来构建一个变换矩阵,这个矩阵使用right,up 和forward 向量。
//从变换构建一个矩阵
var matrix = Matrix4x4();
//从变换构建一个矩阵
function Start ()
{
matrix.SetColumn (0, transform.right);
matrix.SetColumn (1, transform.up);
matrix.SetColumn (2, transform.forward);
var p = transform.position;
matrix.SetColumn (3, Vector4 (p.x, p.y, p.z, 1));
}
//设置第i 列为v。i 必须在0 到3 之间。
参见:GetColumn
◆ function SetRow(i : int,v:Vector4):void
描述:设置矩阵的一行。
设置第i 行为v。i 必须在0 到3 之间。
参见:GetRow
◆ function SetTRS(pos : Vector3, q:Quaternon, s:Vector3):void
描述:设置这个矩阵为一个变换,旋转和缩放矩阵。
当前的矩阵本修改一遍具有位置pos,旋转q 和缩放s。
◆ function ToString():string
描述:返回已格式化的该矩阵的字符串。
类变量
◆ static var identity : Matrix4x4
描述:返回单位矩阵(只读)。
这个矩阵在使用的时候不会影响任何东西。它的主对角线上全是1,其他位置全是0。
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1
参见:zero 变量。
◆&n, bsp;static var zero : Matrix4x4
描述:返回所有元素都为零的矩阵(只读)。
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
参见:identity 变量。
类方法
◆ static operator * (lhs : Matrix4x4,rhs : Matrix4x4) : Matrix4x4
描述:两个矩阵相乘。
返回lhs * rhs。
◆ static operator * (lhs : Matrix4x4,v:Vector4):Vector4
描述:由矩阵来变换一个Vector4。
◆ static function Ortho(left : float,right : float,bottom : float,top : float,zNear : float,zFar :
float):Matirx4x4
描述:创建一个正交投影矩阵。
返回的矩阵是视口ledt 到right,bottom 到top 的区域,zNear 和zFar 深度裁剪面板。
如果你想使用正交来做像素修正渲染,最好使用GL.LoadPixelMatrix,因为它会为Direct3D
渲染器运用适当的half-texel 便宜。
参见:GL.LoadPixelMatrix,GL.LoadProjectionMatrix,GUI.matrix
◆ static function Perspective(fov : float,aspect : float,zNear : float,zFar : float):Matrix4x4
描述:创建一个透视投影矩阵。
fov 为透视矩阵的垂直视野,aspect 为宽高比,zNear 和zFar 设置为深度裁剪面板。
参见:GL.LoadPixelMatrix,GL.LoadProjectionMatrix,GUI.matrix
◆ static function Scale(v:Vector3):Matrix4x4
描述:穿件一个缩放矩阵。
返回沿着坐标轴被响亮v 缩放的矩阵,该矩阵看起来像这样:
v x 0 0 0
0 v y 0 0
0 0 v z 0
0 0 0 1
◆ static function TRS(pos:Vector3,q:Quaternion,s:Vector3):Matrix4x4
描述:创建一个变换,旋转和缩放矩阵。
返回的矩阵具有位置pos,旋转q 和缩放s。
NetworkMessageInfo
这个数据结构包含一个刚收到的来自网络的消息。
它揭示了它从哪来,发送的时间和由什么网络视图发送的。
变量
◆ var networkView : NetworkView
描述:发送这个消息的NetworkView
◆ var sender : NetworkPlayer
描述:发送这个网络信息(拥有者)的玩家。
◆ var TimeStamp : double
描述:当消息被发送时的时间戳,以秒计。
时间邮戳可以用于实现插值或者连续刘宝的预测,时间戳被作为双精度数传递,以避免游戏
运行长一段时间后溢出。内置的时间戳被设置为32 位整数,以毫秒为精度以便节省带宽。
时间戳现对于Network.time 自动调整。因此Network.time-messageInfo.timeStamp 是抱在传输
时花费的时间。
var something : float;
var transitTime: double;
function OnSerializeNetworkView (stream : BitStream, info : NetworkMessageInfo) {
var horizontalInput : float = 0.0;
if (stream.isWriting) {
// 发送
horizontalInput = transform.position.x;stream.Serialize (horizontalInput);
} else {
// 接收
transitTime = Network.time - info.timestamp;
stream.Serialize (horizontalInput);
something = horizontalInput;
}
}
function OnGUI() {
GUILayout.Label("Last transmission time: "+ transitTime);
}
NetworkPlayer
NetworkPlayer 是一个数据结构,通过它你可以通过网络定位其他玩家。
例如,你可以直接发送一个消息给其他玩家。
变量
◆ var externalIP : string
描述:返回网络接口的外部IP 地址。这个只能在建立了外接连接以后才能输入。
◆ var externalPort : int
描述:返回网络接口的外部接口。这个只能在建立了外接连接以后才能输入。
◆ var ipAddress : string
描述:该玩家的IP 地址。
◆ var port : int
描述:该玩家的端口号。
构造函数
◆ static function NetworkPlayer(ip : string , port : int) : NetworkPlayer
描述:
函数
◆ function ToString() : string
描述:返回该网络玩家的指数。
类方法
◆ static operator != (lhs : NetworkPlayer,rhs : NetworkPlayer):bool
描述:如果两个NetworkPlayers 不是同一个玩家返回真
◆ static operator == (lhs : NetworkPlayer,rhs : NetworkPlayer):bool
描述:如果两个NetworkPlayers 是同一个玩家返回真
NetworkPlayer
NetworkPlayer 是一个数据结构,通过它你可以通过网络定位其他玩家。
例如,你可以直接发送一个消息给其他玩家。
变量
◆ var externalIP : string
描述:返回网络接口的外部IP 地址。这个只能在建立了外接连接以后才能输入。
◆ var externalPort : int
描述:返回网络接口的外部接口。这个只能在建立了外接连接以后才能输入。
◆ var ipAddress : string
描述:该玩家的IP 地址。
◆ var port : int
描述:该玩家的端口号。
构造函数
◆ static function NetworkPlayer(ip : string , port : int) : NetworkPlayer
描述:
函数
◆ function ToString() : string
描述:返回该网络玩家的指数。
类方法
◆ static operator != (lhs : NetworkPlayer,rhs : NetworkPlayer):bool
描述:如果两个NetworkPlayers 不是同一个玩家返回真
◆ static operator == (lhs : NetworkPlayer,rhs : NetworkPlayer):bool
描述:如果两个NetworkPlayers 是同一个玩家返回真
NetworkViewID
在一个多玩家游戏中,NetworkViewID 是用于网络视实例的唯一标识符。
这个是重要的,因为这个在所有客户端是唯一的数字,并且客户端自己可以产生这些数字,
否则网络同步将被断开。
变量
◆ var isMine : bool
描述:如果是被我实例化的,返回真。
◆ var owner : NetworkPlayer
描述:拥有NetworkView 的NetworkPlayer。可以是服务器。
函数
◆ function ToString() : string
描述:返回NetworkViewID 中的格式化字符串细节。
类方法
◆ static operator != (lhs : NetworkViewID,rhs : NetworkViewID):bool
描述:如果两个NetworkViewIDs 不是同一个玩家返回真
◆ static operator == (lhs : NetworkViewID,rhs : NetworkViewID):bool
描述:如果两个NetworkViewIDs 是同一个玩家返回真
Network

网络类是网络实现的核心并提供核心函数。
这个类定义了网络接口和所有网络参数。你可以使用它来设置一个服务器或链接到一个服务
器并有一些列辅助函数来帮助你完成这些功能。获取更多关于编辑器中的信息请参考
Network Maner component reference。
消息传递
◆ function OnConnectedToServer() : void
描述:当成功链接到服务器上时,在客户端调用这个函数。
function OnConnectedToServer() {
Debug.Log("Connected to server");
}//发送本地玩家名称到服务器
◆ function OnDisconnectedFromServer(mode : NetworkDisconnection):void
描述:客户端从服务器上断开时在客户端上调用,但当连接被断开时在服务器上调用。
当链接丢失或被服务器断开时,在客户端调用这个函数。NetworkDisconnection 枚举将标示
连接是否断开或是否连接丢失。连接成功断开时再服务器上调用这个函数( 在
Network.Disconnect 之后)。
function OnDisconnectedFromServer(info : NetworkDisconnection) {
if (Network.isServer) {
Debug.Log("Local server connection disconnected");
}
else {
if (info == NetworkDisconnection.LostConnection)
Debug.Log("Lost connection to the server");
else
Debug.Log("Successfully diconnected from the server");
}
}
◆ function OnFailedToConnect(error : NetworkConnectionError):void
描述:当连接因为某些原因失败时,在客户端上调用该函数。
失败的原因作为NetworkConnectionError 枚举传入。
function OnFailedToConnect(error: NetworkConnectionError){
Debug.Log("Could not connect to server: "+ error);
}
◆ function OnFailedToConnectToMasterServer(error : NetworkConnectionError):void
描述:当连接到主服务器出现问题时,在客户端或服务器端调用该函数。
错误原因作为NetworkConnectionError 枚举传入。
function OnFailedToConnectToMasterServer(info: NetworkConnectionError){
Debug.Log("Could not connect to master server: "+ info);
}
◆ function OnNetworkInstantiate(info : NetworkMessageInfo):void
描述:当一个物体使用NetworkInstantiate 进行网络初始化时在该物体上调用这个函数。这
个对于禁用或启用一个已经初始化的物体组件来说是非常有用的,它们的行为取决于他们是
本地还是远端。注意: 在NetworkMessageInfo 里的networkView 属性不能在
OnNetworkInstantiate 里使用。
function OnNetworkInstantiate (info : NetworkMessageInfo) {
Debug.Log("New object instantiated by " + info.sender);
}
描述:当一个新的玩家成功连接时再服务器上调用这个函数。
private var playerCount: int = 0;
function OnPlayerConnected(player: NetworkPlayer) {
Debug.Log("Player " + playerCount++ + " connected from " + player.ipAddress + ":" +
player.port);
}// 用玩家信息构建一个数据结构
◆ function OnPlayerDisconnected(player : NetworkPlayer) : void
描述:当玩家从服务器断开时再服务器上调用这个函数。
function OnPlayerDisconnected(player: NetworkPlayer) {
Debug.Log("Clean up after player " + player);
Network.RemoveRPCs(player);
Network.DestroyPlayerObjects(player);
}
◆ function OnSerializeNetworkView(stream : BitStream, info : NetworkMessageInfo) : void
描述:用来在一个被网络视架空的抄本中自定义变量同步。
它自动决定被序列化的变量是否应该发送或接收。这个依赖于谁拥有这个物体,例如,拥有
者发送,而其他所有的接收。
//该物体的生命值信息
var currentHealth : int;
function OnSerializeNetworkView(stream : BitStream, info : NetworkMessageInfo){
var health : int = 0;
if (stream.isWriting){
health = currentHealth;
stream.Serialize(health);
}
else{
stream.Serialize(health);
currentHealth = health;
}
}
◆ function OnServerInitialized() : void
描述:当Network . InitializeServer 被调用并完成时,在服务器上调用这个函数。
function OnServerInitialized() {
Debug.Log("Server initialized and ready");
}
类变量
◆ static var connections : NetworkPlayer[]
描述:所有连接上的玩家。在客户端中,该变量只包含服务器。
function OnGUI() {
if (GUILayout.Button ("Disconnect first player")) {
if (Network.connections.length > 0) {
Debug.Log("Disconnecting:
"+Network.connections[0].ipAddress+":"+Network.connections[0].port);
Network.CloseConnection(Network.connections[0], true);
}
}
}
◆ static var ConnectionTesterIP:string
描述:用在Network.TestConnection 中的连接测试的IP 地址。
function ResetIP() {
Network.connectionTesterIP = "127.0.0.1";
Network.connectionTesterPort = 10000;
}
◆ static var connectionTesterPort:int
描述:用在Network.TestConnection 中的连接测试的IP 端口。
function ResetIP() {
Network.connectionTesterIP = "127.0.0.1";
Network.connectionTesterPort = 10000;
}
◆ static var incomingPassword:string
描述:为这个服务器设置密码(对于进入的连接)。这个必须与客户端上Network.Connect
中的相同,传递””表示没有密码(默认)。
function ConnectToServer () {
Network.Connect("127.0.0.1", 25000, "HolyMoly");
}
function LaunchServer () {
Network.incomingPassword = "HolyMoly";
Network.InitializeServer(32, 25000);
}
◆ static var isClinet:bool
描述:如果你的端类型是客户端则返回真。
function OnGUI() {
if (Network.isServer)
GUILayout.Label("Running as a server");
else if (Network.isClient)
GUILayout.Label("Running as a client");
}
◆ static var isMessageQueueRunning:bool
描述:启用或禁用网络消息处理。如果这个被禁用,没有RPC 调用或网络视同步会替代。
Network level loading 有如何使用这个函数的例子。
◆ static var isServer:bool
描述如果你的端类型是服务器端则返回真。
function OnGUI() {
if (Network.isServer)
GUILayout.Label("Running as a server");
else if (Network.isClient)
GUILayout.Label("Running as a client");
}
◆ static var maxConnections:int
描述:设置允许的连接/玩家的最大数量。设置0,以为这没有心的连接可以被建立。但现有
保持连接。设置为-1 表示最大连接数被设置为与当前开发的连接数相同。在这种情况下,
如果一个玩家掉线, 那么这个空位还是为他开放的。这个不能设置为高于
Network.InitializeServer 设置的连接数。
function StartGameNow() {
// 不允许更多玩家
Network.maxConnections = -1;
}
◆ static var minimumAllocatableViewIDs:int
描述:在ViewIDc 池中获取或设置服务器分配给客户端ViewID 的最小数。当玩家使用新的
数字连接并被刷新时,ViewID 池被分配给每个玩家。服务器和客户端应该同步这个值。在
服务器上设置的更高,将会发送比它们真正需要的更多视ID 数到客户端。在客户端上设置
更高,意味着它们需要更多视ID。例如当池需要的ID 数,服务器中并不包含足够的数量,
则会在一行中使用两次。默认值为100。如果一个游戏通过网络实例化大量新的物体,例如
每秒超过100 个的网络实例,那么这个值需要被设置的更高。
function Awake () {
// 使用更大的视ID 池来分配
Network.minimumAllocatableViewIDs = 500;
}
◆ static var natFacilitatorIP:string
描述:NAT 穿透辅助的IP 地址。通常这与服务器相同。
function ResetIP() {
Network.natFacilitatorIP = "127.0.0.1";
Network.natFacilitatorPort = 10001;
}
static var natFacilitatorPort:int
描述:NAT 穿透辅助的端口。
function ResetIP() {
Network.natFacilitatorIP = "127.0.0.1";
Network.natFacilitatorPort = 10001;
}
◆ static var peerType:NetworkPeerType
描述:端类型状态。例如,断开连接,连接,服务器或客户端。
function OnGUI() {
if (Network.peerType == NetworkPeerType.Disconnected)
GUILayout.Label("Not Connected");
else if (Network.peerType == NetworkPeerType.Connecting)
GUILayout.Label("Connecting");
else
GUILayout.Label("Network started");
}
◆ static var player:NetworkPlayer
描述:获取本地NetworkPlayer 实例。
◆ static var ProxyIP:string
描述:代理服务器的IP 地址。
function Awake(){
Network.proxyIP = "1.1.1.1";
Network.proxyPort = 1111;
}
◆ static var proxyPassword:string
描述:设置代理服务器密码。可以制作你自己的代理服务器。在这种情况下,你也许想用密
码保护它。然后Unity 玩家必须正确的设置这个值。
function Awake(){
//设置自定义代理服务器地址和密码
Network.proxyIP = "1.1.1.1";
Network.proxyPort = 1111;
Network.proxyPassword = "secret";
}
◆ static var proxyPort:int 描述:代理服务器的端口。
function Awake(){
Network.proxyIP = "1.1.1.1";
Network.proxyPort = 1111;
}
◆ static var sendRate:float 描述:用于所有网络视的默认网络更新发送速率。
function Awake () {
//增加默认的发送速率
Network.sendRate = 25;
}
◆ static var sendRate:float
描述:获取当前网络时间(秒)。这个可以用来比较NetworkMessageInfo 中返回的时间。这
个实例脚本需要附加到一个带有网络视的物体上,并使网络视监视这个脚本。它管理时间,
发送这个物体的同步X 位置消息。
var something : float;
var transitTime: double;
function OnSerializeNetworkView (stream : BitStream, info : NetworkMessageInfo) {
var horizontalInput : float = 0.0;
if (stream.isWriting) {//发送
horizontalInput = transform.position.x;
stream.Serialize (horizontalInput);
}
else {//接收
transitTime = Network.time - info.timestamp;
stream.Serialize (horizontalInput);
something = horizontalInput;
}
}
function OnGUI() {
GUILayout.Label("Last transmission time: "+ transitTime);
}
◆ static var useNat:bool
描述:当连接(客户端)或接收连接(服务器)时,我们应该使用NAT 穿透吗?如果这个
在在服务器上设置,只有具有NAT 穿透的客户端才能连接到它。但是如果服务器有一个NAT
地址,这个需要打开以便连接。有些路由器不知道如何做NAT 穿透。因此对于这些玩家唯
一的方法就是修改路由器以便打开合适的转发端口( 游戏端口)。参考
Network.TestConnection 和Network.TestConnectionNAT 获取如何自动检测端用户的方法。
function OnGUI() {
if (GUILayout.Button ("Start Server"))
{
//如果没有共有IP 地址,使用NAT 穿透
Network.useNat = !Network.HavePublicAddress();
Network.InitializeServer(32, 25002);
MasterServer.RegisterHost("MyUniqueGameType", "JohnDoes game", "l33t game for all");
}
}
◆ static var useProxy:bool
描述:标示是否需要代理服务器支持,在这种情况下流量通过代理服务器被延迟。代理伺服
器是一种与服务器和客户端连接性问题的解决方案。当机器有一个非NAT 穿透能力的路由
器,其连接的选择非常优先。一个游戏不能没有外部连接(只有客户端在本地网络中)。通
过使用代理服务器,该机器可以具有完全的连接性,但是额外的代价是所有的流量都会被延
迟。一个没有NAT 穿透能力的客户端通过代理能够连接到任何服务器,只要代理服务器正
确的设置。官方并不提供代理服务器为公众使用。所以你需要自己建立代理服务器。当然,
用共有IP 地址设置代理服务器并保证有大量可用带宽是明智的。当作为客户端运行时,只
要启用Network .useProxy 就可以。想往常昂使用Network . Connect 连接到服务器。所有通
过代理服务器的流量将被延迟。服务器的外部IP 和内部IP 还像往常一样工作。这样如果它
们位于同一网络中,客户端可以直接连接到它而不需要代理。作为一个服务器运行时,
OnServerInitialized(NetworkPlayer)返回一个NetworkPlayer 结果表明游戏服务器中转的IP 端
口,代理服务器分配给游戏服务器的端口是什么。这个是其他客户端可以连接到的IP 端口。
当连接到服务器时,客户端不会将这个服务器与其他服务器区别对待。严格的说,它们不需
要知道这个服务器得到代理服务器的帮助。当使用主服务器时,你不能只依赖于它在使用代
理服务器时为服务器注册的IP 端口。服务器使用的代理服务器的IP 地址和端口,可以防止
在数据域的注释中来发送给主服务器。从主服务器接收主机信息的客户端可以去除注释域并
查看它是否能够为那个主机使用另一个可选的IP 端口。
重要:你不应该同时为连接到它的服务器和客户端启用代理支持,会发生意想不到的事情。
var imaserver: boolean;
var serverIP: String;
var serverPort: int;
var serverUsesNAT: boolean;
function Awake(){
//设置自定义代理服务器地址
Network.proxyIP = "1.1.1.1";
Network.proxyPort = 1111;
if (imaserver)
StartServerWithProxy();
else
ConnectToServerWithProxy();
}
function StartServerWithProxy(){
Network.useProxy = true;
Network.InitializeServer(2,25000);
}
function OnServerInitialized(player: NetworkPlayer){
if (Network.useProxy)
Debug.Log ("Successfully started server with proxy support. We are connectable through "+
player.ipAddress + ":" + player.port);
}
function OnFailedToConnect(msg: NetworkConnectionError){
if (Network.useProxy && imaserver){
Debug.LogError("Failed to connect to proxy server: " + msg);
}
}
function ConnectToServerWithProxy(){
Network.useProxy = true;
Network.useNat = serverUsesNAT;
Network.Connect(serverIP, serverPort);
}
function OnConnectedToServer(){
Debug.Log("Connected successfully to server");
}
类方法
◆ static function AllocateViewID():NetworkViewID
描述:查询下一个可用的网络视ID 数并分配它(保留)。这个数字又可以被赋予一个实例
化物体的网络视。注意,为了使其可正常工作,必须有一个NetworkView 附加到这个物体,
这个物体必须有这个脚本并必须使这个脚本作为它的观察属性。必须有一个Cube 预设,带
有一个NetworkView 它监视某些东西(例如该Cube 的Transform)。脚本中的cubePrefab 变
量必须设置为立方体预设。使用智能的AllocateViewID 是最简单的方法。如果有超过一个
NetworkView 附加在初始化的Cube 上着将变得更复杂。
var cubePrefab : Transform;
function OnGUI (){
if (GUILayout.Button("SpawnBox")){
var viewID = Network.AllocateViewID();
networkView.RPC("SpawnBox", RPCMode.AllBuffered, viewID, transform.position);
}
}
@RPC
function SpawnBox (viewID : NetworkViewID, location : Vector3) {
//实例化本地的prefab
var clone : Transform;
clone = Instantiate(cubePrefab, location, Quaternion.identity);
var nView : NetworkView;
nView = clone.GetComponent(NetworkView);
nView.viewID = viewID;
}
◆ static function CloseConnection (target : NetworkPlayer, sendDisconnectionNotification :
bool) : void
描述:关闭与其他系统的连接。/target/定义连接到的那个系统将被关闭,如果我们是客户端,
连接到服务器的连接将会关闭。如果我们是服务器目标玩家, 将会被踢出。
sednDisconnectionNotification 启用或禁用通知将被发送到另一端。如果禁用连接被丢弃,如
果没有断开连接通知被发送到远端,那么之后的连接将被丢弃。
function OnGUI() {
if (GUILayout.Button ("Disconnect from server")) {
if (Network.connections.length == 1) {
Debug.Log("Disconnecting:
"+Network.connections[0].ipAddress+":"+Network.connections[0].port);
Network.CloseConnection(Network.connections[0], true);
}
else if (Network.connections.length == 0)
Debug.Log("No one is connected");
else if (Network.connections.length > 1)
Debug.Log("Too many connections. Are we running a server?");
}
if (GUILayout.Button ("Disconnect first player")) {
if (Network.connections.length > 0) {
Debug.Log("Disconnecting:
"+Network.connections[0].ipAddress+":"+Network.connections[0].port);
Network.CloseConnection(Network.connections[0], true);
}
}
}
◆ static function Connect (IP:string, remotePort:int, password:string =
""):NetworkConnectionError
描述:连接到特定的主机(IP 或域名)和服务器端口。参数是主机的IP 地址,点IP 地址或
一个域名。remotePort,指定连接到远端机器的端口。password,它是一个可选的用于服务
器的密码。这个密码必须设置为与服务器的Network.incomingPassword 相同。
function ConnectToServer () {
Network.Connect("127.0.0.1", 25000);
}
◆ static function Connect(IPs:string[], remotePort:int, password:string =
""):NetworkConnectionError
描述:该函数与Network.Connect 类似,但是可以接受一个IP 地址数组。当从一个主服务器
的主机信息返回多个内部IP 地址时,IP 数据结构可以被直接传入这个函数。它将实际的连
接到相应ping 的第一个IP(可连接)。
◆ static function Destroy (viewID : NetworkViewID) : void
描述:跨网络销毁与该视ID 相关的物体。本地的于远端的都会被销毁。
var timer : float;
function Awake () {
timer = Time.time;
}
//通过网络销毁拥有该脚本的物体
//其必须具备NetworkView 属性
function Update() {
if (Time.time - timer >
2)
{
Network.Destroy(GetComponent(NetworkView).viewID);
}
}
function Update() {
if (Time.time - timer > 2){
Network.Destroy(GetComponent(NetworkView).viewID);
}
}
◆ static function Destroy (gameObject : GameObject) : void
描述:跨网络销毁该物体。本地的与远端的都会被销毁。
var timer : float;
function Awake () {
timer = Time.time;
}//通过网络销毁拥有该脚本的物体
function Update() {
if (Time.time - timer > 2){
Network.Destroy(gameObject);
}
}
◆ static function DestroyPlayerObjects (playerID : NetworkPlayer) : void
描述:基于视ID 销毁所有属于这个玩家的所有物体。这个只能在服务器上调用。例如,清
理一个已断开的玩家留下的网络物体。
function OnPlayerDisconnected(player: NetworkPlayer) {
Debug.Log("Clean up after player " + player);
Network.RemoveRPCs(player);
Network.DestroyPlayerObjects(player);
}
◆ static function Disconnect (timeout : int = 200) : void
描述:关闭所有开放的连接并关闭网络接口。timeout 参数表示网络接口在未收到信号的情
况下,多长时间会关闭。网络状态,入安全和密码,也会被重置。
function OnGUI() {
if (GUILayout.Button ("Disconnect")) {
Network.Disconnect();
MasterServer.UnregisterHost();
}
}
◆ static function GetAveragePing (player : NetworkPlayer) : int
描述:到给定player 的最后平均ping 时间,以毫秒计。如果没有发现玩家,返回-1。Ping
会每隔几秒自动发出。
function OnGUI() {
var i: int;
GUILayout.Label("Player ping values");
for (i=0; i < Network.connections.length; i++) {
GUILayout.Label("Player " + Network.connections[i] + " - " +
Network.GetAveragePing(Network.connections[i]) + " ms");
}
}、
◆ static function GetLastPing (player : NetworkPlayer) : int
描述:到给定player 的最后平均ping 时间,以毫秒计。
如果没有发现玩家,返回-1。Ping 会每隔几秒自动发出。
function OnGUI() {
var i: int;
GUILayout.Label("Player ping values");
for (i=0; i < Network.connections.length; i++) {
GUILayout.Label("Player " + Network.connections[i] + " - " +
Network.GetLastPing(Network.connections[i]) + " ms");
}
}
◆ static function HavePublicAddress () : bool
描述:检查该机器是否有一个公共IP 地址。检查所有接口来获取Ipv4 公共地址。如发现返
回真。
function OnGUI() {
if (GUILayout.Button ("Start Server")){
// 如果没有公共IP 地址,使用NAT 穿透
Network.useNat = !Network.HavePublicAddress();
Network.InitializeServer(32, 25002);
MasterServer.RegisterHost("MyUniqueGameType", "JohnDoes game", "l33t game for all");
}
}
◆ static function InitializeSecurity () : void
描述:初始化安全层。你需要再Network.InitializeServer 调用之后在服务器上调用这个函数。
不要再客户端调用该函数你的在线游戏达到一定知名度时就有人试图作弊。你讲需要再游戏
层和网络层处理这个。如果你希望使用它们,Unity 可以通过提供安全连接处理网络层。
使用AES 加密,阻止未授权读取并阻止重复攻击,添加CRC 来检测数据篡改,使用随机的、
加密的SYNCookies 来组织未授权登录,使用RSA 加密保护这个AES 密钥
大多数游戏将使用安全连接。然后,它们会向每个数据包添加15 自己并需要时间计算,所
以你也许想限制使用此功能。
function Start (){
Network.InitializeSecurity();
Network.InitializeServer(32, 25000);
}
◆ static function InitializeServer (connections:int,listenPort:int) : NetworkConnectionError
描述:初始化安全层。connections 是允许进入的连接或玩家的数量。listenPort 是我们要监
听的端口。
function LaunchServer () {
Network.incomingPassword = "HolyMoly";
Network.InitializeServer(32, 25000);
}
◆ static function Instantiate (prefab:Object, position:Vector3, rotation:Quaternion,
group:int):Object
描述:网络实例化预设。给定的预设将在所有的客户端上初始化。同步被自动设置所以没有
额外的工作需要做。位置、旋转和网络组数值作为给定的参数。这是一个RPC 调用,因此
当Network.RemoveRPCs 为这个组调用的使用,这个物体将被移除。注意在编辑器中必须设
置playerPrefab,你能在Object.Instantiate 物体参考中获取更多实例化信息。
//当成功连接到服务器上时
//立即实例化新连接的玩家角色
var playerPrefab : Transform;
function OnConnectedToServer (){
Network.Instantiate(playerPrefab, transform.position, transform.rotation, 0);
}
◆ static function RemoveRPCs (playerID : NetworkPlayer) : void
描述:移除所有属于这个玩家ID 的RPC 函数。
function OnPlayerDisconnected(player: NetworkPlayer) {
Debug.Log("Clean up after player " + player);
Network.RemoveRPCs(player);
Network.DestroyPlayerObjects(player);
}
◆ static function RemoveRPCs (playerID : NetworkPlayer, group : int) : void
描述:移除所有属于这个玩家ID 并给予给定组的所有RPC 函数。
◆ static function RemoveRPCs (viewID : NetworkViewID) : void
描述:移除所有与这个视ID 数相关的RPC 函数调用。
◆ static function RemoveRPCsInGroup (group : int) : void
描述:移除所有属于给定组数值的RPC 函数。
◆ static function SetLevelPrefix (prefix : int) : void
描述:设置关卡前缀,然后所有网络视ID 都会使用该前缀。此处提供了一些保护,可以防
止来自前一个关卡的旧的网络更新影响新的关卡。此处可以设置为任何数字并随着新关卡的
加载而增加。这不会带来额外的网络负担,只会稍微减小网络视ID 池。Network level loading
有如何使用该函数的例子。
◆ static function SetReceivingEnabled (player : NetworkPlayer, group : int, enabled : bool) : void
描述:启用或禁用特定组中来自特定玩家的信息接收。在你不希望任何网络消息进入的时候
可以使用这个函数,然后在你准备好的时候启用。例如,可用于停止网络消息,知道关卡被
加载。
//停止接收来自所有玩家(客户端)的组0 的信息
for (var player : NetworkPlayer in Network.connections)
Network.SetReceivingEnabled(player, 0, false);
◆ static function SetSendingEnabled (group : int, enabled : bool) : void
描述:启用或禁用特定网络组上的信息传输和RPC 调用。当你知道你不发送任何有用的信
息到其他客户端时,可以设置这个。例如在你完全你家在关卡之前。Network level loading
中有例子。
static function SetSendingEnabled (player : NetworkPlayer, group : int, enabled : bool) : void
描述:基于目标玩家和网络组启用或禁用消息传说和RPC 调用。当在客户端使用时,唯一
可能的NetworkPlayer 就是服务器。
◆ static function TestConnection (forceTest : bool = false) : ConnectionTesterStatus
描述:测试这个机器的网络连接。执行两种测试,这取决机器有公用IP 还是只有一个私有
IP。公用IP 测试主要用于服务器,不需要测试具有公用地址的客户端。为了公用IP 测试成
功,必须开启一个服务器实例。一个测试服务器将尝试连接到本地服务器的IP 地址和端口,
因此它被显示在服务器中位可连接状态。如果不是,那么防火墙是最有可能阻断服务端口的。
服务器实例需要运行以便测试服务器能连接到它。另一个试验检测NAT 穿透能力。服务器
和客户端都可以进行,无需任何事先设定。如果用于服务器NAT 测试失败,那么不设置端
口转发是一个坏主意。本地LAN 网络之外的客户端将不能连接。如果测试失败,客户端就
不能使用NAT 连接到服务器,这些服务器将不会提供给用户作为主机。这个函数是异步的,
并可能不会返回有效结果。因为这个测试需要一些时间来完成( 1-2 秒)。测试完成后,测
试的结果只在函数被再次调用时返回。这样,频繁访问该函数是安全的。如果需要其他的测
试,入网络连接已改变,那么forcTest 参数应该为真。该函数返回一个ConnectionTesterStatus
枚举。
//是否应该在主机列表上隐藏NAT 主机?
private var filterNATHosts = false;
private var doneProbingPublicIP = false;
function OnGUI (){
//开始/轮询连接测试
//在标签上显示结果并按照结果做出相应的反应
natCapable = Network.TestConnection();
if (natCapable == -2)
GUILayout.Label("Problem determining NAT capabilities");
else if (natCapable == -1)
GUILayout.Label("Undetermined NAT capabilities");
else if (natCapable == 0){
GUILayout.Label("Cannot do NAT punchthrough, " +"filtering NAT enabled hosts for client
connections, " +"impossible to run a server.");
filterNATHosts = true;
Network.useNat = false;
}
else if (natCapable == 1){
if (doneProbingPublicIP)
GUILayout.Label("Non-connectable public IP address (port "+ serverPort +" blocked), NAT
unchthrough can circumvent the firewall.");
else
GUILayout.Label("NAT punchthrough capable. " +"Enabling NAT punchthrough functionality.");
//一旦服务器开始NAT 功能被启用
//客户端是否开启这个基于主机是否需要
Network.useNat = true;
}
else if (natCapable == 2){
GUILayout.Label("Directly connectable public IP address.");
Network.useNat = false;
}
else if (natCapable == 3){
GUILayout.Label("Non-connectble public IP address (port " + serverPort +" blocked), running a
server is impossible.");
Network.useNat = false;
if (!doneProbingPublicIP){
natCapable = Network.TestConnectionNAT();
doneProbingPublicIP = true;
}
}
else if (natCapable == 4){
GUILayout.Label("Public IP address but server not initialized, "+"it must be started to check
server accessibility.");
Network.useNat = false;
}
if (GUILayout.Button ("Retest connection")){
Debug.Log("Redoing connection test");
doneProbingPublicIP = false;
natCapable = Network.TestConnection(true);
}
}
◆ static function TestConnectionNAT () : ConnectionTesterStatus
描述:测试NAT 穿透的连接性。这个就像Network.TestConnection,只不过NAT 穿透是强
制的,即使该机器有一个公用地址。请参考Network.TestConnection。
Object

Unity 所涉及的所有物体的基类。任何从Object 继承的公有变量将作为一个目标显示在监视
面板中,允许你从GUI 中设置。
变量
◆ var hideFlags : HideFlags 描述:该物体是否被隐藏,保存在场景中或被用户修改。
◆ var name : string
描述:对象的名称。组件与游戏物体和所有附加的组件共享相同名称。
//改变物体的名称为Hello
name = "Hello";
函数
◆ function GetInstanceID () : int 描述:返回该物体的实例id。一个物体的实例ID 总是唯一。
描述:返回该物体的实例id。
一个物体的实例id 总是唯一的。
print(GetInstanceID());
类方法
◆ static function Destroy (obj : Object, t : float = 0.0F) : void
描述:移除一个游戏物体,组件或资源。物体obj 将被小火或者t 秒后被销毁。如果obj 是
一个Component 它将被从GameObject 中移除。如果obj 是一个GameObject 它将销毁这个
GameObject,以及它的组件和所子对象。实际的销毁总是推迟到下个Update 来临时,但总
在渲染前完成。
//销毁这个游戏物体
Destroy (gameObject);
//从物体上移除该脚本
Destroy (this);
//从游戏物体上移除刚体组件
Destroy (rigidbody);
//加载该游戏物体后5 秒删除
Destroy (gameObject, 5);
//当玩家按下Ctrl 时移除名为FoooScript 的脚本
function Update () {
if (Input.GetButton ("Fire1") && GetComponent (FooScript))
Destroy (GetComponent (FooScript));
}
◆ static function DestroyImmediate (obj : Object, allowDestroyingAssets : bool = false) : void
描述:立即销毁物体。强烈建议使用Destroy 代替它。该函数应该只在编写编辑器代码时使
用,因为延迟的销毁将不会再编辑器模式调用。游戏代码中建议使用Destroy。Destroy 总是
延迟的(但是在同一帧执行)。小心使用该函数,因为它能永久的销毁资源。
◆ static function DontDestroyOnLoad (target : Object) : void
描述:加载新场景时确保物体target 不被自动销毁。当加载一个新的关卡时,场景中的所有
物体都会被销毁,然后心关卡中的物体将被加载。为了在关卡加载的时候保持物体在上面调
用DontDestroyOnLoad。如果物体是一个组件或游戏物体,那么它的整个变换层次将不会被
销毁。
//保证该游戏物体及其变化子物体在载入新场景时不会被销毁。
function Awake () {
DontDestroyOnLoad (this);
}
◆ static function FindObjectOfType (type : Type) : Object
描述:返回第一个类型为Type 的已激活加载的物体。参见Object.FindObjectsOfType 。
◆ static function FindObjectsOfType (type : Type) : Object[]
描述:返回所有类型为Type 的已激活加载的物体。
参见Object.FindObjectsOfType 。
它将返回任何资源(网格、纹理、预设等)或已激活加载的物体。
//当点击该物体,它将禁用场景中所有铰链中的弹簧。
function OnMouseDown () {
hinges = FindObjectsOfType (HingeJoint);
for (var hinge : HingeJoint in hinges) {
hinge.useSpring = false;
}
}
c#版
public class Something : MonoBehaviour{
void OnMouseDown(){
HingeJoint[] hinges = FindObjectsOfType<HingeJoint>();
for (HingeJoint hinge in hinges) {
hinge.useSpring = false;
}
}
}
◆ static function Instantiate (original : Object, position : Vector3, rotation : Quaternion) : Object
描述:克隆original 物体并返回该克隆。防御position 兵设置旋转为rotation,然后返回该克
隆。本职上与cmd-d 相同,并移动到给定位置。如果一个游戏物体、组件或脚本实例被传入,
Instantiate 将克隆整个游戏物体层次,所有的子对象也被克隆。所有游戏物体被激活。参加:
预设实例化的深入讨论。
//实例化预设的10 个拷贝,间隔为2 单位。
var prefab : Transform;
for (var i=0;i<10;i++) {
Instantiate (prefab, Vector3(i * 2.0, 0, 0), Quaternion.identity);
}
Instantiate 更多常用于实例化投射物、AI 敌人,粒子爆炸或b 破损的物体。
//实例化一个刚体,然后设置速度。
var projectile : Rigidbody;
function Update () {
//按下ctrl 时,发射一个物体
if (Input.GetButtonDown("Fire1")) {
//以该变化位置与旋转实例化投射物
var clone : Rigidbody;
clone = Instantiate(projectile, transform.position, transform.rotation);
//沿当前物体Z 轴,给克隆体一个初始速度
clone.velocity = transform.TransformDirection (Vector3.forward * 10);
}
}
实例化也能直接克隆脚本实例。整个游戏物体层级将被克隆,并且克隆脚本的实例将被返回。
//初始化一个附加了Missile 脚本的预设
var projectile : Missile;
function Update () {
//按下ctrl 时,发射一个物体
if (Input.GetButtonDown("Fire1")) {
//以该变化位置与传转实例化投射物
var clone : Missile;
clone = Instantiate(projectile, transform.position, transform.rotation);
//设置火箭超市销毁为5 秒
clone.timeoutDestructor = 5;
}
}
克隆一个物体之后可以使用GetComponet 来设置附加到克隆物体上的特定组件的属性。
◆ static function Instantiate (original : Object) : Object
描述:克隆original 物体并返回该克隆。这个函数保留克隆物体的位置与赋值命令相同
(cmd-d)。
//当任何刚体进入这个触发器时实例化预设。
//它保留预设的原始位置与旋转。
var prefab : Transform;
function OnTriggerEnter () {
Instantiate (prefab);
}
◆ static operator != (x : Object, y : Object) : bool
描述:比较两个物体是否不同。
var target : Transform;
function Update (){
//如果target 不同于我们的变换。
if (target != transform){
print("Another object");
}
}
◆ static operator == (x : Object, y : Object) : bool
描述:比较两个物体是否相同。
var target : Collider;
function OnTriggerEnter (trigger : Collider){
if (trigger == target)
print("We hit the target trigger");
}
var target : Transform;
function Update (){
//该物体已被销毁。
if (target == null)
return;
}
◆ static implicit function bool (exists : Object) : bool
描述:这个物体是否存在?
if(rigidbody)
等同于
if(rigidbody != null)
AnimationClip
类,继承自Object。
存贮基于动画的关键帧。
AnimationClip 被Animation 使用来播放动画。
变量
◆ var frameRate : float
描述:关键帧被残阳的帧率。这个与用来制作动画/模型的动画程序相同。
//打印动画剪辑的帧率到控制台。
print(animation["walk"].clip.frameRate);
◆ var length : float
描述:动画播放的描述。
animation.Play(animation.clip);
//等待动画完成。
yield WaitForSeconds (animation.clip.length);
◆ var wrapMode : WrapMode
描述:在动画状态中设定默认的卷模式。
构造函数
◆ static function AnimationClip () : AnimationClip
描述:创建一个新的动画剪辑。
函数
◆ function AddEvent (evt : AnimationEvent) : void
描述:创建一个新的动画剪辑。这将添加这个时间直到退出播放模式或玩家退出。如果你想
从编辑器添加一个固定的剪辑到AnimationEvent , 使用
UnityEditorAnimationUtility.SetAnimationEvents。
◆ function ClearCurves () : void
描述:从剪辑中清理所有曲线。
◆ function SetCurve (relativePath : string, type : Type, propertyName : string, curve :
AnimationCurve) : void
参数
relativePath 应用这个曲线的游戏物体的路径。relativePath 被格式化为一个路径名。入:
“root/spine/leftArm”如果relativePath 为空,表示该动画剪辑所附加的游戏物体。
type 被进行动画处理的组件的类类型。
propertyName 被动画处理的属性的名称或路径。
curve 动画曲线。
描述:给动画指定一个特定的曲线属性。如果曲线为null 该曲线将被移除。如果曲线为null
该曲线将被移除。如果曲线属性已经存在,则会被替换。通常的名称是:“localPostion.x”,
“localPostion.y”,“localPostion.z”,“localRotation.x”,“localRotation.y”,“localRotation.z”,
“localRotation.w”,“localScale.x”,“localScale.y”,“localScale.z”。出于性能考虑Transform
的位置、旋转和缩放只能被所谓一个动画属性。
//对x 坐标的位置进行动画处理
function Start (){
//创建曲线
var curve = AnimationCurve.Linear(0, 1, 2, 3);
//用曲线创建剪辑
var clip = new AnimationClip();
clip.SetCurve("", Transform, "localPosition.x", curve);
//添加并播放剪辑
animation.AddClip(clip, "test");
animation.Play("test");
}
@script RequireComponent(Animation)
Material 属性可以使用shader 到处的名称制作动画属性。通常的属性名称是:“_MainTex”,
“_BumpMap”,“_LightMap”,“_Color”,“_SpecColor”,“_Emmission”。
Float 属性“PropertyName”
Vector4 属性“PropertyName.x”“PropertyName.x” “PropertyName.x” “PropertyName.x” Color 属
性“PropertyName.r”“PropertyName.g”“PropertyName.b”“PropertyName.a”
UV 旋转属性“PropertyName.rotation” ; UB 便宜和缩放
“PropertyName.offset.x”“PropertyName.offset.y”“PropertyName.scale.x”“PropertyName.scale.y”
对于在同一个Renderer 上的多个索引材质,你可以像这样加前缀“[1]._MainTex.offset.y”。
//对alpha 值和主要材质地平线补偿进行动画处理
function Start () {
var clip = new AnimationClip ();
clip.SetCurve ("", typeof(Material), "_Color.a",AnimationCurve (Keyframe(0, 0, 0, 0),
Keyframe(1, 1, 0, 0)));
clip.SetCurve ("", typeof(Material), "_MainTex.offset.x",AnimationCurve.Linear(0, 1, 2, 3));
animation.AddClip (clip, clip.name);
animation.Play(clip.name);
}
@script RequireComponent(Animation)
继承的成员
继承的变量
name 对象名称
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改
继承的函数
GetInstanceID 返回该物体的实例id
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代理。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
AssetBundle
类,继承自Object。AssetBundles 让你通过WWW 类流式加载额外的资源并在运行时实例化
它们。AssetBundles 通过BuildPipeline.BuildAssetBundle 创建。参见:WWW.assetBundle ,
Loading Resources at Runtime ,BuildPipeline.BuildPlayer
function Start () {
var www = new WWW ("http://myserver/myBundle.unity3d");
yield www;
//获取指定的主资源并实例化
Instantiate(www.assetBundle.mainAsset);
}
变量
◆ var mainAsset : Object
描述:竹资源在构建资源boundle 时指定(只读)。该功能可以方便的找到bundle 内的主资
源。例如,你也许想将预设一个角色并包括所有纹理、材质、网格和动画文件。但是完全操
纵角色的预设应该是你的mainAsset 并且可以被容易的访问。
function Start () {
var www = new WWW ("http://myserver/myBundle.unity3d");
yield www;
//获取指定的主资源并实例化
Instantiate(www.assetBundle.mainAsset);
}
函数
◆ function Contains (name : string) : bool
描述:如果AssetBundle 的名称中包含特定的对象则进行检索。如果包含则返回真。
◆ function Load (name : string) : Object
描述:从bundle 中加载名为name 的物体。
◆ function Load (name : string, type : Type) : Object
描述:从bundle 中加载名为name 的type 类物体。
◆ function LoadAll (type : Type) : Object[ ]
描述:加载所有包含在资源bundle 中且继承自type 的物体。
◆ function LoadAll () : Object[ ]
描述:加载包含在资源bundle 中的所有物体。
◆ function Unload (unloadAllLoadedObjects : bool) : void
描述: 写在bundle 中的所有资源。Unload 释放bundle 中所有序列化数据。当
unloadAllLoaderObjects 为假,bundle 内的序列化数据将被写在,但是任何从这个bundle 中
实例化的物体都将完好。当然, 你不能从这个bundle 中加载更多物体。当
unloadAllLoaderObjects 为真,所有从该bundle 中加载的物体也将被销毁。如果
场景中有游戏物体引用该资源,那么引用也会丢失。
继承的成员
继承的变量
name 对象名称
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改
继承的函数
GetInstanceID 返回该物体的实例id
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代理。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
AudioClip
类,继承自Object。音频数据的容器。一个AudioClip 以压缩或未压缩的格式存储音频文件。
AudioClips 被AudioSources 参考或引用来播放声音。参见组件参考的AudioClip.component。
变量
◆ var isReadyToPlay : bool
描述:有没流式音频剪辑准备播放?(只读)如果AudioClip 是从网站上下载的,此变量用
来判断下载到的数据是否足够不间断的播放。对于不是来自web 的流的AudioClips,该值总
是真。
function Start (){
www=new WWW(url);
audio.clip=www.audioClip;
}
function Update (){
if(!audio.isPlaying && audio.clip.isReadyToPlay)
audio.Play();
}
◆ var length : float
描述:音频剪辑的长度,以秒计(只读)。
audio.Play();
//等待音频播放完成
yield.WaitForSeconds(audio.clip.length);
继承的成员
继承的变量
name 对象名称
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改
继承的函数
GetInstanceID 返回该物体的实例id
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代理。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
Component
类,继承自Object。音频数据的容器。所有附加到游戏物体上的对象的基类。
变量
◆ var animation : Animation
描述:附加到这个GameObject 的Animation。(没有则为null)
◆ var audio : AudioSource
描述:附加到这个GameObject 的AudioSource。(没有则为null)
audio.Play()
◆ var camera : Camera
描述:附加到这个GameObject 的Camera。(没有则为null)
◆ var collider : Collider
描述:附加到这个GameObject 的Collider。(没有则为null)
collider.material.dynamicFriction =1
◆ var constantForce : ConstantForce
描述:附加到这个GameObject 上的ConstantForce(没有则为null)。
◆ var gameObject : GameObject
描述:这个组件所附加的游戏物体。组件总是附着在游戏物体上。
print(gameObject.name);
◆ var guiText : GUIText
描述:附加到这个GameObject 上的GUIText(没有则为null)。
guiText.text = "Hello World";
◆ var guiTexture : GUITexture
描述:附加到这个GameObject 上的GUITexture(只读)(没有则为null)。
◆ var hingeJoint : HingeJoint
描述:附加到这个GameObject 的HingeJoint(没有则为null)。
hingeJoint.motor.targetVelocity = 5;
◆ var hingeJoint : HingeJoint
描述:附加到这个GameObject 的HingeJoint(没有则为null)。
◆ var light : Light
描述:附加到这个GameObject 的Light(没有则为null)。
◆ var networkView : NetworkView
描述:附加到这个GameObject 的NetworkView(只读)(没有则为null)。
networkView.RPC("MyFunction", RPCMode.All, "someValue");
◆ var particleEmitter : ParticleEmitter
描述:附加到这个GameObject 的ParticleEmitter(没有则为null)。
particleEmitter.emit = true;
◆ var renderer : Renderer
描述:附加到这个GameObject 的Renderer。(没有则为null)
◆ var rigidbodyr : Rigidbody
描述:附加到这个GameObject 的rigidbody。(没有则为null)
◆ var tag : string
描述:附加到这个GameObject 的rigidbody。标签可以用来标识一个游戏物体。标签在使用
前必须在标签管理器中定义。
◆ var transform : Transform
描述:附加到这个GameObject 的Transform。(没有则为null)
transform.Translate(1, 1, 1);
函数
◆ function BroadcastMessage (methodName : string, parameter : object = null, options :
SendMessageOptions = SendMessageOptions.RequireReceiver) : void
描述:在这个游戏物体或其任何子物体上的每个MonoBehaviour 上调用methodName 方法。
通过使用零参数, 结婚搜方法可以选择忽略parameter 。如果options 被设置为
SednMessageOptions.RequireReceiver,那么如果这个消息没有被任何组件接受时,将打印一
个错误信息。
//使用值5 调用ApplyDamage
BroadcastMessage ("ApplyDamage", 5.0);
//每个附加到该游戏物体及其所有子物体上含有ApplyDamage 函数的脚本都会被调用
function ApplyDamage (damage : float) {
print (damage);
}
◆ function CompareTag (tag : string) : bool
描述:这个游戏物体有被标签为tag 吗?
//立即销毁触发器,销毁任何进入到触发器的碰撞器,这些碰撞器被标记为Player
function OnTriggerEnter (other : Collider) {
if (other.CompareTag ("Player")) {
Destroy (other.gameObject);
}
}
◆ function GetComponent (type : Type) : Component
描述:如果游戏物体上附加了这个组件,则返回一个Type 类,如果没有则返回null。
//等同于Transform curTransform = transform
var curTransform : Transform = GetComponent (Transform);
//你可以像访问其他组件一样的访问脚本组件
function Start () {
var someScript : ExampleScript = GetComponent (ExampleScript);
someScript.DoSomething ();
}
for c#
public class Something : MonoBehaviour{
void Start(){
ExampleScript someScript = GetComponent<ExampleScript>();
someScript.DoSomething ();
}
}
◆ function GetComponent (type : string) : Component
描述:如果游戏物体上附加了这个组件,则返回一个Type 类,如果没有则返回null。处于
性能原因,最好用Type 调用GetComponent 而不是字符串。不过有时你可能无法得到Type。
例如当是同从Javascript 中访问c#时。这时你可以简单的通过名称而不是类型访问该组件。
//为了访问附加在同一物体上的脚本中的公有变量与函数
script = GetComponent(ScriptName);
script.DoSomething ();
◆ function GetComponentInChildren (t : Type) : Component
描述:返回type 类型组件,这个组件位于GameObject 或任何它的子物体上,使用深度优先
搜索。只有激活的最贱会被返回。
var script : ScriptName = GetComponentInChildren(ScriptName);
script.DoSomething ();
for c#
ScriptName script = GetComponentInChildren<ScriptName>();
script.DoSomething ();
◆ function GetComponents (type : type) : Component[]
描述:返回GameObject 上所有type 类型组件。
//关闭该游戏物体铰链上的所有弹簧
var hingeJoints = GetComponents (HingeJoint);
for (var joint : HingeJoint in hingeJoints) {
joint.useSpring = false;
}
for c#
HingeJoint[] hingeJoints = GetComponents<HingeJoint>();
for (HingeJoint joint in hingeJoints) {
joint.useSpring = false;
}
◆ function GetComponentsInChildren (t:Type,includeInactive:bool=false) : Component[]
描述:返回GameObject 上或其子物体上所有type 类型组件。
//关闭该游戏物体极其子物体上的铰链上的所有弹簧
var hingeJoints = GetComponentsInChildren (HingeJoint);
for (var joint : HingeJoint in hingeJoints) {
joint.useSpring = false;
}
for c#
HingeJoint[] hingeJoints = GetComponentsInChildren<HingeJoint>();
for (HingeJoint joint in hingeJoints) {
joint.useSpring = false;
}
继承的成员
继承的变量
name 对象名称
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改
继承的函数
GetInstanceID 返回该物体的实例id
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代理。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
Behaviour
类,继承自Component。Behaviours 是可以被启用或禁用的组件。参见MonoBehaviour 和
Component。
变量
◆ var enabled : bool
描述:启用Behaviours 被更新,禁用Behaviours 不被更新。这将在behaviour 的坚实面板中
显示为一个小的复选框GetComponent(PlayerScript)enabled = false;
继承的成员
继承的变量
transform 附加到该GameObject 的Transform(没有返回null)
rigidbody 附加到该GameObject 的Rigidbody(没有返回null)
camera 附加到该GameObject 的Camera(没有返回null)
light 附加到该GameObject 的Light(没有返回null)
animation 附加到该GameObject 的Animation(没有返回null)
constantForce 附加到该GameObject 的ConstantForce(没有返回null)
renderer 附加到该GameObject 的Renderer(没有返回null)
audio 附加到该GameObject 的Audio(没有返回null)
guiText 附加到该GameObject 的GuiText(没有返回null)
networkView 附加到该GameObject 的NetworkView(没有返回null)
guiTexture 附加到该GameObject 的GuiTexture(没有返回null)
collider 附加到该GameObject 的Collider(没有返回null)
hingeJoint 附加到该GameObject 的HingeJoint(没有返回null)
particleEmitter 附加到该GameObject 的ParticleEmitter(没有返回null)
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改
继承的函数
GetComponent 如果游戏附体上附加了一个,则返回type 类组件,没有则返回null
GetComponentInChildren 如果该组件位于GameObject 或任何其子物体上,返回type 类组件,
使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject 或任何它的子物体上,返回type
类组件。
GetComponents 返回GameObject 上所有type 类的组件
CompareTag 该游戏物体被是否被标签为tag?
SendMessageUpwards 在该游戏物体的每个MonoBehaviour 和该行为的父对象上调用名为
methodName 的方法
SendMessage 在该游戏物体的每个MonoBehaviour 上调用methodName 方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour 上调用
methodName
GetInstanceID 返回该物体的实例id
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代理。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
Animation
类,继承自Behaviour,可枚举。动画组件用来播放动画。你可以给动画组件赋予一个动画
剪辑,并从脚本中控制它的播放。Unity 中的动画系统是基于权值的,并且支持动画混合、
附加动画、动画合成、层和所有动画播放方面的完全控制。
为了播放动画可使用Animation.Play。
为了在动画间渐变可使用Animation.CrossFade。
为了改变动画的层可使用AnimationState.layer。
为了改变动画的包裹模式(循环、单次、往返)可使用Animation.wrapMode 或
AnimationState.wrapMode。
AnimationState 可以被用来调整播放速度和直接控制混合语合成。
Animation 也支持枚举,因此你可以像这样循环所有的AnimationStates。
//使该角色上所有动画半速播放
for (var state : AnimationState in animation) {
state.speed = 0.5;
}
变量
◆ var animateOnlyIfVisible : bool
描述:启用后,Unity 会在认为动画不可见的时候停止播放。该选项可以节省资源。
◆ var animatePhysics : bool
描述:启用后,动画奖在物理循环中执行。这只在与运动学刚体结合时有用。一个动画平台
可以应用速度和摩擦到其顶部的刚体。为了利用这个,animatePhysics 必须被启用,并且动
画物体必须为一个运动学刚体。
◆ var clip : AnimationClip
描述:默认动画。
animation.Play(animation.clip);
//等待动画完成
yield WaitForSeconds (animation.clip.length);
◆ var isPlaying : bool
描述:是否正在播放动画?
//在动画没有播放时播放这个动画。
function OnMouseEnter() {
if (!animation.isPlaying)animation.Play();
}
◆ var playAutomatically : bool
描述:默认的动画剪辑(Animation.clip)是否在开始时自动播放?
animation.playAutomatically = true;
◆ var this[name : string] : AnimationState
描述:返回名为name 的动画状态。
//获取walk 动画状态并设置它的速度
animation["walk"].speed = 2.0;
//获取run 动画状态并设置它的速度
animation["run"].weight = 0.5;
◆ var wrapMode : WrapMode
描述:超出剪辑播放时间之外时如何处理?
WrapMode.Default:从剪辑中获取回绕模式(默认为Once)。
WrapMode.Once:当时间到达末尾时停止动画。
WrapMode.Loop:当时间到达末尾时从头开始播放。
WrapMode.PingPong:在开始和结束之间来回播放。
WrapMode.ClampForever:播放动画。当它到达末端时,它将保持在最后一帧。
//让动画循环
animation.wrapMode = WrapMode.Loop;
函数
◆ function AddClip (clip : AnimationClip, newName : string) : void
描述:添加一个clip 到Animation,它的名称为newName。
var walkClip : AnimationClip;
animation.AddClip(walkClip, "walk");
◆ function AddClip (clip : AnimationClip, newName : string, firstFrame : int, lastFrame : int,
addLoopFrame : bool = false) : void
描述:添加clip 只在firstFrame 和lastFrame 之间播放。这个新的剪辑也将被使用名称newName
并添加到Animation。addLoopFrame:是否要插入额外的帧一边匹配第一帧?如果制作循环
动画就要打开这个。如果存在一个同名的剪辑,老的将被覆盖。
//分割默认的剪辑为shoot,walk 和idle 动画
animation.AddClip(animation.clip, "shoot", 0, 10);
//walk 和idle 将在末尾添加额外的循环真
animation.AddClip(animation.clip, "walk", 11, 20, true);
animation.AddClip(animation.clip, "idle", 21, 30, true);
◆ function Blend (animation : string, targetWeight : float = 1.0F, fadeLength : float = 0.3F) : void
描述:在接下来的time 内混合名为animation 的动画得到targetWeight。其他动画播放不会
受影响。
◆ function CrossFade (animation : string, fadeLength : float = 0.3F, mode : PlayMode =
PlayMode.StopSameLayer) : void
描述: 淡入名为animation 的动画, 并在time 内淡出其他动画。如果模式是
PlayMode.StopSameLayer , 在同一层上淡入的动画将会被淡出。如果模式是
PlayMode.StopAll,当动画被淡入后,所有动画都会被淡出。如果动画被设置为循环,在播
放后将停止并回放。
//淡入walk 循环并淡出同一层上所有其他动画。
//0.2 秒内完成淡入
animation.CrossFade("Walk", 0.2);
//当玩家想要移动的时候,使角色动画在Run 和Idle 动画之间渐变。
function Update (){
if (Mathf.Abs(Input.GetAxis("Vertical")) > 0.1)animation.CrossFade("Run");
else
animation.CrossFade("Idle");
}
◆ function CrossFadeQueued (animation : string, fadeLength : float = 0.3F, queue : QueueMode
= QueueMode.CompleteOthers, mode : PlayMode = PlayMode.StopSameLayer) : AnimationState
描述:在前一动画播放完后渐变到下一个动画。例如你可以播放一个特定的动画序列。动画
在播放前复制自身,因此你可以再相同的动画间渐变,这可用来重叠两个相
同的动画。例如你可能有一个挥剑的动画,玩家快速挥动了2 次,你可以回放这个动画并从
开始播放它,但会跳帧。
下面是可用的queue modes:
下面是可用的queue modes:
如果queue 为QueueMode.CompleteOthers 这个动画纸在所有其他动画都停止播放时才开始。
如果queue 为QueueMode.PlayNow 这个动画将以一个复制的动画状态立即开始播放。
动画播放完成后它将自动清除它自己。在它播放完成后使用赋值的动画将导致一个异常。
function Update (){
if (Input.GetButtonDown("Fire1"))
animation.CrossFadeQueued("shoot", 0.3, QueueMode.PlayNow);
}
◆ function GetClipCount () : int
描述:获取当前animation 的剪辑数。
◆ function IsPlaying (name : string) : bool
描述:名为name 的动画是否在播放?
function OnMouseEnter() {
if (!animation.IsPlaying("mouseOverEffect"))
animation.Play("mouseOverEffect");
}
◆ function Play (mode : PlayMode = PlayMode.StopSameLayer) : bool
function Play (animation : string, mode : PlayMode = PlayMode.StopSameLayer) : bool
描述:立即播放该动画,没有任何混合。Play()将会开始播放名为animation 的动画,或者播
放默认动画,且会在没有混合的情况下突然播放。如果模式为PlayMode.StopSameLayer 所
有在同一层上的动画都将被停止。如果模式是PlayMode.StepAll 所有当前播放的动画都将被
停止。如果动画正在播放,其他动画将被停止,但该动画会回到开始位置。如果动画没有被
设置为循环,播放完后将停止并回放。如果动画无法被播放(没有该剪辑或没有默认动画),
Play()会返回假。
//播放默认动画
animation.Play ();
//播放walk 动画,停止该层内所有其他动画
animation.Play ("walk");
//播放walk 动画,停止其他所有动画
animation.Play ("walk", PlayMode.StopAll);
◆ function PlayQueued (animation : string, queue : QueueMode = QueueMode.CompleteOthers,
mode : PlayMode = PlayMode.StopSameLayer) : AnimationState
描述:在前一动画播放完后渐变一个动画。例如你可以播放一个特定的动画序列。动画状态
在播放前复制自身,因此你可以再相同的动画之间渐变。这可用来重叠两个相同的动画。例
如你可能有一个挥剑的动画。玩家快速的砍了两次,你可以回放这个动画,并且从开始播放,
只不过会跳帧。
下面是可用的queue modes:
如果queue 为QueueMode.CompleteOthers 这个动画纸在所有其他动画都停止播放时才开始。
如果queue 为QueueMode.PlayNow 这个动画将以一个复制的动画状态立即开始播放。
动画播放完成后它将自动清除它自己。在它播放完成后使用赋值的动画将导致一个异常。
function Update (){
if (Input.GetButtonDown("Fire1"))
animation.PlayQueued("shoot", QueueMode.PlayNow);
}
◆ function RemoveClip (clip : AnimationClip) : void
描述:从动画列表中移除剪辑。这将移除该剪辑及所有棘突它的动画状态。
◆ function RemoveClip (clipName : string) : void
描述:从动画列表中移除剪辑。这将移除指定名称的动画状态。
◆ function Rewind (name : string) : void
描述:回退名为name 的动画。
//回退walk 动画到开始
animation.Rewind("walk");
◆ function Rewind () : void
描述:回退所有动画。
//回退所有动画到开始
animation.Rewind();
◆ function Sample () : void
描述:在当前状态采样动画。如果想要设置一些动画状态,并采样一次,可以用这个。
//设置一些状态
animation["MyClip"].time = 2.0;
animation["MyClip"].enabled = true;
//采样动画
animation.Sample();
animation["MyClip"].enabled = false;
◆ function Stop () : void
描述:停止所有由这个Animation 开始的动画。停止一个动画并回退到开始。
//终止所有动画
animation.Stop();
◆ function Stop (name : string) : void
描述:停止名为name 的动画。停止一个动画并回退到开始。
//停止walk 动画
animation.Stop ("walk");
◆ function SyncLayer (layer : int) : void
描述:同步所有在该层的动画的播放速度。当混合两个循环动画时,它们通常有不同长度。
例如一个walk 循环要比run 更长。当混合它们时,你需要确保行走于跑循环中脚的位置相
同。也就是说,动画的播放速度必须被调整一边动画同步。SyncLayer 将给予它们的混合权
值计算在该层上所有动画播放的平均诡异化速度,然后对该层上的动画使用播放速度。
//放置walk 和run 动画在同一层,并同步它们的速度
animation["walk"].layer = 1;
animation["run"].layer = 1;
animation.SyncLayer(1);
继承的成员
继承的变量
enable 启用则Behaviour 被更新,不启用则不更新
transform 附加到该GameObject 的Transform(没有返回null)
rigidbody 附加到该GameObject 的Rigidbody(没有返回null)
camera 附加到该GameObject 的Camera(没有返回null)
light 附加到该GameObject 的Light(没有返回null)
animation 附加到该GameObject 的Animation(没有返回null)
constantForce 附加到该GameObject 的ConstantForce(没有返回null)
renderer 附加到该GameObject 的Renderer(没有返回null)
audio 附加到该GameObject 的Audio(没有返回null)
guiText 附加到该GameObject 的GuiText(没有返回null)
networkView 附加到该GameObject 的NetworkView(没有返回null)
guiTexture 附加到该GameObject 的GuiTexture(没有返回null)
collider 附加到该GameObject 的Collider(没有返回null)
hingeJoint 附加到该GameObject 的HingeJoint(没有返回null)
particleEmitter 附加到该GameObject 的ParticleEmitter(没有返回null)
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改
继承的函数
GetComponent 如果游戏附体上附加了一个,则返回type 类组件,没有则返回null
GetComponentInChildren 如果该组件位于GameObject 或任何其子物体上,返回type 类组件,
使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject 或任何它的子物体上,返回type
类组件。
GetComponents 返回GameObject 上所有type 类的组件
CompareTag 该游戏物体被是否被标签为tag?
SendMessageUpwards 在该游戏物体的每个MonoBehaviour 和该行为的父对象上调用名为
methodName 的方法
SendMessage 在该游戏物体的每个MonoBehaviour 上调用methodName 方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour 上调用
methodName
GetInstanceID 返回该物体的实例id
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代理。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
AudioListener
类,继承自Behaviour。标示在三维空间中的侦听器。这个类可实现麦克风一样的设备。它
记录周围的声音,并通过玩家的扬声器播, 放。在场景中只能有一个侦听器。参见组件参考
中AudioSource,AudioListener,component。
变量
◆ var velocityUpdateMode : AudioVelocityUpdateMode
描述:可让你设置Audio Listener 是否应该用固定或动态方式更新。如果你遇到了多普勒效
应问题,请确保设置这个更新于Audio Listener 的移动在同一循环内。如果它被附加到一个
刚体,默认设置将自动设置该侦听器在固定的更新周期内更新,动态的以其他方式。
listener.velocityUpdateMode = AudioVelocityUpdateMode.Fixed;
类变量
◆ static var pause : bool
描述:音频的暂停状态。如果设置为真,该侦听器将不会产生声音。类似于设置音量为0.0
AudioListener.pause = true;
◆ static var volume : float
描述:控制游戏的音量。
AudioListener.volume = 0.5;
继承的成员
继承的变量
enable 启用则Behaviour 被更新,不启用则不更新
transform 附加到该GameObject 的Transform(没有返回null)
rigidbody 附加到该GameObject 的Rigidbody(没有返回null)
camera 附加到该GameObject 的Camera(没有返回null)
light 附加到该GameObject 的Light(没有返回null)
animation 附加到该GameObject 的Animation(没有返回null)
constantForce 附加到该GameObject 的ConstantForce(没有返回null)
renderer 附加到该GameObject 的Renderer(没有返回null)
audio 附加到该GameObject 的Audio(没有返回null)
guiText 附加到该GameObject 的GuiText(没有返回null)
networkView 附加到该GameObject 的NetworkView(没有返回null)
guiTexture 附加到该GameObject 的GuiTexture(没有返回null)
collider 附加到该GameObject 的Collider(没有返回null)
hingeJoint 附加到该GameObject 的HingeJoint(没有返回null)
particleEmitter 附加到该GameObject 的ParticleEmitter(没有返回null)
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改
继承的函数
GetComponent 如果游戏附体上附加了一个,则返回type 类组件,没有则返回null
GetComponentInChildren 如果该组件位于GameObject 或任何其子物体上,返回type 类组件,
使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject 或任何它的子物体上,返回type
类组件。
GetComponents 返回GameObject 上所有type 类的组件
CompareTag 该游戏物体被是否被标签为tag?
SendMessageUpwards 在该游戏物体的每个MonoBehaviour 和该行为的父对象上调用名为
methodName 的方法
SendMessage 在该游戏物体的每个MonoBehaviour 上调用methodName 方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour 上调用
methodName
GetInstanceID 返回该物体的实例id
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代理。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
AudioSource
类,继承自Behaviour。标示三位空间中的音频源。AudioSource 被附加到GameObject 以便
在三位环境中播放声音。单声道声音以3D 播放。为了播放三位声音,也需要一个
AudioListener。音频侦听器通常附加在使用的相机上。立体声总是不以距离为基础衰减。你
可以使用Play,Pause,Stop 来播放音频剪辑。也可以再播放时使用volume 属性调整音量,
或者使用time 来定位。多个声音可以使用PlayOneShot 在一个AudioSource 上播放。可以使
用PlayClipAtPoint 在三位空间中的一个静态位置播放剪辑。参见AudioListener,AudioClip,
AudioSource component。
变量
◆ var clip : AudioClip
描述:默认播放的AudioClip。
var otherClip: AudioClip;
// 播放默认声音
audio.Play();
// 等待音频结束
yield WaitForSeconds (audio.clip.length);
// 指定其他音频并播放
audio.clip = otherClip;
audio.Play();
◆ var ignoreListenerVolume : bool
描述:这使音频源不考虑音频侦听器的音量。播放背景音乐时可启用这个。当播放背景音乐
时,你希望音乐不受普通音量设置的影响,可以使用该变量。
audio.ignoreListenerVolume = true;
◆ var isPlaying : bool
描述:clip 现在生意否在播放?
//当音频组件停止播放时,播放otherClip
var otherClip : AudioClip;
function Update (){
if (!audio.isPlaying) {
audio.clip = otherClip;
audio.Play();
}
}
◆ var loop : bool
描述:音频剪辑是否循环?如果你在一个正在播放的AudioSource 上禁用循环,声音将在当
前循环结束后停止。
// 停止声音循环
audio.loop = false;
◆ var maxVolume : float
描述:音频剪辑播放时的最大音量。不论你距离多近,声音不会比这个值更大。
audio.maxVolume = 0.5;
参见:minVolume, rolloffFactor.
◆ var minVolume : float
描述:音频剪辑播放时的最小音量。不论你距离多远,声音不会比这个还小。
audio.minVolume = 0.5;
参见:maxVolume, rolloffFactor.
◆ var pitch : float
描述:音频源的音调。
audio.pitch = 1.0;
◆ var playOnAwake : bool
描述:如果设置为真,音频源江在awake 时自动播放。
if(! audio.playOnAwake) {
audio.Play();// 如果没有设置为Awake 时播放,那么播放该剪辑
}
◆ var rolloffFactor : float
描述:设置声音衰减的速度。该值越大,侦听器必须更接近才能听到声音。
audio.rolloffFactor = 0.1;
参见:minVolume, maxVolume.
◆ var time : float
描述:以秒计算的播放位置。使用这个来读当前播放时间或寻找新的播放时间。
◆ var velocityUpdateMode : AudioVelocityUpdateMode
描述:Audio Source 是否应该以固定或动态的方式更新?如果你遇到了这个源的多普勒效应
问题,请确保设置这个更新与Audio Source 的移动
在同一循环内。如果它被附加到一个刚体,默认设置将自动设置该源在固定的更新周期内更
新,以动态的以及其他方式。
◆ var volume : float
描述:音频源的音量。
audio.volume = 0.2;
函数
◆ function Pause () : void
描述:暂停播放clip。
audio.Pause();
参见:Play,Stop 函数
◆ function Play () : void
描述:播放clip。
audio.Play();
参见:Pause,Stop 函数
◆ function PlayOneShot (clip : AudioClip, volumeScale : float = 1.0F) : void
描述:播放一个AudioClip。
//与其他物体碰撞时播放impact 音频剪辑
var impact : AudioClip;
function OnCollisionEnter () {
audio.PlayOneShot(impact);
}
◆ function Stop () : void
描述:停止播放clip。
audio.Stop();
参见:Play,Pause 函数
类方法
◆ static function PlayClipAtPoint (clip : AudioClip, position : Vector3, volume : float = 1.0F) :
void
描述:在制定位置上播放剪辑。播放完成后自动消除音频源。正在播放的声音的音频源被返
回。
//在制定位置播放clip
var clip : AudioClip;
AudioSource.PlayClipAtPoint(clip, Vector3 (5, 1, 2));
如果想进一步控制播放,可以使用下面代码。
var theClip : AudioClip;
PlayAudioClip(theClip, transform.position, 1);
function PlayAudioClip (clip : AudioClip, position : Vector3, volume : float)
{
var go = new GameObject ("One shot audio");
go.transform.position = position;
var source : AudioSource = go.AddComponent (AudioSource);
source.clip = clip;
source.volume = volume;
source.Play ();
Destroy (go, clip.length);
return source;
}
Destroy (go, clip.length);
return source;
}
继承的成员
继承的变量
enable 启用则Behaviour 被更新,不启用则不更新
transform 附加到该GameObject 的Transform(没有返回null)
rigidbody 附加到该GameObject 的Rigidbody(没有返回null)
camera 附加到该GameObject 的Camera(没有返回null)
light 附加到该GameObject 的Light(没有返回null)
animation 附加到该GameObject 的Animation(没有返回null)
constantForce 附加到该GameObject 的ConstantForce(没有返回null)
renderer 附加到该GameObject 的Renderer(没有返回null)
audio 附加到该GameObject 的Audio(没有返回null)
guiText 附加到该GameObject 的GuiText(没有返回null)
networkView 附加到该GameObject 的NetworkView(没有返回null)
guiTexture 附加到该GameObject 的GuiTexture(没有返回null)
collider 附加到该GameObject 的Collider(没有返回null)
hingeJoint 附加到该GameObject 的HingeJoint(没有返回null)
particleEmitter 附加到该GameObject 的ParticleEmitter(没有返回null)
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改
继承的函数
GetComponent 如果游戏附体上附加了一个,则返回type 类组件,没有则返回null
GetComponentInChildren 如果该组件位于GameObject 或任何其子物体上,返回type 类组件,
使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject 或任何它的子物体上,返回type
类组件。
GetComponents 返回GameObject 上所有type 类的组件
CompareTag 该游戏物体被是否被标签为tag?
SendMessageUpwards 在该游戏物体的每个MonoBehaviour 和该行为的父对象上调用名为
methodName 的方法
SendMessage 在该游戏物体的每个MonoBehaviour 上调用methodName 方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour 上调用
methodName
GetInstanceID 返回该物体的实例id
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代理。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
Camera
类,继承自Behaviour。Camera 是一个设备,玩家通过它来看世界。屏幕空间点用像素定义。
屏幕左下为(0,0);右上是(pixelWidth.pixelHeight)。z 的位置是以世界单位衡量到相机的距离。
视口空间点是归一化的并且是相对于相机的。相机左下为(0,0);右上是(1,1)。z 的位置是以
世界单位衡量到相机的距离。世界空间点是以全局坐标定义的(例如Transform.position)。
参见:camera component
变量
◆ var aspect : float
描述:长宽比(宽度除以高度)。默认的长宽比是从屏幕的长宽比计算得到的,即使相机没
有被渲染到全屏。如果修改了相机的aspect 比,这个值将保持到你调用camera.ResetAspect();
这将充值猖狂比为屏幕的长宽比。
if(camera.aspect > 1.0)
print ("Screen is more wide than tall!");
else
print ("Screen is more tall than wide!");
参见:camera component,Screen 类。
◆ var backgroundColor : Color
描述:屏幕将被清理未这个颜色。只能在clearFlags 被设置为CameraClearFlags.SolidColor
(或设置为CameraClearFlags.Skybox 但没有设置天空盒)时使用。
//来回变化背景色
var color1 = Color.red;
var color2 = Color.blue;
var duration = 3.0;
//设置清楚标记为该颜色
camera.clearFlags = CameraClearFlags.SolidColor;
function Update () {
var t = Mathf.PingPong (Time.time, duration) / duration;
camera.backgroundColor = Color.Lerp (color1, color2, t);
}
参见:camera component,Camera.clearFlags 属性。
◆ var cameraToWorldMatrix : Matrix4x4
描述:从相机空间到世界空间的变换矩阵(只读)。使用次变量计算相机空间中的一个点在
世界坐标中的什么位置。注意相机空间与openGL 的约定相同。相机前味z 轴负方向。这不
同于Unity 的约定,向前微z 轴争相。
//以distance 单位,沿着相机所看到的方向,在屏幕中绘制一个黄色的球,
var distance = -1.0;
function OnDrawGizmosSelected () {
var m = camera.cameraToWorldMatrix;
var p = m.MultiplyPoint (Vector3(0,0,distance));
Gizmos.color = Color.yellow;
Gizmos.DrawSphere (p, 0.2);
}
◆ var clearFlags : CameraClearFlags
描述:相机如何清楚背景。可以是CameraClearFlags.Skybox,CameraClearFlags.SolidColor,
CameraClearFlags.Depth,CameraClearFlags.Nothing。
//用背景色清除(忽略天空盒)
camera.clearFlags = CameraClearFlags.SolidColor;
◆ var cullingMask : int
描述:这个用来选择性的渲染部分场景。如果GameObject 的layerMask 与相机的cullingMask
进行AND 操作后为0,则这个游戏物体对于该相机是不可见的。参考Layers 获取更多信息。
//只渲染在第一层中的物体(默认层)
camera.cullingMask = 1 << 0;
参见:camera component
◆ var depth : float
描述:相机在渲染顺序上的深度。具有较低深度的相机将在较高深度的相机之前渲染。如果
有多个相机并其中一些不需要覆盖整个屏幕,可以使用这个来控制相机的绘制次序。
//设置该相机在主相机之后渲染
camera.depth = Camera.main.depth + 1;
参见:camera component,Camera.rect 属性
◆ var farClipPlane : float
描述:远裁剪面的距离。
camera.farClipPlane = 100.0;
参见:camera component
◆ var fieldOfView : float
描述:相机的视野,以度为党委。这是垂直视野。水平FOV 取决于视口的宽高比。当相机
是正交时,fieldOfView 被忽略。(参考orthographic)。
//设置附加到同一个游戏物体上的相机的FOV 位60
camera.fieldOfView = 60;
//设置主相机的视野为80
Camera.main.fieldOfView = 80;
参见:camera component
◆ var nearClipPlane : float
描述:近才见面的距离。
camera.nearClipPlane = 0.1;
参见:camera component
◆ var orthographic : bool
描述:相机是正交的(true)还是透视的(false)?如果orthographic 为true,相机的视野由
orthographicSize 定义。如果orthographic 为false,相机的视野由fieldOfView 定义。
//设置相机为正交
camera.orthographic = true;
//设置主相机为正交
Camera.main.orthographic = true;
参见:camera component
◆ var orthographicSize : float
描述:在正交模式下相机的一半尺寸。这个为视体垂直大小的一半。相机不是正交时,水平
视大小拒绝于视口的长宽比。
//设置相机的正交尺寸为5
camera.orthographic = true;
camera.orthographicSize = 5;
//设置主相机的正交尺寸为5
Camera.main.orthographic = true;
Camera.main.orthographicSize = 5;
参见:camera component
◆ var pixelHeight : float
描述:相机的像素高度(只读)。
print ("Camera is " + camera.pixelHeight + " pixels high");
◆ var pixelRect : Rect
描述:相机被渲染到屏幕像素坐标中的位置。
function Update () {
var r = camera.pixelRect;
print ("Camera displays from " + r.xMin + " to " + r.xMax + " pixel");
}
◆ var pixelWidth : float
描述。相机的像素宽度(只读)。
print ("Camera is " + camera.pixelWidth + " pixels wide");
◆ var projectionMatrix : Matrix4x4
描述:设置自动以的投影矩阵。如果你改变该矩阵,相机的渲染将不再给予它的fieldOfView
更新,直到调用到ResetProjectionMatrix。只有当真正需要一个非标准的投影时,才使用自
定义投影。该属性被Unity 的水渲染使用来设置一个oblique.projection 矩阵。使用自定义投
影需要了解变换和投影矩阵。
//让相机以有节奏的方式晃动
var originalProjection : Matrix4x4;
originalProjection = camera.projectionMatrix;
function Update () {
var p = originalProjection;
//改变原始矩阵的某些值
p.m01 += Mathf.Sin (Time.time * 1.2) * 0.1;
p.m10 += Mathf.Sin (Time.time * 1.5) * 0.1;
camera.projectionMatrix = p;
}
//设置一个变异中心的投影,这里透视的消失点没有必要在屏幕的中心。left/right/top/bottom
定义近裁剪面大小。例如相机的近裁剪面偏移中心的距离,改变该值就可以看到相机视图的
变化。
@script ExecuteInEditMode
var left = -0.2;
var right = 0.2;
var top = 0.2;
var bottom = -0.2;
function LateUpdate () {
var cam = camera;
var m = PerspectiveOffCenter(left, right, bottom, top,cam.nearClipPlane, cam.farClipPlane );
cam.projectionMatrix = m;
}
static function PerspectiveOffCenter(left : float, right : float,bottom : float, top : float,near : float,
far : float ) : Matrix4x4{
var x = (2.0 * near) / (right - left);
var y = (2.0 * near) / (top - bottom);
var a = (right + left) / (right - left);
var b = (top + bottom) / (top - bottom);
var c = -(far + near) / (far - near);
var d = -(2.0 * far * near) / (far - near);
var e = -1.0;
var m : Matrix4x4;
m[0,0] = x; m[0,1] = 0; m[0,2] = a;
m[0,3] = 0;
m[1,0] = 0; m[1,1] = y; m[1,2] = b; m[1,3] = 0;
m[2,0] = 0;
m[2,1] = 0; m[2,2] = c; m[2,3] = d;
m[3,0] = 0; m[3,1] = 0; m[3,2] = e;
m[3,3] = 0;
return m;
}
◆ var rect : Rect
描述:相机被渲染到屏幕归一化坐标中的位置。rect 的范围从0(左/下)到1(右/上)。
//每次按下空格键时改变视口宽度
function Update () {
if (Input.GetButtonDown ("Jump")) {
//随机选择边缘
var margin = Random.Range (0.0, 0.3);
//设置矩形
camera.rect = Rect (margin, 0, 1 - margin * 2, 1);
}
}
◆ var targetTexture : RenderTexture
描述:目标渲染纹理(只限UnityPro)。
◆ var velocity : Vector3
描述:获取世界空间中相机的速度(只读)这是相机在上一帧以秒为单位的运动。
function Update () {
print ("Camera moving at " + camera.velocity.magnitude + " m/s");
}
◆ var worldToCameraMatrix : Matrix4x4
描述:从世界到相机空间的变换矩阵。用这个计算物体的相机空间位置或提供自定义相机的
位置。这个位置不是基于变化的。注意相机空间与openGL 的约定相同:相机的前面为Z 轴
负方向。这不同于Unity 的约定,向前微Z 轴争相。如果你改变该矩阵,相机的渲染将不再
基于它的Transform 更新。知道调用ResetWorldToCameraMatrix。
//从offset 位置偏移相机的渲染
var offset = Vector3 (0,1,0);
function LateUpdate () {
//构建一个沿着Z 轴偏移与镜像的矩阵。因为相机已经为Z 轴镜像,并用于其余部分
var camoffset = Vector3 (-offset.x, -offset.y, offset.z);
var m = Matrix4x4.TRS (camoffset, Quaternion.identity, Vector3 (1,1,-1));
//重载worldToCameraMatrix 为偏移镜像变换矩阵
camera.worldToCameraMatrix = m * transform.worldToLocalMatrix;
}
函数
◆ function CopyFrom (other : Camera) : void
描述:使该相机的设置于其他相机相同。这将从er 相机拷贝到所有相机变量(视野,清楚
标记,裁剪蒙版)。这也将使相机的变换与other 相机相同,相机的层也与other 相机相同。
在做自定义渲染效果的时候,这可以用来设置一台具有与其他相机设置完全相同的相机。例
如在使用RenderWithShader 时。
◆ function Render : void
描述:手动渲染相机。这个将使用相机的清除标记,目标纹理和所有其他设置。相机将发送
OnPreCull,OnPreRender 和OnPostRender 到任何附加的脚本上,并渲染任何最后的图像滤
镜。这个用来精确的控制渲染次序,为了使用这个特性,创建一个相机并禁用它。然后在它
上面调用Render。参见:RenderWithShader。
◆ function RenderToCubemap (cubemap : Cubemap, faceMask : int = 63) : bool
描述:从这个相机渲染到一个立方贴图。这个是非常有用的。可以再编辑器中烘焙场景的静
态立方贴图。参考下面的想到实例。相机的位置,清除标志和裁剪面距离将被使用来渲染到
立方贴图表面。faceMask 是一个比特域,标示哪个立方贴图面应该被渲染。每个位对应于
一个面。比特数是CubemapFace 枚举的整型值。默认的所有六个立方贴图面都将被渲染(默
认值63 最低的6 位是打开的)。如果渲染失败,这个函数将返回false。某些显卡不支持这
个函数。参见:Cubemap assets,Reflective shaders。
//从给定的点渲染场景到以静态立方贴图放置这个脚本到工程的Editor 文件夹中,然后用一
个Reflective shader 来使用立方贴图
class RenderCubemapWizard extends ScriptableWizard{
var renderFromPosition : Transform;
var cubemap : Cubemap;
function OnWizardUpdate () {
helpString = "Select transform to render from and cubemap to render into";
isValid = (renderFromPosition != null) && (cubemap != null);
}
function OnWizardCreate () {
//为渲染创建临时相机
var go = new GameObject( "CubemapCamera", Camera );//放置到物体上
go.transform.position = renderFromPosition.position;
go.transform.rotation = Quaternion.identity;
//渲染到立方贴图
go.camera.RenderToCubemap( cubemap );
//销毁临时相机
DestroyImmediate( go );
}
@MenuItem("GameObject/Render into Cubemap")
static function RenderCubemap () {
ScriptableWizard.DisplayWizard(
"Render cubemap", RenderCubemapWizard, "Render!");
}
}
◆ function RenderToCubemap (cubemap : RenderTexture, faceMask : int = 63) : bool
描述:从这个相机渲染到一个立方贴图。用于实时反射到立方贴图渲染纹理,也是非常耗时
的,尤其是所有六个立方贴图面在每一帧中都被渲染。相机的位置,清楚标志和裁剪面距离
将被使用来渲染到立方贴图表面。faceMask 是一
个比特域,标示哪个立方贴图面应该被渲染。每个位对应于一个面。比特数是CubemapFace
枚举的整型值。默认的所有六个正方贴图面都将被渲染(默认值63 的最低6 位是打开的)。
如果渲染失败该函数会返回false。某些显卡不支持该函数。参加:RenderTexture.isCubemap,
Reflective shaders。
//将该脚本附加到使用了Reflective shader 的物体上实时反射立方贴图
script ExecuteInEditMode
var cubemapSize = 128;
var oneFacePerFrame = false;
private var cam : Camera;
private var rtex : RenderTexture;
function Start () {
//启动时渲染所有6 个面
UpdateCubemap( 63 );
}
function LateUpdate () {
if (oneFacePerFrame) {
var faceToRender = Time.frameCount % 6;
var faceMask = 1 << faceToRender;
UpdateCubemap (faceMask);
}
else {
UpdateCubemap (63); //所有6 个面
}
}
function UpdateCubemap (faceMask : int) {
if (!cam) {
var go = new GameObject ("CubemapCamera", Camera);
go.hideFlags = HideFlags.HideAndDontSave;
go.transform.position = transform.position;
go.transform.rotation = Quaternion.identity;
cam = go.camera;
cam.farClipPlane = 100; //不渲染较远的部分
cam.enabled = false;
}
if (!rtex) {
rtex = new RenderTexture (cubemapSize, cubemapSize, 16);
rtex.isPowerOfTwo = true;
rtex.isCubemap = true;
rtex.hideFlags = HideFlags.HideAndDontSave;
renderer.sharedMaterial.SetTexture ("_Cube", rtex);
}
cam.transform.position = transform.position;
cam.RenderToCubemap (rtex, faceMask);
}
function OnDisable () {
DestroyImmediate (cam);
DestroyImmediate (rtex);
}
◆ function RenderWithShader (shader : Shader, replacementTag : string) : void
描述:用shader 替换渲染相机。参考Rendering with Replaced Shaders 获取细节。此函数将
渲染相机。这将使相机的的清除标记、目标纹理和所有其他设置。这个相机不会发送
OnPreCull, OnPreRender 或者OnPostRender 到已附加的脚本上。
图像滤镜
也不会被渲染。该函数可以用于特效,例如渲染整个场景屏幕空间缓冲,热效果等。为了使
用该特性,创建一个相机并禁用它。然后在它上面调用RenderWithShader。参见:Rendering
with Replaced Shaders, SetReplacementShader, Render。
◆ function ResetAspect () : void
描述:返回猖狂比为屏幕的长宽比。调用这个结束aspect 的效果。
camera.ResetAspect();
◆ function ResetProjectionMatrix () : void
描述:让投影反映正常的相机参数。调用这个结束projectionMatrix 的效果。
camera.ResetProjectionMatrix();
◆ function ResetReplacementShader () : void
描述:从相机上移除shader 替换。调用这个结束SetReplacementShader 效果。
◆ function ResetWorldToCameraMatrix () : void
描述:在场景中让渲染位置反映相机位置。调用这个结束worldToCameraMatrix 的效果。
camera.ResetWorldToCameraMatrix();
◆ function ScreenPointToRay (position : Vector3) : Ray
描述:返回从相机出发,穿过屏幕点的一个射线。产生的射线是在世界空间中,从相机的近
裁剪面开始并穿过屏幕position(x,y)像素坐标(position.z 被忽略)。屏幕空间以像素定义。
屏幕的左下为(0,0);右上是(pixelWidth,pixelHeight)。
//在屏幕视图中绘制一条线,穿过一个到屏幕左下角200 像素的点
function Update () {
var ray = camera.ScreenPointToRay (Vector3(200,200,0));
Debug.DrawRay (ray.origin, ray.direction * 10, Color.yellow);
}
◆ function ScreenToViewportPoint (position : Vector3) : Vector3
描述:从屏幕空间到视口空间变换position。屏幕空间以像素定义。屏幕的左下为(0,0);右
上是(pixelWidth,pixelHeight)。z 的位置是以世界单位衡量的刀相机的距离。视口空间是归一
化的并相对于相机的。相机的左下为(0,0);右上是(1,1)。z 的位置是以世界单位衡量的刀相
机的距离。
◆ function ScreenToWorldPoint (position : Vector3) : Vector3
描述:从屏幕空间到世界空间变换position。屏幕空间以像素定义。屏幕的左下为(0,0);右
上是(pixelWidth,pixelHeight)。z 的位置是以世界单位衡量的到相机的距离。
//在所选相机的近裁剪面上绘制一个黄色的球,在离左下100 像素的位置
function OnDrawGizmosSelected () {
var p = camera.ScreenToWorldPoint (Vector3 (100,100,camera.nearClipPlane));
Gizmos.color = Color.yellow;
Gizmos.DrawSphere (p, 0.1);
}
◆ function SetReplacementShader (shader : Shader, replacementTag : string) : void
描述:使相机用shader 替换来渲染。参考Rendering with Replaced Shaders。调用该函数后,
相机将使用替换的shader 来渲染它的视图。调用ResetReplacementShader 来重置为普通渲染。
参见:Rendering with Replaced Shaders, ResetReplacementShader, RenderWithShader。
◆ function ViewportPointToRay (position : Vector3) : Ray
描述:返回从相机出发穿过视点的一个射线。产生的射线是在世界空间中,从相机的近裁剪
面开始并穿过视口position(x,y)坐标(position.z 被忽略)。视口坐标是归一化的并相对于相
机的。相机的左下为(0,0);右上为(1,1)。
//打印相机直接看到的物体名称
function Update () {
//获取穿过屏幕中心的射线
var ray = camera.ViewportPointToRay (Vector3(0.5,0.5,0));
//投射
var hit : RaycastHit;
if (Physics.Raycast (ray, hit)) {
print ("I'm looking at " + hit.transform.name);
}
else {
print ("I'm looking at nothing!");
}
}
◆ function ViewportToScreenPoint (position : Vector3) : Vector3
描述:从视口空间到屏幕空间变换position。视口空间是归一化的并相对于相机的。相机的
左下为(0,0);右上为(1,1)。z 的位置是以世界单位衡量的刀相机的距离。屏幕空间以像素定
义。屏幕左下为(0,0;右上为(pixelWidth,pixelHeight)。z 的位置是以世界单位衡量的到相机
的距离。
◆ function ViewportToWorldPoint (position : Vector3) : Vector3
描述:从视口空间到屏幕空间变换position。视口空间是归一化的并相对于相机的。相机的
左下为(0,0);右上为(1,1)。z 的位置是以世界单位衡量的刀相机的距离。屏幕空间以像素定
义。屏幕左下为(0,0;右上为(pixelWidth,pixelHeight)。z 的位置是以世界单位衡量的到相机
的距离。
//在进裁剪面的右上角,针对在场景视图中选中的相机绘制一个黄色的球
function OnDrawGizmosSelected () {
var p = camera.ViewportToWorldPoint (Vector3 (1,1, camera.nearClipPlane));
Gizmos.color = Color.yellow;
Gizmos.DrawSphere (p, 0.1);
}
◆ function WorldToScreenPoint (position : Vector3) : Vector3
描述:从世界空间到屏幕空间变换position。屏幕空间以像素定义。屏幕的左下为(0,0;右
上为(pixelWidth,pixelHeight)。z 的位置是
以世界单位衡量的刀相机的距离。
var target : Transform;
function Update () {
var screenPos = camera.WorldToScreenPoint (target.position);
print ("target is " + screenPos.x + " pixels from the left");
}
◆ function WorldToViewportPoint (position : Vector3) : Vector3
描述:从世界空间到视口空间变换position。视口空间是归一化的并相对于相机的。相机的
左下为(0,0);右上为(1,1)。z 的位置是以世界单位衡量的到相机的距离。
//找出target 在屏幕的左边还是右边
var target : Transform;
function Update () {
var viewPos = camera.WorldToViewportPoint (target.position);
//视口坐标范围从0 到1
if( viewPos.x > 0.5 )
print ("target is on the right side!");
else
print ("target is on the left side!");
}
消息传递
◆ function OnPostRender () : void
描述:OnPostRender 在相机渲染场景之后调用。这个消息被发送到所有附加在相机上的脚
本。
◆ function OnPreCull () : void
描述:OnPreCull 在相机开始裁剪场景之前调用。OnPreCull 仅仅在这个过程之间被调用。
这个消息被发送到所有附加在相机上的脚本。如果你想改变相机的视觉参数(例如,
fieldOfView 或者仅仅是变换),就在这里做这个。场景物体的可见性将给予相机的参数在
OnPreCull 之后确定。
◆ function OnPreRender () : void
描述:OnPreCull 在相机开始渲染场景之前调用。这个消息被发送到所有附加在相机上的脚
本。注意如果你在这里改变了相机的视野参数(例如fieldOfView),它们将只影响下一帧。
用OnPreCull 代替。
◆ function OnRenderImage (source : RenderTexture, destination : RenderTexture) : void
描述:OnRenderImage 在所有渲染完成后被调用,来渲染图片的后记处理效果(仅限
UnityPro)。该函数允许使用给予shader 的过滤器来处理最后的图片。进入的图片是source
渲染纹理。结果是destination 渲染纹理。当多个图片过滤器附加在相机上时,它们序列化的
处理图片,将第一个过滤器的目标作为下一个过滤器的源。
该消息被发送到所有附加在相机上的脚本。参见:UnityPro 中的image effects。
◆ function OnRenderObject (queueIndex : int) : void
描述:该函数被用来渲染你自己的物体,使用Graphics.DrawMeshNow 或者其他函数。
queueIndex 指定用来渲染物体的render queue。可以使用RenderBeforeQueues 属性来指定你
想绘制这个物体到哪个渲染队列。
◆ function OnWillRenderObject () : void
描述:如果物体可见,每个相机都会调用OnWillRenderObject。该函数在裁剪过程中被调用。
可用该函数创建具有依赖性的渲染纹理。只有在被渲染的物体可见时,才更新该渲染纹理。
例如,水组件就使用了这个。Camera.current 将被设置为要渲染这个物体的相机。
类变量
◆ static var allCameras : Camera[]
描述:返回场景中所有启用的相机。
var count = Camera.allCameras.length;
print ("We've got " + count + " cameras");
◆ static var current : Camera
描述:当前用于渲染的相机,只用于低级的渲染控制(只读)。多数时候你会使用Camera.main。
只有在执行下面时间的时候使用该函数: MonoBehaviour.OnRenderImage,
MonoBehaviour.OnPreRender, MonoBehaviour.OnPostRender。
◆ static var main : Camera
描述:第一个启用的被标记为“MainCamera”的相机(只读)。如果场景中没有这个相机返回
null。
继承的成员
继承的变量
enable 启用则Behaviour 被更新,不启用则不更新
transform 附加到该GameObject 的Transform(没有返回null)
rigidbody 附加到该GameObject 的Rigidbody(没有返回null)
camera 附加到该GameObject 的Camera(没有返回null)
light 附加到该GameObject 的Light(没有返回null)
animation 附加到该GameObject 的Animation(没有返回null)
constantForce 附加到该GameObject 的ConstantForce(没有返回null)
renderer 附加到该GameObject 的Renderer(没有返回null)
audio 附加到该GameObject 的Audio(没有返回null)
guiText 附加到该GameObject 的GuiText(没有返回null)
networkView 附加到该GameObject 的NetworkView(没有返回null)
guiTexture 附加到该GameObject 的GuiTexture(没有返回null)
collider 附加到该GameObject 的Collider(没有返回null)
hingeJoint 附加到该GameObject 的HingeJoint(没有返回null)
particleEmitter 附加到该GameObject 的ParticleEmitter(没有返回null)
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改
继承的函数
GetComponent 如果游戏附体上附加了一个,则返回type 类组件,没有则返回null
GetComponentInChildren 如果该组件位于GameObject 或任何其子物体上,返回type 类组件,
使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject 或任何它的子物体上,返回type
类组件。
GetComponents 返回GameObject 上所有type 类的组件
CompareTag 该游戏物体被是否被标签为tag?
SendMessageUpwards 在该游戏物体的每个MonoBehaviour 和该行为的父对象上调用名为
methodName 的方法
SendMessage 在该游戏物体的每个MonoBehaviour 上调用methodName 方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour 上调用
methodName
GetInstanceID 返回该物体的实例id
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代理。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
ConstantForce
类,继承自Behaviour。一个不间断的力。这是一个小的物理工具类,用来将一个连续的力
应用到一个物体上。Rigidbody.AddForce 只在一帧中应用力道Rigidbody,因此你不得不持
续调用这个函数。
领以方面ConstantForce 将在每一帧中应用这个力,知道改变这个力或例举为一个新的值。
参见Rigidbody。
变量
◆ var force : Vector3
描述:这个力在每帧中应用到刚体。
//在世界坐标系中向上移动刚体。
constantForce.force = Vector3.up * 10;
◆ var relativeForce : Vector3
描述:力-相对于刚体坐标系统-在每帧中应用。
//向前移动刚体。
constantForce.relativeForce = Vector3.forward * 10;
◆ var relativeTorque : Vector3
描述:力矩-相对于刚体坐标系统-在每帧中应用。
//绕着其X 轴旋转该物体。
constantForce.relativeTorque = Vector3.right * 2;
◆ var torque : Vector3
描述:这个力矩在每帧中应用到刚体。
//绕着世界的Y 轴旋转该物体。
constantForce.torque = Vector3.up * 2;
继承的成员
继承的变量
enable 启用则Behaviour 被更新,不启用则不更新
transform 附加到该GameObject 的Transform(没有返回null)
rigidbody 附加到该GameObject 的Rigidbody(没有返回null)
camera 附加到该GameObject 的Camera(没有返回null)
light 附加到该GameObject 的Light(没有返回null)
animation 附加到该GameObject 的Animation(没有返回null)
constantForce 附加到该GameObject 的ConstantForce(没有返回null)
renderer 附加到该GameObject 的Renderer(没有返回null)
audio 附加到该GameObject 的Audio(没有返回null)
guiText 附加到该GameObject 的GuiText(没有返回null)
networkView 附加到该GameObject 的NetworkView(没有返回null)
guiTexture 附加到该GameObject 的GuiTexture(没有返回null)
collider 附加到该GameObject 的Collider(没有返回null)
hingeJoint 附加到该GameObject 的HingeJoint(没有返回null)
particleEmitter 附加到该GameObject 的ParticleEmitter(没有返回null)
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改
继承的函数
GetComponent 如果游戏附体上附加了一个,则返回type 类组件,没有则返回null
GetComponentInChildren 如果该组件位于GameObject 或任何其子物体上,返回type 类组件,
使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject 或任何它的子物体上,返回type
类组件。
GetComponents 返回GameObject 上所有type 类的组件
CompareTag 该游戏物体被是否被标签为tag?
SendMessageUpwards 在该游戏物体的每个MonoBehaviour 和该行为的父对象上调用名为
methodName 的方法
SendMessage 在该游戏物体的每个MonoBehaviour 上调用methodName 方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour 上调用
methodName
GetInstanceID 返回该物体的实例id
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代理。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
GUIElement
类,继承自Behaviour。用于显示在GUI 上的图片和文本字符串的基类。这个类处理所有
GUI 元素的基本功能。
函数
◆ function GetScreenRect (camera : Camera = null) : Rect
描述:在屏幕坐标返回GUIElement 的包围矩阵。如果没有camera 被指定,一个填充整个游
戏窗口的相机将被使用。
function Start () {
var r = guiTexture.GetScreenRect ();
print ("This gui element is %d pixel wide.",r.width);
var r = guiText.GetScreenRect();
print ("This gui element is %d pixel wide.",r.width);
}
◆ function HitTest (screenPosition : Vector3, camera : Camera = null) : bool
描述:屏幕上的点在是否在元素内部?如果screenPositon 包含在这个GUIElement 内部时返
回真,screenPosition 以屏幕坐标指定,例如由Input.mousePosition 属性返回的值。如果没有
camera 被指定,一个填充整个游戏窗口的相机将被使用。注意,如果位置在元素内部,true
将被返回。即使游戏物体属于Ignore Raycast 层(通常鼠标事件不会发送到Ignore Raycast
物体)。参见GUILayer.HitTest。
if (guiTexture.HitTest (Vector3 (360, 450, 0.)))
print ("This gui texture covers pixel 360, 450");
if (guiText.HitTest (Vector3(360, 450, 0.)))
print ("This gui texture covers pixel 360, 450");
继承的成员
继承的变量
enable 启用则Behaviour 被更新,不启用则不更新
transform 附加到该GameObject 的Transform(没有返回null)
rigidbody 附加到该GameObject 的Rigidbody(没有返回null)
camera 附加到该GameObject 的Camera(没有返回null)
light 附加到该GameObject 的Light(没有返回null)
animation 附加到该GameObject 的Animation(没有返回null)
constantForce 附加到该GameObject 的ConstantForce(没有返回null)
renderer 附加到该GameObject 的Renderer(没有返回null)
audio 附加到该GameObject 的Audio(没有返回null)
guiText 附加到该GameObject 的GuiText(没有返回null)
networkView 附加到该GameObject 的NetworkView(没有返回null)
guiTexture 附加到该GameObject 的GuiTexture(没有返回null)
collider 附加到该GameObject 的Collider(没有返回null)
hingeJoint 附加到该GameObject 的HingeJoint(没有返回null)
particleEmitter 附加到该GameObject 的ParticleEmitter(没有返回null)
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改
继承的函数
GetComponent 如果游戏附体上附加了一个,则返回type 类组件,没有则返回null
GetComponentInChildren 如果该组件位于GameObject 或任何其子物体上,返回type 类组件,
使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject 或任何它的子物体上,返回type
类组件。
GetComponents 返回GameObject 上所有type 类的组件
CompareTag 该游戏物体被是否被标签为tag?
SendMessageUpwards 在该游戏物体的每个MonoBehaviour 和该行为的父对象上调用名为
methodName 的方法
SendMessage 在该游戏物体的每个MonoBehaviour 上调用methodName 方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour 上调用
methodName
GetInstanceID 返回该物体的实例id
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代理。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
GUIText
类,继承自GUIElement。显示在一个GUI 中的文本字符。
变量
◆ var alignment : TextAlignment
描述:文本的对齐。
guiText.alignment = TextAlignment.Left;
◆ var anchor : TextAnchor
描述:文本的锚点。
guiText.anchor = TextAnchor.MiddleCenter;
◆ var font : Font
描述:用于文本的字体。
var font : Font;
guiText.font = font;
◆ var lineSpaceing : float
描述:行间距倍数。这个可以使被定义在字体中行间距增加。
//双倍行间距
guiText.lineSpacing = 2.0;
◆ var material : Material
描述:用于渲染的Material。赋予一个新的材质来改变渲染处理。改变这个材质来改变渲染
的字体。如果赋值null 到material,将使用内置基本字体。
//改变这个材质显示绿色文本。
guiText.material.color = Color.green;
参见:font variable
◆ var pixelOffset : Vector2
描述:文本的像素偏移。文本从它的原始位置偏移的量。
guiText.pixelOffset = Vector2 (10, 10);
◆ var tabSize : float
描述:这个标签增加的宽度。
guiText.tabSize = 4.0;
◆ var text : string
描述:需要显示的文本。
GUITexture
类,继承自GUIElement。用于2D GUI 的纹理图片。
变量
◆ var color : Color
描述:GUI 纹理的颜色。
//改变纹理的颜色为绿色
guiTexture.color = Color.green;
◆ var pixelInset : Rect
描述: pixellnset 用来调整尺寸和位置。为了使GUI 纹理总是原始大小, 设置
transform.localScale 为Vector3.zero。
transform.position = Vector3.zero;
transform.localScale = Vector3.zero;
guiTexture.pixelInset = Rect (50, 50, 100, 100);
◆ var texture : Texture
描述:用于绘制的纹理。
//将someTexture 赋值给guiTexture。
var someTexture : Texture2D;
guiTexture.texture = someTexture;
继承的成员
继承的变量
enable 启用则Behaviour 被更新,不启用则不更新
transform 附加到该GameObject 的Transform(没有返回null)
rigidbody 附加到该GameObject 的Rigidbody(没有返回null)
camera 附加到该GameObject 的Camera(没有返回null)
light 附加到该GameObject 的Light(没有返回null)
animation 附加到该GameObject 的Animation(没有返回null)
constantForce 附加到该GameObject 的ConstantForce(没有返回null)
renderer 附加到该GameObject 的Renderer(没有返回null)
audio 附加到该GameObject 的Audio(没有返回null)
guiText 附加到该GameObject 的GuiText(没有返回null)
networkView 附加到该GameObject 的NetworkView(没有返回null)
guiTexture 附加到该GameObject 的GuiTexture(没有返回null)
collider 附加到该GameObject 的Collider(没有返回null)
hingeJoint 附加到该GameObject 的HingeJoint(没有返回null)
particleEmitter 附加到该GameObject 的ParticleEmitter(没有返回null)
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改
继承的函数
GetComponent 如果游戏附体上附加了一个,则返回type 类组件,没有则返回null
GetComponentInChildren 如果该组件位于GameObject 或任何其子物体上,返回type 类组件,
使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject 或任何它的子物体上,返回type
类组件。
GetComponents 返回GameObject 上所有type 类的组件
CompareTag 该游戏物体被是否被标签为tag?
SendMessageUpwards 在该游戏物体的每个MonoBehaviour 和该行为的父对象上调用名为
methodName 的方法
SendMessage 在该游戏物体的每个MonoBehaviour 上调用methodName 方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour 上调用
methodName
GetInstanceID 返回该物体的实例id
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代理。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
GUILayer
类,继承自Behaviour。
函数
◆ function HitTest (screenPosition : Vector3) : GUIElement
描述: 在屏幕的制定位置获取GUI 元素。返回屏幕上指定点的GUIElement 。如果
screenPosition 在某个GUIElement 内部,那个元素将被返回。如果这个位置没有在任何GUI
元素内部,返回null。输入Ignore Raycast 层的GUI 元素将被忽略,就像它们不存在。
screenPosition 在屏幕坐标系下, 就像由Input.mousePosition 属性返回的值。参见:
GUIElement.HitTest,Input.mousePositon。
继承的成员
继承的变量
enable 启用则Behaviour 被更新,不启用则不更新
transform 附加到该GameObject 的Transform(没有返回null)
rigidbody 附加到该GameObject 的Rigidbody(没有返回null)
camera 附加到该GameObject 的Camera(没有返回null)
light 附加到该GameObject 的Light(没有返回null)
animation 附加到该GameObject 的Animation(没有返回null)
constantForce 附加到该GameObject 的ConstantForce(没有返回null)
renderer 附加到该GameObject 的Renderer(没有返回null)
audio 附加到该GameObject 的Audio(没有返回null)
guiText 附加到该GameObject 的GuiText(没有返回null)
networkView 附加到该GameObject 的NetworkView(没有返回null)
guiTexture 附加到该GameObject 的GuiTexture(没有返回null)
collider 附加到该GameObject 的Collider(没有返回null)
hingeJoint 附加到该GameObject 的HingeJoint(没有返回null)
particleEmitter 附加到该GameObject 的ParticleEmitter(没有返回null)
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改
继承的函数
GetComponent 如果游戏附体上附加了一个,则返回type 类组件,没有则返回null
GetComponentInChildren 如果该组件位于GameObject 或任何其子物体上,返回type 类组件,
使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject 或任何它的子物体上,返回type
类组件。
GetComponents 返回GameObject 上所有type 类的组件
CompareTag 该游戏物体被是否被标签为tag?
SendMessageUpwards 在该游戏物体的每个MonoBehaviour 和该行为的父对象上调用名为
methodName 的方法
SendMessage 在该游戏物体的每个MonoBehaviour 上调用methodName 方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour 上调用
methodName
GetInstanceID 返回该物体的实例id
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代理。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
LensFlare
类,继承自Behaviour。用于Lensflare 组件的借口。这允许你在运行时改变镜头闪光的亮度
和颜色。
变量
◆ var brightness : float
描述:闪光的强度。这个控制发光元素的尺寸和亮度。
参见:Lens flare component, flare assets。
◆ var color : Color
描述:闪光的颜色。这控制闪光元素的颜色(那些启用了use light color 的)。
参见:Lens flare component, flare assets。
◆ var flare : Flare
描述:使用的flare asset。
参见:Lens flare component, flare assets。
继承的成员
继承的变量
enable 启用则Behaviour 被更新,不启用则不更新
transform 附加到该GameObject 的Transform(没有返回null)
rigidbody 附加到该GameObject 的Rigidbody(没有返回null)
camera 附加到该GameObject 的Camera(没有返回null)
light 附加到该GameObject 的Light(没有返回null)
animation 附加到该GameObject 的Animation(没有返回null)
constantForce 附加到该GameObject 的ConstantForce(没有返回null)
renderer 附加到该GameObject 的Renderer(没有返回null)
audio 附加到该GameObject 的Audio(没有返回null)
guiText 附加到该GameObject 的GuiText(没有返回null)
networkView 附加到该GameObject 的NetworkView(没有返回null)
guiTexture 附加到该GameObject 的GuiTexture(没有返回null)
collider 附加到该GameObject 的Collider(没有返回null)
hingeJoint 附加到该GameObject 的HingeJoint(没有返回null)
particleEmitter 附加到该GameObject 的ParticleEmitter(没有返回null)
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改
继承的函数
GetComponent 如果游戏附体上附加了一个,则返回type 类组件,没有则返回null
GetComponentInChildren 如果该组件位于GameObject 或任何其子物体上,返回type 类组件,
使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject 或任何它的子物体上,返回type
类组件。
GetComponents 返回GameObject 上所有type 类的组件
CompareTag 该游戏物体被是否被标签为tag?
SendMessageUpwards 在该游戏物体的每个MonoBehaviour 和该行为的父对象上调用名为
methodName 的方法
SendMessage 在该游戏物体的每个MonoBehaviour 上调用methodName 方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour 上调用
methodName
GetInstanceID 返回该物体的实例id
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代理。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
Light
类,继承自Behaviour。用于light components 的脚本接口。使用这个来控制Unity 光源的所
有方面。这个属性完全与现实在监视面板中的值相同。通常光源都是在编辑器中创建,但是
有时候需要从脚本中创建。
function Start () {
//制作一个游戏物体
var lightGameObject = new GameObject ("The Light");
//添加光源组件
lightGameObject.AddComponent (Light);
//设置颜色和位置
lightGameObject.light.color = Color.blue;
//在添加光照组件后,设置位置(或任何变换组件)
lightGameObject.transform.position = Vector3 (0, 5, 0);
}
变量
◆ var attenuate : bool
描述:光源是否随着距离衰减?对于Directional 光源衰减总是关闭的。
//关闭光源衰减。
light.attenuate = false;
参见:Light component
◆ var color : Color
描述:光源的颜色。为了修改光源的强度你需要改变光源颜色的亮度。光源总是增加亮度,
因此一个黑色的光源与没有光源相同。光源是否随着距离衰减?对于Directional 光源衰减总
是关闭的。
//在2 秒内使颜色变黑。
function Update () {
light.color -= Color.white / 2.0 * Time.deltaTime;
}
//在2 个颜色之间来回插值光源颜色。
var duration = 1.0;
var color0 = Color.red;
var color1 = Color.blue;
function Update () {
//设置光源颜色
var t = Mathf.PingPong (Time.time, duration) / duration;
light.color = Color.Lerp (color0, color1, t);
}
参见:Light component。
◆ var cookie : Texture
描述:被盖光源投影的cookie 纹理。如果cookie 是一个立方体贴图,光源将变为一个点光
源。注意cookie 只在像素光源下显示。
//在监视面板中公开一个纹理的引用
var newCookie : Texture2D;
//赋cookie
light.cookie = newCookie;
参见:Light component
◆ var cullingMask : int
描述:这个用来选择性的照亮部分场景。如果GameObject 的layerMask 与光源的cullingMask
进行AND 操作后为0.,那么这个游戏物体不能被这个光源照亮。参考Layers 获取更多信息。
//只照亮第一层中的物体(默认层)
light.cullingMask = 1 << 0;
参见:Light component
◆ var flare : Flare
描述:为这个光源使用的flare asset。
//在监视面板中公开一个闪光的引用
var newFlare : Flare;
//赋值闪光
light.flare = newFlare;
参见:Light component 和flare asset。
◆ var intensity : float
描述:光源的强度被光源的颜色乘。该值可以介于0~8 之间。允许你创建明亮的灯光。
//随时间改变光照强度
var duration = 1.0;
function Update() {
//余弦理论
var phi = Time.time / duration * 2 * Mathf.PI;
//获取余弦,并将范围从-1~1 变为0~1
var amplitude = Mathf.Cos( phi ) * 0.5 + 0.5;
//设置光的颜色
light.intensity = amplitude;
}
◆ var range : float
描述:光源的范围。
即使光源关闭了attenuate,它还是只影响在它范围内的物体。
//在原始范围与原始范围一般处变换光照范围
var duration = 3.0;
private var originalRange : float;
originalRange = light.range;
function Update() {
var amplitude = Mathf.PingPong( Time.time, duration );
//将0..持续时间改为0.5..1 范围
amplitude = amplitude / duration * 0.5 + 0.5;
//设置光照范围
light.range = originalRange * amplitude;
}
参见:Light component。
◆ var renderMode : LightRenderMode
描述:如何渲染该光源?此处可以是LightRenderMode.Auto, LightRenderMode.ForceVertex
或LightRenderMode.ForcePixel。像素光渲染比较慢但是看起来较好,尤其是对那些没有较
高面数的几何体。一些效果(例如凹凸)只会在像素光照下显示。
//使光源只以点光照模式渲染
light.renderMode = LightRenderMode.ForceVertex;
参见:Light component
◆ var shadowConstantBias : float
描述:阴影偏移常量。
参见:shadows,shadowObjectSizeBias。
◆ var shadowSizeBias : float
描述:阴影偏移常量。
参见:shadows,shadowConstantBias。
◆ var shadows : LightShadows
描述:这个光源是否投射阴影?
//设置光源为投射硬阴影
light.shadows = LightShadows.Hard;
参见:LightShadows, shadowStrength property, Renderer.castShadows, Renderer.receiveShadows
◆ var shadowStrength : float
描述:光源阴影的强度?
//使光源的阴影非常弱
light.shadowStrength = 0.3;
参见:shadows property, Renderer.castShadows, Renderer.receiveShadows。
◆ var spotAngle : float
描述:光源的投射光角度。主要用于Spot 光源。改变Directional 光源的cookie 尺寸。对Point
光源没有影响。
//在”minAngle”与”maxAngle”之间随机改变投射角度
//每’interval’秒改变一次.
var interval=0.3;
var minAngle=10;
var maxAngle=90;
private var timeLeft:float;
teimleft=interval;
light.type=LightType.Spot;
function Update()
{
timeLeft=Time.deltaTime;
if(timeLeft<0.0){
//开始改变
timeLeft=interval;
light.spotAngle=Random Range(minAngle,maxAngle);
};
}
参见:Light component
? var type:LightType
描述:光源的类型
可以是LightType.Spot,LightType.Directional,LightType.Point.
//制作一个投射光源
Light.type=LightType.Spot;
参见:Light component
继承的成员
继承的变量
Enabled 启用Behaviours 被更新,禁用Behaviours 不被更新。
Transform 附加到这个GameObject 的Transform(如果没有为null)。
Rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
Camera 附加到这个GameObject 的Camera(如果没有为null)。
Light 附加到这个GameObject 的Light(如果没有为null)。
Animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce(如果没有为null)。
Renderer 附加到这个GameObject 的Renderer(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(如果没有为null)。
Collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag 这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponet 返回type 类型的组件,如果游戏物体上附加一个,如果没有返
回null。
GetComponentInchildren 返回type 类型的组件,这个组件位于GameObject 或者任何它的子
物体上,使用深度优先搜索。
GetComponentsInchildren 返回所有type 类型的组件,这些组件位于GameObject 或者任何它
的子物体上。
GetComponets 返回Gameobject 所有type 类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards 在这游戏物体的每个MonoBehaviour 和该行为的组先上调用名为
methodName 方法。
SendMessage 在这游戏物体的每个MonoBehaviour 上调用名为
methodName 方法。
BoradcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上调用
methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的类函数
Operator bool 这个物体存在吗?
Instatiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
MonoBehaviour
类,继承自Behaviour
MonoBehaviour 是每个脚本所继承的基类。
每个使用Javascript 的脚本自动地从MonoBehaviour 继承。当使用C#或Boo 时你必须显式
从MonoBehaviour 继承。
参见:手册中的chapter on scripting.
函数
◆function Cancellnvoke():void
描述:取消所有在这个MonoBehaviour 上调用
//在2 秒时开始
//一个projectile 所在每0.3 秒时运行
var projectile:Rigidbody;
InvokeRepeating(“LaunchProjectile”,2,0.3);
//当用户按下ctrl 按钮时,
//取消重复调用
Function Update()
{
If(Input.GetButton(“Fire1”)){
Cancellnvoke();
}
}
Function LaunchProjectile(){
Instance=Instantiate(prtfab);
Instance.velocity=Random.insideUnitSphere*5;
}
◆function Cancellvoke(methodName:string):void
描述:撤销该行为中名为methodName 的所有调用。
//在2 秒时开始
//一个projectile 将在每0.3 秒时运行
var projectile :Rigidbady;
invokeRepeating(“LaunchProjectile”,2,0.3);
//当用户按下crtl 按钮时
//取消重复调用
Function Update(){
If(Input.GetButton(Fire1)){
Cancellnvode(“LaunchProjectile”);
}
}
Function LanuchProjectile(){
instance=Instntiate(prefab);
instance.velocity=Random.insideUnitSphere*5;
}
◆function Invoke(methodName:string,time:float):void
描述:在time 秒调用methodName 方法。
//在两秒时发射一个投射物
var Projectile:rigidbady;
Invoke(“LaunchProjectile”,2);
Function LaunchProjectile(){
Instance=Instantiate(prefab);
Instance.velocity=Random.insideUnitSphere*5;
}
◆function InvokeRepeating(methodName:string,time:float,repeatRate:float):void
描述:在time 秒调用methodName 方法。
第一次调用之后,每repeatRate 秒重复调用这个函数
//在2 秒时开始
//一个Projectile 将在每0.3 秒运行
var projectile:Rigidbody;
InvokeRepeating(“LaunchProjectile”,2,0.3);
Function LaunchProjectile(){
instance=Instantiate(prefab);
instance.velocity=Random.insideUnitSphere*5;
}
◆function IsInvoking(methodName:string)
描述:是否有任何对methodName 的调用在等待?
◆function IsInvoking(methodName:string):bool
描述:是否有任何MonoBehaviour 的调用在等待?
◆Function StartCoroutine(routine:IEnumerator):Coroutine
描述:开始一个coroutine
一个coroutine 的执行可以任何位置使用yield 语句暂停,当coroutine 继续的时候yield 返回
值,当行为需要跨越多个帧的时候,Coroutines 是非常好的,当Coroutines 几乎没有性能负
担。StartCoroutine 函数总是立即返回,然而你能够yidle 结果,这个将等待直到coroutine
执行完成。
当使用javascript 时,没有必要使用StartCorutine,编译器会为你做这件事。在写C#代码的时
候你必须调用StartCoroutine
//在这个例子中我们显示如何并行调用
//一个coroutine 并继续执行这个函数。
//0 秒后,打印”Starting0.0”
//0 秒后,打印”Before WaitAndPrint Finishes0.0”
//2 秒后,打印”WaitAndPrint 2.0”
print(“Starting”+Time.time);
//WaitAndPrint 作为一个coroutine 开始,并等待直到它完成
WaitAndPrint(2.0)
Print(“Before WaitAndPrint Finishes”+Time.time);
function WaitAndPrint(waitTime:float){
//暂停执行waitTime 秒
Yield WaitForSeconds(waitTime);
Print(“WaitAndPrint”+Time.time);
//WaitAndPrint 作为一个coroutine 开始,并等待直到它完成
Yield WaitAndPrint(2.0);
Print(“Done”+Time.time);
}
C#例子代码如下
//C#例子,在这个例子中我们显示如何并行调用
//一个coroutine 并继续执行这个函数
void Start(){
//0 秒后,打印”Starting0.0”
//0 秒后,打印”Before WaitAndPrint Finishes0.0”
//2 秒后,print”waitAndPrint2.0”
Print(“Starting”+Time.time);
StartCoroutine(WaitAndPrint(2.0F));
Print(“Before WaitAndPrint Finishes”+Time.time);
}
IEnumerator WaitAndPrint(float waitTime){
// 暂停waitTime 秒
Yield return new WaitForSeconds(waitTime);
Print(“WaitAndPrint”+Time);
}
//c#例子
//在这个例子中我们展示如何调用一个coroutine 并等待直到它完成
IEnumerator Start(){
//0 秒后,打印”strating0.0”
//2 秒后,prints”WaitAndPrint2.0”
//2 秒后,打印”Done 2.0”
Print(“Starting”+Time.time);
Yield return StartCoutine(WaitAndPrint(2.0f);
Print(“Done”+Time.time);
}
IEnumerator WaitAndPrint(float waitTime){
//暂停waitTime 秒
Yield return new WaitForSeconds(waitTime);
Print(“WaitAndPrint”+Time.time);
}
◆Function StartCoroutine(methodName: string, value: object=null): Coroutine
描述:开始为methodName 的Coroutine。
在大多数情况下, 你要用StartCoroutine 的变体。然而, 使用一个字符串方法名的
StartCoroutine 允许StopCoroutine 使用一个特定的方法名称。字符串级本的特定时它有较高
的运行时开销来开始coroutine,并且你只能传递一个参数。
//在则合格例子中我们现实如何一个字符串名调用一个coroutine 并停止它
Function Start(){
StartCoroutine(“DoSomething”,2.0);
Yield WaitForSeconds(1);
StopCoroutine(”DoSomething”);
}
Function DoSomething(someParameter: float){
While(true)
{
Print(”DoSomething Loop”);
Yield
}
}
◆Function StopAllCoroutines(): void
描述:停止所有运行在这个行为上的Coroutine。
//开始coroutine
StartCoroutine(“DoSomething”);
//紧跟着取消coroutine
Function DoSomething(){
While(true){
Yield;
}
}
StopAllCoroutines();
◆Function StopCoroutine(methodName: string): void
描述:停止所有运行在这个行为上的名为methodName 的Coroutine。
请注意只使用一个字符串方法名的StartCoroutine 才能使用StopCoroutine 停止。
//在这个例子中我们显示如何使用一个字符串名调用一个coroutine 并停止它
Function Start(){
StartCoroutine(“DoSomething”,2.0);
Yield WaitForSeconds(1);
StopCoroutine(”DoSomething”);
}
Function DoSomething(someParameter: float){
While(true)
{
Print(”DoSomething Loop”);
Yield
}
}
重载函数
◆Function Awake(): void
描述:当脚本实例被加载时,Awake 被调用。
在游戏开始前,使用Awake 来初始化任何变量或游戏状态。在脚本实例的生命期内Awake
只被调用一次。Awake 在所有物体被初始化之后被调用,因此你可以安全地告诉其他物体
或使用如GameObject.FindWithTag 来查询它们。每个游戏物体的Awake 以随机的顺序被调
用。因此,你应该使用Awake 来再脚本之间设置引用,并使用Start 来传递消息。Awake 总
是在任何Start 函数之前调用。这允许你调整脚本的初始化顺序。Awake 不能作为一个
Coroutine
注意对于C#哈Boo 用户:使用Awake 而不是构造函数来初始化,因为组件的序列化状态
在构造的时候还没有确定。Awake 只被调用一次,就像构造函数。
Private var target: GameObject;
Function Awake(){
Target=GameObject.FindWithTag(‘”Player”)
}
Awake 不能作为一个coroutine。
◆Function FixedUpdate (): void
描述:如果MonoBehaviour 被启用,这个函数将以固定的帧率调用。
当处理Rigidbody 是应该使用FixedUpdate 而不是使用Update。例如,当添加一个力到刚体
时,你必须在FixedUpdate 内以固定的帧率应用而不是在Update 内。
//应用一个向上的力到刚体
Function FixedUpdate(){
Rigidbody.AddForce(Vector3.up);
}
力伟到从上一次调用Update 的消逝时间,使用Time.deltaTime,这个函数只在Behaviour 被
启用时调用。重载这个函数,以便给你的组件提供功能。
◆Function LateUpdate (): void
描述:如果该Behaviour 被启用,LateUpdate 将在每帧中调用。
LateUpdate 在所有Update 函数被调用后调用。这可用于调整脚本执行顺序。例如,一个跟
随相机应该总是在LateUpdate 中实现,因为他跟踪Update 中移动的物体。
//向前以1 米/秒的速度移动物体
Function LateUpdate (){
transfor.Translate(0,0,Time.deltaTime*1);
}
为了得到从最后一个调用LateUpdate 的消逝时间,使用Time.deltaTime。如果该Behaviour
被启用,该函数将在每帧中调用。重载这个函数,以便给你的组件提供功能。
◆Function OnApplicationPause(pause: bool): void
描述:当玩家暂停时发送到所有游戏物体。
OnApplicationPause 可以是一个coroutine,简单地在这个函数中使用yield 语句。
◆Function OnApplicationQuit(): void
描述:在应用退出之前发送到所有游戏物体。
在编辑器中当用户停止播放模式时这个被调用。在网页播放器中当web 被关闭时这个函数
被调用。
◆Function OnBecameInvisible(): void
描述:OnBecameInvisible 函数在这个渲染上的脚本。OnBecameVisible 和OnBecameInvisible
可以用于只需要在需要在物体可见时才进行的计算。
//当它不可见时禁用这个行为
Finction OnBecameInvisible(){
Enabled=false;
}
OnBecameInvisible 可以是一个coroutine,简单地在这个函数中使用yield 语句。当在编辑器
中运行时,场景试图相机也会导致这个函数被调用。
◆Function OnBecameVisible(): void
描述:OnBecameVisible 函数在这个渲染器对任何相机变得可见时被调用。
这个消息被发送到所有附加在渲染器上的脚本。OnBecameVisible 和OnBecameInvisible 可以
用于只需要在需要在物体可见时才进行的计算。
//当它不可, 见时禁用这个行为
Finction OnBecameVisible(){
Enabled=false;
}
OnBecameVisible 可以是一个coroutine,简单地在这个函数中使用yield 语句。当在编辑器中
运行时,场景试图相机也会导致这个函数被调用。
◆Function OnCollisionEnter(collisionInfo: Collision): void
描述:
当这个碰撞器/刚体开始接触另一个刚体/碰撞器时OnCollisionEnter 被调用。
相对于OnTriggerEnter,OnCollosionEnter 传递Collision 类而不是Collider,Collision 类包含
接触点,碰撞速度等细细。如果在函数中不使用CollisionInfo,省略CollisionInfo 参数以避
免不西药的计算。注意如果碰撞器附加了一个非动力学刚体,也只发送碰撞事件。
Function OnCollisionEnter(collision: Collision){
//调试绘制所有的接触点和法线
For(var contact: ContactPoint in collision.oontacts){
Debug.DrawRay(contact.point, contact.normal, Color.white);
}
//如果碰撞物体有较大的冲击就播放声音
If(collision.relativeVelocity.magnitude>2)
Audio.Play();
}
OnCollisionEnter 可以是一个coroutine,简单地在这个函数中使用yield 语句。
◆Function OnCollisionExit(collisionInfo: Collision): void
描述:当这个碰撞器/刚体开始接触另一个刚体/碰撞器时OnCollisionEnter 被调用。
相对于OnTriggerExit,OnCollosionExit 传递Collision 类而不是Collider. Collision 类包含接
触点,碰撞速度等细细。如果在函数中不使用CollisionInfo,省略CollisionInfo 参数以避免
不西药的计算。注意如果碰撞器附加了一个非动力学刚体,也只发送碰撞事件。
Function OnCollisionExit(collision: Collision){
Print(“No longer in contact with”+collisionInfo.transform.name);
}
OnCollisionExit 可以是一个coroutine,简单地在这个函数中使用yield 语句。
◆function OnCollisionStay(collisionInfo:collision):void
描述:对于每个与刚体碰撞器相触碰的碰撞器刚体,OnCollisionStay 将在每一帧中被调用。
相对于OnTriggerStay,OnCollisionStay 传递Collision 类而不是Collider.Collision 类包含接触
点,碰撞速度等细节。如果在函数中不使用collisionInfo 省略collisionInfo 参数以避免不要
必要的计算。注意如果碰撞器附加了一个非动力学刚体,也只发送碰撞事件。
function OnCollisionStay(CollisionInfo:Collision){
//调试绘制所有的接触点和法线
for (var contact:ContactPoint in collision.contacts){
Debug.DrawRay(contact.point,contact.normal,Color.white);
}
}
OnCollisionStay 可以是一个coroutine,也简单地在这个函数中使用yield 语句
◆function OnConnectedToServer():void
描述:当成功链接到服务器时在客户端调用这个函数。
function OnConnectedToServer(){
Debug.Log(“Connected to server”);
//发送到本地玩家名称到服务器
}
◆function OnControllerColliderHit(Hit:controllerColliderHit):void
描述:在移动的时候,控制器碰到一个碰撞器时,OnControllerColliderHit 被调用。
这可以用来在角色碰到物体时推开物体。
//这个脚本推开所有角色碰到物体时推开物体
Var pushPower=2.0;
Function OnControllerColliderHit(hit: OnControllerColliderHit){
Var body:Rigidbody=hit.collider.attachedRigidboby;
//无刚体
If(body==null||body.isKinematic)
return;
//不推开我们身后的物体
If(hit.moveDirection.y<-0.3)
Return;
//从移动方向计算推的方向
//只推开物体到旁边而不是上下
Var pushDir=Vector3(hit.moveDirection.x,0,hit.moveDirection.z)
//如果知道角色移动有多快
//然后你就可以用它乘以推动速度
//使用推力
Body.velocity=pushDir*pushPower;
}
◆function OnDisable():void
描述:当这个行为禁用或不活动时这个函数被调用。
当物体被销毁的时候这个函数也会被调用并可以用于任何清理的代码。当脚本在编译结束后
被加载时,OnDisable 将被调用,然后脚本加载完成后OnEnable 被调用。
Function OnDisable(){
Print("scrip was remove”);
}
OnDisabe 不能作为一个coroutine.
◆function OnDisconnectedFromServer(mode:NetworkDisconnection):void
描述:当链接挂失或服务器断开时在客户端用这个函数。
Function OnDisconnectedFromServer(info.NetworkDisconnection){
Debug.Log(“Disconnected from server”+info);
}
◆function OnDrawGizmos():void
描述:如果你想绘制可被点的Gizmos 时,实现OnDrawGizmos,
这允许你在场景中快速选择重要的物体。
//在物体的位置上绘制光源灯泡
function OnDrawGizmos(){
Gizmos.DrawIcon(transform.position,”light Gizmo.tiff”);
}
◆function OnDrawGizmosSelected():void
描述:如果你想在物体被选择时绘制gizmos,实现这个OnDrawGizmosSelected。
Gizmos 只在物体被选择的时候绘制。Gizmos 不能点选。这可以设置更容易,例如
一个爆炸脚本可以绘制一个球显示爆炸半径。
var explosionRadius=5.0;
function OnDrawGizmosSelected(){
//选中的时候显示爆炸半径
Gizmos.color=Color.white;
Gizmos.DrawSphere(transfom.position,explosinRadius);
}
◆function OnEnable():void
描述:当物体启用或激活时这个函数被调用
function OnEnbale(){
print(“script was enabled”);
}
◆function OnFailedToconnect(error:NetworkConnectionError);void
描述:当链接因为某些原因失败时在客户端上调用这个函数。
失败的原因作为NetworkConnectionError 枚举传入。
function OnFailedToconnect (info:NetworkConnectionError){
Debug.Log(“Could not connect to server”+error);
◆function OnFailedToConnectToMasterServer (error:NetworkConnectionError):void
描述:当链接到主服务器出现问题时在客户端或服务器调用这个函数。
错误的原因作为NetworkConnectionError 枚举传入
function OnFailedToConnectToMasterServer(info:NetworkConnectionError){
Debug.Log(“Could not connect to master server”+info);
}
◆function OnGUI():void
描述:OnGUI 被调用来渲染并处理GUI 事件。
如果Monobehaviour 的启用属性被设置为假,OnGUI()将不会被调用。
Function OnGUI(){
If(GUI>Button(Rect(10,10,150,100),”I am a button”)){
Print(“You clicked the button”)
}
}
参考GUI Scrtipting Guide 获取更多信息。
◆function ONJointBreak(breakForce:float):void
描述:当附加到相同游戏物体上的关节被断开时调用
当一个力大于这个关节的breakForce 时,关节将被断开,当关节断开时,OnJointBreak 将被
调用,应用到关节的断开力将被传入,OnJointBreak 之后这个关节将自动从游戏物体移除。
参见:Joint.breakForce
◆function OnLevelWasLoaded(level:int):void
描述:这个函数在一个新的关卡被加载之后被调用
//level 是被加载的关卡的索引。使用菜单项File>Build Settings 来查看索引引用的是那个场
景,参见:Application.LoadLevel
//当关卡13 被加载的关卡的索引”Woohoo”
Function OnLevelWasLoaded(level:int){
If(level==13){
Print(“Woohoo”);
}
}
OnLevelWasLoaded 可以是一个coroutine,简单地在这个函数中使用yield 语句。
◆function OnMouseDown():void
描述:当用户在GUIElement 或Collider 上按下鼠标按钮时OnMouseDown 被调用
这个事件被发送到所有附加在Collider 或GUIElement 的脚本上。
//加载名为“someLevel”的关卡
//来响应用户单击
Function OnMouseDown(){
Application.LoadLevel(“SomeLevel”);
}
这个函数不会在属于Ignore Raycast 的层上调用。
OnMouseDown 可以是一个coroutine,简单地在这个函数中使用yield 语句。这个事件被发
送到的有附加在Collider 或GUIElement 的脚本上。
◆function OnMouseDrag():void
描述:当用户在GUIElement 或Collider 上点击并按住鼠标时OnMouseDrag 被调用。
当鼠标被按下时OnMouseDrag 将在每帧中被调用。
//按住鼠标时使用材质颜色变暗
function OnMouseDrag(){
renderer.material.color==Color.white*Time.deltaTime;
}
这个函数不会在属于Ignore Ray 的层被调用。
OnMouseDrag 可以是一个coroutine,简单地在这个函数中使用yield 语句。这个事件被发送
到所有附加在collider 或GUIElement 的脚本上。
◆Function OnMouseEnter():void
描述:当鼠标进入GUIElement 或collider 时,OnMouseEnter 被调用。
//附加这个脚本到网格
//使用当鼠标经过这个网格时使它变红
Function OnMouseEnter(){
Renderer.material.color=Color.red;
}
这个函数不会在属于Ignore Raycast 的层上调用。
OnMouseEnter 可以是一个coroutine,简单地在这个函数中使用yield 语句。这个事件被发送
所有附加在Collider 或GUIElement 的脚本上。
◆function OnMouseExit():void
描述:当鼠标不再位于GUIElement 或Collider 上时,OnMouseExit 被调用。
OnMouseExit 与OnMouseEnter 相反
//当鼠标在网格时
//渐变材质的红色组件为零
Function OnMouseExit(){
Rnderer.material.color=Color.white;
}
这个函数不会在属于Ignore Raycast 的层上调用。
OnMouseExit 可以是一个coroutine,简单地在这个函数中使用yield 语句。这个事件被发送
到所有附加在Collider 或GUIElement 上脚本上。
◆function OnMouseOver();void
描述:当鼠标在GUIElement 或Collider 上时,OnMouseOver 被调用。
//当鼠标在网格上时
//渐变材质的红色组件为零
function OnMouseOver(){
renderer.material.color==0.1*Time.deltaTime;
}
这个函数不会在属于Ignore Raycast 的层上调用。
OnMouseOver 可以是一个coroutine,简单地在这个函数中使用yield 语句,这个事件被发送
到所有附加在Collider 或GUIElement 的脚本上。
◆function OnMouseUP():void
描述:当用户已经松开鼠标按钮时OnMouseUp 调用。
在GUIElement 或Collider 上松开鼠标时OnMouseUp 被调用。
//加载名为”someLevel”的关卡
//来响应用户单击
function OnMouseUp(){
Application.LoadLevel(“SomeLevel”);
}
这个函数不会在属于Ignore Raycast 的层上调用。
OnMouseUp 可以是一个coroution,简单地在这个函数yield 语句。这个事件被发送到所有附
加在Collider 或GUIElement 的脚本上。
◆function OnNetworkInstantiate(info:NetworkMessageInfo):void
描述:当一个物体使用Network.Instantiate 进行网络初始化在该物体上调用这个函数。
这个对于禁用或启用一个已经初始化的物体组件来说是非常有用的,它们的行为取决与它们
是在本地还是在远端。
注意:在NetworkMessageInfo 里的networkView 属性不能在OnNetworkInstantiate 里使用。
function OnNetworkInstantiate(info:NetworkMessageInfo){
Debug.Log(“New object instantiated by”+info.sender);
}
◆function onParticleCollision(other:GameObject):void
描述:当一个粒子碰到一个碰撞器时OnParticleCollision 被调用。
这个可以在游戏物体被粒子击中时应用伤害到它的上面,这个消息被发送到所有附加到
WorldParticleCollider 的脚本上和被击中的Collider 上,这个消息只有当你在
WorldParticleCollider 检视面板中启用了sendCollisionMessage 时才会被发送。
//应用力到所有被粒子击中的刚体上
function OnParticleCollison(other:GameObject){
var body=other.rigidbody;
if(body){
var direction=other.transform.position+transform.position;
direction=direction.normalized;
body.AddForce(direction*5);
}
}
OnParticleCollision 可以是一个coroutine,简单地在这个函数中使用yield 语句。
◆function OnPlayConnected(player:NetworkPlayer):void
描述:当一个新玩家成功连接在服务器上调用这个函数。
private var playerCount:int=int=0;
function OnPlayerConnect(player.NetworkPlayer){
Debug.log(“Player”+playerCount+++”connected from”+player.ip.Address+”:”+player.port);
//用玩家的信息构建一个数据结构
}
◆function OnPlayerDisconnected(player:NetworkPlayer):void
描述:当玩家从服务器断开时在服务器上调用这个函数。
function OnPlayerDisconnected (player:NetworkPlayer){
Debug.Log(“Clean up after player”+player);
Network.RemoveRPcs(player);
Network.DestroyPlayerObject(player);
}
◆function OnpostRender():void
描述:OnPostRender 在相机渲染场景之后调用。
只有脚本被附加到相机上时才会调用这个函数。OnPostRender 可以是一个coroutine,
简单地在这个函数中使用yield 语句。
OnPostRender 在相机渲染完所有它的物体之后被调用。如果你想在所有相机和GUI 被渲染
之后做一些事情,使用WaitForEndFrame coroutine
参见:OnPreRender,WaitForEndOfFrame
//当附加到机时,将消除
//相机纹理的alpha 通道为纯白色
//如果你有一个渲染纹理并想将它显示在GUI 上时可以使用这个函数
Parvate var mat:Material;
function OnPostRender(){
//创建一个只渲染白色到alpha 通道的着色器
If(mat)
{
Mat=new Material(“Shader Hidden SetAlpha”+)
“SubShader{“+”pass{”+”ZTest Always Cull off Zwrite
Off”+”ColorMaskA”+”Color(1,1,1,1)”+”}”+”}”
+”}”);
}
}
// 用上述着色器绘制一个全屏四边形
GL.PushMatrix();
GL.LoadOrtho();
for(var i=0;i<mat.pssCount;++i){
mat.SetPass(i);
GL.Begin(GL.QUADS);
GL.Vertex3(0,0,0.1);
GL.Vertex3(1,0,0.1);
GL.Vertex3(1,1,0.1);
GL.Vertex3(0,1,0.1);
GL.End();
}
GL.PopMatrix();
}
◆function OnpreCull():void
描述:OnPreCull 在相机开始裁剪场景之前调用
裁剪决定那个物体对于相机来说是可见的。OnPreCull 仅仅在这个过程之间被调用。
只有脚本被附加到相机上时才会调用这个函数
如果你想改变相机的视觉参数(例如fieldOfView 或者仅是变换),就在这里做这个。
场景物体的可见性将基于相机参数在OnPerCull 之后确定。
? function OnRender():void
描述:OnpreRender 在相机开始渲染场景之前调用。
只用脚本被附加到相机上时才会调用这个函数。
注意如是果你在这里改变了相机的视野参数(例如fieldOfView),它们将影响下一帧。用
OnPreCull 代替。OnPreRender 可以是一个coroutine,简单地在这个函数中使用yield 语句。
参见:OnPostRender
? function OnRenderImage(source:RenderTexture,destination:RenderTexture):void
描述:OnRenderImage 在所有渲染完成后被调用,来渲染图片的后期处理效果(限于Unity
Pro)
这允许你使用基于shader 的过滤器来处理最后的图片。进入图片是source 渲染纹理结果是
destination 渲染纹理。当有多个图片过滤附加在相机上时,它们序列化地处理图片,将第一
个过滤器的目标作为下一个过滤器的源。
这个消息被发送到所有附加在相机上脚本。
参见:Unity Pro 中的image effects
◆function OnRenderObject(queueindex:int):void
描述:OnRenderObject 被用来渲染你自己的物体,使用Graphics.DarwMesh 或者其他函数。
queueIndex 指定用来渲染物体的render queue。可以使用RenderBeforeQueues 属性来指定你
想绘制这个物体到哪里渲染队列。
◆function OnserializeNetworkView(stream:Bitstream.info:NetworkMessageInfo):void
描述:用来在一个被网络视监控的脚本中自定义变量同步
它自动决定被序列化的变量是否应该发送或接收,查看下面的例子获取更好的描述:
//这个物体的生命信息
Int currentHealth;
function OnSerializeNetworkView(stream:BitStream,info:NetworkMessageInfo){
if(stream.isWriting){
int health=currentHealth;
stream.Serialize(health);
}
else{
int health=0;
stream.Serialize(health);
currentHealth=health;
}
}
◆function OnServerInitialized():void
描述:当Network.InitializeServer 被调用并完成时,在服务器上调用这个函数。
function OnServerInitialized(){
Debug.Log(“Server initialize and ready”);
}
◆function OnTriggerEnter(other:Collider):void
描述:当这个Collider other 进入trigger 时OnTriggerEnter 被调用。
这个消息被发送到这个触发器碰撞器和接触到触发器的刚体(或者是碰撞器如果没有刚体)。
注息如果碰撞器附加了一个刚体,也只发送触发器事件。
//销毁所有进入该触发器的物体
function OntriggerEnter(other:Collider){
Destroy(other.gameObject);
}
OnTriggerEnter 可以是一个coroutine 简单地在这个函数中使用yield 语句。
◆function OnTriggerExit(other:Collider):void
描述:当这个Collider other 停止触碰trigger 时OnTriggerExit 被调用。
这个消息被发送到触发和接触到这个触发器的碰撞器。注意如果碰撞附加了一个刚体,也只
发送触发器事件。
//觥毁所有离开该触发器的物体
function OntriggerExit (other:Collider){
Destroy(other.gameObject);
}
OnTriggerExit 可以是一个coroutine,简单地在这个函数中使用yield 语句。
◆function OnTriggerStay(other:Collider):void
描述:对于每个Collider other,当它触碰到trigger 时,OnTriggerStay 会在每一帧中都被调用。
这个消息被发送到触发器和接触到这个触发器的碰撞器。注意如果碰撞器附加了一个刚体,
也只发送触发器事件。
//对所进入这个触发器的刚体使用一个向上的力
function OnTriggerStay(other:Collider){
if(other.attachedRigidbody){
other.attachedRigidbody.AddForce(Vector3.up*10);
}
}
OnTriggerStay 可以是一个coroutine,简单地在这个函数中使用yield 语句。
◆function OnWillRenderObject():void
描述:如果物体可见,每个相机都会调用OnWiiRenderObject。
这个函数在裁剪过程中被调用,在渲染所有被裁剪的物体之前被调用。可以用这个来创建具
有依赖性的渲染纹理,只有在被渲染的物体可见时才更新这个渲染纹理。作为一个例子,水
组件就使用这个。
Camera.current 将被设置为要渲染这个物体的相机
◆function Reset():void
描述:Reset 在用户点击检视面版的上下文菜单或者第一次添加该组件被调用。Reset 只在编
辑模式下调用。Reset 最常用于在检视面板中给定一个好的默认值
//设置target 为一个默认的值
//这可以用于跟随相机
var target:GameObject;
function Reset(){
//如果target 没有赋值,设置它
if(!target){
target=GameObject.FindWithTag(“play”);
}
}
◆function Start():void
描述:Start 在所有Update 方法被第一次调用前调用。
Start 在行为的生命期内只调用一次。Awake 和Start 的不同在于Start 只在脚本实例被启用时
调用。这个允许你延迟所有初始化代码,知道真正需要它们的时候,Awake 总是在任何Start
函数之前调用。这允许你调整脚本的初始化顺序。Start 不能作为一个coroutine
Start 函数在所有脚本实例的Awake 函数调用之后调用。
//初始化target 变量
//target 是私有的并且不能在检视面板中编辑
parivate var target:GameObject;
function Start(){
target=GameObject.FindWithTag(“Player”);
}
◆function Update():void
描述:如果MonoBehaviour 被启用,Update 将在每帧中调用。
Update 是最常用的函数,来实现任何游戏行为。
//向前以1 米的速度移动物体
function Update(){
transform.Translate(0,0,Time.deltaTime*1);
}
为了得到从最后一次调用Update 的消逝时间,使用Time.deltaTime。如果该Behaviour
被启用,该函数将在每帧中调用,重载这个函数,以便给你的组件提供功能。
继承的成员
继承的变量
endbled 启用Behaviours 被更新,禁用Behaviour 不被更新
transform 附加到这个GameObject 的Transform(如果没有null)
rigidbody 附加到这个GameObject 的Rigidbody(如果没有null)
camera 附加到这个GameObject 的Camera(如果没有null)
light 附加到这个GameObject 的Light(如果没有null)
animation 附加到这个GameObject 的Animation(如果没有null)
constantForce 附加到这个GameObject 的ConstantForce(如果没有null)
renderer 附加到这个GameObject 的Renderer(如果没有null)
audio 附加到这个GameObject 的Audio(如果没有null)
guiText 附加到这个GameObject 的GUIText(如果没有null)
networkView 附加到这个GameObject 的NetworkView(只读)(如果没有null)
guiTexture 附加到这个GameObject 的GUITexture(只读)(如果没有null)
collider 附加到这个GameObject 的Collider(如果没有null)
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有null)
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有null)
gameObject 这个组件附加的游戏物体。一个组件总是附加到一个游戏物体
tag 这个游戏物体的标签
name 对象的名称
hideFlags 该物体是否被隐藏,保存在场景或被用户修改
继承的函数
GetComponent 返回type 类型组件,如果游戏物体上附加了一个如果没有返回
null。
GetComponentInChildren 返回type 类型的组件,这个组件位于GameObject 或任何它的子
物体上,使用深度优先搜索。
GetComponentsInChildren 返回所有type 类型的组件,这些组件位于GameObject 或任何它
的子物体上。
GetComponents 返回GameObject 上所有type 类型的组件。
CompareTag 这个游戏物体被标签为tag?
SendmessageUpwards 在这个游戏物体的每个MonoBehaviour 和该行为的祖先上
调用名为methodName 方法
SendMessage 在这个游戏物体上的每个MonoBehaviour 上调用methodName
方法。
BroadcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上调用
methodName 方法。
GetInstanceID 返回该物体的实例ID。
继承的类函数
Operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
Terrain
类,继承自MonoBehaviour
渲染地形的Terrain
变量
◆var basemapDistance:float
描述:超出basemapDistance 的高度图,将使用预先计算的地解析度basemap。
这个可以改善远处块的性能。Unity 混合任意数量的地形纹理,使用条图来渲染近处的高度
图。
function Start(){
Terrain.activeTerrain.basemapDistance=100;
}
◆var castShadows:bool
描述:地形应该投射阴影?
◆var detailObjectDistance:float
描述:在这个距离内细节将被显示。
function Start(){
Terrain.activeTerrain.detailObjectDistance=40;
}
◆var heightmapMaximumLOD:int
描述:让你实质降低用于渲染的高度图解析度
这个可用在低端的显卡上并不会显示最高的LOD 地形。值为0 表示总是显示最高细节。
值为1 表示三角形数量将减小到1/4,高度图的解析度将是宽度和高度的一半。
function Start(){
Terrain.activeTerrain.heightmapMaximumLOD=1;
}
◆var heightmapPixelError:float
描述:当切换LOD 时大约有多少像素时地形将处于错误的情况。
较高的值减少多边形的绘制数量。
function Start(){
Terrain.activeTerrain.heightmapPixelError=10;
}
◆var Lighting:Terrain.Lighting
描述:地形光照模式
参见:TerrainLighting 枚举,Terrain Lightmap,terrain Settings
◆var terrainData:TerrainData
描述:存储在高度图中的地形数据,地形纹理,细节网格和树。
◆var treebillboardDistance:float
描述:到相机的距离超过这个值,树只被作为公告板渲染。
降低这个值将改善性能,但是使过度看起来更差因为公告板和树的不同将更加明显。
Function Start(){
Terrain.activeTerrain.treeBillboardDistance=100;
}
◆var treeCrossFadeLength:float
描述:树从公告变换到网格到网格的总距离增量。
降低这个值将使变换发生的越快。设置为0 时,在从网格切换分告表示时将立即发生。
function Start(){
Terrain.activeTerrain.treeCrossFadeLength=20;
}
◆var treeDistance:float
描述:渲染树的最大距离。
这个值越高,越远的树将看到,运行的也更慢。
参见:Terrain.treeBillboardDistance
function Start(){
Terrain.activeTerrain.treeDistance=2000;
}
◆var treeMaximumFull.ODCount:int
描述:全LOD 时渲染树的最大数量。
这个是一个简单的设置用来阻止太多的楼以过高的解析度和密度被绘制。因为如果
treeMaximumFullLodCount 过高,树将不会消失,你应该修改treeBillboardDistance 为不
包含。
Function Start(){
Terrain.activeTerrain.treeMaximumFullLODCount=200;
}
函数
◆function SampleHeight(worldPositon:Vector3):float
描述:在世界空间的给定位置处采样高度。
function LateUpdate(){
transfom.positon.y=Terrain.activeTerrain.SampleHeght(transfom.position);
}
◆function SetNeighbors(left:Terrain,top:Terrain,right:Terrain,bottom:Terrain):void
描述:允许你在相邻地形间设置连接
这个确保LOD 在相邻地形上相同。注意,在一个地形上调用这个函数是不够的,你需要在
每个地形上设置邻居。
类变量
◆static var activeTerrain: Terrain
描述:激活的地形。这个是用来在场景中获取主地形的快捷方式。
类方法
◆Static functin CreateTerrainGameObject(assignTerrain: TerrainData): GameObject
描述:从TerrainData 创建一个包含碰撞器的地形。
继承的成员
继承的变量
Enabled 启用Behaviour 被更新,禁用Behaviours 不被更新。
transform 附加到该GameObject 的Transform(没有返回null)
rigidbody 附加到该GameObject 的Rigidbody(没有返回null)
camera 附加到该GameObject 的Camera(没有返回null)
light 附加到该GameObject 的Light(没有返回null)
animation 附加到该GameObject 的Animation(没有返回null)
constantForce 附加到该GameObject 的ConstantForce(没有返回null)
renderer 附加到该GameObject 的Renderer(没有返回null)
audio 附加到该GameObject 的Audio(没有返回null)
guiText 附加到该GameObject 的GuiText(没有返回null)
networkView 附加到该GameObject 的NetworkView(没有返回null)
guiTexture 附加到该GameObject 的GuiTexture(没有返回null)
collider 附加到该GameObject 的Collider(没有返回null)
hingeJoint 附加到该GameObject 的HingeJoint(没有返回null)
particleEmitter 附加到该GameObject 的ParticleEmitter(没有返回null)
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改
继承的函数
Invok e 在time 秒调用methodName 方法。
Invok Repeating 在time 秒调用methodName 方法。
CancelInvoke 取消所有在这个MonoBehaviour 上的调用
IsInvoking 是否有任何对methodName 的调用在等待?
StartCoroutine 开始一个coroutine
StopCoroutine 停止所有运行在这个行为上的名为methodName 的coroutine
StopAllCoroutines 停止所有运行在这个行为上的coroutine
GetComponent 返回type 类型的组件,如果游戏物体上附加了一个,如果没有
返回null。
GetComponcetInChildren 返回type 类型的组件,这个组件位于GameObject 或任何它的子
物体上。使用深度优先搜索
GetComponcetsInChildren 返回所有type 类型组件,这些组件位于Gameobject 或任何它的
子物体上。
GetComponents 返回GameObject 上所有type 类型的组件。
CompareTag 这个游戏物体被标签为tag?
SendMessageUpwards 在这个游戏物体的每个MonoBehaviour 和该行为的祖先上调用
名为methodName 方法。
SendMessage 在这个游戏物体上的每个MonoBehaviour 上调用methodName
方法。
BroadcastMessage 在这个游戏物体或其2 任何子的每个MonoBehaviour 上调用
methodName 方法。
GetInstanceID 返回该物体的实例ID。
继承的消息传递
Update 如果MonoBehaviour 被启用,Update 将在每帧中
调用。
LateUpdate 如果该Behaviour 被禁用,LateUpdate 将在每帧中
调用。
FixedUpdate 如果MonoBehaviour 被启用,这个函数将在每帧中调用。
Awake 当脚本实例被加载时,Awake 被调用。
StartStart 在所有Update 方法被第一次调用前调用。
Reset Reset 在用户点击检视面板的上下文菜单或第一次添加该组件时
被调用。
OnMouseEnter 当鼠标进入GUIElement 或Collider 时,OnMouseEnter 被调用。
OnMouseOver 当鼠标在GUIElement 或Collider 时,OnMouseEnter 被调用。
OnMouseExit 当鼠标不再位于GUIElement 或Collider 上时,OnMouseExit 被调用。
OnMouseDown 当用户在GUIElement 或Collider 上按下鼠标按钮时
,OnMouseDown 被调用。
OnMouseUp 当户已经松开鼠标按钮时OnMouseUp 被调用。
OnMouseDrag 当用户在EUIElement 或Collider 上点击并按住鼠标时
OnMouseDrag 被调用。
OnTriggerEnter 当这个Collider other 进入trigger 时OnTriggerEnter 被调用。
OnTriggerExit 当这个Collider other 停止触碰trigger 进OnTriggerExit 被调用。
OnTriggerStay 对于每个Collider other,当它触碰到trigger 时,OnTriggerStay
会在每一帧中都会被调用。
OnCollisionEnter 当这个碰撞器刚体开始触碰另一个刚体碰撞器
时OnCollisionEnter 被调用。
OnCollisonExit 对于每个与碰撞器刚体停止触碰另一个刚体碰撞器时
OnCollisionExit 被调用。
OnCollisonStay 对于每个与刚体碰撞器相触的碰撞器刚体OnCollisonStay 将在每
一帧中被调用。
OnControllerColliderHit 在移动的时候,控制器碰到一个碰撞器时OnControllerColliderHit
被调用。
OnJointBreak 当附加到相同游戏物体上的关节被断开时调用。
OnParticleCollision 当一个粒子碰到一个碰撞器时OnParticleCollision 被调用。
OnBecameVisibleOnBecamevisible 函数在这个渲染器对任何相机变得可见时被
调用。
OnBecameInvisibleOnBecamevisible 函数在这个渲染器对任何相机变得不可见时被
调用。
OnLevelWasLoaded 这个函数在一个新的关卡被加载之后被调用。
OnEnable 当物体启用或激活时这个函数被调用。
OnDisable 当这个行为禁用或不活动时这个函数被调用。
OnPreCull OnPreCull 在相机开始裁剪场景之前调用。
OnPreRender OnPreRender 在相机开始渲染场景之后调用。
OnPostRender OnPostRender 在相渲染场景之后调用。
OnRenderObjectOnRenderObject 被用来渲染你自己的物体,使用
Graphics.DrawMesh 或者其他函数。
OnWillRenderObject 如果物体可见,每个相机都会调用OnWillRenderObject。
OnGUI OnGUI 被调用来渲染并处理GUI 事件。
OnRenderImageOnRenderImage 在所有渲染完成后被调用,来渲染图片。
OnDrawGizmosSelected 如果你想在物体被选择时绘制gizmos,实现这个
OnDrawGizmosSelected.
OnDrawGizmos 如果你想绘制可被点选的gizmos 时,实现OnDrawGizmos。
OnApplicationPause 当玩家暂停时发送到所有游戏物体。
OnApllicationQuit 在应用退出之前发送到所有游戏物体。
OnPlayerConnected 当一个新玩家成功连接时在服务器上调用这个函数。
OnServerInitialized 当Network.InitializeServer 被调用并完成时,在服务上调用这
个函数。
OnConnectedToServer 当成功链接到服务器上时在客户端调用这个函数。
OnPlayerDisconnected 当玩家从服务器断开时在服务器上调用这个函数。
OndisconnectedFormServer 当链接丢失或服务器断开时在客户端调用这个函数。
OnFailedToConnect 当链接因为某些原失败时在客户端上调用这个
函数
OnFailedToConnectToMasterServer 当链接到主服务器出现问题时在客户端或服务器端调
用这个函数。
OnNetworkInstantiate 当一个物体使用Network.Instantiate 进行网络初始化时在该物体上调
用这个函数。
OnSerializeNetworkView 用来在一个被网络视监控的脚本中自定义变量同步。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
operator == 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
NetworkView
类,继承自Behaviour
网络视是多用户游戏的绑定物。
使用这个你可以准确定义什么应该通过网络同步, 和如何同步, 游戏物体可以有
NetworkView 组件,该组件可以被定义为观察物体的其他组件,可以在Network View manual
page 和component reference page 获取更多信息。
变量
◆ var group : int
描述: 这个网络视所在的网格组。
所有的网格消息和RPC 调用通过这个组。
Function Awake(){
//通过组1 发送来自这个网格视的所有消息
Network View.group=1;
}
◆ var isMine : bool
描述:这个网格视是有这个物体控制吗?
Function OnNetworkInstantiate(info: NetworkMessageInfo){
If{networkView.isMine}
Debug.Log(“New object instanted by me”);
Else
Debug.Log(“New object instantiated by”+info.sender);
}
◆ var obseved : Component
描述:网络视监控的组件。
//打印含有由数组中给出的viewID 的对象的名称(Print the names of the objects which have the
view IDs given in the array)
Function PrintNames(viewIDs: Array){
For (var ID: NetworkViewID in IDs){
Debug.log(“Finding”+ID);
Var view : NetworkView = networkView.Find(ID);
Debug.log(view.observed.name);
}
}
◆ var owner : NetworkPlayer
描述: 拥有这个网络视的NetworkPlayer
function OnNetworkInstantiate(info: NetworkMessageInfo){
if(!networkView.isMine)
Debug.log(“New object instantiated by” + networkView.owner);
}
◆ var stateSynchrohization: NetworkStateSynchronization
描述:为这个网络视设置的NetworkStateSynchronization 类型。
确保NetworkView 在所有机器上使用相同可靠的方法是你的责任。在状态同步已经发生后
不要在运行时改变状态的可靠性。
◆ var viewID: NetworkViewID
描述:这个网络视的ViewID。
函数
◆ function RPC(name: string, mode: RPCMode, params args:object[]): void
描述:在所有连接端调用一个RPC 函数。
调用的函数必须有@RPC 标志([RPC]用于C Sharp)。NetworkView 必须附加到GameObject,
在这个物体上RPC 函数能够被调用。NetworkView 用于其他什么地方或者是仅仅用于RPC
函数是没有关系的。如果他仅仅用于RPC 函数,state synchronization 应该被关掉。Ovserved
属性设置为none,在整个场景中RPC 函数的名称应该是唯一的,如果不同脚本的两个RPC
函数具有相同的名称,仅有一个会被调用。RPC 调用总是确保执行的顺序与他们调用的顺
序相同。用NetworkView.group 为NetworkView 设置的通信用,被用于RPC 调用。为了获
取RPC 自身的信息,可以添加一个NetworkMessageInfo 参数到函数申明中,它将自动包含
这个信息。这样的做的时候你不需要改变调用RPC 函数的方式,可以参考manual 的RPC
部分以便获取更多关于RPC 的信息。可用的RPC 参数为int,float,string,NetworkPlayer,
NetworkViewID,Vector3 和Quaternion。
var cubePrefab : Transform;
function OnGUI()
{
if (GUILayout.Button(“SpawnBox”))
{
var viewID = Netwok.AllocateViewID();
networkView.RPC(“SpawnBox”,
RPCMode.AllBuffered,
viewID,
transform.position);
}
}
@RPC
function SpawnBox (viewID : NetworkViewID, location : Vector3) {
// Instantate the prefab locally
var clone : Transform;
clone = Instantiate(cubePrefab, location, Quaternion.identity);
var nView : NetworkView;
nView = clone.GetComponent(NetworkView);
nView.viewID = viewID;
}
◆ function RPC(name: string, target: NetworkPlayer, params args: object[]): void
描述:在特定的玩家端调用RPC
◆ function SetSeope(player: NetworkPlayer, relevancy: bool): bool
描述:相对于一个特定的网络玩家这是网络视的范围
这可以用来实现相关设置,设置它为真假取决于你是否想这个玩家从网络接收更新。
类方法
◆ static function Find(viewID: NetworkViewID): NetworkView
描述:基于NetworkViewID 查找一个网络视。
// 打印物体的名称,这些物体具有数组中给定的视ID (Print the names of the objects which
have the view IDs given in the array)
function PrintNames(viewIDs : Array) {
for (var ID: NetworkViewID in IDs) {
Debug.Log("Finding "+ID);
var view : NetworkView = networkView.Find(ID);
Debug.Log(view.observed.name);
}
}
继承的成员
继承的变量
enabled 启用Behaviours 被更新,禁用Behaviours 不被更新。
transform 附加到这个GameObject 的Transform(如果没有为null)。
rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
camera 附加到这个GameObject 的Camera(如果没有为null)。
light 附加到这个GameObject 的Light(如果没有为null)。
animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce(如果没有为null)。
renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSource(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(只读)。(如果没有为null)
guiTexture 附加到这个GameObject 的GUITexture(只读)。(如果没有为null)
collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
tag 这个游戏物体的标签。
name 对象的名称。
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponent 返回type 类型的组件,如果游戏物体上附加了一个,如果没有
返回null。
GetComponentInChildren 返回type 类型的组件,这个组件位于GameObject 或任何它的子
物体上,使用深度优先搜索。
GetComponentsInChildren 返回所有type 类型的组件,这些组件位于GameObject 或任何它
的子物体上。
GetComponents 返回GameObject 上所有type 类型的组件。
CompareTag 这个游戏物体标签为tag?
SendMessageUpwards 在这个游戏物体的每个MonoBehaviour 和该行为的祖先上调用
名为methodName 方法。
SendMessage 在这个游戏物体的每个MonoBehaviour 上调用methodName 方
法。
BroadcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上调用
methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
operator == 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
Projector
类,继承自Behaviour。
脚本界面就是一个Projector 组件。
这个Projector 可用于场景工程中的任何材料——就像一个真实的世界。这类的属性值就是
Projector 的检查值。
它可以用来执行斑点或投射阴影。你也可以投射纹理动画或渲染纹理在电影场景的另一个部
分。所有物体投影的视图在其观点和提供的材料中。
没有快捷方式在游戏对象或者组件来访问Projector,所以你必须使用GetComponent 来做:
function Start() {
// 获取projector
Var proj.Projector=GetComponent(Projector);
//使用这个
Proj.nearClipPlane=0.5;
}
参见:projector.component;
变量
◆var aspectRatio:float
描述:投影的长宽比。
这个是投影的宽度除以高度。比为1.0 使这个投影为正方形:比为2.0 使得宽为高的2 倍。
function Start() {
var proj : Projector = GetComponent (Projector);
proj.aspectRatio = 2.0;
}
参见:projector component.
◆var farClipPlane:float
描述:远裁剪面的距离。
投影器将不会影响任何运离这个距离的物体。
function Start() {
var proj : Projector = GetComponent (Projector);
proj.farClipPlane = 20.0;
}
参见:projector component
◆var fieldofView:float
描述:投影的视野,以度为单位。
这是垂直视野:水平FOV 取决于aspectRatio。当投射器是正交时fieldOfView 被忽略
(参考orthographic)
function Start() {
var proj : Projector = GetComponent (Projector);
proj.fieldOfView = 80.0;
}
参见:project component
◆var ignoreLayers:int
描述:那个物体层将这个投射器忽略。
参见layer mask
缺省为零,没有层被忽略,在ignoreLayers 中设置的每个位将使这个层不会被投射器影
响。
function Start() {
var proj : Projector = GetComponent (Projector);
//使投射器忽略默认的(0)层
proj.ignoreLayers = (1<<0);
}
参见:projector component,Layers.
◆var material:material
描述:这个材质将被投射到每个物体上
如果没有设置材质,投射器不会做任何事情,Standard Assets 中的Blob.Shadow 文件夹包含
一个投射器材质的例子
参见:projector component,Material 类。
◆var nearClipPlane:float
描述:近裁剪面的距离。
投影器将不会影响任何比这个距离近的物体。
function Start() {
var proj : Projector = GetComponent (Projector);
proj.nearClipPlane = 0.5;
}
参见:projector component;
◆var orthographic:bool
描述:投射是正交的(true)还是透视的(false)?
当正交为true 时,投影被orghographicSize 定义。
当正交为false 时,投射被fieldOfView 定义
function Start() {
var proj : Projector = GetComponent (Projector);
proj.orthographic = true;
}
参见:projector component
◆var orthographicSize:float
描述:在正交模式下投射的一半尺寸。
这个为投影体垂直大小的一半。水平投射的大小取决于aspectRatio,投射器不是正交时,
orthographicSize 被忽略(参考orthographic)
function Start() {
var proj : Projector = GetComponent (Projector);
proj.orthographic = true;
proj.orthographicSize = 2.0;
}
参见:projector component
继承的成员
继承的变量
enabled 启用Behaviours 被更新,禁用Behaviours 不被更新。
transform 附加到这个GameObject 的Transform(如果没有为null)。
rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
camera 附加到这个GameObject 的Camera(如果没有为null)。
light 附加到这个GameObject 的Light(如果没有为null)。
animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce(如果没有为null)。
renderer 附加到这个GameObject 的Renderer(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(如果没有为null)。
Collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag 这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponet 返回type 类型的组件,如果游戏物体上附加一个,如果没有返回null。
GetComponentInchildren 返回type 类型的组件,这个组件位于GameObject 或者任何它的子
物体上,使用深度优先搜索。
GetComponentsInchildren 返回所有type 类型的组件,这些组件位于GameObject 或者任何它
的子物体上。
GetComponets 返回Gameobject 所有type 类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards 在这游戏物体的每个MonoBehaviour 和该行为的组先上调用名为
methodName 方法。
SendMessage 在这游戏物体的每个MonoBehaviour 上调用名为
methodName 方法。
BoradcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上调用
methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的类函数
Operator bool 这个物体存在吗?
Instatiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
Skybox
类,继承自Behaviour
Skybox component 的脚本接口
天空盒只有material 属性
参见:skybox component
变量
◆var material:Material
描述:该天空盒使用的材质。
参见:skybox component
继承的成员
继承的变量
Enabled 启用Behaviours 被更新,禁用Behaviours 不被更新。
Transform 附加到这个GameObject 的Transform(如果没有为null)。
Rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
Camera 附加到这个GameObject 的Camera(如果没有为null)。
Light 附加到这个GameObject 的Light(如果没有为null)。
Animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce(如果没有为null)。
Renderer 附加到这个GameObject 的Renderer(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(如果没有为null)。
Collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag 这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponet 返回type 类型的组件,如果游戏物体上附加一个,如果没有返
回null。
GetComponentInchildren 返回type 类型的组件,这个组件位于GameObject 或者任何它的子
物体上,使用深度优先搜索。
GetComponentsInchildren 返回所有type 类型的组件,这些组件位于GameObject 或者任何它
的子物体上。
GetComponets 返回Gameobject 所有type 类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards 在这游戏物体的每个MonoBehaviour 和该行为的组先上调用名为
methodName 方法。
SendMessage 在这游戏物体的每个MonoBehaviour 上调用名为
methodName 方法。
BoradcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上调用
methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的类函数
Operator bool 这个物体存在吗?
Instatiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
collider
类,继承自Component
所有碰撞器的基类
参见:BoxCollider,SphereCollider,CapsuleCollider,MeshCollider,PhysicCollider,Rigidbody.
如果你打算经常移动一个碰撞器,建议再附加一个运动学刚体。
变量
◆var attachedRigidbody:Rigidbody
描述:该碰撞器所附加的刚体。
如果碰撞器附加到非刚体上返回null。
碰撞器被自动链接到刚体,这个刚体附加在与碰撞器相同的游戏物体或者父游戏物体上。
//升起附加在碰撞器上的刚体
Collider.attachedRigidbody.AddForce(1,0,1);
◆var bounds:Bounds
描述:碰撞器在世界空间中的包围盒
◆var isTrigger:bool
描述:该碰撞器是一个触发器?
触发器不会与刚体碰撞,当刚体进入或离开这个触发器时,触发器将发送OnTriggerEnter
OnTriggerExit 和OnTriggerStay.
//将附加的碰撞器转化为一个触发器
Collider.isTrigger=true;
◆var material:PhysicMaterial
描述:该碰撞器使用的材质。
如果材质被碰撞器共享,它将复制材质并将它赋给碰撞器。
//让碰撞器你冰一样
Collider.material.dynamicFriction=0;
collider.material.staticFricton=0;
◆var sharedMaterial:PhysicMaterial
描述:该碰撞器的共享物理材质。
修改这个材质将改变所有使用这个材质的碰撞器的表面属性。大多数情况下,你只要修改
Collider.material。
Var material:PhysicMaterial;
Collider.shareMaterial=material;
函数
◆function ClosestPointOnBounds(position:Vector3):Vector3
描述:到碰撞器包围上最近的点。
这可以用来计算受到爆炸伤害时伤害点数。
var hitPoints=100.0;
function ApplyHitPoint(explosionPos:Vector3,radius:float){
//从爆炸位置到刚体表面的距离
var closetPoint=collider.ClosePointOnBounds(explosionPos);
var distance=Vector3f.Distance(closestPoint,explosionPos);
//伤害点数随着到伤害点的距离而降低
Var hitPoints=1.0-Math.Clamp0|(distance/radius);
//这是我们要用的最终伤害点数。最大为10
hitPoints=10;
}
◆function Raycast(ray:Ray,outhitInfo:RaycastHIt,distance:float):bool
参数
ray 射线的开始点和方向。
hitInfo 如果没有近回真,hitInfo 将包含更多关于碰撞器被碰到什么地方的信息(参考:
RaycastHit).
Distance 射线的长度
返回:布尔值-当射线碰到任何碰撞器时为真,否则为假。
描述:投射一个Ray,它忽略所有碰撞器除了这个。
同上使用ray.origin 和ray.direction 而不是origin 和disrection.
var ray=Camera.main.ScreenPointToRay(Input.mousePostion);
var hit:RaycastHit;
if(collider.Raycast(ray,hit,100){
Debug.drawLine(ray.origin,hit.point);
}
消息传递
◆function OnCollisionEnter(collisionInfo:Collision):void
描述:当这个碰撞器/刚体开始触碰另一个刚体/碰撞器时OnCollisionEnter 被调用。
相对于OnTriggerEnter,OnCollisionEnter 传递Collision 类而不是Collider.Collision 类包含接触
点,碰撞器速度等细节。如果在函数中不使用CollisionInfo,省略collisionInfo 参数以避免不
必要的计算。注意如果碰撞器附加了一个非动力学刚体,也只发送碰撞事件。
◆Function OnCollisionEnter(collision:Collision){
//调试绘制所有的接触点和法线
for(var contact:ContacePoint in collision.contacts){
Debug.DrawRay(contact.point,contact.normal,color.white);
}
//如果碰撞物体有较大的冲击就播放声音
If(collision.relativeVelocity.magnitude.2)
Audio.Play();
}
//一枚手榴弹
//在击中一个表面时初始化一个爆炸预设
//然后销毁它
var exploionPrefab:Transform;
function OnCollisionEnter(collision:Collision){
//旋转这个物体使y 轴面向沿着表面法线的方向
var contact=collision.contact[0];
var rot=Quaternion.FromToRotation(Vector3.up,contact.normal);
var pos=contact.point;
Instantiate(exploionPrefab,pos,rot);
Destroy(gameObject);
}
◆function OnCollisionExit(collisionInfo:Collision):void
描述:当这个碰撞器/刚体停止触碰另一个刚体/碰撞器时OnCollisionExit 被调用。
相当于OnTriggerExit,OnCollisionExit 传递Collision 类而不是Collider.Collision 类包含接触
点,碰撞速度等细节。如果在函数中不使用collisionInfo,省略collisionInfo 参数以避免不必
要的计算,注意如果碰撞器附加了一个非动力学刚体,也只发关碰撞事件。
function OnCollisionExit(collisionInfo:Collision){
print(“No longer in contact with”+collisionInfo.transform.name);
}
◆function OnCollisionStay(collisionInfo:Collision):void
描述:对于每个与刚体/碰撞器相触碰的碰撞器/刚体,OnCollisionStay 将在每一帧中被调用。
相当于OnTriggerStay,OnCollisionStay 传递Collision 类而不是Collider.Collision 类包含接
触点,碰撞速度等细节。如果在函数中不使用collisionInfo,省略collisionInfo 参数以避免
不必要的计算。注意如果碰撞器附加了一个非动力学刚体,也只发送碰撞事件。
function OnCollisionStay(collisionInfo:Collision){
//调试绘制所有的接触点和法线
for(var contact:ContactPoint in collision.contacts){
Debug.DrawRay(contact.point,contact.normal,color.white);
}
}
◆function OnTriggerEnter(other:Collider):void
描述:当这个Collider other 进入trigger 时OnTriggerEnter 被调用。
这个消息被发送到这个触发器碰撞器和接触到触发器的刚体(或者是碰撞器如果没有刚体)。
注意如果碰撞器附加了一个
刚体,也只发送触发器事件。
//销毁所有进入该触发器的物体
function OnTriggerEnter(other:Collider){
Destroy(other.gameObject);
}
◆function OnTriggerExit(other:Collider):void
描述:当这个Collider other 停止触碰trigger 时OnTriggerExit 被调用。
这个消息被发送到触发器和拉触到这个触发器的碰撞器。注意如果碰撞器附加了一个
刚体,也只发送触发器事件。
销毁所有离开该触发器的物体
function OnTriggerExit(other:Collider){
Destroy(other.gameObject);
}
◆function OnTriggerStay(other:collider):void
描述:对于每个Collider other,当它触碰到trigger 时,OnTriggerStay 会在每一帧中都被调用。
这个消息被发送到触发器和接触到这个触发器的碰撞器。注意如果碰撞器附加了一个刚体,
也只发送触发器事件。
//对所进入这个触发器的刚体使用一个向上的力
function OnTriggerStay(other:Collider){
if(other.atachedRigidbody){
other.attachedRigidbody.AddForce(Vector3.up*10);
}
}
继承的成员
继承的变量
transform 附加到这个GameObject 的Transform(如果没有为null)。
rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
camera 附加到这个GameObject 的Camera(如果没有为null)。
light 附加到这个GameObject 的Light(如果没有为null)。
animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce(如果没有为null)。
Renderer 附加到这个GameObject 的Renderer(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(如果没有为null)。
Collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
tag 这个游戏的标签。
name 对象的名称。
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponet 返回type 类型的组件,如果游戏物体上附加一个,如果没有返
回null。
GetComponentInchildren 返回type 类型的组件,这个组件位于GameObject 或者任何它的子
物体上,使用深度优先搜索。
GetComponentsInchildren 返回所有type 类型的组件,这些组件位于GameObject 或者任何它
的子物体上。
GetComponets 返回Gameobject 所有type 类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards 在这游戏物体的每个MonoBehaviour 和该行为的组先上调用名为
methodName 方法。
SendMessage 在这游戏物体的每个MonoBehaviour 上调用名为
methodName 方法。
BoradcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上调用
methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的类函数
Operator bool 这个物体存在吗?
Instatiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
BosCollider
类,继承自Collider
一个盒状的简单碰撞器
参见:SphereCollider,copsuleCollider,PhysicMaterial,Rigidbody
变量
◆var center:vector3
描述:box 的中心,基于物体局部空间。
//重置中心到变换的位置
collider.center=Vector3.zero;
◆var size:Vector3
描述:box 的尺寸,基于物体局部空间
该box 的尺寸将随着变换的缩放面缩放。
//使这个box 碰撞器变长
collider.size=Vector3(10,1,1);
继承的成员
继承的变量
attachedRigidbody 该碰撞器所附加的刚体。
isTrigger 该碰撞器是一个触发器?
material 该碰撞器使用的材质。
sharedMaterial 该碰撞器的共享物体材质。
bounds 碰撞器在世界空间中包围盘。
Transform 附加到这个GameObject 的Transform(如果没有为null)。
Rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
Camera 附加到这个GameObject 的Camera(如果没有为null)。
Light 附加到这个GameObject 的Light(如果没有为null)。
Animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce(如果没有为null)。
Renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSourec(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(如果没有为null)。
Collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag 这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改?
继承的函数
ClosestPointOnBounds 附加碰撞器到包围盒最近的点。
Raycast 投射一个Ray,它忽略所有的碰撞器除了这个。
GetComponet 返回type 类型的组件,如果游戏物体上附加一个,如果没有返回null。
GetComponentInchildren 返回type 类型的组件,这个组件位于GameObject 或者任何它的子
物体上,使用深度优先搜索。
GetComponentsInchildren 返回所有type 类型的组件,这些组件位于GameObject 或者任何它
的子物体上。
GetComponets 返回Gameobject 所有type 类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards 在这游戏物体的每个MonoBehaviour 和该行为的组先上调用名为
methodName 方法。
SendMessage 在这游戏物体的每个MonoBehaviour 上调用名为
methodName 方法。
BoradcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上调用
methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的消息传递
OnTriggerEnter 当这个Collider other 进入trigger 进OnTriggerEnter 被调用。
OnTriggerExit 当这个Collider other 停止触碰trigger 时OnTriggerExit 被调用。
OnTriggerStay 对于每个Collider other,当它触碰到trigger 时,OnTriggerStay 会
在每一帧中都被调用。
OnCollisionEnter 当这个碰撞器/刚体开始触碰另一个刚体/碰撞器时
OnCollisionEnter 被调用。
OnCollisionExit 当这个碰撞器/刚体停止触碰另一个刚体/碰撞器时OnCollisionExit
被调用
OnCollisionStay 对于每个与刚体/碰撞器相触碰的碰撞器/刚体OnCollisionStay 将在每
一帧中被调用。
继承的类函数
Operator bool 这个物体存在吗?
Instatiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
CapsuleCollider
类,继承自Collider
一个胶囊状的简单碰撞器
Capsules 是术状的并在每端有一个半球。
参见:BoxCollider,SphereCollder,PhysicMaterial,Rigidbody
变量
◆var center:vector3
描述:胶囊的中心,基于物体的局部空间。
//重置中心到变换的位置
collider.center=Vector3.zero;
◆var direction:int
描述:胶囊的方向
0->胶囊的高度沿着x 轴。1->胶囊的高度沿着y 轴。2->胶囊的高度沿着z 轴。
//使胶囊的高度沿着x 轴
collider.direction=0;
◆var height:float
描述:胶囊的高度,基于物体的局部空间
该胶囊的高度将随着变换的缩放而缩放。注意height 为包含两端两个半球的实际高度。
collider.height=5;
◆var radius:float
描述:球的半径,基于物体的局部空间。
该胶囊的半径随着变换的缩放而缩放。
collider.radius=1;
继承的成员
继承的变量
attachedRigidbody 该碰撞器所附加的刚体。
isTrigger 该碰撞器是一个触发器?
material 该碰撞器使用的材质。
sharedMaterial 该碰撞器的共享物体材质。
bounds 碰撞器在世界空间中包围盘。
Transform 附加到这个GameObject 的Transform(如果没有为null)。
Rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
Camera 附加到这个GameObject 的Camera(如果没有为null)。
Light 附加到这个GameObject 的Light(如果没有为null)。
Animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce(如果没有为null)。
Renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSourec(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(如果没有为null)。
Collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag 这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改?
继承的函数
ClosestPointOnBounds 附加碰撞器到包围盒最近的点。
Raycast 投射一个Ray,它忽略所有的碰撞器除了这个。
GetComponet 返回type 类型的组件,如果游戏物体上附加一个,如果没有返回null。
GetComponentInchildren 返回type 类型的组件,这个组件位于GameObject 或者任何它的子
物体上,使用深度优先搜索。
GetComponentsInchildren 返回所有type 类型的组件,这些组件位于GameObject 或者任何它
的子物体上。
GetComponets 返回Gameobject 所有type 类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards 在这游戏物体的每个MonoBehaviour 和该行为的组先上调用名为
methodName 方法。
SendMessage 在这游戏物体的每个MonoBehaviour 上调用名为
methodName 方法。
BoradcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上调用
methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的消息传递
OnTriggerEnter 当这个Collider other 进入trigger 进OnTriggerEnter 被调用。
OnTriggerExit 当这个Collider other 停止触碰trigger 时OnTriggerExit 被调用。
OnTriggerStay 对于每个Collider other,当它触碰到trigger 时,OnTriggerStay 会
在每一帧中都被调用。
OnCollisionEnter 当这个碰撞器/刚体开始触碰另一个刚体/碰撞器时
OnCollisionEnter 被调用。
OnCollisionExit 当这个碰撞器/刚体停止触碰另一个刚体/碰撞器时OnCollisionExit
被调用
OnCollisionStay 对于每个与刚体/碰撞器相触碰的碰撞器/刚体OnCollisionStay 将在每
一帧中被调用。
继承的类函数
Operator bool 这个物体存在吗?
Instatiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
CharactController
类,继承自Collider
CharacterController 允许你很容易地做受到碰撞制约的移动,而无需处理刚体。
CharacterController 不会受力, 的影响,并且只有在调用Move 函数时才会移动,然后这个
控制器将实现移动,但是会受到碰撞的制约。
参见:Character Controller component 和Character animation examples
变量
◆var center:Vector3
描述:角色胶囊相对于变换的位置的中心。
//向上移动胶囊的中心
var Controller. CharacterController=GetComponent(CharacterController);
controller.center=Vector3(0,1,0);
◆var collisionFlags:CollisionFlags
描述:在最后一次调用CharacterController.Move 时,胶囊的哪个部分与环境发生了碰撞。
function Update(){
var controller:CharacterController=GetComponent(CharacterController);
if((controller collisionFlags&collisionFlags.Above)!=0)
print(“touched the celling”);
}
◆var detectCollisions:bool
描述:其他刚体或角色控制器应该与这个角色控制器碰撞吗(默认总是启用的)?
这个方法不会影响角色移动时的碰撞检测。它控制角色和其他物体之间的碰撞。例如,
一个箱子可以阻止控制器的运动,但是作为模拟的一部分这个箱子可以进入控制器。这可以
用于临时禁用角色控制器。例如,你也许想装载角色到汽车上并禁用碰撞直到再次退出汽车。
注意这只影响其他没有与碰撞的物体。detectCollisions 不是可序列化的。也就说,它不会显
示要检视面板中并且当在场景中实例化或保存这个控制器时,它将不被保存。
GetComponent(CharacterController).detectCollisions=false;
◆var height:float
描述:这个胶囊的高度
//设置控制器的高度为2.0
var controller:CharacterController=GetComponent(CharacterController);
controller.height=2.0;
◆var isGrounded:bool
描述:CharacterController 上一次移动的时候是否接触地面?
function Update(){
var controller.CharacterController=GetComponent(CharacterController);
if(controller.isGronded){
print(“We are grounded”)
}
}
◆var radius:float
描述:角色胶囊的半径
//这只控制器的半径为0.3
var controller:CharacterController=GetComponent(CharacterController);
controller.radius=0.3;
◆var slopLimit:float
描述:角色控制器的斜度限制
//设置控制器的斜度限制为45
var controller:CharacterController=GetComponent(CharacterController);
controller.slopLimit=45.0;
◆var stepOffset:float
描述:角色控制器的步高,以米为单位。
//这只控制器的步高为2.0
var controller:CharacterController=GetComponent(CharacterController);
controller.stepOffset=2.0;
◆var velocity:Vector3
描述:角色的当前速度
这允许你知道角色实际的行走有多快,例如当它碰到墙时这个值为零向量
function Update(){
var controller:CharacterController=GetComponent(CharacterController);
var horizontalVelocity=controller.velocity;
horizontalVelocity=0;
//x-z 平面上的速率,忽略其他任何速率
var horizontalSpeed= horizontalVelocity.y;
//整体速率
var overallSpeed=controller.velocity.magnitude;
}
函数
◆function Move(motion:Vector3):CollisionFlags
描述:一个更复杂的移动函数,可以使用绝对移动增量。
试图由motion 来移动控制器,这个运动只受制于碰撞,它将沿着碰撞器滑动,
collisionFlags 为移动期间所发生的碰撞总和。这个函数不使用任何重力。
//这个脚本基于方向键向前
//和两边移动角色控制器
//按下空格后它也会跳跃
//确保这个与角色控制器附加在同一个游戏物体上
var speed = 6.0;
var jumpSpeed = 8.0;
var gravity = 20.0;
private var moveDirection = Vector3.zero;
function FixedUpdate() {
var controller : CharacterController = GetComponent(CharacterController);
if (controller.isGrounded) {
//我们在地面上,因此重计算
//直接沿轴方向移动
moveDirection = Vector3(Input.GetAxis("Horizontal"), 0,
Input.GetAxis("Vertical"));
moveDirection = transform.TransformDirection(moveDirection);
moveDirection *= speed;
if (Input.GetButton ("Jump")) {
moveDirection.y = jumpSpeed;
}
}
// 使用重力
moveDirection.y -= gravity * Time.deltaTime;
// 移动控制器
controller.Move(moveDirection * Time.deltaTime);
}
◆function SimpleMove(speed:Vector3);bool
描述:以speed 移动角色
沿着y 轴的速度将忽略。速度单位m/s,重力被自动应用。返回角色是否在地面
上。
var speed = 3.0;
var rotateSpeed = 3.0;
function Update (){
var controller : CharacterController = GetComponent(CharacterController);
// Rotate around y - axis
transform.Rotate(0, Input.GetAxis ("Horizontal") * rotateSpeed, 0);
// Move forward / backward
var forward = transform.TransformDirection(Vector3.forward);
var curSpeed = speed * Input.GetAxis ("Vertical");
controller.SimpleMove(forward * curSpeed);
}
@script RequireComponent(CharacterController)
消息传递
◆function OnControllerColliderHit(hit:ControllerColliderHit):void
描述:在移动的时候,控制器碰到一个碰撞器时,OnControllerColliderHit 被调用。
这可以用来在角色碰到物体时推开物体。
//这个脚本推开所有碰到的刚体
var pushPower = 2.0;
function OnControllerColliderHit (hit : ControllerColliderHit){
var body : Rigidbody = hit.collider.attachedRigidbody;
// 无刚体
if (body == null || body.isKinematic)
return;
// 不推开我们身后的物体
if (hit.moveDirection.y < -0.3)
return;
//从移动方向计算推的方向
// 只推开物体到旁边而不是上下
var pushDir = Vector3 (hit.moveDirection.x, 0, hit.moveDirection.z);
//如果知道角色移动有多快
//然后你就可以用它乘以推动速度
//使用推力
body.velocity = pushDir * pushPower;
}
继承的成员
继承的变量
attachedRigidbody 该碰撞器所附加的刚体。
isTrigger 该碰撞器是一个触发器?
material 该碰撞器使用的材质。
sharedMaterial 该碰撞器的共享物体材质。
bounds 碰撞器在世界空间中包围盘。
Transform 附加到这个GameObject 的Transform(如果没有为null)。
Rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
Camera 附加到这个GameObject 的Camera(如果没有为null)。
Light 附加到这个GameObject 的Light(如果没有为null)。
Animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce(如果没有为null)。
Renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSourec(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(如果没有为null)。
Collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag 这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改?
继承的函数
ClosestPointOnBounds 附加碰撞器到包围盒最近的点。
Raycast 投射一个Ray,它忽略所有的碰撞器除了这个。
GetComponet 返回type 类型的组件,如果游戏物体上附加一个,如果没有返回null。
GetComponentInchildren 返回type 类型的组件,这个组件位于GameObject 或者任何它的子
物体上,使用深度优先搜索。
GetComponentsInchildren 返回所有type 类型的组件,这些组件位于GameObject 或者任何它
的子物体上。
GetComponets 返回Gameobject 所有type 类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards 在这游戏物体的每个MonoBehaviour 和该行为的组先上调用名为
methodName 方法。
SendMessage 在这游戏物体的每个MonoBehaviour 上调用名为
methodName 方法。
BoradcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上调用
methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的消息传递
OnTriggerEnter 当这个Collider other 进入trigger 进OnTriggerEnter 被调用。
OnTriggerExit 当这个Collider other 停止触碰trigger 时OnTriggerExit 被调用。
OnTriggerStay 对于每个Collider other,当它触碰到trigger 时,OnTriggerStay 会
在每一帧中都被调用。
OnCollisionEnter 当这个碰撞器/刚体开始触碰另一个刚体/碰撞器时
OnCollisionEnter 被调用。
OnCollisionExit 当这个碰撞器/刚体停止触碰另一个刚体/碰撞器时OnCollisionExit
被调用.
OnCollisionStay 对于每个与刚体/碰撞器相触碰的碰撞器/刚体
OnCollisionStay 将在每一帧中被调用。
继承的类函数
Operator bool 这个物体存在吗?
Instatiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
MeshCollider
类,继承自Collider
网格碰撞器允许人在网格和几何体之间进行碰撞检测。
参见:BosCollider,CapsuleCollider,PhysicMaterial,Rigidbody
变量
◆var convex:bool
描述:为这个网格将使用一个凸碰撞器。
凸网格可以与其他凸碰撞器和非凸网格碰撞。因此凸网格碰撞器适用于刚体,如果你真的需
要比几何碰撞器更多的详细的碰撞信息,可以使用这个。
◆var shareMesh:mesh
描述:用于碰撞检测的网格物体。
◆var smoothSphereCollision:bool
描述:为球形碰撞使用插值法线而不是平面多边形法线。
这可以让球体在平面上的滚动更加更滑。缺点是在从陡峭的角度滚落时,它的行为非常奇怪,
显得有拉动某个方向的的球体。
继承的成员
继承的变量
attachedRigidbody 该碰撞器所附加的刚体。
isTrigger 该碰撞器是一个触发器?
material 该碰撞器使用的材质。
sharedMaterial 该碰撞器的共享物体材质。
bounds 碰撞器在世界空间中包围盘。
Transform 附加到这个GameObject 的Transform(如果没有为null)。
Rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
Camera 附加到这个GameObject 的Camera(如果没有为null)。
Light 附加到这个GameObject 的Light(如果没有为null)。
Animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce(如果没有为null)。
Renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSourec(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(如果没有为null)。
Collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag 这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改?
继承的函数
ClosestPointOnBounds 附加碰撞器到包围盒最近的点。
Raycast 投射一个Ray,它忽略所有的碰撞器除了这个。
GetComponet 返回type 类型的组件,如果游戏物体上附加一个,如果没有返回null。
GetComponentInchildren 返回type 类型的组件,这个组件位于GameObject 或者任何它的子
物体上,使用深度优先搜索。
GetComponentsInchildren 返回所有type 类型的组件,这些组件位于GameObject 或者任何它
的子物体上。
GetComponets 返回Gameobject 所有type 类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards 在这游戏物体的每个MonoBehaviour 和该行为的组先上调用名为
methodName 方法。
SendMessage 在这游戏物体的每个MonoBehaviour 上调用名为
methodName 方法。
BoradcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上调用
methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的消息传递
OnTriggerEnter 当这个Collider other 进入trigger 进OnTriggerEnter 被调用。
OnTriggerExit 当这个Collider other 停止触碰trigger 时OnTriggerExit 被调用。
OnTriggerStay 对于每个Collider other,当它触碰到trigger 时,
会在每一帧中都被调用。
OnCollisionEnter 当这个碰撞器/刚体开始触碰另一个刚体/碰撞器时
OnCollisionEnter 被调用。
OnCollisionExit 当这个碰撞器/刚体停止触碰另一个刚体/碰撞器时OnCollisionExit
被调用.
OnCollisionStay 对于每个与刚体/碰撞器相触碰的碰撞器/刚体
OnCollisionStay 将在每一帧中被调用。
继承的类函数
Operator bool 这个物体存在吗?
Instatiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
RaycastCollider
类,继承自Collider
基于碰撞的一个线。
Raycast 碰撞器主要用于模型汽车,气垫船和船因为它们提供更精确的碰撞检测。然而,对
于轮式交通工具,建议使用WheelCollider。
一个Raycast 碰撞器总是沿着本地y 轴向下投射一个射线。Raycast 碰撞器在与设置为具有
弹性的物理材质组全时是最有用的。
变量
◆var center:Vector3
描述:胶囊的中心,基于物体的局部空间。
//重置中心到变换的位置
collider.center=Vector3.zero;
◆var length:float
描述:本地空间的射线的长度,射线将发射
从center 沿着变换的负y 轴,length 将随着变换的缩放而缩放
collider.length=2;
继承的成员
继承的变量
attachedRigidbody 该碰撞器所附加的刚体。
isTrigger 该碰撞器是一个触发器?
material 该碰撞器使用的材质。
sharedMaterial 该碰撞器的共享物体材质。
bounds 碰撞器在世界空间中包围盘。
Transform 附加到这个GameObject 的Transform(如果没有为null)。
Light 附加到这个GameObject 的Light(如果没有为null)。
Animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce(如果没有为null)。
Renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSourec(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(如果没有为null)。
Collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag 这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改?
继承的函数
ClosestPointOnBounds 附加碰撞器到包围盒最近的点。
Raycast 投射一个Ray,它忽略所有的碰撞器除了这个。
GetComponet 返回type 类型的组件,如果游戏物体上附加一个,如果没有返回null。
GetComponentInchildren 返回type 类型的组件,这个组件位于GameObject 或者任何它的子
物体上,使用深度优先搜索。
GetComponentsInchildren 返回所有type 类型的组件,这些组件位于GameObject 或者任何它
的子物体上。
GetComponets 返回Gameobject 所有type 类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards 在这游戏物体的每个MonoBehaviour 和该行为的组先上调用名为
methodName 方法。
SendMessage 在这游戏物体的每个MonoBehaviour 上调用名为
methodName 方法。
BoradcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上调用
methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的消息传递
OnTriggerEnter 当这个Collider other 进入trigger 进OnTriggerEnter 被调用。
OnTriggerExit 当这个Collider other 停止触碰trigger 时OnTriggerExit 被调用。
OnTriggerStay 对于每个Collider other,当它触碰到trigger 时,OnTriggerStay 会
在每一帧中都被调用。
OnCollisionEnter 当这个碰撞器/刚体开始触碰另一个刚体/碰撞器时
OnCollisionEnter 被调用。
OnCollisionExit 当这个碰撞器/刚体停止触碰另一个刚体/碰撞器时OnCollisionExit
被调用.
OnCollisionStay 对于每个与刚体/碰撞器相触碰的碰撞器/刚体
OnCollisionStay 将在每一帧中被调用。
继承的类函数
Operator bool 这个物体存在吗?
Instatiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
SphereCollider
类继承自Collider
一个球形的几何碰撞器
参见:BoxCollider,CapsuleCollider,Physic Material,Rigidbody
变量
◆var center:Vector3
描述:球的中心,基于物体的局部空间。
//重置中心到变换的位置
Collider.center=Vector3.zero;
◆var radius:float
描述:球的半径,基于物体的局部空间。
球体随着变换的缩放而缩放
collider.radius=10;
继承的成员
继承的变量
attachedRigidbody 该碰撞器所附加的刚体。
isTrigger 该碰撞器是一个触发器?
material 该碰撞器使用的材质。
sharedMaterial 该碰撞器的共享物体材质。
Transform 附加到这个GameObject 的Transform(如果没有为null)。
Light 附加到这个GameObject 的Light(如果没有为null)。
Animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce(如果没有为null)。
Renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSourec(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(如果没有为null)。
Collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag 这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改?
继承的函数
ClosestPointOnBounds 附加碰撞器到包围盒最近的点。
Raycast 投射一个Ray,它忽略所有的碰撞器除了这个。
GetComponet 返回type 类型的组件,如果游戏物体上附加一个,如果没有返回null。
GetComponentInchildren 返回type 类型的组件,这个组件位于GameObject 或者任何它的子
物体上,使用深度优先搜索。
GetComponentsInchildren 返回所有type 类型的组件,这些组件位于GameObject 或者任何它
的子物体上。
GetComponets 返回Gameobject 所有type 类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards 在这游戏物体的每个MonoBehaviour 和该行为的组先上调用名为
methodName 方法。
SendMessage 在这游戏物体的每个MonoBehaviour 上调用名为
methodName 方法。
BoradcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上调用
methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的消息传递
OnTriggerEnter 当这个Collider other 进入trigger 进OnTriggerEnter 被调用。
OnTriggerExit 当这个Collider other 停止触碰trigger 时OnTriggerExit 被调用。
OnTriggerStay 对于每个Collider other,当它触碰到trigger 时,OnTriggerStay 会
在每一帧中都被调用。
OnCollisionEnter 当这个碰撞器/刚体开始触碰另一个刚体/碰撞器时
OnCollisionEnter 被调用。
OnCollisionExit 当这个碰撞器/刚体停止触碰另一个刚体/碰撞器时OnCollisionExit
被调用.
OnCollisionStay 对于每个与刚体/碰撞器相触碰的碰撞器/刚体
OnCollisionStay 将在每一帧中被调用。
继承的类函数
Operator bool 这个物体存在吗?
Instatiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
TerrainCollider
类,继承自Collider
基于高度图的碰撞器。
变量
◆var terrainData:TerrainData
描述:存储高度图的地形
继承的成员
继承的变量
attachedRigidbody 该碰撞器所附加的刚体。
isTrigger 该碰撞器是一个触发器?
material 该碰撞器使用的材质。
sharedMaterial 该碰撞器的共享物体材质。
bounds 碰撞器在世界空间中包围盘。
Transform 附加到这个GameObject 的Transform(如果没有为null)。
Light 附加到这个GameObject 的Light(如果没有为null)。
Animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce(如果没有为null)。
Renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSourec(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(如果没有为null)。
Collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag 这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改?
继承的函数
ClosestPointOnBounds 附加碰撞器到包围盒最近的点。
Raycast 投射一个Ray,它忽略所有的碰撞器除了这个。
GetComponet 返回type 类型的组件,如果游戏物体上附加一个,如果没有返回null。
GetComponentInchildren 返回type 类型的组件,这个组件位于GameObject 或者任何它的子
物体上,使用深度优先搜索。
GetComponentsInchildren 返回所有type 类型的组件,这些组件位于GameObject 或者任何它
的子物体上。
GetComponets 返回Gameobject 所有type 类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards 在这游戏物体的每个MonoBehaviour 和该行为的组先上调用名为
methodName 方法。
SendMessage 在这游戏物体的每个MonoBehaviour 上调用名为
methodName 方法。
BoradcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上调用
methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的消息传递
OnTriggerEnter 当这个Collider other 进入trigger 进OnTriggerEnter 被调用。
OnTriggerExit 当这个Collider other 停止触碰trigger 时OnTriggerExit 被调用。
OnTriggerStay 对于每个Collider other,当它触碰到trigger 时,OnTriggerStay 会
在每一帧中都被调用。
OnCollisionEnter 当这个碰撞器/刚体开始触碰另一个刚体/碰撞器时
OnCollisionEnter 被调用。
OnCollisionExit 当这个碰撞器/刚体停止触碰另一个刚体/碰撞器时OnCollisionExit
被调用.
OnCollisionStay 对于每个与刚体/碰撞器相触碰的碰撞器/刚体
OnCollisionStay 将在每一帧中被调用。
继承的类函数
Operator bool 这个物体存在吗?
Instatiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
WheelCollider
类,继承自Collider
用于车轮的特殊碰撞器。
车轮的碰撞器用来模拟车轮。它的功能类似与RaycastCollider,但是还有车轮物理和基于
轮胎摩擦力模拟的滑动。在大多数情况下WheelCollider 是更精确的也更容易使用的。
车轮的碰撞检测是通过从center 沿着局部Y 轴向下投射一个射线进行的。车轮有一个radius
并可以通过suspensionDistance 向下扩展。
车轮使用motoTorque,brakeTorque 和steerAngle 属性控制。
车轮碰撞器使用不同于物理引擎的一个基于滑动的摩擦力模型来计算摩擦力。这允许更加
真实的行为。而且使车轮忽略标准的PhysiMaterial 设置。通过改变车轮所碰到的
rorwardFriction 和sidewaysFriction 来模拟不同的路面材质。参见:GetGroundHit 和
WheelFrictionCurve。
变量
◆var brakeTorque:float
描述:制动的力矩。必须为正
//制动车轮
collider.brakeTorque=1000;
◆var center:vector3
描述:车轮的中心,基于物体的局部空间。
//重置中心到变换的位置
collider.center=Vector.zero;
◆var forwardFriction:WheelFrictionCurve
描述;在轮胎所指向上的摩擦力属性
◆var isGrounded:bool
描述:表示当前车轮是否与什么东西发生碰撞(只读)
◆var mass:float
描述:车轮的质量必须比0 大
collider.mass=1;
◆var motorTorque:float
描述:车轮上的动力力矩。正负根据方向而定。
为了模拟制动,不要使用负的动力力矩,而使用brakeTorque
//向前旋转的车轮
collider.motorTorque=10;
◆var radius:float
描述:本地空间的车轮的半径。
半径将随着变换的缩放而缩放。
collider.radius=5;
◆var rpm:float
描述:当前车轮轴的旋转速度,以旋转/秒(只读)
◆var sidewaysFriction:WheelfrictionCurve
描述:侧向的轮胎摩擦力属性。
◆var steerAngle:float
描述:转向的角度,总是绕着本地y 轴。
//转向前
collider.steerAngle=0;
较高的速率使用小的转向角:一点角度就足够了。
◆var suspensionDistance:float
描述:在局部空间下,车轮悬挂的最大扩展距离。
悬挂总是沿着本地y 轴向下扩展。悬挂过程将随着变换的缩放而缩放。
collider.susensionDistance:=0.1;
◆var suspensionSpring:JointSring
描述:车轮悬挂的参数。悬挂视图到达一个目标的位置
通过添加弹簧和阴尼力。
suspensionSpring.spring 力视图到达这个目标的位置。较大的值使得悬挂更快到达目标
位置。
suspensionSpring.damer 力阻尼悬挂速度。较大的值使得悬挂更慢到达目标。
悬挂试图到达suspensionSpring.targetPositon.它是悬挂沿着suspensionDistance 的剩余长度。
零值表示完全扩展。1 表示完全压缩,缺省的值为0,它匹配于常规汽车的悬挂行为。
函数
◆function GetGroundHit(out hit:WheelHit):bool
描述:获取轮胎的地面碰撞数据。
如果车轮碰撞器与某些物体发生了碰撞,返回true 并填充hit 结构。如果车轮没有碰撞。
返回false 并保持hit 结构不变。
报告的hit 总是最接近的一个,因为轮胎摩擦力模型不会自动响应其他的physicMaterial。
任何对不同地面材质的模拟必须基于这里所返回的碰撞器材质来手动调整forwordFriction
和sidewayFriction 完成。
继承的成员
继承的变量
attachedRigidbody 该碰撞器所附加的刚体。
isTrigger 该碰撞器是一个触发器?
material 该碰撞器使用的材质。
sharedMaterial 该碰撞器的共享物体材质。
bounds 碰撞器在世界空间中包围盘。
Transform 附加到这个GameObject 的Transform(如果没有为null)。
Light 附加到这个GameObject 的Light(如果没有为null)。
Animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce(如果没有为null)。
Renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSourec(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(如果没有为null)。
Collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag 这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改?
继承的函数
ClosestPointOnBounds 附加碰撞器到包围盒最近的点。
Raycast 投射一个Ray,它忽略所有的碰撞器除了这个。
GetComponet 返回type 类型的组件,如果游戏物体上附加一个,如果没有返回null。
GetComponentInchildren 返回type 类型的组件,这个组件位于GameObject 或者任何它的子
物体上,使用深度优先搜索。
GetComponentsInchildren 返回所有type 类型的组件,这些组件位于GameObject 或者任何它
的子物体上。
GetComponets 返回Gameobject 所有type 类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards 在这游戏物体的每个MonoBehaviour 和该行为的组先
上调
用名为methodName 方法。
SendMessage 在这游戏物体的每个MonoBehaviour 上调用名为
methodName 方法。
BoradcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上调用
methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的消息传递
OnTriggerEnter 当这个Collider other 进入trigger 进OnTriggerEnter 被调用。
OnTriggerExit 当这个Collider other 停止触碰trigger 时OnTriggerExit 被调用。
OnTriggerStay 对于每个Collider other,当它触碰到trigger 时,OnTriggerStay 会
在每一帧中都被调用。
OnCollisionEnter 当这个碰撞器/刚体开始触碰另一个刚体/碰撞器时
OnCollisionEnter 被调用。
OnCollisionExit 当这个碰撞器/刚体停止触碰另一个刚体/碰撞器时OnCollisionExit
被调用.
OnCollisionStay 对于每个与刚体/碰撞器相触碰的碰撞器/刚体
OnCollisionStay 将在每一帧中被调用。
继承的类函数
Operator bool 这个物体存在吗?
Instatiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
Joint
类,继承自Comonent
Joint 是所有关节的基类。
参见:CharacterJoint,HingJoint,SpringJoint.
变量
◆var anchor:Vector3
描述:关节的移动被限制于绕着这个锚点的位置。
定义在本地空间中的位置。
hingeJoint.anchor=Vector3(2,0,0);
◆var axis:Vector3
描述:物体被限制于绕着这个轴的方向旋转。
定义在本地空间中的轴。
hingeJoint.axis=Vector3.up;
◆var breakForce:float
描述:需要断开关节的力
力可能来自与其他物体的碰撞,应用到刚体的力。addTorque 或来自其他关节。
//当一个大于10 的力矩被应用时使用关节断开
hingeJoint.breakForce=10;
//使关节不会被断开
hingeJoint.breakForce=mathf.Infinity;
参见:OnJointBreak
◆var breakTorque:float
描述:需要断开关节的力矩
力矩可能来自与其他物体的碰撞,使用rigidbody.AddTorque 或来自其他关节。
//当一个大于10 的力矩被应用时使关节断开
hingeJoint.breakTorque=10;
//使关节不会被断开
hingeJoint.breakTorque=mathf.Infinity;
参见:OnJointBreak
◆var connectedBody:Rigidbody
描述:这个关节链接到的另一个刚体的引用。
如果不设置,这个关节将连接物体到世界。
//连接关节到世界而不是其他刚体
hingeJoint.connectedBody=Null;
连接关节到其他物体
var otherBody=Rigidbody;
hingeJoint.connectedBody=otherBody;
消息传递
◆function OnJointBreak(breakForce:float):void
描述:当附加到相同游戏物体上的关节被断开。当关节断开时,OnJointBreak 将被调用
,应用到关节的断开力将被传入,OnJointBreak 之后这个关节自动从游戏物体移除。参见:
Joint.breakForce
继承的成员
继承的变量
Transform 附加到这个GameObject 的Transform(如果没有为null)。
Rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
Camera 附加到这个GameObject 的Camera(如果没有为null)。
Light 附加到这个GameObject 的Light(如果没有为null)。
Animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce(如果没有为null)。
Renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSouree(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(只读)(如果没有为null)。
guiTexture 附加到这个GameObject 的GUITexture(只读)(如果没有为null)。
collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
tag 这个游戏物体的标签。
name 对象的名称。
hideFlags 该物体是否被隐藏。保存在场景中或被用户修改?
继承的函数
GetComponent 返回type 类型的组件,如果游戏物体上附加了一个,如果没有
返回null。
GetComponentInChildren 返回type 类型的组件,这个组件位于GameObject 或任何它的子
物体上,使用深度优先搜索。
GetComponentsInChildren 返回所有type 类型的组件,这些组件位于GameObject 或任何它
的子物体上。
GetComponents 返回GameObject 上所有type 类型的组件。
CompareTag 这个游戏物体标签为tag?
SendMessageUpwards 在这个游戏物体的每个MonoBehaviour 和该行为的祖先上调用
名为methodName 方法。
SendMessage 在这个游戏物体的每个MonoBehaviour 上调用methodName 方
法。
BroadcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上调用
methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
operator == 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
CharacterJoint
类,继承自Joint
Joints 的属性主要用于碰撞效果。它们是一个扩展的球窝状joint,允许你限制joint 在每个轴
上。
变量
◆var highTwistLimit:SoftJointLimit
描述:角色关节原始轴的上限。
这个限制是相对于两个刚体开始模拟时的角度。
◆var lowTwistLimit:SoftJointLimit
描述:角色关节原始轴上的下限。
这个限制是相对于两个刚体开始模拟时的角度。
◆var swing1Limit:SoftJointLimit
描述:在角色关节的原始轴上限制。
限制是对称的。因此,例如30 将在此-30 到30 之间限制是相对于两个刚体开始模拟时的角
度。
◆var swing2Limit:SoftJointLimit
描述:在角色关节的原始轴上的限制。
限制是对称的。因此,例如30 将在此-30 到30 之间限制是相对于两个刚体开始模拟时的角
度。
◆var swingAxis:vector3
描述:关节可以绕着旋转的第二轴
CharacterJoint.swing1Limit 是被允许的绕着这个轴旋转的限制。
继承的成员
继承的变量
Transform 附加到这个GameObject 的Transform(如果没有为null)。
Rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
Camera 附加到这个GameObject 的Camera(如果没有为null)。
Light 附加到这个GameObject 的Light(如果没有为null)。
Animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce(如果没有为null)。
Renderer 附加到这个GameObject 的Renderer(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(如果没有为null)。
Collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag 这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponet 返回type 类型的组件,如果游戏物体上附加一个,如果没有返
回null。
GetComponentInchildren 返回type 类型的组件,这个组件位于GameObject 或者任何它的子
物体上,使用深度优先搜索。
GetComponentsInchildren 返回所有type 类型的组件,这些组件位于GameObject 或者任何它
的子物体上。
GetComponets 返回Gameobject 所有type 类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards 在这游戏物体的每个MonoBehaviour 和该行为的组先上调用名为
methodName 方法。
SendMessage 在这游戏物体的每个MonoBehaviour 上调用名为
methodName 方法。
BoradcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上调用
methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的类函数
Operator bool 这个物体存在吗?
Instatiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectOfType 返回第一个类型为type 的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
ConfigurableJoint
类,继承自Joint
可配置关节是一种非常灵活的关节,它让你完全控制旋转和线性移动。
你也可以用它的构建所有其他类型的关节,但是它的设置也是非常复杂的。它让你在每个
旋转轴线自由度上完全控制motor.drive 和关节限制。
变量
◆var angularXDrive:jointDrive
描述:定义关节的旋转如何绕着局部x 轴作用。仅在Rotation Drive Mode 为Swing&
twist 时使用。
◆var angularXMotion:configurableJointMotion
描述:根据Low 和High Angular Xlimit 允许沿着X 轴的旋转为free,完全locked 或者
limited.
◆var angularYLimit:SoftJointLimit
描述:基于原始旋转的增量定义的旋转约束边界。
◆var angularYMotion:ConfigurableJointMotion
描述:根据Low 和High AngularZLimit 允许沿着Z 轴的旋转为Free,完全Locked 或者
Limited。
◆var angularYZDrive:JointDrive
描述:定义的旋转如何绕着局部Y 和Z 轴作用。仅在Rotation Drive Mode 为Swing&Twist
时使用。
◆var angularZLimit:SoftJointLimit
描述:基于到原始旋转的增量定义的旋转约束边界。
◆var angularZmotion:ConfigurableJointMotion
描述:根据Low 和High Angular Zlimit 允许沿着Z 轴的族转为Free,完全Locked 或者
Limited.
◆var configuredInWorldSpace:bool
描述:如果启用,所有目标值将在世界空间中计算而不是物体的局空间。
◆var highAngularXLimit:SoftJointLimit
描述:基于到原始旋转的增量定义的最大旋转约束边界。
◆var linearLimit:SoftJointLimit
基于到关节原点的距离确定的移动约束边界定义。
◆var lowAngularXlimit:SoftJointLimit
基于到原始旋转的增量定义的最小旋转约束边界。
◆var projectionAngle:float
描述:到Connected Body 的距离,在物体折回到一个可接受的位置之前必须超过这个距离。
◆var projectionDistance:float
描述:到Connected Body 的距离,在物体折回到一个可接受的位置之前必须超过这个距离。
◆var projectionMode:JointProjectionMode
描述:该属性用来在物体偏离太多时候将它回到约束位置。
◆var rotationDriveMode:RotationDriveMode
描述:控制物体使用X&YZ 或自身的slerp Dirve 旋转
◆var slerpDrive:JointDrive
描述:定义关节的旋转如何绕着所有的局部轴作用。仅在Rotation Drive Mode 为slerp only 时
使用。
◆var targetAngularVelocity:Vector3
描述:这是一个Vector3。它定义了关节应该旋转的角速度。
◆var targetPosition:Vector3
描述:需要关节移动到的位置。
◆var targetVelocity:Vector3
描述:需要关节移动的速度。
◆var xDrive:JointDrive
描述:定义关节的移动如何沿着局部X 轴作用。
◆var xMotion:JointDrive
描述:按照Linear Limit 允许沿着X 轴的移动为Free,完全Locked 或者Limited。
◆var yDrive:JointDrive
描述:定义关节的移动如何沿着局部Y 轴作用。
◆var yMotion:JointDrive
描述:按照Linear Limit 允许沿着Y 轴的移动为Free,完全Locked 或者Limited。
◆var zDrive:JointDrive
描述:定义关节的移动如何沿着局部Z 轴作用。
◆var zMotion:JointDrive
描述:按照Linear Limit 允许沿着Z 轴的移动为Free,完全Locked 或者Limited。
继承的成员
继承的变量
connectedBody 这个关机链接到的另一个刚体的引用。
axis 物体被限制于绕着这个轴的方向旋转。
anchor 关节的移动被限制于绕着这个锚点的位置。
breakForce 需要断开关节的力。
breakTorque 需要断开关节的力矩。
transform 附加到这个GameObject 的Transform(如果没有为null)。
rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
camrea 附加到这个GameObject 的Camera(如果没有为null)。
light 附加到这个GameObject 的Light(如果没有为null)。
animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce 如果没有为null)。
renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSource(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(只读)。(如果没有为null)。
guiTexture 附加到这个GameObject 的GUITexture(只读)。(如果没有为null)。
collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
tag 这个游戏物体的标签。
name 对象的名称。
hideFlags 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponent 返回type 类型的组件,如果游戏物体上附加了一个,如
果没有返回null。
GetComponentInChildren 返回type 类型的组件,这个组件位于GameObject 或任何
它的子物体上,使用深度优先搜索。
GetComponentsInChildren 返回所以type 类型的组件,这些组件位于GameObject 或
任何它的子物体上。
GetComponents 返回GameObject 上所以type 类型的组件。
CompareTag 这个游戏物体被标签为tag?
SendMessageUpwards 在这个游戏物体的每个MonoBehaviour 和该行为的祖先
上调用名为methodName 方法。
SendMessage 在这个游戏物体上的每个MonoBehaviour 上调用
methodName 方法。
BroadcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上
调用methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的消息传递
OnJointBreak 当附加到相同游戏物体上的关节被断开时调用。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
FixedJoint
类,继承自Joint
FixedJoint 将两个刚体组合在一起,使他们在边界位置粘合。
参见: CharacterJoint, HingeJoint, SpringJoint.
继承的成员
继承的变量
ConnectedBody 这个关机链接到的另一个刚体的引用。
axis 物体被限制于绕着这个轴的方向旋转。
anchor 关节的移动被限制于绕着这个锚点的位置。
breakForce 需要断开关节的力。
breakTorque 需要断开关节的力矩。
transform 附加到这个GameObject 的Transform(如果没有为null)。
rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
camrea 附加到这个GameObject 的Camera(如果没有为null)。
light 附加到这个GameObject 的Light(如果没有为null)。
animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce 如果没有为null)。
renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSource(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(只读)。(如果没有为null)。
guiTexture 附加到这个GameObject 的GUITexture(只读)。(如果没有为null)。
collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
tag 这个游戏物体的标签。
name 对象的名称。
hideFlags 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponent 返回type 类型的组件,如果游戏物体上附加了一个,如
果没有返回null。
GetComponentInChildren 返回type 类型的组件,这个组件位于GameObject 或任何
它的子物体上,使用深度优先搜索。
GetComponentsInChildren 返回所以type 类型的组件,这些组件位于GameObject 或
任何它的子物体上。
GetComponents 返回GameObject 上所以type 类型的组件。
CompareTag 这个游戏物体被标签为tag?
SendMessageUpwards 在这个游戏物体的每个MonoBehaviour 和该行为的祖先
上调用名为methodName 方法。
SendMessage 在这个游戏物体上的每个MonoBehaviour 上调用
methodName 方法。
BroadcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上
调用methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的消息传递
OnJointBreak 当附加到相同游戏物体上的关节被断开时调用。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
HingeJoint
类,继承自Joint
HingeJoint 组合两个刚体,约束它们的移动就像用一个铰链链接他们一样。
这个类关节对于门市非常好的,但是也能被用于模型链,等等...
HingeJoint 有一个动力,这个能够用来使链接绕着关节的轴旋转。一个弹簧,它通过
绕着铰链关节轴旋转达到一个目标角度。和一个限制,用来约束关节角度。
变量
◆ var angle: folat
描述:链接相对于静止位置的当前角度。(只读)
两个物体间的静止角度再开始模拟时总是零。
print(hingeJoint.angle);
◆ var limits: JointLimits
描述:铰链链接的限制。
这个链接将被限制,这样角度总是在limits.min 和limits.max 之间,链接的角度是相对
于静止角度的度数。两个物体间的静止角度再开始模拟时总是零。
为门制作一个铰链限制;
hinge.Joint.limits.min=();
hinge.Joint.limits.minBounce=();
hinge.Joint.limits.max=9();
hinge.Joint.limits.maxBounce=();
修改限制自动地启用它。
◆ var motor: JointMotor
描述:动力将使用一个最大力来试图以角度/秒来到达目标速度。
动力试图以角度/秒达到motor.targetVelocity 角速度. 如果motor.force 足够大,动力将
只能达到motor.targetVelocity。如果关节旋转的比motor.targetVelocity 快,动力将断开,负
motor.targetVelocity 将使得动力以相反的方向旋转。
motor.force 是动力能够运用的最大力矩。如果它是零动力将禁用。如果
motor.freeSpin 为假,动力将只在旋转比motor.targetVelocity 快时断开。如果motor.freeSpin
为真,动力将不断开。
//制作一个铰链动力以每秒90 度旋转,和一个较大的力。
hingeJoint.motor.force = 100;
hingeJoint.motor.targetVelocity = 90;
hingeJoint.motor.freeSpin = false;
设置HingeJoint.useMotor 为真,将在修改动力时自动地启动动力。
◆ var spring: JointSpring
描述:通过添加弹力和阻力,弹簧试图达到一个目标角度。
spring.spring 力视图到达这个目标角度,较大的值使得弹簧更快达到目标位置。
spring.damper 阻尼角速度,较大的值使得弹簧更慢到达目标。
弹簧到达spring.targetPosition 时相对于静止的角度,两个物体间的静止角度在开始模
拟时总是零。
//是弹簧尽量到达70 度角;
//这可能是用来发射弹弓;
hingeJoint.spring.spring = 10;
hingeJoint.spring.damper = 3;
hingeJoint.spring.targetPosition = 70;
修正弹簧自动地启用它。
◆ var useLimits: bool
描述:启用关节的限制。
hingeJoint.useLimits = true;
◆ var useMotor: bool
描述:启动关节的动力。
hingeJoint.useMotor = true;
◆ var useSpring: bool
描述:启用关节的弹性。
hingeJoint.useMotor = true;
◆ var velocity: float
描述:关节的角速度,度/秒。
print(hingeJoint.velocity);
继承的成员
继承的变量
ConnectedBody 这个关机链接到的另一个刚体的引用。
axis 物体被限制于绕着这个轴的方向旋转。
anchor 关节的移动被限制于绕着这个锚点的位置。
breakForce 需要断开关节的力。
breakTorque 需要断开关节的力矩。
transform 附加到这个GameObject 的Transform(如果没有为null)。
rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
camrea 附加到这个GameObject 的Camera(如果没有为null)。
light 附加到这个GameObject 的Light(如果没有为null)。
animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce 如果没有为null)。
renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSource(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(只读)。(如果没有为null)。
guiTexture 附加到这个GameObject 的GUITexture(只读)。(如果没有为null)。
collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
tag 这个游戏物体的标签。
name 对象的名称。
hideFlags 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponent 返回type 类型的组件,如果游戏物体上附加了一个,如
果没有返回null。
GetComponentInChildren 返回type 类型的组件,这个组件位于GameObject 或任何
它的子物体上,使用深度优先搜索。
GetComponentsInChildren 返回所以type 类型的组件,这些组件位于GameObject 或
任何它的子物体上。
GetComponents 返回GameObject 上所以type 类型的组件。
CompareTag 这个游戏物体被标签为tag?
SendMessageUpwards 在这个游戏物体的每个MonoBehaviour 和该行为的祖先
上调用名为methodName 方法。
SendMessage 在这个游戏物体上的每个MonoBehaviour 上调用
methodName 方法。
BroadcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上
调用methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的消息传递
OnJointBreak 当附加到相同游戏物体上的关节被断开时调用。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
SpringJoint
类,继承自Joint
弹性关节连接2 个刚体,弹力将自动应用以便保持物体在给定的距离内。
弹性试图位置他们的开始距离,因此如果你的关节开始的时候是分离得,那么这个关
节将试图维持这个距离。minDistance 和maxDistance 属性添加这个隐式距离的顶部。
变量
◆ var damper: float
描述:用于阻尼弹簧的阻尼力。
◆ var maxDistance: float
描述:两个物体之间相对于它们的初试距离的最大距离。
距离将在minDistance 和maxDistance 之间,该值是相对于场景第一次加载时重心之间的
距离。
◆ var minDistance: float
描述:两个物体之间相对于它们的初试距离的最小距离。
距离将在minDistance 和maxDistance 之间,该值是相对于场景第一次加载时重心之间的
距离。
◆ var spring: folat
描述:弹力用于保持两个物体在一起。
继承的成员
继承的变量
ConnectedBody 这个关机链接到的另一个刚体的引用。
axis 物体被限制于绕着这个轴的方向旋转。
anchor 关节的移动被限制于绕着这个锚点的位置。
breakForce 需要断开关节的力。
breakTorque 需要断开关节的力矩。
transform 附加到这个GameObject 的Transform(如果没有为null)。
rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
camrea 附加到这个GameObject 的Camera(如果没有为null)。
light 附加到这个GameObject 的Light(如果没有为null)。
animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce 如果没有为null)。
renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSource(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(只读)。(如果没有为null)。
guiTexture 附加到这个GameObject 的GUITexture(只读)。(如果没有为null)。
collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
tag 这个游戏物体的标签。
name 对象的名称。
hideFlags 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponent 返回type 类型的组件,如果游戏物体上附加了一个,如
果没有返回null。
GetComponentInChildren 返回type 类型的组件,这个组件位于GameObject 或任何
它的子物体上,使用深度优先搜索。
GetComponentsInChildren 返回所以type 类型的组件,这些组件位于GameObject 或
任何它的子物体上。
GetComponents 返回GameObject 上所以type 类型的组件。
CompareTag 这个游戏物体被标签为tag?
SendMessageUpwards 在这个游戏物体的每个MonoBehaviour 和该行为的祖先
上调用名为methodName 方法。
SendMessage 在这个游戏物体上的每个MonoBehaviour 上调用
methodName 方法。
BroadcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上
调用methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的消息传递
OnJointBreak 当附加到相同游戏物体上的关节被断开时调用。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
MeshFilter
类,继承自Component
一个类用来访问mesh filter 的Mesh.
使用这个作为一个程序的网格接口。参见:Mesh class.
变量
◆ var mesh: mesh
描述:返回赋给网格过滤器的实例化Mesh。
如果没有赋予网格过滤器,一个新的网格将被创建并被导入。
如果赋予网格过滤器的网格被共享,它将被自动赋值并且实例化的网格将被返回。
通过使用mesh 属性你能只修改单个物体。其他使用相同网格的物体不会被修改。
function Update (){
//获取实例化网格
var mesh: Mesh = GetComponent(MeshFilter).mesh;
//随即改变顶点
var vertices = mesh. vertices;
for(var p in vertices)
{
p.y ~= Random.Range(-0.3,0.3);
}
mesh.vertices = vertices;
mesh.RecalculateNormals();
}
参见: Mesh class.
◆ var sharedMesh: Mesh
描述:返回网格过滤器的共享网格。
建议只使用这个函数来读网格数据而不是写,因为你可能修改导入的资源并且使用这个
网格的所有物体都会被影响。
继承的成员
继承的变量
transform 附加到这个GameObject 的Transform(如果没有为null)。
rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
camrea 附加到这个GameObject 的Camera(如果没有为null)。
light 附加到这个GameObject 的Light(如果没有为null)。
animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce 如果没有为null)。
renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSource(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(只读)。(如果没有为null)。
guiTexture 附加到这个GameObject 的GUITexture(只读)。(如果没有为null)。
collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
tag 这个游戏物体的标签。
name 对象的名称。
hideFlags 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponent 返回type 类型的组件,如果游戏物体上附加了一个,如
果没有返回null。
GetComponentInChildren 返回type 类型的组件,这个组件位于GameObject 或任何
它的子物体上,使用深度优先搜索。
GetComponentsInChildren 返回所以type 类型的组件,这些组件位于GameObject 或
任何它的子物体上。
GetComponents 返回GameObject 上所以type 类型的组件。
CompareTag 这个游戏物体被标签为tag?
SendMessageUpwards 在这个游戏物体的每个MonoBehaviour 和该行为的祖先
上调用名为methodName 方法。
SendMessage 在这个游戏物体上的每个MonoBehaviour 上调用
methodName 方法。
BroadcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上
调用methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
ParticleAnimator
类,继承自Component
粒子动画器随着时间移动你粒子,使用它们将风、力和颜色循环应用到你的粒子系统。
这个类是particle animator 组件的脚本接口。
变量
◆ var autodestruct: bool
描述:这个粒子动画器的GameObject 会自动销毁?
当设置为true,该GameObject 将在所有粒子消失后被销毁。
◆ var colorAnimation: Color[]
描述:粒子的色彩随着生命循环。
当前,你不能直接修改这个数组的索引。相反,你需要取间整个数组,修改它,然后将
它赋回粒子动画器。
//如何通过脚本正确的改变colorAnimation 颜色
//附加这个脚本到GameObject 这个物体包含完整的粒子系统
function Start ()
{
var modifiedColors: Color[]=particleAnimatorcolorAnimation;
mofifiedColor[2]=Color.yellow;
particleAnimator.colorAnimation=modifiedColors;
}
◆ var damping: float
描述:每帧粒子速度减慢多少
值为1 没有阻尼,值越小使它们越慢。
◆ var doesAnimateColor: bool
描述:粒子在它们的生命期中循环它们的颜色?
◆ var force: Vector3
描述:应用到粒子的力
◆ var localRotationAxis: Vector3
描述:粒子绕着旋转的本地空间轴。
◆ var rndForce: Vector3
描述:添加到粒子的随机力
用这个来让烟变得更加有活力。
◆ var sizeGrow: float
描述:粒子的尺寸如何随着生命期增加
◆ var worldRotationAxis: Vector3
描述:粒子绕着旋转的世界空间轴。
继承的成员
继承的变量
transform 附加到这个GameObject 的Transform(如果没有为null)。
rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
camrea 附加到这个GameObject 的Camera(如果没有为null)。
light 附加到这个GameObject 的Light(如果没有为null)。
animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce 如果没有为null)。
renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSource(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(只读)。(如果没有为null)。
guiTexture 附加到这个GameObject 的GUITexture(只读)。(如果没有为null)。
collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
tag 这个游戏物体的标签。
name 对象的名称。
hideFlags 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponent 返回type 类型的组件,如果游戏物体上附加了一个,如
果没有返回null。
GetComponentInChildren 返回type 类型的组件,这个组件位于GameObject 或任何
它的子物体上,使用深度优先搜索。
GetComponentsInChildren 返回所以type 类型的组件,这些组件位于GameObject 或
任何它的子物体上。
GetComponents 返回GameObject 上所以type 类型的组件。
CompareTag 这个游戏物体被标签为tag?
SendMessageUpwards 在这个游戏物体的每个MonoBehaviour 和该行为的祖先
上调用名为methodName 方法。
SendMessage 在这个游戏物体上的每个MonoBehaviour 上调用
methodName 方法。
BroadcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上
调用methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
ParticleEmitter
类,继承自Component
粒子发射器的脚本接口
参见:Particle documentation.
变量
◆ var emit: bool
描述:粒子应该被自动发射?
//发射粒子三秒
particleEmitter.emit=true;
yield WaitForSeconds(3);
//然后停止
particleEmitter.emit=false;
◆ var emitterVelocityScale: float
描述:粒子继承的发射器的速度量。
◆ var localVelocity: Vector3
描述:粒子沿着物体的X,Y,和Z 轴的开始速度。
◆ var maxEmission: float
描述:每秒生成的最大粒子的数量
◆ var maxEnergy: float
描述:每个粒子的最大生命期,以秒计。
◆ var maxSize: float
描述:每个粒子生成时的最大尺寸。
◆ var minEmission: float
描述:每秒生成的最小粒子的数量
◆ var minEnergy: float
描述:每个粒子的最小生命期,以秒计。
◆ var minSize: float
描述:每个粒子生成时的最小尺寸。
◆ var particleCount:int
描述:粒子的当前数量(只读)。
◆ var particles:Particle[]
描述:返回所有粒子的一个拷贝和指定所有粒子的数组到当前粒子。
注意,修改了粒子数组后,你必须将它赋回particleEmitter 才能看到改变。能力以零或
小于零的粒子将在赋给粒子数组的时候被销毁。因此,当创造一个完整的新粒子数组时,你

要显式地设置所有粒子的能量。
//附加这个脚本到一个已有的粒子系统上。
function LateUpdate(){
//提取粒子
var particles=particleEmitter particles
for(var i=(), i=particles length; i**){
//在正弦曲线上上下移动粒子
car yPosition = Mathf.Sin (Time.time) * Time.deltaTime.Particles[i]position *=Vector3 (0,
yPosition, 0)
//使粒子变红
particles[i]color=Color.red
//按照正弦曲线修改粒子大小
particles[i]size=Mathf.Sin(Time.time)*0.2;
}
//将他们拷量回粒子系统
particleEmitter.particles=particles
}
◆ var rndVelocity: Vector3
描述:一个沿着X,Y,和Z 的随机速度,它被添加到当前速度。
//主要沿着x=z 轴扩展随机速度
particleEmitter.rndVelocity=Vector3(2,0.1,2);
◆ var useWorldSpace: bool
描述:如果启用,当发射器移动的时候粒子不会移动。如果为假,当你移动发射器时,
粒子将跟随它移动。
particleEmitter.useWorldSpace=true;
◆ var worldVelocity: Vector3
描述:粒子在世界空间的开始速度,沿着X,Y,和Z.
函数
◆ function ClearParticles(): void
描述:从粒子系统中移除所有粒子。
particleEmitter.ClearParticles();
◆ function Emit(): void
描述:发射大量粒子
根据minEmission 和maxEmission 属性使发射器发射随机数量的粒子,
//在min 和max 直接发射随机数量的粒子
particleEmitter.Emit();
◆ function Emit(count: int): void
描述:立即发射count 数量的粒子
//发射10 个粒子
particleEmitter.Emit(10);
◆ function Emit(pos: Vector3, velocity: Vector3, size: float, energy: float, color: color): void
描述:以给定的参数发射一个粒子。
//在原点处发射一个粒子
//粒子的大小是0.2 并且它将存活2 秒
particleEmitter.Emit(Vector3.zero, Vector3 up, 0.2,2 Color yellow);
Renderer
类,继承来自Component
所以渲染器的一般功能
一个渲染器使物体显示在屏幕上。对于任何游戏物体或组件,它的渲染器可通过一个
renderer 属性来访问。
renderer.enabled=false;//使这个物体不可见!
使用这个类来访问任何物体的渲染器,网格或粒子系统。渲染器可以被禁用使物体不
可见(参见enabled),并且可以通过它们访问并修改材质(参考material)。
参见:用于meshes,particles,lines 和trails 的渲染组件。
变量
◆ var bounds: Bounds
描述:渲染器的包围边界(只读)
这个是在世界空间中完全包围物体的包围盒。
使用bounds 是方便的,可以粗略地近似物体的位置和长宽高,例如,
renderer.bounds.center 通常是比transform.position 更精确地"物体的中心",尤其是当物体
是对称的时候。
参考Mesh.bounds 属性,这个属性返回局部坐标中网格的边框.
//打印包围盒x 轴最左边的点
print(renderer.bounds.min.x);
//打印包围盒x 轴最右边的点
print(renderer.bounds.max.x);
//场景视图中绘制一个网格球体
//完全包围这个球体
function OnDrawGizmosSelected(){
//一个完全包围这个包裹盒的球体
var center=renderer.bounds.center;
var radius=renderer.bounds.extents.magnitude;
//绘制它
Gizmos.color=Color.white;
Gizmos.DrawWireSphere(center,radius);
}
参见:Bounds 类,Mesh.bounds 属性.
◆ var castShadows: bool
描述:这个物体投射阴影?
//使物体不投射阴影
renderer.castShadows=false;
参见:receiveShadows, Light.shadows.
◆ var enabled: bool
描述:如果启用使渲染的3D 物体可见。
//使这个物体不可见
renderer.en, abled=false;
//使这个物体可见
renderer.enabled=true;
//每秒切换一次物体的可见性
function Update(){
//当前秒是奇数还是偶数
var seconds: int=Time.time;
var oddeven=(seconds%2)==0;
//据此启用着色器
renderer.enabled=oddeven;
}
◆ var lightmapIndex: int
描述:应用到这个渲染器的光照图的索引。
这个索引表示在LightmapSettings 类中的光照贴图.值-I 表示没有光照贴图被赋值,这
个是默认的。这个索引不能大于254。
一个场景可以有多个光照贴图储存在这里,Renderer 组件可以使用这些光照贴图中的一
个,这就使得它能够在多个物体上使用相同的材质,而这个物体可以使用不同的光照贴图或
同一个光照贴图的不同部分。
参见:LightmapSettings 类,lightmapTilingOffset 属性,ShaderLad properties.
◆ var lightmapTilingOffset: Vector4
描述:用于光照图的平铺和偏移。
一个场景可以有多个光照贴图存储在这里,Renderer 组件可以使用这些光照贴图中的一
个。这就使得它能够在多个物体上使用相同的材质,而每个物体可以使用不同的光照贴图或
同一个光照贴图的不同部分。
向量的x 和y 表示光照图缩放,z 和w 表示光照图偏移.
参见:LightmapSettings 类,lightmapIndex 属性,ShaderLab properties.
◆ var material: Material
描述:这个物体的材质。
修改material 将只为这个物体改变材质。
如果材质被任何其他渲染器使用,这将克隆这个共享材质并从现在开始使用它。
//设置主颜色为红色
renderer.material.color=Color.red;
//每changeInterval 秒从定义在检视面板中的
//纹理数组中改变这个渲染器的材质
var materials: Material[];
var changeInterval=0.33;
function Update(){
if(materials.length==0)//如果没有材质返回
return;
//计算材质的索引
var index: int=Time.time/changeInterval;
//对于材质数取模,这样动画可以重复
index=index%materials.length;
//赋值它到渲染器
prenderer.sharedMaterial=material[index];
}
◆ var materials: Material[]
描述:这个物体的所有材质。
这是一个被渲染其实有的所有材质的数组。Unity 支持一个物体使用多个材质;在这种
情况下materials 包含所有的材质。如果超过一个材质sharedMaterial 和material 属性返回
第一个使用的材质。
修改任何在materials 的材质将只改变那个物体的外观.
print("I'm using"+renderer.materials.Length+"material(s)");
◆ var receiveShadows: bool
描述:这个物体接收阴影?
//使物体不接受阴影
renderer.receiveShadows=false;
参见:castShadows
◆ var sharedMaterial: Material
描述:这个物体的共享材质。
修改sharedMaterial 将改变所有使用这个材质物体的外观,并且改变的材质色绘制并
且改变的材质设置也被保存在工程中.
不建议修改由sharedMaterial 返回的材质。如果你想修改一个渲染器的材质,使用
material。
参见:material 属性.
◆ var sharedMaterial: Material[]
描述:这个物体的所有共享材质。
这是一个渲染其使用的所有材质的数组。Unity 支持一个物体使用多个材质;在这种
情况下sharedMaterials 包含所有的材质。如果有超过一个材质sharedMaterial 和material 属
性返回第一个使用的材质。
修改任何sharedMaterial 将改变所有使用这个材质物体的外观,并且改变的材质设置
也被保存在工程中.
不建议修改由sharedMaterials 返回的材质。如果你想修改一个渲染器的材质,使用
material。
print("I'm using"+renderer.sharedMaterials.Length+"material(s)");
参见:material.sharedMaterial 属性.
消息传递
◆ function OnBecameInvisible(): void
描述:OnBecameVisible 函数在这个物体对任何相机变得不可见时被调用.
这个消息被发送到所有附加在渲染器上的脚本。OnBecameVisible 和OnBecameInvisible
可以用于只需要在物体可见时才进行的计算。
//当它不可见时禁用这个行为
function OnBecameVisible(){
enabled=false;
}
注意:当在编辑器中运行时,场景视图相机也会导致这个函数被调用。
参见:OnBecameVisible.
◆ function OnBecamevisible(): void
描述:OnBecameVisible 函数在这个物体对任何相机变得不可见时被调用.
这个消息被发送到所有附加在渲染器上的脚本。OnBecameVisible 和OnBecameInvisible
可以用于只需要在物体可见时才进行的计算。
//当它不可见时禁用这个行为
function OnBecameVisible(){
enabled=true;
}
注意:当在编辑器中运行时,场景视图相机也会导致这个函数被调用。
参见:OnBecameInvisible.
继承的成员
继承的变量
transform 附加到这个GameObject 的Transform(如果没有为null)。
rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
camrea 附加到这个GameObject 的Camera(如果没有为null)。
light 附加到这个GameObject 的Light(如果没有为null)。
animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce 如果没有为null)。
renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSource(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(只读)。(如果没有为null)。
guiTexture 附加到这个GameObject 的GUITexture(只读)。(如果没有为null)。
collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
tag 这个游戏物体的标签。
name 对象的名称。
hideFlags 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponent 返回type 类型的组件,如果游戏物体上附加了一个,如
果没有返回null。
GetComponentInChildren 返回type 类型的组件,这个组件位于GameObject 或任何
它的子物体上,使用深度优先搜索。
GetComponentsInChildren 返回所以type 类型的组件,这些组件位于GameObject 或
任何它的子物体上。
GetComponents 返回GameObject 上所以type 类型的组件。
CompareTag 这个游戏物体被标签为tag?
SendMessageUpwards 在这个游戏物体的每个MonoBehaviour 和该行为的祖先
上调用名为methodName 方法。
SendMessage 在这个游戏物体上的每个MonoBehaviour 上调用
methodName 方法。
BroadcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上
调用methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
LineRenderer
类,继承自Renderer
LineRender 用于在3D 空间中绘制浮动的线。
这个类是line renderer 组件的脚本接口.
变量
◆ var userWorldSpace: bool
描述:如果启用,这个线定义在世界空间中。
函数
◆ function SetColors(start: Color, end: Color): void
描述:设置线开始和结束位置的颜色。
◆ function SetPostition(index: int, position: Vector3): void
描述:设置线上点的位置。
参见:SetVertexCount 函数.
◆ function SetVertexCount(count: int): void
描述:设置线段数
参见:SetPosition 函数.
◆ function SetWidth(start: float, end: float): void
描述:设置开始和结束位置的线宽。
继承的成员
继承的变量
enabled 如果启用使渲染的3D 物体可见。
castShadows 这个物体投射阴影?
receiveShadows 这个物体接收阴影?
material 这个物体的材质。
sharedMaterial 这个物体的共享材质。
sharedMaterials 这个物体的所有共享材质。
materials 这个物体的所有材质。
bounds 渲染器的包围边界(只读)。
lightmapIndex 应用这个渲染器的光照图的索引。
lightmapTilingOffset 用于光照图的平铺和偏移。
transform 附加到这个GameObject 的Transform(如果没有为null)。
rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
camrea 附加到这个GameObject 的Camera(如果没有为null)。
light 附加到这个GameObject 的Light(如果没有为null)。
animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce 如果没有为null)。
renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSource(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(只读)。(如果没有
为null)。
guiTexture 附加到这个GameObject 的GUITexture(只读)。(如果没有
为null)。
collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物
体。
tag 这个游戏物体的标签。
name 对象的名称。
hideFlags 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponent 返回type 类型的组件,如果游戏物体上附加了一个,如
果没有返回null。
GetComponentInChildren 返回type 类型的组件,这个组件位于GameObject 或任何
它的子物体上,使用深度优先搜索。
GetComponentsInChildren 返回所以type 类型的组件,这些组件位于GameObject 或
任何它的子物体上。
GetComponents 返回GameObject 上所以type 类型的组件。
CompareTag 这个游戏物体被标签为tag?
SendMessageUpwards 在这个游戏物体的每个MonoBehaviour 和该行为的祖先
上调用名为methodName 方法。
SendMessage 在这个游戏物体上的每个MonoBehaviour 上调用
methodName 方法。
BroadcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上
调用methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的消息传递
OnBecameVisible OnBecameVisible 函数在这个物体对任何相机变得可见时被调
用.
OnBecameInvisible OnBecameInvisible 函数在这个物体对任何相机变得可见时被调
用.
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
MeshRenderer
类,继承自Renderer
渲染自MeshFilter 或TextMesh 插入的网格。
继承的成员
继承的变量
enabled 如果启用使渲染的3D 物体可见。
castShadows 这个物体投射阴影?
receiveShadows 这个物体接收阴影?
material 这个物体的材质。
sharedMaterial 这个物体的共享材质。
sharedMaterials 这个物体的所有共享材质。
materials 这个物体的所有材质。
bounds 渲染器的包围边界(只读)。
lightmapIndex 应用这个渲染器的光照图的索引。
lightmapTilingOffset 用于光照图的平铺和偏移。
transform 附加到这个GameObject 的Transform(如果没有为null)。
rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
camrea 附加到这个GameObject 的Camera(如果没有为null)。
light 附加到这个GameObject 的Light(如果没有为null)。
animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce 如果没有为null)。
renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSource(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(只读)。(如果没有
为null)。
guiTexture 附加到这个GameObject 的GUITexture(只读)。(如果没有
为null)。
collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物
体。
tag 这个游戏物体的标签。
name 对象的名称。
hideFlags 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponent 返回type 类型的组件,如果游戏物体上附加了一个,如
果没有返回null。
GetComponentInChildren 返回type 类型的组件,这个组件位于GameObject 或任何
它的子物体上,使用深度优先搜索。
GetComponentsInChildren 返回所以type 类型的组件,这些组件位于GameObject 或
任何它的子物体上。
GetComponents 返回GameObject 上所以type 类型的组件。
CompareTag 这个游戏物体被标签为tag?
SendMessageUpwards 在这个游戏物体的每个MonoBehaviour 和该行为的祖先
上调用名为methodName 方法。
SendMessage 在这个游戏物体上的每个MonoBehaviour 上调用
methodName 方法。
BroadcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上
调用methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的消息传递
OnBecameVisible OnBecameVisible 函数在这个物体对任何相机变得可见时被调
用.
OnBecameInvisible OnBecameInvisible 函数在这个物体对任何相机变得可见时被调
用.
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
ParticleRenderer
类,继承自Renderer
在屏幕上渲染粒子。
这个类是particle renderer 组件的脚本接口.
变量
◆ var camera VelocityScale: float
描述:粒子被拉伸多少取决于camera 的速度。
如果相机具有较大的速度,使用这个使粒子变得较大。
◆ var lengthScale: float
描述:粒子在它的运动方向上拉伸多少。
使用这个使粒子总是比较长。
◆ var maxParticleSize: float
描述:最大的粒子尺寸
粒子会给填充率带来严重负担。使用这个设置来确保靠近观察者时,它们不会占用过
多的性能。
◆ var particleRenderMode: ParticleRenderMode
描述:粒子如何被绘制
◆ var uvAnimationCycles: float
描述:设置UV 动画循环
◆ var uvAnimationXTile: int
描述:设置水平平铺数。
◆ var uvAnimationYTile: int
描述:设置垂直平铺数。
◆ var velocityScale: float
描述:粒子被拉伸多少取决于"它们移动的多快"。
使用这个使粒子随着它们的速度变长。
继承的成员
继承的变量
enabled 如果启用使渲染的3D 物体可见。
castShadows 这个物体投射阴影?
receiveShadows 这个物体接收阴影?
material 这个物体的材质。
sharedMaterial 这个物体的共享材质。
sharedMaterials 这个物体的所有共享材质。
materials 这个物体的所有材质。
bounds 渲染器的包围边界(只读)。
lightmapIndex 应用这个渲染器的光照图的索引。
lightmapTilingOffset 用于光照图的平铺和偏移。
transform 附加到这个GameObject 的Transform(如果没有为null)。
rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
camrea 附加到这个GameObject 的Camera(如果没有为null)。
light 附加到这个GameObject 的Light(如果没有为null)。
animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce 如果没有为null)。
renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSource(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(只读)。(如果没有
为null)。
guiTexture 附加到这个GameObject 的GUITexture(只读)。(如果没有
为null)。
collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物
体。
tag 这个游戏物体的标签。
name 对象的名称。
hideFlags 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponent 返回type 类型的组件,如果游戏物体上附加了一个,如
果没有返回null。
GetComponentInChildren 返回type 类型的组件,这个组件位于GameObject 或任何
它的子物体上,使用深度优先搜索。
GetComponentsInChildren 返回所以type 类型的组件,这些组件位于GameObject 或
任何它的子物体上。
GetComponents 返回GameObject 上所以type 类型的组件。
CompareTag 这个游戏物体被标签为tag?
SendMessageUpwards 在这个游戏物体的每个MonoBehaviour 和该行为的祖先
上调用名为methodName 方法。
SendMessage 在这个游戏物体上的每个MonoBehaviour 上调用
methodName 方法。
BroadcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上
调用methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的消息传递
OnBecameVisible OnBecameVisible 函数在这个物体对任何相机变得可见时被调
用.
OnBecameInvisible OnBecameInvisible 函数在这个物体对任何相机变得可见时被调
用.
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
SkinnedMeshRenderer
类,继承自Renderer
蒙皮网格过滤器
变量
◆ var bones: Transform[]
描述:用于蒙皮网格的骨骼。
function Start(){
gameObject.AddComponent(Animation);
gameObject.AddComponent(MeshFilter);
gameObject.AddComponent(MeshRenderer);
gameObject.AddComponent(SkinnedMeshFilter);
//构建基本网格
var mesh: Mesh=new Mesh();
mesh.vertices=[Vector3(-1,0,0), Vector3(1,0,0), Vector3(-1,5,0), Vector3(1,5,0)];
mesh.uv=[Vector2(0,0), Vector2(1,0), Vector2(0,0), Vector2(0,1), Vector2(1,1),];
mesh.triangles=[0,1,2,1,3,2];
mesh.RecalculateNormals();
//赋值网格到mesh filter 和renderer
GetComponent(MeshFilter).mesh=mesh;
renderer.material=new Material(Shader.Find(" Diffuse"));
//赋值骨骼权值到网格
//使用两个骨骼,一个用于上部的顶点,一个用于下部的顶点
var weights=new BoneWeight[4];
weights[0].boneIndex0=0;
weights[0].weight0=1;
weights[1].boneIndex0=0;
weights[1].weight0=1;
weights[2].boneIndex0=1;
weights[2].weight0=1;
weights[3].boneIndex0=1;
weights[3].weight0=1;
mesh.boneWeights=weights;
//创建骨骼变换并绑定姿势
//一个骨骼在顶部一个在底部
var bones = new Transform[2];
var bindPoses = new Matrix4x4[2];
bones[0] = new GameObject("Lower").transform;
bones[0].parent = transform;
//设置相对于父的位置
bones[0].localRotation = Quaternion.identity;
bones[0].localPosition = Vector3.zero;
//绑定姿势是骨骼的逆变换矩阵
//在这种情况下我们也要使这个矩阵是相对与根的
//这样我们就能够随意移动根物体了
bindPoses[0] = bones[0].worldToLocalMatrix * transform.localToWorldMatrix;
bones[1] = new GameObject("Upper").transform;
bones[1].parent = transform;
//设置相对于父的位置
bones[1].localRotation = Quaternion.identity;
bones[1].localPosition = Vector3(0,5,0);
//绑定姿势是骨骼的逆变换矩阵
//在这种情况下我们也要使这个矩阵是相对与根的
//这样我们就能够随意移动根物体了
bindPoses[1] = bones[1].worldToLocalMatrix * transform.localToWorldMatrix;
//赋值骨骼并绑定姿势
GetComponent(SkinnedMeshFilter).bones = bones;
GetComponent(SkinnedMeshFilter).bindPoses = bindPoses;
GetComponent(SkinnedMeshFilter).mesh = mesh;
//赋值一个简单的挥动动画到底部的骨骼
var curve = new AnimationCurve();
curve.keys = [new Keyframe(0,0,0,0), new Keyframe(1,3,0,0), new Keyframe(2,0.0,0,0)],
//使用曲线创建剪辑e
var clip = new AniamtionClip();
clip.SetCurve("Lower", Transform, "m_LocalPosition.z", curve);
//添加并播放剪辑
animation.AddClip(clip, "test");
aniamtion.Play("test"),
}
@ script RequireComponent(Animation)
◆ var quality: SkinQuality
描述:影响单个顶点的最大骨骼数量
renderer.quality = SkinQuality.Bone2;
◆ var sharedMesh: Mesh
描述:用于蒙皮的网格
◆ var skinNormals: bool
描述:如果启用,几何体法线将随着骨骼动画更新。
参见:Skinned Mesh Renderer component.
◆ var updateWhenOffscreen: bool
描述:如果启用,蒙皮网格将在离屏的时候更新。如果禁用,也将禁用动画更新。
参见:Skinned Mesh Renderer component.
继承的成员
继承的变量
enabled 如果启用使渲染的3D 物体可见。
castShadows 这个物体投射阴影?
receiveShadows 这个物体接收阴影?
material 这个物体的材质。
sharedMaterial 这个物体的共享材质。
sharedMaterials 这个物体的所有共享材质。
materials 这个物体的所有材质。
bounds 渲染器的包围边界(只读)。
lightmapIndex 应用这个渲染器的光照图的索引。
lightmapTilingOffset 用于光照图的平铺和偏移。
transform 附加到这个GameObject 的Transform(如果没有为null)。
rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
camrea 附加到这个GameObject 的Camera(如果没有为null)。
light 附加到这个GameObject 的Light(如果没有为null)。
animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce 如果没有为null)。
renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSource(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(只读)。(如果没有
为null)。
guiTexture 附加到这个GameObject 的GUITexture(只读)。(如果没有
为null)。
collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物
体。
tag 这个游戏物体的标签。
name 对象的名称。
hideFlags 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponent 返回type 类型的组件,如果游戏物体上附加了一个,如
果没有返回null。
GetComponentInChildren 返回type 类型的组件,这个组件位于GameObject 或任何
它的子物体上,使用深度优先搜索。
GetComponentsInChildren 返回所以type 类型的组件,这些组件位于GameObject 或
描述:trail 在出生点处的宽度。
参见:endWidth 变量.
◆ var time: float
描述:尾迹多长时间会消失。
继承的成员
继承的变量
enabled 如果启用使渲染的3D 物体可见。
castShadows 这个物体投射阴影?
receiveShadows 这个物体接收阴影?
material 这个物体的材质。
sharedMaterial 这个物体的共享材质。
sharedMaterials 这个物体的所有共享材质。
materials 这个物体的所有材质。
bounds 渲染器的包围边界(只读)。
lightmapIndex 应用这个渲染器的光照图的索引。
lightmapTilingOffset 用于光照图的平铺和偏移。
transform 附加到这个GameObject 的Transform(如果没有为null)。
rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
camrea 附加到这个GameObject 的Camera(如果没有为null)。
light 附加到这个GameObject 的Light(如果没有为null)。
animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce 如果没有为null)。
renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSource(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(只读)。(如果没有
为null)。
guiTexture 附加到这个GameObject 的GUITexture(只读)。(如果没有
为null)。
collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物
体。
tag 这个游戏物体的标签。
name 对象的名称。
hideFlags 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponent 返回type 类型的组件,如果游戏物体上附加了一个,如
果没有返回null。
GetComponentInChildren 返回type 类型的组件,这个组件位于GameObject 或任何
它的子物体上,使用深度优先搜索。
GetComponentsInChildren 返回所以type 类型的组件,这些组件位于GameObject 或
任何它的子物体上。
GetComponents 返回GameObject 上所以type 类型的组件。
CompareTag 这个游戏物体被标签为tag?
SendMessageUpwards 在这个游戏物体的每个MonoBehaviour 和该行为的祖先
上调用名为methodName 方法。
SendMessage 在这个游戏物体上的每个MonoBehaviour 上调用
methodName 方法。
BroadcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上
调用methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的消息传递
OnBecameVisible OnBecameVisible 函数在这个物体对任何相机变得可见时被调
用.
OnBecameInvisible OnBecameInvisible 函数在这个物体对任何相机变得可见时被调
用.
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
Rigidbody
类,继承自Component
通过物理模拟控制一个物体的位置。
Rigidbody 组件控制对象的位置- 它使物体在重力影响下下落,并可计算物体如何响
应碰撞。
当操作刚体参数的时候,你应该在FixedUpdate 函数中使用它,物理模拟以离散的时间
步执行。FixedUpdate 函数在每一步之前被立即调用。
需要注意的事是何时使用刚体:
1. 如果你的模拟看起来像慢动作并且不真实:
这是缩放的问题。如果你的游戏世界非常大,所以的东西将显示的非常慢,确保所有
你的模型有审视世界的大小。例如,一个汽车应该有4 米长,一个角色2 米高。物体以相
同的加速度下落,不论它大还是小,重或是轻。如果你的游戏时间有较大的缩放,物体将
还是以相同的加速度下落。但是因为物体都比较大,所以物体的下落显得比较慢。
变量
◆ var angularDrag: float
描述:物体的角阻力。
角阻力可以用来减缓物体的旋转。阻力越大,旋转减缓的越快。
rigidbody.angularDrag=10;
◆ var angularVelocity: Vector3
描述:刚体的角速度向量
在大多数情况下,你不应该直接修改它,以为这会导致不真实的结果。
//根据旋转的速度改变材质
var fastWheelMaterial: Material;
var slowWheelMaterial: Material;
function Update(){
if(rigidbody.angularVelocity.magnitude<5){
renderer.sharedMaterial=slowWheelMaterial;
}
else
{
renderer.sharedMaterial=fastWheelMaterial;
}
}
◆ var centerOfMass: Vector3
描述:相对于变换,原点的重心。
如果你不从脚边中设置重心,它将从所有附加到刚体的碰撞器上自动计算,当模拟汽车
时,设置重心是非常有用的,可以使它更加稳定。具有较低重心的汽车不太可能倾翻。
rigidbody.centerOfMass=Vector3(0,-2,0);
◆ var detectCollisions: bool
描述:碰撞检测应该启用? (默认总是启用的)
禁用碰撞检测是有用的,如果有一个人偶,它被设置为运动学并且你想避免刚体上大量
的碰撞检测计算,detectCollisions 是非序列化的,也就是说,它不会显示在检视面板中并且
当在场景中实例化或保存这个刚体时,它将不被保存。
///让动画控制这个刚体并忽略碰撞
rigidbody.isKinematic=true;
rigidbody.detectCollision=false;
///让刚体使用空,检测碰撞
rigidbody.isKinematic=false;
rigidbody.detectCollision=true;
◆ var drag: float
描述:物体的阻力
阻力可用来减缓物体的速度。阻力越大,旋转减缓的越快。
function OpenParachute(){
rigidbody.drag=20;
}
function Update(){
if(Input.GetButton("Space"))
{
OpenParachute();
}
}
◆ var freezeRotation: bool
描述:控制物理是个改变物体的旋转。
如果freezeRotation 被启用,旋转不会被物体模拟修改。这对于创建第一人称射击时有
用的,因为玩家需要使用鼠标完全控制旋转。
//冻结旋转
rigidbody.freezeRotation=true;
◆ var intertiaTensor: Vector3
描述:相对于重心的质量对角惯性张量。
惯性张量是被intertiaTensorRotation 旋转的。如果你不从脚本中设置惯性张量,它将从
所以附加到刚体的碰撞器上自动计算。
//长砖的惯性张量
rigidbody.intertiaTensor=Vector3(5,1,1);
◆ var intertiaTensorRotation: Quaternion
描述:惯性张量旋转。
如果你不从脚本中设置惯性张量旋转,它将从所有附加到刚体的碰撞器上自动计算。
//重置惯性张量为变换的坐标系统
rigidbody.intertiaTensorRotation=Quaternion,identity;
◆ var interpolation: RigidbodyInterpolation
描述:插值允许你以固定的帧率平滑物理运行效果。
默认,插值是关闭的。普通的刚体插值用于玩家角色。物理以离散的时间步运行,而
显卡以可变的帧率渲染。这可能导致物体的抖动,因为物理和显卡不完全同步。这个效果
是细微的但是通常会在玩家角色上看到,尤其是如果相机跟随主角色。建议为主角色打开
插值,但是禁用其他物体上的插值。
//是刚体插值
rigidbody.interpolation=RigidbodyInterpolation.Interpolate;
◆ var isKinematic: bool
描述:控制物理是够影响这个刚体。
如果isKinematic 启用,力,碰撞和关节将不会再影响这个刚体。刚体通过改变
transform.postion 由动画或脚本的完全控制。动力学刚体也会通过碰撞或关机影响其他刚体
的运动。例如,可以使用关节链接一个普通的刚体到动力学刚体,现在这个刚体受到动力学
刚体运动的约束。动力学刚体也被用于制作角色,这个角色通常是由动画驱动的,但是在
某些事件中可以通过设置isKinematic 为false 来讲它快速转化为一个人偶。
//不让刚体受到物理的影响!
rigidbody.isKinematic=true;
◆ var mass: float
描述:刚体的质量
你应该保持质量接近0.1 并且不要超过10。大的质量会使物理模拟不稳定。
当碰撞时较大质量的物体推动较小质量的物体。考虑一个大卡车,装上一个小汽车。
一个常见的错误时重的物体比轻的物体下落的快。这是不对的,速度依赖于重力和阻
力。
rigidbody.mass=0.5;
◆ var maxAngularVelocity: float
描述:刚体的最大角速度向量(默认7)范围{0,infinity}
刚体的角速度最大为maxAngularVelocity 以避免高速旋转物体的数值不稳定性。因为
这也许会阻止企图快速旋转的物体,例如车轮,你可以使用逐刚体重载该值。
rigidbody.maxAngularVelocity=10;
◆ var position: Vector3
描述:刚体的位置
这个与设置transfor.position 相同,然而position 只在物理的最后一步被应用到变换。
如果你想连续移动一个刚体或运动学刚体,使用MovePosition 和MoveRotation。
function Start(){
rigidbody.position=Vectorr3.zero;
}
◆ var rotation: Quaternion
描述:刚体的旋转
这个与设置transform.rotation 相同,然而rotation 只在物理的最后被应用到变换。如果
你想连续移动一个刚体或运动学刚体,使用MovePosition 和MoveRotation。
function Start(){
rigidbody.rotation=Quaternion.identity;
}
◆ var sleepAngularVelocity: float
描述:角速度,低于该值的物体将开始休眠。(默认0.14)范围{0, infinity}
参考Rigidbody Sleeping 获取更多信息。
◆ var sleepVelocity: float
描述:线行速度,低于该值的物体将开始休眠。(默认0.14)范围{0, infinity}
参考Rigidbody Sleeping 获取更多信息。
Rigidbody.sleepingVelocity=0.1;
◆ var solverIterationCount: int
描述:允许你覆盖每个刚体的求解迭代数。
solverIterationCount 决定关节和接触点如何精确地计算。如果出现链接的物体震荡和行
为怪异,为solver Iteration Count 设置一个较高的值将改善他们的稳定性。
rigidbody.solverIterationCount=10;
◆ var useConeFriction: bool
描述:用于该钢铁的立锥摩擦力
这确保所有接触包含的行为将使用锥摩擦力。这对于性能有负面影响。默认这个是关
闭的,一个更快和更好的被称为金字塔摩擦的近似方法被使用。在大多数情况下建议保留
这个值为关闭。
◆ var useGravity: bool
描述:控制重力是否影响这个刚体
如果设置为假刚体的行为会像是在外层空间。
在所有进入这个碰撞器的所有刚体上禁用重力
function OnTriggerEnter(other: Collider)
{
if(other.attachedRigidbody)
{
other.attachedRigidbody.useGravity=false;
}
}
//启用时将这个碰撞器改变为一个触发器
collider.isTrigger=true;
◆ var velocity: Vector3
描述:刚体的速度向量
在大多数情况下,你不应该直接修改速度,因为这会导致不真实的结果。不要再每个
物体步设置物体的速度,这将导致不真实的物理模拟。一个典型的例子是,当你在FPS 中
使用跳的时候,改变速度,因为你想立即改变速度。
function FixedUpdate(){
if(Input.GetButtonDown("Jump")){
rigidbody.velocity.y=10;}
}
◆ var worldCenterOfMass: Vector3
描述:世界空间中刚体的质量重心(只读)。
函数
◆ function AddExplosionForce (explosionForce : float, explosionPosition : Vector3,
explosionRadius : float, upwardsModifier : float = 0.0F, mode : ForceMode =
ForceMode.Force): void
描述:应用一个力到刚体来模拟爆炸效果。爆炸力将随着到刚体的距离线形衰减。
这个功能也对人偶有很好的作用。如果radius 为0,将使用全部的力不论position 距
离刚体多远.upwardModifier 就像从物体下方使用这个力. 这个是非常有用的,以为爆炸
将向上抛这个物体而不是将它们推向一边,这个看起来非常的酷。值2 将应用一个力在低
于物体2 米处,然而不会改变实际的爆炸位置. explosionPositon 是爆炸力被应用的位置.
explosionRadius 是爆炸的半径,超过explosionRadius 距离的刚体将不会受到影响.
var radius=5.0;
var power=10.0;
function Start(){
//应用一个爆炸力到所有附加的刚体上
var explosionPos=transform.position;
var colliders: Collider[]=Physics.OverlapSphere(explosionPos, radius);
for (var hit in colliders){
if(!hit)
continue;
if(hit.rigidbody){
hit.rigidbody.AddExplosionForce(power.explosionPos, radius, 3.0);
}
}
}
◆ function AddForce(force: Vector3, mode: ForceMode=ForceMode.Force): void
描述:为刚体添加一个力。作为结果刚体将开始移动。
//在全局坐标空间中添加一个向上的力
function FixedUpdate(){
rigidbody.AddForce(Vector3.up*10);
}
◆ function AddForce(x: float, y: float, z: float, mode: ForceMode=ForceMode.Force): void
描述:为刚体添加一个力,作为结果刚体将开始移动。
//全局坐标空间中添加一个向上的力
function FixedUpdate(){
rigidbody.AddForce(0,10,0);
}
如果你想在多针帧中使用力,你应该在FixedUpdate 中而不是Update 使用使用它。
◆ function AddForceAtPosition(force: Vector3, position: Vector3, mode: ForceMode=
ForceMode.Force): void
描述:在位置position 处使用force。这个将应用力矩和力到这个物体上。
对于真的的效果position 应该近似地在刚体表面的范围内. 这个最常用于爆炸。当使用
爆炸的时候最好应用力到多帧而不是一帧中。主要当position 远离刚体的中心时,使用的力
矩阵将非常不真实。
function ApplyForce(body: Rigidbody){
direction=body.transform.position-transform.position;
body.AddForceAtPosition(direction.normalized, transform.position);
}
◆ function AddRelativeForce(force: Vector3, mode: ForceMode=ForceMode.Force): void
描述:相对于它的坐标系统添加一个力到刚体。
作为结果刚体将开始移动。
//沿着自身z 轴向前移动刚体
function FixedUpadate(){
rigidbody.AddRelativeForce(Vector3.forward*10);
}
◆ function AddRelativeForce(x: float, y: float, z: float, mode: ForceMode=
ForceMode.Force): void
描述:相对于它的坐标系统添加一个力到刚体。
作为结果刚体将开始移动。
//沿着自身z 轴向前移动刚体
function FixedUpadate(){
rigidbody.AddRelativeForce(0,0,10);
}
如果你想在多帧中使用力,你应该在FixedUpdate 中而不是Update 使用使用它。
◆ function AddRelativeTorque(torque: Vector3, mode: ForceMode=ForceMode.Force):
void
描述:相对于刚体自身的坐标系统,添加一个力矩到刚体。
刚体将绕着torque 轴旋转。
//绕着全局y 轴旋转刚体
function FixedUpadate(){
rigidbody.AddRelativeForce(Vector3.up*10);}
◆ function AddRelativeTorque(x: float, y: float, z: float, mode: ForceMode=
ForceMode.Force): void
描述:相对于刚体自身的坐标系统,添加一个力矩到刚体。
刚体将绕着torque 轴旋转。
//绕着自身y 轴旋转刚体
function FixedUpadate(){
rigidbody.AddRelativeForce(0,10,0);}
如果你想在多帧中使用力,你应该在FixedUpdate 中而不是Update 使用使用它。
◆ function AddTorque((torque: Vector3, mode: ForceMode=ForceMode.Force): void
描述:为刚体添加一个力矩。
刚体将绕着torque 轴旋转。
//绕着全局y 轴旋转刚体
function FixedUpadate(){
rigidbody.AddTorque(Vector3.up*10);
}
如果你想在多帧中使用力,你应该在FixedUpdate 中而不是Update 使用使用它。
◆ function AddTorque(x: float, y: float, z: float, mode: ForceMode=ForceMode.Force):
void
描述:为刚体添加一个力矩。
刚体将绕着torque 轴旋转。
/绕着全局y 轴旋转到刚体
function FixedUpadate(){
rigidbody.AddTorque(0,10,0);
}
◆ function ClosestPointOnBounds(position: Vector3): Vector3
描述:到碰撞器包围盒上最近点。
这可以用来计算受到爆炸伤害时的伤害点数。或计算作用到刚体表面上一个点的爆炸
力。
var hitPoints=10.0;
function ApplyHitPoints(explostionPos: Vector3, radius: float){
//从爆炸位置到刚体表面的距离
var ClosestPoint=rigidbody.ClosestPointOnBounds(explosionPos);
var distance=Vector3f.Distance(closestPoint, explosionPos);
//伤害点数随着到伤害的距离而降低
var damage=1.0-Mathf.Cllamp01(distance/radius);
//这是我们要用的最终伤害点数。10 at maximum
damage*=10;
//应用伤害
hitPoints=damage;
}
◆ function GetPointVelocity(worldPoint: Vector3): Vector3
描述:刚体在世界空间中worldPoint 点处的速度.
GetPointVelocity 在计算速度的时候将考虑刚体的angularVelocity。
//打印车轮的速度
point=transform.InverseTransformPoint(Vector3(0,-2,0));
var velocity=rigidbody.GetPointVelocity(point);
print(velocity.magnitude);
◆ function GetRelativeVelocity(relativePoint: Vector3): Vector3
描述:相对于刚体在relativePoint 处的速度。
GetRelativePointVelocity 在计算速度的时候将考虑刚体的angularVelocity。
//打印车轮的速度
var relativeVelocity=rigidbody.GetRelativePointVelocity(Vector3(0,-2,0));
print(relativeVelocity.magnitude);
◆ function IsSleeping(): bool
描述:刚体处于休眠?
参考Rigidbody Sleeping 获取更多信息。
if(rigidbody.IsSleeping())
print("Sleeping");
◆ function MovePosition(position: Vector3): void
描述:移动刚体到position.
对于运动学刚体,它基于刚体的运动应用摩擦力。这个让你模拟刚体位于移动平台之
上的情况。如果你想其他的刚体与运动学刚体交互,你需要在FixedUpdate 函数中移动它。
var speed=Vector3(3,0,0);
function FixedUpdate()
{
rigidbody.MovePosition(rigidbody.position+speed*Time.deltaTime);
}
◆ function MoveRotation(rot: Quaternion): void
描述:旋转刚体到rotation.
对于运动学刚体,它基于刚体的运动应用摩擦力。这个让你模拟刚体位于移动/旋转平
台之上的情况。如果你想其他的刚体与运动学刚体交互,你需要在FixedUpdate 函数中移
动它。
var eulerAngleVelocity=Vector3(0,100,0);
function FixedUpdate()
{
var deltaRotation=Quaternion.Euler(eulerAngleVelocity*Time.deltaTime);
rigidbody.MoveRotation(rigidbody.rotation*deltaRotation);
}
◆ function SetDensity(density: float): void
描述:基于附加的刚体和固定的密度设置质量。
这个可以用来设置质量为随着碰撞器的尺寸而缩放。
rigidbody.SetDensity(1.5);
◆ function Sleep(): void
描述:强制刚体休眠至少一帧
一个常见的使用是从Awake 中调用它以便使刚体在启用的时候休眠。参考Rigidbody
Sleeping 获取更多信息。
rigidbody.Sleeping()
◆ function WakeUp(): void
描述:强制刚体苏醒
rigidbody.WakeUp()
参考Rigidbody Sleeping 获取更多信息。
消息传递
◆ function OnCollisionEnter(collisionInfo: Collision): void
描述:当这个碰撞器/刚体开始碰撞另一个刚体/碰撞器时OnCollisionEnter 被调用。
相对于OnTriggerEnter,OnCollisionEnter 传递Collision 类而不是Collider.Collision 类包
含接触点,碰撞速度等细细。如果在函数中不使用collisionInfo,省略collisionInfo 参数以避
免不必要的计算。主要如果碰撞器附加了一个非动力刚体,也只发送碰撞事件。
function OnCollisionEnter(collision:Collision){
//调试绘制所以的接触点和法线
for(var contact:ContactPoint in collision.contacts){
Debug.DrawRay(contact.point, contact.normal, Color.white);
}
//如果碰撞物体有较大的冲劲就播放声音
if(collision.relativeVelocity.magnitude>2)
audio.Play();
}
//一枚手榴弹
//-在击中一个表面时初始化一个爆炸预设
//-然后销毁它
var explosionPrefab: Transform;
function OnCollisionEnter(collision: Collision){
//旋转这个物体使y 轴面向沿着表面法线的方向
var contact-collision.contacts[0];
var rot=Quaternion.FormToRotation(Vector3.up, contact.mormal);
var pos=contact.point;
Instantiate(explosionPrefab, pos, rot);
//销毁这个发射物
Destroy(gameObject);
}
◆ function OnCollisionExit(collisionInfo: Collision): void
描述:当这个碰撞器/刚体停止碰撞另一个刚体/碰撞器时OnCollisionExit 被调用。
相对于OnTriggerExit,OnCollisionExit 传递Collision 类而不是Collider.Collision 类包含
接触点,碰撞速度等细细。如果在函数中不使用collisionInfo,省略collisionInfo 参数以避免
不必要的计算。主要如果碰撞器附加了一个非动力刚体,也只发送碰撞事件。
function OnCollisionExit(collision:Collision){
print("No longer in contact with "+collisionInfo.transform.name);
}
◆ function OnCollisionStay(collisionInfo: Collision): void
描述:对于每个与刚体/碰撞器相触碰的碰撞器/刚体,OnCollisionStay 将在每一帧中被调
用。
相对于OnTriggerStay,OnCollisionStay 传递Collision 类而不是Collider.Collision 类包含
接触点,碰撞速度等细细。如果在函数中不使用collisionInfo,省略collisionInfo 参数以避免
不必要的计算。主要如果碰撞器附加了一个非动力刚体,也只发送碰撞事件。
function OnCollisionStay(collision:Collision){
function OnCollisionEnter(collision:Collision){
//调试绘制所以的接触点和法线
for(var contact:ContactPoint in collision.contacts){
Debug.DrawRay(contact.point, contact.normal, Color.white);
}
继承的成员
继承的变量
transform 附加到这个GameObject 的Transform(如果没有为null)。
rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
camrea 附加到这个GameObject 的Camera(如果没有为null)。
light 附加到这个GameObject 的Light(如果没有为null)。
animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce 如果没有为null)。
renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSource(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(只读)。(如果没有为null)。
guiTexture 附加到这个GameObject 的GUITexture(只读)。(如果没有为null)。
collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
tag 这个游戏物体的标签。
name 对象的名称。
hideFlags 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponent 返回type 类型的组件,如果游戏物体上附加了一个,如
果没有返回null。
GetComponentInChildren 返回type 类型的组件,这个组件位于GameObject 或任何
它的子物体上,使用深度优先搜索。
GetComponentsInChildren 返回所以type 类型的组件,这些组件位于GameObject 或
任何它的子物体上。
GetComponents 返回GameObject 上所以type 类型的组件。
CompareTag 这个游戏物体被标签为tag?
SendMessageUpwards 在这个游戏物体的每个MonoBehaviour 和该行为的祖先
上调用名为methodName 方法。
SendMessage 在这个游戏物体上的每个MonoBehaviour 上调用
methodName 方法。
BroadcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上
调用methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
TextMesh
类,继承自Component
text mesh component 的脚本接口
参见:text mesh component.
变量
◆ var font: Font
描述:使用的Font.
参见:text mesh component.
//设置附加的文本网格的文本
var newFont: Font;
GetComponent(TextMesh).font=newFont;
◆ var font: string
描述:显示的文本.
参见:text mesh component.
//设置附加的文本网格的文本
GetComponent(TextMesh).text="Hello World";
继承的成员
继承的变量
transform 附加到这个GameObject 的Transform(如果没有为null)。
rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
camrea 附加到这个GameObject 的Camera(如果没有为null)。
light 附加到这个GameObject 的Light(如果没有为null)。
animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce 如果没有为null)。
renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSource(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(只读)。(如果没有为null)。
guiTexture 附加到这个GameObject 的GUITexture(只读)。(如果没有为null)。
collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
tag 这个游戏物体的标签。
name 对象的名称。
hideFlags 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponent 返回type 类型的组件,如果游戏物体上附加了一个,如
果没有返回null。
GetComponentInChildren 返回type 类型的组件,这个组件位于GameObject 或任何
它的子物体上,使用深度优先搜索。
GetComponentsInChildren 返回所以type 类型的组件,这些组件位于GameObject 或
任何它的子物体上。
GetComponents 返回GameObject 上所以type 类型的组件。
CompareTag 这个游戏物体被标签为tag?
SendMessageUpwards 在这个游戏物体的每个MonoBehaviour 和该行为的祖先
上调用名为methodName 方法。
SendMessage 在这个游戏物体上的每个MonoBehaviour 上调用
methodName 方法。
BroadcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上
调用methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
Transform
类,继承自Behaviour,可计数
物体的位置,旋转和缩放。
场景中的每个物体都有一个变换。这个用来存储并操作物体的位置,旋转和缩放,每
个变换可以有一个父,它允许你层次地应用位置,旋转和缩放。这个是可以在层次面板中
看到的层次,它们也支持计数器,这样你可以循环所以使用的子:
//变量的所有子像是移动10 个单位!
for(var child: Transform in transform){
child.position+=Vector3.up*10.0;
}
参见:The component reference, Physics 类.
变量
◆ var childCount: int
描述:变化的子的数量。
//打印子物体的数量
print(transform.childCount);
◆ var eulerAngles: Vector3
描述:旋转作为欧拉角度。
仅仅使用这个变量来读取和设置绝对值角度。不要递增它们,因为当该角度超过360
度时它将失败。使用Transform.Rotate 代替.
//打印绕着全局x 轴的旋转角度
print(transform.eulerAngles.x);
//打印绕着全局y 轴的旋转角度
print(transform.eulerAngles.y);
//打印绕着全局z 轴的旋转角度
print(transform.eulerAngles.z);
//使用eulerAngles 赋值绝对旋转
var yRotation=5.0;
function Update()
{
yRotation+=Input.GetAxis("Horizontal");
transform.eulerAngles=Vector3(10,yRoation,0);
}
不要分别设置eulerAngles 轴的(例如eulerAngles.x=10)以为这将导致偏移和不期望的
旋转。当设置它们为新值的时候,同事全部设置它们,如上所示。Unity 将转化储存在
Transfor.rotation 中的角度。
◆ var forward: Vector3
描述:在世界空间中变换的蓝色轴。
//设置刚体的速度为
//沿着变换的蓝色轴
rigidbody.velocity=transform.forward*10;
//计算target 变换和这个物体之间的角度
var angleBetween=0.0;
var target: Transform;
function Update()
{
var targetDir=target.position-transform.position
angleBetween=Vector3.Angle(transform.forward, targetDir);
}
◆ var localEulerAngles: Vector3
描述:相对于父变换旋转的欧拉角度。
仅仅使用这个变量来读取和设置绝对值角度。不要递增它们,因为当该角度超过360
度时它将失败。使用Transform.Rotate 代替.
//打印绕着父x 轴的旋转
print(transform.localEulerAngles.x);
//打印绕着父y 轴的旋转
print(transform.localEulerAngles.y);
//打印绕着父z 轴的旋转
print(transform.localEulerAngles.z);
Unity 将自动转化存储在Transform.localRotation 中的角度。
◆ var localPosition: Vector3
描述:该变换的位置相对于父变换。如果变换没有父,它与Transform.position 相同。
//移动物体到与父物体相同的位置
Transform.localPosition=Vector3(0,0,0);
//获取相对于父位置的y 组件
//并打印它到控制台
print(transform.localPosition.y);
注意,当计算世界位置时父变换的世界旋转和缩放将被应用到本地位置。这就是说
Transform.position 的1 单位总是1 单位。Transform.localPosition 的1 单位将受到所有父缩放
的影响。
◆ var localRotation: Quaternion
描述:该变换相对于父变换旋转的旋转。
Unity 内部以四元组方式存储旋转。使用Transform.Rotate 旋转物体. 使用
Transform.localEulerAngles 来修改旋转的欧拉角。
//设置旋转与父相同
Transform.localRotation=Quaternion.identity;
◆ var localScale: Vector3
描述:该变换相对于父的缩放。
Transform.localScale.x+=0.1;// 物体加宽0.1
◆ var localToWorldMatrix: Matrix4x4
描述:从本地空间到世界空间的变换矩阵(只读)。
如果你对使用矩阵进行坐标变换不熟悉那么使用Transform.TransformPoint 代替.
◆ var lossyScale: Vector3
描述:对象的全局缩放。
请注意,如果有一个父变换,该变化具有缩放并且它的子被随意缩放,那么该缩放是有
误差的。因此缩放不能正确地表示在一个3 组件向量中,而是一个3x3 矩阵。这样的表示
是非常麻烦的,而且lossyScale 是一个方便的属性,它尽量匹配实际世界缩放。如果你的
物体部没有偏差,这个值将是完全正确的。如果包含偏差,差别也不回太大。
print(transform.lossyScale);
◆ var parent: Transform
描述:变换的父
改变父将修改相对父的位置,缩放和旋转但是世界空间的位置,旋转和缩放时相同的,
//通过使相机成为该物体的子
//使它跟随这个物体.
//获取相机的变换
var cameraTransform=Camera main.transform;
//使它成为当前物体的子
cameraTransform.parent=transform;
//放置在当前物体之后
cameraTransform.localPosition=Vector3.forward*5;
//使它指向这个物体
cameraTransform.LookAt(transform);
//从变换的父上断开
transform.parent=mull;
◆ var position: Vector3
描述:在世界空间中变换的位置.
//移动物体到(0,0,0)
transform.position=Vector3(0,0,0);
//打印位置的x 组件到控制台
print(transform.position.x);
◆ var right: Vector3
描述:在世界空间中变换的红色轴.
//设置刚体的速度为
//沿着变换的绿色轴
rigidbody.velocity=transform.right*10;
◆ var root: Transform
描述:返回层次最顶端的变换。
(这个永远不会为Null,如果这个Transform 没有父它返回它自身.)
//两个碰撞的物体是否有不同的层次?
function OnCollisionEnter(collision){
if(collision.other.transform.root!=transform.root){
print("The colliding objects are not in the same hierachy");
}
}
◆ var rotation: Quaternion
描述:在世界空间中作为Quaternion 存储的旋转.
Unity 内部以四元组方式存储旋转。使用Transform.Rotation 旋转物体,使用
Transform.eulerAngles 来修改旋转的欧拉角
//重置世界旋转
Transform.Rotation=Quaternion.identity
//平滑地向一个target 旋转倾斜
var smooth=2.0;
var tiltAngle=30.0;
function Update(){
var tiltAroundZ=Input.GetAxis("Horizontal")*tiltAngles;
var tiltAroundX=Input.GetAxis("Vertical")*tiltAngles;
var target=Quaternion.Euler(tiltAroundX,0,tiltAroundZ);
//向target 旋转衰减
Transform.Rotation=Quaternion.Slerp(Transform.Rotation,target,Time.deltaTime*smooth);;
}
◆ var up: Vector3
描述:在世界空间中变换的绿色轴。
//设置刚体的速度为
//沿着变化的绿色轴
rigidbody.velocity=transform.up*10;
◆ var worldToLocalMatrix: Matrix4x4
描述:从世界空间到本地空间的变化矩阵(只读)
如果你对使用矩阵进行坐标变换不熟悉那么使用Transform.InverseTransformPoint 代替.
函数
◆ function DetachChildren(): void
描述:解除所以的子的父子关系。
如果你想销毁层次的根而不销毁它的子,可以使用这个。
transform.DetachChildren();
Destroy(gameObject);
参见:Transfrom.parent 来分开/改变单个变换的父.
◆ function find(name: string): Transform
描述:根据name 查找子并返回它.
如果没有子具有名称name 返回null.如果name 包含V 字符它将像一个路径名一样穿越
层次.
//旋转手指
function Update(){
aFinger=transform.find("LeftShoulder/Arm/Hand/Finger");aFinger.Rotate(Time.delta.Time*20,0,
0);
}
◆ function InverseTransfromDirection(direction: Vector3): Vector3
描述:从世界空间到本地空间变换direction。相对于Transform.TransfromDirection.
这个操作不受变换的影响。
//变换世界朝向到本地空间;
relative=transform.InverseTransfromDirection(Vector3.forward);
◆ function InverseTransfromDirection(x: float, y: float, z: float): Vector3
描述:从世界空间变换方向x,y,z 到本地空间。相对于Transform.TransfromDirection.
这个操作不受变换的影响。
//变换世界朝向到本地空间;
relative=transform.InverseTransfromDirection(0,0,1);
◆ function InverseTransfromPoint(position: Vector3): Vector3
描述:从世界空间到本地空间变换position。相对于Transform.TransformPoint.
注意返回位置会受到缩放的影响。如果你在处理方向,使用
Transform.InverseTransfromDirection.
//计算相对于相机的变换位置
camera=Camera.main.transform;
cameraRelative=camera.InverseTransfromPoint(transform.position);
if(cameraRelative.z>0){
print("The object is in front of the camera");
}
else{
print("he object is behind of the camera");
}
◆ function InverseTransfromPoint(x: float, y: float, z: float): Vector3
描述:从世界空间变换位置到x,y,z 到本地空间. 相对于Transform.TransformPoint.
注意返回位置会受到缩放的影响。如果你在处理方向,使用
Transform.InverseTransfromDirection.
//相对于这个变换计算世界原点.
relativePoint=transform.InverseTransfromPoint(0,0,0,);
if(RelativePoint.z>0){
print("The world origin is in front of the object");
}
else{
print("he world origin is behind of the object");
}
◆ function IsChildOf(parent: Transform): bool
描述:这个变换时parent 的一个子?
返回一个布尔值,表面改变换是否为给定变换的一个子。如果是为真,否则为假。
function OnEnterTrigger(col: Collider){
//在碰撞器和器子碰撞器之间忽略碰撞
//例如,当你有一个带有多个触发碰撞器的复杂角色时
if(col.transform.IsChildOf(transform))
return;
print("Don something here")
}
◆ function LookAt(target: Transform, worldUp: Vector3=Vector3.up): void
描述:旋转变换以前向向量指向/target/的当前位置。
然后旋转变换的向上向量为worldUp 向量. 如果你留空worldUp 参数,该函数将使用
世界y 轴。worldUp 是唯一一个建议向量,如果前向量与worldUp 垂直,旋转的向上向量
只与worldUp 向量相同。
//这个完成的脚本可以附加到一个相机上使它
//连续地指向另一个物体.
//target 作为一个属性显示在检视面板中
//拖动其他物体到它上面使相机看向它
var target: Transform;
//每帧旋转相机以便使它一直看向目标
function Update(){
transform.LookAt(target);
}
◆ function LookAt(worldPosition: Vector3, worldUp: Vector3=Vector3.up): void
描述:旋转该变换以便前向向量指向worldPosition。
然后旋转变换的向上向量为worldUp 向量. 如果你留空worldUp 参数,该函数将使用
世界y 轴。worldUp 是唯一一个建议向量,如果前向量与worldUp 垂直,旋转的向上向量
只与worldUp 向量相同。
//指向位于世界坐标原点的物体
transform.LookAt(Vector3.zero);
◆ function Rotate(eulerAngles: Vector3, relativeTo: Space=Space.Self): void
描述:绕着x 轴旋转eulerAngles.x 度,绕着y 轴旋转eulerAngles.y 度并绕着z 轴旋转
eulerAngles.z 度.
如果relativeTo 留空或者设置为Space.Self 该旋转将绕着变换的本地轴。(当在场景视图
中选择该物体时,显示物体的x,y 和z 轴)如果relativeTo 是Space.World 旋转绕着世界的
x,y,z 轴.
function Update(){
//绕着物体的X 轴以1 度/秒的速度旋转物体.
transform.Rotate(Vector3.right*Time.deltaTime);
//...同时现对于世界坐标
//的Y 轴以相同的速度旋转,
transform.Rotate(Vector3.up*Time.deltaTime, Space.World);
}
◆ function Rotate(xAngle : float, yAngles : float, zAngles : float, relativeTo: Space=
Space.Self): void
描述:绕着x 轴旋转xAngle 度,绕着y 轴旋转yAngles 度并绕着z 轴旋转zAngles 度.
如果relativeTo 留空或者设置为Space.Self 该旋转将绕着变换的本地轴。(当在场景视图
中选择该物体时,显示物体的x,y 和z 轴)如果relativeTo 是Space.World 旋转绕着世界的
x,y,z 轴.
function Update(){
//绕着物体的X 轴以1 度/秒的速度旋转物体.
transform.Rotate(Time.deltaTime,0,0);
//...同时现对于世界坐标
//的Y 轴以相同的速度旋转,
transform.Rotate(0.deltaTime, 0, Space.World);
}
◆ function Rotate(axis : Vector3, angles : float, relativeTo: Space=Space.Self): void
描述:绕着axis 轴旋转angle 度.
如果relativeTo 留空或者设置为Space.Self 该axis 参数将相对于变换的本地轴。(当在
场景视图中选择该物体时,显示物体的x,y 和z 轴)如果relativeTo 是Space.World 该axis

对于世界的x,y,z 轴.
function Update(){
//绕着物体的X 轴以1 度/秒的速度旋转物体.
transform.Rotate(Vector3.right, Time.deltaTime);
//...同时现对于世界坐标
//的Y 轴以相同的速度旋转,
transform.Rotate(Vector3.up, Time.deltaTime, Space.World);
}
◆ function RotateAround(point: Vector3, axis : Vector3, angle: float): void
描述:绕着axis 旋转改变换,并通过世界左边的point,旋转angle 度.
这个将同时修改变换的位置和旋转。
function Update(){
//绕着世界原点以20 度/秒旋转物体.
transform.RotateAround(Vector3.zero, Vector3.up. 20*Time.deltaTime);
}
◆ function TransformDirection(direction: Vector3): Vector3
描述:从本地空间到世界空间变换direction。
这操作不会受到缩放或变换位置的影响。返回的向量与direction 有相同的长度.
//计算相对于相机的轴
camera=Camera.main.transform;
cameraRelativeRight=camera.TransformDirection(Vector3.right);
//相对于相机的x 轴应用一个力
rigidbody.AddForce(cameraRelativeRight*10);
◆ function TransformDirection(x: float, y: float, z: float): Vector3
描述:从本地空间变换方向x,y,z 到世界空间。
这操作不会受到缩放或变换位置的影响。返回的向量与direction 有相同的长度.
//计算相对于相机的轴
camera=Camera.main.transform;
cameraRelativeRight=camera.TransformDirection(1,0,0);
//
相对于相机的x 轴应用一个力
rigidbody.AddForce(cameraRelativeRight*10);
◆ function TransformPoint(position: Vector3): Vector3
描述:从本地空间到世界空间变换position。
注意返回位置会受到缩放的影响。如果你在处理方向,使用
Transform.TransformDirection.
//你需要在检视面板中赋值一个物体到这个变量
var someObject: GameObject;
//在当前物体的右侧实例化一个物体
thePosition=transform TransformPoint(Vector3.right*2);
Instantiate(someObject, thePosition);
◆ function TransformPoint(x: float, y: float, z: float): Vector3
描述:从本地空间变换位置x,y,z 到世界空间.
注意返回位置会受到缩放的影响。如果你在处理方向,使用
Transform.TransformDirection.
//你需要在检视面板中赋值一个物体到这个变量
var someObject: GameObject;
//在当前物体的右侧实例化一个物体
thePosition=transform TransformPoint(2,0,0);
Instantiate(someObject, thePosition);
◆ function Translate(translation: Vector3, relativeTo: Space=Space.Self): void
描述:在该方向上移动变换transform 距离.
如果relativeTo 留空或者设置为Space.Self 该运动将相对于变换的本地轴.(当在场景视
图中选择该物体时,显示物体的x,y 和z 轴)如果relativeTo 是Space.World 运动将相对于

界的坐标系统.
function Update(){
//沿着物体的z 轴向前以1 单位/秒的速度移动物体
transform.Translate(Vector3.up*Time.deltaTime, Space.World);
}
◆ function Translate(x: float, y: float, z: float, relativeTo: Space=Space.Self): void
描述:沿着x 轴移动x,沿着y 轴移动y,沿着z 轴移动.
如果relativeTo 留空或者设置为Space.Self 该运动将相对于变换的本地轴.(当在场景视
图中选择该物体时,显示物体的x,y 和z 轴)如果relativeTo 是Space.World 运动将相对于

界的坐标系统.
function Update(){
//沿着物体的z 轴向前以1 单位/秒的速度移动物体
transform.Translate(0,0,Time.deltaTime);
//世界空间中向上以1 单位/秒的速度移动物体
transform.Translate(0,Time.deltaTime,0,Space.World);
}
◆ function Translate(translation: Vector3, relativeTo: Transform): void
描述:在该方向上移动变换translation 距离.
运动相对于/relativeTo/的本地坐标系统. 如果relativeTo 是null 运动将相对于世界的坐
标系统.
function Update(){
//相对于相机以1 单位/秒的速度向右移动物体.
transform.Translate(Vector3.right*Time.deltaTime, Camera.main.transform);
}
◆ function Translate(x: float, y: float, z: float, relativeTo: transform): void
描述:沿着x 轴移动x,沿着y 轴移动y,沿着z 轴移动.
运动相对于/relativeTo/的本地坐标系统. 如果relativeTo 是null 运动将相对于世界的坐
标系统. function Update(){
//相对于相机以1 单位/秒的速度向右移动物体.
transform.Translate(Time.deltaTime, 0,0, Camera.main.transform);
}
继承的成员
继承的变量
transform 附加到这个GameObject 的Transform(如果没有为null)。
rigidbody 附加到这个GameObject 的Rigidbody(如果没有为null)。
camrea 附加到这个GameObject 的Camera(如果没有为null)。
light 附加到这个GameObject 的Light(如果没有为null)。
animation 附加到这个GameObject 的Animation(如果没有为null)。
constantForce 附加到这个GameObject 的ConstantForce 如果没有为null)。
renderer 附加到这个GameObject 的Renderer(如果没有为null)。
audio 附加到这个GameObject 的AudioSource(如果没有为null)。
guiText 附加到这个GameObject 的GUIText(如果没有为null)。
networkView 附加到这个GameObject 的NetworkView(只读)。(如果没有为null)。
guiTexture 附加到这个GameObject 的GUITexture(只读)。(如果没有为null)。
collider 附加到这个GameObject 的Collider(如果没有为null)。
hingeJoint 附加到这个GameObject 的HingeJoint(如果没有为null)。
particleEmitter 附加到这个GameObject 的ParticleEmitter(如果没有为null)。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
tag 这个游戏物体的标签。
name 对象的名称。
hideFlags 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetComponent 返回type 类型的组件,如果游戏物体上附加了一个,如
果没有返回null。
GetComponentInChildren 返回type 类型的组件,这个组件位于GameObject 或任何
它的子物体上,使用深度优先搜索。
GetComponentsInChildren 返回所以type 类型的组件,这些组件位于GameObject 或
任何它的子物体上。
GetComponents 返回GameObject 上所以type 类型的组件。
CompareTag 这个游戏物体被标签为tag?
SendMessageUpwards 在这个游戏物体的每个MonoBehaviour 和该行为的祖先
上调用名为methodName 方法。
SendMessage 在这个游戏物体上的每个MonoBehaviour 上调用
methodName 方法。
BroadcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour 上
调用methodName 方法。
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
Flare
类,继承自Object
一个闪光资源。在组件参考中获取更多关于闪光的信息.
这个类没有属性。他需要在检视面板中设置。你可以应用闪光并在运行时将它赋给一
个光源。
//在检视面板中公开一个闪光的引用
var newFlare: Flare;
//赋值闪光
light.flare-newFlare;
参见:Flare assets,LensFlare 类.
继承的成员
继承的变量
name 对象的名称。
hideFlags 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
Font
类,继承自Object
用于字体资源的脚本接口,
可以使用这个类为GUI 文本或文本网格动态切换字体。
参见:GUIText 和TextMesh.
变量
◆ var material: Material
描述:这个材质用于字体的显示。
函数
◆ function HasCharacter(c: char): bool
描述:这个字体是否有特定字符?
继承的成员
继承的变量
name 对象的名称。
hideFlags 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
GameObject
类,继承自Object
Unity 场景中所有实体的基类。
参见:Component
变量
◆ var active: bool
描述:游戏物体是激活的?激活/不激活该游戏物体,
//不激活该游戏物体.
gameObject.active=false;
◆ var animation: Animation
描述:附加到这个游戏物体的???(只读)(如果没有为null)
var other: GameObject;
other.animation.Play();
◆ var audio: AudioSource
描述:附加到这个游戏物体的???(只读)(如果没有为null)
var other: GameObject;
other.audio.Play();
◆ var camera: Camera
描述:附加到这个游戏物体的相机(只读)(如果没有为null)
var other: GameObject;
other.camera.fieldOfView=45;
◆ var collider: Collider
描述:附加到这个游戏物体的碰撞器(只读)(如果没有为null)
var other: GameObject;
other.collider.material.dynamicFriction=1;
◆ var constantForce: ConstantForce
描述:附加到这个游戏物体的恒定力(只读)(如果没有为null)
var other: GameObject;
other.constantForce.relativeForce=Vector3(0,0,1);
◆ var guiText: GUIText
描述:附加到这个游戏物体的GUIText(只读)(如果没有为null)
var other: GameObject;
other.guiText.text="HelloWorld";
◆ var guiTexture: GUITexture
描述:附加到这个游戏物体的GUIText(只读)(如果没有为null)
◆ var hingeJoint: HingeJoint
描述:附加到这个游戏物体的HingeJoint(只读)(如果没有为null)
var other: GameObject;
other.hingeJoint Spring.targetPosition=70;
◆ var layer: int
描述:游戏物体所在的层,一个层在[0...32]之间.
Layer 可以用来选择性的渲染或忽略投射, .
//设置游戏物体到忽略投射物体的层上
gameObject.layer=2;
◆ var light: Light
描述:附加到这个游戏物体的光影(只读)(如果没有为null)
var other: GameObject;
other.light.range=10;
◆ var networkView: NetworkView
描述:附加到这个游戏物体的网络视(只读)(如果没有为null)
var other: GameObject;
other.networkView.RPC("MyFunction",RPCMode.All,"someValue");
◆ var particleEmitter: ParticleEmitter
描述:附加到这个游戏物体的粒子发射器(只读)(如果没有为null)
var other: GameObject;
other.particleEmitter.emite=true;
◆ var renderer: Renderer
描述:附加到这个游戏物体的渲染器(只读)(如果没有为null)
var other: GameObject;
other.renderer.material.color=Color.green;
◆ var rigidbody: Rigidbody
描述:附加到这个游戏物体的刚体(只读)(如果没有为null)
var other: GameObject;
other.rigidbody.AddForce(1,1,1);
◆ var tag: string
描述:这个游戏物体的标签。
标签可以用来标识一个游戏物体。标签在使用前必须在标签管理器中定义。
gameObject.tag="Player";
◆ var transform: Transform
描述:附加到这物体的变换. (如果没有为null)
var other: GameObject;
other.transform.Translate(1,1,1);
构造函数
◆ static function GameObject(name:string): GameObject
描述:创建一个新的游戏物体,命名为name.
Transform 总是被添加到该游戏物体.
//创建一个名为"Player"的游戏物体
//并给他添加刚体和立方体碰撞器.
player=new GameObject("Player");
player.AddComponent("Rigidbody");
player.AddComponent("BoxCollider");
◆ static function GameObject(): GameObject
描述:创建一个新的游戏物体.
Transform 总是被添加到该游戏物体.
//创建一个没有名称的游戏物体
//并给他添加刚体和立方体碰撞器.
player=new GameObject();
player.AddComponent("Rigidbody");
player.AddComponent("BoxCollider");
◆ static function GameObject(name: string, params components: Type[]): GameObject
描述:创建一个游戏物体并附加特定的组件.
函数
◆ function AddComponent(className: string): Component
描述:添加一个名为className 的组件类型到该游戏物体.
使用这个函数来改变物体的行为。你也可以传递脚本的类名来添加脚本到游戏物体。
有些组件也需要另一些组件存在于同一个游戏物体上。这个函数会自动添加需要的组
件,例如如果你添加一个HingeJoint 也会自动添加一个Rigidbody.
//添加名为FoobarScript 的脚本到游戏物体
gameObject.AddComponent("FoobarScript");
//添加球形碰撞器到游戏物体
gameObject.AddComponent("FoobarCollider");
◆ function AddComponent(componentType: Type): Component
描述:添加一个名为componentType 类型的类到该游戏物体.
gameObject.AddComponent("FoobarScript");
注意,没有RemoveComponent(),来移除组件,使用Object.Destroy.
◆ function BroadcastMessage(methodName: string, parameter: object=mull, option:
SendMessageOption=SendMessageOptions.RequireReceiver): void
描述:在这个游戏物体或其任何子上的每个MonoBehaviour 上调用methodName 方法。
通过使用零参数,接收方法可以选择忽略parameter。如果options 被设置为
SendMessageOptions.RequireReceiver,那么如果这个消息没有被任何组件接收时将打印一个
错误消息。
///使用值5 调用函数ApplyDamage
gameObject.BroadcastMessage("ApplyDamage",5);
//所有附加到该游戏物体和其子物体上脚本中的
//ApplyDamage 函数都将调用
function ApplyDamage(damage){
print(damage)
}
◆ function CompareTag(tag: string): bool
描述:这个游戏物体被标签为tag?
//立即死亡触发器
//销毁任何进入到触发器的碰撞器,这些碰撞器被标记为Player.
function OnTriggerEnter(other: Collider){
if(other.gameObject.CompareTag("Player"))
{
Destroy(other.gameObject);
}
}
◆ function GetComponent(type: Type): bool
描述:如果游戏物体有type 类型的组件就返回它,否则返回null. 你可以使用这个函数
访问内置的组件或脚本.
GetComponent 是防卫其他组件的主要方法。对于Javascript 脚本的类型总是脚本显示
在工程视图中的名称。例如:
function Start()
{
var curTransform: Transform;
curTransform=gameObject.GetComponent(Transform);
//这等同于
curTransform=gameObject.transform;
}
function Update() {
//为访问附加在同一游戏物体上
//其他脚本内的公用变量和函数
//(ScriptName 为Javascript 文件名)
var other: ScriptName=gameObject.GetComponent(ScriptName);
//调用该脚本中的DoSomething 函数
other DoSomething();
//设置其他脚本实例中的另一个变量
other.someVariable=5;
}
◆ function GetComponent(type: string): Component
描述:返回名为type 的组件,如果游戏物体上附加了一个就返回它,如果没有返回null.
出于性能的原因最好用Type 电影GetComponent 而不是一个字符串。然而有时你可能
无法得到类型,例如当试图从Javascript 中访问c#时。在那种情况下你可以简单的通过名
称而不是类型访问这个组件。例如:
function Update()
{
//为访问附加在同一游戏物体上
//其他脚本内的公用变量和函数.
//(ScriptName 为Javascript 文件名)
var other=gameObject.GetComponent("ScriptName");
//调用该脚本中的DoSomething 函数
other.DoSomething().
//设置其他脚本实例中的另一个变量
other.someVariable=5;
}
◆ function GetComponentInChildren(type: Type): Component
描述:返回type 类型的组件,这个组件位于这个游戏物体或任何它的子物体上,使用
深度优先搜索。
只有激活的组件被返回。
var script: ScriptName=gameObject.GetComponentInChildren(ScriptName);
script.DoSomething();
◆ function GetComponents(type: Type): Component[]
描述:返回该游戏物体上所有type 类型的组件。
//在这个游戏物体和所有它的子物体上
//的HingeJoints 上禁用弹簧
var hingeJoints=gameObject.GetComponents(HingeJoint);
for(var joint: HingeJoint in hingeJoints){
joint.useSpring=false;
}
◆ function GetComponentsInChildren(type: Type, includeInactive: bool=false):
Component[]
描述:返回所有type 类型的组件,这些组件位于该游戏物体或任何它的子物体上。
只有激活的组件被返回。
//在这个游戏物体和所有它的子物体上
//的所有HingeJoints 上禁用弹簧
var hingeJoints=gameObject.GetComponentsInChildren(HingeJoint);
for(var joint: HingeJoint in hingeJoints){
joint.useSpring=false;
}
◆ function SampleAnimation(animation: AnimationClip, time: float): void
描述:在一个特定的时间采样动画,用于任何动画目的。
出于性能考虑建议使用Animation 接口,这将在给定的time 采用animation,任何被动
化的组件属性都将被这个采样值替换,多数时候你会使用Animation.Play. SampleAnimation
用于当你需要以无序方式或给予一些特殊的输入在帧之间跳跃时使用。参见:Aniamtion
//通过采样每一帧或动画剪辑
varclip.AniamtionClip
function Update()
{
gameObject.sampleAnimation(clip, clip.length-Time.time);
}
◆ function SendMessage(methodName: string, value: object=null, options:
SendMessageOption=SendMessageOption.RequireReceiver): void
描述:在这个游戏物体上的每个MonoBehaviour 上调用methodName 方法。
通过使用零参数,接收方法可以选择忽略参数。如果options 被设置为
SendMessageOptions.RequireReceiver,那么如果这个消息没有被任何组件接收时将打印一个
错误消息。
//使用值5 调用函数ApplyDamage
gameObject.SendMessage("ApplyDamage",5);
//所以附加到该游戏物体上的脚本中的
//ApllyDamage 函数都将调用
function.ApplyDamage(damage){
pring(damage);
}
◆ function SendMessageUpwards(methodName: string, value: object=null, options:
SendMessageOption=SendMessageOption.RequireReceiver): void
描述:在这个游戏物体上的每个MonoBehaviour 和该行为的祖先上调用名为methodName
方法。
通过使用零参数,接收方法可以选择忽略参数。如果options 被设置为
SendMessageOptions.RequireReceiver,那么如果这个消息没有被任何组件接收时将打印一个
错误消息。
//使用值5 调用函数ApplyDamage
gameObject.SendMessageUpwards("ApplyDamage",5);
//所以附加到该游戏物体上的脚本中的
//ApllyDamage 函数都将调用
function.ApplyDamage(damage){
pring(damage);
}
◆ function SetActiveRecursion(rotate: bool): void
描述:设置这个物体和所以子游戏物体的机会状态。
gameObject.SetActiveRecursion(true);
类方法
◆ static function CreatePrimitive(type: PrimitiveType): GameObject
描述:用几何的网格渲染器和适当的碰撞器创建一个游戏物体。
///在场景中创建一个平面,球体和立方体
function Start()
{
GameObject.CreatePrimitive(PrimitiveType.Plane);
var cube=GameObject.CreatePrimitive(PrimitiveType.Cube);
cube.transform.position=Vector3(0,0.5,0);
var sphere=GameObject.CreatePrimitive(PrimitiveType.Sphere);
Sphere.transform.position=Vector3(0,1.5,0);
var capsule=GameObject.CreatePrimitive(PrimitiveType.Capsule);
capsule.transform.position=Vector3(2,1,0);
var cylinder=GameObject.CreatePrimitive(PrimitiveType.Cylinder);
cylinder.transform.position=Vector3(-2,1,0);
◆ static function Find(name: string): GameObject
描述:依据name 查找物体并返回它.
如果没有物体具有名称name 返回null. 如果name 包含'/'字符它将像一个路径名一样穿
越层次,这个函数只返回激活的游戏物体。
出于性能考虑建议不要在每帧中都是有该函数,而是在开始时调用并在成员变量中缓存结果
或者用GameObject.FindWithTag.
//这返回场景中名为Hand 的游戏物体.
hand=GameObject.Find("Hand");
//这将返回名为Hand 的游戏物体.
//在层次试图中Hand 也许没有父!
hand=GameObject.Find("/Hand");
//这将返回名为Hand 的游戏物体.
//它是Arm>Monster 的子.
//在层次试图中Monster 也许没有父!
hand=GameObject.Find("/Monster/Arm/Hand");
//这将返回名为Hand 的游戏物体.
//它是Arm>Monster 的子.
//Monster 有父.
hand=GameObject.Find("/Monster/Arm/Hand");
这个函数最常用与在加载时自动链接引用到其他物体,例如,在MonoBehaviour.Awake
或MonoBehaviour.Start 内部. 处于性能考虑你不应该在每帧中调用这个函数,例如
MonoBehaviour.Update 内. 一个通用的模式是在MonoBehaviour.Start 内将一个游戏物体赋给
一个变量. 并在MonoBehaviour.Update 中使用这个变量.
//在Start 中找到Hand 并在每帧中选择它
private var hand: GameObject;
function Start(){
hand=GameObject.Find("/Monster/Arm/Hand");
}
function Update(){
hand.transform.Rotate(0,100*Time.deltaTime,0);
}
◆ static function FindGameObjectsWithTag(tag: string): GameObject[]
描述:返回标记为tag 的激活物体列表,如果没有发现返回null.
标签在使用前必须在标签管理中定义。
//在所有标记为"Respawn"的物体位置处
//实例化respawnPrefab
var respawnPrefab: GameObject;
var respawns=GameObject.FindGameObjectsWithTag("Respawn");
for(var respawn in respawns)
Instantiate(respawnPrefab, respawn.position, respawn.rotation);
//打印最接近的敌人的名称
print(FindClosestEnemy().name);
//找到最近的敌人的名称
function FindClosestEnemy(): GameObject {
//找到所以标记为Enemy 的游戏物体
var gos: GameObject[]
gos=GameObject.FindGameObjectsWithTag("Enemy");
var closest: GameObject;
var distance=Mathf.Infinity;
var position=transform.position;
//遍历它们找到最近的一个
for(var go: GameObject in gos){
var diff=(go.transform.position-position);
var curDistance=diff.sqrMagnitude;
if(curDistance<distance){
closest=go;
distance=curDistance;
}
}
return closest;
}
◆ static function FindGWithTag(tag: string): GameObject
描述:返回标记为tag 的一个激活游戏物体,如果没有发现返回null.
标签在使用前必须在标签管理中定义。
//在标记为"Respawn"的物体位置处
//实例化一个respawnPrefab
var respawnPrefab: GameObject;
var respawns=GameObject.FindWithTag("Respawn");
Instantiate(respawnPrefab, respawn.position, respawn.rotation);
继承的成员
继承的变量
name 对象的名称。
hideFlags 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
这与使用带有"_MainTex"名称的GetTextureOffset 或SetTextureOffset 相同。
//基于时间滚动主纹理
var scrollSpeed=0.5;
function Update(){
var offset=Time.time*scrollspeed;
renderer.material.mainTextureOffset=Vector2(offset,0);
}
参见:SetTextureOffset.GetTextureOffset.
◆ var mainTextureScale: Vector2
描述:主材质的纹理缩放。
这与使用带有"_MainTex"名称的GetTextureScale 或SetTextureScale 相同。
function Update(){
var scalex=Mathf.Cus(Timetime)*0.5+1;
var scaleY=Mathf.Sin(Timetime)*0.5+1;
renderer.material.mainTextureScale=Vector2(scaleX,scaleY);
}
参见:SetTextureScale.GetTextureScale.
◆ var passCount: int
描述:在这个材质中有多少个pass(只读).
这个最常用在使用GL 类之间绘制的代码中(只限于Unity Pro). 例如,Image Effects 使用
材质来实现屏幕后期处理. 对材质中的每一个pass(参考SetPass)它们激活并绘制一个全屏
四边形。
这里是一个全屏图形效果的例子,它反转颜色。添加这个脚本到相机并在播放模式中
查看。
private var mat: Material;
function Start()
{
mat=new Material(
"Shader\"Hidden/Invert\"{"+
"SubShader{"+
"Pass{"+
"ZTestAlways Cull Off ZWrite Off"+
"SetTexture[_RenderTex]{combine one-texture}"+
"}"+
"{"+
"}"+
);
}
function OnRenderImage(source: RenderTexture, dest: RenderTexture){
RenderTexture.active=dest;
source.SetGlobalShaderProperty("_RenderTex");
GL.PushMatrix();
GL.LoadOrtho();
//对于材质中的每个pass(这里只有一个)
for(var i=0; i<mat.passCount; ++i){
//激活pass
mat.SetPass(i);
//绘制一个四边形
GL.Begin(GLQUADS);
GL.TEXCoord2(0,0); GL.Vertex3(0,0,0.1);
GL.TEXCoord2(1,0); GL.Vertex3(1,0,0.1);
GL.TEXCoord2(1,1); GL.Vertex3(1,1,0.1);
GL.TEXCoord2(0,1); GL.Vertex3(0,1,0.1);
GL.End();
}
GL.PopMatrix();
}
参见:SetPass 函数,GL 类,ShaderLab documentation.
◆ var renderQueue: int
描述:这个材质的渲染队列(只读)
默认地材质使用shader 的render queue,你可以使用这个变量重载该渲染队列。注意一
旦渲染队列在该材质上被设置,它将保持这个值,集市以后shader 被改变为不同的一个值。
渲染队列值需要时正的才能正常工作。
参见:Shader.renderQueue, RenderQueue tag.
◆ var shader: Shader
描述:该材质使用的着色器。
//按下空格键时,
//在Diffuse 和Transparent/Diffuse 着色器之间切换
private var shader1=Shader.Find("Diffuse");
private var shader2=Shader.Find("Transparent/Diffuse");
function Update() {
if(Input.GetButtonDown("Jump")){
If(renderer.material.shader--shader1)
rendere.material.shader=shader2;
else
renderer.material.shader=shader1;
}
}
参见:Shader.Find 方法,Material, ShaderLab documentation.
构造函数
◆ static function Material(contents: string): Material
描述:从一个源shader 字符串创建一个材质。
如果你有一个实现自定义特效的脚本,你需要使用着色器和材质实现所有的图像设置。
在你的脚本内使用这个函数创建一个自定义的着色器和材质。在创建材质后,使用SetColor,
SetTexture, SetFloat, SetVector, SetMatrix 来设置着色器属性值。
//创建一个附加混合材质并用它来渲染
var color=Color.white;
function Start()
{
var shader Text=
"shader\"Alpha Additive\"{"+
Properties{_Color(\"Main Color\", Color)=(1,1,1,0)}"+
"SubShader {"+
"Tags {\"Queue\"=\"Transparent\"}"+
"Pass {"+
"Blend One One ZWrite Off ColorMask RGB"+
"Material {Diffuse[_Color]Ambient[_Color]}"+
"Lighting On"+
"SetTexture[_Dummy]{combine primary double, primary}"+
"}"+
"}"+
"}";
renderer.material=new Material(shaderText);
renderer.material.color=color;
}
参见:ShaderLab documentation.
函数
◆ function CopyPropertiesFormMaterial(mat: Material): void
描述:从其他材质拷贝属性到这个材质。
◆ function GetColor(propertyName: string): Color
描述:获取一个命名的颜色值。
数多shader 使用超过一个颜色,使用GetColor 来获取propertyName 颜色。
Unity 内置着色器使用的普通颜色名称;
"_Color"为材质的主颜色。这也能够通过color 属性访问。
"_SpecColor"为材质的反射颜色(在specular/glossy/vertexlit 着色器中使用)。
"_Emission"为材质的散射颜色(用在reflective 着色器中使用)。
print(renderder.material.GetColor("_SpecColor));
参见:color 属性,SetColor.
◆ function GetFloat(propertyName: string): float
描述:获取一个命名的浮点值。
参见:SetFloat, Materials, ShaderLab documentation.
◆ function GetMatrix(propertyName: string): Matrix4x4
描述:从该shader 中获取命名矩阵的值。
这个最常用于自定义的shader,其中需要额外的矩阵参数,矩阵参数不需要在材质检
视面板中公开,但是能够在脚本中通过SetMatrix 和GetMatrix 来设置和查询。
参见:SetMatrix, Materials, ShaderLab documentation.
◆ function GetTag(taf: string, searchFallbacks: bool, defaultValue: string=""): string
描述:获取材质的shader 标签值。
如果材质的shader 没有定义标签,defaultValue 被返回。
如果searchFallbacks 为true 那么这个函数将在所有的子shader 和所有后备中查找标签。
如果searchFallbacks 为false 只在当前查询的子shader 中查找这个标签。
使用不搜索后备的GetTag 可以检视现在使用的是哪个子shader:添加一个自定义具有
不同值的标签到每个子shader,然后再运行时查询这个值。例如,Unity Pro 的水使用这个
函数来检测shader 何时退化为没有反射,然后关闭反射相机。
◆ function GetTexture(propertyNmae: string): Texture
描述:获取一个命名纹理。
数多shader 使用超过一个纹理。使用GetTexture 来获取propertyName 纹理。
Unity 内置着色器使用的普通纹理名称;
"_MainTex"为主散射纹理. 这也能够通过mainTexture 属性访问。
"_BumpMap"为法线贴图。
"_LightMap"为光照贴图。
"_Cube"为发射立方体贴图。
function Start(){
var tex=renderer.material.GetTexture("_BumpMap");
if(tex)
print("My bumpmap is "+ tex.name);
else
print("I have no bumpmap!");
}
参见:mainTexture 属性,SetTexture.
◆ function GetTextureOffset(propertyName: string): Vector2
描述:获取纹理propertyName 的位置偏移。
Unity 内置着色器使用的普通纹理名称;
"_MainTex"为主散射纹理. 这也能够通过mainTextureOffset 属性访问。
"_BumpMap"为法线贴图。
"_LightMap"为光照贴图。
"_Cube"为发射立方体贴图。
参见:mainTextureOffset 属性,SetTextureOffset.
◆ function GetTextureScale(propertyName: string): Vector2
描述:获取纹理propertyName 的位置缩放。
Unity 内置着色器使用的普通纹理名称;
"_MainTex"为主散射纹纹理. 这也能够通过mainTextureOffset 属性访问。
"_BumpMap"为法线贴图。
"_LightMap"为光照贴图。
"_Cube"为发射立方体贴图。
参见:mainTextureScale 属性,SetTextureScale.
◆ function GetVector(propertyName: string): Vector4
描述:获取一个命名向量的值。
在Unity shader 中四组件向量和颜色是相同的。GetVector does exactly the same as
GetColor just the input data type is different(xyzw in the vector becomes rgba in the color).
See Also: GetColor, SetVector.
◆ function HasProperty(propertyName: string): bool
描述:检查材质的shader 是否有给定名称的属性。
参见:mainTextureScale 属性,SetTextureScale.
◆ function Lerp(Start: Material, end: Material, t: float): void
描述:在两个材质间插值属性。
使一个材质的所有颜色和浮点值从start 到end 基于t 来插值。
当t 为0,所有的值为start。
当t 为1,所有的值为end。
通常你想要插值的两个材质是相同的(使用相同的着色器和纹理)除了颜色和浮点值。
然后你使用Lerp 来混合它们。
//混合两个材质
var material1: Material;
var material2: Material;
var duration=2.0;
function Start()
{
//首先使用第一个材质
renderer.material=material[];
}
function Update()
{
//随着时间来回变化材质
var lerp=Mathf.PingPong(Time.time, duration)/duration;
renderer.material.Lerp(material1, materail2, lerp);
}
参见:Material.
◆ function SetColor(propertyName: string, color: Color): void
描述:设置一个命名的颜色值。
数多shader 使用超过一个颜色。使用SetColor 来获取propertyName 颜色.
Unity 内置着色器使用的普通颜色名称;
"_Color"为材质的主颜色. 这也能够通过color 属性访问.
"_SpecColor"为材质的反射颜色(在specular/glossy/vertexlit 着色器中使用).
"_Emission"为材质的散射颜色(用在vertexlit 着色器中).
"_ReflectColor"为材质的反射颜色(用在reflective 着色器中).
function Start(){
//设置Glossy 着色器这样可以使用反射颜色
renderer.material.shader=Shader.Find("Glossy");
//设置红色的高光
renderer.material.SetColor("_SpecColor", Color.red);
}
参见:color 属性,GetColor.
◆ function SetFloat(propertyName: string, value: float): void
描述:设置一个命名的浮点值。
function Start(){
//在这个材质上使用Glossy 着色器
renderer.material.shader=Shader.Find("Glossy");
}
function Start(){
//动画Shininess 值
var shininess=Mathf.PingPong(Time.time, 1.0);
renderer.material.SetFloat("_Shininess, shininess);
}
参见:GetFloat, Materials, ShderLab documentation.
◆ function SetMatrix(propertyName: string, matrix: Matrix4x4): void
描述:为一个shader 设置一个命名矩阵。
这个最常用于自定义的shader,其中需要额外的矩阵参数,矩阵参数不需要在材质检
视面板中公开,但是能够在脚本中通过SetMatrix 和GetMatrix 来设置和查询。
var rotateSpeed=30;
var texture: Texture;
function Start(){
//用于一个着色器创建一个新的材质
//这个着色器旋转纹理
var m=new Material
(
"Shader\"Rotation Texture\"{"+
"Properties{_Main Tex(\"Base",2D)=\"white"{}}"+
"SubShader{"+
"Pass{"+
"Material{Diffuse(1,1,0)Ambient(1,1,1,0)}"+
"Lighting On"+
"SetTexture[_MainTex]{"+
"matrix[_Rotation]"+
"combing texture*primary double.texture"+
"{"+
"}"+
"{"+
"}"
);
m.mainTexture=texture;
renderer.material=m;
}
function Update()
}
//为这个着色器构建一个旋转矩阵并设置它
var rot=Quaternion, Euler(0,0,Time.time*rotateSpeed);
var m=Matrix4x4.TRS(Vector3.zero,rot.Vector3(1,1,1));
renderer.material.SetMatrix(*_Rotation", m);
}
参见:GetMatrix,Materials,ShaderLab documentation.
◆ function SetPass(pass: int): bool
描述:为渲染激活给定的pass.
传递从零开始最大到passCount(但不包含)的索引。
这个最常用在使用GL 类直接绘制的代码中(只能Unity Pro)。例如,Image Effects 使用
材质来实现屏幕后期处理,对材质中的每一个pass 它们激活并绘制一个全屏四边形。
如果SetPass 返回假,你不应该渲染任何东西。
这里是一个全屏图像效果的例子,它反转颜色,添加这个脚本到相机并在播放模式中
查看。
private var mat: Material;
function Start()
{
mat=new Material(
"Shader\"Hidden/Invert\"{"+
"SubShader{"+
"Pass{"+
"ZTest Always Cull Off ZWrite Off"+
"SetTexture[_RenderTex]{combine one-texture}"+
"}"+
"}"+
"}"
);
}
function OnRenderImage(source: RenderTexrure, dest: RenderTexture){
RenderTexture.active=dest;
source.SetGlobalShaderProperty("_RenderTex");
GL.PushMatrix();
GL.LoadOrtho();
//激活第一个pass(这里我们知道它只有仅有的pass)
mat.SetPass(0);
//绘制一个四边形
GL..Begin(GL.QUADS);
GL..TexCoord2(0,0);GL..Vertex3(0,0,0.1);
GL..TexCoord2(1,0);GL..Vertex3(1,0,0.1);
GL..TexCoord2(1,1);GL..Vertex3(1,1,0.1);
GL..TexCoord2(0,1);GL..Vertex3(0,1,0.1);
GL..End();
GL.PopMatrix();
}
参见:passCount 属性,GL 类,ShaderLab documentation.
◆ function SetTexture(propertyName: string, texture: Texture): void
描述:设置一个命名纹理.
数多shader 使用超过一个纹理。使用SetTexture 来改变propertyName 纹理。
Unity 内置着色器使用的普通纹理名称:
"_MainTex"为主射散纹理,这也能够通过mainTexture 属性访问.
"_BumapMap"为法线贴图.
"_LightMap"为光照贴图.
"_Cub"为放射立方体贴图.
//基于实际滚动主纹理
var scrollSpeed=0.5;
function Update(){
var offset=Time.time*scrollSpeed;
rendereer.material.SetTextureOffset("_MatrixTex", Vector2(offset,0));
}
参见:mainTextureOffset 属性,GetTextureOffset.
◆ function SetTextureScale(propertyName: string, scale: Vector2): void
描述:设置纹理propertyName 的位置缩放.
Unity 内置着色器使用的普通纹理名称:
"_MainTex"为主射散纹理,这也能够通过mainTexture 属性访问.
"_BumapMap"为法线贴图.
"_LightMap"为光照贴图.
"_Cub"为放射立方体贴图.
参见:mainTextureScale 属性,GetTextureScale.
function Update()
{
//以一个流行的放式动画主纹理缩放!
var scaleX=Mathf.Cos(Time.time)*0.5+1;
var scaleY=Mathf.Sin(Time.time)*0.5+1;
rendereer.material.SetTextureScale("_MainTex", Vector2(ScaleX,ScaleY));
}
◆ function SetVector(propertyName: string, Vector: Vector4): void
描述:设置一个命名的向量值.
在Unity shader 中四组件向量和颜色是相同的。SetVector 与SetColor 完全相同,仅仅
是输入数据类型不同(向量的xyzw 变为颜色的rgba).
参见:SetColor, GetVector.
继承的成员
继承的变量
name 对象的名称。
hideFlags 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target 不被自动销毁。
Mesh
类,继承自Object
一个类允许你从脚本中创建或修改网格。
网格包含顶点和多个三角形数组。参考Procedural example project 获取石油网格接口的
例子。
三角数组只是顶点索引数组;三个索引为一个三角形。
对于每个顶点可以有一个法线,两个纹理坐标,颜色和切线。这些都是可选的并可以
去掉。所有的顶点信息被存储相同尺寸的不同数组中,因此如果的网格有10 个顶点,你
应该有大小为10 的数组用于法线和其他属性。
可能有三件事,你可能想要使用可调整的网格。
1. 从头开始构建网格:应该总是按照如下的顺序:1)赋值vertices2)赋值triangles
function start(){
var mesh=new Mesh();
GetComponent(MeshFilter).mesh=mesh;
mesh.vertices=newVertices;
nesh.uv=newUV;
mesh.triangles=newTriangles;
}
2. 没帧修改顶点属性:1)获取顶点,2)修改它们,3)将它们赋值回网格.
function Update(){
var mesh: mesh=GetComponent(MeshFilter).mesh;
var vertices=newVertices;
var normals=mesh.normals;
for(var i=0,i<vertices.length,i++)
{
vertices[i]+=mormals{i}*Mathf.Sin(Time.time);
}
mesh.vertices=vertices;
}
3. 连续地改变网格三角形和顶点:1)调用Clear 开始刷心,2)赋值顶点和其他属性,3)

值三角形索引.
在赋值新的顶点或三角形时调用Clear 是重要的。Unity 总是检查提供的三角形索引,
它们是否没有超出顶点边界。电影Clear 然后赋值顶点然后三角形,确保没你没有超出数据

界。
function Update(){
var mesh: mesh=GetComponent(MeshFilter).mesh;
mesh.Clear();
mesh.vertices=newVertices;
nesh.uv=newUV;
mesh.triangles=newTriangles;
}
变量
◆ var bindposes: Matrix4x4[]
描述:绑定的姿势。每个索引的绑定姿势使用具有相同的索引的骨骼。
当骨骼在绑定姿势中时,绑定姿势是骨骼变换矩阵的逆。
function Start(){
gameObject.AddComponent(Animation);
gameObject.AddComponent(SkinnedMeshRenderer);
var renderer: SkinnedMeshRenderer=GetComponent(SkinnedMeshRenderer);
//构建基本网格
var mesh: Mesh-new Mesh();
mesh.vertices=[Vector3(-1,0,0), Vector3(1,0,0), Vector3(-1,5,0), Vector3(1,5,0)];
mesh.uv=[Vector2(0,0), Vector2(1,0), Vector2(0,1), Vector2(1,1)];
mesh.triangles=[0,1,2,1,3,2];
mesh.RecalculateNormals();
//赋网格到网格过滤器和渲染器
renderer.material=new Material(Shader.Find("Diffuse"));
//赋骨骼权值到网格
//使用两个骨骼. 一个用于上部的顶点,一个用于下部的顶点
var weights=new BoneWeight[4];
weights[0].boneIndex0=0;
weights[0].weight0=1;
weights[1].boneIndex0=0;
weights[1].weight0=1;
weights[2].boneIndex0=1;
weights[2].weight0=1;
weights[3].boneIndex0=1;
weights[3].weight0=1;
mesh.boneWeights=weights;
//创建骨骼变换并绑定姿势
//一个骨骼在顶部一个在底部
var bones=new Transform[2];
var bindPoses=new Matrx4x4[2];
bones[0]=new GameObject("Lower").transform;
bones[0]parent=transform;
//设置相对于父的位置
bones[0].localRotation=Quaternion.identity;
bones[0].localPosition=Vector3.zero;
//绑定姿势是骨骼的逆变换矩阵
//在这种情况下我们也要使这个矩阵市相对与根的
//这样我们就能够随意移动根物体了
bindPose[0]=bones[0].worldToLocalMatrix*transform.localToWorldMatrix;
bones[1]=new GameObject("Upper").transform;
bones[1]parent=transform;
//设置相对于父的位置
bones[1].localRotation=Quaternion.identity;
bones[1].localPosition=Vector3.(0,5,0);
//绑定姿势是骨骼的逆变换矩阵
//在这种情况下我们也要使这个矩阵市相对与根的
//这样我们就能够随意移动根物体了
bindPose[1]=bones[1].worldToLocalMatrix*transform.localToWorldMatrix;
.mesh.bindposes=bindPoses;
.//赋值骨骼并绑定姿势
.renderer.bones=bones;
.renderer.sharedMesh=mesh;
//赋值一个简单的挥动动画到底部的骨骼
var curve=new AnimationCurve();
curve.keys=[new Keyframe(0,0,0,0:,new Keyframe(1,3,0,0),new Keyframe(2,0.0,0,0,)];
//使用曲线创建剪辑
var clip=new AnimationClip();
clip.SetCurve("Lower", Transform,"m_LocalPosition.z", curve);
//添加并播放剪辑
animation.AddClip(clip, "test");
animation.Play("test"); }
◆ var boneWeights: BondWeight[]
描述:每个顶点的骨骼权重
数组的大小与vertexCount 相同或为空。
每个顶点可以被至多4 个不同骨骼影响。4 个骨骼的权值加和应该为1,
function Start(){
gameObject.AddComponent(Animation);
gameObject.AddComponent(SkinnedMeshRenderer);
var renderer: SkinnedMeshRenderer=GetComponent(SkinnedMeshRenderer);
//构建基本网格
var mesh: Mesh-new Mesh();
mesh.vertices=[Vector3(-1,0,0), Vector3(1,0,0), Vector3(-1,5,0), Vector3(1,5,0)];
mesh.uv=[Vector2(0,0), Vector2(1,0), Vector2(0,1), Vector2(1,1)];
mesh.triangles=[0,1,2,1,3,2];
mesh.RecalculateNormals();
//赋网格到网格过滤器和渲染器
renderer.material=new Material(Shader.Find("Diffuse"));
//赋骨骼权值到网格
//使用两个骨骼. 一个用于上部的顶点,一个用于下部的顶点
var weights=new BoneWeight[4];
weights[0].boneIndex0=0;
weights[0].weight0=1;
weights[1].boneIndex0=0;
weights[1].weight0=1;
weights[2].boneIndex0=1;
weights[2].weight0=1;
weights[3].boneIndex0=1;
weights[3].weight0=1;
mesh.boneWeights=weights;
//创建骨骼变换并绑定姿势
//一个骨骼在顶部一个在底部
var bones=new Transform[2];
var bindPoses=new Matrx4x4[2];
bones[0]=new GameObject("Lower").transform;
bones[0]parent=transform;
//设置相对于父的位置
bones[0].localRotation=Quaternion.identity;
bones[0].localPosition=Vector3.zero;
//绑定姿势是骨骼的逆变换矩阵
//在这种情况下我们也要使这个矩阵市相对与根的
//这样我们就能够随意移动根物体了
bindPose[0]=bones[0].worldToLocalMatrix*transform.localToWorldMatrix;
bones[1]=new GameObject("Upper").transform;
bones[1]parent=transform;
//设置相对于父的位置
bones[1].localRotation=Quaternion.identity;
bones[1].localPosition=Vector3.(0,5,0);
//绑定姿势是骨骼的逆变换矩阵
//在这种情况下我们也要使这个矩阵市相对与根的
//这样我们就能够随意移动根物体了
bindPose[1]=bones[1].worldToLocalMatrix*transform.localToWorldMatrix;
mesh.bindposes=bindPoses;
//赋值骨骼并绑定姿势
renderer.bones=bones;
renderer.sharedMesh=mesh;
//赋值一个简单的挥动动画到底部的骨骼
var curve=new AnimationCurve();
curve.keys=[new Keyframe(0,0,0,0:,new Keyframe(1,3,0,0),new Keyframe(2,0.0,0,0,)];
//使用曲线创建剪辑
var clip=new AnimationClip();
clip.SetCurve("Lower", Transform,"m_LocalPosition.z", curve);
//添加并播放剪辑
animation.AddClip(clip, "test");
animation.Play("test");
}
◆ var bounds: Bounds
描述:网格的包围体。
这个是在网格的局部坐标空间中轴对齐的包围盒(不会受到变换的影响)参考世界空
间中的Renderer.Bounds 属性。
//产生一个屏幕UV 坐标,这个与网格尺寸无关
//通过缩放包围盒尺寸的顶点
function Start(){
var mesh: Mesh=GetComponent(MeshFilter).mesh;
var.vertices=mesh vertices;
var.uv=new Vector2[vertices.length];
var.bounds=mesh.bounds;
for (var i=0,i<uvs.length;i++){
uvs[i]=Vector2(vertices[i].x/bounds.size.x,vertices[i].z/bounds.size.x);
}
mesh.uv=uvs;
}
参见:Bounds 类,Renderer.Bounds 属性.
◆ var Colors: Color[]
描述:返回网格的顶点颜色。
如果没有顶点颜色可用,一个空的数组将被返回。
//设置y=0 的顶点位红色,y=1 的订单为绿色.
//(注意大多数设置着色器不显示顶点颜色,你可以
//使用例如,一个粒子渲染器来查看顶点颜色)
function Start(){
var mesh: Mesh=GetComponent(MeshFilter).mesh;
var.vertices=mesh vertices;
var.color=new Color[Vertices.Length];
for (var i=0,i<vertices.length;i++){
colors[i]=Color.Lerp(Colored, Color.green, vertices[i].y);
}
mesh.colors=colors;
}
◆ var normals: Vectors[]
描述:网格的法线。
如果网格布包含发行,一个空的数组将被返回。
//以speed 每帧旋转法线
var speed=100.0;
function Update(){
var mesh: Mesh=GetComponent(MeshFilter).mesh;
var.normals=mesh.normals;
var rotation=Quaternion.AngleAxis(Time.deltaTime*speeed, Vector3.up);
for (var i=0,i<normals.length;i++){
normals[i]=rotation*normals[i];
}
mesh.normals=normals;
}
◆ var subMeshCount: int
描述:子网格数。每个材质有一个不同的三角形列表。
◆ var tangents: Vector4[]
描述:网格的切线。
切线主要用于bumpmap shader 中。切线是一个单位长度向量,a 沿着网格表面指向水平
(U)纹理方向。Unity 中的切线是由Vector4 表示的,x.y.z 组件定义向量,如果需要w 用来翻
转副法线。
Unity 通过计算向量和切线之间的叉乘来计算表面的向量(副法线),并乘以
tangnent.w.因此w 应该是1 或-1。
如果你想在网格上使用凹凸贴图着色器,你需要自己计算切线。赋值normals 或使用
RecalculateNormals 之后计算切线。
◆ var tirangles: int[]
描述:一个数组包含网格中所有的三角形。
这个数组时包含顶点数组索引的三角形列表。三角形数组的大小总是3 的倍数。顶点
可以通过简单地索引同一顶点来共享。如果网格包含多个子网格(材质),三角形列表将包
含所有子网格的所有三角形。建议赋值顶点数组之后赋值一个三角形数组,以避免越界错
误。
//构建一个网格,这个网格包含一个带有uv 的三角形.
function start(){
gameObject.AddComponent("MeshFilter);
gameObject.AddComponent("MeshRenderer);
var.mesh: Mesh=GetComponent(MeshFilter).mesh;
mesh.Clear();
mesh.vertices=[Vector3(0,0,0), Vector3(0,1,0), Vector3(1,1,0)];
mesh.uv=[Vector2(0,0), Vector2(0,1), Vector2(1,1)];
mesh.triangles=[0,1,2];
}
◆ var uv: Vector2[]
描述:网格的基本纹理坐标。
//产生一个平面uv 坐标
function start(){
var mesh: Mesh=GetComponent(MeshFilter).mesh;
var vertices=mesh.vertices;
var uvs=new Vector2[vertices.lenghth];
fpr(var i=0;i<uvs.Length,i++){
uvs[i]=Vector2(vertices[i].x, vertices[i].z);
}
mesh.uv=uvs;
}
◆ var uv2: Vector2[]
描述:网格的第二个纹理坐标集,如果提供。
//为第二个uv 集产生一个平面uv 坐标
function start(){
var mesh: Mesh=GetComponent(MeshFilter).mesh;
var vertices=mesh.vertices;
var uvs=new Vector2[vertices.lenghth];
fpr(var i=0;i<uvs.Length,i++){
uvs[i]=Vector2(vertices[i].x, vertices[i].z);
}
mesh.uv2=uvs;
}
◆ var vertexCount: int
描述:网格顶点数(只读)
function start(){
var mesh=GetComponent(MeshFilter).sharedMesh;
print(mesh.vertexCount);
}
◆ var vertices: Vector3[]int
描述:返回一个顶点位置的拷贝或赋值一个新的顶点位置数组。
网格的顶点数可,以通过赋值一个不同数量的顶点数组来改变。注意,如果你调整了
顶点数组,那么所有其他顶点属性(法线,颜色,切线,UV)将被自动地调整大小。设置
顶点时,如果没有顶点被赋值到这个网格那么RecalculateBounds 将自动被调用。
function start(){
var mesh=GetComponent(MeshFilter).sharedMesh;
var vertics=mesh vertices;
fpr(var i=0;i<vertices.Length,i++)
{
vertices[i]+=Vector3.up*Time.deltaTime;
}
mesh.vertices=vertices;
mesh.RecalculateBounds();
}
构造函数
◆ static function Mesh(): Mesh
描述:创建一个空的网格
//创建一个新的网格并将它赋给网格过滤器
function Start(){
var mesh=new Mesh();
GetComponent(MeshFilter).mesh=mesh;
}
函数
◆ function Clear(): void
描述:清除所有的顶点数据和所有的三角形索引。
你应该在重建triangles 数组之间调用这个函数。
◆ function GetTriangles(submesh: int): int[]
描述:返回子网格的三角形列表。
一个子网格仅仅是一个独立的三角形列表。当网格渲染器使用多个材质时,你应该确保
有尽可能多的子网格作为材质。
◆ function Optimize(): void
描述:优化网格以便显示。
这个操作将花费一点时间但是会使几何体显示的更快。例如,它从三角形中产生三角形
带。如果你从头创建一个网格并且想在运行的时候取得更好的运行时性能而不是较高的加
载时间,你应该使用它。它三角带化你的模型为每个顶点缓存位置优化三角形,对于导
载时间,你应该使用它。它三角带化你的模型并为每个顶点缓存位置优化三角形。对于导
入的模型你不应该调用这个,因为导入流水线已经为你做了。
function Start(){
var mesh: Mesh=GetComponent(MeshFilter).mesh;
mesh.Optimize();
}
◆ function RecalculateBounds(): void
描述:从顶点重新计算网格的包围提。
修改顶点之后你应该调用这个函数以确保包围体式正确的。赋值三角形将自动计算
这个包围体。
function Start(){
var mesh: Mesh=GetComponent(MeshFilter).mesh=mesh;
mesh.RecalculateBounds();
}
◆ function RecalculateNormals(): void
描述:从三角形和顶点重新计算网格的法线。
在调整顶点之后通常需要更新法线以便反映这个改变。法线是从所有共享的顶点来计
算的。导入的网格有时并不共享所有顶点。例如在UV 法线接缝处的点将被分割成两个点。

而RecalculateNormals 函数在uv 接缝处将创建不平滑的法线,RecalculateNormals 不会自动
产生切线,因此bumpmap 着色器在调用RecalculateNormals 之后不会工作。然而你可以提
取你自己的切线。
function Start(){
var mesh: Mesh=GetComponent(MeshFilter).mesh;
mesh.RecalculateNormals();
}
◆ function SetTriangles(triangles: int[], submesh: int): void
描述:为子网格设置多边形列表
一个子网格仅仅是一个独立的三角形列表。当网格渲染器使用多个材质时,你应该确保
有尽可能多的子网格作为材质。建议赋值顶点数组之后赋值一个三角形数组,以避免越界
错误。
继承的成员
继承的变量
name 对象的名称
hideFlages 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,缓存或资源。
DestroyImmediate 立即销毁物体obj,强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较连个物体是否不相同。
DomDestroyOnLoad 卸载场景时确保物体target 不被自动销毁。
PhysicsMaterial
类,继承自Object
载体材质描述:如何处理物体碰撞(摩擦,弹性)
参见:Collider
变量
◆ var bounceCombine: PhysicsMaterialCombine
描述:决定弹力是如何组合的。
传统上弹性属性依赖于两种相互接触的材质的组合。然而在游戏中这是不切实的。可以
使用组合模式来调整两个材质的弹性如何被组合。
collider.material.bounceCombine=FrictionCombineMode.Average;
◆ var bouncyness: float
描述:表面的弹力如何?0 值没有弹力。1 值没有能力损失的反弹。
collider.bouncyness=1;
◆ var dynamicFriction: float
描述:移动时候使用的摩擦力。这个值在0 到1 之间。
0 值就像冰,1 像橡胶。
collider.dynamicFriction=1;
◆ var dynamicFriction2: float
描述:如果有向摩擦力被启用,dynamicFriction2 将沿着FrictionDirection2 使用。
collider.physicMaterial.dynamicFriction2=0;
◆ var frictionCombine: PhysicMaterialCombine
描述:决定摩擦力是如何组合的。
传统上摩擦力属性依赖于两种相互接触的材质的组合。然而在游戏中这是不切实的。
你可以使用组合模式来调整两个材质的摩擦力如何被组合。
collider.material.frictionCombine=physicMaterialCombine.Average;
◆ var frictionDirection2: Vector3
描述:有向性方向。如果这个矢量是非零,有向摩擦力被启用。
dynamicFriction2 和staticFriction2 将沿着frictionDirection2 被应用。有向性方向相对于
碰撞器的局部坐标系统。
//使碰撞向前滑动而不是侧滑
collider.physicMaterial.frictionDirection2=Vector3.forward;
collider.physicMaterial.dynamicFriction2=0;
collider.physicMaterial.dynamicFriction=1;
◆ var staticFriction: float
描述:当一个物体静止在一个表面上时使用的摩擦力。通常是0 到1 之间的值。
0 值就像冰,1 像橡胶。
collider.staticFriction=1;
◆ var staticFriction2: float
描述:如果有向摩擦力被启用,staticFriction2 将沿着frictionDirection2 使用。
collider.physicMaterial.staticFriction2=0;
构造函数
◆ static function PhysicMaterial(): PhysicMaterial
描述:创建一个新的材质
通常只使用collider.material 和直接修改附加的材质更加简单。
//创建一个新的材质并附加它
function Start(){
var material=new PhysicMaterial();
material.dynamicfriction=1;
collider.material=material;
}
◆ static function PhysicMaterial(name: string): PhysicMaterial
描述:创建一个新的材质,命名为name.
//创建一个新的材质并附加它
function Start(){
var material=new PhysicMaterial("New Material");
material.dynamicfriction=1
collider.material=material;
}
继承的成员
继承的变量
name 对象的名称
hideFlages 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,缓存或资源。
DestroyImmediate 立即销毁物体obj,强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较连个物体是否不相同。
DomDestroyOnLoad 卸载场景时确保物体target 不被自动销毁
ScriptableObject
类,继承自Object
如果你想创建一个不需要附加到游戏物体的对象,可以从这个类继承、
这对于那些只存储数据资源是组有用的。
消息传递
◆ function OnDisable(): void
描述:当可编辑物体超出范围时调用这个函数
当物体被销毁的时候这个函数也会被调用并可以用于任何清理的代码。当脚本在编译
结束后被加载时,OnDisable 将被调用,然后脚本加载完成后OnDisable 将被调用。
function OnDisable()
{
print(:script was removed");
}
OnDisable 不能作为一个coroutine.
◆ function OnEnable(): void
描述:物体被加载时调用该函数
function OnEnable()
{
print(:script was enabled");
}
OnEnable 不能作为一个coroutine.
类方法
◆ static function CreateInstance(className: string): ScriptableObject
描述:使用className 创建一个可编程物体的实例.
继承的成员
继承的变量
name 对象的名称
hideFlages 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,缓存或资源。
DestroyImmediate 立即销毁物体obj,强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较连个物体是否不相同。
DomDestroyOnLoad 卸载场景时确保物体target 不被自动销毁
GUISkin
类,继承自ScriptableObject
变量
◆ var box: GUIStyle
描述:用于GUI.Box 控件的缺省风格
◆ var button: GUIStyle
描述:用于GUI.Button 控件的缺省风格
◆ var GUIStyle[i]:
描述:
◆ var font: Font
描述:用于所有风格的缺省字体。
◆ var horizontalScrollbar: GUIStyle
描述:
◆ var horizontalScrollbarLeftButton: GUIStyle
描述:
◆ var horizontalScrollbarRightButton: GUIStyle
描述:
◆ var horizontalScrollbarThumb: GUIStyle
描述:
◆ var horizontalSlider: GUIStyle
描述:用于GUI.HorizontalSlider 控件背景部分的缺省风格.
用于决定滑块可拖动区域尺寸的填充属性。
◆ var horizontalSliderThumb: GUIStyle
描述:用于GUI.HorizontalSlider 控件中可拖动滑块的缺省风格.
用于决定滑块尺寸的填充属性。
◆ var label: GUIStyle
描述:用于GUI.Label 控件的缺省风格.
◆ var scrollView: GUIStyle
描述:
◆ var settings: GUISettings
描述:使用这个皮肤的空间如何表现得通用设置。
◆ var textArea: GUIStyle
描述:用于GUI.TextArea 控件的缺省风格。
◆ var textField: GUIStyle
描述:用于GUI.textField 控件的缺省风格。
◆ var toggle: GUIStyle
描述:用于GUI.toggle 控件的缺省风格。
◆ var verticalScrollbar: GUIStyle
描述:
◆ var verticalScrollbarDownButton: GUIStyle
描述:
◆ var verticalScrollbarThumb: GUIStyle
描述:
◆ var verticalScrollbarUpbutton: GUIStyle
描述:
◆ var verticalSlider: GUIStyle
描述:用于GUI.VerticalSlider 控件背景部分的缺省风格.
用于决定滑块可拖动区域尺寸的填充属性。
◆ var verticalSliderThumb: GUIStyle
描述:用于GUI.VerticalSlider 控件中可拖动滑块的缺省风格.
用于决定滑块尺寸的填充属性。
◆ var window: GUIStyle
描述:用于GUI.Windows 控件的缺省风格。
函数
◆ function FindStyle(styleName: string): GUIStyle
描述:获取一个命名GUIStyle.
继承的成员
继承的变量
name 对象的名称
hideFlages 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetInstanceID 返回该物体的实例id。
继承的消息传递
OnEnable 物体被加载时调用该函数
OnDisable 可用编程物体超出范围时调用这个函数
继承的类函数
CreateInstance 使用className 创建一个可编程物体的实例。
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,缓存或资源。
DestroyImmediate 立即销毁物体obj,强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较连个物体是否不相同。
DomDestroyOnLoad 卸载场景时确保物体target 不被自动销毁。
Shader
类,继承自Object
用于所以渲染的着色器脚本
大多数高级的渲染都是通过Material 类控制的. Shader 类类最常用于检查一个着色器时
否能够运行在用户的硬件上(isSupported 属性)并根据名称找到着色器(Find 方法).
参见:Material 类,Materials,ShaderLab documentation.
变量
◆ var isSupported: bool
描述:这个着色器能够运行在端用户的显卡上?(只读)
如果这个着色器重的设置和任何fallback 函数被支持,返回真。在实现特定的效果时,
最常使用这个。例如,Unity Pro 中的image effects,如果这个着色器不被支持那么Unity 将
自动禁用它们。
//如果材质的着色器不被支持,禁用渲染器
if(!renderer material.shader.isSupported)
renderer.enabled=false;
参见:Material 类,ShaderLab documentation.
◆ var maximumLOD: int
描述:该shader 的LOD 等级
参见:Shader Level of Detail, Shder globalMaximumLOD.
◆ var renderQueue: int
描述:这个shader 的渲染队列(只读)
参见:Material.renderQueue, RenderQueue tag.
类变量
◆ static var globalMaximumLOD: int
描述:所有shader 的LOD 等级.
参见:Shader Level of Detail, Shader.MaximumLOD.
类方法
◆ static function Find(name: string): Shader
描述:找到名为name 的着色器。
Shader.Find 能够用来切换到另一个着色器,而不需要保持一个到该着色的引用。name
为材质着色器下拉框中的名称。通常的名称是:"Diffuse", "Bumped Diffuse", "VertexLit",
"Transparent/Diffuse"等等。
在构建时,只包含那些使用中的shader 或位置在"Resources"文件夹中shader。
//从脚本中改变shader
function Start()
{
//切换到透明散射着色器
renderer.material.shader=Shader.Find("Transparent/Diffuse");
}
//从代码创建一个材质
function Start()
//使用透明散射着色器创建一个材质
var material=new Material(Shader.Find("Transparent//Diffuse");
material.color=Color.green;
//赋值这个材质到渲染器
renderer.material=material;
}
参见:Material 类。
◆ static function PropertyToID(name: string): int
描述:为一个着色器属性名获取唯一标识。
着色器属性表示被MaterialPropertyBlock 函数使用。
在Unity 中着色器属性的每个名称都(例如,_MainTex 或_Color)被赋予一个唯一的整型
数,在整个游戏中都不变。
参见:MaterialPropertyBlock.
◆ static function SetGlobalColor(propertyName: string, color: Color): void
描述:为所以着色器设置全局颜色属性。
如果一个着色器需要而材质没有定义它们将使用全局属性(例如,如果着色器不在
Properties 模块中公开它们).
通常在你有一组定义的着色器并使用相同的"全局"颜色(例如,太阳的颜色)。然后
你可以从脚本中设置全局属性,并不需要在所有的材质中设置相同的颜色。
参见:SetGlobalFloat,SetGlobalVector,SetGlobalTexture;Material 类,ShaderLab
documentation.
◆ static function SetGlobalFloat(propertyName: string, value: float): void
描述:为所有着色器设置全局浮点数属性。
如果一个着色器需要而材质没有定义它们将使用全局属性(例如,如果着色器不在
Properties 模块中公开它们).
通常在你有一组定义的着色器并使用相同的"全局"浮点z 数(例如,自定义雾类型的
密度)。然后你可以从脚本中设置全局属性,并不需要在所有的材质中设置相同的浮点数。
参见:SetGlobalColor,SetGlobalTexture;Material 类,ShaderLab documentation.
◆ static function SetGlobalMatrix(propertyName: string, mat: Matrix4x4): void
描述:为所有着色器设置全局矩阵属性。
如果一个着色器需要而材质没有定义它们将使用全局属性(例如,如果着色器不在
Properties 模块中公开它们).
参见:SetGlobalColor,SetGlobalFloat;Material 类,ShaderLab documentation.
◆ static function SetGlobalTexture(propertyName: string, tex: Texture): void
描述:为所有的着色器设置全局纹理属性。
如果一个着色器需要而材质没有定义它们将使用全局属性(例如,如果着色器不在
Properties 模块中公开它们).
通常在你有一组定义的着色器并使用相同的"全局"纹理(例如,自定义散射光照立方
贴图)。然后你可以从脚本中设置全局属性,并不需要在所有的材质中设置相同的纹理。
参见:SetGlobalColor,SetGlobalFloat;Material 类,ShaderLab documentation.
◆ static function SetGlobalVector(propertyName: string, vec: Vector4): void
描述:为所有着色器设置全局向量属性。
如果一个着色器需要而材质没有定义它们将使用全局属性(例如,如果着色器不在
Properties 模块中公开它们).
通常在你有一组定义的着色器并使用相同的"全局"向量(例如,风的方向)。然后你
可以从脚本中设置全局属性,并不需要在所有的材质中设置相同的向量。
参见:SetGlobalFloat,SetGlobalColor,SetGlobalTexture;Material 类,ShaderLab
documentation.
继承的成员
继承的变量
name 对象的名称
hideFlages 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,缓存或资源。
DestroyImmediate 立即销毁物体obj,强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较连个物体是否不相同。
DomDestroyOnLoad 卸载场景时确保物体target 不被自动销毁。
TerrainData
类,继承自Object
TerrainData 类存储高度图,细节网格位置,树实例,和地形纹理alph 图,
Terrain 组件链接地形数据并渲染它。
变量
◆ var heightmapHeight: int
描述:采样的地形高度(只读)
◆ var heightmapWidth: int
描述:采样的地形宽度(只读)
◆ var size: Vector3
描述:地形在世界单位下的总大小
函数
◆ function GetHeights(xBase: int, yBase: int, width: int, height: int): float[,]
描述:获取高度图采样的一个数组。
◆ function GetInterpolatedNormal(x: float, y: float): Vector3
描述:在一个给定的位置获取插值法线。
/x/和y 坐标被作为0...1 之间正规化的坐标被指定。
◆ function SetHeights(xBase: int, yBase: int, height: float): float[,]): void
描述:设置高度图采样的一个数组。
继承的成员
继承的变量
name 对象的名称
hideFlages 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,缓存或资源。
DestroyImmediate 立即销毁物体obj,强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较连个物体是否不相同。
DomDestroyOnLoad 卸载场景时确保物体target 不被自动销毁。
TextAsset
类,继承自Object
文本文件资源。
你可以在你的工程中使用原始的.txt 文件作为资源,并通过这个类获取它们的内容。
变量
描述:文本资源的原始字节
//通过添加.txt 扩展名到文件来加载一个.jpg 或.png 文件
//并拖动它到imageTextAsset
var image TextAsset: TextAsset
function Start(){
var tex=new Texture2D(4,4);
tex.LoadImage(imageTextAsset.bytes);
renderer.material.mainTexture=tex;
}
◆ var text: string
描述:.txt 文件的文本内容作为一个字符串。
var asset: TextAsset;
function Start()
{
print(asset.text);
}
继承的成员
继承的变量
name 对象的名称
hideFlages 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,缓存或资源。
DestroyImmediate 立即销毁物体obj,强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较连个物体是否不相同。
DomDestroyOnLoad 卸载场景时确保物体target 不被自动销毁。
Texture
类,继承自Object
用于处理纹理的基类,包含的功能被Texture2D 和RenderTexture 类共用。
变量
◆ var anisoLevel: int
描述:纹理的各向异性过滤等级
反走样过滤使纹理从一个较小的视角看时具有较好的效果,但是会带来显卡性能上的开
值。通常你可以将它用与地面,地板或路面纹理以使它看起来更好。参见:texture assets.
renderer.material.mainTexture.anisoLevel=2;
◆ var filterMode: FilterMode
描述:纹理的过滤模式
renderer.material.mainTexture.filterMode=FilterMode.trilinear;
参见:FilterMode, texture assets.
◆ var height: int
描述:纹理的像素高度(只读)
//打印纹理尺寸到控制台
var texture: Texture;
function Start(){
print("Size is"+texture.width+"by"+texture.height);
}
◆ var mipMapBias: float
描述:纹理的mipMap 偏移。
一个正的偏移使纹理显得非常模糊,而一个负的偏移使纹理变得更加清晰。注意使用
大的负值会降低性能,因此不建议使用小于0.5 的偏移。在大多数情况先,纹理的锐化可
以通过使用反走样过滤来实现。
参见:texture.anisoLevel, texture assets.
renderer.material.mainTexture.mipMaoBias=0.5;
◆ var width: int
描述:纹理的像素宽度(只读)
//打印纹理尺寸到控制台
var texture: Texture;
function Start(){
print("Size is"+texture.width+"by"+texture.height);
}
◆ var wrapMode: TextureWrapMode
描述:纹理的包裹模式(Repeat 或Clamp)
使用TextureWrapMode.Clamp 在边界上设置纹理剪裁以避免包裹的不真实,或者用
TextureWrapMode.Repeat 平铺纹理。参见:TextureWrapMode, texture assets.
renderer.material.mainTexture.WrapMode=TextureWrapMode.Clamp;
继承的成员
继承的变量
name 对象的名称
hideFlages 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,缓存或资源。
DestroyImmediate 立即销毁物体obj,强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较连个物体是否不相同。
DomDestroyOnLoad 卸载场景时确保物体target 不被自动销毁。
Cubemap
类,继承自Texture
处理立方贴图的类,用这个来创建或修改已有的cube map assets.
变量
◆ var format: TextureFormat
描述:纹理中像素数据的格式(只读)
使用这个确定纹理的格式。
构造函数
◆ static function Cubemap(size: int. format: TextureFormat, mipmap: bool): Cubemap
描述:创建新的空立方贴图纹理;
在每个面,纹理将是size 大小的并且有或没有mipmap.
通常你会想在创建它之后设置纹理的颜色,使用SetPixel 和Apply 函数.
function Start(){
//创建一个新的纹理并将它复制给渲染器材质
var texture=new Cubemap(128, TextureFormat.ARGB32, false)
renderer.material.mainTexture=Texture;
}
参见:SetPixel,Apply 函数.
函数
◆ function Apply(updateMipmaps: bool=true): void
描述:应用所有面前的SetPixel 改变.
如果updateMipMaps 为true.mip 等级也被重新计算.这是非常耗时的操作,因此你要在
Apply 调用之间改变尽可能多的像素。参见:SetPixel 函数.
◆ function GetPixel(face: CubemapFace, x: int, y: int): Color
描述:返回坐标(face, X, Y)处的像素颜色.
如果像素坐标超出边界(大于宽/高或小于0),它将基于纹理的包裹模式来限制或重复。
该函数只工作再ARGB32,RGB24 和Alpha8 纹理格式上。对于其他格式,他总是返
回不透的白色。
◆ function GetPixels(face: CubemapFace, miplevel: int): Color[]
描述:返回立方贴图一个面的像素颜色.
这个函数返回立方贴图面上整个mip 等级的像素颜色数组。
返回的数组被设置在2D 数组中,这里,像素被从左到右,从上到下放置(行序)数
组的大小是所使用的mip 等级的宽乘高。默认的mip 等级是零(基本纹理)在这种情况下
大小仅为纹理的大小。一般地,mip 等级尺寸是mipSize=max(1,width>>miplevel)高度类似。
该函数只工作在ARGB32,RGB24 和Alpha8 纹理格式上。对于其他格式,GetPixels 被
忽略.
使用GetPixels 比重复调用GetPixel 更快,尤其是对于大纹理,此外GetPixels 可以访
问单独的mipmap 等级.
参见:SetPixels,mipmapCount.
◆ function SetPixel(face: CubemapFace, x: int, y: int, color: Color): void
描述:在坐标(face,x,y)处设置像素颜色。
调用Apply 来实际上载改变后的像素到显卡, 上载是非常耗时的操作,因此你要在
Apply 调用之间改变尽可能多的像素。
该函数只工作再ARGB32,RGB24 和Alpha8 纹理格式上。对于其他格式SetPixels 被
忽略. 参见:Apply 函数.
◆ function SetPixels(color: Color[], face: CubemapFace, mipmapFace, miplevel: int): void
描述:设置立方贴图一个面的像素颜色。
这个函数取回并改变整个立方贴图面的像素颜色数组。调用Apply 来实际上载改变后
的像素到显卡.
colors 数组被放置在2D 数组中,这里,像素被从左到右,从上到下放置(行序)数组
的大小必须至少是所使用的mip 等级的宽乘高。默认的mip 等级是零(基本纹理)在这种
情况下大小仅为纹理的大小。一般地,mip 等级尺寸是mipSize=max(1,width>>miplevel)高
度类似。
该函数只工作在ARGB32,RGB24 和Alpha8 纹理格式上。对于其他格式,GetPixels 被
忽略.
参见:GetPixel, Apply, mipmapCount.
继承的成员
继承的变量
name 对象的名称
hideFlages 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,缓存或资源。
DestroyImmediate 立即销毁物体obj,强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较连个物体是否不相同。
DomDestroyOnLoad 卸载场景时确保物体target 不被自动销毁。
MovieTexture
类,继承自Texture
Movie Textures 是可以播放电影的纹理
它们可以用于过场动画电影序列,或者渲染电影到场景中。
变量
◆ var audioClip: AudioClip
描述:返回属于MovieTexture 的AudioClip.
注意这是一个特定的AudioClip 它总是与电影同步播放音频。在编辑器重如果你将电影
的audioClip 附加到一个源上,它将在电影播放的时候自动开始播放,否则你必须收动开
始它,剪辑只能被附加到一个AudioSource。
◆ var isPlaying: bool
描述:返回电影是否在播放
◆ var isReadyToPlay: bool
描述:如果电影是从网站上下载的,这个返回是够已经下载了足够的数据以便能够不同
版的播放它。
对于不是来自web 的流的电影,这个值是返回真。
function Start(){
www=new WWW(url);
guiTexture.texture=www.movie;
}
function Update(){
if(!guiTexture.texture.isPlaying&&guiTexture.texture.isReadyToPlay)
guiTexture.texture.Play();
}
◆ var loop: bool
描述:这个为真时电影循环。
函数
◆ function Pause(): void
描述:暂停播放电影。
function Start(){
renderer.material.mainTexture.Pause();
}
◆ function Play(): void
描述:开始播放电影。
注意运行的MovieTexture 将使用大量的CPU 资源,并且它将持续运行直到它被手、
动停止或加载一个新的关卡。参见:stop
function Start(){
renderer.material.mainTexture.Play();
}
继承的成员
继承的变量
width 纹理的像素宽度(只读)
height 纹理像素高度(只读)
filterMode 纹理的过滤模式
anisoLevel 纹理的各向异性过滤等级
wrapMode 纹理的包裹模式(Repeat 或Clamp)
mipMapBias 纹理的mipMap 便宜。
name 对象的名称
hideFlages 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
描述:渲染纹理的尺寸限制为2 的幂次?
当创建图像后刷处理效果时,你应该总是设置这个为false 因为这允许四面
ReaderTexture 大小问任意屏幕大小。
当为普通的材质和shader 使用RenderTexture 时,你应该总是设置这个为true 因为这允
许像普通纹理一样使用一个RenderTexture.
◆ var useMipMap: bool
描述:生成mipmap 等级?
当设置为true,渲染到这个纹理将创建并生成mipmap 等级面膜人的渲染纹理没有
mipmap.
这个这毙用于2 的幂次方尺寸的渲染纹理(参考isPowerOfTwo).
◆ var width: int
描述:渲染纹理的像素宽度。
注意不像Texture.height 属性,这个是可读写的,设置一个值来改变大小
构造函数
◆ static function ReaderTexture(width: int, height: int, depth: int): ReaderTexture
描述:创建一个新的RenderTexture 对象。
渲染纹理使用width x height 尺寸创建,深度缓存为depth 位(深度可以是0,16 或24)
渲染纹理或设置为非2 的幂次纹理并使用默认的color format
注意创建一个RenderTexture 不会立即创建硬件表示。实际的渲染纹理是第一次使用
是创建或当Create 被手动调用时创建。因此在创建渲染纹理之后,你可以设置额外的变量,

isPowerOfTwo, format, isCubemap 等等。
参见:isPowerOfTwo 变量, format 变量.
函数
◆ function Create(): bool
描述:实际创建RenderTexture。
RenderTexture 构造函数实际上并没有创建硬件纹理:默认的纹理第一次创建时被设置
为active,调用Create 来创建它。如果纹理已经被创建Create 不做任何事。
参见:Release,isCreated 函数.
◆ function IsCreate(): bool
描述:渲染纹理产生了?
RenderTexture 构造函数实际上并没有创建硬件纹理:默认的纹理第一次创建时被设置
为active,如果用于渲染的的硬件资源被创建了,IsCreate 返回ture.
参见:Create,Release 函数.
◆ function Release(): void
描述:释放RenderTexture。
这个函数释放由这个渲染纹理使用的硬件资源,纹理本身并不被销毁,并在使用的时候
被自动再次创建。
参见:Create,IsCreate 函数.
◆ function SetBorderColor(color: Color): void
描述:为这个渲染纹理设置为边框颜色。
如果显卡支持"剪裁到边界",那么任何超出0...1UV 范围的纹理采样将返回边界颜色。
◆ function SetGlobalShaderProperty(propertyName: string): void
描述:赋值这个RenderTexture 为一个名为propertyName 的全局shader 属性。
类变量
◆ static var active: RenderTexture
描述:激活的渲染纹理。
所有的渲染将进入激活的RenderTexture 如果活动的RenderTexture 未null 所有的东西都
被渲染到主窗口.
当你一个RenderTexture 变为激活,如果它还没有被创建,硬件渲染内容将被自动创建。
类方法
◆ static function GetTemporary(width: int, height: int, depthBuffer: int, format:
RenderTextureFormat=RenderTextureFormat.ARGB32): RenderTexture
描述:分配一个临时的渲染纹理。
这个函数被优化,用于当你需呀一个快速RenderTexture 来做一些临时计算时,一旦完
成使用ReleaseTemporary 释放它,这样,如果需要,另一个调用能够开始重用它。
◆ static function ReleaseTemporary(temp: RenderTexture): void
描述:释放一个由GetTemporary 分配的临时纹理。
如果可能,之后调用GetTemporary 将重用前面创建的RenderTexture,如果没有请来临
时RenderTexture,几帧后它将被销毁。
继承的成员
继承的变量
width 纹理的像素宽度(只读)
height 纹理像素高度(只读)
filterMode 纹理的过滤模式
anisoLevel 纹理的各向异性过滤等级
wrapMode 纹理的包裹模式(Repeat 或Clamp)
mipMapBias 纹理的mipMap 便宜。
name 对象的名称
hideFlages 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,缓存或资源。
DestroyImmediate 立即销毁物体obj,强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较连个物体是否不相同。
DomDestroyOnLoad 卸载场景时确保物体target 不被自动销毁。
Texture2D
类,继承自Texture
用于处理纹理的类。使用这个来创建临时的纹理或, 修改已经存在的texture assets
变量
◆ var format: TextureFormat
描述:纹理中像素数据的格式(只读)
使用这个确定纹理的格式。
◆ var mipmapCount: int
描述:在这个纹理中有多少Mipmap 等级(只读)
返回值也包含基本等级,因此他总是1 或更大。
如果你使用GetPixels 或SetPixels 来取回或修改不同的mip 等级时,需要使用
mipmapCount. 例如,你可以改变一个纹理以便每个mip 等级以不同的颜色修改. 然后再游
戏中你可以看到那个mip 等级被实际使用了。
参见:GetPixels 函数,SetPixels 函数。
构造函数
◆ static function Texture2D(width: int, height: int): Texture2D
描述:创建新的空纹理;
纹理为width 乘height 大小,TextureFormat 为ARGB32 带有mipmap.
通常你会想到在创建它之后设置纹理的颜色,使用SetPixel,SetPixels 和Apply 函数。
function Start(){
//创建一个新的纹理并将它赋给渲染器材质
var texture=new Texture2D(128,128);
renderer.material.mainTexture=texture;
}
参见:SetPixel,SetPixels,Apply 函数.
◆ static function Texture2D(width: int, height: int, format: TextureFormat, mipmap: bool):
Texture2D
描述:创建新的空纹理;
纹理为width 乘height 大小,具有给定的format 有或没有miamap.
通常你会想到在创建它之后设置纹理的颜色,使用SetPixel,SetPixels 和Apply 函数。
创建不允许有压缩纹理格式的贴图。
function Start(){
//创建一个新的纹理并将它赋给渲染器材质
var texture=new Texture2D(128,128, TextureFofrmat.AGRB32, false);
renderer.material.mainTexture=texture;
}
参见:SetPixel,SetPixels,Apply 函数.
函数
◆ function Apply(updateMipmaps: bool=true): void
描述:实际地应用前面的SetPixel 和SetPixels 改变.
如果updateMipmaps 为true,mipmap 等级也被重新计算,使用基本等级作为源.通常
你会想在所有的情况下使用true,除非你已经使用SetPixels 修改了mip 等级。
这是非常耗时的操作,因此你要在Apply 调用之间改变尽可能多的像素。
function Start(){
//创建一个新的纹理并赋值它到渲染器材质
var texture=new Texture2D(128,128);
renderer.material.mainTexture=texture;
//用Sierpinski 分形模式填充!
for(y=0; y<texture.height; ++y) {
for(x=0; x<texture.width; ++x) {
var color=(x&y)? Color.white: Color.gray;
texture.SetPixel(x, y, color);
}
}
//应用所有的SetPixel 调用
texture.Apply();
}
参见:SetPixel,SetPixels 函数.
◆ function Compress(highQuality: bool): void
描述:压缩纹理问DXT 格式。
使用这个来压缩在运行时生成的纹理。压缩后的纹理使用较少的显存并可以更快地被
渲染。
压缩之后,如果原始纹理没有alpha 通道纹理将是DXT1 格式,如果它有alpha 通道纹理
将是DXT5 格式.
传递true 到highQuality 将在压缩过程中抖动源纹理,这可以帮助提高压缩质量但是会
有一些慢。
如果显卡不支持压缩或者纹理已经是压缩格式,那么Compress 将不做任何事情。
参见:SetPixels 函数.
◆ function EncodeToPNG(): byte[]
描述:编码这个纹理为PNG 格式。
返回的字节数组是PNG"文件"。你可以将它们写在键盘上以便获取PNG 文件,并通
过网格发送它们。
该函数只工作在ARGB32 和RGB24 纹理格式上。对于ARGB32 纹理编码的PNG 数
据将包含alpha 通道。对于RGB24 纹理不包含alpha 通道。PNG 数据将不包含伽马矫正或

色配置信息。
//存储截屏为PNG 文件。
import System.1();
//立即截屏
function Start(){
UploadPNG();
}
function UploadPNG(){
//只在渲染完成后读取屏幕缓存
yield WaitForEndOfFrame();
//创建一个屏幕大小的纹理,RGB24 格式
var width=Screen.width;
var height=Screen.height;
var tex=new Texture2D(width, height, TextureFormat.RGB24, false);
//读取屏幕内容到纹理
tex ReadPixels(Rect(0, 0, width, height), 0, 0);
tex.Apply();
//编码纹理为PNG 文件
var bytes=tex.EncodeToPNG();
Destroy(tex);
//处于测试目的,也在工程文件夹中写一个文件
//File.WriteAllBytes(Application.dataPath+"/../SavedScreen.png", bytes);
//创建一个Web 表单
var form=new WWWForm();
form.AddField("frameCount", Time.frameCount.ToString());
form.AddBinaryData("fileUpload",bytes);
//上传到一个CGI 脚本
var w=WWW("http://localhost/cgi-bin/env.cgi?post",form);
yield w;
if(w.error!=null)
{
print(w.error);
}
else{
print("Finished Uploading Screenshot");
}
}
参见:ReadPixels, WaitForEndOfFrame, LoadImage.
◆ function GetPixel(x: int, y: int): Color
描述:返回坐标(x, y)处的像素颜色。
如果像素坐标超出边界(大于宽/高或小于0),它将给予纹理的包裹模式来限制或重复。
如果你正在从纹理中读一个大的像素块,使用GetPixels 可能会更快,它将返回整个像
素颜色块。
该函数只工作在ARGB32, RGB24 和Alpha8 纹理格式上。对于其他格式,他总是返
回不透的白色。
//设置变换的y 坐标为跟着高度图
var heightmap: Texture2D;
var size=Vector3(100, 10, 100);
function Update()
{
var x: int=transform.position.x/size.x*heightmap.width;
var z: int=transform.position.z/size.z*heightmap.height;
transform.position.y=heightmap.GetPixel(x,z).grayscale*size.y;
}
参见:GetPixels, SetPixel, GetPixelBilinear.
◆ function GetPixelBilinear(u: float, v: float): Color
描述:返回正规化坐标(u, y)处的过滤像素颜色。
坐标u 和v 从0.0 到1.0,就像网格上的UV 坐标。如果坐标超出边界(大于1 小于0).
它基于纹理的包裹模式来限制或重复。
返回被双线性过滤的像素颜色。
该函数只工作在ARGB32, RGB24 和Alpha8 纹理格式上。对于其他格式,他总是返
回不透的白色。
参见:GetPixel.
◆ function GetPixels(miplevle: int): Color[]
描述:获取一块像素颜色。
这个函数返回纹理整个mip 等级的像素颜色数组。
返回的数组被放置在2D 数组中,这里,像素被从左到右,从上到下放置(行序)数
组的大小是所使用的mip 等级的宽乘高。默认的mip 等级是零(基本纹理)在这种情况下
大小仅为纹理的大小。一般地,mip 等级尺寸是mipWidth-max(1,width>>miplecvel)高度类
似。
该函数只工作在ARGB32, RGB24 和Alpha8 纹理格式上。对于其他格式GetPixels 被忽
略。
使用GetPixels 比重复调用GetPixel 更快,尤其是对于大纹理. 此外,GetPixels 可以访
问单独的mipmap 等级.
参见:GetPixels, mipmapCount.
◆ function GetPixels(x: int, y: int, blockWidth: int, blockHeight: int, miplevel: int): Color[]
描述:获取一块像素颜色。
这个函数是上面GetPixels 函数的扩展;它不会返回整个mip 等级而只是返回开始于x,y
点blockWidth 乘blockHeight 的区域。该块必须适合使用的mip 等级。返回的数组是
blockWidth*blockHeight 尺寸。
◆ function LoadImage(data: byte[]): bool
描述:从一个字节数组中加载一个图片。
这个函数从原始的字节数组中加载一个JPG 和PNG 图片。
//通过添加.txt 扩展名刀文件来加载一个.jpg 或.png 文件
//并拖动它到imageTextAsset
var imageTextAsset: TextAsset;
function Start()
{
var tex=new Texture2D(4,4);
tex.LoadImage(imageTextAsset.bytes);
renderer.material.mainTexture=tex;
}
参见:EncodeToPNG 函数.
◆ function PackTextures(textures: Textures2D[]. padding: int, maximumAtlasSize: int=
2048): Rect[]
参数
textures 纹理数组被打包到集合汇总。
padding 打包纹理的像素间距。
maximumAtlasSize 调整纹理的最大尺寸。
返回Rect[]-一个矩形数组,数组包含每个输入纹理的UV 坐标集合,如果打包失败
为mull。
描述:打包多个textures 到一个纹理集中。
这个函数将使用纹理集替换当前纹理。尺寸,格式和纹理是否有Mipmap 可以在打包后
改变。
生成的纹理集尽可能的大以便适合所有输入的纹理,但是在没有维度上不超过
maximumAtlasSize. 如果输入的纹理不能适合纹理集合的大小,它们将被缩小。
如果所有导入的纹理是DXT1 压缩格式的,纹理集也有DXT1 格式. 如果所有输入纹理
被以DXT1 或DXT5 格式压缩,那么集合将是DXT5 格式。如果任何输入的纹理是没有压
缩的,那么集合将是ARGB32 来压缩格式。
如果输入的纹理没有mipmap,那么集合也将不会有mipmap。
◆ function ReadPixels(source: Rect, destX: int, destY: int, recalculateMipMaps: bool=
true: void
描述:读取屏幕像素到保存的纹理数据中。
这将从当前激活的ReaderTexture 或试图(由/source/指定)拷贝一个矩形像素区域到由
destX 和destY 定义的位置上. 两个坐标都是用像素空间-(0,0)为左下角。
如果recalculateMipMaps 被设置为真,纹理的Mip 贴图也将被更新。如果
recalculateMipMaps 被设置为假,你必须调用Apply 重计算它们.
该函数只工作在ARGB32 和RGB24 纹理格式上。
参见:EncodeToPNG.
◆ function Resize(width: int, height: int, format: TextureFormat, hasMipMap: bool): bool
描述:调整纹理大小。
改变纹理的尺寸为width 乘height,格式为textureFormat 并有选择地创建Mip 贴图.调
整大小后,纹理像素将是未定义的。这个函数非常类似与纹理构造器,除了它工作在已存
在的纹理物体上。
调用Aplly 来实际上载改变后的像素到显卡。
不允许调整压缩纹理格式的大小。
◆ function Resize(width: int, height: int): bool
描述:调整纹理大小。
改变纹理的大小为width 乘height。调整大小后,纹理像素将是未定义的。这个函数
非常类似与纹理构造器,除了它工作在已存在的纹理物体上。
调用Aplly 来实际上载改变后的像素到显卡。
不允许调整压缩纹理格式的大小。
◆ function SetPixel(x: int, y: int, color: Color): void
描述:在坐标(x,y)处设置像素颜色。
调用Aplly 来实际上载改变后的像素到显卡。上载是非常耗时的操作,因此你要在
Apply 调用之间改变尽可能多的像素。
如果你需要在运行时频繁重计算一个纹理,生产一个像素颜色数组并用SetPixels 一次设
置它们,这种方法要快一些。
该函数只工作在ARGN32, RGB24 和Alpha8 纹理格式上。对于其他格式SetPixel 被
忽略。
function Start(){
//创建一个新的纹理并赋值它到渲染器材质
var texture=new Texture2D(128,128);
renderer.material.mainTexture=texture;
//用Sierpinski 分形模式填充!
for(y=0; y<texture.height; ++y) {
for(x=0; x<texture.width; ++x) {
var color=(x&y)? Color.white: Color.gray;
texture.SetPixel(x, y, color);
}
}
//应用所有的SetPixel 调用
texture.Apply(); }
参见:SetPixels,GetPixel, Apply.
◆ function SetPixels(Colors: Color[], miplevel: int): void
描述:设置一块像素颜色。
这个函数取的并改变纹理整个mip 等级的像素颜色数组调用Apply 来实际上载改变
后的像素到显卡.
Colors 数组被放置在2D 数组中,这里,像素被从左到右,从上到下放置(行序)数组
的大小必须至少是所使用的mip 等级的宽乘高。默认的mip 等级是零(基本纹理)在这种
情况下大小仅为纹理的大小。一般地,mip 等级尺寸是mipWidth-max(1,width>>miplecvel)
高度类似。
该函数只工作在ARGB32, RGB24 和Alpha8 纹理格式上。对于其他格式GetPixels 被
忽略。
使用GetPixels 比重复调用GetPixel 更快,尤其是对于大纹理. 此外,GetPixels 可以访问
单独的mipmap 等级.
参见:GetPixels, Apply, mipmapCount.
//这个脚本用不同的颜色修改纹理的Mip 等级
//(第一个等级为红色,第二个为绿色,第三个为蓝色),你可以使用这个来查看
//那个Mip 被实际使用和如何使用.
function Start(){
//赋值原始的纹理并赋值给材质
var texture: Texture2D=Instantiate(Renderer.material.mainTexture);
renderer.material.mainTexture=texture;
//colors 用来修改前3 个mip 等级
var colors=new Colors[3];
colors[0]=Color.red;
colors[1]=Color.green;
colors[2]=Color.blue;
var mipCount=Mathf.Min(3, texture.mipmapCount);
//修改每个Mip 等级
for(var mip=0; mip<mipCount; ++mip){
var cols=texture.GetPixels(mip);
for(var i=0; i<cols.Length; ++i){
cols[i]=ColorLerp(cols[i], colors[mip], 0.33);
}
texture.SetPixel(cols, mip);
}
//实际应用SetPixels,不重新计算mip 等级
texture.Apply(false);
}
◆ function SetPixels(x: int, y: int, blockWidth: int, blochHeight: int, Colors: Color[],
miplevel: int): void
描述:设置一块像素颜色。
这个函数是上面SetPixels 函数的扩展;它不会修改整个mip 等级而只是修改开始于x,y
点blockWidth 乘blockHeight 的区域。该colors 数组必须是blockWidth*blockHeight 大小,

且可修改的块比例适应适应的Mip 等级。
继承的成员
继承的变量
width 纹理的像素宽度(只读)
height 纹理像素高度(只读)
filterMode 纹理的过滤模式
anisoLevel 纹理的各向异性过滤等级
wrapMode 纹理的包裹模式(Repeat 或Clamp)
mipMapBias 纹理的mipMap 便宜。
name 对象的名称
hideFlages 该物体是够被隐藏,保存在场景中或被用户修改?
继承的函数
GetInstanceID 返回该物体的实例id。
继承的类函数
operator bool 这个物体存在吗?
Instantiate 克隆original 物体并返回这个克隆。
Destroy 移除一个游戏物体,缓存或资源。
DestroyImmediate 立即销毁物体obj,强烈建议使用Destroy 代替。
FindObjectsOfType 返回所有类型为type 的激活物体。
FindObjectsOfType 返回第一个类型为type 的激活物体。
operator== 比较两个物体是否相同。
operator != 比较连个物体是否不相同。
DomDestroyOnLoad 卸载场景时确保物体target 不被自动销毁。
Particle
结构
参见:ParticleEmitter,Particles documentation.
变量
◆ var color: Color
描述:粒子的颜色。
颜色的Alpha 通道用来淡出粒子。
参见:Particles documentation.
◆ var energy: float
描述:粒子的能量。
这是粒子生存的时间。当能量低于零时粒子将被销毁。
能量也被用于UV 动画。
如果energy 等于ParticleEmitter.maxEnergy 第一个瓦片将被使用。
如果energy 等于0 最后一个瓦片将被使用。
参见:Particles documentation.
◆ var position: Vector3
描述:粒子的位置。
参见:Particles documentation.
◆ var size: float
描述:粒子的大小。
在世界空间中粒子的尺寸,以来计。
参见:Particles documentation.
◆ var velocity: Vector3
描述:粒子的速度。
如果有一个particel animator 它将根据velocity 移动粒子. 如果Stretch Particles 被设置为
ParticleRenderMode.Stretch,这个速度也被particle render 使用。
参见:Particles documentation.
Path

类方法
◆ static function Combine(path1: string, path2: string): string
描述:
◆ static function GetDirectoryName(path: string): string
描述:
◆ static function GetExtension(path: string): string
描述:
◆ static function GetFileName(path: string): string
描述:
◆ static function GetFileNameWithoutExtension(path: string): string
描述:
Physics

全局屋里属性和辅助方法。
类变量
◆ static var bounceThreshold: float
描述:两个碰撞物体的相对速度对于这个值时将不会反弹(默认为2)。必须为正
这个值可以在Edit->Project Settings->Physics 的检视面板中改变而不是通过脚本。
◆ static var gravity: Vector3
描述:应用到场景所以刚体的重力。
重力可以通过在单体刚体上使用useGravity 属性关闭。
Physics.gravity=Vector3(0,-1,0,0);
◆ static var maxAngularVelocity: float
描述:允许用于任何刚体的缺省最大角速度(默认为7)。必须为正
刚体的角速度最大为maxAngularVelocity 以避免高速旋转物体的数值不稳定性。因为
这也许会阻止企图快速旋转的物体,例如车轮,你可以使用Rigidbody.maxAngularVelocity
逐刚体重载该值。
这个值可以在Edit->Project Settings->Physics 的检视面板中改变而不是通过脚本。
Physics.maxAngularVelocity=10;
◆ static var minPenetrationForPenalty: float
描述:最小的接触渗透值,以便应用一个罚力(默认为0.05)必须为正
这个值可以在Edit->Project Settings->Physics 的检视面板中改变而不是通过脚本。
Physics.minPenetrationForPenalty=0.1;
◆ static var sleepAngularVelocity: float
描述:缺省的角速度。低于该值的物体将开始休眠(默认为0.14)。必须为正
参考Rigidbody Sleeping 获取更多信息。这个值可以使用Rigidbody.sleepAngularVelocity
来逐刚体重载。
这个值可以在Edit->Project Settings->Physics 的检视面板中改变而不是通过脚本。
Physics.sleepAngularVelocity=0.1;
◆ static var sleepVelocity: float
描述:缺省的线性速度,低于改值的物体将开始休眠(默认为0.15)。必须为正。
参考Rigidbody Sleeping 获取更多信息。则会更值可以使用Rigidbody.sleepVelocity 来逐
刚体重载。
这个值可以在Edit->Project Setting->Physics 的检视面板中改变而不是通过脚本
Physics.sleepVelocity=0.1;
◆ static var solverIterationCount: int
描述:允许用于任何刚体的缺省迭代数(默认为7)。必须为正。
solverIterationCount 聚顶关节和接触点如何精确地计算。如果出现链接的物体震荡和行
为怪异,为solver Iteration Count 设置一个较高的值将改善他们的稳定性(但是比较慢)。通
常值7 可以在几乎所有的情况下工作的很好。
这个值可以在Edit->Project Settings->Physics 的检视面板中改变而不是通过脚本.
Physics.solverIterationCount=10;
类方法
◆ static function CheckCapsule(start: Vector3, end: Vector3, radius: float, layermask: int=
kDefaultRaycastLayers): bool
描述:如果有任何碰撞器接触到由世界坐标中的start 和end 构成的轴并具有radius 半
径的胶囊时返回真。
◆ static function CheckSphere(position: Vector3, radius: float, layermask: int=
kDefaultRaycastLayers): bool
描述:如果有任何碰撞器接触到由世界坐标中的position 和radius 定义的球体时返回
真。
◆ static function IgnoreCollision(collider1: collider, collider2: collider, ignore: bool=
true): void
描述:使碰撞检测系统忽略所有collider1 和collider2 之间的任何碰撞。
这是最有用的,如投射物不与发射他们的物体碰撞。
IgnoreCollision 有一些限制:1)它不是持久的. 这个以为着当保存场景时,忽略碰撞
状态将不会存储在编辑器重。2)你只能将忽略碰撞应用到激活物体的碰撞器上. 当不激活
碰撞器或附加的刚体时,IgnoreCollision 将丢失并且你必须再次调用Physics.IgnoreCollision.
//实例化一个子弹并使它忽略与这个物体的碰撞
var bulletPrefab: Transform;
function Start()
{
var bullet=Instantiate(bulletPrefab);
Physics.IgnoreCollision(bullet.collider, collider);
}
◆ static function Linecase(start: Vector3, end: Vector3, layerMask: int=
kDefaultRaycastLayers): bool
描述:如果有任何碰撞器与从start 开始到end 的线段相交时返回真.
var target: Transform;
function Update(){
if(!Physics.Linecast(transform.position, target.position}){
//做一些事情
}
}
当投射射线时,Layer mask 被用来选择性的忽略碰撞器.
◆ static function Linecase(start: Vector3, end: Vector3, out hitInfo: RaycastHit, layerMask:
int=kDefaultRaycastLayers): bool
描述:如果有任何碰撞器与从start 开始到end 的线段相交时返回真.
如果返回真,hitInfo 将包含更多关于碰撞器被碰到什么地方的信息(参考:RaycastHit).
当投射射线时,Layer mask 被用来选择性的忽略碰撞器.
◆ static function OverlapSphere(position: Vector3, radius: float, layerMask: int=
kAllLayers): Collider[]
描述:返回触碰到的或在球体内的所有碰撞器的列表.
注意:当前这个值检查碰撞器的包围体耳不是实际的碰撞器。
◆ static function Raycast(origin: Vector3, direction: Vector3, distance: float=Mathf.Infinity,
layerMask: int=kDefaultRaycastLayers): bool
参数
origin 世界坐标中射线的开始点。
direction 射线的方向。
distance 射线的长度。
layerMask 当投射射线时,layer mask 被用来选择性的忽略碰撞器.
返回:布尔值-当射线碰到任何碰撞器时为真,否则为假.
描述:投射一个射线与场景中的所有碰撞器相交。
function Update(){
var hit: RaycastHit;
var fwd=transform.TransformDirection(Vector3.forward);
if(Physics.Raycast(transform.position, fwd, 10))
{
pring("There is something in front of the object!");
}
}
◆ static function Raycast(origin: Vector3, direction: Vector3, out hitInfo: RaycastHit,
distance: float=Mathf.Infinity, layerMask: int=kDefaultRaycastLayers): bool
参数
origin 世界坐标中射线的开始点。
direction 射线的方向。
distance 射线的长度。
hitInfo 如果返回真,hitInfo 将包含更多关于碰撞器被碰到什么地方的信息(参
考: RaycaseHit).
layerMask 当投射射线时,layer mask 被用来选择性的忽略碰撞器.
返回:布尔值-当射线碰到任何碰撞器时为真,否则为假.
描述:投射一个射线并碰撞场景中的所有碰撞器闭并返回碰撞的细节。
function Update(){
var hit: RaycastHit;
if(Physics.Raycast(transform.position, -Vector3 up, hit)){
distanceToGround=hit.distance;
}
}
//向上投射100 米
function Update()
{
var hit: RaycastHit;
if(Physics.Raycast(transform.position, -Vector3 up, hit, 100.0)){
distanceToGround=hit.distance;
}
}
◆ static function Raycast(ray: Ray, distance: float=Mathf.Infinity, layerMask: int=
kDefaultRaycastLayers): bool
参数
ray 射线的开始点和方向。
distance 射线的长度。
layerMask 当投射射线时,layer mask 被用来选择性的忽略碰撞器.
返回:布尔值-当射线碰到任何碰撞器时为真,否则为假.
描述:同上使用ray.origin 和ray.direction 而不是origin 和direction.
var ray=Camera.main.ScreenPointToRay(Input.mousePosition);
if(Physics.Raycast(ray, 100)){
print("Hit something");
}
◆ static function Raycast(ray: Ray, out hitInfo: RaycastHit, distance: float=Mathf.Infinity,
layerMask: int=kDefaultRaycastLayers): bool
参数
ray 射线的开始点和方向。
distance 射线的长度。
hitInfo 如果返回真,hitInfo 将包含更多关于碰撞器被碰到什么地方的信息(参
考:RaycastHit)
layerMask 当投射射线时,layer mask 被用来选择性的忽略碰撞器.
返回:布尔值-当射线碰到任何碰撞器时为真,否则为假.
描述:同上使用ray.origin 和ray.direction 而不是origin 和direction.
var ray=Camera.main.ScreenPointToRay(Input.mousePosition);
var hit: RaycastHit;
if(Physics.Raycast(ray, hit, 100)) {
Debug.DrawLine(ray.origin, hit.point);
}
◆ static function RaycastAll(ray: Ray, distance: float=Mathf.Infinity, layerMask: int=
kDefaultRaycastLayers): RaycastHit[]
◆ static function RaycastAll(origin: Vector3, direction: Vector3, distance: float=
Mathf.Infinity, layerMask: int=kDefaultRaycastLayers): RaycastHit[]
描述:投射一个穿过场景射线并返回所有的碰撞的东西。
function Update(){
var hit: RaycastHit[];
hits=Physics.RaycastAll(transform.position,transform.forward, 100.0);
//改变所有碰到的碰撞器的材质
//使用一个透明Shader
for(var i=0,i<hits.length,i++) {
var hit: RaycastHit=hits[i];
var renderer=hit collider.renderer;
if(renderer)
{
renderer.material.shader=Shader.Find("Transparent/Diffuse")
renderer.material.color.a=0.3;
}
}
}
Ping

变量
◆ var ip: string
描述:ping 的IP 目标。
◆ var isDone: bool
描述:ping 函数已经完成?
◆ var time: int
描述:在isDone 返回真厚,这个属性包含ping 的时间结果。
构造函数
◆ static function Ping(address: string): Ping
描述:对提供的目标IP 地址执行ping 操作。
这个不执行主机名的DNS 插值,所以它只接受的IP 地址。
Plane
结构
表示一个平面。
平面式由一个法向量和原点到平面的距离定义的。
变量
◆ var distance: float
描述:从原点到平面的距离
构造函数
◆ staic function Plane(inNormal: Vector3, inPoint: Vector3): Plane
描述:创建一个平面
平面具有法线inNormal 并通过inPoint 点,inNormal 不需要被规范化
◆ staic function Plane(inNormal: Vector3,d: float): Plane
描述:创建一个平面
平面具有法线inNormal 和距离d,inNormal 不需要被规范化
◆ staic function Plane(a: Vector3, b: Vector3, e: Vector3): Plane
描述:创建一个平面
屏幕通过给定的三个点
函数
◆ function GetDistanceToPoint(inPt: Vector3): float
描述:从平面到点的距离
◆ function GetSide(inPt: Vector3): bool
描述:一个点是否位于平面的正侧
◆ function Raycast(rayt: Ray, out enter: float): bool
描述:一个射线与平面相交
这个函数设置enter 为沿着射线的距离,这个距离是它与平面相交的位置。如果这个射
线与平面平行,函数返回false 并设置enter 为零。
◆ function SameSide(inPt0: Vector3, inPt1: Vector3): bool
描述:两个点是否在平面的同侧
PlayerPrefsException
类,继承自Exception
这个异常时由PlayerPrefs 类在web 模式时抛出的,表示偏好文件超出了分配的存储空
间.
PlayerPrefs

在游戏会话中保持并访问玩家偏好设置。
在Mac OS X 上PlayerPrefs 存储在-/Library/PlayerPrefs 文件夹,名文unity/[company
name]\[product name].plist,这里company 和product 是在Project Setting 中设置的,相同
的plist 用于在编辑器中运行的工程和独立模式.
在Windows 独立模式下,PlayerPrefs 被存储在注册表的HKCU Software[company
name]\[product name]键下,这里company 和product 是在Project Setting 中设置的.
在Web 模式,PlayerPrefs 存储在Mac OS X 的二进制文件
-/Library/Preferences/Unity/WebPlayerPrefs 中和Windows 的
%APPDATA%\Unity\WebPlayerPrefs 中,一个偏好设置文件对应一个web 播放器URL 并且
文件大小被限制为1 兆。如果超出这个限制,SetInt,SetFloat 和SetString 将不会存储值并

处一个PlayerPrefsException.
类方法
◆ static function DeleteAll(): void
描述:从设置文件中移除所有键和值,谨慎的使用它们。
◆ static function DeleteKey(key: string): void
描述:从设置文件中移除key 和它对应的值.
◆ static function GetFloat(key: string, defaultValue: float=OF): float
描述:返回设置文件中key 对应的值,如果存在.
如果不存在,它将返回defaultValue.
print(PlayerPrefs.GetFlat("Player score"));
◆ static function GetInt(key: string, defaultValue: int): int
描述:返回设置文件中key 对应的值,如果存在.
如果不存在,它将返回defaultValue.
print(PlayerPrefs.GetInt("Player score"));
◆ static function GetString(key: string, defaultValue: string=**): string
描述:返回设置文件中key 对应的值,如果存在.
如果不存在,它将返回defaultValue.
print(PlayerPrefs.GetString("Player Name"));
◆ static function HasKey(key: string): bool
描述:在设置文件如果存在key 则返回真.
◆ static function SetFloat(key: string, value: float): void
描述:设置由key 确定的值.
print(PlayerPrefs.SetFloat("Player Score", 10.0));
◆ static function SetInt(key: string, value: int): void
描述:设置由key 确定的值.
PlayerPrefs.SetInt("Player Score", 10);
◆ static function SetString(key: string, value: string): void
描述:设置由key 确定的值.
PlayerPrefs.Setstring("Player Name", "Foobar");
QualitySettings

用于Quality Settings 的脚本接口.
有六个质量等级可以选择;每个等级的细节都在工程的Quality Settings 中设置,在运行
的时候,当前质量等级可以使用这个类来改变。
类变量
◆ static var currentLevel: QualityLevel
描述:当前图像质量等级。
QualitySettings.currentLevel=QualityLevel.Good;
参见:QualityLevel 枚举,Quality Settings.
◆ static var pixelLightCount: int
描述:影响一个物体的最大像素光源的质量。
如果有更多的光照亮该物体,最暗的一个将作为顶点光源被渲染。
如果你想更好的控制而不是使用质量设置等级,从脚本中使用这个。
//为每个物体使用最多一个像素光
QualitySettings.pixelCount=1;
参见:Quality Settings.
◆ static var softVegetation: bool
描述:使用一个双pass 着色器,用于地形引擎中的植被。
如果启用,植被将有平滑的边缘,如果禁用所有植物将有硬边但是渲染会快两倍。
参见:Quality Settings.
类方法
◆ static function DecreaseLevel(): void
描述:减小当前质量等级。
QualitySettings.DecreaseLevel();
参见:IncreaseLevel, currentLevel, Quality Settings.
◆ static function IncreaseLevel(): void
描述:增加当前质量等级。
QualitySettings.IncreaseLevel();
参见:DecreaseLevel, currentLevel, Quality Settings.
Quaternion
结构
四元组用来表示旋转
它们是紧凑的,不会出现万向节锁能够很容易被插值。Unity 内如使用Quaternion 表示
所有旋转。
然而,它们基于复述的并不容易被理解。因此你没有必要访问或修改Quaternion 组
件(x,y,z,w);最常用的应该是事业已有的旋转(例如,来自Transform)并使用它们来构造
新的旋转(例如,在两个旋转间平滑地插值) .99%的时间你会使用四元组函数(其他函数
仅额
外使用)Quaternion.LookRotation, Quaternion.Angle, Quaternion.Euler, Quaternion.Slerp,
Quaternion.FromToRotation, Quaternion.identity
变量
◆ var eulerAngles: Vector3
描述:返回表示旋转的欧拉角。
返回一个旋转,这个旋转绕着x 轴旋转euler.x 度,绕着y 轴旋转euler.y 度,绕着euler.z
轴旋转euler.x 度。
//创建一个旋转
var rotation=Quaternion.identity;
//赋值一个旋转为绕着y 轴30 度;
rotation.eulerAngles=Vector3(0,30,0);
//打印燃着y 轴的选择
print(rotation.eulerAngles.y);
◆ var this[index: int]: float
描述:分别使用[0], [1],[2],[3]访问x,y,z,w 组件。
Quaternion p;
p[3]=0.5;//与p.w=0.5 相同
◆ var w: float
描述:Quaternion 的W 组件,不要直接修改这个,除非你了解四元组内部
◆ var x: float
描述:Quaternion 的X 组件,不要直接修改这个,除非你了解四元组内部
◆ var y: float
描述:Quaternion 的Y 组件,不要直接修改这个,除非你了解四元组内部
◆ var z: float
描述:Quaternion 的Z 组件,不要直接修改这个,除非你了解四元组内部
构造函数
◆ static function Quaternion(x: float, y: float, z: float, w: float): Quaternion
描述:用给定的x,y,z,w 组件构造新的四元组。
函数
◆ function SetFromToRotation(fromDirection: Vector3, toDirection: Vector3): void
描述:创建一个从fromDirection 到toDirection 的旋转。
◆ function SetLookRotation(view: Vector3, up: Vector3=Vector3.up): void
描述:创建一个旋转,沿着forward 看并且头沿着upwards 向上
如果前向为零将记录一个错误。
◆ function ToAngleAxis(out angle: float, out axis: Vector3): void
描述:转化一个旋转为角度-轴表示。
//提取角度-来自变换选择的轴旋转
var angle=0.0;
var axis=Vector3.zero;
transform.rotation.ToAngleAxis(angle.axis);
◆ function ToString(): string
描述:返回格式化好的这个四元组的字符串。
print(Quaternion.identity):
类变量
◆ static var identity: Quaternion
描述:返回单位旋转(只读). 这个四元组对应与"无旋转":这个物体完全与世界或父的
轴对齐。
transform.rotation=Quaternion.identity;
类方法
◆ static function Angles(a: Quaternion, b: Quaternion): float
描述:返回两个旋转a 和b 之间的角度
//计算这个变换和
//target 之间的角度.
var target: Transform;
function Update()
var angle=Quaternion.Angles(transform.rotation,target.rotation);
◆ static function AnglesAxis(angle: float, axis: Vector3): Quaternion
描述:创建一个旋转绕着axis 轴旋转angle 度。
//设置旋转绕着y 轴旋转30 度
transform.rotation=Quaternion.AnglesAxis(30, Vector3.up);
◆ static function Dot(a: Quaternion, b: Quaternion): float
描述:两个旋转之间的点乘。
print(Quaternion.Dot(transform.rotation, Quaternion.identity));
◆ static function Euler(x: float, y: float, z: float): Quaternion
描述:返回一个旋转,这个旋转绕着x 轴旋转x 度,绕着y 轴旋转y 度,绕着z 轴旋转
z 度。
//绕着y 轴旋转30 度
var rotation=Quaternion.Euler(0,30,0);
◆ static function Euler(euler: Vector3): Quaternion
描述:返回一个旋转,这个旋转绕着x 轴旋转x 度,绕着y 轴旋转y 度,绕着z 轴旋转
z 度。
//绕着y 轴旋转30 度
var rotation=Quaternion.Euler(Vector3(0,30,0));
◆ static function FromToRotation(fromDirection: Vector3, toDirection: Vector3):
Quaternion
描述:创建一个从fromDirection 到toDirection 的旋转.
通常你使用这个来旋转一个变换,这样它的一个周,例如y 轴-遵循世界空间的
toDirection 目标方向。
//设置旋转这样变换的y 轴沿着表面的法线
transform rotation=Quaternion.FromToRotation(Vector3.up, surfaceNormal);
◆ static function Inverse(rotation: Quaternion): Quaternion)
描述:返回rotation 的逆.
//设置这个变换为具有target 的方向旋转
var target: Transform;
function Update()
{
transform.rotation=Quaternion.Inverse(target.rotation);
}
◆ static function Lerp(a: Quaternion, b: Quaternion, t: float): Quaternion
描述:从from 到to 基于t 插值并规范化结果.
这个比Slerp 快但是如果旋转较远看起来就较差。
//在from 到to 之间
//插值旋转.
//(from 和to 不能
//与附加脚本的物体相同)
var from: Transform;
var toL Transform;
var speed=0.1;
function Update()
{
transform.rotation=Quaternion.Lerp(from.rotation, to.rotation, Time.time*speed);
}
◆ static function LookRotation(forward: Vector3, upwards: Vector3=Vector3.up):
Quaternion
描述:创建一个旋转,沿着forward 看并且沿着upwards 向上
如果向前为零将记录一个错误。
//大多数时候你可以使用。
//transform.LookAt 来代替
var target: Transform
function Update()
{
var relativePos=target.position-transform.position;
var rotation=Quaternion.LookRotation(relativePos);
transform.rotation=rotation;
}
◆ static operator!=(lhs: Quaternion, rhs: Quaternion): bool
描述:两个四元组不对等?
这个函数测试两个四元组的点乘是否小于1.0
注意,因为四元组最多可以表示两个全旋转(720 度),这个比较可以返回true 即使产
生旋转看起来一起。
◆ static operator*(lhs: Quaternion, rhs: Quaternion): Quaternion
描述:组合lhs 和rhs 旋转.
首先用lhs 旋转一个点然后用rhs 继续旋转,与使用组合旋转相同。注意旋转不可交换:
lhs*rhs 不等于rhs*lhs.
//应用
//extraRotation 当当前旋转
var extraRotation: Transform;
transform.rotation*=extraRotation.rotation;
◆ static operator*(rotation: Quaternion, point: Vector3): Vector3
描述:用rotation 旋转点point
//沿着relativeDirection 移动物体
//通常你应该使用transform.Move
var relativeDirection=Vector3.forward;
function Update() {
var absoluteDirection=transform.rotation*relativeDirection;
transform.position+=absoluteDirection*Time.deltaTime;
}
◆ static operator==(lhs: Quaternion, rhs: Quaternion): bool
描述:两个四元组相等?
这个函数测试两个四元组的点乘是否接近1.0
注意,因为四元组可以表示最大两个全旋转(720 度),这个比较可以返回false 即使产
生旋转看起来一起。
◆ static function Slerp(from: Quaternion, to: Quaternion, t: float): Quaternion
描述:从from 到to 基于t 的球形插值.
//在from 和to 之间
//插值旋转.
//(from 和to 不能
//与附加脚本的物体相同)
var from: Transform;
var to: Transform;
var speed=0.1;
function Update() {
transform.rotation= Quaternion.Slerp(from.rotation, to.rotation, Time.time*speed);
}
Random

用于生成随机数据的类。
类变量
◆ static var insideUnitCircle: Vector2
描述:返回半径为1 的圆内部的一个随机点(只读)。
//设置这个位置为一个半径为
//5, 中心在零点的圆环内部的一个点.
var newPosition: Vector2=Random.insideUnitCircle*5;
transform.position.x=newPosition.x;
transform.position.y=newPosition.y;
◆ static var insideUnitSphere: Vector3
描述:返回半径为1 的球体内部的一个随机点(只读)。
//设置这个位置为一个半径为5
//中心在零点的球体内部的一个点.
transform.position=Random.insideUnitSphere*5;
◆ static var onUnitSphere: Vector3
描述:返回半径为1 的球体表面上的一个随机点(只读)。
//在一个随机的方向上设置刚体速度为10.
rigidbody.velocity=Random.onUnitSphere*10;
◆ static var rotation: Quaternion
描述:返回s 随机旋转(只读)。
//在世界坐标原点用一个随机旋转实例化一个预设
var prefab: GameObject;
Instantiate(prefab, Vector3.zero., Random.rotation);
◆ static var seed: int
描述:设置随机种子生成器。
◆ static var value: float
描述:返回一个0.0[包含]和1.0[包含]之间的随机数(只读).
0.0 和1.0 会被这个函数返回。
//打印0 到1 之间的值
print(Random.value);
类方法
◆ static function Range(min: float, max: float): float
描述:返回一个随机的浮点数,在min[包含]和max[包含]之间(只读).
//在x-z 平面上的-10 和10 之间的某个位置实例化预设
var prefab: GameObject;
function Start()
{
var position=Vector3(Random Range(-10, 10), 0, Random Range(-10, 10));
Instantiate(prefab.position, Quaternion.identity);
◆ static function Range(min: int, max: int): int
描述:返回一个随机的整数,在min[包含]和max[包含]之间(只读).
如果max 等于min,min 将被返回,返回的值不会是max 除非min 等于max
//从关卡到列表中加载一个随机的关卡
Application.LoadLevel(Random Range(0, Application.levelCount));
Ray
结果
表示射线。
射线时一个无穷线段,开始于origin 并沿着direction 方向。
变量
◆ var direction: Vector3
描述:射线的方向。
方向总是一个规范化的向量。如果你赋值一个非单位化长度,它将被规范化。
◆ var origin: Vector3
描述:射线的起点。
构造函数
◆ static function Ray(origin: Vector3, direction: Vector3): Ray
描述:创建一个射线从origin 开始沿着direction 方向。
//从变换位置开始沿着变换的z 轴创建一个射线
var ray=new Ray(transform.position, transform.forward);
函数
◆ static GetPoint(distance: float): Vector3
描述:返回沿着射线距离为distance 单位的点。
var r: ray;
pting(r.GetPoint(10));//沿着这个射线10 个单位的点
◆ function ToString(): string
描述:返回格式化好的这个射线的字符串
RaycastHit
结构
用来从一个raycase 获取信息的结构。
参见:Physics.Raycast, Physics.Linecast, Physics.RaycastAll.
变量
◆ var barycentricCoordinate: Vector3
描述:所碰到的三角形的重心坐标。
这允许你沿着3 个轴插值任何顶点数据。
//附加这个脚本到相机然后它将
//绘制一个从法线指出的调试直线
function Update(){
//如果碰到物体,继续
var hit: RaycastHit;
if(!Physics.Raycst(Camera.main.ScreenPointToRay(Input.mousePosition), hit))
return;
//以防万一,确保碰撞器也有一个渲染器
//材质和纹理
var meshCollider=hit.collider as MeshCollider;
if(meshCollider==null || meshCollider.sharedMesh=null)
return;
var mesh: Mesh=meshCollider.sharedMesh;
var normals=mesh.normals;
var triangles=mesh.triangles;
//取得所碰到三角形的本地法线
var n0=normals[triangles[hit.triangleIndex*3+0]];
var n1=normals[triangles[hit.triangleIndex*3+1]];
var n2=normals[triangles[hit.triangleIndex*3+1]];
//使用碰撞点的中心坐标来插值
var baryCenter=hit.barycenterCoordinate;
//使用中心坐标插值法线
var interpolatedNormal=n0*baryCenter.x+n1*baryCenter.y+n2*baryCenter.z;
//规范化插值法线
interpolatedNormal=interpolatedNormal.Normalized;
//Transform local space normals to world space
var hitTransform: Transform:=hit.collider.transform;
interpolatedNormal=hitTransform.TransformDirection(interpolatedNormal);
//用Debug.DrawLine 显示
Debug.DrawRay(hit.poing, interpolatedNormal);
◆ var collider: Collider
描述:被碰到的Collider.
如果没有碰到任何东西该属性为null 否则为非null 参见:Physics.Raycast,
Physics.Linecast, Physics.RaycastAll.
◆ var distance: float
描述:从射线的原点到碰撞点的距离。
参见:Physics.Raycast, Physics.Linecast, Physics.RaycastAll.
◆ var normal: Vector3
描述:射线所碰到的表面的法线。
参见:Physics.Raycast, Physics.Linecast, Physics.RaycastAll.
◆ var point: Vector3
描述:在世界空间中,射线碰到碰撞器的碰撞点。
参见:Physics.Raycast, Physics.Linecast.
◆ var rigidbody: Rigidbody
描述:碰到的碰撞器的Rigidbody. 如果该碰撞器没有附加刚体那么它为null。
参见:Physics.Raycast, Physics.Linecast, Physics.RaycastAll.
◆ var textureCoord: Vector2
描述:碰撞点的UV 纹理坐标。
这个可用于3D 纹理绘制或绘制弹痕。如果碰撞器时非网格碰撞器,零Vector2 将被返
回.
//附加这个脚本到相机,当用户点击时
//它将在3D 中绘制黑色的像素. 确保你想绘制的网格附加有
//一个网格碰撞器.
function Update()
(
//只有当我们按下鼠标
if(!input.GetMouseButton(0))
return;
//只有碰到某些东西,继续
var hit: RaycastHit;
if(!Physics.Raycast(camera.ScreenPointToRay(Input.mousePosition), hit))
return;
/以防万一,还要确保碰撞器也有一个渲染器
//材质和纹理.我们也应该忽略几何体碰撞器.
var renderer: Renderer=hit.collider.renderer;
var meshCollider=hit.collider as MeshCollider;
if(renderer==null || renderer.sharedMaterial==null || renderer.sharedMaterial.mainTexture==null ||
meshCollider==null)
return;
//现在在我们碰到的物体上绘制一个像素
var tex: Texture2D=renderer.material.mainTexture;
var pixelUV=hit.textureCoord;
pixelUV.x*=tex.width;
pixelUV.y*=tex.height;
tex.SetPixel(pixelUV.x, pixelUV.y, Color.black);
tex.Apply();
}
参见:Physics.Raycast, Physics.Linecast, Physics.RaycastAll.
◆ var textureCoord2: Vector2
描述:碰撞点的第二个UV 纹理坐标。
这个可用于3D 纹理绘制或绘制弹痕。如果碰撞器时非网格碰撞器,零Vector2.zero 将被
返回.如果网格没有包含第二个uv 集,主uv 集将被返回。
//附加这个脚本到相机,当用户点击时
//它将在3D 中绘制黑色的像素. 确保你想绘制的网格附加有
//一个网格碰撞器.
function Update()
(
//只有当我们按下鼠标
if(!input.GetMouseButton(0))
return;
//只有碰到某些东西,继续
var hit: RaycastHit;
if(!Physics.Raycast(camera.ScreenPointToRay(Input.mousePosition), hit))
return;
/以防万一,还要确保碰撞器也有一个渲染器
//材质和纹理.我们也应该忽略几何体碰撞器.
var renderer: Renderer=hit.collider.renderer;
var meshCollider=hit.collider as MeshCollider;
if(renderer==null || renderer.sharedMaterial==null || renderer.sharedMaterial.mainTexture==null ||
meshCollider==null)
return;
//现在在我们碰到的物体上绘制一个像素
var tex: Texture2D=renderer.material.mainTexture;
var pixelUV=hit.textureCoord2;
pixelUV.x*=tex.width;
pixelUV.y*=tex.height;
tex.SetPixel(pixelUV.x, pixelUV.y, Color.black);
tex.Apply();
}
参见:Physics.Raycast, Physics.Linecast, Physics.RaycastAll.
◆ var triangleIndex: int
描述:碰到的三角形的索引.
如果被击中的碰撞器时一个MeshCollider 三角形索引才可用.
//附加这个脚本到相机然后它将
//绘制一个调试直线三角形
//在我们放置鼠标的三角形上
function Update()
(
//如果我们击中了某物,继续
var hit: RaycastHit;
if(!Physics.Raycast(camera.ScreenPointToRay(Input.mousePosition), hit))
return;
/以防万一,确保碰撞器也有一个渲染器
//材质和纹理
var meshCollider=hit.collider as MeshCollider;
if(meshCollider==null ||meshCollider.sharedMesh==null)
return;
var mesh: Mesh=meshCollider.sharedMesh;
var vertices=mesh.vertices;
var triangles=mesh.triangles;
//取回碰到的本地坐标点
var p0=vertices[triangles[hit.triangleIndex*3+0]];
var p1=vertices[triangles[hit.triangleIndex*3+1]];
var p2=vertices[triangles[hit.triangleIndex*3+1]];
//交换本地空间点到世界空间
var hitTransform: transform=hit.collider.transform;
p0=hitTransform.TransformPoint(p0);
p1=hitTransform.TransformPoint(p1);
p2=hitTransform.TransformPoint(p2);
//用Debug.DrawLine 显示
Debug.DrawLine(p0, p1);
Debug.DrawLine(p1, p2);
Debug.DrawLine(p2, p0);
}
参见:Physics.Raycast, Physics.Linecast, Physics.RaycastAll.
RectOffset

用于矩形,边界等的偏移。
被GUIStyle 用在所有地反。
变量
◆ var bottom: int
描述:底部边缘的尺寸。
◆ var horizontal: int
描述:left+right 的快捷方式(只读)。
◆ var left: int
描述:左边边缘的尺寸。
◆ var right: int
描述:右边边缘的尺寸。
◆ var top: int
描述:顶部边缘的尺寸。
◆ var vertical: int
描述:top+bottom 的快捷方式(只读)
函数
◆ function Add(rect: Rect): Rect
描述:向一个rect 中添加边界偏移。
◆ function Remove(rect: Rect): Rect
描述:从一个rect 中移除边界偏移。
Rect
结构
由x,y 位置和width,height 定义的2D 矩阵
Rect 结构主要用于2D 操作;UnityGUI 系统广泛的使用它,也可用来在屏幕上定位相机
参见:GUIScripting.Guide, Camera.rect, Camera.pixelRect.
变量
◆ var height: float
描述:矩形的高。
var rect=Rect(0,0,10,10);
print(rect.height);
rect.height=20;
◆ var width: float
描述:矩形的宽。
var rect=Rect(0,0,10,10);
print(rect.width);
rect.width=20;
◆ var x: float
描述:矩形的左侧坐标。
◆ var xMax: float
描述:矩形的右侧坐标
改变这个值将保持矩形的左边(这样宽度也将改变)
◆ var xMin: float
描述:矩形的左侧坐标
改变这个值将保持矩形的右边(这样宽度也将改变)
◆ var y: float
描述:矩形的顶部坐标。
var rect=Rect(10,10,100,100);
print(rect.y);
rect.x=20;
◆ var yMax: float
描述:矩形的底部坐标。
改变这个将保持矩形的顶边(这样高度也将改变)
◆ var yMin: float
描述:矩形的顶部坐标。
改变这个将保持矩形的底边(这样高度也将改变)
构造函数
◆ static function Rect(left: float, top: float, width: float, height: float): Rect
描述:创建一个新的矩形
var rect=Rect(0,0,10,10);
函数
◆ function Contains(point: Vector2): bool
◆ function Contains(point: Vector3): bool
描述:如果point 的x 和y 位于矩阵的内部
//当坐标???
function Update()
{
var rect=Rect(0,0,150,150);
if(rect Contains(Input.???Position))
print("Inside")
}
◆ function ToString(): string
描述:返回格式化好的Rect 字符串、
var rect=Rect(0,0,10,10);
print(rect);
类方法
◆ static function MinMaxRect(left: float, top: float, right: float, bottom: float): Rect
描述:根据min/max 坐标值创建一个矩形。
◆ static operator!=(lhs: Rect, rhs: Rect): bool
描述:如果矩形不相同返回真。
◆ static operator==(lhs: Rect, rhs: Rect): bool
描述:如果矩形相同返回真。
RenderSettings

Render Settings 包含用于场景中可视元素范围的缺省值,如雾和环境光。
参见:Render Settings manager
类变量
◆ static var ambientLight: Color
变量
◆ var height : int
描述: 解析度的像素高度。
◆ var width : int
描述: 解析度的像素宽度。
◆ var refreshRate : int
描述: 解析度的垂直刷新率Hz。
Resources

Resources 类允许你按照它们的路径名找到并加载物体。
所有位于Assets 文件夹下名“Resources”的文件夹中的资源,都可以Resources.Load
函数访问,
在Unity 中你通常不需要使用路径名来访问资源,相反你可以通过声明一个成员变量
来公开到一个资源的应用,然后在检视面板中给它赋值。使用这个技巧的时候Unity 可以在构
建的时候自动计算哪个资源被使用。这从根本上最大限度地减少了实际用于游戏的资源的尺
寸。当你放置资源在“Resources”文件夹中时这个不会这么做,因此所有在“Resources”文件夹
中的资源都将被包含在游戏中。
另一个使用路径名的缺点是,缺乏可重用性,因为脚本对于使用的资源具有硬编码要求。另
一方面使用公开在检视面板中的引用,是自文档化的,对于使用你脚本的用户来说也是显而
易见的。
然而,有些情况下按照名称而不是在检视面板中取回一个资源是更方便的。尤其是当在检视
面板中赋值引用是不方便的时候。例如你或许想从脚本创建一个游戏物体,为程序生成的网
格赋值一个纹理。
var go = new GameObject.CreatePrimitive(PrimitiveType.Plane);
go.renderer.marerial.mainTexture = Resources.Load("glass");
类方法
◆ static function Load(path : string) : Object
描述: 加载储存在Resources 文件夹中的path 处的资源。
如果在path 处发现这个资源返回它,否则返回null。Path 相对于Resources 文件夹,扩展名必
须被忽略。Resources 文件夹可以在Assets 文件夹中的任何位置。
//附加一个名为"Assets/Resources/glass"的纹理到Plane.
function Start() {
var go = new GameObject.CreatePrimitive(PrimitiveType.Plane);
go.renderer.material.mainTexture = Resources.Load("glass");
}
//实例化路径"Assets/Resources/enemy"处的一个预设
function Start () {
var instance : GameObject = Instantiate(Resources.Load("enemy"));
}
◆ static function Load ( path : String, type : Type) : Object
描述: 加载储存在Resources 文件夹中path 处的资源。
如果在path 处发现这个资源就返回它,否则返回null。只有type 类型的物体将被返回. Path
相对于Resources 文件夹,扩展名必须被忽略。Resouces 文件夹可以在Assets 文件夹中的任
何位置。
//附加一个名为”glass”的纹理到Plane
function Start () {
var go = new GameObject.CreatePrimitive(PrimitiveType.Cube);
go.renderer.material.main.Texture = Resources.Load(“glass”, Texture2D);
}
//实例化名为”Resources/enemy”的一个预设
function Start () {
var instance : GameObject = Instantiate(Resources.Load(“enemy”, GameObject);
}
◆ static function LoadAll (path : String, type : Type) : Object[]
描述: 加载Resources 文件夹中的path 文件夹或者文件中的所有资源。
如果path 是一个文件夹,文件中的所有资源都将被返回。如果path 为一个文件,只有这个
资源将被返回。只有type 类型的物体将被返回。Path 相对于Resources 文件夹。Resources
文件夹可以在Assets 文件夹中的任何位置。
//加载”Resources/Texture”文件夹中所有资源
//然后从列表中选择随机的一个
function Start () {
var go = new GameObject.CreatePrimitive(PrimitiveType.Cube);
var textures : Object[] = Resources.LoadAll(“Textures”, Texture2D);
var texture : Texture2D = textures[Random.Range(0, textures.Length)];
go.renderer.material.mainTexture = texture;
}
◆ static function LoadAll (path : String) : Object[]
描述: 加载Resources 文件夹中的path 文件夹或者文件中的所有资源。
如果path 是一个文件夹,文件中的所有资源都将被返回。如果path 为一个文件,只有这个
资源将被返回。只有type 类型的物体将被返回。Path 相对于Resources 文件夹。Resources
文件夹可以在Assets 文件夹中的任何位置。
//加载”Resources/Texture”文件夹中所有资源
//然后从列表中选择随机的一个
function Start () {
var go = new GameObject.CreatePrimitive(PrimitiveType.Cube);
var textures : Object[] = Resources.LoadAll(“Textures”);
var texture : Texture2D = textures[Random.Range(0, textures.Length)];
go.renderer.material.mainTexture = texture;
}
◆ static function LoadAssetAtPath (assetPath : String, type : Type) : Object
描述: 返回资源路径上的一个资源(只在编辑器中)。
在独立版或者web 版中这个函数总是返回null。这个可以用来快速访问一个在编辑器中使用
的资源。
var prefab : GameObject;
function Start () {
prefab = Resources.LoadAssetAtPath(“Assets/Artwork/mymodel.fbx”, GameObject);
}
Screen

访问显示信息。
屏幕类用来获取支持的解析度列表,切换当前分辨率,隐藏或显示系统的鼠标指针。
类变量
◆ static var currentResolution : Resolution
描述: 当前屏幕的解析度。
如果播放器运行在窗口模式,这将返回当前左面的解析度。
print(Screen.currentResolution);
◆ static var fullScreen : bool
描述: 游戏是否运行在全屏模式下?
通过改变这个属性来切换全屏模式。
//切换全屏
Screen.fullScreen = !Screen.fullScreen;
参见: SetResolution。
◆ static var height : int
描述: 屏幕窗口的当前像素高度(只读)。
播放窗体的实际高度(在全屏模式下也是当前的分辨率高度)
◆ static var lockCursor : bool
描述: 光标是否被锁定?
光标将被自动隐藏、居中并且不会离开这个视点。
在web 播放器中光标只在用户点击内容并且用户的鼠标没有离开内容视图的时候锁定。用
户按下escape 或切换到其他应用程序时光标将被自动锁定。当退出全屏模式时,光标锁定
也将丢失。通过检查lockCursor 状态,你可以查询光标当前是否被锁定。为了提供一个好的
用户体验,建议只在用户按下按钮的时候锁定光标。你也应该光标是否解锁,例如暂停游戏
或者打开游戏菜单。在web 播放器和编辑器中,当你按下escape 时光标将自动被解锁。在
独立播放模式下你有完全的鼠标锁定控制权,因此它不会自动释放鼠标锁定,除非你切换应
用程序。
//当鼠标被锁定时调用
function DidLockCursor () {
Debug.Log(“Locking cursor”);
//禁用按钮
guiTexture.enabled = false;
}
//当光标被解锁时调用
//或被脚本调用Screen.lockCursor = false;
Function DidUnlockCursor () {
Debug.Log(“Unlocking cursor”);
//再次显示按钮
guiTexture.enabled = true;
}
function OnMouseDown () {
//锁定光标
Screen.lockCursor = true;
}
private var wasLocked = false;
function Update () {
//在独立模式下我们需要提供自己的键来锁定光标
If(Input.GetKeyDown(“escape”)
Screen.lockCursor = false;
//我们失去了鼠标锁定?
//例如因为用户按下escape 键或因为他切换到了其他应用程序
//或者因为一些脚本设置Screen.lockCursor = false;
If(!Screen.lockCursor && wasLocked) {
wasLocked = false;
DidUnlockCursor();
}
//再次获得光标锁定?
else if(Screen.lockCursor && wasLocked) {
wasLocked = true;
DidLockCursor();
}
}
◆ static var resolutions : Resolution[]
描述: 该显示器支持的所有全屏解析度(只读)
返回的解析度按照宽度排序,较低的解析度位于前面。
var resolutions : Resolutions[] = Screen.resolutions;
//打印解析度
for(var res in resolutions) {
print(res.width + “x” + res.height);
}
//切换到支持的最低全屏解析度
Screen.SetResolution(resolutions[0].width, resolutions[0].height, true);
参见: Resolution 结构, SetResolution。
◆ static var showCursor : bool
描述: 光标是否可见?
完全可以实现一个自定义的光标而不是系统的。要做到这一点,你要隐藏系统的,然后跟
踪位置或移动并在需要的位置显示你自己的图片。
//隐藏光标
Screen.showCursor = false;
◆ static var width : int
描述: 屏幕窗口的当前像素宽度(只读)。
播放窗体的实际宽度(在全屏模式下也是当前的分辨率宽度)
类方法
◆ static function SetResolution (width : int, height : int, fullscreen : bool, preferredRefreshRate :
int) : void
描述: 切换屏幕的解析度。
Width x height 解析度将被使用。如果没有匹配的解析度支持,最近的一个将被使用。
如果preferredRefreshRate 为0 (默认),Unity 将切换到显示器支持的最高刷新率。
如果preferredRefreshRate 不是0,如果显示器支持Unity 将使用它,否则将选择所支持的
最高的一个。
在web 播放器中你只需要在用户点击内容之后切换分辨率。推荐的方法是只在用户点击指
定按钮的时候切换分辨率。
//切换成640 x 480 全屏模式
Screen. SetResolution(640, 480, true);
//切换成640 x 480 全屏模式60hz
Screen. SetResolution(640, 480, true, 60);
//切换成800 x 600 窗口模式
Screen. SetResolution(800, 600, false);
参考: resolution 属性。
SoftJointLimit
结构
这限制是由CharacterJoint 定义的。
变量
◆ var bouneyness : float
描述: 当关节到达这个限定时,它可以使其弹回。
bouneyness 决定弹回的限制,范围{0, 1};
◆ var damper : float
描述: 如果弹力大于0,限制被减缓。
这是弹簧的z 阻力,范围{0, 无穷};
◆ var limit : float
描述: 关节的位置/角度限制。
◆ var spring : float
描述: 如果大于零,限制被减缓。弹簧将推回该关节。{0, 无穷}
String

表示一系列Unicode 字符文本。
变量
◆ var Length : int
描述: 获取该实例中字符的数量。
◆ var String : static
描述: 初始化一个新的实例化String 类,它的值为一个新的Unicode 字符数组。数组开始
字符的位置,和一个长度。表示一个空的字符串,这个域是只读的。
SystemInfo

类变量
◆ static var graphicsDeviceName : string
描述: 显示设备的名称(只读)。
这个是用户显卡的名称,由显卡设备驱动报告。
//打印”ATi Raedon X1600 OpenGL Engine”在MacBook Pro OS X 10.4.8 上
print(SystemInfo.graphicsDeviceName);
参见: SystemInfo.graphicsDeviceVendor, SystemInfo.graphicsDeviceVersion.
◆ static var graphicsDeviceVendor : string
描述: 显示设备的生产厂商(只读)。
这个是用户显卡的生产厂商,由显卡设备驱动报告。
//打印”ATi Technologies Inc.” 在MacBook Pro OS X 10.4.8 上
print(SystemInfo.graphicsDeviceVendor);
参见: SystemInfo.graphicsDeviceName, SystemInfo.graphicsDeviceVersion.
◆ static var graphicsDeviceVersion : string
描述: 该显示设备所支持的图形API 版本(只读)。
这个是用户显卡设备所支持的底层图形API 版本。
如果是OpenGL API,返回字符串包含”OpenGL”然后是”major.minor”格式的版本号,然后
在方括号中试完整的版本号。
如果是Direct3D9 API,返回的字符串包含”Direct3D 9.0c”,然后再方括号中试驱动名称和
版本号。
//打印”OpenGL 2.0[2.0 ATi-1.4.40]”在MacBook Pro OS X 10.4.8 下。
//打印”Direct3D 9.0c[atiumdag.dll 7.14 10.471]”在MacBook Pro/ Windows Vista 下。
print(SystemInfo.graphicsDeviceVersion);
参见: SystemInfo.graphicsDeviceName, SystemInfo.graphicsDeviceVendor.
◆ static var graphicsMemorySize : int
描述: 显存的大小(只读)。
这个是以兆(MB)计算的显存容量。
◆ static var supportsImageEffects : bool
描述: 是否支持图像效果?(只读)
如果显卡支持后期处理特效则返回true。
参见: Image Effects。
◆ static var supportsRenderTexture : bool
描述: 是否支持渲染到纹理?(只读)
如果显卡支持渲染到纹理则返回true。使用SupportsRenderTextureFormat 来检查支持的特
定渲染纹理格式。
参见: Render Texture assets,RenderTexture 类。
◆ static var supportsShadows : bool
描述: 是否支持内置阴影?(只读)
如果显卡支持内置阴影则返回true。
参见: Shadows doucumentation。
类方法
◆ static function SupportsRenderTextureFormat (format : RenderTextureFormat) : bool
描述: 是否支持该渲染纹理格式?
如果显卡支持指定的RenderTextureFormat 格式,返回true。
参见: Render Texture assets,RenderTexture 类。
Time

从Unity 中获取时间的接口。
类变量
◆ static var captureFramerate : int
描述: 如果captureFramerate 被设置为大于0 的值,时间将为(1.0/ captureFramerate)每帧而
不考虑实际时间。如果想用一个固定的帧率捕获一个视频时可以使用这个。
Time. captureFramerate = 25;
◆ static var deltaTime : float
描述: 用于完成最后一帧的时间(只读)。
如果你加或减一个每帧改变的值,你应该将它与deltaTime 相乘。当你乘以Time.deltaTime
时,你实际表达:我想以10 米/秒移动这个物体而不是10 米/帧。
在MonoBehaviour 的FixedUpdate 内部调用时,返回固定帧率增量时间。
function Update () {
var translation = Time.deltaTime * 10;
transform.Translate(0, 0, translation);
}
◆ static var fixedDeltaTime : float
描述: 物理和其他固定帧率更新(如MonoBehaviour 的FixedUpdate)以这个间隔来执行。
建议使用Time.deltaTime 代替,因为如果在FixedUpdate 函数或Update 函数内部它将自动
返回正确的增量时间。
注意fixedDeltaTime 间隔对应的游戏时间会受到timeScale 的影响。
◆ static var fixedTime : float
描述: 最后一次FixedUpdate 调用已经开始的时间(只读)。这个是以秒计的游戏开始的时间。
固定时间以定期的间隔来更新(相当于fixedDeltaTime)直到到达了time 属性。
◆ static var frameCount : int
描述: 已经传递的帧总数(只读)。
//确保RecaloulateValue 在每帧中只执行一次某些操作
static private var lastRecaloulation = -1;
static function RecaloulateValue () {
if(lastRecaloulation == Time.frameCount)
return;
PerformSomeCalculations();
}
◆ static var realTimeSinceStartup : float
描述: 从游戏开始的实时时间(只读)。
在大多数情况下你应该使用Time.time。
realTimeSinceStartup 返回从开始到现在的时间,不会受到Time.timeScale 的影响。当玩家
暂停的时候realTimeSinceStartup 也会增加(在后台)。使用realTimeSinceStartup 时很有用的,
当你想通过设置Time.timeScale 为0 来暂停游戏,但还在某些时候使用时间。
注意realTimeSinceStartup 返回的时间是来源于系统计时器,根据不同平台和硬件,也许会
在一些连贯的帧上报告相同的时间。如果通过不同的时间来区分不同的事情,需要考虑这个
(时间的差别可能变为零!)。
//打印从开始到现在的真实时间
print(Time.realTimeSinceStartup);
//一个FPS 计数器,在每个updateInterval 间隔处计算帧/秒,这样显示就不会随意的改变。
var updateInterval = 0.5;
private var last Interval : double; //最后间隔结束时间
private var frames = 0;//超过当前间隔帧
private fps : float; //当前fps
function Start () {
lastInterval = Time. realTimeSinceStartup;
frames = 0;
}
function OnGUI () {
//显示两位小数
GUILayout.xxxx(“” + fps.ToString(“F2”);
}
function Update () {
++frames;
var timeNow = Time.realtimeSinceStartup;
if(timeNow > lastInterval + updateInterval) {
fps = frames / (timeNow – lastInterval);
frames = 0;
lastInterval = timeNow;
}
}
◆ static var smoothDeltaTime : float
描述: 一个平滑的Time.deltaTime(只读)。
◆ static var time : float
描述: 该帧开始的时间(只读)。从游戏开始到现在的时间。
在MonoBehaviour 的FixedUpdate 内部调用时,返回fixedTime 属性。
//如果Fire1 按钮(默认为Ctrl)被按下,每0.5 秒实例化一个projectile。
var projectile : GameObject;
var fireRate = 0.5;
private var nextFire = 0.0;
function Update () {
if(Input.GetButton(“Fire1”) && Time.time > nextFire) {
nextFire = Time.time + fireRate;
clone = Instantiate(projectile, transform.position, transform.rotation);
}
}
◆ static var timeScale : float
描述: 传递时间的缩放,可以用来减慢动作效果。
当timeScale 为1.0 的时候时间和真实时间一样快;当timeScale 为0.5 的时候时间为真实时
间的一半速度;当timeScale 被设置为0 的时候那么游戏基本上处于暂停状态,如果所有函
数都是与帧率无关的。如果降低timeScale 建议同时降低Time.fixedDeltaTime 相同的量。当
timeScale 被设置为0 时FixedUpdate 将不会被调用。
//当用户按下Fire1 按钮时可以在1 和0.7 之间切换时间。
function Update () {
if(Input.GetButton(“Fire1”)) {
if(Time.timeScale == 1.0) {
Time.timeScale = 0.7;
}
else {
Time.timeScale = 1.0;
}
//根据timeScale 调整固定增量时间
Time.fixedDeltaTime = 0.02 * Time.TimeScale;
}
}
◆ static var timeSinceLevelLoad : float
描述: 该帧开始的时间(只读)。最后一个关卡被加载到现在的时间。
//设置GUI 文本为玩家完成该关卡的时间。
function PlayerCompletedGame () {
guiText.text = Time. timeSinceLevelLoad.ToString;
}
Vector2
结构
表示2D 向量和点。
这个在某些地方用来表示2D 位置和向量(例如,在Mesh 中的纹理坐标或者Material 中的
纹理偏移)。在大多数情况下使用一个Vector3。
变量
◆ var magnitude : float
描述: 返回这个向量的长度(只读)。
向量的长度是(x*x+y*y)的平方根。
如果你只需要比较向量的长度,你可以使用sqrMagnitude(计算长度的平方式比较快的)比较
它们的平方。
参见: sqrMagnitude
◆ var sqrMagnitude : flaot
描述: 返回这个向量长度的平方(只读)。
计算长度的平方比magnitude 更快。通常如果你只比较两个向量的长度你可以只比较它们
的长度的平方。
参见: magnitude
◆ var this[index : int] : float
描述: 分别使用0 或1 来访问x 和y 组件。
Vector2 p;
p[1] = 5; //与p.y = 5 相同
◆ var x : float
描述: 该向量的x 组件。
◆ var y : float
描述: 该向量的y 组件。
构造函数
◆ static function Vector2 (x : float, y : float) : Vector2
描述: 用指定的x,y 组件构造一个新的向量。
函数
◆ function ToString () : String
描述: 返回格式化好的Vector 字符串。
类变量
◆ static var right : Vector2
描述: Vector2(1,0)的简写。
◆ static var up : Vector2
描述: Vector2(0,1)的简写。
◆ static var zero : Vector2
描述: Vector2(0,0)的简写。
类方法
◆ static function Distance(a:Vector2, b:Vector2):float
描述: 返回a 和b 之间的距离。
Vector2.Distance(a,b)和(a-b).magnitude 相同。
◆ static function Dot(lhs:Vector2, rhs:Vector2):float
描述: 2 个向量的点乘。
返回lhs.rhs.
对于规范化的向量,如果它们指向相同的方向Dot 返回1;如果指向相反的方向返回-1;
在另外的情况下返回一个数字(例如,如果向量垂直则Dot 返回0)。
◆ static operator* (a:Vector2, d:float):Vector2
描述: 用一个数乘以一个向量。
用d 乘以a 的每个组件。
// 使向量变为二倍长;打印(2.0, 4.0)
print (Vector2(1,2) * 2.0);
◆ staic operator* (d:float, a:Vector2):Vector2
描述: 用一个数乘以一个向量。
用d 乘以a 的每个组件。
// 使向量变为二倍长; 打印(2.0, 4.0)
print(2.0 * Vector2(1, 2));
◆ static operator + (a:Vector2, b:Vector2):Vector2
描述: 两个向量相加。
将对应的组件加在一起。
// 打印(3.0, 5.0)
print(Vector2(1,2) + Vector2(2,3));
◆ static operator–(a:Vector2, b:Vector2):Vector2
描述: 两个向量相减。
从a 中减去b 的每个对应组件。
// 打印(-2.0, 0.0)
print(Vector2(1,2)–Vector2(3,2));
◆ static operator–(a:Vector2):Vector2
描述: 向量取反。
结果中的每个组件都被取反。
// 打印(-1.0, -2.0)
print(-Vector2(1,2);
◆ static operator/(a:Vector2, d:float):Vector2
描述: 用一个数除以一个向量。
用d 除以a 的每个组件。
// 使向量缩短一倍;打印(0.0, 1.0)
print(Vector2(1,2)/2.0);
◆&nbs, p;static operator==(lhs:Vector2, rhs:float):Vector2
描述: 如果向量相等返回true。
对于非常接近相等的向量,这个也返回true。
◆ static implicit function Vector2(v:Vector3):Vector2
描述: 把一个Vector3 转化成Vector2。
Vector3 可被隐式的转化为Vector2(z 被丢弃)。
◆ static implicit function Vector3(v:Vector2):Vector3
描述: 把一个Vector2 转化成Vector3。
Vector2 可被隐式的转化为Vector3(z 被默认设置成0)。
◆ static function Scale(a:Vector2, b:Vector2):Vector2
描述: 两个向量组件相乘
结果中的每个组件都是a 中的一个组件乘以b 中相同的组件。
// 打印(2.0, 6.0)
print(Vector2.Scale(Vector2(1,2), Vector2(2,3)));
Vector3
结构
表示3D 的向量和点。
这个结构被用在这个Unity 中传递3D 位置和方向,它也包含函数来做普通的向量操作。
变量
◆ var magnitude : float
描述: 返回这个向量的长度(只读)。
向量的长度是(x*x+y*y+z*z)的平方根。
如果你只需要比较向量的长度,你可以使用sqrMagnitude(计算长度的平方根是较快的)比较
它们的长度平方。
参见: sqeMagnitude
◆ var normalized : Vector3
描述: 返回这个向量,并且magnitude 为1(只读)。
规范化之后,一个向量保持相同的方向但是它的长度为1.0。
注意当前的向量不改变并返回一个新的规范化向量,如果你像规范化当前向量,使用
normalized 函数。
如果这个向量太小以至于不能规范化,将返回一个零向量。
参见: Normalize 函数
◆ var sqeMagnitude : float
描述: 返回这个向量长度的平方(只读)。
计算长度的平方比magnitude 更快。通常如果你只比较两个向量的长度你可以只比较它们
的平方。
// 检测当一个变化比closeDistance 更接近
// 这个比使用Vector3 magnitude 更快
var other : Transform;
var closeDistance = 5.0;
function Update() {
if(other) {
var sqeLen = (other.position – transform.position).sqrMagnitude;
// 平方我们需要比较的距离
if(sqrLen < closeDistance * closeDistance)
print(“The other transform is close to me!”);
}
}
参见: magnitude
◆ var this[index : int] : float
描述: 分别使用[0],[1],[2]访问x,y,z 组件。
Vector3 p;
p[1] = 5; //与p.y = 5 相同
◆ var x : float
描述: 该向量的x 组件。
◆ var y : float
描述: 该向量的y 组件。
◆ var z : float
描述: 该向量的z 组件。
构造函数
◆ static function Vector3(x : float, y : float, z : float) : Vector3
描述: 用给定的x,y,z 组件构建一个新的向量。
◆ static function Vector3(x : float, y : float) : Vector3
描述: 用给定的x,y 组件构建一个新的向量并设置z 为0。
函数
◆ function Normalize() : void
描述: 使该向量的magnitude 为1。
规范化之后,一个向量保持相同的方向但是它的长度为1.0。
注意这个函数将改变当前向量。如果你想保持当前向量不改变,使用normalized 变量。
如果这个向量太小以至于不能规范化,它将被设置为0.
参见: normalized 变量
◆ function Scale(scale : Vector3) : void
描述: 用scale 的组件乘以这个向量中的每个对应组件。
◆ static function Scale(a : Vecotr3, b : Vector3) : Vecotr3
描述: 两个向量的组件相乘。
结果中的每个组件是a 中的一个组件乘以b 中的相对应组件。
// 打印(2.0, 6.0, 12.0)
print(Vector3.Scale(Vector3(1,2,3), Vector3(2,3,4)));
◆ function ToString() : string
描述: 返回格式化好的Vector3 字符串。
类变量
◆ static var forward : Vector3
描述: Vector3(0, 0, 1)的简写。
transform.position += Vector3.forward * Time.deltaTime;
◆ static var one : Vector3
描述: Vector3(1, 1, 1)的简写。
transform.position = Vector3.one;
◆ static var right : Vector3
描述: Vector3(1, 0, 0)的简写。
transform.position += Vector3.right * Time.deltaTime;
◆ static var up : Vector3
描述: Vector3(0, 1, 0)的简写。
transform.position += Vector3.up * Time.deltaTime;
◆ static var zero : Vector3
描述: Vector3(0, 0, 0)的简写。
transform.position += Vector3.zero;
类方法
◆ static function Angle(from : Vector3, to : Vector3) : float
描述: 返回from 和to 之间的角度。
// 如果这个变化的z 轴看向target
// 打印”close”
var target : Transform;
function Update() {
var targetDir = target.position – transform.position;
var forward = transform.forward;
var angle = Vector3.Angle(targetDir, forward);
if(angle < 5.0)
print(“close”);
}
◆ static function Cross(lhs : Vector3, rhs : Vector3) : float
描述: 两个向量的叉乘。
返回lhs x rhs。
◆ static function Distance(a : Vector3, b : Vector3) : float
描述: 返回a 和b 之间的距离。
Vector3.Distance(a, b)与(a – b).magnitude 相同。
var other : Transform;
if(other) {
var dist = Vector3.Distance(other.position, transform.position);
print(“Distance to other: ” + dist);
}
◆ static function Dot(lhs : Vector3, rhs : Vector3) : float
描述: 两个向量的点乘。
返回lhs.rhs。
对于normalized 的向量,如果它们指向相同的方向Dot 返回1;如果指向完全相反的方向
则返回-1;在另外的情况下返回一个数字(例如,如果向量垂直则Dot 返回0)。
对于任意长度的向量Dot 返回的值是相同的。当两个向量的角度增加的时候,这个值会变
大。
// 检测是否有其他变换在这个物体之后
var other : Transform;
function Update() {
if(other) {
var forward = transform.Transform.Distance(Vector3.forward);
var toOther = other.position;
transform.position;
if(Vector3.Dot(forward, toOther) < 0)
print(“The other transform is behind me!”);
}
}
◆ static function Lerp(from : Vector3, to : Vector3, t : float) : Vector3
描述: 在两个向量之间找到线性插值。
从from 到to 基于t 插值。
t 被裁剪到(0…1)之间。当t 为0 时返回from,当t 为1 时返回to。当t = 0.5 时返回from
和to 的平均值。
// 在一秒内从from 开始移动到to 结束
var start : Transform;
var end : Transform;
function Update() {
transform.position = Vector3.Lerp(start.position, end.position, Time.time);
}
// 像一个弹簧一样跟随target 位置
var target : Transform;
var smooth = 5.0;
function Update() {
transform.position = Vector3.Lerp(transform.position, target.position, Time.deltaTime *
smooth);
}
◆ static function Max(lhs : Vector3, rhs : Vector3) : Vector3
描述: 返回由lhs 和rhs 中最大组件组成的向量。
var a = Vector3(1,2,3);
var b = Vector3(4,3,2);
print(Vector3.Max(a,b)); //打印(4.0, 3.0, 3.0);
参见: Min 函数
◆ static function Min(lhs : Vector3, rhs : Vector3) : Vector3
描述: 返回由lhs 和rhs 中最小组件组成的向量。
var a = Vector3(1,2,3);
var b = Vector3(4,3,2);
print(Vector3.Min(a,b)); //打印(1.0, 2.0, 2.0);
参见: Max 函数
◆ static operator != (lhs : Vecotr3, rhs : Vecotr3) : bool
描述: 如果向量不同返回true。
非常接近的向量被认为是相等的。
var other : Transform;
if(other && transform.position != other.position) {
print(“I’m at the different place than the other transform!”);
}
◆ static operator * (a : Vector3, d : float) : Vector3
描述: 用一个数乘以一个向量。
用d 乘以a 的每个组件。
print(Vector3(1,2,3) * 2.0); //使向量变为二倍长,打印(2.0, 4.0, 6.0)
◆ static operator * (d : float , a : Vector3) : Vector3
描述: 用一个数乘以一个向量。
用d 乘以a 的每个组件。
print(Vector3(1,2,3) * 2.0); //使向量变为二倍长,打印(2.0, 4.0, 6.0)
◆ static operator + (a : Vector3, b : Vector3) : Vector3
描述: 两个向量相加。
将对应的组件加在一起。
// 打印(5.0, 7.0, 9.0)
print(Vector3(1,2,3) + Vector3(4,5,6));
◆ static operator - (a : Vector3, b : Vector3) : Vector3
描述: 两个向量相减。
将a 与b 对应的组件相减。
// 打印(-5.0, -3.0, -1.0)
print(Vector3(1,2,3) - Vector3(6,5,4));
◆ static operator - (a : Vector3) : Vector3
描述: 向量取反。
将a 中的每个组件都取反。
// 打印(-1.0, -2.0, -3.0)
print(Vector3(1,2,3));
◆ static operator / (a : Vector3, d : float) : Vector3
描述: 用一个数除以一个向量。
用d 除以a 的每个组件。
// 使向量缩短一倍,打印(0.5, 1.0, 1.5)
print(Vector3(1,2,3) / 2.0);
◆ static operator == (lhs : Vector3, rhs : Vector3) : bool
描述: 如果向量相等返回true。
对于非常接近相等的向量,这个也返回真。
var other : Transform;
if(other && transform.position == other.position) {
print(“I’m at the same place as the other transform”);
}
◆ static function OrthoNormalize(ref normal : Vector3, ref tangent : Vector3) : void
描述: 使两个向量规范化并互相正交。
规范化normal;规范化tangent 并确保它正交于normal(就是说,它们之间的角度是90 度)。
参见: Normalize 函数
◆ static function OrthoNormalize(ref normal : Vector3, ref tangent : Vector3, ref binormal :
Vector3) : void
描述: 使两个向量规范化并互相正交。
规范化normal;规范化tangent 并确保它与normal。规范化binormal 并确保它与normal 和
tangent 正交。
参见: Normalize 函数
◆ static function Project(vector : Vector3 , onNormal : Vector3) : Vector3
描述: 投影一个向量到另一个向量。
返回投影到onNormal 上的vector。如果onNormal 接近零,返回零矩阵。
◆ static function Reflect(inDirection : Vector3, inNormal : Vector3) : Vector3
描述: 沿着法线反射这个向量。
返回的值inDirection 从以inNormal 为法线的表面反射。
var originalObject : Transform;
var reflectedObject : Transform;
function Update() {
// 使反射物体与凡是物体沿着世界的z 轴镜像反射
reflectedObject.position = Vector3.Reflect(originalObject.position, Vector3.right);
}
◆ static function RotateTowards(from : Vector3, to : Vector3, maxRadiansDelta : float,
maxMagnitudeDelta : float) : Vector3
描述: 旋转一个向量from 到to。
该向量将被在一个弧线上旋转而不是线形插值。本质上与Vector3.Slerp 相同,但是这个函
数将确保角速度和长度的改变不会超过maxRadiansDelta 和maxMagnitudeDelta。
◆ function Scale(scale : Vector3) : void
描述: 用sacle 的组件乘以这个向量中的每个对应组件。
◆ static function Scale(a : Vector3, b : Vector3) : Vector3
描述: 两个向量组件相乘。
结果中的每个组件是a 中的一个组件乘以b 中相对应的组件。
// 打印(2.0, 6.0, 12.0)
print(Vector3.Scale(Vector3(1,2,3), Vector3(2,3,4)));
◆ static function Slerp(from : Vector3, to : Vector3, t : float) : Vector3
描述: 在两个向量之间球形插值。
从from 到to 基于t 插值,返回向量的magnitude 将在from 和to 的长度之间插值。
t 被裁剪到[0…1]之间。
// 在sunrise 和sunset 之间以弧线变换一个位置
var sunrise : Transform;
var sunset : Transform;
function Update() {
// 弧线的中心
var center = (sunrise.position – sunset.position) * 0.5;
// 向下移动一点中心使该弧线垂直
center.y -= 1;
//相对于中心插值这个弧线
var riseRelCenter = sunrise.positioni – center;
var setRelCenter = sunset.position – center;
transform.position = Vector3.Slerp(riseRelCenter, setRelCenter. Time.time);
transform.position += center;
}
参见: Lerp 函数
Vector4
结构
表示四维向量。
这个结构被用在一些地方来表示四个组件的向量(例如,网格切线,shader 的参数)。在其
他的一些地方使用Vector5。
变量
◆ var magnitude : float
描述: 返回这个向量的长度(只读)。
向量的长度是(x*x+y*y+z*z+w*w)的平方根。
如果你只需要比较向量的长度,你可以使用sqrMagnitude(计算长度的平方是比较快的)
比较它们的长度平方。
参见: sqrMagnitude
◆ var normalized : Vector4
描述: 返回这个向量,并且magnitude 为1(只读)。
注意当前的向量不改变并返回一个新的规范化的向量。如果你像规范化当前向量,使用
Normalize 函数。
如果这个向量太小以至于不能规范化,将返回一个零向量。
参见: Normalize 函数。
◆ var sqrMagnitude : float
描述: 返回这个向量的长度的平方(只读)。
计算长度的平方比magnitude 更快。
参见: magnitude
◆ var this[index : int] : float
描述: 分别使用[0],[1],[2],[3]访问x,y,z,w 组件。
Vector4 p;
p[3] = 5; // 与p.w = 5 相同
◆ var w : float
描述: 该向量的w 组件。
◆ var x : float
描述: 该向量的x 组件。
◆ var y : float
描述: 该向量的y 组件。
◆ var z : float
描述: 该向量的z 组件。
构造函数
◆ static function Vector4 (x : float, y : float, z : float, w : float) : Vector4
描述: 用给定的x,y,z,w 组件构建一个新的向量。
◆ static function Vector4 (x : float, y : float, z : float) : Vector4
描述: 用给定的x,y,z 组件构建一个新的向量并设置w 为0。
◆ static function Vector4 (x : float, y : float) : Vector4
描述: 用给定的x,y 组件构建一个新的向量并设置z 和w 为0。
函数
◆ function Normalize() : void
描述: 使该向量的magnitude 值为1。
注意这个函数将改变当前向量。如果你想保持当前向量不改变,使用normalized 变量。
如果这个向量太小以至于不能规范化,它将被设置为0。
参见: normalized 变量
◆ function Scale(scale : Vector4) : void
描述: 用scale 的组件乘以这个向量中的每个对应组件。
◆ static function Scale(a : Vector4, b : Vector4) : Vector4
描述: 两个向量的组件相乘。
结果中的每个组件是a 中的一个组件乘以b 中相同的组件。
// 打印(2.0, 6.0, 12.0, 12.0)
print(Vector4.Scale(Vector4(1,2,3,4), Vector4(2,3,4,5)));
◆ function ToString() : String
描述: 返回格式化好的vector 字符串
类变量
◆ static var one : Vector4
描述: Vector4(1,1,1,1)的简写。
◆ static var zero : Vector4
描述: Vector4(0,0,0,0)的简写。
类方法
◆ static function Distance(a : Vector4, b : Vector4) : float
描述: 返回a 和b 之间的距离。
Vector4 Distance(a,b)和(a-b).magnitude 相同。
◆ static function Dot(lhsVector4, rhsVector4) : float
描述: 两个向量的点乘。
返回lhs.rhs。
◆ static function Lerp(from : Vector4, to : Vector4, t : float) : Vector4
描述: 在两个向量之间线形插值。
从from 到to 基于t 插值。
t 被裁剪到[0…1]之间,当t 为0 时返回from,当t 为1 时返回to,当t = 0.5 时返回from 与
to 的平均值。
◆ static operator != (lhs : Vector4, rhs : Vector4) : bool
描述: 如果向量不同返回真。
非常接近的向量被认为是相等的。
◆ static operator * (a : Vector4, d : float) : Vector4
描述: 用一个数乘以一个向量。
用d 乘以a 的每个组件。
// 使向量变为二倍长,打印(2.0, 4.0, 6.0, 8.0)
print(Vector4(1,2,3,4) * 2.0);
◆ static operator * (d : float, a : Vector4) : Vector4
描述: 用一个数乘以一个向量。
用d 乘以a 的每个组件。
// 使向量变为二倍长,打印(2.0, 4.0, 6.0, 8.0)
print(2.0 * Vector4(1,2,3,4));
◆ static operator + (a : Vector4, b : Vector4) : Vector4
描述: 两个向量相加。
将对应的组件加在一起。
// 打印(5.0, 7.0, 9.0, 11.0)
print(Vector4(1,2,3,4) + Vector4(4,5,6,7));
◆ static operator - (a : Vector4, b : Vector4) : Vector4
描述: 两个向量相减。
从a 中减去b 中每个对应的组件。
// 打印(-5.0, -3.0, -1.0, 1.0)
print(Vector4(1,2,3,4) + Vector4(6,5,4,3));
◆ static operator - (a : Vector4) : Vector4
描述:向量取反。
a 中的每个组件都被取反。
// 打印(-4.0, -3.0, -2.0, -1.0)
print(-Vector4(4,3,2,1));
◆ static operator / (a : Vector4, d : float) : Vector4
描述: 用一个数除以一个向量。
从d 除以a 中每个组件。
// 使向量缩短一半,打印(0.5, 1.0, 1.5, 2.0)
print(Vector4(1,2,3,4) / 2.0);
◆ static operator == (lhs : Vector4, rhs : Vector4) : bool
描述: 如果向量相等返回true。
对于非常接近相等的向量,这个也返回true。
◆ static implicit function Vector3(v : Vector4) : Vector3
描述: 把一个Vector4 转换为一个Vector3。
Vector4 可以被隐式转换成Vector3(w 被丢弃)。
function Start() {
// shader 总是Vector4。但是这个值被转化成一个Vector3。
var value : Vector3 = renderer.material.GetVector(“_SomeVariable”);
}
◆ static implicit function Vector4(v : Vector3) : Vector4
描述: 把一个Vector3 转换为一个Vector4。
Vector3 可以被隐式转换成Vector4(w 被设置为0)。
function Start() {
// shader 总是Vector4。这个值从一个Vector3 转换为一个Vector4。
var value : Vector3 = Vector3.one;
renderer.material.SetVector(“_SomeVariable”, value);
}
◆ static function Project(a : Vector4, b : Vector4) : Vector4
描述: 投影一个向量到另一个向量。
返回投影到b 的a。
◆ static Scale(scale : Vector4) : void
描述: 用scale 的组件乘以这个向量中的每个对应组件。
◆ static function Scale(a : Vector4, b : Vector4) : Vector4
描述: 两个向量的组件相乘。
结果中每个组件都是a 中的一个组件乘以b 中的对应组件。
// 打印(2.0, 6.0, 12.0 , 20.0)
print(Vector4.Scale(Vector4(1,2,3,4), Vector4(2,3,4,5)));
WWWFrom

辅助类。用来生成表单数据并使用WWW 类传递到web 服务器。
// 获取一个截屏并上传到CGI 脚本
// 该CGI 脚本必须能处理表单上传
var screenshotURL = “http://www.my-site.com/cgi-bin/screenshot.pl”;
// 截屏
function Start() {
UploadPN