shader实例(二十六)水(反射,法线,透明)

unity自带的资源中有水的例子,导入步骤为:Assets-Import Package-Water (Pro Only),熟悉相关参数就可以调出很漂亮的水效果,但是作为程序员不能只停留在使用层,了解其中的原理才是我们追寻的目标。

先看看效果,这样学习兴趣会更大。

因为unity自带demo集成的比较多,作为新手很难进行学习,所以就在网上先找关于反射的资料,不找不知道一找吓一跳,反射才不简单!不过现在不用看懂它会用就好,在这里反射被封装为一个名为Mirror的cs脚本,将这个脚本绑定到水的对象上就可以获取当前反射的贴图,然后将贴图传到shader中就可以显示。之前有接触过grabpass,法线贴图,所以现在只需要加上反射就能实现一个普通水的效果,显然通过设置参数这个shader还可以用于镜面反射,玻璃效果等等。而在这之前完全不懂这些是啥,所以获得经验:有规划的进行学习终究有所收获。

原理和shader代码如下(有不对的地方希望能指出):

Shader "Mirrors/Transparent Bumped Specular Flat" {

Properties {

_Speed ("UV移动速度", Range (-1,1)) = 0

_Transparency("材质透明度", Range (0, 1)) = 1

_Distortion ("针对法线贴图的扭曲程度", range (0,0.4)) = 0

_Color ("主色", Color) = (1,1,1,1)

_MainTex ("主材质", 2D) = "white" {}

_BlendLevel("主材质显示强度",Range(0,1))=1

_SpecColor ("镜面颜色", Color) = (0.5, 0.5, 0.5, 1)

_Shininess ("镜面强度", Range (0.01, 1)) = 0.078125

_BumpMap ("法线贴图", 2D) = "bump" {}

_Bumpness ("法线颜色强度",Range(0,1))= 1

_Ref ("来自镜面反射", 2D) = "white" {}

}

SubShader {

Tags { "Queue"="Transparent" "RenderType"="Opaque" }

GrabPass {

Name "BASE"

Tags { "LightMode" = "Always" }

}

CGPROGRAM

#pragma surface surf BlinnPhong

#pragma target 3.0

half _Speed;// uv移动速度

half _Transparency;//材质透明度

half _Distortion;// 扭曲强度

fixed4 _Color;//主色

sampler2D _MainTex;// 主材质图

half _BlendLevel;// 主材质强度

half _Shininess;// 镜面强度

sampler2D _BumpMap;// 法线贴图

half _Bumpness;// 法线颜色强度

sampler2D _Ref;// 反射贴图

sampler2D _GrabTexture;// 屏幕纹理

struct Input {

float2 uv_MainTex;// 主贴图

float2 uv_BumpMap;// 法线贴图

float4 screenPos;// 顶点在屏幕坐标的位置

};

void surf (Input IN, inout SurfaceOutput o) {

// 移动法线纹理的X

IN.uv_BumpMap.x = IN.uv_BumpMap.x + _Speed * _Time;

// 对法线贴图进行采样

fixed3 nor = UnpackNormal (tex2D(_BumpMap, IN.uv_BumpMap));

// 对主材质进行采样

fixed4 tex = tex2D(_MainTex, IN.uv_MainTex);

// 【将反射的图像正常显示在此对象上】

// 获取屏幕纹理坐标信息

float2 screenUV = IN.screenPos.xy / IN.screenPos.w;

// 针对法线纹理做法线扭曲,_Distortion为扭曲强度

screenUV += nor.xy * _Distortion ;

// 对反射纹理进行采样,通过屏幕纹理

fixed4 ref = tex2D(_Ref, screenUV);

// 【将屏幕的纹理正常显示在此对象上】,如果不需要半透明可去掉

// 获取顶点在屏幕的坐标为纹理

float4 screenUV2 = IN.screenPos;

// 以下是根据平台来判断是否需要倒置Y坐标

// D3D:scale=-1,那么screenUV2.y = -1 * screenUV2.y + screenUV2.w;【倒置后+w让值域保持为0到1】

// OpenGL:scale=1,那么screenUV2.y = screenUV2.y;

#if UNITY_UV_STARTS_AT_TOP

float scale = -1.0;

#else

float scale = 1.0;

#endif

screenUV2.y = (screenUV2.y - screenUV2.w * 0.5) * scale + screenUV2.w * 0.5;

screenUV2.xy = screenUV2.xy / screenUV2.w;

// 针对法线纹理做的法线扭曲,_Distortion为强度

screenUV2.xy += nor.xy * _Distortion;

// 对屏幕纹理进行采样

fixed4 trans = tex2D(_GrabTexture,screenUV2.xy);

// 最终颜色 = 主材质颜色 * 主颜色 * 主色显示强度

o.Albedo = tex.rgb * _Color.rgb * _BlendLevel;

// 反射颜色 = 反射材质颜色和【屏幕纹理颜色】的插值

o.Emission = lerp(ref.rgb,trans.rgb,_Transparency);

// 法线值 = 法线材质颜色 * 法线强度

o.Normal = nor.rgb * _Bumpness;

// 发光强度 = 主纹理A

o.Gloss = tex.a;

// 透明度 = 主色

o.Alpha = tex.a * _Color.a;

// 镜面高光【高光需要针对针对非立方体,如果是平面BlinnPhong也无效】

o.Specular = _Shininess * _SpecColor;

}

ENDCG

}//end subshader

}

镜子代码Mirror 如下:

using UnityEngine;

using System.Collections;

[ExecuteInEditMode]

public class Mirror : MonoBehaviour

{

 public bool m_DisablePixelLights = true;

 public int m_TextureSize = 256;

 public float m_ClipPlaneOffset = 0.07f;

public bool m_IsFlatMirror = true;

 public LayerMask m_ReflectLayers = -1;

 private Hashtable m_ReflectionCameras = new Hashtable();

 private RenderTexture m_ReflectionTexture = null;

 private int m_OldReflectionTextureSize = 0;

 private static bool s_InsideRendering = false;

 public void OnWillRenderObject()

 {

 if( !enabled || !renderer || !renderer.sharedMaterial || !renderer.enabled )

 return;

 Camera cam = Camera.current;

 if( !cam )

 return;

 if( s_InsideRendering )

 return;

 s_InsideRendering = true;

 Camera reflectionCamera;

 CreateMirrorObjects( cam, out reflectionCamera );

 Vector3 pos = transform.position;

Vector3 normal;

if(m_IsFlatMirror){

 normal = transform.up;

}

else{

normal= transform.position - cam.transform.position ;

normal.Normalize();

}

 int oldPixelLightCount = QualitySettings.pixelLightCount;

 if( m_DisablePixelLights )

 QualitySettings.pixelLightCount = 0;

 UpdateCameraModes( cam, reflectionCamera );

 float d = -Vector3.Dot (normal, pos) - m_ClipPlaneOffset;

 Vector4 reflectionPlane = new Vector4 (normal.x, normal.y, normal.z, d);

 Matrix4x4 reflection = Matrix4x4.zero;

 CalculateReflectionMatrix (ref reflection, reflectionPlane);

 Vector3 oldpos = cam.transform.position;

 Vector3 newpos = reflection.MultiplyPoint( oldpos );

 reflectionCamera.worldToCameraMatrix = cam.worldToCameraMatrix * reflection;

 Vector4 clipPlane = CameraSpacePlane( reflectionCamera, pos, normal, 1.0f );

 Matrix4x4 projection = cam.projectionMatrix;

 CalculateObliqueMatrix (ref projection, clipPlane);

 reflectionCamera.projectionMatrix = projection;

 reflectionCamera.cullingMask = ~(1<<4) & m_ReflectLayers.value;

 reflectionCamera.targetTexture = m_ReflectionTexture;

 GL.SetRevertBackfacing (true);

 reflectionCamera.transform.position = newpos;

 Vector3 euler = cam.transform.eulerAngles;

 reflectionCamera.transform.eulerAngles = new Vector3(0, euler.y, euler.z);

 reflectionCamera.Render();

 reflectionCamera.transform.position = oldpos;

 GL.SetRevertBackfacing (false);

 Material[] materials = renderer.sharedMaterials;

 foreach( Material mat in materials ) {

 if( mat.HasProperty("_Ref") )

 mat.SetTexture( "_Ref", m_ReflectionTexture );

 }

 if( m_DisablePixelLights )

 QualitySettings.pixelLightCount = oldPixelLightCount;

 s_InsideRendering = false;

 }

 void OnDisable()

 {

 if( m_ReflectionTexture ) {

 DestroyImmediate( m_ReflectionTexture );

 m_ReflectionTexture = null;

 }

 foreach( DictionaryEntry kvp in m_ReflectionCameras )

 DestroyImmediate( ((Camera)kvp.Value).gameObject );

 m_ReflectionCameras.Clear();

 }

 private void UpdateCameraModes( Camera src, Camera dest )

 {

 if( dest == null )

 return;

 dest.clearFlags = src.clearFlags;

 dest.backgroundColor = src.backgroundColor;

 if( src.clearFlags == CameraClearFlags.Skybox )

 {

 Skybox sky = src.GetComponent(typeof(Skybox)) as Skybox;

 Skybox mysky = dest.GetComponent(typeof(Skybox)) as Skybox;

 if( !sky || !sky.material )

 {

 mysky.enabled = false;

 }

 else

 {

 mysky.enabled = true;

 mysky.material = sky.material;

 }

 }

 dest.farClipPlane = src.farClipPlane;

 dest.nearClipPlane = src.nearClipPlane;

 dest.orthographic = src.orthographic;

 dest.fieldOfView = src.fieldOfView;

 dest.aspect = src.aspect;

 dest.orthographicSize = src.orthographicSize;

dest.renderingPath = src.renderingPath;

 }

 private void CreateMirrorObjects( Camera currentCamera, out Camera reflectionCamera )

 {

 reflectionCamera = null;

 if( !m_ReflectionTexture || m_OldReflectionTextureSize != m_TextureSize )

 {

 if( m_ReflectionTexture )

 DestroyImmediate( m_ReflectionTexture );

 m_ReflectionTexture = new RenderTexture( m_TextureSize, m_TextureSize, 16 );

 m_ReflectionTexture.name = "__MirrorReflection" + GetInstanceID();

 m_ReflectionTexture.isPowerOfTwo = true;

 m_ReflectionTexture.hideFlags = HideFlags.DontSave;

 m_OldReflectionTextureSize = m_TextureSize;

 }

 reflectionCamera = m_ReflectionCameras[currentCamera] as Camera;

 if( !reflectionCamera )

 {

 GameObject go = new GameObject( "Mirror Refl Camera id" + GetInstanceID() + " for " + currentCamera.GetInstanceID(), typeof(Camera), typeof(Skybox) );

 reflectionCamera = go.camera;

 reflectionCamera.enabled = false;

 reflectionCamera.transform.position = transform.position;

 reflectionCamera.transform.rotation = transform.rotation;

 reflectionCamera.gameObject.AddComponent("FlareLayer");

 go.hideFlags = HideFlags.HideAndDontSave;

 m_ReflectionCameras[currentCamera] = reflectionCamera;

 }

 }

 private static float sgn(float a)

 {

 if (a > 0.0f) return 1.0f;

 if (a < 0.0f) return -1.0f;

 return 0.0f;

 }

 private Vector4 CameraSpacePlane (Camera cam, Vector3 pos, Vector3 normal, float sideSign)

 {

 Vector3 offsetPos = pos + normal * m_ClipPlaneOffset;

 Matrix4x4 m = cam.worldToCameraMatrix;

 Vector3 cpos = m.MultiplyPoint( offsetPos );

 Vector3 cnormal = m.MultiplyVector( normal ).normalized * sideSign;

 return new Vector4( cnormal.x, cnormal.y, cnormal.z, -Vector3.Dot(cpos,cnormal) );

 }

 private static void CalculateObliqueMatrix (ref Matrix4x4 projection, Vector4 clipPlane)

 {

 Vector4 q = projection.inverse * new Vector4(

 sgn(clipPlane.x),

 sgn(clipPlane.y),

 1.0f,

 1.0f

 );

 Vector4 c = clipPlane * (2.0F / (Vector4.Dot (clipPlane, q)));

 projection[2] = c.x - projection[3];

 projection[6] = c.y - projection[7];

 projection[10] = c.z - projection[11];

 projection[14] = c.w - projection[15];

 }

 private static void CalculateReflectionMatrix (ref Matrix4x4 reflectionMat, Vector4 plane)

 {

 reflectionMat.m00 = (1F - 2F*plane[0]*plane[0]);

 reflectionMat.m01 = ( - 2F*plane[0]*plane[1]);

 reflectionMat.m02 = ( - 2F*plane[0]*plane[2]);

 reflectionMat.m03 = ( - 2F*plane[3]*plane[0]);

 reflectionMat.m10 = ( - 2F*plane[1]*plane[0]);

 reflectionMat.m11 = (1F - 2F*plane[1]*plane[1]);

 reflectionMat.m12 = ( - 2F*plane[1]*plane[2]);

 reflectionMat.m13 = ( - 2F*plane[3]*plane[1]);

 reflectionMat.m20 = ( - 2F*plane[2]*plane[0]);

 reflectionMat.m21 = ( - 2F*plane[2]*plane[1]);

 reflectionMat.m22 = (1F - 2F*plane[2]*plane[2]);

 reflectionMat.m23 = ( - 2F*plane[3]*plane[2]);

 reflectionMat.m30 = 0F;

 reflectionMat.m31 = 0F;

 reflectionMat.m32 = 0F;

 reflectionMat.m33 = 1F;

 }

}

转自:http://blog.sina.com.cn/s/blog_89d90b7c0102vgk1.html

推荐阅读更多精彩内容