public BocsSlotBase(BocsNodeBase n, string title, string name, BocsSlotType type)
{
Node = n;
SlotType = type;
SlotTitle = title;
SlotName = name;
InputSlot = null;
OutputSlots = new List <BocsSlotBase>();
}
public static string SaveGraph()
{
//Debug.Log("SaveGraph");
string s = string.Empty;
for (int i = 0; i < BocsCyclesNodeManager.Nodes.Count; i++)
{
BocsNodeBase n = BocsCyclesNodeManager.Nodes[i];
s += "node" + "|";
s += "t=" + n.GetType().Name + ",";
s += "x=" + (int)n.NodeRect.x + ",";
s += "y=" + (int)n.NodeRect.y + ",";
s += "c=" + n.State;
s += ":";
}
for (int i = 0; i < BocsCyclesNodeManager.Nodes.Count; i++)
{
BocsNodeBase n = BocsCyclesNodeManager.Nodes[i];
for (int j = 0; j < n.Slots.Count; j++)
{
if (n.Slots[j].HasValue())
{
s += "val" + "|";
s += "n=" + i + ",";
s += "s=" + n.Slots[j].SlotName + ",";
s += "v=" + n.Slots[j].GetString();
s += ":";
}
}
}
for (int i = 0; i < BocsCyclesNodeManager.Nodes.Count; i++)
{
BocsNodeBase n = BocsCyclesNodeManager.Nodes[i];
for (int j = 0; j < n.Slots.Count; j++)
{
for (int k = 0; k < n.Slots[j].OutputSlots.Count; k++)
{
int cn = FindNodeFromSlot(n.Slots[j].OutputSlots[k]);
int cs = FindSlotInNode(BocsCyclesNodeManager.Nodes[cn], n.Slots[j].OutputSlots[k]);
s += "connect" + "|";
s += "n1=" + i + ",";
s += "n2=" + cn + ",";
s += "s1=" + n.Slots[j].SlotName + ",";
s += "s2=" + BocsCyclesNodeManager.Nodes[cn].Slots[cs].SlotName + ",";
s += ":";
}
}
}
return(s);
}
public static int FindSlotInNode(BocsNodeBase nb, BocsSlotBase sb)
{
for (int i = 0; i < nb.Slots.Count; i++)
{
if (nb.Slots[i] == sb)
{
return(i);
}
}
return(-1);
}
public static BocsSlotBase FindOutputSlotFromString(BocsNodeBase bn, string s)
{
for (int i = 0; i < bn.Slots.Count; i++)
{
if (bn.Slots[i].SlotType != BocsSlotBase.BocsSlotType.Output)
{
continue;
}
if (bn.Slots[i].SlotName == s)
{
return(bn.Slots[i]);
}
}
return(null);
}
public static void DeleteNode(int i)
{
if (i == -1)
{
return;
}
if (i > Nodes.Count)
{
return;
}
SelectedNode = -1;
//Debug.Log("Delete:" + i);
BocsNodeBase bn = BocsCyclesNodeManager.Nodes[i];
foreach (BocsSlotBase s in bn.Slots)
{
s.RemoveConnection();
}
BocsCyclesNodeManager.Nodes.Remove(bn);
}
public BocsSlotInt(BocsNodeBase n, string description, string name, BocsSlotType type, int defaultValue = 0) : base(n, description, name, type)
{
Val = defaultValue;
}
public BocsSlotColor(BocsNodeBase n, string description, string name, BocsSlotType type, Color defaultValue = default(Color)) : base(n, description, name, type)
{
SlotColor = Color.yellow;
ColorVal = defaultValue;
}
public BocsSlotStringList(BocsNodeBase n, string description, string name, BocsSlotType type, int defaultValue) : base(n, description, name, type)
{
Selected = defaultValue;
}
public BocsSlotClosure(BocsNodeBase n, string description, string name, BocsSlotType type) : base(n, description, name, type)
{
//Color Known Types...
if (description == "Color")
{
SlotColor = Color.yellow;
}
if (description == "Surface")
{
SlotColor = Color.green;
}
if (description == "BSDF")
{
SlotColor = Color.green;
}
if (description == "Shader")
{
SlotColor = Color.green;
}
if (description == "Volume")
{
SlotColor = Color.green;
}
if (description == "Emission")
{
SlotColor = Color.green;
}
if (description == "BSSRDF")
{
SlotColor = Color.green;
}
if (description == "Background")
{
SlotColor = Color.green;
}
if (description == "AO")
{
SlotColor = Color.green;
}
if (description == "Holdout")
{
SlotColor = Color.green;
}
if (description == "Normal")
{
SlotColor = Color.blue;
}
if (description == "Tangent")
{
SlotColor = Color.blue;
}
if (description == "Vector")
{
SlotColor = Color.blue;
}
if (description == "Clearcoat Normal")
{
SlotColor = Color.blue;
}
if (description == "Generated")
{
SlotColor = Color.blue;
}
if (description == "UV")
{
SlotColor = Color.blue;
}
if (description == "Object")
{
SlotColor = Color.blue;
}
if (description == "Camera")
{
SlotColor = Color.blue;
}
if (description == "Window")
{
SlotColor = Color.blue;
}
if (description == "Reflection")
{
SlotColor = Color.blue;
}
}
public BocsSlotBool(BocsNodeBase n, string description, string name, BocsSlotType type, bool defaultValue = true) : base(n, description, name, type)
{
Val = defaultValue;
}
public BocsSlotVector3(BocsNodeBase n, string description, string name, BocsSlotType type, Vector3 defaultValue = default(Vector3)) : base(n, description, name, type)
{
SlotColor = Color.blue;
Vect3 = defaultValue;
}
public BocsSlotTexture(BocsNodeBase n, string description, string name, BocsSlotType type) : base(n, description, name, type)
{
SlotColor = Color.yellow;
}
public static void CreateNode(string type, float x, float y, int c)
{
BocsNodeBase nb = null;
//I'm sure there is a better way, maybe Activator or reflection..but meh for now
if (type == "BocsNodeOutput")
{
nb = new BocsNodeOutput();
}
if (type == "BocsNodeDiffuseBsdf")
{
nb = new BocsNodeDiffuseBsdf();
}
if (type == "BocsNodeMixShader")
{
nb = new BocsNodeMixShader();
}
if (type == "BocsNodeGlossyBsdf")
{
nb = new BocsNodeGlossyBsdf();
}
if (type == "BocsNodeTexture")
{
nb = new BocsNodeTexture();
}
if (type == "BocsNodeGlassBsdf")
{
nb = new BocsNodeGlassBsdf();
}
if (type == "BocsNodeEmission")
{
nb = new BocsNodeEmission();
}
if (type == "BocsNodeEnviromentTexture")
{
nb = new BocsNodeEnviromentTexture();
}
if (type == "BocsNodeSkyTexture")
{
nb = new BocsNodeSkyTexture();
}
if (type == "BocsNodeNoiseTexture")
{
nb = new BocsNodeNoiseTexture();
}
if (type == "BocsNodeCheckerTexture")
{
nb = new BocsNodeCheckerTexture();
}
if (type == "BocsNodeBrickTexture")
{
nb = new BocsNodeBrickTexture();
}
if (type == "BocsNodeGradientTexture")
{
nb = new BocsNodeGradientTexture();
}
if (type == "BocsNodeVoronoiTexture")
{
nb = new BocsNodeVoronoiTexture();
}
if (type == "BocsNodeMusgraveTexture")
{
nb = new BocsNodeMusgraveTexture();
}
if (type == "BocsNodeMagicTexture")
{
nb = new BocsNodeMagicTexture();
}
if (type == "BocsNodeWaveTexture")
{
nb = new BocsNodeWaveTexture();
}
if (type == "BocsNodeNormal")
{
nb = new BocsNodeNormal();
}
if (type == "BocsNodeBump")
{
nb = new BocsNodeBump();
}
if (type == "BocsNodeAnisotropicBsdf")
{
nb = new BocsNodeAnisotropicBsdf();
}
if (type == "BocsNodeTranslucentBsdf")
{
nb = new BocsNodeTranslucentBsdf();
}
if (type == "BocsNodeTransparentBsdf")
{
nb = new BocsNodeTransparentBsdf();
}
if (type == "BocsNodeVelvetBsdf")
{
nb = new BocsNodeVelvetBsdf();
}
if (type == "BocsNodeToonBsdf")
{
nb = new BocsNodeToonBsdf();
}
if (type == "BocsNodeRefractionBsdf")
{
nb = new BocsNodeRefractionBsdf();
}
if (type == "BocsNodeHairBsdf")
{
nb = new BocsNodeHairBsdf();
}
if (type == "BocsNodeAmbientOcclusion")
{
nb = new BocsNodeAmbientOcclusion();
}
if (type == "BocsNodeHoldout")
{
nb = new BocsNodeHoldout();
}
if (type == "BocsNodeAbsorptionVolume")
{
nb = new BocsNodeAbsorptionVolume();
}
if (type == "BocsNodeScatterVolume")
{
nb = new BocsNodeScatterVolume();
}
if (type == "BocsNodeSubsurfaceScattering")
{
nb = new BocsNodeSubsurfaceScattering();
}
if (type == "BocsNodeGeometry")
{
nb = new BocsNodeGeometry();
}
if (type == "BocsNodeTextureCoordinate")
{
nb = new BocsNodeTextureCoordinate();
}
if (type == "BocsNodeLightPath")
{
nb = new BocsNodeLightPath();
}
if (type == "BocsNodeLightFalloff")
{
nb = new BocsNodeLightFalloff();
}
if (type == "BocsNodeObjectInfo")
{
nb = new BocsNodeObjectInfo();
}
if (type == "BocsNodeParticleInfo")
{
nb = new BocsNodeParticleInfo();
}
if (type == "BocsNodeHairInfo")
{
nb = new BocsNodeHairInfo();
}
if (type == "BocsNodeValue")
{
nb = new BocsNodeValue();
}
if (type == "BocsNodeColor")
{
nb = new BocsNodeColor();
}
if (type == "BocsNodeAddShader")
{
nb = new BocsNodeAddShader();
}
if (type == "BocsNodeInvert")
{
nb = new BocsNodeInvert();
}
if (type == "BocsNodeMixRGB")
{
nb = new BocsNodeMixRGB();
}
if (type == "BocsNodeGamma")
{
nb = new BocsNodeGamma();
}
if (type == "BocsNodeBrightContrast")
{
nb = new BocsNodeBrightContrast();
}
if (type == "BocsNodeCombineRGB")
{
nb = new BocsNodeCombineRGB();
}
if (type == "BocsNodeSeparateRGB")
{
nb = new BocsNodeSeparateRGB();
}
if (type == "BocsNodeCombineHSV")
{
nb = new BocsNodeCombineHSV();
}
if (type == "BocsNodeSeparateHSV")
{
nb = new BocsNodeSeparateHSV();
}
if (type == "BocsNodeCombineXYZ")
{
nb = new BocsNodeCombineXYZ();
}
if (type == "BocsNodeSeparateXYZ")
{
nb = new BocsNodeSeparateXYZ();
}
if (type == "BocsNodeHueSaturation")
{
nb = new BocsNodeHueSaturation();
}
if (type == "BocsNodeWaveLength")
{
nb = new BocsNodeWaveLength();
}
if (type == "BocsNodeBlackbody")
{
nb = new BocsNodeBlackbody();
}
if (type == "BocsNodeAttribute")
{
nb = new BocsNodeAttribute();
}
if (type == "BocsNodeUVmap")
{
nb = new BocsNodeUVmap();
}
if (type == "BocsNodeCameraData")
{
nb = new BocsNodeCameraData();
}
if (type == "BocsNodeFresnel")
{
nb = new BocsNodeFresnel();
}
if (type == "BocsNodeLayerWeight")
{
nb = new BocsNodeLayerWeight();
}
if (type == "BocsNodeWireframe")
{
nb = new BocsNodeWireframe();
}
if (type == "BocsNodeNormalMap")
{
nb = new BocsNodeNormalMap();
}
if (type == "BocsNodeTangent")
{
nb = new BocsNodeTangent();
}
if (type == "BocsNodeMath")
{
nb = new BocsNodeMath();
}
if (type == "BocsNodeVectorMath")
{
nb = new BocsNodeVectorMath();
}
if (type == "BocsNodeVectorTransform")
{
nb = new BocsNodeVectorTransform();
}
if (type == "BocsNodeRGBtoBW")
{
nb = new BocsNodeRGBtoBW();
}
if (type == "BocsNodeBackground")
{
nb = new BocsNodeBackground();
}
if (type == "BocsNodeDisneyBsdf")
{
nb = new BocsNodeDisneyBsdf();
}
if (type == "BocsNodeMapping")
{
nb = new BocsNodeMapping();
}
if (nb != null)
{
Rect pos = new Rect(x, y, 0, 0);
nb.NodeRect = pos;
nb.State = c;
BocsCyclesNodeManager.Nodes.Add(nb);
}
}
public BocsSlotFloat(BocsNodeBase n, string description, string name, BocsSlotType type, float defaultValue = 1.0f) : base(n, description, name, type)
{
Val = defaultValue;
}
private static void _addShaderGraph(XmlTextWriter xml, BocsCyclesGraphBase graph, string name)
{
string saved = BocsCyclesNodeManager.SaveGraph();
for (int graphIndex = 0; graphIndex < graph.GetGraphCount(); graphIndex++)
{
BocsCyclesNodeManager.LoadGraph(graph.GetGraph(graphIndex));
if (name != string.Empty)
{
xml.WriteStartElement("shader");
xml.WriteAttributeString("name", name + graphIndex);
}
for (int nid = 0; nid < BocsCyclesNodeManager.Nodes.Count; nid++)
{
BocsNodeBase n = BocsCyclesNodeManager.Nodes[nid];
if (n.NodeName == "output")
{
continue; //shaders have one by default
}
xml.WriteStartElement(n.NodeName);
xml.WriteAttributeString("name", n.NodeName + nid);
for (int sid = 0; sid < n.Slots.Count; sid++)
{
BocsSlotBase slot = n.Slots[sid];
string val = slot.GetXML();
if (val != string.Empty)
{
xml.WriteAttributeString(slot.SlotName, val);
}
}
xml.WriteEndElement();
}
for (int nid = 0; nid < BocsCyclesNodeManager.Nodes.Count; nid++)
{
BocsNodeBase n = BocsCyclesNodeManager.Nodes[nid];
for (int sid = 0; sid < n.Slots.Count; sid++)
{
BocsSlotBase slot = n.Slots[sid];
foreach (BocsSlotBase c in slot.OutputSlots)
{
int toID = BocsCyclesNodeManager.FindNodeFromSlot(c);
BocsNodeBase toNode = BocsCyclesNodeManager.Nodes[toID];
string toConnect = "output";
if (toNode.NodeName != "output")
{
toConnect = toNode.NodeName + toID;
}
xml.WriteStartElement("connect");
xml.WriteAttributeString("from", n.NodeName + nid + " " + slot.SlotName);
xml.WriteAttributeString("to", toConnect + " " + c.SlotName);
xml.WriteEndElement();
}
}
}
if (name != string.Empty)
{
xml.WriteEndElement();
}
}
BocsCyclesNodeManager.LoadGraph(saved);
}
public BocsSlotGradient(BocsNodeBase n, string description, string name, BocsSlotType type) : base(n, description, name, type)
{
}
public static void LoadGraph(string g)
{
//Debug.Log("LoadGraph");
Reset();
if (g == null)
{
return;
}
string[] sn = g.Split(':');
foreach (string n in sn)
{
//Debug.Log(n);
string[] s = n.Split('|');
//foreach(string ts in s) Debug.Log(ts);
if (s.Length > 0)
{
if (s[0] == "node")
{
string[] p = s[1].Split(',');
//foreach(string ts in p) Debug.Log(ts);
int x = 0;
int y = 0;
int c = 0;
string t = string.Empty;
foreach (string ts in p)
{
string[] v = ts.Split('=');
if (v.Length > 1)
{
if (v[0] == "t")
{
t = v[1];
}
if (v[0] == "x")
{
x = int.Parse(v[1]);
}
if (v[0] == "y")
{
y = int.Parse(v[1]);
}
if (v[0] == "c")
{
c = int.Parse(v[1]);
}
}
}
CreateNode(t, x, y, c);
}
if (s[0] == "val")
{
string[] p = s[1].Split(',');
//foreach(string ts in p) Debug.Log(ts);
int ni = -1;
string ss = string.Empty;
string sv = string.Empty;
foreach (string ts in p)
{
string[] v = ts.Split('=');
if (v.Length > 1)
{
if (v[0] == "n")
{
ni = int.Parse(v[1]);
}
if (v[0] == "s")
{
ss = v[1];
}
if (v[0] == "v")
{
sv = v[1];
}
}
}
if (ni >= 0 && ni < BocsCyclesNodeManager.Nodes.Count)
{
BocsNodeBase nb = BocsCyclesNodeManager.Nodes[ni];
if (nb != null)
{
foreach (BocsSlotBase us in nb.Slots)
{
if (us.SlotName == ss)
{
us.SetString(sv);
}
}
}
}
}
if (s[0] == "connect")
{
string[] p = s[1].Split(',');
//foreach(string ts in p) Debug.Log(ts);
int n1 = -1;
int n2 = -1;
string s1 = string.Empty;
string s2 = string.Empty;
foreach (string ts in p)
{
string[] v = ts.Split('=');
if (v.Length > 1)
{
if (v[0] == "n1")
{
n1 = int.Parse(v[1]);
}
if (v[0] == "n2")
{
n2 = int.Parse(v[1]);
}
if (v[0] == "s1")
{
s1 = v[1];
}
if (v[0] == "s2")
{
s2 = v[1];
}
}
}
if (n1 != -1 && n2 != -1 && s1 != string.Empty && s2 != string.Empty && n1 < Nodes.Count && n2 < Nodes.Count)
{
BocsSlotBase f = FindOutputSlotFromString(BocsCyclesNodeManager.Nodes[n1], s1);
BocsSlotBase t = FindInputSlotFromString(BocsCyclesNodeManager.Nodes[n2], s2);
if (f != null && t != null)
{
f.AddConnection(t);
}
}
}
}
}
}
