//=============================================================================
// by turbo
// because distancefog should change too in conjunction with gametimemanager and daytimesunlight
// OBSOLETE
//=============================================================================
class DayZoneLightFogChanger extends Trigger;

var GameTimeManager Manager;
var DaylightSunlight Daylight;
var() Name  DaylightSunlightTag;
var ZoneInfo ZoneActor;
var() Name  ZoneTag;

simulated function BeginPlay()
{
	foreach AllActors(Class'GameTimeManager',Manager)
		break;
	if ( DaylightSunlightTag != '' )
		foreach AllActors(Class'DaylightSunlight',Daylight,DaylightSunlightTag)
			break;
	if ( ZoneTag != '' )
		foreach AllActors(Class'ZoneInfo',ZoneActor,ZoneTag)
			break;
	if( ZoneActor==None || Manager==None || Daylight==None || Level.NetMode==NM_DedicatedServer || DaylightSunlightTag=='' || ZoneTag=='' )
	{
		Disable('Tick');
	}
	else
	{
		Role = ROLE_Authority;
	}
}
simulated function Tick( float Delta )
{
	Delta = Manager.GameTime*Manager.FullDayTimeDiv;
	//BroadcastMessage( Delta ); //DEBUG BROADCAST
	//changecolors();
	
	
	ZoneActor.FogColor.R = HLStoRGB(Daylight.LightHue,Daylight.LightBrightness,Daylight.LightSaturation).x;
	ZoneActor.FogColor.G = HLStoRGB(Daylight.LightHue,Daylight.LightBrightness,Daylight.LightSaturation).y;
	ZoneActor.FogColor.B = HLStoRGB(Daylight.LightHue,Daylight.LightBrightness,Daylight.LightSaturation).z;
	//BroadcastMessage( HLStoRGB(Daylight.LightHue,Daylight.LightBrightness,Daylight.LightSaturation) ); //DEBUG BROADCAST
}

/*
function changecolors()
{
	local float R,G,B,F,P,Q,T;
	local int H;
	
	Delta = Manager.GameTime*Manager.FullDayTimeDiv;
	BroadcastMessage( Delta ); //DEBUG BROADCAST
	
	H = (Daylight.LightHue / 255) * 6;
	F = Daylight.LightHue * 6 - H;
	P = Daylight.LightBrightness * (1 - Daylight.LightSaturation);
	Q = Daylight.LightBrightness * (1 - F * Daylight.LightSaturation);
	T = Daylight.LightBrightness * (1 - (1 - F) * Daylight.LightSaturation);
	
	if (H == 0)
	{
		R = Daylight.LightBrightness;
		G = T;
		B = P;
	}
	else if (H == 1)
	{
		R = Q;
		G = Daylight.LightBrightness;
		B = P;
	}
	else if (H == 2)
	{
		R = P;
		G = Daylight.LightBrightness;
		B = T;
	}
	else if (H == 3)
	{
		R = P;
		G = Q;
		B = Daylight.LightBrightness;
	}
	else if (H == 4)
	{
		R = T;
		G = P;
		B = Daylight.LightBrightness;
	}
	else if (H == 5)
	{
		R = Daylight.LightBrightness;
		G = P;
		B = Q;
	}
	
	ZoneActor.FogColor.B = int(B*255);
	ZoneActor.FogColor.G = int(G*255);
	ZoneActor.FogColor.R = int(R*255);
	
	BroadcastMessage( ZoneActor.FogColor.R ); //DEBUG BROADCAST
	BroadcastMessage( ZoneActor.FogColor.G ); //DEBUG BROADCAST
	BroadcastMessage( ZoneActor.FogColor.B ); //DEBUG BROADCAST
	
	



}
*/
/*
//APPROACH 4
//=============================================================================
function changecolors()
{
	local float Min;
	local float Chroma;
	local float Hdash;
	local float X;
	local float R,G,B;
	
 
	Chroma = Daylight.LightSaturation * Daylight.LightBrightness;
	Hdash = Daylight.LightHue / 60.0;
	X = Chroma * (1.0 - Abs((Hdash % 2.0) - 1.0));
 
	if(Hdash < 1.0)
	{
		R = Chroma;
		G = X;
	}
	else if(Hdash < 2.0)
	{
		R = X;
		G = Chroma;
	}
	else if(Hdash < 3.0)
	{
		G = Chroma;
		B = X;
	}
	else if(Hdash < 4.0)
	{
		G= X;
		B = Chroma;
	}
	else if(Hdash < 5.0)
	{
		R = X;
		B = Chroma;
	}
	else if(Hdash <= 6.0)
	{
		R = Chroma;
		B = X;
	}
	
	Min = Daylight.LightBrightness - Chroma;
 
	ZoneActor.FogColor.B = B += Min;
	ZoneActor.FogColor.G = G += Min;
	ZoneActor.FogColor.R = R += Min;
	
	BroadcastMessage( ZoneActor.FogColor.R ); //DEBUG BROADCAST
	BroadcastMessage( ZoneActor.FogColor.G ); //DEBUG BROADCAST
	BroadcastMessage( ZoneActor.FogColor.B ); //DEBUG BROADCAST
	
}
*/

//APPROACH 3
//=============================================================================
simulated final function vector HLStoRGB(float H,float L,float S)
{
	//local float OffsetLightness;
	local float OffsetSaturation;
	local vector cout;
 
	H = fclamp(H,0,255);
	L = fclamp(L,0,255);
	S = fclamp(S,0,255);
	S = 255 - S;
 
	if(H < 85)
		cout.x = fMin(1, (85 - H)  / 42.5);
 
	else if(H > 170)
		cout.x = fMin(1, (H - 170) / 42.5);
 
	if (H < 170)
		cout.y = fMin(1, (85 - Abs(H -  85)) / 42.5);
 
	if (H > 85)
		cout.z = fMin(1, (85 - Abs(H - 170)) / 42.5);

	if (S < 255)
	{
		cout = cout * (S / 255);
		OffsetSaturation =  (255 - S) / 255;
		cout.x += OffsetSaturation;
		cout.y += OffsetSaturation;
		cout.z += OffsetSaturation;
	}
 
	cout = cout * (255 - Abs(L - 255));
	//cout = cout * ((255 - Abs(L - 255)) / 255);
	return cout;
}

/*
//APPROACH 2
//=============================================================================
static function vector HLStoRGB(int H, int L, int S) 
{
	local int OffsetLightness;
	local int OffsetSaturation;
	local vector Color;
 
	if (H < 0) H = (240 - H) % 240;
    else H =        H  % 240;
 	if (H <  80) Color.x = Min(255, 255 * (80 - H)  / 40);
	else if (H > 160) Color.x = Min(255, 255 * (H - 160) / 40);
	if (H < 160) Color.y = Min(255, 255 * (80 - Abs(H -  80)) / 40);
	if (H >  80) Color.z = Min(255, 255 * (80 - Abs(H - 160)) / 40);
 	if (S < 240) 
	{
		Color = Color * (float(S) / 240);
		OffsetSaturation = 128 * (240 - S) / 240;
		Color.x += OffsetSaturation;
		Color.y += OffsetSaturation;
		Color.z += OffsetSaturation;
    }
 
	L = Min(240, L);
	Color = Color * ((120 - Abs(L - 120)) / 120);
 
	if (L > 120) 
	{
		OffsetLightness = 256 * (L - 120) / 120;
		Color.x += OffsetLightness;
		Color.y += OffsetLightness;
		Color.z += OffsetLightness;
    }
 
	return Color;
}
*/
/*
//APPROACH 1
//=============================================================================
final simulated function float HueToRGB(float n1, float n2, float hue)
{
	if ( hue < 0 ) hue += HLSMAX;
	if ( hue > HLSMAX ) hue -= HLSMAX;
 
	// return r,g, or b value from this tridrant 
	if ( hue < (HLSMAX/6) )
		return ( n1 + (((n2-n1)*hue + (HLSMAX/12))/(HLSMAX/6)) );
	if ( hue < (HLSMAX/2) )
		return n2;
	if ( hue < ((HLSMAX*2)/3) )
		return ( n1 + (((n2-n1)*(((HLSMAX*2)/3)-hue) + (HLSMAX/12))/(HLSMAX/6)) );
	else
		return n1;
}

simulated final function vector HLStoRGB(byte hue, byte lum, byte sat)
{
	local vector C;
	local float Magic1, Magic2;
	local int R,G,B;
	const HLSMAX = 240;
	const RGBMAX = 255;
	
	if ( sat==0)
	{     // achromatic case
		C.x = (lum * RGBMAX) / HLSMAX;
		C.y = C.x;
		C.z = C.x;
 
		//Small fix
		R = C.x;
		G = C.y;
		B = C.z;
	}
	else
	{       // chromatic case
		// set up magic numbers
		if (lum <= (HLSMAX/2))
		{
			Magic2 = (lum*(HLSMAX+sat)+(HLSMAX/2)) / HLSMAX;
		}
		else
		{
			Magic2 = lum+sat - ((lum*sat)+(HLSMAX/2)) / HLSMAX;
		}
		Magic1 = 2*lum - Magic2;
 
		// get RGB, change units from HLSMAX to RGBMAX
		R = (HueToRGB(Magic1, Magic2, hue+(HLSMAX/3))
				* RGBMAX + (HLSMAX/2)) / HLSMAX;
		G = (HueToRGB(Magic1, Magic2, hue)
				* RGBMAX + (HLSMAX/2)) / HLSMAX;
		B = (HueToRGB(Magic1, Magic2, hue-(HLSMAX/3))
				* RGBMAX + (HLSMAX/2)) / HLSMAX;
	
	
	
	}
 
	C.x = R;
	C.y = G;
	C.z = B;
	//C.A = 255;
	return C;
}
*/
defaultproperties
{
    RemoteRole=ROLE_None
	Texture=Texture'Engine.S_SpecialEvent'
}