Bumpy Atlas Terrain... here's my latest attempt...

by Ves · in Torque Game Engine Advanced · 09/03/2007 (10:46 pm) · 52 replies · **Edited to replace images with image links... to save page loads....

OUT.col  = (o.r * t1 + o.g * t2 + o.b * t3 + o.a * t4);
FragOut pixClipmap( PixClipMapConnectData IN, 
				   uniform sampler2D diffuseMap[mapCount] : register(S0),
				   uniform sampler2D lightMap[mapCount] : register(S4),
				   uniform sampler2D opacityMap[mapCount] : register(S8),
				   uniform sampler2D bumpMap1 : register(S12),
				   uniform sampler2D bumpMap2 : register(S13),
				   uniform sampler2D bumpMap3 : register(S14),
				   uniform sampler2D bumpMap4 : register(S15),
				   uniform float4    ambient   : register(PC_AMBIENT_COLOR),
				   uniform float4    specular  : register(PC_MAT_SPECCOLOR),
				   uniform float     shine     : register(PC_MAT_SPECPOWER)
				   )
{

   FragOut OUT;

   const float3 diffuse  = {1,1,1};

   // view and light directions
   float3 v = normalize(IN.eyepos);
   float3 l = normalize(IN.lightvec);

   // Do a layered blend into accumulator, so most detail when we have it will show through...
   float4 color = tex2D(diffuseMap[0], IN.texCoord[0].xy);
   float4 lm = tex2D(lightMap[0], IN.texCoord[0].xy);
   float4 oMap = tex2D(opacityMap[0], IN.texCoord[0].xy);

   //Clipmap level merging
   //woohoo!!! why to one lerp when you can do 3... per level... every pixel
   for(int i=1; i<mapCount; i++)
   {
      float  scaleFactor = saturate(IN.fade[i] * 2.0);
      float4 layer       = tex2D(diffuseMap[i], IN.texCoord[i].xy);
      color = lerp(layer, color , scaleFactor);
      float4 layer2       = tex2D(lightMap[i], IN.texCoord[i].xy);
      lm = lerp(layer2, lm , scaleFactor);
      float4 layer3       = tex2D(opacityMap[i], IN.texCoord[i].xy);
      oMap = lerp(layer3, oMap , scaleFactor);	 
   }

   //Begin ugly parralex calculation block I have to do this 4 times since 
   //I need to do it preblend
   float2 uv = IN.texCoord[0].xy*128.0;
   float height = tex2D(bumpMap1,uv).w * 0.06 - 0.03;
   float2 uv1 = uv;
   uv1 += height * v.xy;
   float4 t1 = tex2D(bumpMap1,uv1);
   height = tex2D(bumpMap2,uv).w * 0.06 - 0.03;
   uv1 = uv;
   uv1 += height * v.xy;
   float4 t2 = tex2D(bumpMap2,uv1);
   height = tex2D(bumpMap3,uv).w * 0.06 - 0.03;
   uv1 = uv;
   uv1 += height * v.xy;
   float4 t3 = tex2D(bumpMap3,uv1);
   height = tex2D(bumpMap4,uv).w * 0.06 - 0.03;
   uv1 = uv;
   uv1 += height * v.xy;
   float4 t4 = tex2D(bumpMap4,uv1);

   //and finally a blended normal map
   float4 normal = (oMap.r * t1 + oMap.g * t2 + oMap.b * t3 + oMap.a * t4); 

   //fade normal at a distance
   float s = saturate((IN.dis.x-50)/300);

   // normal map
   normal.xyz=normalize(normal.xyz-0.5); 
   normal.y=-normal.y;

   normal.xyz = lerp(normal.xyz,float3(1,0,0),s);

   // compute diffuse and specular terms
   float4 lightVec = lit(dot(l,normal.xyz),dot(normalize(l-v),normal.xyz),shine);

   // attenuation factor
   float att=1.0-max(0,l.z); att=1.0-att*att;

   // compute final color
   float4 finalcolor;	
   finalcolor.xyz = ambient*color.xyz + att*((color.xyz*diffuse*lightVec.y) + lightVec.z ) * lm; 
   finalcolor.w=1.0;

   OUT.col = finalcolor;

   return OUT;
}
VertClipMapConnectData vertClipmap( VertData IN,
                  uniform float4x4 modelView         : register(C0),
                  uniform float    morphT            : register(C49),
                  uniform float4   mapInfo[mapCount] : register(C50),
				  uniform float3   lightpos        : register(VC_LIGHT_DIR1),
				  uniform float3   eyePos          : register(VC_EYE_POS),
				  uniform float4x4 objTrans        : register(VC_OBJ_TRANS)
                  )
{
   VertClipMapConnectData OUT;

   // Do vertex transform...
   OUT.hpos = atlasVertex(IN, modelView, morphT);

   OUT.baseCoord = IN.texCoord;
   // And get our morphed texcoord...
   float2 tc = atlasTexCoord(IN, morphT);

   // Scale texcoords.
   for(int i=0; i<mapCount; i++)
      OUT.texCoord[i] = tc * mapInfo[i].z;

   // Caculate fades. We never fade base level, so skip it.
   float4 distAcc = 0;
   for(int i=1; i<mapCount; i++)
      distAcc[i] = distance(mapInfo[i].xy, OUT.texCoord[i].xy);

   // Do all the fade biasing in one go.
   for(int i=0; i<4; i++)
      OUT.fade[i] = (distAcc[i] * (2.0 * fadeConstant) - (fadeConstant - 1.0)) / 2.0;

   // tangent vectors in view space 
	float3x3 tangentspace = float3x3(IN.T, cross( IN.T, IN.normal) , IN.normal);

  // view in tangent space
	float3 obvv = eyePos - IN.position;
    float3 eye = mul( tangentspace, obvv );
    eye = -eye;
	OUT.outeyeposition = eye;

	OUT.lightvec.xyz = -lightpos;
	OUT.lightvec.xyz = mul(tangentspace, OUT.lightvec);	
	OUT.lightvec = (OUT.lightvec / 2.0) + 0.5;
	OUT.dis = 0;
    OUT.dis.x = distance(eye, OUT.hpos.xyz);
	//OUT.lightvec = IN.T;

   return OUT;
}

FragOut pixClipmap( PixClipMapConnectData IN, 
				   //uniform sampler2D diffuseMap[mapCount] : register(S0),
				   uniform sampler2D diffuseMap1 : register(S0),
				   uniform sampler2D diffuseMap2 : register(S1),
				   uniform sampler2D diffuseMap3 : register(S2),
				   uniform sampler2D diffuseMap4 : register(S3),
				   uniform sampler2D lightMap[mapCount] : register(S4),
				   uniform sampler2D opacityMap[mapCount] : register(S8),
				   uniform sampler2D bumpMap1 : register(S12),
				   uniform sampler2D bumpMap2 : register(S13),
				   uniform sampler2D bumpMap3 : register(S14),
				   uniform sampler2D bumpMap4 : register(S15),
				   uniform float4    ambient   : register(PC_AMBIENT_COLOR),
				   uniform float4    specular  : register(PC_MAT_SPECCOLOR),
				   uniform float     shine     : register(PC_MAT_SPECPOWER)
				   )
{

   FragOut OUT;

   const float3 diffuse  = {1,1,1};
   // Do a layered blend into accumulator, so most detail when we have it will show through...
   //float4 color = tex2D(diffuseMap[0], IN.texCoord[0].xy);
   //float4 lm = tex2D(lightMap[0], IN.texCoord[0].xy);
   float4 lm = tex2D(lightMap[0], IN.baseCoord.xy);
   //float4 oMap = tex2D(opacityMap[0], IN.texCoord[0].xy);
   float4 oMap = tex2D(opacityMap[0], IN.baseCoord.xy);
   // view and light directions
   float3 v = normalize(IN.eyepos);
   float3 l = normalize(IN.lightvec);

   float2 uv = IN.baseCoord.xy*128.0;

   /*for(int i=1; i<mapCount; i++)
   {
      float  scaleFactor = saturate(IN.fade[i] * 2.0);
      float4 layer       = tex2D(diffuseMap[i], IN.texCoord[i].xy);
      color = lerp(layer, color , scaleFactor);
	  //float4 layer2       = tex2D(lightMap[i], IN.texCoord[i].xy);
      //lm = lerp(layer2, lm , scaleFactor);
	  //float4 layer3       = tex2D(opacityMap[i], IN.texCoord[i].xy);
      //float4 layer3       = tex2D(opacityMap[i], IN.baseCoord.xy);
      //oMap = lerp(layer3, oMap , scaleFactor);
	  //OUT.col += (i/mapCount)*0.25;
   }*/

   float height = tex2D(bumpMap1,uv).w * 0.02 - 0.01;
   float2 uv1 = uv;
   uv1 += height * v.xy;   
   float4 t1 = tex2D(diffuseMap1,uv1);

   height = tex2D(bumpMap2,uv).w * 0.02 - 0.01;
   uv1 = uv;
   uv1 += height * v.xy;
   float4 t2 = tex2D(diffuseMap2,uv1);

   height = tex2D(bumpMap3,uv).w * 0.02 - 0.01;
   uv1 = uv;
   uv1 += height * v.xy;
   float4 t3 = tex2D(diffuseMap3,uv1);

   height = tex2D(bumpMap4,uv).w * 0.02 - 0.01;
   uv1 = uv;
   uv1 += height * v.xy;
   float4 t4 = tex2D(diffuseMap4,uv1);

   float4 color = (oMap.r * t1 + oMap.g * t2 + oMap.b * t3 + oMap.a * t4); 

   t1 = tex2D(bumpMap1,uv1);
   t2 = tex2D(bumpMap2,uv1);
   t3 = tex2D(bumpMap3,uv1);
   t4 = tex2D(bumpMap4,uv1);
   float4 normal = (oMap.r * t1 + oMap.g * t2 + oMap.b * t3 + oMap.a * t4);
   // parallax code
   //float height = tex2D(bumpMap[0],uv).w * 0.06 - 0.03;
   //uv += height * v.xy;

   // normal map
   normal.xyz=normalize(normal.xyz-0.5); 
   normal.y=-normal.y;

   //normal fade
   /*float s = saturate((IN.dis.x-100)/100);
   normal.xyz = lerp(normal.xyz,float3(1,0,0),s);*/

   // compute diffuse and specular terms
   float4 lightVec = lit(dot(l,normal.xyz),dot(normalize(l-v),normal.xyz),shine);

   // attenuation factor
   float att=1.0-max(0,l.z); att=1.0-att*att;

    // compute final color
    float4 finalcolor;
    finalcolor.xyz = ambient*color.xyz + att*((color.xyz*diffuse*lightVec.y) + lightVec.z ) * lm;
    finalcolor.w=1.0;
    //finalcolor.xyz = lightVec.y;
    OUT.col = finalcolor;

   return OUT;
}

Game Development Community

Bumpy Atlas Terrain... here's my latest attempt...

About the author

Recent Threads