2019-07-09 15:51:17 w962942172 阅读数 476
  • Unity 值得看的500+ 技术内容列表

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

Unity3D学习笔记:粒子特效参数含义

转载 https://blog.csdn.net/asd237241291/article/details/8433534

粒子特效

粒子系统检视面板

初始化模块:
持续时间(Duration):粒子系统发射粒子的持续时间
循环(Looping):粒子系统是否循环
预热(Prewarm):当looping开启时,才能启动预热(Prewarm),游戏开始时粒子已经发射了一个周期。
初始延迟(Start Delay):粒子系统发射粒子之前的延迟。注意在prewarm(预热)启用下不能使用此项。
初始生命(Start Lifetime)以秒为单位,粒子存活数量。
初始速度(Start Speed):粒子发射时的速度。
初始大小(Start Size):粒子发射时的大小。
初始旋转(Start Rotation):粒子发射时的旋转值。
初始颜色(Start Color):粒子发射时的颜色。
重力修改器(Gravity Modifier):粒子在发射时受到的重力影响。
继承速度(Inherit Velocity):---控制粒子速率的因素将继承自粒子系统的移动(对于移动中的粒子系统)。
模拟空间(Simulation Space):粒子系统在自身坐标系还是世界坐标系。
唤醒时播放(Play On Awake):如果启用粒子系统当在创建时,自动开始播放。
最大粒子数(Max Particles):粒子发射的最大数量
发射模块(Emission):

控制粒子的发射时的速率,在粒子系统存续期间可以在某个时间生成大堆粒子(模拟爆炸)。

速率(Rate):每秒的粒子发射的数量 (小箭头可选择“每秒(Time)”或“每米(Distance)”)。
突发(Bursts):在粒子系统生存期间增加爆发
爆炸的时间 | 数量(Time | Particles):指定时间(在生存期内,以秒(Time)为单位时),将发射指定数量的粒子。
									 用"+"或"-"调节爆	 ···发数量。
发射器形状模块(Shape):

发射器形状内部随机位置生成,并能提供初始的力,该力的方向将延表面法线或随机方向发射。

球体【Sphere】
半径(Radius):球体的半径。
从外壳发射(Emit from Shell):从球体外壳发射。
随机方向(Random Direction):随机方向或是沿表面法线。
半球【Hemisphere】
半径(Radius):半椭圆的半径。
从外壳发射(Emit from Shell):从半椭圆外壳发射。
随机方向(Random Direction):随机方向或是沿表面法线。
锥体【Cone】喇叭~
角度(Angle):圆锥的角度(喇叭口)。如果是0,粒子将延一个方向发射(直筒)。
半径(Radius ):发射口半径。
立方体【Box】
Box X:X轴的缩放值
Box Y:Y轴的缩放值
Box Z:Z轴的缩放值
随机方向(Random Direction):粒子将延一个随机方向发射(取消:延Z轴发射)。
网格【Mesh】
类型(Type):粒子将从顶点(Vertex)、边(Edge)、或三角面(Triangle)发射。
网格(Mesh):选择一个面作为发射面。
随机方向(Random Direction):粒子发射将随机方向或是沿表面法线。
存活时间的速度模块(Velocity Over Lifetime):

粒子的直接动画路径。(通常用于复杂物理粒子,不过是简单的视觉行为和物理世界的小互动,如与飘荡的烟雾和气温降低。)

XYZ:使用常量曲线或在曲线中随机去控制粒子的运动。
Space:局部/世界 速度值在局部还是世界坐标系。
存活期间的限制速度模块(Limit Velocity Over Lifetime):

基本上被用于模拟的拖动。如果有了确定的阀值,将抑制或固定速率。可以通过坐标轴或向量调整。
拖动指用于Taril, 一般有拖尾的时候会让粒子随着移动变小,然后形成渐变的拖尾效果。

分离轴(Separate Axis):用于每个坐标轴控制。
----速度(Speed):用常量或曲线指定来限制所有方向轴的速度。(未选中)
----XYZ:用不同的轴分别控制。见最大最小曲线。(选中)
阻尼(Dampen):(0-1)的值确定多少过度的速度将被减弱。(值为0.5,将以50%的速率降低速度)
存活期间的受力模块(Force Over Lifetime):
XYZ:使用常量或随机曲线来控制作用于粒子上面的力。
Space:Local自己的坐标系,World世界的坐标系。
随机(Randomize):每帧作用在粒子上面的力都是随机的。(两组xyz时可选择,随机范围是这两组xyz之间的差值。)
存活时间的颜色模块(Color Over Lifetime):

控制每个粒子存活期间的颜色(与初始颜色叠加)。粒子存活时间越短变化越快。
两种颜色随机比例互相叠加。
目前我用到的情况是呼吸灯的情况

颜色速度模块(Color By Speed):
使粒子颜色根据其速度动画化。为颜色在1个特定范围内重新指定速度。

颜色(Color):用于指定的颜色。使用渐变色来指定各种颜色。
颜色缩放(Color Scale):使用颜色缩放可以方便的调节纯色和渐变色。
速度范围(Speed Range):min和max值用来定义颜色速度范围。
存活时间的大小模块(Size Over Lifetime):
大小(Size):控制每个粒子在其存活期间内的大小。曲线,随机双曲线或随机范围数值。(配合Color over lifetime 实现呼吸灯效果)
存活时间的大小速度模块(Size By Speed):
大小(Size):大小用于指定速度。用曲线表示各种大小。
速度范围(Speed Range):min和max值用来定义大小速度范围。
存活期间的旋转速度模块(Rotation Over Lifetime):

以度为单位指定值。

旋转速度(Rotational Speed):控制每个粒子在其存活期间内的旋转速度。使用常量,曲线,2曲线随机。
旋转速度模块(Rotation By Speed):
旋转速度(Rotational Speed):用来重新测量粒子的速度。使用曲线表示各种速度。
速度范围(Speed Range):为min和max值用来定义旋转速度范围。
碰撞模块(Collision Module)

为粒子系统建立碰撞。现在只有平面碰撞被支持,这个将很有效率的做简单探测。

平面(Planes):Planes被定义为指定引用。可以动画化。如果多个面被使用,Y轴作为平面的法线。
阻尼(Dampen):0-1 在碰撞后变慢。
反弹(Bounce):0-1 当粒子碰撞后的反弹力度。
生命减弱(Lifetime Loss):(0-1) 每次碰撞胜铭减弱的比例。0,碰撞后粒子正常死亡。1,碰撞后粒子立即死亡。
可视化(Visualization):可视化平面:网格还是实体
-----网格(Grid):在场景渲染为辅助线框。
----实体(Solid):在场景渲染为平面。
缩放平面(Scale Plane):重新缩放平面
子粒子发射模块(Sub Emitter):

可以生成其他粒子系统,用下列的粒子事件:出生、死亡、碰撞。

出生(Birth):在每个粒子出生的时候生成其他粒子系统
死亡(Death):在每个粒子死亡的时候生成其他粒子系统
碰撞(Collision):在每个粒子碰撞的时候生成其他粒子系统。重要的 碰撞需要建立碰撞模块。见碰撞模块
纹理层动画模块(Texture Sheet Animation):

在粒子存活期间动画化UV坐标。动画每帧可以显示在表格或1个表格的每行,这样将动画分开。每帧可以用曲线动画或者在2个曲线取随机。速度被定义为"循环"、
注意:用于动画的纹理是在渲染器模块中材质找到使用的。
目前用到的是碎石效果。利用多个Sprite对象同时生成,实现碎石效果。

模型(Mode):选取Grid或者Sprite。Grid是利用整个Animation Sheet文件,
		     选取Sprites则可以添加多个Sprites并随机生成实现粒子特效
平铺(Tiles):定义纹理的平铺
动画(Animation):指定动画类型:整个表格或是单行。
----整个表(Whole Sheet):为UV动画使用整个表格。
-------时间帧(Frame over Time):在整个表格上控制UV动画。使用常量,曲线,2曲线随机。
----单行(Single Row):为UV动画使用表格单独一行。
-------随机行(Random Row):如果选择第一行随机,不选择得指定行号(第一行是0)
-------时间帧(Frame over Time):在1个特定行控制每个粒子的UV动画。使用常量,曲线,2曲线随机。
周期(Cycles):指定动画速度。
渲染器模块(Renderer):

渲染模块显示粒子系统渲染组件的属性。注意:即使一个游戏物体有渲染粒子系统组件,当此模块被删除/添加后,它的属性也只能显示在这里。这个实际上是粒子系统渲染组件的添加和删除。还可以用来调整粒子系统的坐标位置,比如世界坐标,本地坐标。

渲染模式(Render Mode):选择下列粒子渲染模式之一
----广告牌(Billboard):让粒子永远面对摄像机。
----拉伸广告牌(Stretched Billboard):粒子将通过下面属性伸缩。
	摄像机缩放(Camera Scale):决定摄像机的速度对粒子伸缩的影响程度。
	速度缩放(Speed Scale):通过比较速度来决定粒子的长度。
	长度缩放(Length Scale):通过比较宽度来决定粒子的长度。
----水平广告牌(Horizontal Billboard):让粒子延Y轴对齐,面朝Y轴方向。
----垂直广告牌(Vertical Billboard):当面对摄像机时,粒子延XZ轴对齐。
----网格(Mesh):粒子被渲染时使用mesh而不是quad。
-------网格(Mesh):渲染粒子所用的网格引用。
材质(Material):材质。
排序模式(Sort Mode):绘画顺序可通过具体,生成早优先和生成晚优先。
排序校正(Sorting Fudge):使用这个将影响绘画顺序。粒子系统带有更低sorting fudge值,更有可能被最后绘制,
						从而显示在透明物体和其他粒子系统的前面 。
投射阴影(Cast Shadows):粒子能否投影?这是由材质决定的。
接受阴影(Receive Shadows):粒子能否接受阴影?这是由材质决定的。
最大粒子大小(Max Particle Size):设置最大粒子大小,相对于视窗大小。有效值为0-1。

粒子系统检视面板
管理复杂的粒子效果,untiy提供了粒子编辑器,用户从监事面板的粒子组件面板可以点击"Open Editor"按钮。

2017-05-16 17:08:21 qq_20849387 阅读数 1961
  • Unity 值得看的500+ 技术内容列表

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

需求:游戏中展示卡牌这种效果也是蛮酷炫并且使用的一种常见效果,下面我们就来实现以下这个效果是如何实现。
这里写图片描述
这里写图片描述
思考:第一看看到这个效果,我们首先会想到UGUI里面的ScrollRect,当然也可以用ScrollRect来实现缩短ContentSize的width来自动实现重叠效果,然后中间左右的卡牌通过计算来显示缩放,这里我并没有用这种思路来实现,我提供另外一种思路,就是自己去计算当前每个卡牌的位置和缩放值,不用UGUI的内置组件。
CODE:
1.卡牌拖动组件:

using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

public enum DragPosition
{
        Left,
        Right,
        Up,
        Down,
}

[RequireComponent(typeof(Image))]
public class CDragOnCard : MonoBehaviour, IBeginDragHandler, IDragHandler, IEndDragHandler
{
        public bool dragOnSurfaces = true;
        public ScrollRect m_ScrollRect = null;
        public CFixGridRect m_FixGridRect = null;
        private RectTransform m_DraggingPlane;

        public bool isVertical = false;
        private bool isSelf = false;
        private DragPosition m_dragPosition = DragPosition.Left;

        public System.Action<DragPosition> DragCallBack = null;

        public void OnBeginDrag(PointerEventData eventData)
        {
                Vector2 touchDeltaPosition = Vector2.zero;
#if UNITY_EDITOR
                float delta_x = Input.GetAxis("Mouse X");
                float delta_y = Input.GetAxis("Mouse Y");
                touchDeltaPosition = new Vector2(delta_x, delta_y);

#elif UNITY_ANDROID || UNITY_IPHONE
        touchDeltaPosition = Input.GetTouch(0).deltaPosition;  
#endif
                if (isVertical)
                {
                        if(touchDeltaPosition.y > 0)
                        {
                                UnityEngine.Debug.Log("上拖");
                                m_dragPosition = DragPosition.Up;
                        }
                        else
                        {
                                UnityEngine.Debug.Log("下拖");
                                m_dragPosition = DragPosition.Down;
                        }

                        if (Mathf.Abs(touchDeltaPosition.x) > Mathf.Abs(touchDeltaPosition.y))
                        {
                                isSelf = true;
                                var canvas = FindInParents<Canvas>(gameObject);
                                if (canvas == null)
                                        return;

                                if (dragOnSurfaces)
                                        m_DraggingPlane = transform as RectTransform;
                                else
                                        m_DraggingPlane = canvas.transform as RectTransform;

                        }
                        else
                        {
                                isSelf = false;
                                if (m_ScrollRect != null)
                                        m_ScrollRect.OnBeginDrag(eventData);
                        }
                }
                else //水平
                {
                        if (touchDeltaPosition.x > 0)
                        {
                                UnityEngine.Debug.Log("右移");
                                m_dragPosition = DragPosition.Right;
                        }
                        else
                        {
                                UnityEngine.Debug.Log("左移");
                                m_dragPosition = DragPosition.Left;
                        }

                        if (Mathf.Abs(touchDeltaPosition.x) < Mathf.Abs(touchDeltaPosition.y))
                        {
                                isSelf = true;
                                var canvas = FindInParents<Canvas>(gameObject);
                                if (canvas == null)
                                        return;

                                if (dragOnSurfaces)
                                        m_DraggingPlane = transform as RectTransform;
                                else
                                        m_DraggingPlane = canvas.transform as RectTransform;
                        }
                        else
                        {
                                isSelf = false;
                                if (m_ScrollRect != null)
                                        m_ScrollRect.OnBeginDrag(eventData);
                        }
                }
        }

        public void OnDrag(PointerEventData data)
        {
                if (isSelf)
                {

                }
                else
                {
                        if (m_ScrollRect != null)
                                m_ScrollRect.OnDrag(data);
                }
        }

        public void OnEndDrag(PointerEventData eventData)
        {
                if (isSelf)
                {

                }
                else
                {
                        if (m_ScrollRect != null)
                                m_ScrollRect.OnEndDrag(eventData);
                        if (m_FixGridRect != null)
                                m_FixGridRect.OnEndDrag(eventData);
                }

                if (DragCallBack != null)
                        DragCallBack(m_dragPosition);
        }

        static public T FindInParents<T>(GameObject go) where T : Component
        {
                if (go == null) return null;
                var comp = go.GetComponent<T>();

                if (comp != null)
                        return comp;

                Transform t = go.transform.parent;
                while (t != null && comp == null)
                {
                        comp = t.gameObject.GetComponent<T>();
                        t = t.parent;
                }
                return comp;
        }
}

2.卡牌组件

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

public class EnhanceItem : MonoBehaviour
{
        // 在ScrollViewitem中的索引
        // 定位当前的位置和缩放
        public int scrollViewItemIndex = 0;
        public bool inRightArea = false;

        private Vector3 targetPos = Vector3.one;
        private Vector3 targetScale = Vector3.one;

        private Transform mTrs;
        private Image mImage;

        private int index = 1;
        public void Init(int cardIndex = 1)
        {
                index = cardIndex;
                mTrs = this.transform;
                mImage = this.GetComponent<Image>();
                mImage.sprite = Resources.Load<Sprite>(string.Format("Texture/card_bg_big_{0}", cardIndex % 6 + 1));
                this.gameObject.GetComponent<Button>().onClick.AddListener(delegate () { OnClickScrollViewItem(); });
        }

        // 当点击Item,将该item移动到中间位置
        private void OnClickScrollViewItem()
        {
                Debug.LogError("点击" + index);
                EnhancelScrollView.GetInstance().SetHorizontalTargetItemIndex(scrollViewItemIndex);
        }

        /// <summary>
        /// 更新该Item的缩放和位移
        /// </summary>
        public void UpdateScrollViewItems(float xValue, float yValue, float scaleValue)
        {
                targetPos.x = xValue;
                targetPos.y = yValue;
                targetScale.x = targetScale.y = scaleValue;

                mTrs.localPosition = targetPos;
                mTrs.localScale = targetScale;
        }

        public void SetSelectColor(bool isCenter)
        {
                if (mImage == null)
                        mImage = this.GetComponent<Image>();

                if (isCenter)
                        mImage.color = Color.white;
                else
                        mImage.color = Color.gray;
        }
}

3.自定义的ScrollView组件

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

public class EnhancelScrollView : MonoBehaviour
{
        public AnimationCurve scaleCurve;
        public AnimationCurve positionCurve;
        public float posCurveFactor = 500.0f;
        public float yPositionValue = 46.0f;

        public List<EnhanceItem> scrollViewItems = new List<EnhanceItem>();
        private List<Image> imageTargets = new List<Image>();

        private EnhanceItem centerItem;
        private EnhanceItem preCenterItem;

        private bool canChangeItem = true;

        public float dFactor = 0.2f;

        private float[] moveHorizontalValues;
        private float[] dHorizontalValues;

        public float horizontalValue = 0.0f;
        public float horizontalTargetValue = 0.1f;

        private float originHorizontalValue = 0.1f;
        public float duration = 0.2f;
        private float currentDuration = 0.0f;

        private static EnhancelScrollView instance;

        private bool isInit = false;
        public static EnhancelScrollView GetInstance()
        {
                return instance;
        }

        void Awake()
        {
                instance = this;
        }

        public void Init()
        {
                if ((scrollViewItems.Count % 2) == 0)
                {
                        Debug.LogError("item count is invaild,please set odd count! just support odd count.");
                }

                if (moveHorizontalValues == null)
                        moveHorizontalValues = new float[scrollViewItems.Count];

                if (dHorizontalValues == null)
                        dHorizontalValues = new float[scrollViewItems.Count];

                if (imageTargets == null)
                        imageTargets = new List<Image>();

                int centerIndex = scrollViewItems.Count / 2;
                for (int i = 0; i < scrollViewItems.Count; i++)
                {
                        scrollViewItems[i].scrollViewItemIndex = i;
                        Image tempImage = scrollViewItems[i].gameObject.GetComponent<Image>();
                        imageTargets.Add(tempImage);

                        dHorizontalValues[i] = dFactor * (centerIndex - i);

                        dHorizontalValues[centerIndex] = 0.0f;
                        moveHorizontalValues[i] = 0.5f - dHorizontalValues[i];
                        scrollViewItems[i].SetSelectColor(false);
                }

                //centerItem = scrollViewItems[centerIndex];
                canChangeItem = true;
                isInit = true;
        }

        public void UpdateEnhanceScrollView(float fValue)
        {
                for (int i = 0; i < scrollViewItems.Count; i++)
                {
                        EnhanceItem itemScript = scrollViewItems[i];
                        float xValue = GetXPosValue(fValue, dHorizontalValues[itemScript.scrollViewItemIndex]);
                        float scaleValue = GetScaleValue(fValue, dHorizontalValues[itemScript.scrollViewItemIndex]);
                        itemScript.UpdateScrollViewItems(xValue, yPositionValue, scaleValue);
                }
        }

        void Update()
        {
                if (!isInit)
                        return;
                currentDuration += Time.deltaTime;
                SortDepth();
                if (currentDuration > duration)
                {
                        currentDuration = duration;

                        //if (centerItem != null)
                        //{
                        //        centerItem.SetSelectColor(true);
                        //}

                        if (centerItem == null)
                        {
                                var obj = transform.GetChild(transform.childCount - 1);
                                if (obj != null)
                                        centerItem = obj.GetComponent<EnhanceItem>();
                                if (centerItem != null)
                                        centerItem.SetSelectColor(true);
                        }
                        else
                                centerItem.SetSelectColor(true);
                        if (preCenterItem != null)
                                preCenterItem.SetSelectColor(false);
                        canChangeItem = true;
                }

                float percent = currentDuration / duration;
                horizontalValue = Mathf.Lerp(originHorizontalValue, horizontalTargetValue, percent);
                UpdateEnhanceScrollView(horizontalValue);
        }

        private float GetScaleValue(float sliderValue, float added)
        {
                float scaleValue = scaleCurve.Evaluate(sliderValue + added);
                return scaleValue;
        }

        private float GetXPosValue(float sliderValue, float added)
        {
                float evaluateValue = positionCurve.Evaluate(sliderValue + added) * posCurveFactor;
                return evaluateValue;
        }

        public void SortDepth()
        {
                imageTargets.Sort(new CompareDepthMethod());
                for (int i = 0; i < imageTargets.Count; i++)
                        imageTargets[i].transform.SetSiblingIndex(i);
        }

        public class CompareDepthMethod : IComparer<Image>
        {
                public int Compare(Image left, Image right)
                {
                        if (left.transform.localScale.x > right.transform.localScale.x)
                                return 1;
                        else if (left.transform.localScale.x < right.transform.localScale.x)
                                return -1;
                        else
                                return 0;
                }
        }

        private int GetMoveCurveFactorCount(float targetXPos)
        {
                int centerIndex = scrollViewItems.Count / 2;
                for (int i = 0; i < scrollViewItems.Count; i++)
                {
                        float factor = (0.5f - dFactor * (centerIndex - i));

                        float tempPosX = positionCurve.Evaluate(factor) * posCurveFactor;
                        if (Mathf.Abs(targetXPos - tempPosX) < 0.01f)
                                return Mathf.Abs(i - centerIndex);
                }
                return -1;
        }

        public void SetHorizontalTargetItemIndex(int itemIndex)
        {
                if (!canChangeItem)
                        return;

                EnhanceItem item = scrollViewItems[itemIndex];
                if (centerItem == item)
                        return;

                canChangeItem = false;
                preCenterItem = centerItem;
                centerItem = item;

                float centerXValue = positionCurve.Evaluate(0.5f) * posCurveFactor;
                bool isRight = false;
                if (item.transform.localPosition.x > centerXValue)
                        isRight = true;

                int moveIndexCount = GetMoveCurveFactorCount(item.transform.localPosition.x);
                if (moveIndexCount == -1)
                {
                        moveIndexCount = 1;
                }

                float dvalue = 0.0f;
                if (isRight)
                        dvalue = -dFactor * moveIndexCount;
                else
                        dvalue = dFactor * moveIndexCount;

                horizontalTargetValue += dvalue;
                currentDuration = 0.0f;
                originHorizontalValue = horizontalValue;
        }

        public void OnBtnRightClick()
        {
                if (!canChangeItem)
                        return;
                int targetIndex = centerItem.scrollViewItemIndex + 1;
                if (targetIndex > scrollViewItems.Count - 1)
                        targetIndex = 0;
                SetHorizontalTargetItemIndex(targetIndex);
        }

        public void OnBtnLeftClick()
        {
                if (!canChangeItem)
                        return;
                int targetIndex = centerItem.scrollViewItemIndex - 1;
                if (targetIndex < 0)
                        targetIndex = scrollViewItems.Count - 1;
                SetHorizontalTargetItemIndex(targetIndex);
        }
}
2016-07-16 23:25:57 daimou123 阅读数 2038
  • Unity 值得看的500+ 技术内容列表

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

Unity制作颜色渐变的倒计时

项目需要制作颜色渐变的倒计时,挺简单的代码,大体思路就是开一个协程,在协程里面控制颜色的变化以及进度条的进度,话不多说代码奉上

public void ShowSliderWithId(int time)
{
    GameObject sl = (GameObject)Instantiate (_sliderPrefab);
    sl.transform.parent = transform;  //设置父节点
    sl.transform.localScale = new Vector3 (1f,1f,1f);
    sl.transform.localPosition = new Vector3 (0f,0f,0f);
    sl.GetComponent<UISlider> ().value = 1f;
    StartCoroutine (ScheduleUpdateGlobal (sl,time));
}

IEnumerator ScheduleUpdateGlobal(GameObject obj,int time)
{
    float seconds = 0;//倒计时时间
    UISlider slider  = obj.GetComponent<UISlider> ();
    UISprite sprite = obj.GetComponent<UISprite> ();
    while(true)  
    {  
        for (float timer = 0; timer < 1; timer += Time.deltaTime) {//控制时间1秒走完
            seconds += Time.deltaTime;  
            slider.value = (1-seconds / time);
            if (seconds > time / 2) { //时间到达一半开始我这里要求是时间过去一半颜色开始变化
                float g = ((time - seconds) * 2 / time);
                sprite.color = new Color (1, g, 1, 1);//控制g渐变为红色
            }
            yield return 0; 
        }
        if (seconds >= time) {
            GameObject.Destroy (obj);
            break; //跳出死循环
        }
    }
}

我用的是环形进度条,我的ui用的是NGUI,需要在Inspector面板中UISprite里面的type选择filled,fillDir选择redial360;
附上我用的进度条

2013-01-29 17:01:00 weixin_34211761 阅读数 25
  • Unity 值得看的500+ 技术内容列表

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

Tutorial:辅导,辅助
pivot:中心点;枢轴
diffuse:扩散;四散
assets:资源
Camera:相机
icon:图标;肖像
cube:立方体
Rotation:旋转、循环
Scale:刻度,比例
Collider:对碰机,碰撞机
Transform:改变,变换
Pillar:柱子
prefab:预设,预制
FPS Controller:第一人称控制器
rigid:坚硬的  rigidbody 刚体
trigger:触发器
preference:选择权
general:常规
extension:延伸
Terrain:地形、地势
Component:组件
Mesh:网眼
Shadows:阴影、影子
Blob shadows:斑点影子
Audio Reverb Zone:音频混响区
Level:水平
Particle:颗粒
render:着色、渲染  renderer:渲染器
animator:绘制者   particle animator:粒子动画
Directional :方向、
spotlight:聚光灯
physics:物理现象、物理学
receive:接受、收到
materials:材料
capsule:太空舱、小容
axis:轴、轴线
horizontal:水平线
vertical:垂直线
fade;淡入
billboard:广告牌
repeating:重复
gravity:重力
sphere:球体
cylinder:柱面、圆柱状物
intensity:强度
range:范围
crate:板条箱
mass:众多、大量
Opacity:不透明
Grass:草地
palm:手掌;棕榈树;掌状物
radius:半径范围
slope:倾斜度
setp Offset:一步抵消
Min Move Distance:移动的最小距离
apply:. 应用;申请;涂,敷
drag:拖拽
angular:生硬的
density:密度
variation:变化
flags:标记
solid:固体
account:账户
predefined  words;预定义单词
core:核心
element:元素
versus:对、与。。。相对
respawn:复位
Fixed :固定
platform:平台
Quaternion:四元数;四个一组
force:力量
instantiate:举例说明
forward:早的;向前的
Special Effects:特技效果
angular drag:角拖
kinematic:运动学的
interpolate:插入;篡改
freeze rotation:冻结旋转
translate:翻译;调动;解释;转化;转变为
Interacting:相互影响
toon shading:卡通渲染
acceleration:加速;加速度
tiling:盖瓦;瓷砖
compressed:扁平的;被压缩的
orientation:方向;向东方;定向
device:图案
turret:炮塔
clip:修剪;夹牢;
metal:金属
generate:使生成;发生
scale:刻度
split:分离
tangents:切线的,想切的;
factor:因数;
special:专门的
emitter:放射器
ellipsoid:椭圆
velocity:速率,周转率
weapons:斗争工具;武器;武装
grenades:n. 灭火弹;手榴弹 vt. 扔手榴弹;用催泪弹攻击
convex:凸面体
smooth:光滑的;
sphere:球体
automatically:自动的
compression:压缩
add ammo to inventory:添加弹药存货
destroy the ammo box:破坏弹药盒
large flame:大火焰
zoom:急速上升;使摄像机移动
vertex:顶点
simulate:模仿;假装
modified:修改
attack:攻击;
timing:定时;
identifier:认同者
artificial  intelligence:人工智能

转载于:https://www.cnblogs.com/Lin267307031/archive/2013/01/29/2881719.html

2015-01-21 22:25:43 Fish_cwh 阅读数 359
  • Unity 值得看的500+ 技术内容列表

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

     制作一个控制背景音乐控制台:

     1.建一个空对象‘;

    2.Add Component 添加Audio Sources ;

    3.把准好的音乐拖到 Audio Clip中;

    4.勾选Bypass Effects (打开音频特效)、Play On Awake(开机自动播放)、(Loop:循环播放)

   //音乐文件
    public AudioSource music;
    //音量
    public float musicVolume;
    //音乐控制标志位
    bool flag = false;
    void Start()
    {
        //设置默认音量
        musicVolume = 0.5F;
    }
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.L))
        {
            flag = true;//弹出音乐控制台
        }
        if (Input.GetKeyDown(KeyCode.O))
        {
            flag = false;关闭音乐控制台
        }
       
    }
    void OnGUI()
    {
        if(flag)
        {
            //播放音乐按钮
            if (GUI.Button(new Rect(10, 10, 100, 50), "Play music"))
            {
                //没有播放中
                if (!music.isPlaying)
                {
                    //播放音乐
                    music.Play();
                }
            }
            //关闭音乐按钮
            if (GUI.Button(new Rect(10, 60, 100, 50), "Stop music"))
            {
                if (music.isPlaying)
                {
                    //关闭音乐
                    music.Stop();
                }
            }
            //暂停音乐
            if (GUI.Button(new Rect(10, 110, 100, 50), "Pause music"))
            {
                if (music.isPlaying)
                {
                    //暂停音乐
                    //这里说一下音乐暂停以后
                    //点击播放音乐为继续播放
                    //而停止以后在点击播放音乐
                    //则为从新播放
                    //这就是暂停与停止的区别
                    music.Pause();
                }
            }

            //创建一个横向滑动条用于动态修改音乐音量
            //第一个参数 滑动条范围
            //第二个参数 初始滑块位置
            //第三个参数 起点
            //第四个参数 终点
            musicVolume = GUI.HorizontalSlider(new Rect(160, 10, 100, 50), musicVolume, 0.0F, 1.0F);
            //将音量的百分比打印出来
            GUI.Label(new Rect(160, 50, 300, 20), "Music Volueme is " + (int)(musicVolume * 100) + "%");
            if (music.isPlaying)
            {
                //音乐播放中设置音乐音量 取值范围 0.0F到 1.0
                music.volume = musicVolume;
            }
        }
    }      

   最终结果:
   
  
    
没有更多推荐了,返回首页