Beispiel #1
0
        public void Write( )
        {
            Help.IOHelp.WriteInt(Scripts.Count);
            foreach (Script.ScriptLink s in Scripts)
            {
                Help.IOHelp.WriteString(s.Name);
                Help.IOHelp.WriteString(s.FilePath);
            }
            Help.IOHelp.WriteMatrix(LocalTurn);
            Help.IOHelp.WriteVec(LocalPos);
            Help.IOHelp.WriteVec(LocalScale);
            Help.IOHelp.WriteString(Name);
            Help.IOHelp.WriteBool(AlwaysAlpha);
            Help.IOHelp.WriteBool(On);
            Help.IOHelp.WriteInt(Sub.Count);

            int mc = Meshes.Count;

            Help.IOHelp.WriteInt(mc);
            foreach (Mesh3D msh in Meshes)
            {
                msh.Write( );
            }
            foreach (Node3D sn in Sub)
            {
                Entity3D e = sn as Entity3D;
                e.Write( );
            }
        }
Beispiel #2
0
        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( );
            }
            Entity3D r = Root as Entity3D;

            if (Root != null)
            {
                r.Write( );
            }

            fs.Flush( );
            fs.Close( );
        }
Beispiel #3
0
        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 FusionEngine.Lighting.Light3D();
                nl.Read( );
                Lights.Add(nl);
            }
            Entity3D re = new Entity3D();

            Root = re;
            re.Read( );
            fs.Close( );
        }
Beispiel #4
0
 private void DScale(float x, float y, float z, Entity3D node)
 {
     foreach (Mesh3D m in node.Meshes)
     {
         m.Scale(x, y, z);
     }
     foreach (Node3D snode in node.Sub)
     {
         DScale(x, y, z, snode as Entity3D);
     }
 }
Beispiel #5
0
        public void SetMat(Material3D mat)
        {
            foreach (Mesh3D m in Meshes)
            {
                m.Mat = mat;
            }
            foreach (Node3D n in Sub)
            {
                if (n is Entity3D || n is Terrain.Terrain3D)
                {
                    ;
                }

                {
                    Entity3D ge = n as Entity3D;
                    ge.SetMat(mat);
                }
            }
        }
Beispiel #6
0
 public void GetVerts(List <Vector3> verts, Entity3D node)
 {
     foreach (Mesh3D m in node.Meshes)
     {
         for (int i = 0; i < m.NumVertices; i++)
         {
             int     vid = i * 3;
             Vector3 nv  = new Vector3(m.Vertices[vid], m.Vertices[vid + 1], m.Vertices[vid + 2]);
             nv = Vector3.TransformPosition(nv, node.World);
             verts.Add(nv);
             // verts.Add(m.Vertices[vid]); verts.Add(m.Vertices[vid + 1]);
             // verts.Add(m.Vertices[vid + 2]);
         }
     }
     foreach (Node3D snode in node.Sub)
     {
         GetVerts(verts, snode as Entity3D);
     }
 }
Beispiel #7
0
 public void GetBounds(Entity3D node)
 {
     foreach (Mesh3D m in node.Meshes)
     {
         for (int i = 0; i < m.NumVertices; i++)
         {
             int vid = i * 3;
             if (m.Vertices [vid] < sw)
             {
                 sw = m.Vertices [vid];
             }
             if (m.Vertices [vid] > bw)
             {
                 bw = m.Vertices [vid];
             }
             if (m.Vertices [vid + 1] < sh)
             {
                 sh = m.Vertices [vid + 1];
             }
             if (m.Vertices [vid + 1] > bh)
             {
                 bh = m.Vertices [vid + 1];
             }
             if (m.Vertices [vid + 2] < sd)
             {
                 sd = m.Vertices [vid + 2];
             }
             if (m.Vertices [vid + 2] > bd)
             {
                 bd = m.Vertices [vid + 2];
             }
         }
     }
     foreach (Node3D snode in node.Sub)
     {
         if (snode is Entity3D || snode is Terrain.Terrain3D)
         {
             GetBounds(snode as Entity3D);
         }
     }
 }
Beispiel #8
0
        public void Read( )
        {
            int ns1 = Help.IOHelp.ReadInt();

            for (int i = 0; i < ns1; i++)
            {
                Script.ScriptLink sb = new Script.ScriptLink
                {
                    Name     = Help.IOHelp.ReadString( ),
                    FilePath = Help.IOHelp.ReadString( )
                };
                Scripts.Add(sb);
            }
            LocalTurn   = Help.IOHelp.ReadMatrix( );
            LocalPos    = Help.IOHelp.ReadVec3( );
            LocalScale  = Help.IOHelp.ReadVec3( );
            Name        = Help.IOHelp.ReadString( );
            AlwaysAlpha = Help.IOHelp.ReadBool( );
            On          = Help.IOHelp.ReadBool( );
            int ns = Help.IOHelp.ReadInt();
            int mc = Help.IOHelp.ReadInt();

            for (int m = 0; m < mc; m++)
            {
                Mesh3D msh = new Mesh3D();
                msh.Read( );
                Meshes.Add(msh);
            }
            for (int i = 0; i < ns; i++)
            {
                Entity3D gn = new Entity3D();
                Sub.Add(gn);
                gn.Top = this;
                gn.Read( );
            }
            SetMultiPass( );
        }
Beispiel #9
0
        public FusionEngine.Pick.PickResult CamPick(int x, int y)
        {
            Pick.PickResult res = new Pick.PickResult( );

            List <Node3D> nl = GetList(true);

            Pick.Ray mr = Pick.Picker.CamRay(Cams [0], x, y);

            float  cd = 0;
            bool   firstHit = true;
            float  cu = 0, cv = 0;
            Node3D cn = null;

            foreach (Node3D n in nl)
            {
                Entity3D e = n as Entity3D;

                foreach (Data.Mesh3D msh in e.Meshes)
                {
                    for (int i = 0; i < msh.TriData.Length; i++)
                    {
                        int     v0 = msh.TriData[i].V0;
                        int     v1 = msh.TriData[i].V1;
                        int     v2 = msh.TriData[i].v2;
                        Vector3 r0, r1, r2;
                        r0 = Rot(msh.VertexData [v0].Pos, n);
                        r1 = Rot(msh.VertexData [v1].Pos, n);
                        r2 = Rot(msh.VertexData [v2].Pos, n);
                        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       = n;
                                cu       = cr.Y;
                                cv       = cr.Z;
                            }
                        }
                    }
                }
            }

            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);
        }
Beispiel #10
0
        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 first = true;
                        foreach (Light3D l in Lights)
                        {
                            Light3D.Active = l;

                            if (first)
                            {
                                first = false;
                                GL.Disable(EnableCap.Blend);
                            }
                            else
                            {
                                GL.Enable(EnableCap.Blend);
                                GL.BlendFunc(BlendingFactor.One, BlendingFactor.One);
                            }
                            // Console.WriteLine("Presenting:" + node.Name);
                            if (node.Name.Contains("Merged"))
                            {
                            }
                            node.Present(c);

                            // foreach (var n in Nodes) { n.Present(c); }
                        }
                    }
                    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);
                    }
                }
            }
        }