//=========================================================================
private int FindPassOptIndex(int ipass, EchoPFXRenderGroup ierg, ECHOPFXOPTION iopt)
{
if (ipass == 0)
{
for (int loop = 0; loop < ierg.possibleOpts1.Count; loop++)
{
if (ierg.possibleOpts1[loop].type == iopt)
{
return(loop);
}
}
}
else
{
for (int loop = 0; loop < ierg.possibleOpts2.Count; loop++)
{
if (ierg.possibleOpts2[loop].type == iopt)
{
return(loop);
}
}
}
return(-1);
}
//=========================================================================
public void RemoveOptionOfType(ECHOPFXOPTION iopt, int ipass)
{
for (int loop = 0; loop < epeList.Count; loop++)
{
epeList[loop].RemoveOptionOfType(iopt, ipass);
}
}
//=========================================================================
public static int HasCustomOptions(ECHOPFXOPTION ipo)
{
int rc = 0;
switch (ipo)
{
case ECHOPFXOPTION.OVERLAY_NORMAL:
case ECHOPFXOPTION.OVERLAY_SCREEN:
case ECHOPFXOPTION.OVERLAY_ADD:
case ECHOPFXOPTION.OVERLAY_SUBTRACT:
case ECHOPFXOPTION.OVERLAY_MULTIPLY:
case ECHOPFXOPTION.OVERLAY_OVERLAY:
rc = 1;
break;
case ECHOPFXOPTION.CUSTOM_FRAG_1:
case ECHOPFXOPTION.CUSTOM_FRAG_2:
case ECHOPFXOPTION.CUSTOM_FRAG_3:
case ECHOPFXOPTION.CUSTOM_FRAG_4:
rc = 2;
break;
case ECHOPFXOPTION.SCANLINES:
rc = 3;
break;
}
return(rc);
}
//=========================================================================
public PossibleOpts(ECHOPFXOPTION iopt, int iorder)
{
scanlines = ECHOPFXSCANLINES.HORIZONTAL;
order = iorder;
type = iopt;
useUniqueTC = false;
}
//=========================================================================
private bool IsOptUsed(List <EchoPFXOption> iepolist, ECHOPFXOPTION iopt)
{
for (int loop = 0; loop < iepolist.Count; loop++)
{
if (iepolist[loop].optType == iopt)
{
return(true);
}
}
return(false);
}
//=========================================================================
public bool OptionTimingSet(ECHOPFXOPTION ipo, int ipass, float istartDelay, float iattackTime, float isustainTime, float ireleaseTime)
{
EchoPFXOption epo;
bool rc = false;
epo = _passDict[ipass][ipo];
if (epo != null)
{
epo.DefaultTimingSet(istartDelay, iattackTime, isustainTime, ireleaseTime);
rc = true;
}
return(rc);
}
//=========================================================================
public void RemoveOptionOfType(ECHOPFXOPTION iopt, int ipass)
{
int loop;
passOpt[0] = passOpt1;
passOpt[1] = passOpt2;
for (loop = passOpt[ipass].Count - 1; loop >= 0; loop--)
{
if (passOpt[ipass][loop].optType == iopt)
{
passOpt[ipass].Remove(passOpt[ipass][loop]);
}
}
}
//============================================================
private static EchoPFXOption LoadOption(XmlNode inode)
{
ECHOPFXOPTION opt = ( ECHOPFXOPTION )NodeParseEnum(inode, "optType", typeof(ECHOPFXOPTION), (int)ECHOPFXOPTION.GREYSCALE);
EchoPFXOption epo = new EchoPFXOption(opt);
epo.passOrder = NodeParseInt(inode, "passOrder");
epo.startDelay = NodeParseFloat(inode, "startDelay");
epo.attackTime = NodeParseFloat(inode, "attackTime");
epo.sustainTime = NodeParseFloat(inode, "sustainTime");
epo.releaseTime = NodeParseFloat(inode, "releaseTime");
epo.fadeMin = NodeParseFloat(inode, "fadeMin");
epo.fadeMax = NodeParseFloat(inode, "fadeMax");
epo.fadeCur = NodeParseFloat(inode, "fadeCur");
epo.rgba = (Color)NodeParseVector4(inode, "rgba");
epo.rgbaMultiply = NodeParseFloat(inode, "rgbaMultiply");
epo.distAmountH = NodeParseFloat(inode, "distAmountH");
epo.distSpeedH = NodeParseFloat(inode, "distSpeedH");
epo.distStrengthH = NodeParseFloat(inode, "distStrengthH");
epo.distAmountV = NodeParseFloat(inode, "distAmountV");
epo.distSpeedV = NodeParseFloat(inode, "distSpeedV");
epo.distStrengthV = NodeParseFloat(inode, "distStrengthV");
epo.linesAmountDivideH = NodeParseBool(inode, "linesAmountDivideH");
epo.linesAmountH = NodeParseInt(inode, "linesAmountH");
epo.linesScrollH = NodeParseFloat(inode, "LinesScrollH");
epo.linesAmountDivideV = NodeParseBool(inode, "linesAmountDivideV");
epo.linesAmountV = NodeParseInt(inode, "linesAmountV");
epo.linesScrollV = NodeParseFloat(inode, "LinesScrollV");
epo.shockDistance = NodeParseFloat(inode, "shockDistance");
epo.shockSize = NodeParseFloat(inode, "shockSize");
epo.shockCenterX = NodeParseFloat(inode, "shockCenterX");
epo.shockCenterY = NodeParseFloat(inode, "shockCenterY");
epo.tex = NodeParseTex2D(inode, "tex");
epo.texBlend = ( ECHOPFXBLEND )NodeParseEnum(inode, "texBlend", typeof(ECHOPFXBLEND), (int)ECHOPFXBLEND.NORMAL);
epo.customArgs = NodeParseVector4(inode, "customArgs");
epo.overlayST = NodeParseVector4(inode, "overlayST");
epo.overlayST_Scroll = NodeParseVector4(inode, "overlayST_Scroll");
return(epo);
}
//=========================================================================
public static string ParseCustomCode(ECHOPFXOPTION ipo, string icode)
{
int num = (int)ipo - (int)ECHOPFXOPTION.CUSTOM_FRAG_1 + 1;
if (icode == null || icode == "")
{
return("//NOCODE");
}
icode = icode.Replace("_RGB", "_ioRGB");
icode = icode.Replace("_Texture", "_echoCustomF" + num.ToString() + "Tex");
icode = icode.Replace("_Texture_ST", "_echoCustomF" + num.ToString() + "Tex_ST");
icode = icode.Replace("_Fade", "_echoCustomF" + num.ToString() + "Fade");
icode = icode.Replace("_Args", "_echoCustomF" + num.ToString() + "Args");
icode = icode.Replace("_Color", "_echoCustomF" + num.ToString() + "Color");
icode = icode.Replace("_TC", "ECHODEF_CUSTOM" + num.ToString() + "_TC");
return(icode);
}
//=========================================================================
public EchoPFXOption OptionGet(ECHOPFXOPTION ipo, int ipass)
{
return(_passDict[ipass][ipo]);
}
//=========================================================================
public PossibleOpts(ECHOPFXOPTION iopt)
{
scanlines = ECHOPFXSCANLINES.HORIZONTAL;
order = 99 + (int)iopt;
type = iopt;
}
//=========================================================================
public void EffectPassMake(int ipassid)
{
List <EchoPFXOption>[] passOpt = new List <EchoPFXOption> [2];
List <PossibleOpts>[] possibleOpts = new List <PossibleOpts> [2];
ECHOPFXOPTION[] optLookup;
EchoPFXOption epo;
int loop;
string[] popupNames;
int count;
int index;
EchoPFXEffect epe;
if (_erg == null)
{
return;
}
epe = _erg.epeList[_epeIndex];
passOpt[0] = epe.passOpt1;
passOpt[1] = epe.passOpt2;
possibleOpts[0] = _erg.possibleOpts1;
possibleOpts[1] = _erg.possibleOpts2;
count = 0;
for (loop = 0; loop < possibleOpts[ipassid].Count; loop++)
{
if (IsOptUsed(passOpt[ipassid], possibleOpts[ipassid][loop].type) == false)
{
count++;
}
}
popupNames = new string[count + 1];
popupNames[0] = "Add Effect Option";
optLookup = new ECHOPFXOPTION[count + 1];
count = 1;
for (loop = 0; loop < possibleOpts[ipassid].Count; loop++)
{
if (IsOptUsed(passOpt[ipassid], possibleOpts[ipassid][loop].type) == false)
{
popupNames[count] = optNames[(int)possibleOpts[ipassid][loop].type];
optLookup[count] = possibleOpts[ipassid][loop].type;
count++;
}
}
if (count > 1)
{
GUILayout.BeginHorizontal();
index = EditorGUILayout.Popup(0, popupNames);
if (index > 0)
{
passOpt[ipassid].Add(new EchoPFXOption(optLookup[index]));
_erg.ValidateOptions();
}
GUILayout.EndHorizontal();
}
epe.passOpt[0] = epe.passOpt1;
epe.passOpt[1] = epe.passOpt2;
for (loop = 0; loop < epe.passOpt[ipassid].Count; loop++)
{
epo = epe.passOpt[ipassid][loop];
if (epo == null)
{
continue;
}
switch (epo.optType)
{
case ECHOPFXOPTION.GREYSCALE:
PostFxOptionGUI(passOpt[ipassid], loop, "Greyscale:");
break;
case ECHOPFXOPTION.INVERSE:
PostFxOptionGUI(passOpt[ipassid], loop, "Inverse:");
break;
case ECHOPFXOPTION.COLOR:
if (PostFxOptionGUI(passOpt[ipassid], loop, "Color:"))
{
PostFxColorGUI(epo);
}
break;
case ECHOPFXOPTION.ADD:
if (PostFxOptionGUI(passOpt[ipassid], loop, "Add:"))
{
PostFxColorGUI(epo);
}
break;
case ECHOPFXOPTION.MULTIPLY:
if (PostFxOptionGUI(passOpt[ipassid], loop, "Multiply:"))
{
PostFxColorGUI(epo);
}
break;
case ECHOPFXOPTION.NOISE:
if (PostFxOptionGUI(passOpt[ipassid], loop, "Noise:"))
{
PostFxTextureGUI(epo);
}
break;
case ECHOPFXOPTION.DISTORTION:
if (PostFxOptionGUI(passOpt[ipassid], loop, "Distortion:"))
{
PostFxDistortionGUI(epo);
}
break;
case ECHOPFXOPTION.SHOCKWAVE:
if (PostFxOptionGUI(passOpt[ipassid], loop, "Shockwave:"))
{
PostFxShockwaveGUI(epo);
}
break;
case ECHOPFXOPTION.SCANLINES:
if (PostFxOptionGUI(passOpt[ipassid], loop, "Scanlines:"))
{
PossibleOpts po;
for (int i = 0; i < possibleOpts[ipassid].Count; i++)
{
po = possibleOpts[ipassid][i];
if (po.type == epo.optType)
{
PostFxScanLinesGUI(epo, po);
break;
}
}
}
break;
case ECHOPFXOPTION.LUMRAMP:
if (PostFxOptionGUI(passOpt[ipassid], loop, "Lum Ramp:"))
{
PostFxTextureGUI(epo);
}
break;
case ECHOPFXOPTION.COLOR_CORRECT:
if (PostFxOptionGUI(passOpt[ipassid], loop, "Color Correct:"))
{
PostFxTextureGUI(epo);
}
break;
case ECHOPFXOPTION.OVERLAY_NORMAL:
if (PostFxOptionGUI(passOpt[ipassid], loop, "Texture:"))
{
PostFxOverlayGUI(epo, ipassid);
}
break;
case ECHOPFXOPTION.OVERLAY_SCREEN:
if (PostFxOptionGUI(passOpt[ipassid], loop, "Texture Screen:"))
{
PostFxOverlayGUI(epo, ipassid);
}
break;
case ECHOPFXOPTION.OVERLAY_ADD:
if (PostFxOptionGUI(passOpt[ipassid], loop, "Texture Add:"))
{
PostFxOverlayGUI(epo, ipassid);
}
break;
case ECHOPFXOPTION.OVERLAY_SUBTRACT:
if (PostFxOptionGUI(passOpt[ipassid], loop, "Texture Subtract:"))
{
PostFxOverlayGUI(epo, ipassid);
}
break;
case ECHOPFXOPTION.OVERLAY_MULTIPLY:
if (PostFxOptionGUI(passOpt[ipassid], loop, "Texture Multiply:"))
{
PostFxOverlayGUI(epo, ipassid);
}
break;
case ECHOPFXOPTION.OVERLAY_OVERLAY:
if (PostFxOptionGUI(passOpt[ipassid], loop, "Texture Overlay:"))
{
PostFxOverlayGUI(epo, ipassid);
}
break;
case ECHOPFXOPTION.CUSTOM_FRAG_1:
if (PostFxOptionGUI(passOpt[ipassid], loop, "Custom Frag 1:"))
{
PostFxCustomGUI(epo, ipassid);
}
break;
case ECHOPFXOPTION.CUSTOM_FRAG_2:
if (PostFxOptionGUI(passOpt[ipassid], loop, "Custom Frag 2:"))
{
PostFxCustomGUI(epo, ipassid);
}
break;
case ECHOPFXOPTION.CUSTOM_FRAG_3:
if (PostFxOptionGUI(passOpt[ipassid], loop, "Custom Frag 3:"))
{
PostFxCustomGUI(epo, ipassid);
}
break;
case ECHOPFXOPTION.CUSTOM_FRAG_4:
if (PostFxOptionGUI(passOpt[ipassid], loop, "Custom Frag 4:"))
{
PostFxCustomGUI(epo, ipassid);
}
break;
}
}
}
//=========================================================================
public bool OptionTimingSet(ECHOPFXOPTION ipo, int ipass, float istartDelay, float iattackTime, float isustainTime, float ireleaseTime)
{
return(epe.OptionTimingSet(ipo, ipass, istartDelay, iattackTime, isustainTime, ireleaseTime));
}
//=========================================================================
public EchoPFXOption(ECHOPFXOPTION iopt)
{
optType = iopt;
ResetDefaults();
}