vertex shader GLSL

uniform vec3 fvLightPosition;
uniform vec3 fvEyePosition;

uniform float amplitude;
uniform float frequency;
uniform float cubify;
uniform vec3 planetPos;
uniform vec4 planetRot;
uniform float planetRad;
uniform int LOD;
uniform vec3 translation;

//varying vec2 Texcoord;
varying vec3 ViewDirection;
varying vec3 LightDirection;
varying vec3 Normal;

// TODO: change this to texture
int p[512] = int[512](151,160,137,91,90,15,
   131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
   190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
   88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
   77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
   102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
   135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
   5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
   223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
   129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
   251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
   49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
   138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180,
   151,160,137,91,90,15,
   131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
   190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
   88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
   77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
   102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
   135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
   5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
   223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
   129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
   251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
   49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
   138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180
);

float fade(float t)
{
   return t*t*t*(t*(t*6-15)+10);
}

float lerp(float t, float a, float b)
{
   return a + t * (b - a);
}

float grad(int hash, float x, float y, float z)
{
   int h = hash & 15;
   float u = h<8 ? x : y;
   float v = h<4 ? y : h==12||h==14 ? x : z;
   return ((h&1) == 0 ? u : -u) + ((h&2) == 0 ? v : -v);
}

float noise(float x, float y, float z)
{
   int mx = int(x) & 255;
   int my = int(y) & 255;
   int mz = int(z) & 255;

   x -= int(x);
   y -= int(y);
   z -= int(z);

   if(x<0) { x+=1; mx = (mx+255) & 255; }
   if(y<0) { y+=1; my = (my+255) & 255; }
   if(z<0) { z+=1; mz = (mz+255) & 255; }

   float u = fade(x);
   float v = fade(y);
   float w = fade(z);

   int A  = p[mx  ]+my;
   int AA = p[A   ]+mz;
   int AB = p[A +1]+mz;
   int B  = p[mx+1]+my;
   int BA = p[B   ]+mz;
   int BB = p[B +1]+mz;

   return lerp(w, lerp(v, lerp(u,grad(p[AA  ],x  ,y  ,z  ),
                                 grad(p[BA  ],x-1,y  ,z  )),
                          lerp(u,grad(p[AB  ],x  ,y-1,z  ),
                                 grad(p[BB  ],x-1,y-1,z  ))),
                  lerp(v, lerp(u,grad(p[AA+1],x  ,y  ,z-1),
                                 grad(p[BA+1],x-1,y  ,z-1)),
                          lerp(u,grad(p[AB+1],x  ,y-1,z-1),
                                 grad(p[BB+1],x-1,y-1,z-1))));
}

void main( void )
{
	vec3 tmpPos = gl_Vertex.xyz * pow(0.5,LOD) + translation;

   float xx = tmpPos.x * tmpPos.x;
   float yy = tmpPos.y * tmpPos.y;
   float zz = tmpPos.z * tmpPos.z;

   // calculate sphere vertices
   float x = tmpPos.x * sqrt(1.0 - (yy/2.0) - (zz/2.0) + (yy*zz/3.0));
   float y = tmpPos.y * sqrt(1.0 - (xx/2.0) - (zz/2.0) + (xx*zz/3.0));
   float z = tmpPos.z * sqrt(1.0 - (yy/2.0) - (xx/2.0) + (yy*xx/3.0));

   // apply sphere mapping quantity
   x = tmpPos.x*cubify + x*(1.0-cubify);
   y = tmpPos.y*cubify + y*(1.0-cubify);
   z = tmpPos.z*cubify + z*(1.0-cubify);

   // apply sphere mapping and fix normals
   vec4 newPos = vec4(x,y,z,gl_Vertex.w);
   vec3 newNormal = normalize(vec3(x,y,z));

   // calculate longitude and latitude
   //float lon = atan(newPos.z/newPos.x);
   float lon = atan(x,z);
   float lat = asin(y/planetRad);

   if(abs(y) > planetRad-0.000001)
      lon = 0.0;

   // calculate increment value
   float inc = radians(90.0/(16.0*pow(2,LOD)));
   float newLon = lon+inc;
   float newLat = lat-inc;
   if(lat > radians(87.0))
      newLat = lat+inc;

   // calculate neighbor points
   float ny = sin(newLat)*planetRad;
   float L = cos(newLat)*planetRad;
   float nx = sin(lon)*L;
   float nz = cos(lon)*L;
   vec3 posPlusLat = vec3(nx,ny,nz);

   if(abs(y) > planetRad-0.000001)
   {
      newLon = radians(90.0);
   }
   else
   {
      ny = sin(lat)*planetRad;
      L = cos(lat)*planetRad;
   }
   nx = sin(newLon)*L;
   nz = cos(newLon)*L;

   vec3 posPlusLong = vec3(nx,ny,nz);



   // apply height displacement
   newPos.xyz = newPos.xyz + newNormal * amplitude * noise(newPos.x*frequency,newPos.y*frequency,newPos.z*frequency);

   // displace neighbors and calculate normal
   posPlusLat = posPlusLat + normalize(posPlusLat) * amplitude * noise(posPlusLat.x*frequency,posPlusLat.y*frequency,posPlusLat.z*frequency);
   posPlusLong = posPlusLong + normalize(posPlusLong) * amplitude * noise(posPlusLong.x*frequency,posPlusLong.y*frequency,posPlusLong.z*frequency);
   vec3 bumpNormal = cross(normalize(posPlusLat-newPos.xyz),normalize(posPlusLong-newPos.xyz));
   bumpNormal = normalize(bumpNormal);
   if(dot(bumpNormal,newNormal) < 0)
      bumpNormal = -bumpNormal;

   gl_Position = gl_ModelViewProjectionMatrix * newPos;
   //Texcoord    = gl_MultiTexCoord0.xy;



   vec4 fvObjectPosition = gl_ModelViewMatrix * newPos;

   // TODO: change position and rotation

   ViewDirection  = fvEyePosition - fvObjectPosition.xyz;
   LightDirection = (gl_ModelViewMatrix * vec4(fvLightPosition - fvObjectPosition.xyz,0.0)).xyz;
   //Normal         = gl_NormalMatrix * (gl_Normal*cubify + (1.0-cubify)*bumpNormal);
   Normal = gl_NormalMatrix * bumpNormal;
}