spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

/************************************************************

in:

  t0        texcoords
  t1        lightvector
  t2        halfvector
  t3        viewvector

  stage 0   diffuse texture
  stage 1   normal map

  c0        const (0.0f, 0.5f, 1.0f, 2.0f)
  c1        (specular power, height scale, offset, 0.0f)
  c2        light color

*************************************************************/

ps_2_0

dcl v0

dcl t0
dcl t1
dcl t2
dcl t3

dcl_2d s0
dcl_2d s1


// parallax mapping

texld r0, t0, s1

nrm r1, t3               // renormalize viewvector
mul r1, r1, c1.y

mad r0, r0, c0.w, -c0.z  // decompress height
mad r4, r1, r0.a, t0


// normal mapping

texld r1, r4, s1         // r1 <- normal map

nrm r3, t2               // renormalize halfvector
nrm r2, t1               // renormalize lightvector

texld r0, r4, s0         // r0 <- diffuse texture

mad r1, r1, c0.w, -c0.z  // decompress normals

// r4 <- lambert
dp3 r4, r1, r2           // N * L

// r5 <- blinn specular
dp3 r5, r1, r3           // N * H
pow r5, r5.w, c1.x
mul r5, r5, r0.a

mad r0, r0, r4, r5       // texture * diffuse + specular
mul r0, r0, c2           // (texture * diffuse + specular) * light color
mul r0, r0, v0

mov oC0, r0

Quellcode

float height_scale;
float height_bias;

float specular_power;
float3 light_color;


sampler diffuse_tex : s0;  // gloss map in alpha channel
sampler normal_map : s1;  // bump map in alpha channel


float4 ParallaxNormalMap(float2 t : TEXCOORD0,  // Texcoords
                         float3 l : TEXCOORD1,  // Light vector in Tangent Space
                         float3 h : TEXCOORD2,  // Half vector in Tangent Space
                         float3 v : TEXCOORD3   // View vector in Tangent Space
                         ) : COLOR0
{   
  float height = tex2D(normal_map, t).a * height_scale - height_bias;
  
  v = normalize(v);  // renormalize v
  
  t += v.xy * height;  // parallax
  
  float3 n = tex2D(normal_map, t).xyz;
  
  l = normalize(l);  // renormalize l
  h = normalize(h);  // renormalize h
  
  float4 diffuse_color = tex2D(diffuse_tex, t);
  
  n = n * 2.0f - 1.0f;
  
  float lambert = max(dot(n, l), 0.0f);
  float specular = pow(max(dot(n, h), 0.0f), specular_power) * diffuse_color.a;
  
  return float4(lambert * diffuse_color.rgb + specular) * light_color, 1.0f);
}