深度格子Shader

王者再临

ps">

1. Shader "quad_depth_relief_mapping"
   
2. {
   
3. Properties
   
4. {
   
5. depth ("Depth Factor", Float) = 0.1
   
6. tile ("Tile Factor", Float) = 1
   
7. 
   
8. ambient_color ("Ambient",  Color) = (0.2, 0.2, 0.2)
   
9. diffuse_color ("Diffuse",  Color) = (1, 1, 1)
   
10. specular_color ("Specular", Color) = (0.75,0.75,0.75)
    
11. 
    
12. shine ("Shine", Float) = 128
    
13. 
    
14. lightpos ("Light Position (view space)", Vector) = (100.0, -50.0, 50.0)
    
15. 
    
16. color_map ("Color Map" ,2D) = "white" {}
    
17. quad_depth_map ("Quad Depth Map",2D) = "white" {}
    
18. normal_map_x ("Normal Map X" ,2D) = "white" {}
    
19. normal_map_y ("Normal Map Y" ,2D) = "white" {}
    
20. 
    
21. }
    
22. SubShader
    
23. {
    
24. Pass
    
25. {
    
26. Cull off
    
27. 
    
28. CGPROGRAM //-----------
    
29. 
    
30. #pragma target 3.0
    
31. #pragma vertex view_space
    
32. #pragma fragment relief_map_quad_depth
    
33. #pragma profileoption MaxTexIndirections=64
    
34. 
    
35. //----- uniform
    
36. float depth;
    
37. float tile;
    
38. float3 ambient_color;
    
39. float3 diffuse_color;
    
40. float3 specular_color;
    
41. float shine;
    
42. float3 lightpos : POSITION;
    
43. 
    
44. //----- application data
    
45. 
    
46. struct a2v
    
47. {
    
48.     float4 vertex       : POSITION; // float4 pos
    
49.     float3 normal     : NORMAL;
    
50.     float2 texcoord   : TEXCOORD0;
    
51.     float4 tangent   : TANGENT0; // float3 tangent
    
52.     //float3 binormal   : BINORMAL0; // Not found in unity3d
    
53. };
    
54. 
    
55. struct v2f
    
56. {
    
57. float4 hpos : POSITION;
    
58. float3 eye : TEXCOORD0;
    
59. float3 light : TEXCOORD1;
    
60. float2 texcoord : TEXCOORD2;
    
61. };
    
62. 
    
63. //----- vetrex shader
    
64. v2f view_space(a2v IN)
    
65. {
    
66. 
    
67. v2f OUT;
    
68. 
    
69. // vertex position in object space
    
70. float4 pos=float4(IN.vertex.x,IN.vertex.y,IN.vertex.z,1.0);
    
71. 
    
72. // vertex position IN clip space
    
73. OUT.hpos = mul(glstate.matrix.mvp, pos);
    
74. 
    
75. // copy color and texture coordinates
    
76. OUT.texcoord=IN.texcoord.xy*tile;
    
77. 
    
78. // compute modelview rotation only part
    
79. float3x3 modelviewrot =float3x3(glstate.matrix.modelview[0]);
    
80. 
    
81. // tangent vectors IN view space
    
82. float3 IN_bINormal = cross( IN.normal, IN.tangent.xyz )*IN.tangent.w;  
    
83. float3 tangent = mul(modelviewrot, IN.tangent.xyz);
    
84. float3 bINormal = mul(modelviewrot, IN_bINormal.xyz); // IN.biNormal
    
85. float3 normal = mul(modelviewrot, IN.normal);
    
86. float3x3 tangentspace = float3x3(tangent, bINormal,normal);
    
87. 
    
88. // vertex position IN view space (with model transformations)
    
89. float3 vpos=mul(glstate.matrix.modelview[0],pos).xyz;
    
90. 
    
91. // view in tangent space
    
92. float3 eye=mul(tangentspace,vpos);
    
93. eye.z=-eye.z;
    
94. OUT.eye=eye;
    
95. 
    
96. // light position in tangent space
    
97. OUT.light=mul(tangentspace,lightpos -vpos);
    
98. //OUT.light=mul(tangentspace,glstate.light[0].position.xyz -vpos);
    
99. 
    
100. return OUT;
     
101. }
     
102. 
     
103. 
     
104. // ray intersect quad depth map with linear search
     
105. void ray_intersect_rmqd_linear(
     
106.       in sampler2D quad_depth_map,
     
107.       inout float3 s,
     
108.       inout float3 ds)
     
109. {
     
110.    const int linear_search_steps=30;  //15
     
111.    
     
112.    ds/=linear_search_steps;
     
113.    
     
114.    // search front to back for first point inside object
     
115.    for( int i=0;i<linear_search_steps-1;i++ )
     
116.    {
     
117. float4 t=tex2D(quad_depth_map,s.xy);
     
118. 
     
119. float4 d=s.z-t; // compute distances to each layer
     
120. d.xy*=d.zw; d.x*=d.y; // x=(x*y)*(z*w)
     
121. 
     
122. if (d.x>0) // if ouside object move forward
     
123. s+=ds;
     
124.    }
     
125. }
     
126. 
     
127. // ray intersect quad depth map with binary search
     
128. void ray_intersect_rmqd_binary(
     
129.       in sampler2D quad_depth_map,
     
130.       inout float3 s,
     
131.       inout float3 ds)
     
132. {
     
133.    const int binary_search_steps=5;
     
134.    
     
135.    float3 ss=sign(ds.z);
     
136. 
     
137.    // recurse around first point for closest match
     
138.    for( int i=0;i<binary_search_steps;i++ )
     
139.    {
     
140. ds*=0.5; // half size at each step
     
141. 
     
142. float4 t=tex2D(quad_depth_map,s.xy);
     
143. 
     
144. float4 d=s.z-t; // compute distances to each layer
     
145. d.xy*=d.zw; d.x*=d.y; // x=(x*y)*(z*w)
     
146. 
     
147. if (d.x<0) // if inside
     
148. {
     
149. ss=s; // store good return position
     
150. s-=2*ds; // move backward
     
151. }
     
152. s+=ds; // else move forward
     
153.    }
     
154.    
     
155.    s=ss;
     
156. }
     
157. 
     
158. float4 relief_map_quad_depth(
     
159. v2f IN,
     
160. uniform sampler2D quad_depth_map,
     
161. uniform sampler2D color_map,
     
162. uniform sampler2D normal_map_x,
     
163. uniform sampler2D normal_map_y ) : COLOR
     
164. {
     
165. // view vector in tangent space
     
166. float3 v=normalize(IN.eye);
     
167. 
     
168. // serach start position
     
169. float3 s=float3(IN.texcoord,0);
     
170. 
     
171. // separate direction (front or back face)
     
172. float dir=v.z;
     
173. v.z=abs(v.z);
     
174. 
     
175. // depth bias (1-(1-d)*(1-d))
     
176. float d=depth*(2*v.z-v.z*v.z);
     
177. 
     
178. // compute serach vector
     
179. v/=v.z;
     
180. v.xy*=d;
     
181. s.xy-=v.xy*0.5;
     
182. 
     
183. // if viewing from backface
     
184. if (dir<0)
     
185. {
     
186. s.z=0.996; // search from back to front
     
187. v.z=-v.z;
     
188. }
     
189. 
     
190. // ray intersect quad depth map
     
191. ray_intersect_rmqd_linear(quad_depth_map,s,v);
     
192. ray_intersect_rmqd_binary(quad_depth_map,s,v);
     
193. 
     
194. // discard if no intersection is found
     
195. if (s.z>0.997) discard;
     
196. if (s.z<0.003) discard;
     
197. 
     
198. // DEBUG: return depth
     
199. //return float4(s.zzz,1);
     
200. 
     
201. // get quad depth and color at intersection
     
202. float4 t=tex2D(quad_depth_map,s.xy);
     
203. float4 c=tex2D(color_map,s.xy);
     
204. 
     
205. // get normal components X and Y
     
206. float4 nx=tex2D(normal_map_x,s.xy);
     
207. float4 ny=tex2D(normal_map_y,s.xy);
     
208. 
     
209. // compute normal
     
210. float4 z=abs(s.z-t);
     
211. int m=0; // find min component
     
212. float zm = z.x;
     
213. if (z.y<zm) { m=1; zm = z.y; }
     
214. if (z.z<zm) { m=2; zm = z.z; }
     
215. if (z.w<zm) { m=3; }
     
216. 
     
217. float3 n; // get normal at min component layer
     
218. if ( m == 0) { n.x=nx[0]; n.y=1-ny[0]; } //n.x=nx[m]; n.y=1-ny[m];
     
219. if ( m == 1) { n.x=nx[1]; n.y=1-ny[1]; }
     
220. if ( m == 2) { n.x=nx[2]; n.y=1-ny[2]; }
     
221. if ( m == 3) { n.x=nx[3]; n.y=1-ny[3]; }
     
222. 
     
223. n.xy=n.xy*2-1; // expand to [-1,1] range
     
224. n.z=sqrt(max(0,1.0-dot(n.xy,n.xy))); // recompute z
     
225. if (m==1||m==3) // invert normal z if in backface
     
226. n.z=-n.z;
     
227. 
     
228. // DEBUG: return normal
     
229. // return float4(n*0.5+0.5,1);
     
230. 
     
231. // compute light vector in view space
     
232. float3 l=normalize(IN.light);
     
233. 
     
234. // restore view direction z component
     
235. v=normalize(IN.eye);
     
236. v.z=-v.z;
     
237. 
     
238. // compute diffuse and specular terms
     
239. float ldotn=saturate(dot(l,n));
     
240. float ndoth=saturate(dot(n,normalize(l-v)));
     
241. 
     
242. // attenuation factor
     
243. float att=1.0-max(0,l.z); att=1.0-att*att;
     
244. 
     
245. // return final color with lighting
     
246. float4 finalcolor;
     
247. finalcolor.xyz = c.xyz*ambient_color +
     
248. att*(c.xyz*diffuse_color*ldotn +
     
249. c.w*specular_color.xyz*pow(ndoth,shine));
     
250. finalcolor.w=1;
     
251. 
     
252. return finalcolor;
     
253. }
     
254. 
     
255. ENDCG //----------
     
256. } // Pass
     
257. } // SubShader
     
258. } // Shader

复制代码

蜗牛

谢谢 共享 。。。。

kikkik7000

Thanks for sharing !

BlueGem

感谢分享

川流不息

感谢楼主的无私分享

vega_lin

感谢无私分享.~

gracezrxx

4个报错 28 29 71

Eureka

感谢无私分享.~

smg169

感谢楼主分享啦~~~