Unity Shaders and Effects Cookbook (4-4)在Cubemap 上使用法线贴图 (法线贴图与反射)

法线贴图在之前学习过了，我们使用法线贴图在低分辨率的模型上模拟高分辨率的效果。

Unity中通过 UnpackNormal 函数来使用法线贴图。

之前学习法线贴图的记录

Unity Shaders and Effects Cookbook (2-5) 如何使用法线贴图

这一节讲的是在Cubemap 上使用法线贴图。模拟凹凸效果。

最终效果如图

一起来做吧。

首先搭建好场景，和上一节一样。

导入法线贴图

创建材质、Shader 。

复制上一节的 Shader 就行。然后修改成下面的内容。

Shader "CookBookShaders/Chapt4-4/Cubemap_NormalMap"
{
	Properties
	{
		_MainTint("Diffuse Color",Color)=(1,1,1,1)
		_MainTex ("Base (RGB)", 2D) = "white" {}

		_NormalMap("Normal Map",2D) = "bump"{}

		_Cubemap("Cubemap",CUBE)=""{}

		_ReflAmount("Reflection Amount",Range(0,1))=0.5
	}

	SubShader
	{
		Tags { "RenderType"="Opaque" }
		LOD 200

		CGPROGRAM
		#pragma surface surf Lambert

		float4 _MainTint;
		sampler2D _MainTex;

		sampler2D _NormalMap;

		samplerCUBE _Cubemap;

		float _ReflAmount;

		struct Input
		{
			float2 uv_MainTex;

			float2 uv_NormalMap;

			float3 worldRefl;

			INTERNAL_DATA
		};

		void surf (Input IN, inout SurfaceOutput o)
		{
			half4 c = tex2D (_MainTex, IN.uv_MainTex);

			//从法线贴图中提取法线信息，UnpackNormal这个函数在 CGInclude 文件夹中的Lighting中。
			float3 normals=UnpackNormal(tex2D(_NormalMap,IN.uv_NormalMap));

			o.Normal=normals;

			//上面使用法线贴图中的法线数据 替代了 原来的法线数据。

			//法线被修改了，就不能 直接用原来的 内置属性 worldRefl 这个反射向量，而是要通过 WorldReflectionVector(IN,o.Normal)来获取。

			//使用WorldReflectionVector 获得 基于法线贴图中的反射向量的 世界反射向量
			o.Emission = texCUBE(_Cubemap,WorldReflectionVector(IN,o.Normal)).rgb * _ReflAmount;

			o.Albedo = c.rgb * _MainTint;
			o.Alpha = c.a;
		}
		ENDCG
	}
	FallBack "Diffuse"
}

和上一节的Shader 相比，修改了如下几处：

1、在 Properties 属性块中添加了法线贴图

_NormalMap("Normal Map",2D) = "bump"{}

然后在 SubShader 中添加对应的变量

sampler2D _NormalMap;

2、在 Input 中添加了法线贴图的UV，以及一个奇怪的字段 INTERNAL_DATA

		struct Input
		{
			float2 uv_MainTex;

			float2 uv_NormalMap;

			float3 worldRefl;

			INTERNAL_DATA
		};

uv_NormalMap 是用来读取法线贴图数据的。

转自http://blog.csdn.net/huutu http://www.thisisgame.com.cn

INTERNAL_DATA

书上有两点解释

A：通过在Input 中添加 INTERNAL_DATA ，我们就可以访问由法线贴图修改后的表面法线。

这个很奇怪，为什么要添加 INTERNAL_DATA，才可以访问由法线贴图修改后的表面法线？上次学习法线贴图的时候可没有这个东西。

习惯性到 CGIncludes 里面去查找，发现并没有 INTERNAL_DATA 。

在官方文档

http://docs.unity3d.com/Manual/SL-SurfaceShaderExamples.html

找到这一句话

If you want to do reflections that are affected by normal maps, it needs to be slightly more involved: INTERNAL_DATA needs to be added to the Input structure, and WorldReflectionVector function used to compute per-pixel reflection vector after you’ve written the Normal output.

就是说计算世界反射向量的时候使用了法线贴图就要加上这个。

谷歌一下，发现网友说在生成的代码中能看出来，然后就查看生成的代码

Shader "CookBookShaders/Chapt4-4/Cubemap_NormalMap"
{
	Properties
	{
		_MainTint("Diffuse Color",Color)=(1,1,1,1)
		_MainTex ("Base (RGB)", 2D) = "white" {}

		_NormalMap("Normal Map",2D) = "bump"{}

		_Cubemap("Cubemap",CUBE)=""{}

		_ReflAmount("Reflection Amount",Range(0,1))=0.5
	}

	SubShader
	{
		Tags { "RenderType"="Opaque" }
		LOD 200

	// ------------------------------------------------------------
	// Surface shader code generated out of a CGPROGRAM block:

	// ---- forward rendering base pass:
	Pass {
		Name "FORWARD"
		Tags { "LightMode" = "ForwardBase" }

CGPROGRAM
// compile directives
#pragma vertex vert_surf
#pragma fragment frag_surf
#pragma multi_compile_fwdbase
#include "HLSLSupport.cginc"
#include "UnityShaderVariables.cginc"
#define UNITY_PASS_FORWARDBASE
#include "UnityCG.cginc"
#include "Lighting.cginc"
#include "AutoLight.cginc"

#define INTERNAL_DATA half3 TtoW0; half3 TtoW1; half3 TtoW2;
#define WorldReflectionVector(data,normal) reflect (data.worldRefl, half3(dot(data.TtoW0,normal), dot(data.TtoW1,normal), dot(data.TtoW2,normal)))
#define WorldNormalVector(data,normal) fixed3(dot(data.TtoW0,normal), dot(data.TtoW1,normal), dot(data.TtoW2,normal))

// Original surface shader snippet:
#line 18 ""
#ifdef DUMMY_PREPROCESSOR_TO_WORK_AROUND_HLSL_COMPILER_LINE_HANDLING
#endif

		//#pragma surface surf Lambert

		float4 _MainTint;
		sampler2D _MainTex;

		sampler2D _NormalMap;

		samplerCUBE _Cubemap;

		float _ReflAmount;

		struct Input
		{
			float2 uv_MainTex;

			float2 uv_NormalMap;

			float3 worldRefl;

			INTERNAL_DATA
		};

		void surf (Input IN, inout SurfaceOutput o)
		{
			half4 c = tex2D (_MainTex, IN.uv_MainTex);

			//从法线贴图中提取法线信息，UnpackNormal这个函数在 CGInclude 文件夹中的Lighting中。
			float3 normals=UnpackNormal(tex2D(_NormalMap,IN.uv_NormalMap));

			o.Normal=normals;

			//上面使用法线贴图中的法线数据 替代了 原来的法线数据。

			//法线被修改了，就不能 直接用原来的 内置属性 worldRefl 这个反射向量，而是要通过 WorldReflectionVector(IN,o.Normal)来获取。

			//使用WorldReflectionVector 获得 基于法线贴图中的反射向量的 世界反射向量
			o.Emission = texCUBE(_Cubemap,WorldReflectionVector(IN,o.Normal)).rgb * _ReflAmount;

			o.Albedo = c.rgb * _MainTint;
			o.Alpha = c.a;
		}

// vertex-to-fragment interpolation data
#ifdef LIGHTMAP_OFF
struct v2f_surf {
  float4 pos : SV_POSITION;
  float4 pack0 : TEXCOORD0;
  fixed4 TtoW0 : TEXCOORD1;
  fixed4 TtoW1 : TEXCOORD2;
  fixed4 TtoW2 : TEXCOORD3;
  fixed3 lightDir : TEXCOORD4;
  fixed3 vlight : TEXCOORD5;
  LIGHTING_COORDS(6,7)
};
#endif
#ifndef LIGHTMAP_OFF
struct v2f_surf {
  float4 pos : SV_POSITION;
  float4 pack0 : TEXCOORD0;
  fixed4 TtoW0 : TEXCOORD1;
  fixed4 TtoW1 : TEXCOORD2;
  fixed4 TtoW2 : TEXCOORD3;
  float2 lmap : TEXCOORD4;
  LIGHTING_COORDS(5,6)
};
#endif
#ifndef LIGHTMAP_OFF
float4 unity_LightmapST;
#endif
float4 _MainTex_ST;
float4 _NormalMap_ST;

// vertex shader
v2f_surf vert_surf (appdata_full v) {
  v2f_surf o;
  o.pos = mul (UNITY_MATRIX_MVP, v.vertex);
  o.pack0.xy = TRANSFORM_TEX(v.texcoord, _MainTex);
  o.pack0.zw = TRANSFORM_TEX(v.texcoord, _NormalMap);
  float3 viewDir = -ObjSpaceViewDir(v.vertex);
  float3 worldRefl = mul ((float3x3)_Object2World, viewDir);
  TANGENT_SPACE_ROTATION;
  o.TtoW0 = float4(mul(rotation, _Object2World[0].xyz), worldRefl.x)*unity_Scale.w;
  o.TtoW1 = float4(mul(rotation, _Object2World[1].xyz), worldRefl.y)*unity_Scale.w;
  o.TtoW2 = float4(mul(rotation, _Object2World[2].xyz), worldRefl.z)*unity_Scale.w;
  #ifndef LIGHTMAP_OFF
  o.lmap.xy = v.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
  #endif
  float3 worldN = mul((float3x3)_Object2World, SCALED_NORMAL);
  float3 lightDir = mul (rotation, ObjSpaceLightDir(v.vertex));
  #ifdef LIGHTMAP_OFF
  o.lightDir = lightDir;
  #endif

  // SH/ambient and vertex lights
  #ifdef LIGHTMAP_OFF
  float3 shlight = ShadeSH9 (float4(worldN,1.0));
  o.vlight = shlight;
  #ifdef VERTEXLIGHT_ON
  float3 worldPos = mul(_Object2World, v.vertex).xyz;
  o.vlight += Shade4PointLights (
    unity_4LightPosX0, unity_4LightPosY0, unity_4LightPosZ0,
    unity_LightColor[0].rgb, unity_LightColor[1].rgb, unity_LightColor[2].rgb, unity_LightColor[3].rgb,
    unity_4LightAtten0, worldPos, worldN );
  #endif // VERTEXLIGHT_ON
  #endif // LIGHTMAP_OFF

  // pass lighting information to pixel shader
  TRANSFER_VERTEX_TO_FRAGMENT(o);
  return o;
}
#ifndef LIGHTMAP_OFF
sampler2D unity_Lightmap;
#ifndef DIRLIGHTMAP_OFF
sampler2D unity_LightmapInd;
#endif
#endif

// fragment shader
fixed4 frag_surf (v2f_surf IN) : SV_Target {
  // prepare and unpack data
  #ifdef UNITY_COMPILER_HLSL
  Input surfIN = (Input)0;
  #else
  Input surfIN;
  #endif
  surfIN.uv_MainTex = IN.pack0.xy;
  surfIN.uv_NormalMap = IN.pack0.zw;
  surfIN.worldRefl = float3(IN.TtoW0.w, IN.TtoW1.w, IN.TtoW2.w);
  surfIN.TtoW0 = IN.TtoW0.xyz;
  surfIN.TtoW1 = IN.TtoW1.xyz;
  surfIN.TtoW2 = IN.TtoW2.xyz;
  #ifdef UNITY_COMPILER_HLSL
  SurfaceOutput o = (SurfaceOutput)0;
  #else
  SurfaceOutput o;
  #endif
  o.Albedo = 0.0;
  o.Emission = 0.0;
  o.Specular = 0.0;
  o.Alpha = 0.0;
  o.Gloss = 0.0;

  // call surface function
  surf (surfIN, o);

  // compute lighting & shadowing factor
  fixed atten = LIGHT_ATTENUATION(IN);
  fixed4 c = 0;

  // realtime lighting: call lighting function
  #ifdef LIGHTMAP_OFF
  c = LightingLambert (o, IN.lightDir, atten);
  #endif // LIGHTMAP_OFF || DIRLIGHTMAP_OFF
  #ifdef LIGHTMAP_OFF
  c.rgb += o.Albedo * IN.vlight;
  #endif // LIGHTMAP_OFF

  // lightmaps:
  #ifndef LIGHTMAP_OFF
    #ifndef DIRLIGHTMAP_OFF
      // directional lightmaps
      fixed4 lmtex = tex2D(unity_Lightmap, IN.lmap.xy);
      fixed4 lmIndTex = tex2D(unity_LightmapInd, IN.lmap.xy);
      half3 lm = LightingLambert_DirLightmap(o, lmtex, lmIndTex, 1).rgb;
    #else // !DIRLIGHTMAP_OFF
      // single lightmap
      fixed4 lmtex = tex2D(unity_Lightmap, IN.lmap.xy);
      fixed3 lm = DecodeLightmap (lmtex);
    #endif // !DIRLIGHTMAP_OFF

    // combine lightmaps with realtime shadows
    #ifdef SHADOWS_SCREEN
      #if defined(UNITY_NO_RGBM)
      c.rgb += o.Albedo * min(lm, atten*2);
      #else
      c.rgb += o.Albedo * max(min(lm,(atten*2)*lmtex.rgb), lm*atten);
      #endif
    #else // SHADOWS_SCREEN
      c.rgb += o.Albedo * lm;
    #endif // SHADOWS_SCREEN
  c.a = o.Alpha;
  #endif // LIGHTMAP_OFF

  c.rgb += o.Emission;
  return c;
}

ENDCG

}

	// ---- forward rendering additive lights pass:
	Pass {
		Name "FORWARD"
		Tags { "LightMode" = "ForwardAdd" }
		ZWrite Off Blend One One Fog { Color (0,0,0,0) }

CGPROGRAM
// compile directives
#pragma vertex vert_surf
#pragma fragment frag_surf
#pragma multi_compile_fwdadd
#include "HLSLSupport.cginc"
#include "UnityShaderVariables.cginc"
#define UNITY_PASS_FORWARDADD
#include "UnityCG.cginc"
#include "Lighting.cginc"
#include "AutoLight.cginc"

#define INTERNAL_DATA
#define WorldReflectionVector(data,normal) data.worldRefl
#define WorldNormalVector(data,normal) normal

// Original surface shader snippet:
#line 18 ""
#ifdef DUMMY_PREPROCESSOR_TO_WORK_AROUND_HLSL_COMPILER_LINE_HANDLING
#endif

		//#pragma surface surf Lambert

		float4 _MainTint;
		sampler2D _MainTex;

		sampler2D _NormalMap;

		samplerCUBE _Cubemap;

		float _ReflAmount;

		struct Input
		{
			float2 uv_MainTex;

			float2 uv_NormalMap;

			float3 worldRefl;

			INTERNAL_DATA
		};

		void surf (Input IN, inout SurfaceOutput o)
		{
			half4 c = tex2D (_MainTex, IN.uv_MainTex);

			//从法线贴图中提取法线信息，UnpackNormal这个函数在 CGInclude 文件夹中的Lighting中。
			float3 normals=UnpackNormal(tex2D(_NormalMap,IN.uv_NormalMap));

			o.Normal=normals;

			//上面使用法线贴图中的法线数据 替代了 原来的法线数据。

			//法线被修改了，就不能 直接用原来的 内置属性 worldRefl 这个反射向量，而是要通过 WorldReflectionVector(IN,o.Normal)来获取。

			//使用WorldReflectionVector 获得 基于法线贴图中的反射向量的 世界反射向量
			o.Emission = texCUBE(_Cubemap,WorldReflectionVector(IN,o.Normal)).rgb * _ReflAmount;

			o.Albedo = c.rgb * _MainTint;
			o.Alpha = c.a;
		}

// vertex-to-fragment interpolation data
struct v2f_surf {
  float4 pos : SV_POSITION;
  float4 pack0 : TEXCOORD0;
  half3 lightDir : TEXCOORD1;
  LIGHTING_COORDS(2,3)
};
float4 _MainTex_ST;
float4 _NormalMap_ST;

// vertex shader
v2f_surf vert_surf (appdata_full v) {
  v2f_surf o;
  o.pos = mul (UNITY_MATRIX_MVP, v.vertex);
  o.pack0.xy = TRANSFORM_TEX(v.texcoord, _MainTex);
  o.pack0.zw = TRANSFORM_TEX(v.texcoord, _NormalMap);
  TANGENT_SPACE_ROTATION;
  float3 lightDir = mul (rotation, ObjSpaceLightDir(v.vertex));
  o.lightDir = lightDir;

  // pass lighting information to pixel shader
  TRANSFER_VERTEX_TO_FRAGMENT(o);
  return o;
}

// fragment shader
fixed4 frag_surf (v2f_surf IN) : SV_Target {
  // prepare and unpack data
  #ifdef UNITY_COMPILER_HLSL
  Input surfIN = (Input)0;
  #else
  Input surfIN;
  #endif
  surfIN.uv_MainTex = IN.pack0.xy;
  surfIN.uv_NormalMap = IN.pack0.zw;
  #ifdef UNITY_COMPILER_HLSL
  SurfaceOutput o = (SurfaceOutput)0;
  #else
  SurfaceOutput o;
  #endif
  o.Albedo = 0.0;
  o.Emission = 0.0;
  o.Specular = 0.0;
  o.Alpha = 0.0;
  o.Gloss = 0.0;

  // call surface function
  surf (surfIN, o);
  #ifndef USING_DIRECTIONAL_LIGHT
  fixed3 lightDir = normalize(IN.lightDir);
  #else
  fixed3 lightDir = IN.lightDir;
  #endif
  fixed4 c = LightingLambert (o, lightDir, LIGHT_ATTENUATION(IN));
  c.a = 0.0;
  return c;
}

ENDCG

}

	// ---- deferred lighting base geometry pass:
	Pass {
		Name "PREPASS"
		Tags { "LightMode" = "PrePassBase" }
		Fog {Mode Off}

CGPROGRAM
// compile directives
#pragma vertex vert_surf
#pragma fragment frag_surf

#pragma exclude_renderers flash
#include "HLSLSupport.cginc"
#include "UnityShaderVariables.cginc"
#define UNITY_PASS_PREPASSBASE
#include "UnityCG.cginc"
#include "Lighting.cginc"

#define INTERNAL_DATA
#define WorldReflectionVector(data,normal) data.worldRefl
#define WorldNormalVector(data,normal) normal

// Original surface shader snippet:
#line 18 ""
#ifdef DUMMY_PREPROCESSOR_TO_WORK_AROUND_HLSL_COMPILER_LINE_HANDLING
#endif

		//#pragma surface surf Lambert

		float4 _MainTint;
		sampler2D _MainTex;

		sampler2D _NormalMap;

		samplerCUBE _Cubemap;

		float _ReflAmount;

		struct Input
		{
			float2 uv_MainTex;

			float2 uv_NormalMap;

			float3 worldRefl;

			INTERNAL_DATA
		};

		void surf (Input IN, inout SurfaceOutput o)
		{
			half4 c = tex2D (_MainTex, IN.uv_MainTex);

			//从法线贴图中提取法线信息，UnpackNormal这个函数在 CGInclude 文件夹中的Lighting中。
			float3 normals=UnpackNormal(tex2D(_NormalMap,IN.uv_NormalMap));

			o.Normal=normals;

			//上面使用法线贴图中的法线数据 替代了 原来的法线数据。

			//法线被修改了，就不能 直接用原来的 内置属性 worldRefl 这个反射向量，而是要通过 WorldReflectionVector(IN,o.Normal)来获取。

			//使用WorldReflectionVector 获得 基于法线贴图中的反射向量的 世界反射向量
			o.Emission = texCUBE(_Cubemap,WorldReflectionVector(IN,o.Normal)).rgb * _ReflAmount;

			o.Albedo = c.rgb * _MainTint;
			o.Alpha = c.a;
		}

// vertex-to-fragment interpolation data
struct v2f_surf {
  float4 pos : SV_POSITION;
  float2 pack0 : TEXCOORD0;
  float3 TtoW0 : TEXCOORD1;
  float3 TtoW1 : TEXCOORD2;
  float3 TtoW2 : TEXCOORD3;
};
float4 _NormalMap_ST;

// vertex shader
v2f_surf vert_surf (appdata_full v) {
  v2f_surf o;
  o.pos = mul (UNITY_MATRIX_MVP, v.vertex);
  o.pack0.xy = TRANSFORM_TEX(v.texcoord, _NormalMap);
  TANGENT_SPACE_ROTATION;
  o.TtoW0 = mul(rotation, ((float3x3)_Object2World)[0].xyz)*unity_Scale.w;
  o.TtoW1 = mul(rotation, ((float3x3)_Object2World)[1].xyz)*unity_Scale.w;
  o.TtoW2 = mul(rotation, ((float3x3)_Object2World)[2].xyz)*unity_Scale.w;
  return o;
}

// fragment shader
fixed4 frag_surf (v2f_surf IN) : SV_Target {
  // prepare and unpack data
  #ifdef UNITY_COMPILER_HLSL
  Input surfIN = (Input)0;
  #else
  Input surfIN;
  #endif
  surfIN.uv_NormalMap = IN.pack0.xy;
  #ifdef UNITY_COMPILER_HLSL
  SurfaceOutput o = (SurfaceOutput)0;
  #else
  SurfaceOutput o;
  #endif
  o.Albedo = 0.0;
  o.Emission = 0.0;
  o.Specular = 0.0;
  o.Alpha = 0.0;
  o.Gloss = 0.0;

  // call surface function
  surf (surfIN, o);
  fixed3 worldN;
  worldN.x = dot(IN.TtoW0, o.Normal);
  worldN.y = dot(IN.TtoW1, o.Normal);
  worldN.z = dot(IN.TtoW2, o.Normal);
  o.Normal = worldN;

  // output normal and specular
  fixed4 res;
  res.rgb = o.Normal * 0.5 + 0.5;
  res.a = o.Specular;
  return res;
}

ENDCG

}

	// ---- deferred lighting final pass:
	Pass {
		Name "PREPASS"
		Tags { "LightMode" = "PrePassFinal" }
		ZWrite Off

CGPROGRAM
// compile directives
#pragma vertex vert_surf
#pragma fragment frag_surf
#pragma multi_compile_prepassfinal
#pragma exclude_renderers flash
#include "HLSLSupport.cginc"
#include "UnityShaderVariables.cginc"
#define UNITY_PASS_PREPASSFINAL
#include "UnityCG.cginc"
#include "Lighting.cginc"

#define INTERNAL_DATA half3 TtoW0; half3 TtoW1; half3 TtoW2;
#define WorldReflectionVector(data,normal) reflect (data.worldRefl, half3(dot(data.TtoW0,normal), dot(data.TtoW1,normal), dot(data.TtoW2,normal)))
#define WorldNormalVector(data,normal) fixed3(dot(data.TtoW0,normal), dot(data.TtoW1,normal), dot(data.TtoW2,normal))

// Original surface shader snippet:
#line 18 ""
#ifdef DUMMY_PREPROCESSOR_TO_WORK_AROUND_HLSL_COMPILER_LINE_HANDLING
#endif

		//#pragma surface surf Lambert

		float4 _MainTint;
		sampler2D _MainTex;

		sampler2D _NormalMap;

		samplerCUBE _Cubemap;

		float _ReflAmount;

		struct Input
		{
			float2 uv_MainTex;

			float2 uv_NormalMap;

			float3 worldRefl;

			INTERNAL_DATA
		};

		void surf (Input IN, inout SurfaceOutput o)
		{
			half4 c = tex2D (_MainTex, IN.uv_MainTex);

			//从法线贴图中提取法线信息，UnpackNormal这个函数在 CGInclude 文件夹中的Lighting中。
			float3 normals=UnpackNormal(tex2D(_NormalMap,IN.uv_NormalMap));

			o.Normal=normals;

			//上面使用法线贴图中的法线数据 替代了 原来的法线数据。

			//法线被修改了，就不能 直接用原来的 内置属性 worldRefl 这个反射向量，而是要通过 WorldReflectionVector(IN,o.Normal)来获取。

			//使用WorldReflectionVector 获得 基于法线贴图中的反射向量的 世界反射向量
			o.Emission = texCUBE(_Cubemap,WorldReflectionVector(IN,o.Normal)).rgb * _ReflAmount;

			o.Albedo = c.rgb * _MainTint;
			o.Alpha = c.a;
		}

// vertex-to-fragment interpolation data
struct v2f_surf {
  float4 pos : SV_POSITION;
  float4 pack0 : TEXCOORD0;
  float4 screen : TEXCOORD1;
  fixed4 TtoW0 : TEXCOORD2;
  fixed4 TtoW1 : TEXCOORD3;
  fixed4 TtoW2 : TEXCOORD4;
#ifdef LIGHTMAP_OFF
  float3 vlight : TEXCOORD5;
#else
  float2 lmap : TEXCOORD5;
#ifdef DIRLIGHTMAP_OFF
  float4 lmapFadePos : TEXCOORD6;
#endif
#endif
};
#ifndef LIGHTMAP_OFF
float4 unity_LightmapST;
#endif
float4 _MainTex_ST;
float4 _NormalMap_ST;

// vertex shader
v2f_surf vert_surf (appdata_full v) {
  v2f_surf o;
  o.pos = mul (UNITY_MATRIX_MVP, v.vertex);
  o.pack0.xy = TRANSFORM_TEX(v.texcoord, _MainTex);
  o.pack0.zw = TRANSFORM_TEX(v.texcoord, _NormalMap);
  float3 viewDir = -ObjSpaceViewDir(v.vertex);
  float3 worldRefl = mul ((float3x3)_Object2World, viewDir);
  TANGENT_SPACE_ROTATION;
  o.TtoW0 = float4(mul(rotation, _Object2World[0].xyz), worldRefl.x)*unity_Scale.w;
  o.TtoW1 = float4(mul(rotation, _Object2World[1].xyz), worldRefl.y)*unity_Scale.w;
  o.TtoW2 = float4(mul(rotation, _Object2World[2].xyz), worldRefl.z)*unity_Scale.w;
  o.screen = ComputeScreenPos (o.pos);
#ifndef LIGHTMAP_OFF
  o.lmap.xy = v.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
  #ifdef DIRLIGHTMAP_OFF
    o.lmapFadePos.xyz = (mul(_Object2World, v.vertex).xyz - unity_ShadowFadeCenterAndType.xyz) * unity_ShadowFadeCenterAndType.w;
    o.lmapFadePos.w = (-mul(UNITY_MATRIX_MV, v.vertex).z) * (1.0 - unity_ShadowFadeCenterAndType.w);
  #endif
#else
  float3 worldN = mul((float3x3)_Object2World, SCALED_NORMAL);
  o.vlight = ShadeSH9 (float4(worldN,1.0));
#endif
  return o;
}
sampler2D _LightBuffer;
#if defined (SHADER_API_XBOX360) && defined (HDR_LIGHT_PREPASS_ON)
sampler2D _LightSpecBuffer;
#endif
#ifndef LIGHTMAP_OFF
sampler2D unity_Lightmap;
sampler2D unity_LightmapInd;
float4 unity_LightmapFade;
#endif
fixed4 unity_Ambient;

// fragment shader
fixed4 frag_surf (v2f_surf IN) : SV_Target {
  // prepare and unpack data
  #ifdef UNITY_COMPILER_HLSL
  Input surfIN = (Input)0;
  #else
  Input surfIN;
  #endif
  surfIN.uv_MainTex = IN.pack0.xy;
  surfIN.uv_NormalMap = IN.pack0.zw;
  surfIN.worldRefl = float3(IN.TtoW0.w, IN.TtoW1.w, IN.TtoW2.w);
  surfIN.TtoW0 = IN.TtoW0.xyz;
  surfIN.TtoW1 = IN.TtoW1.xyz;
  surfIN.TtoW2 = IN.TtoW2.xyz;
  #ifdef UNITY_COMPILER_HLSL
  SurfaceOutput o = (SurfaceOutput)0;
  #else
  SurfaceOutput o;
  #endif
  o.Albedo = 0.0;
  o.Emission = 0.0;
  o.Specular = 0.0;
  o.Alpha = 0.0;
  o.Gloss = 0.0;

  // call surface function
  surf (surfIN, o);
  half4 light = tex2Dproj (_LightBuffer, UNITY_PROJ_COORD(IN.screen));
#if defined (SHADER_API_MOBILE)
  light = max(light, half4(0.001));
#endif
#ifndef HDR_LIGHT_PREPASS_ON
  light = -log2(light);
#endif
#if defined (SHADER_API_XBOX360) && defined (HDR_LIGHT_PREPASS_ON)
  light.w = tex2Dproj (_LightSpecBuffer, UNITY_PROJ_COORD(IN.screen)).r;
#endif

  // add lighting from lightmaps / vertex / ambient:
  #ifndef LIGHTMAP_OFF
    #ifdef DIRLIGHTMAP_OFF
      // dual lightmaps
      fixed4 lmtex = tex2D(unity_Lightmap, IN.lmap.xy);
      fixed4 lmtex2 = tex2D(unity_LightmapInd, IN.lmap.xy);
      half lmFade = length (IN.lmapFadePos) * unity_LightmapFade.z + unity_LightmapFade.w;
      half3 lmFull = DecodeLightmap (lmtex);
      half3 lmIndirect = DecodeLightmap (lmtex2);
      half3 lm = lerp (lmIndirect, lmFull, saturate(lmFade));
      light.rgb += lm;
    #else
      // directional lightmaps
      fixed4 lmtex = tex2D(unity_Lightmap, IN.lmap.xy);
      fixed4 lmIndTex = tex2D(unity_LightmapInd, IN.lmap.xy);
      half4 lm = LightingLambert_DirLightmap(o, lmtex, lmIndTex, 1);
      light += lm;
    #endif
  #else
    light.rgb += IN.vlight;
  #endif
  half4 c = LightingLambert_PrePass (o, light);
  c.rgb += o.Emission;
  return c;
}

ENDCG

}

	// ---- end of surface shader generated code

#LINE 64

	}
	FallBack "Diffuse"
}

果然，原来 INTERNAL_DATA 就是一个宏……

而且会发现在生成的代码中不止一个 INTERNAL_DATA。这是因为生成的代码中有多个PASS

forward rendering additive lights pass:
deferred lighting base geometry pass:
deferred lighting final pass:
forward rendering base pass:

每个PASS 都有一个，所以有好几个。

那么，不使用 INTERNAL_DATA，而是直接使用具体的内容，可以吗？来试一下。

首先，从Shader 中删掉 INTERNAL_DATA。

Unity 报了以下错误

Shader error in ‘CookBookShaders/Chapt4-4/Cubemap_NormalMap‘: invalid subscript ‘TtoW0‘ at line 59

是这一行的错

o.Emission = texCUBE(_Cubemap,WorldReflectionVector(IN,o.Normal)).rgb * _ReflAmount;

因为从上面 Shader 编译后的代码看到，WorldReflectionVector 也是一个宏

#define WorldReflectionVector(data,normal) reflect (data.worldRefl, half3(dot(data.TtoW0,normal), dot(data.TtoW1,normal), dot(data.TtoW2,normal)))

其实就是说，在WorldReflectionVector 这个函数里找不到 TtoW0 这个参数了。

然后，在 Input 结构体中添加 INTERNAL_DATA 的具体内容看看

		struct Input
		{
			float2 uv_MainTex;

			float2 uv_NormalMap;

			float3 worldRefl;

			half3 TtoW0; half3 TtoW1; half3 TtoW2;

		};

法线 Shader 已经正常工作啦

B：在Input 中添加 float3 worldRefl 和 INTERNAL_DATA ，给o.Normal 赋值的话，就可以用 WorldReflectionVector(IN,o.Normal) 获取到法线贴图计算后的反射向量。

原文是这样写的

在Input 结构体中还有更多的内置函数，其中一部分如下：

float3 viewDir ：

Will contain view direction, for computing Parallax effects, rimlighting, and so on.

float4 COLOR ：

Will contain interpolated per-vertex color.

float4 screenPos：

Will contain screen-space position for reflection effects. Used by WetStreet shader in Dark Unity, for example.

float3 worldPos ：

Will contain world space position.

float3 worldRefl ：

Will contain world reflection vector if Surface Shader does not write to o.Normal. See Reflect-Diffuse shader for example.

float3 worldNormal ：

Will contain world normal vector if Surface Shader does not write to o.Normal.

float3 worldRef;INTERNAL_DATA：

Will contain world reflection vector if Surface Shader writes to o.Normal. To get the reflection vector based on per-pixel normal map, use WorldReflectionVector (IN,o.Normal). See Reflect-Bumped shader for example.

float3 worldNormal;INTERNAL_DATA：
Will contain world normal vector if Surface Shader writes to o.Normal. To get the normal vector based on per-pixel normal map, use WorldNormalVector (IN, o.Normal).

3、在 surf 函数中添加了读取法线贴图的代码

//从法线贴图中提取法线信息，UnpackNormal这个函数在 CGInclude 文件夹中的Lighting中。
			float3 normals=UnpackNormal(tex2D(_NormalMap,IN.uv_NormalMap));

4、上一节中直接使用 Input 中的 worldRefl 这个反射向量来获取立方图采样。这一次需要使用上面说的 WorldReflectionVector 来计算世界反射向量。

//使用WorldReflectionVector 获得 基于法线贴图中的反射向量的 世界反射向量
o.Emission = texCUBE(_Cubemap,WorldReflectionVector(IN,o.Normal)).rgb * _ReflAmount;

示例项目打包下载：

http://pan.baidu.com/s/1c1TcSgS

时间： 2024-04-26 21:40:35

Unity Shaders and Effects Cookbook (4-4)在Cubemap 上使用法线贴图 (法线贴图与反射)的相关文章

Unity Shaders and Effects Cookbook (4-6)震撼的实时反射动态立方图系统

昨天逛街的时候看到太平鸟里面摆了个金属的米老鼠,于是职业病犯了,一直在想金属的颜色是什么,这个反射该怎么写,想不出来-- 今天正好看到动态反射立方图系统这一节,看完觉得很别扭,因为书上介绍的是事先踩点生成Cubemap的方式而不是实时的.于是到官方文档找到实时反射的代码,做了一个比较花俏的场景,运行之后吃了一大惊,实时反射是如此的震撼.. 第四章第一节第二节介绍了创建Cubemap,然后学习了如何使用. Unity Shaders and Effects Cookbook (4-1)(4-2)静

Unity Shaders and Effects Cookbook (4-3)遮罩反射

今天看完了4.3小节,Unity3d 中的遮罩反射,这一节内容比较少. 如果大家对Unity Shader 感兴趣的白菜,那么推荐大家购买一本 Unity 着色器和屏幕特效开发秘笈 .这本书写的浅显易懂,很适合入门. 当看完这本书,大概了解 Shader 的用处的时候,再去看更高级的 Shader 教程也可以. 京东图书连接 http://item.jd.com/1338728578.html 转自http://blog.csdn.net/huutu http://www.thisisgame.

Unity Shaders and Effects Cookbook (3-6) 创建各向异性高光类型(Anisotropic) 模拟金属拉丝效果

这一次学习各向异性高光类型,名字真拗口,Anisotropic 这个英文单词也很拗口. 各向异性是模拟物体表面沟槽方向性的高光反射类型,他会修改或延伸垂直方向上的高光. 比如模拟金属拉丝的效果,就可以使用各向异性来模拟. 转自http://blog.csdn.net/huutu http://www.thisisgame.com.cn 首先需要准备一张各向异性的法线贴图,代表各向异性镜面高光的方向性. 注意法线贴图导入到Unity之后要在属性面板中勾选类型为 Normal Map. 首先在

Unity Shaders and Effects Cookbook (4-1)(4-2)静态立方体贴图的创建与使用

开始学习第4章 - 着色器的反射看完了1.2节,来记录一下.反射主要是利用了 Cubemap 立方体贴图. 认识Cubemap 立方体贴图,就如同名字所说,在一个立方体上有6张图,就这样认为吧. 假想一下 ,在一个艳丽的房间里,有一个表面是镜子的圆球,那这个圆球表面就反射了房间里面的所有东西,就是一个大号的凸镜. 这是到网上找得一张图,很直观的表达了我的意思-- 注意标题中说的,静态立方体贴图,为什么叫静态,因为这一次使用的立方体贴图是提前生成好的图片,而不是动态生成的. 这又是什么意思呢?

Unity Shaders and Effects Cookbook (2-4) 压缩和混合纹理贴图:使用灰度图存储插值信息

这一节看了几次才慢慢的读懂. 首先是这个灰度图,为什么叫灰度图,是因为这个图片中的 R.G.B 存放的都是同一份数据,打开Unity 来调一下颜色看看更直观. 可以看到,当 R.G.B 三个值相同的时候,图片是只有黑白,而丢失了其它的颜色的,所以我们叫灰度图. 什么时候用到灰度图? 本文转自http://blog.csdn.net/huutu http://www.thisisgame.com.cn 比如说高度图,在这个坐标的点,海拔高,就记作 1,海拔低就记作0 .把这一份数据同时存储到

Unity Shaders and Effects Cookbook (6-4) GUI 和透明度

在游戏项目中使用透明最多的地方就是 GUI 了.这一节用一个非常简单的 GUI 例子,来熟悉控制透明物体的渲染顺序. 搭建场景,导入随书资源. 创建着色器 GUI,创建两个Material,一个 GUIBG 用于背景图片,一个 GUIGRP 用于按钮界面. 转自http://blog.csdn.net/huutu http://www.thisisgame.com.cn 把创建的Material 分别赋值给 GUIBG 和 GUIGRP. 场景搭建完毕后效果如下因为创建的Shader 默认

Unity Shaders and Effects Cookbook (7-2) Surface Shader 中实现顶点动画

上一节中说了,在 Surface Shader 中,添加顶点函数,我们可以在顶点函数中获取到顶点数据,比如顶点颜色.顶点坐标等. 这一节学习获取顶点坐标,并且修改顶点坐标,来实现顶点动画. 简单介绍原理: 在顶点函数中,获取到顶点坐标 vertex,然后,求float offsetY = sin(vertex.x) ,然后将 offsetY 加到 vertex.y 上,这样就把原来的平面 ,变成了正弦波浪. 然后再使用之前学过的内置变量 _Time ,算式变为 float offset

Unity Shaders and Effects Cookbook (D-1) 设置 ZTest 来实现遮挡半透效果

在游戏里面经常看到这样的效果,英雄走到障碍物后面,但是我们能够透过障碍物看到英雄的身体,好像我们有了透视眼一般. 都是套路. 其实是程序猿在显示英雄模型的时候,画了两次. 一次是被遮挡的部分用半透明的样子画了一遍. 另一次是没有遮挡的部分画了一遍. 下面在Unity中来实现. 首先新建材质 .Shader.场景. 搭建好场景,一个Cube.一个Capsule 好了,现在是最正常不过的情况了,Capsule被Cube 挡住了. 转自http://blog.csdn.net/huutu http:/

Unity Shaders and Effects Cookbook (6-1) 使用 alpha 参数的半透明着色器

对于游戏项目,透明是很消耗资源的一个操作,在Unity的Profile 中可以很直观的看到透明所消耗的系统资源. 在Unity的表面着色器 Surface Shader 中,我们可以很方便的创建一种全透明的效果.如草的表面.这一节学习通过在 #pragma 语句中添加 alpha 参数来使用透明功能. 这一节我使用了下面这张贴图作为球的表面纹理. 这张 512x 512 的图片分为了 4个色块区域.分别是 Green .Red.White.Blue. Green:就是 G通道为1,R.B

Unity Shaders and Effects Cookbook (4-4)在Cubemap 上使用 法线贴图 (法线贴图与反射)

Unity Shaders and Effects Cookbook (4-4)在Cubemap 上使用 法线贴图 (法线贴图与反射)的相关文章

Unity Shaders and Effects Cookbook (4-4)在Cubemap 上使用法线贴图 (法线贴图与反射)

Unity Shaders and Effects Cookbook (4-4)在Cubemap 上使用法线贴图 (法线贴图与反射)的相关文章