public virtual void RenderNodeNoLights(Node3D node)
{
if (CamOverride != null)
{
foreach (Light3D l in Lights)
{
Light3D.Active = l;
node.Present(CamOverride);
}
}
else
{
foreach (Cam3D c in Cams)
{
GL.Disable(EnableCap.Blend);
// Console.WriteLine("Presenting:" + node.Name);
node.Present(c);
// foreach (var n in Nodes) { n.Present(c); }
}
}
foreach (Node3D snode in node.Sub)
{
// Console.WriteLine("Rendering Node:" + snode.Name);
RenderNodeNoLights(snode);
}
}
public static Node3D LoadNode(string path)
{
FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read);
BinaryReader r = new BinaryReader(fs);
Help.IOHelp.r = r;
int et = IOHelp.ReadInt();
switch (et)
{
case 1:
var new_ent = new Entity3D();
new_ent.Read();
fs.Close();
return(new_ent);
break;
case 2:
var new_node = new Node3D();
new_node.Read();
fs.Close();
return(new_node);
break;
}
fs.Close();
return(null);
}
public virtual void Clear()
{
Root = new Node3D();
Root.Name = "Root";
Lights.Clear();
Cams.Clear();
}
public void CheckAssets(Node3D node)
{
Recheck:
foreach (var scr in node.NodeScripts)
{
if (scr.Updated)
{
System.Console.WriteLine("Updated:" + scr.FullPath);
node.NodeScripts.Remove(scr);
Vivid.Scripting.NodeScript ns = Vivid.Scripting.NodeScriptCompiler.Compile(scr.FullPath);
ns.Node = node;
// scr.Transfer(ns);
node.NodeScripts.Add(ns);
goto Recheck;
}
}
foreach (var sub_n in node.Sub)
{
CheckAssets(sub_n);
}
}
public void LoadGraph(string file)
{
FileStream fs = new FileStream(file, FileMode.Open, FileAccess.Read);
BinaryReader r = new BinaryReader(fs);
Help.IOHelp.r = r;
int cc = r.ReadInt32();
for (int i = 0; i < cc; i++)
{
Cam3D nc = new Cam3D();
nc.Read();
Cams.Add(nc);
}
int lc = r.ReadInt32();
for (int i = 0; i < lc; i++)
{
Light3D nl = new Light3D();
nl.Read();
Lights.Add(nl);
}
//Entity3D re = new Entity3D();
Node3D new_e = null;
Root = ReadNode();
//re.Read();
fs.Close();
Root.SetMultiPass();
}
public Node3D ReadNode()
{
int node_t = Help.IOHelp.ReadInt();
Node3D nn = null;
if (node_t == 1)
{
Entity3D new_e = new Entity3D();
new_e.Read();
nn = new_e;
}
else if (node_t == 0)
{
Node3D new_n = new Node3D();
new_n.Read();
nn = new_n;
}
else
{
System.Environment.Exit(-3);
}
int sc = Help.IOHelp.ReadInt();
for (int i = 0; i < sc; i++)
{
var rn = ReadNode();
rn.Top = nn;
nn.Sub.Add(rn);
}
return(nn);
}
public Vivid.Pick.PickResult CamPick(int x, int y)
{
if (SceneUpdating == true)
{
return(null);
}
System.Console.WriteLine("Checking Scene: CacheSize:" + SceneCache.Length);
Pick.PickResult res = new Pick.PickResult();
Pick.Ray mr = Pick.Picker.CamRay(Cams[0], x, y);
float cd = 0;
bool firstHit = true;
float cu = 0, cv = 0;
Node3D cn = null;
int ms = System.Environment.TickCount;
for (int i = 0; i < SceneCache.Length; i += 3)
{
var r0 = SceneCache[i];
var r1 = SceneCache[i + 1];
var r2 = SceneCache[i + 2];
Vector3?pr = Pick.Picker.GetTimeAndUvCoord(mr.pos, mr.dir, r0, r1, r2);
if (pr == null)
{
}
else
{
Vector3 cr = (Vector3)pr;
if (cr.X < cd || firstHit)
{
firstHit = false;
cd = cr.X;
cn = SceneNodes[i];
cu = cr.Y;
cv = cr.Z;
}
}
}
ms = System.Environment.TickCount - ms;
System.Console.WriteLine("PickTime:" + ms + " Secs:" + (ms / 1000));
if (firstHit)
{
return(null);
}
res.Dist = cd;
res.Node = cn;
res.Pos = Pick.Picker.GetTrilinearCoordinateOfTheHit(cd, mr.pos, mr.dir);
res.Ray = mr;
res.UV = new Vector3(cu, cv, 0);
return(res);
}
public void DrawNodeScripts(Node3D node)
{
node.DrawScripts();
foreach (var s_node in node.Sub)
{
DrawNodeScripts(s_node);
}
}
public void UpdateNodeScripts(Node3D node)
{
node.UpdateScripts();
foreach (var s_node in node.Sub)
{
UpdateNodeScripts(s_node);
}
}
public virtual void Add(Node3D n)
{
Root.Add(n);
n.Top = Root;
SceneCached = false;
SceneChanged = true;
n.Graph = this;
}
public void BeginFrameNode(Node3D node)
{
node.StartFrame();
foreach (Node3D snode in node.Sub)
{
BeginFrameNode(snode);
}
}
public void Remove(Node3D node)
{
node.Top.Sub.Remove(node);
node.Top = null;
//RemoveNode(Root, node);
}
public void CopyNode(Node3D node)
{
node.CopyProps();
foreach (Node3D nn in node.Sub)
{
CopyNode(nn);
}
}
public void RestoreNode(Node3D node)
{
node.RestoreProps();
foreach (Node3D nn in node.Sub)
{
RestoreNode(nn);
}
}
public void InitUINodeScripts(Node3D node, Vivid.Resonance.UI ui)
{
node.InitUIScripts(ui);
foreach (var s_node in node.Sub)
{
InitUINodeScripts(s_node, ui);
}
}
public void RenderNodeSSRExtrasMap(Node3D node, Cam3D c)
{
var e3 = node as Entity3D;
e3.PresentSSRExtrasMap(c);
foreach (var node2 in node.Sub)
{
RenderNodeSSRExtrasMap(node2, c);
}
}
public virtual void RenderNode(Node3D node)
{
// Console.WriteLine("RenderNode:" + node.Name);
RenderThis(node);
foreach (Node3D snode in node.Sub)
{
// Console.WriteLine("Rendering Node:" + snode.Name);
RenderNode(snode);
}
}
public void RenderNodeNormalMap(Node3D node, Cam3D c)
{
var e3 = node as Entity3D;
e3.PresentNormalMap(c);
foreach (var snode in node.Sub)
{
RenderNodeNormalMap(snode, c);
}
}
public void InitNodeScripts(Node3D node)
{
node.InitScripts();
//foreach(var s_node in node.Sub)
//{
for (int nn = 0; nn < node.Sub.Count; nn++)
{
var s_node = node.Sub[nn];
InitNodeScripts(s_node);
}
}
public SceneGraph3D()
{
InitThreads();
Running = false;
Paused = false;
RenderingShadows = false;
Root = new Node3D()
{
Name = "Root"
};
CurScene = this;
}
public virtual void RenderNodeDepth(Node3D node, Cam3D c)
{
var e3 = node as Entity3D;
if (node.CastDepth)
{
node.PresentDepth(c);
}
foreach (Node3D snode in node.Sub)
{
RenderNodeDepth(snode, c);
}
}
public Node3D FindNode(Node3D s, string name)
{
if (s.Name == name)
{
return(s);
}
foreach (var sub_n in s.Sub)
{
var fn = FindNode(sub_n, name);
if (fn != null)
{
return(fn);
}
}
return(null);
}
private void NodeToList(Node3D node, bool meshes, List <Node3D> list)
{
if (meshes)
{
if (node is Entity3D)
{
list.Add(node);
}
}
else
{
list.Add(node);
}
foreach (Node3D n2 in node.Sub)
{
NodeToList(n2, meshes, list);
}
}
public virtual void RenderNodeByTags(List <string> tags, Node3D node)
{
bool rt = false;
foreach (string tag in tags)
{
if (node.RenderTags.Contains(tag))
{
rt = true;
RenderThis(node);
break;
}
}
if (rt)
{
foreach (Node3D n in node.Sub)
{
RenderNodeByTags(tags, n);
}
}
}
public void SaveNode(Node3D node)
{
if (node is Entity3D)
{
Help.IOHelp.WriteInt(1);
node.Write();
}
else if (node is Node3D)
{
Help.IOHelp.WriteInt(0);
node.Write();
}
else
{
System.Environment.Exit(-2);
}
Help.IOHelp.WriteInt(node.Sub.Count);
foreach (var sub in node.Sub)
{
SaveNode(sub);
}
}
public void SaveGraph(string file)
{
FileStream fs = new FileStream(file, FileMode.Create, FileAccess.Write);
BinaryWriter bw = new BinaryWriter(fs);
Help.IOHelp.w = bw;
bw.Write(Cams.Count);
foreach (Cam3D c in Cams)
{
c.Write();
}
bw.Write(Lights.Count);
foreach (Light3D c in Lights)
{
c.Write();
}
Node3D r = Root as Node3D;
SaveNode(r);
bw.Flush();
fs.Flush();
fs.Close();
}
public virtual void UpdateNode(Node3D node)
{
node.Update();
}
public static void AddToScene(Node3D node)
{
CurScene.Root.Add(node);
node.Top = CurScene.Root;
}
public void RemoveNode(Node3D s, Node3D r)
{
if (s == r)
{
}
}
private void RenderThis(Node3D node)
{
if (node.Name == "Terrain")
{
}
if (CamOverride != null)
{
foreach (Light3D l in Lights)
{
Light3D.Active = l;
node.Present(CamOverride);
}
}
else
{
foreach (Cam3D c in Cams)
{
if (node.AlwaysAlpha)
{
Entity3D ge = node as Entity3D;
if (ge.Renderer is Visuals.RMultiPass)
{
ge.Renderer = new Visuals.VRNoFx();
}
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
node.Present(c);
continue;
}
if (node.Lit)
{
bool second = true;
bool first = true;
foreach (Light3D l in Lights)
{
Light3D.Active = l;
if (first)
{
first = false;
GL.Disable(EnableCap.Blend);
}
else if (second)
{
second = false;
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactor.One, BlendingFactor.One);
}
node.Present(c);
// foreach (var n in Nodes) { n.Present(c); }
}
GL.Disable(EnableCap.Blend);
}
else
{
if (node.FaceCamera)
{
node.LookAt(c.LocalPos, new Vector3(0, 1, 0));
}
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactor.Src1Alpha, BlendingFactor.OneMinusSrcAlpha);
GL.DepthMask(false);
node.Present(c);
GL.DepthMask(true);
}
}
}
}
