UTMultiTeam.UTMT_TeamMaterialTransformer

//-----------------------------------------------------------
// Based upon Lotus's CustomUT skin shaders, code and shaders
// used with permission.
//
// Copyright 2007, Infinity Impossible
//-----------------------------------------------------------
class UTMT_TeamMaterialTransformer extends ReplicationInfo
	abstract;


struct ReplacementMaterial
{
	var string MaterialName;
	var MaterialInterface ReplacementMaterial;
};


struct VectorParameterTransform
{
	var name ParamName;
	var LinearColor ParamValue;
};


/**
 * Describes the transforms performed on a given material to turn it into
 * the new team color using the new materials. Hue is the same as the hue value
 * in the HSV color space (use the interwebs to find info on hue, saturation
 * and value if you want more info ;)). R, G and B express a multiplier on the
 * transformed values: 1 leaves the skin the same after the transform, greater
 * then 1 makes the skins brigher, less than 1 makes them darker.
 *
 * VectorParams can be used to express material-specific parameter changes. For
 * example, on a character skin you might want something along the lines of:
 *
 *		ParamName="Char_TeamColor",ParamValue=(R=2,G=0,B=0,A=2)
 *
 * which would change the "Char_TeamColor" variable, that controls the glowstick
 * distance effect to be red for this transform.
 */
struct TeamColorTransform
{
	var float Hue;
	var float R;
	var float G;
	var float B;
	var array<VectorParameterTransform> VectorParams;
};


/** Named material texture parameters to copy from the old material to the new */
var array<name> TextureParameterNames;
/** Named material scalar parameters to copy from the old material to the new */
var array<name> ScalarParameterNames;
/** Named material vector parameters to copy from the old material to the new */
var array<name> VectorParameterNames;


/**
 * Any base material with a given replacement name is swapped for the
 * corresponding replacement material.
 */
var array<ReplacementMaterial> ReplacementMaterials;


var LinearColor RedMask;
var LinearColor BlueMask;
var LinearColor GreenMask;


simulated function MaterialInterface GetTeamColorShader(string MatName)
{
	local int i;
	local MaterialInterface Mat;

	Mat = none;
	for(i = 0; i < ReplacementMaterials.Length; ++i)
	{
		if( (ReplacementMaterials[i].MaterialName ~= MatName)
			|| (string(ReplacementMaterials[i].ReplacementMaterial) ~= MatName) )
		{
			Mat = ReplacementMaterials[i].ReplacementMaterial;
		}
	}

	return Mat;
}


simulated function TransformMaterial(MaterialInstanceConstant OldMIC, TeamColorTransform TCT)
{
	local MaterialInstanceConstant NewMIC;
	local string NewMatName;
	local MaterialInterface NewMaterial;

	NewMatName = GetRootMaterialName(OldMIC);
	NewMaterial = GetTeamColorShader(NewMatName);

	if(NewMaterial == None)
	{
		LogInternal("No team color material found for Material by the name of:"@NewMatName);
	}
	else
	{
		if( !(GetRootMaterialName(OldMIC) ~= string(NewMaterial)) )
		{
			NewMIC = new class'MaterialInstanceConstant';
			NewMIC.SetParent(NewMaterial);

			CopySkinParameters(NewMIC, OldMIC);
			OldMIC.SetParent(NewMIC);
		}

		SetTeamHue(OldMIC, TCT);
	}
}


simulated function SetTeamHue(MaterialInstanceConstant MIC, TeamColorTransform TCT)
{
	local LinearColor NewRed;
	local LinearColor NewGreen;
	local LinearColor NewBlue;
	local LinearColor LC;
	local VectorParameterTransform Param;
	local float ParamSize;
	local int i;

	TCT.Hue += 120.0;

	NewRed = HueTransform(RedMask, TCT.Hue) * TCT.R;
	NewGreen = HueTransform(GreenMask, TCT.Hue) * TCT.G;
	NewBlue = HueTransform(BlueMask, TCT.Hue) * TCT.B;

	for(i = 0; i < TCT.VectorParams.Length; ++i)
	{
		Param = TCT.VectorParams[i];
		MIC.GetVectorParameterValue(Param.ParamName, LC);
		ParamSize = Sqrt(LC.R*LC.R + LC.B*LC.B + LC.G*LC.G);
		MIC.SetVectorParameterValue(Param.ParamName, Param.ParamValue * ParamSize);
	}

	MIC.SetVectorParameterValue('ColorMult_Red', NewRed);
	MIC.SetVectorParameterValue('ColorMult_Green', NewGreen);
	MIC.SetVectorParameterValue('ColorMult_Blue', NewBlue);
}


/**
 * Return the name of the material at the top of the instancing chain. This
 * assumes that once we reach a MaterialInterface that has itself as its
 * parent, we have reached the top of the chain.
 */
static simulated function string GetRootMaterialName(MaterialInterface Mat)
{
	local MaterialInterface LastMat;

    LastMat = Mat;
   	Mat = Mat.GetMaterial();

   	while(Mat != LastMat)
   	{
   		LastMat = Mat;
	   	Mat = Mat.GetMaterial();
   	}

	return string(Mat);
}


/**
 * Spins the given color from its current hue by the amount given as deltaH
 * and returns the transformed color.
 */
simulated function LinearColor HueTransform(LinearColor L, float deltaH)
{
    local float Max, Min, R, G, B, H, S, V, f, p, q, t;
    local int sector;

	R = L.R/255.0;
	G = L.G/255.0;
	B = L.B/255.0;

	if(R == G && G == B)
		return L;

    Max = FMax(R, FMax(G, B));
    Min = FMin(R, FMin(G, B));

    if(max == R)
    {
        if(G >= B)
            H = 60.0*(G-B)/(Max-Min);
        else
            H = 60.0*(G-B)/(Max-Min)+360.0;
    }
    else if(max == G)
    {
        H = 60.0*(B-R)/(Max-Min)+120.0;
    }
    else
    {
        H = 60.0*(R-G)/(Max-Min)+240.0;
    }

    if(Max == 0.0)
        S = 0.0;
    else
        S = 1.0-Min/Max;

    V = max;


    H = (H + deltaH)%360;
    sector = int(H/60)%6;
    f = H/60.0-sector;
    p = v*(1-s);
    q = v*(1-f*s);
    t = v*(1-(1-f)*s);

	switch (sector)
	{
		case 0:   return MakeLinearColor(v,t,p,1);
		case 1:   return MakeLinearColor(q,v,p,1);
		case 2:   return MakeLinearColor(p,v,t,1);
		case 3:   return MakeLinearColor(p,q,v,1);
		case 4:   return MakeLinearColor(t,p,v,1);
		case 5:   return MakeLinearColor(v,p,q,1);
	}

    return L;
}


/**
 * Copy all skin parameters manually, since, eg, MI.TextureParameterValues.Length
 * is 0, even though it has parameters we can use...
 */
simulated function CopySkinParameters(MaterialInstanceConstant NewMI, MaterialInterface MI)
{
	local name ParamName;
	local LinearColor LC;
	local float F;
	local texture Tex;
	local int i;


	//===============================================
	// Texture Paramaters
	//===============================================
	for(i = 0; i < TextureParameterNames.Length; ++i)
	{
		ParamName = TextureParameterNames[i];
		MI.GetTextureParameterValue(ParamName, Tex);
		NewMI.SetTextureParameterValue(ParamName, Tex);
	}


	//===============================================
	// Scalar Paramaters
	//===============================================
	for(i = 0; i < ScalarParameterNames.Length; ++i)
	{
		ParamName = ScalarParameterNames[i];
		MI.GetScalarParameterValue(ParamName, F);
		NewMI.SetScalarParameterValue(ParamName, F);
	}


	//===============================================
	// Vector Paramaters
	//===============================================
	for(i = 0; i < default.ScalarParameterNames.Length; ++i)
	{
		ParamName = ScalarParameterNames[i];
		MI.GetVectorParameterValue(ParamName, LC);
		NewMI.SetVectorParameterValue(ParamName, LC);
	}
}

defaultproperties
{
   RedMask=(R=255.000000,G=0.000000,B=0.000000,A=1.000000)
   BlueMask=(R=0.000000,G=0.000000,B=255.000000,A=1.000000)
   GreenMask=(R=0.000000,G=255.000000,B=0.000000,A=1.000000)
}