#version 120
const bool advancedProcedurals = 	#{{level:extreme}};
const bool parallax = 				#{{level:extreme}};
const bool scattering =				#{{level:extreme}};
const bool pbrLight = 				#{{level:high}};
const bool simpleProcedurals = 		#{{level:high}};
const bool advancedAmbience = 		#{{level:high}};
const bool normalMapping = 			#{{level:medium}};
const bool simpleAmbience = 		#{{level:medium}};
const bool selfIllumination = 		#{{level:medium}};


const int nLightCount = 2;
const float pi = 3.14159265358;
const float tau = 6.28318530717;

const vec4 hashSeed = vec4(0.16532,0.17369,0.15787,0.14987);

// constants for emissive lights and starlight intensity
const float emissiveIntensity = 2.5;
const float lightIntensity = 2.5;

uniform sampler2D biomes, cities, differenceNoise, lookup, cityGlow, surfaceData;
uniform samplerCube skybox;
uniform float lightRadius[nLightCount];
uniform vec4 ownerColor;
uniform float time;
uniform float cycle;
uniform float population;
vec4 playerPlateProfile = vec4(vec3((1.0 - ownerColor.rgb) * 0.2 + 0.8), 0.75);

// complimentary triad color harmony, should in theory always generate an appealing theme.
vec3 colorLightsPrimary = ownerColor.rgb * 0.45 + 0.55;
vec3 colorLightsSecondary = vec3(ownerColor.brg) * 0.45 + 0.55;
vec3 colorLightsTertiary = vec3(ownerColor.gbr) * 0.85 + 0.15;

const float splatSharpness = 2.0;

////Amount of population considered 'half full'
const vec3 basePopulation = vec3(1.0, 0.25, 0.25);
 
varying vec2 uv, uv2, uvNoise, uvSplat, uvB[5];
varying vec4 pos;
varying vec3 light[nLightCount];
varying vec3 normal, npos, origo;
varying float pulse, poleMask;
varying vec3 splatRadial;
varying float atmoMask;

uniform vec4[3] biomesPicks;

// parallax scale, bias and steps
const vec2 scaleBias = vec2(0.005, 0.0025);
 
// smoothstep without the edges
float smoothCurve(float x){
    return x * x * (3.0 - 2.0 * x);
}
 
vec3 toLinear(vec3 x) {
    return pow(x, vec3(2.2));
}
 
vec3 toGamma(vec3 x) {
    return pow(x, vec3(0.45));
}
 
vec3 square(vec3 x) {
    return x*x;
}
 
float square(float x) {
    return x*x;
}
 
vec2 square(vec2 x) {
    return x*x;
}
 
float pow5(float x) {
 
    float y = x*x;
    return y*y*x;
}
  
vec2 pow5(vec2 x) {
 
    vec2 y = x*x;
    return y*y*x;
}
 
vec3 pow5(vec3 x) {
 
    vec3 y = x*x;
    return y*y*x;
}
 
vec3 pow3(vec3 x) {
    return x*x*x;
}
 
vec2 pow3(vec2 x) {
    return x*x*x;
}
 
float pow3(float x) {
    return x*x*x;
}
 
float pow8(float x) {
 
    x = x*x;
    x = x*x;
    return x*x;
}

// speculer term part 1
float D_GGX(float HdotN, float Roughness)
{
    float m = Roughness * Roughness;
    float m2 = m * m;
    float denominator = HdotN * HdotN * (m2 - 1.0) + 1.0;
    float D = m2 /( pi * denominator * denominator);
    return D;
}

// specular term part 2
float V_SchlickforGGX(float Roughness, float NdotV, float NdotL)
{
    float k = Roughness * Roughness * 0.5f;
    float G1V = NdotV * (1.0 - k) + k;
    float G1L = NdotL * (1.0 - k) + k;
    return 0.25f / (G1V * G1L);
}
// fresnel for specular term
vec3 Fresnel(vec3 substance, vec3 l, vec3 h)
{
	return max(vec3(0.0), substance + (substance - 1.0) * pow(1.0 - max(0.0,(dot(l, h))), 5.0));
}
// fresnel for ambient light
vec3 Fresnel2(vec3 substance, float dotProduct, float roughness)
{
	return substance + (1.0 - substance) * pow((1.0 - dotProduct), 5.0) / (6.0 - 5.0 * roughness);
}
// diffuse term
float OrenNayerforDiffuseOnly(float roughness, float NdotL, float NdotV)
{
	float O = 0.62 - pow(1.0-NdotL * clamp(1.0-NdotV/2.0, 0.0,1.0), pi) * 0.62;
	O = mix(O, NdotL, roughness);
	return O;
}

// fail-safe get normal map z component
float deriveZ(vec2 n) {
 
    float z = pow(abs(1.0 - n.x * n.x - n.y * n.y), 0.5);
   
    return z;
}
 
// calculates palette for cracks
vec3 paletteCracks(float c)
{
    return 0.5 + 0.5 * cos(tau * (1.0 * c + vec3(0.0, 0.33, 0.67)) );
}
 
// calculates light tinting, simulating atmospheric scattering.
vec3 paletteAtmoTint( float t )
{
    t *= t;
    return square(min(vec3(1.0), 0.45 + 0.45*cos( tau*((t * 0.9)+vec3(0.45, 0.55, 0.65)) ) + (1.0 - t) * 0.25));
}
 
vec3 dp1Calc(vec3 p)
{
    return dFdx(p);
}
 
vec3 dp2Calc(vec3 p)
{
    return dFdy(p);
}
 
vec2 duv1Calc(vec2 uv)
{
    return dFdx(uv);
}
 
vec2 duv2Calc(vec2 uv)
{
    return dFdy(uv);
}

// random noise functions ahead
float hash12(vec2 p)
{
	vec3 p3  = fract(vec3(p.xyx) * hashSeed.xyz);
    p3 += dot(p3, p3.yzx + 19.19);
    return fract((p3.x + p3.y) * p3.z);
}

float noise(vec2 n) {
    const vec2 d = vec2(0.0, 1.0);
    vec2 b = floor(n), f = smoothstep(vec2(0.0), vec2(1.0), fract(n));
    return mix(mix(hash12(b), hash12(b + d.yx), f.x), mix(hash12(b + d.xy), hash12(b + d.yy), f.x), f.y);
}

float cloudMaker(vec2 n, vec2 f, int iterations, float w) {
	float total = 0.0, amplitude = 1.0;
	for (int i = 0; i < iterations; i++) {
		total += noise(n + w + f + total * 0.5) * amplitude;
		n += n;
		w *= 0.75;
		f *= 1.5;
		amplitude *= 0.4;
	}
	return total;
}

vec2 rotator(vec2 rotate, float rate)
{
	return vec2(dot(rotate,  vec2(cos(rate),  -sin(rate))), dot(rotate,  vec2(sin(rate),  cos(rate))));
}
// regular atan() fails at 0,0
float atan2(float y, float x)
{
    return x == 0.0 ? sign(y)*pi/2 : atan(y, x);
}


void main() {
	// atmoMask 1 = ground geometry, atmoMask 0 = cloud geometry
	int atmoSteps;
	if (advancedProcedurals){
		atmoSteps = 8 - int(atmoSteps * 4.0); // reduce cloud iterations for softer shadows and performance
	}
	else if (simpleProcedurals){		
		atmoSteps = 6 - int(atmoSteps * 3.0);
	}
	else{
		atmoSteps = 4 - int(atmoSteps * 2.0);
	}
	// create cloud shadows and animated clouds
	float shadow = abs(mod(uv.x + cycle - (1.0 - atmoMask), 1.0/8.0) * 8.0 - 0.5) * 2.0;
	shadow = 1.0 - smoothstep(0.7,0.8, shadow) * 0.95;
	float cloudSeamKill = 1.0 - max(0.0, abs((uv.x - 0.5) * 128.0) - 63.0);
	float cloudDistort = noise(uv * vec2(32.0, 1.0) - vec2(time * 0.125, 0.0)) * 2.0 - 1.0;
	float cloudAnimated = 1.0 - cloudMaker(uv * vec2(256.0, 8.0), vec2(time * 0.5, 0.0), atmoSteps, cloudDistort);
	cloudAnimated *= cloudSeamKill * cloudSeamKill * (3.0 - cloudSeamKill * 2.0);
	cloudAnimated = clamp(cloudAnimated * ((1.0 - atmoMask) * 0.5 + 1.0), 0.0, 1.0);
	
	// shared
	vec3 v = normalize(npos);
	vec4 n = vec4(normalize(normal), 0.5); // heightmap is stored in a later
	vec2 NdotV = vec2(max(0.0, dot(n.xyz, v)), 0.0);
	vec3 color  = vec3(0.0);
	
	// branch cloud shading off
	if(atmoMask > 0.0){
		vec4 splatMap = texture2D(surfaceData, uvB[0]) * 2.0;
		for (int i = 0; i < 4; i++) {          
			splatMap.rgb += texture2D(surfaceData, uvB[i+1]).rgb;
		}
		splatMap.rgb *= 0.166666666;
		splatMap.b = pow(max(0.0,(splatMap.b - 0.5)* 2.0), 0.25);
		vec2 uvS = uv2;
		
		vec3 r = n.xyz;
		vec4 albedoR = vec4(0.0); // pure color of a surface and roughness
		vec3 substance = vec3(0.0); // essentially an rgb specular color extracted from the albedo through metalness
		float metalness = 0.0; // dielectric or metallic surface
		float cavity = 0.5; // hard multiplier
		float ao = 1.0; // detail occluder for lights
		
		// results
		vec3 lights = vec3(0.0);
		vec3 citylights = vec3(0.0);
		
		// because we have two uvs, for poles and equator, to avoid polar distortions and hide tiling, we need to run most things twice
		mat3 TBN = mat3(0.0);
			
			// build splatting basis
			vec3 detailSamp = vec3(texture2D(biomes, uvS + biomesPicks[0].xy).a, texture2D(biomes, uvS + biomesPicks[1].xy).a, texture2D(biomes, uvS + biomesPicks[2].xy).a);
		
		vec3 splatMaskMixed = vec3(detailSamp.r + detailSamp.g, detailSamp.g + detailSamp.b, detailSamp.b); // last one comes later
		
		splatMaskMixed = min(vec3(1.0), (splatMaskMixed.rgb + splatMap.rgb) * splatMap.rgb);
		
		// optional
		splatMaskMixed = pow(splatMaskMixed.rgb, vec3(splatSharpness));
		
		// create combined detail texture and calculate weighted splat mapping for the two uv sets
		detailSamp.r = mix(mix(detailSamp.r, detailSamp.g, splatMaskMixed.r), detailSamp.b, splatMaskMixed.g) - splatMap.b;   
		
		if (normalMapping){
		
			vec3 dp1 = dp1Calc(-v);
			vec3 dp2 = dp2Calc(-v);
			// derive for both uv's
			vec2 duv1 = duv1Calc(uvS);
			vec2 duv2 = duv2Calc(uvS);
		
			vec3 dp2perp = cross(dp2, n.xyz);
			vec3 dp1perp = cross(n.xyz, dp1);
		
			// create matrix A
			vec3 tangent = dp2perp * duv1.x + dp1perp * duv2.x;
			vec3 binormal = dp2perp * duv1.y + dp1perp * duv2.y;
			float invmax = pow(max(dot(tangent, tangent), dot(binormal, binormal)), -0.5);
			TBN = mat3(tangent * invmax, binormal * invmax, n.xyz);
			
			if (parallax){
		
				// water depth refraction
				float depthRefraction = mix(1.33,0.66, square(NdotV.r)); // water refraction index is 1.33, square so transparency wont cancel it out later
				detailSamp.r *= mix(depthRefraction, 1.0, ceil(1.0 - detailSamp.r));
			
				// do parallax
				float fDet = dot(dp1, dp2perp);
				vec2 vProjVScr = (1.0/fDet) * vec2(dot(dp2perp, v), dot(dp1perp, v));
				vec2 vProjVTex = (duv1 * vProjVScr.x + duv2 * vProjVScr.y);
				float vProjVTexZ = NdotV.r * (detailSamp.r * scaleBias.r - scaleBias.g);
		
				uvS += vProjVTex * vProjVTexZ;
			}
		}
		// sample all four biomes once for each of the first two uv sets
		vec4 firstbiome    = texture2D(biomes, uvS + biomesPicks[0].xy);//red
		vec4 secondbiome   = texture2D(biomes, uvS + biomesPicks[1].xy);//green
		vec4 thirdbiome    = texture2D(biomes, uvS + biomesPicks[2].xy);//black
		
		// mix the normals cavity and resampled heightmap
		vec4 dataSamp = mix(mix(firstbiome, secondbiome, splatMaskMixed.r), thirdbiome, splatMaskMixed.g);
			float waterMask = clamp(floor((dataSamp.a + splatMap.b) * splatMap.b), 0.0, 1.0);
		
		dataSamp.a = dataSamp.b - splatMap.b;
		dataSamp.z = max(0.0, ceil(dataSamp.a));
		
		dataSamp.x = mix(0.5, dataSamp.x, dataSamp.z);
		ao = min(1.0,(dataSamp.x * 2.0));
		
		vec4 textureNoise = texture2D(differenceNoise, uvNoise.xy);
		vec2 waterNorms = vec2(mix(vec2(textureNoise.r, textureNoise.g), vec2(textureNoise.g, textureNoise.b), pulse)) - 0.5;// // could maybe be replaced by a small simple 2D noise function
			
		float underWaterBlur = pow((1.0 - dataSamp.z) * (1.0 - dataSamp.a - 1.0), 0.5) * 7.0 + 1.0;
		vec4  city	= texture2D(cities, uvS * vec2(4.0, 2.0), underWaterBlur);
		citylights = texture2D(cityGlow, uvS.xy * vec2(4.0, 2.0), underWaterBlur).rgb;
		
		float citySplat = clamp(pow5((1.0 - abs(dataSamp.a - 0.5) * 0.2)) * (abs(city.a - 0.5) + city.a) * splatMap.a, 0.0, 1.0);
		
		if (normalMapping){  
			// perform TBN matrix multiplication for each of the two normal maps separately and mix, save instructions by mix in height in alpha.
		
			n.xy = vec2(mix(dataSamp.xy, city.xy, citySplat));
			n *= 2.0;
			n -=1.0;
			//create waterNormalMap
			n.xy = mix(waterNorms * 0.1, n.xy, dataSamp.z);       
		
			n.xyz = mix(vec3(0.0,0.0,1.0), vec3(n.xy, deriveZ(n.xy)), atmoMask);
			n = vec4(normalize(TBN * n.xyz), dataSamp.a);
		
			r = normalize(reflect(-v, n.xyz));		
		}
		
		NdotV.r = dot(n.xyz, v);
		NdotV.g = (1.0 - NdotV.r) * 0.5 + 0.5;
		NdotV = max(vec2(0.0), NdotV);
		
			vec3 cityData = vec3(city.ba, citySplat);
		// create combined lookup gradients for all four biomes, clamped to not wrap the texture.
		vec3 albedoGradients = vec3(firstbiome.a, secondbiome.a, thirdbiome.a);
		// and make the flat slopes have less color shifts - think silt vs cliff sides.
		albedoGradients = clamp(1 - albedoGradients,  vec3(0.00390625), vec3(0.984375));
			vec3 lookUpValue = vec3(biomesPicks[0].z,biomesPicks[1].z,biomesPicks[2].z) + vec3(biomesPicks[0].w,biomesPicks[1].w,biomesPicks[2].w) * poleMask;
		// sample albedo and roughness from lookup table
		vec4 firstBiomesAlbedoR = texture2D(lookup,  vec2(lookUpValue.x, albedoGradients.r)); //, 0.0
		vec4 secondBiomesAlbedoR = texture2D(lookup, vec2(lookUpValue.y, albedoGradients.g)); //, 0.0
		vec4 thirdBiomesAlbedoR = texture2D(lookup,  vec2(lookUpValue.z, albedoGradients.b)); //, 0.0
		// create final splatmap , save instructions by mix in cavity in alpha.
		vec4 albedoSplatCavity = vec4(splatMaskMixed, dataSamp.b);
		
		// mix final albedo and tweak with cavity roughness values
		albedoR = mix(mix(firstBiomesAlbedoR, secondBiomesAlbedoR, albedoSplatCavity.r), thirdBiomesAlbedoR, albedoSplatCavity.g);
			cityData.rg = cityData.rg * 0.33 + 0.5;
			albedoR = mix(albedoR, vec4(playerPlateProfile.rgb * cityData.g, playerPlateProfile.a) * cityData.r, cityData.b);
		
		// creates ocean color
		vec3 oceanColor = texture2D(lookup, vec2(biomesPicks[0].z, max(0.995, waterMask * 0.05))).rgb; //  from 0.0065 to 0.0025
			
		//creates lights
		citylights.rg *= (1.5 - underWaterBlur * 0.1) * min(1.0, cityData.b + (1.0 - dataSamp.z) * 0.5 * splatMap.a);
		citylights.g *= 0.5;
		citylights.b *= splatMap.a * 0.5;
		citylights = clamp(vec3(population) - vec3(0.0, 15.0, 30.0), vec3(0.0), vec3(1.0)) * citylights * emissiveIntensity;
		citylights = toLinear(citylights.r * colorLightsPrimary) + toLinear(citylights.g * colorLightsSecondary) + toLinear(citylights.b * colorLightsTertiary);
		citylights *= min(vec3(1.0), square(oceanColor.rgb) + dataSamp.z);
		
		// creates oceans
		albedoR = mix(vec4((oceanColor / (1.0 + (1.0 - NdotV.y) * 0.75)) * mix(min(1.0, dataSamp.y * dataSamp.x * pow3(splatMap.b) * 16.0 + 0.25), 1.0, NdotV.y), 0.25), albedoR, dataSamp.z);
		
		// clamp to keep in PBR safe ranges - nothing in reality either albedo nor roughness is 0 or 1 and can make the math fail
		albedoR = clamp(albedoR, vec4(0.05), vec4(0.975));
		
		
		// create sss mask
		vec4 invertedAlbedo = 1.0 - albedoR;   
		float SSSmask = mix(NdotV.r * 0.5 + 0.5, 1.0 - min(1.0, pow8((1.0 - invertedAlbedo.a * invertedAlbedo.b) * (1.0 - invertedAlbedo.r * invertedAlbedo.g))) * dataSamp.y * dataSamp.x, dataSamp.z);
		
		// creates a metalness value if biomes are above 1950 on the lookup, for metallic specular on crystals.
		metalness = square(n.a) * ceil(mix(mix(biomesPicks[0].z, biomesPicks[1].z, albedoSplatCavity.r), biomesPicks[2].z, albedoSplatCavity.g) - 0.9521484375) * dataSamp.z;
		// Substance setup and Albedo adjust
		albedoR.rgb = toLinear(albedoR.rgb);
		substance = clamp((0.04 - 0.04 * metalness) + albedoR.rgb * metalness,0.0, 1.0);
		albedoR.rgb -= substance;
			
		// actual shading starts here
		vec3 ambientFresnel = Fresnel2(substance, NdotV.r ,albedoR.a);
		
		if (advancedAmbience){
			
			color += square((textureCube(skybox, r, sqrt(albedoR.a) * 8.0).rgb) + 0.024) * ambientFresnel;
		
			// ambient light
			color += square(textureCube(skybox, n.xyz, 8.0).rgb + 0.024) * albedoR.rgb * (1.0 - ambientFresnel);
		}
		else if (simpleAmbience){
			// Ambient reflections with fix mip and n instead of refect
			color += square(textureCube(skybox, r, 3.0).rgb * ambientFresnel);
		
			// Ambient light - average color of skybox squared
			color += vec3(0.006724, 0.014884, 0.067081) * albedoR.rgb * (1.0 - ambientFresnel);
		}
		else{
			// Ambient 
			color += vec3(0.006724, 0.014884, 0.067081) * (ambientFresnel + albedoR.rgb * (1.0 - ambientFresnel));
		}
		color *= ao;
		float cloudShadow = 1.0 - cloudAnimated;

		if (pbrLight){	
	
			for (int i = 0; i < nLightCount; i++) {
				float distance = length(gl_LightSource[i].position.xyz - pos.xyz); // EYE SPACE, I'm sorry:o(
				// rest is world space
	
				vec3 L = normalize(light[i] / distance);
				vec2 NdotL = max(vec2(0.0), vec2(dot(mix(n.xyz, normalize(normal), 0.5),L) * 0.8 + 0.2, dot(n.xyz,L)));
	
				float sqrLightRadius = square(lightRadius[i]);
				float illuminance = lightIntensity * pi * (sqrLightRadius / (max(sqrLightRadius, dot(L,L) )));
							
				// note the square to kill hard spec in deep space!
				float attenuation = square(1.0 / (1.0 + (gl_LightSource[i].constantAttenuation
				+ gl_LightSource[i].linearAttenuation * distance
				+ gl_LightSource[i].quadraticAttenuation * square(distance)))) * illuminance * NdotL.x  * shadow;
				
				citylights *= clamp(1.0 - attenuation, 0.0, 1.0) * atmoMask;
	
				if (attenuation >0.0){
					vec3 VplusL = L + v * 0.5; // *0.5 is not correct but without it grazing angle specular fails, propably somewhere something is flipped space/normal space
					vec3 halfVec = normalize(VplusL);
					float HdotN = max(0.0, dot(halfVec, n.xyz));
					vec3 F = Fresnel(substance, L, halfVec);
					float D = max(0.0, D_GGX(HdotN, albedoR.a));
					float V = max(0.0, V_SchlickforGGX((1.0 + albedoR.a) * 0.5, NdotV.r, NdotL.y));
					float O = OrenNayerforDiffuseOnly(albedoR.a, NdotL.y, NdotV.r);
					
					vec3 A = vec3(1.0);
					vec3 SSS = vec3(0.0);
					if (scattering) {
						// atmospheric light tinting simulating scattering
						A = vec3(paletteAtmoTint(1.0 - max(0.0, min(0.33, dot(normal,L) * square(shadow)) + 0.15)));
					
						// sub surface scattering model
						float inScatter = pow(clamp(dot(L, -v), 0.0, 1.0), 12.0) * mix(8.0, 0.1, SSSmask);
						float normalContribution = clamp(dot(mix(normal, n.xyz, SSSmask), halfVec) * SSSmask + 1.0 - SSSmask, 0.0, 1.0);
						float backScatter = dataSamp.x * normalContribution / tau;
						SSS = mix(backScatter, 1.0, inScatter) * square(oceanColor) * NdotL.x;    
					}
					color += ((D * V * F) + ((1.0 - F) * O * albedoR.rgb) + SSS) * cloudShadow * gl_LightSource[i].diffuse.rgb * attenuation;		
				}
			}
			// hard cavity multiplier
			color *= dataSamp.x - metalness + 1.0;
		}
			// probably not worth it to check attenuation like pbr
		else{
		
			for (int i = 0; i < nLightCount; i++) {	
				float distance = length(gl_LightSource[i].position.xyz - pos.xyz); // EYE SPACE, I'm sorry:o(
				// rest is world space
	
				vec3 L = normalize(light[i] / distance);
				float NdotL = max(0.0, dot(n.xyz,L));
				
				float sqrLightRadius = square(lightRadius[i]);
				float illuminance = lightIntensity * pi * (sqrLightRadius / (max(sqrLightRadius, dot(L,L))));
				
				// note the square to kill hard spec in deep space!
				float attenuation = square(1.0 / (1.0 + (gl_LightSource[i].constantAttenuation
				+ gl_LightSource[i].linearAttenuation * distance
				+ gl_LightSource[i].quadraticAttenuation * square(distance)))) * illuminance * NdotL;
				
				citylights *= clamp(1.0 - attenuation, 0.0, 1.0);
				vec3 VplusL = L + v; 
				vec3 halfVec = normalize(VplusL);
				float HdotN = max(0.0, dot(halfVec, n.xyz));
				vec3 S = Fresnel2(substance, HdotN ,albedoR.a);
				// albedoR.rgb * (dataSamp.x * 0.75) to sorta hack albedo into a classical diffuse texture
				color += max(vec3(0.001), albedoR.rgb * (dataSamp.x * 0.75) + pow(S * HdotN, vec3(albedoR.a + 5.0))) * gl_LightSource[i].diffuse.rgb * attenuation;
			}
		}
		gl_FragColor.rgb = toGamma(clamp(color + lights + citylights, vec3(0.0), vec3(1.0)));	
		gl_FragColor.a = 1.0;
	}
	else{
		float atmosphere = 1.0 - NdotV.r;	
		for (int i = 0; i < nLightCount; i++) {
			// atmo color is terran atmosphere blue part precalculated to linear
			color += mix(vec3(0.218,0.456,0.978) * atmosphere, gl_LightSource[i].diffuse.rgb, cloudAnimated) * shadow;
		}
		gl_FragColor.rgb = toGamma(color);
		gl_FragColor.a = mix(square(atmosphere) * 0.75, cloudAnimated, cloudAnimated);
	}
}