//=========================================================================
public EchoPFX(string iergname, string ifxname)
{
int loop;
erg = null;
epe = null;
if (iergname != null && ifxname != null)
{
if (ergList != null)
{
for (loop = 0; loop < ergList.Count; loop++)
{
if (ergList[loop].name == iergname)
{
erg = ergList[loop];
break;
}
}
for (loop = 0; loop < erg.epeList.Count; loop++)
{
if (erg.epeList[loop].name == ifxname)
{
epe = erg.epeList[loop];
break;
}
}
// look for special case shockwave option
_passOpt[0] = epe.passOpt1;
_passOpt[1] = epe.passOpt2;
}
}
}
//=========================================================================
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);
}
//=========================================================================
private void SetNewRenderGroup(EchoPFXRenderGroup ierg, bool iadd)
{
if (_erg != ierg)
{
_customOpt = null;
}
else
{
return;
}
_erg = ierg;
if (iadd)
{
float highnum = -2;
epfxm.ergList.Add(_erg);
for (int loop = 0; loop < epfxm.ergList.Count; loop++)
{
if (epfxm.ergList[loop] != ierg)
{
if (epfxm.ergList[loop].cameraDepthEnd > highnum)
{
highnum = epfxm.ergList[loop].cameraDepthEnd;
}
}
}
highnum++;
_erg.cameraDepthStart = highnum;
_erg.cameraDepthEnd = highnum + 1;
}
_ergIndex = epfxm.ergList.IndexOf(_erg);
_epeIndex = 0;
}
//=========================================================================
void OnEnable()
{
EchoPFXEffect epe;
LoadPrefs();
_customOpt = null;
epfxm = (EchoPFXManager)target;
serializedObject.Update();
// postFX.Update();
if (epfxm.ergList.Count < 1)
{
SetNewRenderGroup(new EchoPFXRenderGroup(GetGroupID()), true);
}
if (_ergIndex < 0 || _ergIndex >= epfxm.ergList.Count)
{
_ergIndex = 0;
}
_erg = epfxm.ergList[_ergIndex];
if (_epeIndex < 0 || _epeIndex >= _erg.epeList.Count)
{
if (_erg.epeList.Count < 1)
{
epe = new EchoPFXEffect();
epe.name = "New Effect";
_erg.epeList.Add(epe);
_epeIndex = _erg.epeList.IndexOf(epe);
}
}
EditorApplication.playmodeStateChanged = AutoCompileShaders;
//epfxm.UpdateAllRenderGroups();
}
//=========================================================================
public int ValidateOptions(EchoPFXRenderGroup ierg)
{
int total = 0;
int loop;
int pass;
_erg = ierg;
_passDict = new Dictionary <ECHOPFXOPTION, EchoPFXOption> [2];
_passDict[0] = _pass1Dict;
_passDict[1] = _pass2Dict;
passOpt[0] = passOpt1;
passOpt[1] = passOpt2;
optionsOff = 0;
optionsTotal = passOpt1.Count + passOpt2.Count;
for (pass = 0; pass < 2; pass++)
{
for (loop = 0; loop < passOpt[pass].Count; loop++)
{
passOpt[pass][loop].passOrder = FindPassOptIndex(pass, _erg, passOpt[pass][loop].optType);
}
passOpt[pass].Sort(delegate(EchoPFXOption e1, EchoPFXOption e2)
{
return(e1.passOrder.CompareTo(e2.passOrder));
});
}
_passDict[0].Clear();
_passDict[1].Clear();
for (pass = 0; pass < 2; pass++)
{
for (loop = 0; loop < passOpt[pass].Count; loop++)
{
_passDict[pass].Add(passOpt[pass][loop].optType, passOpt[pass][loop]);
}
}
if (passActive == null || passActive.Length < 1)
{
passActive = new bool[2];
}
total = 0;
if (passOpt[0].Count > 0)
{
passActive[0] = true;
total++;
}
if (passOpt[1].Count > 0)
{
passActive[1] = true;
total++;
}
if (total == 2)
{
_pass_low = 0;
_pass_high = 2;
}
else
{
if (passOpt[0].Count > 0)
{
_pass_low = 0;
_pass_high = 1;
}
else
{
_pass_low = 1;
_pass_high = 2;
}
}
return(total);
}
//=========================================================================
public void MyRenderGroupsGUI()
{
int loop;
int delIndex = -1;
EchoPFXRenderGroup erg;
Color old_color = GUI.color;
EditorGUILayout.Space();
if (GUILayout.Button("Add Render Group"))
{
SetNewRenderGroup(new EchoPFXRenderGroup(GetGroupID()), true);
epfxm.SortRenderGroups();
}
EditorGUILayout.Space();
if (epfxm.ergList.Count < 1)
{
EditorGUILayout.Space();
EditorGUILayout.LabelField("No Render Groups !");
EditorGUILayout.Space();
return;
}
for (loop = 0; loop < epfxm.ergList.Count; loop++)
{
erg = epfxm.ergList[loop];
if (erg == null)
{
continue;
}
GUILayout.BeginHorizontal();
if (loop == _ergIndex)
{
GUI.color = new Color(0.5f, 0.7f, 2.0f, 1.0f);
}
if (GUILayout.Button(erg.name))
{
EditorGUIUtility.systemCopyBuffer = erg.name;
SetNewRenderGroup(erg, false);
_curMode = 0;
}
GUI.color = old_color;
if (GUILayout.Button("-", GUILayout.Width(32)))
{
_customOpt = null;
delIndex = loop;
}
GUILayout.EndHorizontal();
}
if (delIndex >= 0)
{
if (epfxm.ergList.Count > 0)
{
epfxm.ergList.RemoveAt(delIndex);
_ergIndex--;
if (_ergIndex < 0)
{
_ergIndex = 0;
if (epfxm.ergList.Count < 1)
{
_erg = null;
}
}
}
else
{
_erg = null;
_ergIndex = 0;
}
}
}
//============================================================
private static EchoPFXRenderGroup LoadRenderGroup(XmlNode inode)
{
EchoPFXRenderGroup erg = new EchoPFXRenderGroup(_curID++);
XmlNode node;
XmlNode childNode;
int loop;
ECHOPFXOPTION fxo;
PossibleOpts po;
node = inode.FirstChild;
erg.name = inode["name"].InnerText;
erg.id = NodeParseInt(inode, "id");
erg.passCount = NodeParseInt(inode, "passCount");
erg.active = NodeParseBool(inode, "active");
erg.cameraDepthStart = NodeParseFloat(inode, "cameraDepthStart");
erg.cameraDepthEnd = NodeParseFloat(inode, "cameraDepthEnd");
erg.meshCellWidth = NodeParseInt(inode, "meshCellWidth");
erg.meshCellHeight = NodeParseInt(inode, "meshCellHeight");
erg.rtAdjustSize = (ECHORTADJUST)NodeParseEnum(inode, "rtAdjustSize", typeof(ECHORTADJUST), (int)ECHORTADJUST.DEVICE_SIZE);
erg.rtAdjustWidth = NodeParseInt(inode, "rtAdjustWidth");
erg.rtAdjustHeight = NodeParseInt(inode, "rtAdjustHeight");
erg.rtFilterMode = new FilterMode[2];
erg.rtFilterMode[0] = ( FilterMode )NodeParseEnum(inode, "rtFilterMode1", typeof(FilterMode), (int)FilterMode.Point);
erg.rtFilterMode[1] = ( FilterMode )NodeParseEnum(inode, "rtFilterMode2", typeof(FilterMode), (int)FilterMode.Point);
erg.rtBlendMode = new ECHOPFXBLEND[2];
erg.rtBlendMode[0] = ( ECHOPFXBLEND )NodeParseEnum(inode, "rtBlendMode1", typeof(ECHOPFXBLEND), (int)ECHOPFXBLEND.NORMAL);
erg.rtBlendMode[1] = ( ECHOPFXBLEND )NodeParseEnum(inode, "rtBlendMode2", typeof(ECHOPFXBLEND), (int)ECHOPFXBLEND.NORMAL);
node = inode["PossibleOpts1"];
erg.possibleOpts1.Clear();
for (loop = 0; loop < node.ChildNodes.Count; loop++)
{
childNode = node.ChildNodes[loop];
fxo = ( ECHOPFXOPTION )NodeParseEnum(childNode["type"], typeof(ECHOPFXOPTION), (int)ECHOPFXOPTION.COUNT);
if (fxo != ECHOPFXOPTION.COUNT)
{
po = new PossibleOpts(fxo, loop);
po.customCode = NodeParseString(childNode["code"]);
erg.possibleOpts1.Add(po);
}
}
node = inode["PossibleOpts2"];
erg.possibleOpts2.Clear();
for (loop = 0; loop < node.ChildNodes.Count; loop++)
{
childNode = node.ChildNodes[loop];
fxo = ( ECHOPFXOPTION )NodeParseEnum(childNode["type"], typeof(ECHOPFXOPTION), (int)ECHOPFXOPTION.COUNT);
if (fxo != ECHOPFXOPTION.COUNT)
{
po = new PossibleOpts(fxo, loop);
po.customCode = NodeParseString(node.ChildNodes[loop]["code"]);
erg.possibleOpts2.Add(po);
}
}
node = inode["Effects"];
erg.epeList.Clear();
for (loop = 0; loop < node.ChildNodes.Count; loop++)
{
erg.epeList.Add(LoadEffect(node.ChildNodes[loop]));
}
return(erg);
}
//============================================================
public static void SaveRenderGroup(EchoPFXRenderGroup ierg, XmlElement iparent)
{
XmlElement eleParent;
XmlElement ele;
XmlElement eleOpts;
XmlElement opar;
PossibleOpts po;
int loop;
eleParent = xfile.CreateElement("RenderGroup");
iparent.AppendChild(eleParent);
ele = xfile.CreateElement("name");
ele.InnerText = ierg.name;
eleParent.AppendChild(ele);
ele = xfile.CreateElement("id");
ele.InnerText = ierg.id.ToString();
eleParent.AppendChild(ele);
ele = xfile.CreateElement("passCount");
ele.InnerText = ierg.passCount.ToString();
eleParent.AppendChild(ele);
ele = xfile.CreateElement("active");
ele.InnerText = ierg.active.ToString();
eleParent.AppendChild(ele);
ele = xfile.CreateElement("cameraDepthStart");
ele.InnerText = ierg.cameraDepthStart.ToString();
eleParent.AppendChild(ele);
ele = xfile.CreateElement("cameraDepthEnd");
ele.InnerText = ierg.cameraDepthEnd.ToString();
eleParent.AppendChild(ele);
ele = xfile.CreateElement("meshCellWidth");
ele.InnerText = ierg.meshCellWidth.ToString();
eleParent.AppendChild(ele);
ele = xfile.CreateElement("meshCellHeight");
ele.InnerText = ierg.meshCellHeight.ToString();
eleParent.AppendChild(ele);
ele = xfile.CreateElement("rtAdjustSize");
ele.InnerText = ierg.rtAdjustSize.ToString();
eleParent.AppendChild(ele);
ele = xfile.CreateElement("rtAdjustWidth");
ele.InnerText = ierg.rtAdjustWidth.ToString();
eleParent.AppendChild(ele);
ele = xfile.CreateElement("rtAdjustHeight");
ele.InnerText = ierg.rtAdjustHeight.ToString();
eleParent.AppendChild(ele);
ele = xfile.CreateElement("rtFilterMode1");
ele.InnerText = ierg.rtFilterMode[0].ToString();
eleParent.AppendChild(ele);
ele = xfile.CreateElement("rtFilterMode2");
ele.InnerText = ierg.rtFilterMode[1].ToString();
eleParent.AppendChild(ele);
ele = xfile.CreateElement("rtBlendMode1");
ele.InnerText = ierg.rtBlendMode[0].ToString();
eleParent.AppendChild(ele);
ele = xfile.CreateElement("rtBlendMode2");
ele.InnerText = ierg.rtBlendMode[1].ToString();
eleParent.AppendChild(ele);
// possible options pass 1
eleOpts = xfile.CreateElement("PossibleOpts1");
eleParent.AppendChild(eleOpts);
for (loop = 0; loop < ierg.possibleOpts1.Count; loop++)
{
po = ierg.possibleOpts1[loop];
// parent
opar = xfile.CreateElement("Option");
eleOpts.AppendChild(opar);
ele = xfile.CreateElement("type");
ele.InnerText = po.type.ToString();
opar.AppendChild(ele);
ele = xfile.CreateElement("code");
ele.InnerText = po.customCode;
opar.AppendChild(ele);
}
// possible options pass 2
eleOpts = xfile.CreateElement("PossibleOpts2");
eleParent.AppendChild(eleOpts);
for (loop = 0; loop < ierg.possibleOpts2.Count; loop++)
{
po = ierg.possibleOpts2[loop];
// parent
opar = xfile.CreateElement("Option");
eleOpts.AppendChild(opar);
ele = xfile.CreateElement("type");
ele.InnerText = po.type.ToString();
opar.AppendChild(ele);
ele = xfile.CreateElement("code");
ele.InnerText = po.customCode.ToString();
opar.AppendChild(ele);
}
// save effects
eleOpts = xfile.CreateElement("Effects");
eleParent.AppendChild(eleOpts);
for (loop = 0; loop < ierg.epeList.Count; loop++)
{
SaveEffect(ierg.epeList[loop], eleOpts);
}
}
//=========================================================================
public static void WriteFragOption(PossibleOpts ipo, EchoPFXRenderGroup ierg, int ipass)
{
switch (ipo.type)
{
case ECHOPFXOPTION.GREYSCALE:
_final += _greyscale;
break;
case ECHOPFXOPTION.INVERSE:
_final += _inverse;
break;
case ECHOPFXOPTION.COLOR:
_final += _color;
break;
case ECHOPFXOPTION.ADD:
_final += _add;
break;
case ECHOPFXOPTION.MULTIPLY:
_final += _multiply;
break;
case ECHOPFXOPTION.NOISE:
_final += _noise;
break;
case ECHOPFXOPTION.DISTORTION:
break;
case ECHOPFXOPTION.SHOCKWAVE:
break;
case ECHOPFXOPTION.SCANLINES:
if (ipo.scanlines == ECHOPFXSCANLINES.HORIZONTAL || ipo.scanlines == ECHOPFXSCANLINES.BOTH)
{
_final += _scanlineh;
}
_final += "\n";
if (ipo.scanlines == ECHOPFXSCANLINES.VERTICAL || ipo.scanlines == ECHOPFXSCANLINES.BOTH)
{
_final += _scanlinev;
}
break;
case ECHOPFXOPTION.LUMRAMP:
_final += _ramp;
break;
case ECHOPFXOPTION.COLOR_CORRECT:
_final += _color_correct;
break;
case ECHOPFXOPTION.OVERLAY_NORMAL:
_final += _overlay_lerp;
break;
case ECHOPFXOPTION.OVERLAY_SCREEN:
_final += _overlay_screen;
break;
case ECHOPFXOPTION.OVERLAY_ADD:
_final += _overlay_add;
break;
case ECHOPFXOPTION.OVERLAY_SUBTRACT:
_final += _overlay_subtract;
break;
case ECHOPFXOPTION.OVERLAY_MULTIPLY:
_final += _overlay_multiply;
break;
case ECHOPFXOPTION.OVERLAY_OVERLAY:
_final += _overlay_overlay;
break;
case ECHOPFXOPTION.CUSTOM_FRAG_1:
_final += "#ifdef ECHO_PFX_CUSTOM_FRAG_1_ON\n";
_final += ParseCustomCode(ipo.type, ipo.customCode) + "\n";
_final += "#endif\n";
break;
case ECHOPFXOPTION.CUSTOM_FRAG_2:
_final += "#ifdef ECHO_PFX_CUSTOM_FRAG_2_ON\n";
_final += ipo.customCode + "\n";
_final += "#endif\n";
break;
case ECHOPFXOPTION.CUSTOM_FRAG_3:
_final += "#ifdef ECHO_PFX_CUSTOM_FRAG_3_ON\n";
_final += ipo.customCode + "\n";
_final += "#endif\n";
break;
case ECHOPFXOPTION.CUSTOM_FRAG_4:
_final += "#ifdef ECHO_PFX_CUSTOM_FRAG_4_ON\n";
_final += ipo.customCode + "\n";
_final += "#endif\n";
break;
}
_final += "\n";
}
//=========================================================================
public static void BuildRenderGroupShaders(EchoPFXRenderGroup ierg)
{
int loop;
int pass;
int index;
string line;
List <PossibleOpts>[] po = new List <PossibleOpts> [2];
string groupName;
string passName;
po[0] = ierg.possibleOpts1;
po[1] = ierg.possibleOpts2;
groupName = "group" + ierg.id + "_";
for (pass = 0; pass < 2; pass++)
{
passName = "pass" + (pass + 1);
_final = "";
for (index = 0; index < _template.Length; index++)
{
line = _template[index].Trim();
switch (line)
{
case "ECHO_SHADER_NAME:":
_final += "Shader \"echoLogin/PFX/echologin_postfx_" + groupName + passName + "\"" + "\n";
break;
case "ECHO_BLEND_MODE:":
_final += rtBlendModes[(int)ierg.rtBlendMode[pass]] + "\n";
break;
case "ECHO_KEYWORDS:":
for (loop = 0; loop < po[pass].Count; loop++)
{
WriteTCDefine(po[pass][loop]);
}
_final += "\n";
for (loop = 0; loop < po[pass].Count; loop++)
{
_final += "#pragma multi_compile ";
_final += EchoPFXRenderGroup._keywords[(int)po[pass][loop].type, 0] + " ";
_final += EchoPFXRenderGroup._keywords[(int)po[pass][loop].type, 1] + "\n";
}
break;
case "ECHO_FRAG_INSERT:":
for (loop = 0; loop < po[pass].Count; loop++)
{
WriteFragOption(po[pass][loop], ierg, pass);
}
break;
default:
_final += line + "\n";
break;
}
}
SaveTextFile("echoLogin-postfx-" + groupName + passName + ".shader", _final);
}
}
