Unity3D游戏开发之在3D场景中选择物体并显示轮廓效果



博客地址是blog.youkuaiyun.com/qinyuanpei。

在《仙剑奇侠传》、《古剑奇谭》等游戏中，经常需要玩家在一个3D场景中选取场景中的物体。比如为我方角色添加状态、为我方角色增加血量、选择要攻击的敌人等，通常我们使用鼠标来选择一个目标物体，当鼠标移动到目标物体上时，目标物体将显示轮廓线，此时就表示当前物体被选中，我们可以在此基础上为游戏物体进行一系列的操作。那么，这一功能如何在Unity3D中实现呢？首先我们可以将问题分解为两个子问题：第一，如何确定物体是否被选中；第二，物体被选中后如何清晰地传达给用户。如图是古剑奇谭和仙剑奇侠传的战斗画面：

接下来，我们分别来解决这两个问题。对于第一个问题，我们可以采取射线检测的方法，即从摄像机向鼠标所在的位置发射射线，如果该射线击中了游戏场景中的物体，我们就认为该物体被选中了。对于第二个问题，我们需要让物体的轮廓线显示出来，这是我们今天着重要研究的地方。在Unity3D中我们可以通过Shader 即着色器来实现更改材质的渲染方法。Unity3D内置了6类着色器，从简单的VertexLit到复杂的带有 高光的视差凹凸贴图(Parallax Bumped with Specular),共30个。其中：

1、Normal：适用于不透明的物体

2、Transparent：适用于半透明的物体，透明度由贴图的alpha通道决定

3、TransparentCutOut：适用于某些部分透明，某些部分不透明的物体

4、Self-Illuminated：适用于需要自发光的物体

5、Reflective：适用于需要反射环境光的物体

6、Lightmapped：适用于需要添加光照贴图及相应的UV坐标数值

从一般的意义上来说，着色器定义了渲染物体的方法、材质中指定的贴图、用于渲染的顶点及片段着色程序、材质中调整的颜色以及各种数值设定。而相对应地，材质决定我们将使用那些贴图来渲染、使用哪些颜色渲染等。在今天的文章中，我们将定义下面的着色器代码：

 

view source print ?

001. Shader "Custom/BoundryShader" {

002. Properties {

003.         //定义材质的颜色为白色

004.         _Color ("Main Color", Color) = (1,1,1,1)

005.         //定义材质的轮廓线为黑色

006.         _OutlineColor ("Outline Color", Color) = (0,0,0,1)  //改变这个能改变轮廓边的颜色

007.         //定义线宽

008.         _Outline ("Outline width", Range (0.0, 0.03)) = 0.001   //改变这个能改变轮廓边的粗细

009.         _MainTex ("Base (RGB)", 2D) = "white" { }

010.     }

011.      

012. CGINCLUDE

013. #include "UnityCG.cginc"

014.  

015. struct appdata {

016.     float4 vertex : POSITION;

017.     float3 normal : NORMAL;

018. };

019.  

020. struct v2f {

021.     float4 pos : POSITION;

022.     float4 color : COLOR;

023. };

024.  

025. uniform float _Outline;

026. uniform float4 _OutlineColor;

027.  

028. v2f vert(appdata v) {

029.     // just make a copy of incoming vertex data but scaled according to normal direction

030.     v2f o;

031.     o.pos = mul(UNITY_MATRIX_MVP, v.vertex);

032.  

033.     float3 norm   = mul ((float3x3)UNITY_MATRIX_IT_MV, v.normal);

034.     float2 offset = TransformViewToProjection(norm.xy);

035.  

036.     o.pos.xy += offset * o.pos.z * _Outline;

037.     o.color = _OutlineColor;

038.     return o;

039. }

040. ENDCG

041.  

042.     SubShader {

043.         Tags { "Queue" = "Transparent" }

044.  

045.         // note that a vertex shader is specified here but its using the one above

046.         Pass {

047.             Name "OUTLINE"

048.             Tags { "LightMode" = "Always" }

049.             Cull Off

050.             ZWrite Off

051.             ZTest Always

052.             ColorMask RGB // alpha not used

053.  

054.             // you can choose what kind of blending mode you want for the outline

055.             Blend SrcAlpha OneMinusSrcAlpha // Normal

056.             //Blend One One // Additive

057.             //Blend One OneMinusDstColor // Soft Additive

058.             //Blend DstColor Zero // Multiplicative

059.             //Blend DstColor SrcColor // 2x Multiplicative

060.  

061. CGPROGRAM

062. #pragma vertex vert

063. #pragma fragment frag

064.  

065. half4 frag(v2f i) :COLOR {

066.     return i.color;

067. }

068. ENDCG

069.         }

070.  

071.         Pass {

072.             Name "BASE"

073.             ZWrite On

074.             ZTest LEqual

075.             Blend SrcAlpha OneMinusSrcAlpha

076.             Material {

077.                 Diffuse [_Color]

078.                 Ambient [_Color]

079.             }

080.             Lighting On

081.             SetTexture [_MainTex] {

082.                 ConstantColor [_Color]

083.                 Combine texture * constant

084.             }

085.             SetTexture [_MainTex] {

086.                 Combine previous * primary DOUBLE

087.             }

088.         }

089.     }

090.      

091.     SubShader {

092.         Tags { "Queue" = "Transparent" }

093.  

094.         Pass {

095.             Name "OUTLINE"

096.             Tags { "LightMode" = "Always" }

097.             Cull Front

098.             ZWrite Off

099.             ZTest Always

100.             ColorMask RGB

101.  

102.             // you can choose what kind of blending mode you want for the outline

103.             Blend SrcAlpha OneMinusSrcAlpha // Normal

104.             //Blend One One // Additive

105.             //Blend One OneMinusDstColor // Soft Additive

106.             //Blend DstColor Zero // Multiplicative

107.             //Blend DstColor SrcColor // 2x Multiplicative

108.  

109.             CGPROGRAM

110.             #pragma vertex vert

111.             #pragma exclude_renderers gles xbox360 ps3

112.             ENDCG

113.             SetTexture [_MainTex] { combine primary }

114.         }

115.  

116.         Pass {

117.             Name "BASE"

118.             ZWrite On

119.             ZTest LEqual

120.             Blend SrcAlpha OneMinusSrcAlpha

121.             Material {

122.                 Diffuse [_Color]

123.                 Ambient [_Color]

124.             }

125.             Lighting On

126.             SetTexture [_MainTex] {

127.                 ConstantColor [_Color]

128.                 Combine texture * constant

129.             }

130.             SetTexture [_MainTex] {

131.                 Combine previous * primary DOUBLE

132.             }

133.         }

134.     }

135.      

136.     Fallback "Diffuse"

137. }

对于着色器程序的编写，我们此时可以先放在一边，这里我们着重来学习如何使用着色器来实现不同的渲染效果。我们新建一个材质，将该材质的着色器设置为我们这里编写的着色器，如图：

 

好，在准备好材质后，我们就可以正式开始今天的内容啦，我们创建一个简单的场景：

注意到这里的物体时没有轮廓线的，因为我们这里使用的是默认材质Default-Diffuse。那么，接下来，我们通过编程的方式来动态更换材质，这样就可以实现不同的渲染效果，编写下面的脚本：

 

view source print ?

01. using UnityEngine;

02. using System.Collections;

03.  

04. public class ShowBoundry : MonoBehaviour {

05.  

06.     //使用显示轮廓的简单材质

07.     public Material mSimpleMat;

08.     //使用显示轮廓的高级材质

09.     public Material mAdvanceMat;

10.     //默认材质

11.     public Material mDefaultMat;

12.      

13.  

14.     void Update ()

15.     {

16.        //获取鼠标位置

17.        Vector3 mPos=Input.mousePosition;

18.        //向物体发射射线

19.        Ray mRay=Camera.main.ScreenPointToRay(Input.mousePosition);

20.        RaycastHit mHit;

21.        //射线检验

22.        if(Physics.Raycast(mRay,out mHit))

23.        {

24.           //Cube

25.           if(mHit.collider.gameObject.tag=="Cube")

26.           {

27.              //将当前选中的对象材质换成带轮廓线的材质

28.              mHit.collider.gameObject.renderer.material=mSimpleMat;

29.              //将未选中的对象材质换成默认材质

30.              GameObject.Find("Sphere").renderer.material=mDefaultMat;

31.              //设置提示信息

32.              GameObject.Find("GUIText").guiText.text="当前选择的对象是:Cube";

33.           }

34.           //Sphere

35.           if(mHit.collider.gameObject.tag=="Sphere")

36.           {

37.              //将当前选中的对象材质换成带轮廓线的材质

38.              mHit.collider.gameObject.renderer.material=mSimpleMat;

39.              //将未选中的对象材质换成默认材质

40.              GameObject.Find("Cube").renderer.material=mDefaultMat;

41.              //设置提示信息

42.              GameObject.Find("GUIText").guiText.text="当前选择的对象是:Sphere";

43.           }

44.           //Person

45.           if(mHit.collider.gameObject.tag=="Person")

46.           {

47.              //由于人物模型的材质较为复杂，所以不能使用这种方法

48.           }

49.        }

50.  

51.     }

52. }

在上面的这段脚本中，首先我们指定了三个材质，分别是适用于简单物体(如Cube等）的带轮廓线的材质，适用于复杂物体(如人物模型）的带轮廓线的材质( 本文未实现)、适用于简单物体的默认材质。主要原理就是我们在文章开头就提到过的射线检验方法。我们将这个脚本绑定到游戏场景中的物体上，设置好tag后就可以运行程序了，我们一起来看看程序的效果吧！

 

这就是我们今天想要实现的效果啦，通过今天的文章我们可以实现在3D场景中对一个物体的选取，这种需求在游戏里还是比较多的啊，哈哈。那么，对于复杂的人物模型怎么办呢？模型一般会有很多张贴图，如果我们针对每一张贴图再去制作与之对应的材质文件，是不是会有些繁琐呢？那么请大家关注我的博客，我们将在下一篇文章中为大家揭晓。好了，老规矩，为大家送上一句充满力量的话，早安！

 

每日箴言 ：人生就像一座山，重要的不是它的高低，而在于它的灵秀。

 

出处：http://blog.youkuaiyun.com/qinyuanpei/article/details/26435473