OgreMax中使用offsetmapping

第一个texture unit 里是凹凸贴图，第二个texutre unit里是漫反射贴图

vertex shader和pixex shader如下：

offsetmapping.program：

 

1. // Bump map with Parallax offset vertex program, support for this is required 
2. vertex_program my/OffsetMappingVP cg 
3. { 
4.    source OffsetMapping.cg 
6.    default_params
7.    {
8.   param_named scale float 1.0
9.             param_named_auto lightPosition light_position_object_space 0 
10.             param_named_auto eyePosition camera_position_object_space 
11.             param_named_auto worldViewProj worldviewproj_matrix 
12.    }
14.    entry_point main_vp 
15.    profiles vs_1_1 arbvp1 
16. } 
18. // Bump map with parallax fragment program 
19. fragment_program my/OffsetMappingFP cg
20. { 
21.    source OffsetMapping.cg
23.    default_params
24.    {
25.             param_named_auto lightDiffuse light_diffuse_colour 0 
26.             param_named_auto lightSpecular light_specular_colour 0 
27.             // Parallax Height scale and bias 
28.             param_named scaleBias float4 0.04 -0.02 1 0 
29.    }
31.    entry_point main_fp
32.    profiles ps_2_0 arbfp1
33. } 

OffsetMapping.cg：

1. /* Bump mapping with Parallax offset vertex program 
2.    In this program, we want to calculate the tangent space light end eye vectors 
3.    which will get passed to the fragment program to produce the per-pixel bump map 
4.    with parallax offset effect. 
5. */
7. struct outPixel
8. {
9.   float4 colour  : COLOR0;
10. };
12. // General functions
14. // Expand a range-compressed vector
15. half4 expand(half4 v)
16. {
17.     return v * 2 - 1;
18. }
19. half3 expand(half3 v)
20. {
21.     return v * 2 - 1;
22. }
23. half2 expand(half2 v)
24. {
25.     return v * 2 - 1;
26. }
27. half1 expand(half1 v)
28. {
29.     return v * 2 - 1;
30. }
32. // Returns light direction from light position and vertex position
33. half3 getLightDirection(float4 lightPosition, float4 position)
34. {
35.     // calculate tangent space light vector
36.     // Get object space light direction
37.     // Non-normalised since we'll do that in the fragment program anyway
38.     return lightPosition.xyz -  (position.xyz * lightPosition.w);
39. }
41. // Returns eye direction from eye position and vertex position
42. half3 getEyeDirection(float3 eyePosition, float4 position)
43. {
44.     return eyePosition - position.xyz;
45. }
47. // Returns a Tangent Binormal Normal matrix
48. half3x3 getTBNMatrix(float3 tangent, float3 normal)
49. {
50.     // Calculate the binormal (NB we assume both normal and tangent are
51.     // already normalised)
52.     // NB looks like nvidia cross params are BACKWARDS to what you'd expect
53.     // this equates to NxT, not TxN
54.     float3 binormal = cross(tangent, normal);
55.     
56.     // Form a rotation matrix out of the vectors
57.     return half3x3(tangent, binormal, normal);
58. }
60. // Returns expanded normal vector from texture map
61. half3 getNormalMapVector(sampler2D normalMap, float2 uv)
62. {
63.     // get bump map vector, again expand from range-compressed
64.     return expand(tex2D(normalMap, uv).xyz);
65. }
67. // Returns displacement vector from normalmaps alpha channel
68. half getDisplacement(sampler2D normalMap, float2 uv, half scale, half bias)
69. {
70.     // get the height using the tex coords
71.     half height = tex2D(normalMap, uv).a;
73.     // calculate displacement   
74.     return (height * scale) + bias;
75. }
77. // Returns a specular component from normal vector, specular colour and specular power
78. half3 getSpecularComponent(float3 normal, float3 halfAngle, float3 specularcolour, float specularPower)
79. {
80.     return pow(saturate(dot(normal, halfAngle)), specularPower) * specularcolour;
81. }
83. // Returns a per-pixel lighted component from normal vector, lightdir and colour
84. half3 getLightingComponent(float3 normal, float3 lightDir, float3 colour)
85. {
86.     return saturate(dot(normal, lightDir)) * colour;
87. }
91. float4 lightPosition;
92. float3 eyePosition;
93. float4x4 worldViewProj;
95. float3 lightDiffuse;
96. float3 lightSpecular;
97. float4 scaleBias;
98. sampler2D normalHeightMap;
99. sampler2D diffuseMap;
101. struct app2vertOffsetMapping
102. {
103.     float4 position : POSITION;
104.     float3 normal   : NORMAL;
105.     float2 uv       : TEXCOORD0;
106.     float3 tangent      : TANGENT0;
107. };
109. struct vert2fragOffsetMapping
110. {
111.     float4 position     : POSITION;
112.     float2 uv       : TEXCOORD0;
113.     float3 lightDir     : TEXCOORD1;
114.     float3 eyeDir       : TEXCOORD2;
115.     float3 halfAngle    : TEXCOORD3;
116. };
118. /* Vertex program that moves light and eye vectors into texture tangent space at vertex */ 
120. vert2fragOffsetMapping main_vp(uniform float scale,app2vertOffsetMapping IN) 
121. {
122.     vert2fragOffsetMapping OUT;
124.     // calculate output position 
125.     OUT.position = mul(worldViewProj, IN.position); 
127.     // pass the main uvs straight through unchanged 
128.     OUT.uv = IN.uv*scale; 
130.     half3 lightDir = getLightDirection(lightPosition, IN.position);
131.     half3 eyeDir = getEyeDirection(eyePosition, IN.position);
132.     
133.     // Form a rotation matrix out of the vectors 
134.     half3x3 TBN = getTBNMatrix(IN.tangent, IN.normal); 
135.     
136.     // Transform the light vector according to this matrix 
137.     OUT.lightDir = normalize(mul(TBN, lightDir)); 
138.     OUT.eyeDir = normalize(mul(TBN, eyeDir)); 
140.     OUT.halfAngle = normalize(OUT.eyeDir + OUT.lightDir);
142.     return OUT;
143. }
145. outPixel main_fp(vert2fragOffsetMapping IN)
146. {
147.     outPixel OUT;
149.     half displacement = getDisplacement(normalHeightMap, IN.uv, scaleBias.x, scaleBias.y);
150.     
151.     float3 uv2 = float3(IN.uv, 1);
152.     
153.     // calculate the new tex coord to use for normal and diffuse
154.     float2 newTexCoord = ((IN.eyeDir * displacement) + uv2).xy;
155.     
156.     // get the new normal and diffuse values
157.     half3 normal = getNormalMapVector(normalHeightMap, newTexCoord);
158.     half3 diffuse = tex2D(diffuseMap, newTexCoord).xyz;
159.     
160.     half3 specular = getSpecularComponent(normal, IN.halfAngle, lightSpecular, 32);
161.     half3 col = diffuse * getLightingComponent(normal, IN.lightDir, lightDiffuse) + specular;
162.         
163.     OUT.colour = float4(col, 1);
165.     return OUT;
166. }