//////////////////////////  2D Perlin Noise   //////////////////////////uniform sampler2D permTexture;uniform vec2 nScale;uniform vec2 nOffset;uniform float dAmt;/*	To create offsets of one texel and one half texel in the	texture lookup, we need to know the texture image size.*/const float permTexUnit = 1.0 / 256.0;const float permTexUnitHalf = 0.5 / 256.0;float fade(in float t) {	return t*t*t*(t*(t*6.0-15.0)+10.0);}float pnoise2(in vec2 P){	// Integer part, scaled and offset for texture lookup	vec2 Pi = permTexUnit*floor(P)+permTexUnitHalf;	// Fractional part for interpolation	vec2 Pf = fract(P);		// Noise contribution from lower left corner	vec2 grad00 = texture2D(permTexture, Pi).rg * 4.0 - 1.0;	float n00 = dot(grad00, Pf);		// Noise contribution from lower right corner	vec2 grad10 = texture2D(permTexture, Pi + vec2(permTexUnit, 0.0)).rg * 4.0 - 1.0;	float n10 = dot(grad10, Pf - vec2(1.0, 0.0));		// Noise contribution from upper left corner	vec2 grad01 = texture2D(permTexture, Pi + vec2(0.0, permTexUnit)).rg * 4.0 - 1.0;	float n01 = dot(grad01, Pf - vec2(0.0, 1.0));		// Noise contribution from upper right corner	vec2 grad11 = texture2D(permTexture, Pi + vec2(permTexUnit, permTexUnit)).rg * 4.0 - 1.0;	float n11 = dot(grad11, Pf - vec2(1.0, 1.0));		// Blend contributions along x	vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade(Pf.x));		// Blend contributions along y	float n_xy = mix(n_x.x, n_x.y, fade(Pf.y));		// We're done, return the final noise value.	return n_xy;}////////////////////////  Sphere Function ////////////////////////uniform float sRadius;const float PI = 3.14159265359;const float TWOPI = 6.28318530718;vec3 sphere(in vec2 uv) {	uv[0] *= PI;	uv[1] *= TWOPI;	vec3 sPoint;	sPoint.x = cos(uv[0]) * cos(uv[1]);	sPoint.y = sin(uv[0]) * cos(uv[1]);	sPoint.z = sin(uv[1]);	return sPoint;}/////////////////////////////////////// Calculate Noise-Modulated Point ///////////////////////////////////////vec3 vNoisePoint(in vec2 p) {	vec3 pSphere = sphere(p.xy);				// Create sphere	vec2 nVal = pSphere.xy * nScale + nOffset;	// Values for noise	float noise = pnoise2(nVal);				// Noise value	noise = 0.5 * noise + 0.5;					// Scale and offset to 0 > 1 range	vec3 sNorm = normalize(pSphere);				// Fake normal		// Return XYZ coordinates of point moved along fake sphere normal	return (pSphere + (sNorm * noise * dAmt)) * sRadius;}///////////////////////// Lighting & Normal /////////////////////////varying vec3 lightVec, view, normal;const vec2 gridX = vec2(0.001,0.0);const vec2 gridY = vec2(0.0,0.001);void velvetVS(in vec3 p, in vec3 np) {	// Calculate normal by 'neighbour' technique	vec3 tangent	 = vNoisePoint(p.xy + gridX) - np;	vec3 bitangent = vNoisePoint(p.xy + gridY) - np;	normal = normalize(cross(tangent, bitangent));	normal = gl_NormalMatrix * normal;	normal = (normal.z < 0.0) ? -normal : normal;		// Other varying to FS	vec3 lPos = gl_LightSource[0].position.xyz;	vec4 po = vec4(p,1.0);	vec3 pw = (gl_ModelViewMatrix * po).xyz;	lightVec = normalize(lPos - pw);	vec3 eyePos = vec3(0.0,0.0,1.0);	view = normalize(eyePos - pw);}/////////////////////   Main Loop   /////////////////////void main(){	vec4 vert = gl_Vertex;		// Noise vertex	vec4 nVert = vec4(vNoisePoint(vert.xy),1.0);		velvetVS(vert.xyz, nVert.xyz);				// Transform vertex by modelview and projection matrices	gl_Position = gl_ModelViewProjectionMatrix * nVert;		// Forward texture coordinates after applying texture matrix	gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;}

uniform vec4 lDiffColor;	// Diffuse Color (0.5, 0.5, 0.5, 1.0)uniform vec4 lSpecColor;	// Specular Color (0.7, 0.7, 0.75, 1.0)uniform vec4 lSubColor;		// Under-Color (0.2, 0.2, 1.0, 1.0)uniform float lRollOff;		// Edge Rolloff 0.0 > 1.0varying vec3 lightVec, view, normal;vec4 velvetFS() {	vec3 Ln = normalize(lightVec);	vec3 Nn = normalize(normal);	vec3 Vn = normalize(view);	vec3 Hn = normalize(Vn + Ln);	float ldn = dot(Ln,Nn);	float diffComp = max(0.0,ldn);	vec3 diffContrib = vec3(diffComp * lDiffColor);	float subLamb = smoothstep(-lRollOff,1.0,ldn) - smoothstep(0.0,1.0,ldn);	subLamb = max(0.0,subLamb);	vec3 subContrib = vec3(subLamb * lSubColor);	float vdn = 1.0-dot(Vn,Nn);	vec4 vecColor = vec4(vec3(vdn),1.0);	vec4 DiffuseContrib = vec4((subContrib+diffContrib).xyz,1.0);	vec4 SpecularContrib = vec4((vecColor*lSpecColor).xyz,1.0);	return DiffuseContrib + SpecularContrib;}/////////////////////   Main Loop   /////////////////////void main(){	//	gl_FragColor = velvetFS();}</font>

/// VERTEX SHADER/*	2D Perlin-Noise in the vertex shader, based originally on	vBomb.fx HLSL vertex noise shader, from the NVIDIA Shader Library.	http://developer.download.nvidia.com/shaderlibrary/webpages/shader_library.html#vbomb		Original Perlin function substituted for Stefan Gustavson's	texture-lookup-based Perlin implementation.		Quartz Composer setup	toneburst 2009	http://machinesdontcare.wordpress.com*///////////////////////////  2D Perlin Noise   ///////////////////////////*	2D Perlin-Noise from example by Stefan Gustavson, found at	http://staffwww.itn.liu.se/~stegu/simplexnoise/*/uniform sampler2D permTexture;			// Permutation textureconst float permTexUnit = 1.0/256.0;		// Perm texture texel-sizeconst float permTexUnitHalf = 0.5/256.0;	// Half perm texture texel-sizefloat fade(in float t) {	return t*t*t*(t*(t*6.0-15.0)+10.0);}float pnoise2D(in vec2 p){	// Integer part, scaled and offset for texture lookup	vec2 pi = permTexUnit*floor(p) + permTexUnitHalf;	// Fractional part for interpolation	vec2 pf = fract(p);		// Noise contribution from lower left corner	vec2 grad00 = texture2D(permTexture, pi).rg * 4.0 - 1.0;	float n00 = dot(grad00, pf);		// Noise contribution from lower right corner	vec2 grad10 = texture2D(permTexture, pi + vec2(permTexUnit, 0.0)).rg * 4.0 - 1.0;	float n10 = dot(grad10, pf - vec2(1.0, 0.0));		// Noise contribution from upper left corner	vec2 grad01 = texture2D(permTexture, pi + vec2(0.0, permTexUnit)).rg * 4.0 - 1.0;	float n01 = dot(grad01, pf - vec2(0.0, 1.0));		// Noise contribution from upper right corner	vec2 grad11 = texture2D(permTexture, pi + vec2(permTexUnit, permTexUnit)).rg * 4.0 - 1.0;	float n11 = dot(grad11, pf - vec2(1.0, 1.0));		// Blend contributions along x	vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade(pf.x));		// Blend contributions along y	float n_xy = mix(n_x.x, n_x.y, fade(pf.y));		// We're done, return the final noise value.	return n_xy;}/////////////////////// Sphere Function ///////////////////////const float PI = 3.14159265;const float TWOPI = 6.28318531;uniform float BaseRadius;vec4 sphere(in float u, in float v) {	u *= PI;	v *= TWOPI;	vec4 pSphere;	pSphere.x = BaseRadius * cos(v) * sin(u);	pSphere.y = BaseRadius * sin(v) * sin(u);	pSphere.z = BaseRadius * cos(u);	pSphere.w = 1.0;	return pSphere;}///////////////////////////// Apply 2D Perlin Noise /////////////////////////////uniform vec3 NoiseScale;	// Noise scale, 0.01 > 8uniform float Sharpness;	// Displacement 'sharpness', 0.1 > 5uniform float Displacement;	// Displcement amount, 0 > 2uniform float Speed;		// Displacement rate, 0.01 > 1uniform float Timer;		// Feed incrementing value, infinitevec4 perlinSphere(in float u, in float v) {	vec4 sPoint = sphere(u, v);	// The rest of this function is mainly from vBomb shader from NVIDIA Shader Library	vec4 noisePos = vec4(NoiseScale.xyz,1.0) * (sPoint + (Speed * Timer));	float noise = (pnoise2D(noisePos.xy) + 1.0) * 0.5;;	float ni = pow(abs(noise),Sharpness) - 0.25;	vec4 nn = vec4(normalize(sPoint.xyz),0.0);	return (sPoint - (nn * (ni-0.5) * Displacement));}////////////////////////////////// Calculate Position, Normal //////////////////////////////////const float grid = 0.01;	// Grid offset for normal-estimationvarying vec3 norm;			// Normalvec4 posNorm(in float u, in float v) {	// Vertex position	vec4 vPosition = perlinSphere(u, v);	// Estimate normal by 'neighbour' technique	// with thanks to tonfilm	vec3 tangent = (perlinSphere(u + grid, v) - vPosition).xyz;	vec3 bitangent = (perlinSphere(u, v + grid) - vPosition).xyz;	norm = gl_NormalMatrix * normalize(cross(tangent, bitangent));	// Return vertex position	return vPosition;}//////////////////////////// Phong Directional VS ////////////////////////////// -- Lighting varyings (to Fragment Shader)varying vec3 lightDir0, halfVector0;varying vec4 diffuse0, ambient;void phongDir_VS() {	// Extract values from gl light parameters	// and set varyings for Fragment Shader	lightDir0 = normalize(vec3(gl_LightSource[0].position));	halfVector0 = normalize(gl_LightSource[0].halfVector.xyz);	diffuse0 = gl_FrontMaterial.diffuse * gl_LightSource[0].diffuse;	ambient =  gl_FrontMaterial.ambient * gl_LightSource[0].ambient;	ambient += gl_LightModel.ambient * gl_FrontMaterial.ambient;}///////////////// Main Loop /////////////////uniform vec2 PreScale, PreTranslate;	// Mesh pre-transformvoid main(){	vec2 uv = gl_Vertex.xy;	// Offset XY mesh coords to 0 > 1 range	uv += 0.5;		// Pre-scale and transform mesh	uv *= PreScale;	uv += PreTranslate;		// Calculate new vertex position and normal	vec4 spherePos = posNorm(uv[0], uv[1]);		// Calculate lighting varyings to be passed to fragment shader	phongDir_VS();		// Transform new vertex position by modelview and projection matrices	gl_Position = gl_ModelViewProjectionMatrix * spherePos;		// Forward current texture coordinates after applying texture matrix	gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;}/// FRAGMENT SHADER/*	Generic Fragment Shader	with Phong Directional lighting*///////////////////////////// Phong Directional FS ////////////////////////////// -- Lighting varyings (from Vertex Shader)varying vec3 norm, lightDir0, halfVector0;varying vec4 diffuse0, ambient;vec4 phongDir_FS(){	vec3 halfV;	float NdotL, NdotHV;		// The ambient term will always be present	vec4 color = ambient;		// compute the dot product between normal and ldir	NdotL = max(dot(norm, lightDir0),0.0);		if (NdotL > 0.0) {		color += diffuse0 * NdotL;		halfV = normalize(halfVector0);		NdotHV = max(dot(norm, halfV), 0.0);		color +=	gl_FrontMaterial.specular * 				gl_LightSource[0].specular * 				pow(NdotHV, gl_FrontMaterial.shininess);	}		return color;}///////////////// Main Loop /////////////////void main(){	// Call lighting function and return result	gl_FragColor = phongDir_FS();}