private Mesh Tire(float width)
    {
        var vertices = new List <Vector3>();
        var offset   = new Vector3(width, 0, 0);

        vertices.AddRange(Octagon(offset, 0.5f));
        vertices.AddRange(Octagon(-offset, 0.5f));
        vertices.AddRange(Octagon(offset, 0.4f));
        vertices.AddRange(Octagon(-offset, 0.4f));
        var faces = new List <Face>();

        faces.AddRange(OctagonCoverFaces(new List <int> {
            0, 1
        }));
        faces.AddRange(OctagonCoverFaces(new List <int> {
            16, 17
        }, true));
        faces.AddRange(OctagonCoverSideFaces(new List <int> {
            0, 1
        }));
        faces.AddRange(OctagonCoverSideFaces(new List <int> {
            8, 9
        }, true));

        var mesh = new Mesh(vertices, faces);

        mesh.Add(mesh.MirrorY());
        mesh.Add(mesh.MirrorZ());
        return(mesh);
    }
    private Mesh Logo(Vector3 origin, float width, float radius)
    {
        var vertices = new List <Vector3>();
        var offset   = new Vector3(width, 0, 0);

        vertices.AddRange(Octagon(offset, radius));
        vertices.AddRange(Octagon(-offset, radius));
        var faces = new List <Face>();

        faces.AddRange(OctagonCoverFaces(new List <int> {
            0, 1
        }));
        vertices.Add(offset);
        faces.AddRange(OctagonFaces(16, new List <int> {
            0, 1
        }));

        var mesh = new Mesh(vertices, faces);

        // mesh.Add(Spoke(origin, 0.15f, 0.4f, 0.05f).Rotate(Quaternion.Euler(22.5f, 0, 0)));
        // mesh.Add(Spoke(origin, 0.15f, 0.4f, 0.05f).Rotate(Quaternion.Euler(67.5f, 0, 0)));

        mesh.Add(mesh.MirrorY());
        mesh.Add(mesh.MirrorZ());
        return(mesh.Translate(origin));
    }
示例#3
0
文件: RailwayTest.cs 项目: Antash/j4f
        public void IfCrashExistsTest()
        {
            bool actual, expected;
            var  m = new Mesh();

            m.Add(new Line(1, 5, 2));
            m.Add(new Line(5, 7, 5));
            m.Add(new Line(7, 4, 6));
            m.Add(new Line(4, 3, 1));
            m.Add(new Line(4, 6, 8));
            m.Add(new Line(7, 6, 3));
            m.Add(new Line(1, 2, 3));
            m.Add(new Line(3, 2, 3));
            m.Add(new Line(1, 3, 6));
            m.Add(new Line(5, 6, 2));

            Railway target = new Railway(m);

            target.ClearPaths();
            // Scenario 1. Crash happens at the station
            target.AddPath(new uint[] { 1, 5, 7, 4, 3 });
            target.AddPath(new uint[] { 3, 4, 7, 6 });
            target.AddPath(new uint[] { 4, 6, 5, 1, 3 });
            target.AddPath(new uint[] { 2, 1, 3, 4, 7 });

            expected = true;
            actual   = target.IfCrashExists();
            Assert.AreEqual(expected, actual);

            target.ClearPaths();
            // Scenario 2. Crash happens at the line
            target.AddPath(new uint[] { 3, 4, 7, 6 });
            target.AddPath(new uint[] { 4, 6, 7, 5 });
            target.AddPath(new uint[] { 2, 1, 3, 4, 7 });

            actual = target.IfCrashExists();
            Assert.AreEqual(expected, actual);

            target.ClearPaths();
            // Scenario 3.1 There are no crashes
            target.AddPath(new uint[] { 3, 4, 7, 6 });
            target.AddPath(new uint[] { 5, 6, 5, 1, 3 });
            target.AddPath(new uint[] { 2, 1, 3, 4, 7 });

            expected = false;
            actual   = target.IfCrashExists();
            Assert.AreEqual(expected, actual);

            target.ClearPaths();
            // Scenario 3.2 There are no crashes (trans passing same line together)
            target.AddPath(new uint[] { 7, 6, 4, 3 });
            target.AddPath(new uint[] { 5, 6, 4, 7 });

            actual = target.IfCrashExists();
            Assert.AreEqual(expected, actual);
        }
    private void CreateMesh()
    {
        // Body
        var body = new Mesh(new List <Vector3>(), new List <Face>());

        body.Add(Side(new Vector3(0.3f, -0.2f, 0), 0.5f, 1.7f, 0.7f, 1.1f, 1.2f));
        body.Add(Side(new Vector3(0.3f, -0.2f, 0), 0.5f, 1.7f, 0.7f, 1.1f, 1.2f).MirrorX());
        body.Add(Center(new Vector3(0, -0.2f, 0), 0.3f, 1.7f, 1.1f, 1.2f));

        // Logos
        var logos = new Mesh(new List <Vector3>(), new List <Face>());

        logos.Add(Logo(new Vector3(0.45f, 1, 0), 0.1f, 0.3f));
        logos.Add(Logo(new Vector3(0.45f, 1, 0), 0.1f, 0.3f).MirrorX());

        // Wheel covers
        var covers = new Mesh(new List <Vector3>(), new List <Face>());

        covers.Add(WheelCover(new Vector3(1, 0, 0), 0.2f));
        covers.Add(WheelCover(new Vector3(1, 0, 0), 0.2f).MirrorX());

        // Wheels
        var wheels = new Mesh(new List <Vector3>(), new List <Face>());

        wheels.Add(Wheel(new Vector3(1, 0, 0), 0.2f));
        wheels.Add(Wheel(new Vector3(1, 0, 0), 0.2f).MirrorX());

        // Sensors
        var sensors = new Mesh(new List <Vector3>(), new List <Face>());

        sensors.Add(SensorCone(new Vector3(0.25f + 0.03646613f, 1.5f + 0.2068096f, 0), 300));
        sensors.Add(SensorCone(new Vector3(0.25f + 0.03646613f, 1.5f + 0.2068096f, 0), 300).MirrorX());

        // Sensor poles
        var poles = new Mesh(new List <Vector3>(), new List <Face>());

        poles.Add(SensorPole().Translate(new Vector3(0.25f + 0.03646613f, 1.5f + 0.2068096f, 0)));
        poles.Add(SensorPole().Translate(new Vector3(0.25f + 0.03646613f, 1.5f + 0.2068096f, 0)).MirrorX());

        mesh.Add(body);
        mesh.Add(logos);
        mesh.Add(covers);
        mesh.Add(wheels);
        mesh.Add(sensors);
        mesh.Add(poles);
        SetMesh();
        ExportFile("Vehicle.obj", mesh.ExportObj());
        ExportFile("Body.obj", body.ExportObj());
        ExportFile("Logos.obj", logos.ExportObj());
        ExportFile("WheelCovers.obj", covers.ExportObj());
        ExportFile("WheelChassis.obj", Chassis(0.2f).ExportObj());
        ExportFile("WheelTire.obj", Tire(0.2f).ExportObj());
        ExportFile("SensorPoles.obj", poles.ExportObj());
    }
示例#5
0
        public DynamicRelaxationSystem()
        {
            this.Nodes      = new List <Node>();
            this.Connectors = new List <Connector>();
            this.Mesh       = new List <MeshElement>();

            Gravity = 0;
            double stiffness = 100;

            Nodes.Add(new Node(10, new Point3D(0, 0, 0))
            {
                Fixed = true
            });
            for (int i = 1; i < 10; i++)
            {
                Nodes.Add(new Node(10, new Point3D(i * 1000, 0, 0)));
                Connectors.Add(new Connector(Nodes[i - 1], Nodes[i])
                {
                    NaturalLength = 1000, Stiffness = stiffness
                });
            }
            for (int i = 1; i < 10; i++)
            {
                Nodes.Add(new Node(10, new Point3D(0, i * 1000, 0)));
                Connectors.Add(new Connector(Nodes[i * 10], Nodes[(i - 1) * 10])
                {
                    NaturalLength = 1000, Stiffness = stiffness
                });
                for (int j = 1; j < 10; j++)
                {
                    Nodes.Add(new Node(10, new Point3D(j * 1000, i * 1000, 0)));
                    Connectors.Add(new Connector(Nodes[i * 10 + j - 1], Nodes[i * 10 + j])
                    {
                        NaturalLength = 1000, Stiffness = stiffness
                    });
                    Connectors.Add(new Connector(Nodes[i * 10 + j], Nodes[(i - 1) * 10 + j])
                    {
                        NaturalLength = 1000, Stiffness = stiffness
                    });
                    Mesh.Add(new MeshElement((i - 1) * 10 + j - 1, (i - 1) * 10 + j, i * 10 + j - 1));
                    Mesh.Add(new MeshElement((i - 1) * 10 + j, i * 10 + j, i * 10 + j - 1));
                }
            }
            Nodes[99].Position = new Point3D(Nodes[99].Position.X, Nodes[99].Position.Y, 0);
            Nodes[99].Fixed    = true;
            Nodes[9].Position  = new Point3D(Nodes[9].Position.X, Nodes[9].Position.Y, 0);
            Nodes[9].Fixed     = true;
            Nodes[90].Position = new Point3D(Nodes[90].Position.X, Nodes[90].Position.Y, 0);
            Nodes[90].Fixed    = true;

            double minX = Nodes.Min(a => a.Position.X);
            double minY = Nodes.Min(a => a.Position.Y);
            double maxX = Nodes.Max(a => a.Position.X);
            double maxY = Nodes.Max(a => a.Position.Y);

            foreach (var node in Nodes)
            {
                node.uvPoint = new Point((int)(node.Position.X - minX) / (maxX - minX), (node.Position.Y - minY) / (maxY - minY));
            }
        }
示例#6
0
        static void Main(string[] args)
        {
            consumers.Add(new PrintConsumer());

            // create some hardcoded bones
            List <BodyPart> parts = provider.Get();
            // generate them
            List <Mesh> previous = new List <Mesh>();
            Mesh        total    = new Mesh();

            foreach (var item in parts)
            {
                Mesh generated = item.GenerateAndModify(previous, total);
                previous.Add(generated);
                total.Add(generated);
            }
            // send them to MeshConsumers
            foreach (var consumer in consumers)
            {
                foreach (var item in previous)
                {
                    consumer.Accept(item, false);
                }
                consumer.Accept(total, true);
            }
        }
示例#7
0
        private static void InsertWavefrontVertex(Mesh <WavefrontVertex, EdgeBase, WavefrontFace> wavefrontMesh, IDictionary <VertexBase, List <WavefrontVertex> > wavefrontVertices, WavefrontVertex wavefrontVertex)
        {
            wavefrontMesh.Add(wavefrontVertex);
            TVertex figureVertex = wavefrontVertex.GraphVertex;

            if (!wavefrontVertices.ContainsKey(figureVertex))
            {
                wavefrontVertices.Add(figureVertex, new List <WavefrontVertex>());
            }
            wavefrontVertices[figureVertex].Add(wavefrontVertex);
        }
    private Mesh Chassis(float width)
    {
        var vertices = new List <Vector3>();
        var offset   = new Vector3(width, 0, 0);

        vertices.AddRange(Octagon(offset, 0.1f));
        vertices.AddRange(Octagon(-offset, 0.1f));
        vertices.AddRange(Octagon(offset * 0.75f, 0.4f));
        var faces = new List <Face>();

        faces.AddRange(OctagonCoverFaces(new List <int> {
            0, 1
        }));

        vertices.Add(offset);
        faces.AddRange(OctagonFaces(24, new List <int> {
            0, 1
        }));
        vertices.Add(offset);
        faces.AddRange(OctagonFaces(25, new List <int> {
            8, 9
        }, true));

        vertices.Add(offset * 0.75f);
        faces.AddRange(OctagonFaces(26, new List <int> {
            16, 17
        }));

        var mesh = new Mesh(vertices, faces);

        // mesh.Add(Spoke(origin, 0.15f, 0.4f, 0.05f).Rotate(Quaternion.Euler(22.5f, 0, 0)));
        // mesh.Add(Spoke(origin, 0.15f, 0.4f, 0.05f).Rotate(Quaternion.Euler(67.5f, 0, 0)));

        mesh.Add(mesh.MirrorY());
        mesh.Add(mesh.MirrorZ());
        return(mesh);
    }
    private Mesh SensorPole()
    {
        var vertices = new List <Vector3>();
        var offset   = new Vector3(POLE_HEIGHT, 0, 0);

        vertices.AddRange(Octagon(offset, POLE_TOP_RADIUS));
        vertices.AddRange(Octagon(-offset, POLE_BOTTOM_RADIUS));
        var faces = new List <Face>();

        faces.AddRange(OctagonCoverFaces(new List <int> {
            0, 1
        }));

        vertices.Add(offset * POLE_CAP);
        faces.AddRange(OctagonFaces(16, new List <int> {
            0, 1
        }));

        var mesh = new Mesh(vertices, faces);

        mesh.Add(mesh.MirrorY());
        mesh.Add(mesh.MirrorZ());
        return(mesh.Rotate(Quaternion.Euler(0, 0, POLE_ANGLE)).Translate(Quaternion.Euler(0, 0, POLE_ANGLE) * new Vector3(-POLE_HEIGHT * CONE_POSITION, 0, 0)));
    }
示例#10
0
        private void Skeletonize()
        {
            // Duplicate the figure, but convert the types of vertices and edges
            // and maintain a mapping from the triangulation vertices to the wavefront vertices.
            var wavefrontMesh     = new Mesh <WavefrontVertex, EdgeBase, WavefrontFace>();
            var wavefrontVertices = new Dictionary <VertexBase, List <WavefrontVertex> >();

            foreach (TVertex v in figure.Vertices)
            {
                WavefrontVertex wavefrontVertex = new WavefrontVertex(v, new Vector2D());
                wavefrontMesh.Add(wavefrontVertex);
                if (!wavefrontVertices.ContainsKey(v))
                {
                    wavefrontVertices.Add(v, new List <WavefrontVertex>());
                }
                wavefrontVertices[v].Add(wavefrontVertex);
            }

            // Now insert the edges from the figure
            foreach (TEdge e in figure.Edges)
            {
                WavefrontVertex from = wavefrontVertices[e.Source].First();
                WavefrontVertex to   = wavefrontVertices[e.Target].First();
                wavefrontMesh.AddEdge(from, to, new FigureEdge());
            }

            // Triangulate the figure. All new edges inserted during the triangulation
            // are to be SpokeEdges. TODO: What about bounding-box edges?
            Algorithms.TriangulatePlanarSubdivision <WavefrontVertex, EdgeBase, WavefrontFace, TriangulationEdge>(wavefrontMesh, true);

            // Build the wavefront triangulation
            //  - insert additional zero size triangles at the terminals of the figure
            //  - split each edge of the figure along its length so that otherwise adjacent
            //    triangles do not share an edge
            foreach (TVertex figureVertex in figure.Vertices)
            {
                // TODO: Ensure we pass the right vertex to the functions here
                if (figureVertex.Degree >= 2)
                {
                    ProcessNonTerminalVertex(wavefrontMesh, wavefrontVertices, figureVertex);
                }
                else if (figureVertex.Degree == 1)
                {
                    ProcessTerminalVertex(wavefrontMesh, wavefrontVertices, figureVertex);
                }
            }
        }
示例#11
0
        static public Mesh ImportFromFile(string path)
        {
            StreamReader sr  = new StreamReader(path);
            StreamReader sr1 = new StreamReader(path);
            string       s;

            string[]        line = new string[4];
            Mesh            mesh = new Mesh();
            List <Triangle> list = new List <Triangle>();
            List <Vector3>  vec  = new List <Vector3>();


            while ((s = sr.ReadLine()) != null)
            {
                line = s.Split(' ');

                if (line[0] == "v")
                {
                    Vector3 vector = new Vector3(0.0f, 0.0f, 0.0f);
                    vector.x = float.Parse(line[1], System.Globalization.CultureInfo.InvariantCulture);
                    vector.y = float.Parse(line[2], System.Globalization.CultureInfo.InvariantCulture);
                    vector.z = float.Parse(line[3], System.Globalization.CultureInfo.InvariantCulture);
                    vec.Add(vector);
                }
            }
            while ((s = sr1.ReadLine()) != null)
            {
                line = s.Split(' ');
                int pom1, pom2, pom3;
                if (line[0] == "f")
                {
                    pom1 = int.Parse(line[1]);
                    pom2 = int.Parse(line[2]);
                    pom3 = int.Parse(line[3]);
                    pom1--;
                    pom2--;
                    pom3--;
                    Triangle t = new Triangle(vec[pom1], vec[pom2], vec[pom3]);
                    mesh.Add(t);
                }
            }

            sr.Close();
            sr1.Close();
            return(mesh);
        }
    private Mesh SensorCone(Vector3 origin, float angle)
    {
        var divisions    = (int)Math.Ceiling(angle / 45f);
        var segmentAngle = angle / divisions;

        var mesh = new Mesh(new List <Vector3>(), new List <Face>());

        for (var i = 0; i < divisions; i++)
        {
            mesh.Add(SensorConeSegment(segmentAngle).Rotate(Quaternion.Euler(0, i * segmentAngle, 0)));
        }
        mesh.faces.Add(new Face(0, 5, 4));
        mesh.faces.Add(new Face(1, 5, 0));
        mesh.faces.Add(new Face((divisions - 1) * 7, (divisions - 1) * 7 + 2, (divisions - 1) * 7 + 3));
        mesh.faces.Add(new Face((divisions - 1) * 7 + 1, (divisions - 1) * 7, (divisions - 1) * 7 + 3));
        return(mesh.Rotate(Quaternion.Euler(0, angle / -2, 0)).Translate(origin));
    }
    private Mesh Side(Vector3 origin, float width, float height, float cornerDepth, float innerDepth, float upperDepth)
    {
        var vertices = new List <Vector3>();

        vertices.Add(origin + new Vector3(width, 0, 0));
        vertices.Add(origin + new Vector3(width, 0, cornerDepth));
        vertices.Add(origin + new Vector3(0, 0, innerDepth));
        vertices.Add(origin + new Vector3(0, height, 0));
        vertices.Add(origin + new Vector3(0, height, upperDepth));

        var faces = new List <Face>();

        faces.Add(new Face(0, 3, 1));
        faces.Add(new Face(1, 3, 4));
        faces.Add(new Face(1, 4, 2));
        faces.Add(new Face(2, 4, 2));

        var mesh = new Mesh(vertices, faces);

        mesh.Add(mesh.MirrorZ());
        return(mesh);
    }
    private Mesh Center(Vector3 origin, float width, float height, float bottomDepth, float upperDepth)
    {
        var vertices = new List <Vector3>();

        vertices.Add(origin + new Vector3(width, 0, bottomDepth));
        vertices.Add(origin + new Vector3(-width, 0, bottomDepth));
        vertices.Add(origin + new Vector3(width, height, upperDepth));
        vertices.Add(origin + new Vector3(-width, height, upperDepth));
        vertices.Add(origin + new Vector3(width, height, 0));
        vertices.Add(origin + new Vector3(-width, height, 0));

        var faces = new List <Face>();

        faces.Add(new Face(0, 2, 1));
        faces.Add(new Face(1, 2, 3));
        faces.Add(new Face(2, 4, 5));
        faces.Add(new Face(2, 5, 3));

        var mesh = new Mesh(vertices, faces);

        mesh.Add(mesh.MirrorZ());
        return(mesh);
    }
示例#15
0
        public Cuboid(double a = 1.0, double b = 1.0, double c = 1.0)
        {
            Name = "Cuboid";
            double starta = -a / 2;
            double enda   = a / 2;
            double startb = -b / 2;
            double endb   = b / 2;
            double startc = -c / 2;
            double endc   = c / 2;

            Mesh.Add(new Triangle(new Vector(starta, startb, startc), new Vector(starta, endb, startc), new Vector(enda, endb, startc)));
            Mesh.Add(new Triangle(new Vector(starta, startb, startc), new Vector(enda, endb, startc), new Vector(enda, startb, startc)));
            Mesh.Add(new Triangle(new Vector(enda, startb, startc), new Vector(enda, endb, startc), new Vector(enda, endb, endc)));
            Mesh.Add(new Triangle(new Vector(enda, startb, startc), new Vector(enda, endb, endc), new Vector(enda, startb, endc)));
            Mesh.Add(new Triangle(new Vector(enda, startb, endc), new Vector(enda, endb, endc), new Vector(starta, endb, endc)));
            Mesh.Add(new Triangle(new Vector(enda, startb, endc), new Vector(starta, endb, endc), new Vector(starta, startb, endc)));
            Mesh.Add(new Triangle(new Vector(starta, startb, endc), new Vector(starta, endb, endc), new Vector(starta, endb, startc)));
            Mesh.Add(new Triangle(new Vector(starta, startb, endc), new Vector(starta, endb, startc), new Vector(starta, startb, startc)));
            Mesh.Add(new Triangle(new Vector(starta, endb, startc), new Vector(starta, endb, endc), new Vector(enda, endb, endc)));
            Mesh.Add(new Triangle(new Vector(starta, endb, startc), new Vector(enda, endb, endc), new Vector(enda, endb, startc)));
            Mesh.Add(new Triangle(new Vector(enda, startb, endc), new Vector(starta, startb, endc), new Vector(starta, startb, startc)));
            Mesh.Add(new Triangle(new Vector(enda, startb, endc), new Vector(starta, startb, startc), new Vector(enda, startb, startc)));
            Color = Color.LightBlue;
        }
示例#16
0
        public Sphere(double r, int d1, int d2)
        {
            Name             = "Sphere";
            Color            = Color.Orange;
            d1              += 1;
            Vector[,] sphere = new Vector[d1, d2];
            double step1 = Math.PI / (d1 - 1);
            double step2 = 2 * Math.PI / d2;
            double lat   = 0.0;
            double lon   = 0.0;

            for (int i = 0; i < d1; i++)
            {
                for (int j = 0; j < d2; j++)
                {
                    double x = r * Math.Sin(lon) * Math.Cos(lat);
                    double y = r * Math.Sin(lon) * Math.Sin(lat);
                    double z = r * Math.Cos(lon);
                    Vector v = new Vector(x, y, z);
                    sphere[i, j] = v;
                    lat         += step2;
                }
                lon += step1;
            }

            for (int i = 0; i < d1 - 1; i++)
            {
                for (int j = 0; j < d2; j++)
                {
                    Triangle t1 = new Triangle(sphere[i, j], sphere[(i + 1) % d1, j], sphere[i, (j + 1) % d2]);
                    Triangle t2 = new Triangle(sphere[i, (j + 1) % d2], sphere[(i + 1) % d1, j], sphere[(i + 1) % d1, (j + 1) % d2]);
                    Mesh.Add(t1);
                    Mesh.Add(t2);
                }
            }
        }
示例#17
0
        public Models(Matrix4x4 matWorld, Matrix4x4 matView, Matrix4x4 matpro, Vector3 Camera)
        {
            this.meshModelsProject = new Mesh();


            Vector3 temp1 = new Vector3(), temp2 = new Vector3(), temp3 = new Vector3();


            //lista posortowana
            List <Triangle> sortToRaster = new List <Triangle>();



            Vector3 normal = new Vector3(), line1 = new Vector3(), line2 = new Vector3();

            foreach (Triangle item in meshModels.lista)
            {
                Triangle transformed = new Triangle(temp1, temp2, temp3);
                Triangle translate   = new Triangle(temp1, temp2, temp3);
                Triangle projected   = new Triangle(temp1, temp2, temp3);
                Triangle triView     = new Triangle(temp1, temp2, temp3);

                transformed.v1 = Vector3.Matrix_MultiplyVector(matWorld, item.v1);
                transformed.v2 = Vector3.Matrix_MultiplyVector(matWorld, item.v2);
                transformed.v3 = Vector3.Matrix_MultiplyVector(matWorld, item.v3);

                //obliczanie normalych
                line1 = Vector3.Vector_Sub(transformed.v2, transformed.v1);
                line2 = Vector3.Vector_Sub(transformed.v3, transformed.v1);

                normal = Vector3.Vectro_CrossPd(line1, line2);

                normal = Vector3.Vector_Normalise(normal);


                //normalne by wyswietlac te sciany co powinniśmy
                Vector3 cameraRay = Vector3.Vector_Sub(transformed.v1, Camera);

                if (Vector3.Vector_DotProduct(normal, cameraRay) < 0.0f)
                {
                    //light
                    Vector3 light = new Vector3(0.0f, 0.0f, -1.0f);
                    //rotacja światła wraz z sceną
                    light = Vector3.Matrix_MultiplyVector(matWorld, light);
                    light = Vector3.Vector_Normalise(light);

                    //iloczyn skalarny


                    float dp = System.Math.Max(0.1f, Vector3.Vector_DotProduct(light, normal));



                    //przestrzen swiata--> przestrzen projektowana
                    triView.v1 = Vector3.Matrix_MultiplyVector(matView, transformed.v1);
                    triView.v2 = Vector3.Matrix_MultiplyVector(matView, transformed.v2);
                    triView.v3 = Vector3.Matrix_MultiplyVector(matView, transformed.v3);

                    //przycinanie trójkątów jeżeli sa za wielkie i za blisko ekranu
                    Vector3         plane_p    = new Vector3(0.0f, 0.0f, 0.1f);
                    Vector3         plane_n    = new Vector3(0.0f, 0.0f, 1.0f);
                    List <Triangle> toClip     = Triangle.ClipAgainstPlane(plane_p, plane_n, triView);
                    int             clippedTri = toClip.Count;
                    for (int i = 0; i < clippedTri; i++)
                    {
                        projected.v1 = Vector3.Matrix_MultiplyVector(matpro, toClip[i].v1);
                        projected.v2 = Vector3.Matrix_MultiplyVector(matpro, toClip[i].v2);
                        projected.v3 = Vector3.Matrix_MultiplyVector(matpro, toClip[i].v3);

                        projected.v1 = Vector3.Vector_Div(projected.v1, projected.v1.w);
                        projected.v2 = Vector3.Vector_Div(projected.v2, projected.v2.w);
                        projected.v3 = Vector3.Vector_Div(projected.v3, projected.v3.w);

                        projected.v1.x *= -1.0f;
                        projected.v1.y *= -1.0f;
                        projected.v2.x *= -1.0f;
                        projected.v2.y *= -1.0f;
                        projected.v3.x *= -1.0f;
                        projected.v3.y *= -1.0f;

                        //początkowa translacja sceny
                        Vector3 offserView = new Vector3(1.0f, 2.0f, 1.0f);
                        projected.v1 = Vector3.Vector_Add(projected.v1, offserView);
                        projected.v2 = Vector3.Vector_Add(projected.v2, offserView);
                        projected.v3 = Vector3.Vector_Add(projected.v3, offserView);
                        //skalowanie sceny
                        projected.v1.x *= 0.5f * (float)1024;
                        projected.v1.y *= 0.5f * (float)768;

                        projected.v2.x *= 0.5f * (float)1024;
                        projected.v2.y *= 0.5f * (float)768;

                        projected.v3.x *= 0.5f * (float)1024;
                        projected.v3.y *= 0.5f * (float)768;


                        projected.dp = dp;

                        sortToRaster.Add(projected);
                    }
                }
            }
            List <Triangle> listtri = new List <Triangle>();

            foreach (Triangle item in sortToRaster)
            {
                //ucinanie dla czterech krawędzi okna
                listtri.Clear();
                listtri.Add(item);
                int newTri = 1;
                for (int i = 0; i < 4; i++)
                {
                    while (newTri > 0)
                    {
                        //pierwsza z kolejki
                        Triangle t = listtri.First();
                        listtri.RemoveAt(0);
                        newTri--;
                        List <Triangle> clippedTriangles = new List <Triangle>();
                        switch (i)
                        {
                        case 0:
                            clippedTriangles = Triangle.ClipAgainstPlane(new Vector3(0.0f, 0.0f, 0.0f), new Vector3(0.0f, 1.0f, 0.0f), t);
                            break;

                        case 1:
                            clippedTriangles = Triangle.ClipAgainstPlane(new Vector3(0.0f, 768 - 1, 0.0f), new Vector3(0.0f, -1.0f, 0.0f), t);
                            break;

                        case 2:
                            clippedTriangles = Triangle.ClipAgainstPlane(new Vector3(0.0f, 0.0f, 0.0f), new Vector3(1.0f, 0.0f, 0.0f), t);
                            break;

                        case 3:
                            clippedTriangles = Triangle.ClipAgainstPlane(new Vector3(1024 - 1, 0.0f, 0.0f), new Vector3(-1.0f, 0.0f, 0.0f), t);
                            break;
                        }
                        foreach (Triangle item2 in clippedTriangles)
                        {
                            listtri.Add(item2);
                        }
                    }
                    newTri = listtri.Count;
                }

                foreach (Triangle item3 in listtri)
                {
                    meshModelsProject.Add(item3);
                }
            }

            meshModelsProject.Sort();
        }
示例#18
0
        /// <summary>
        /// Create a physics mesh from data that comes with the prim.  The actual data used depends on the prim type.
        /// </summary>
        /// <param name="primName"></param>
        /// <param name="primShape"></param>
        /// <param name="size"></param>
        /// <param name="lod"></param>
        /// <returns></returns>
        private Mesh CreateMeshFromPrimMesher(string primName, PrimitiveBaseShape primShape, float lod, bool convex)
        {
//            m_log.DebugFormat(
//                "[MESH]: Creating physics proxy for {0}, shape {1}",
//                primName, (OpenMetaverse.SculptType)primShape.SculptType);

            List<Coord> coords;
            List<Face> faces;

            if (primShape.SculptEntry)
            {
                if (((OpenMetaverse.SculptType)primShape.SculptType) == SculptType.Mesh)
                {
                    if (!useMeshiesPhysicsMesh)
                        return null;

                    if (!GenerateCoordsAndFacesFromPrimMeshData(primName, primShape, out coords, out faces, convex))
                        return null;
                }
                else
                {
                    if (!GenerateCoordsAndFacesFromPrimSculptData(primName, primShape, lod, out coords, out faces))
                        return null;
                }
            }
            else
            {
                if (!GenerateCoordsAndFacesFromPrimShapeData(primName, primShape, lod, out coords, out faces))
                    return null;
            }


            int numCoords = coords.Count;
            int numFaces = faces.Count;

            Mesh mesh = new Mesh();
            // Add the corresponding triangles to the mesh
            for (int i = 0; i < numFaces; i++)
            {
                Face f = faces[i];
                mesh.Add(new Triangle(coords[f.v1].X, coords[f.v1].Y, coords[f.v1].Z,
                                      coords[f.v2].X, coords[f.v2].Y, coords[f.v2].Z,
                                      coords[f.v3].X, coords[f.v3].Y, coords[f.v3].Z));
            }

            coords.Clear();
            faces.Clear();

            if(mesh.numberVertices() < 3 || mesh.numberTriangles() < 1)
                {
                m_log.ErrorFormat("[MESH]: invalid degenerated mesh for prim " + primName + " ignored");
                return null;
                }

            primShape.SculptData = Utils.EmptyBytes;

            return mesh;
        }
示例#19
0
        /// <summary>
        /// creates a simple box mesh of the specified size. This mesh is of very low vertex count and may
        /// be useful as a backup proxy when level of detail is not needed or when more complex meshes fail
        /// for some reason
        /// </summary>
        /// <param name="minX"></param>
        /// <param name="maxX"></param>
        /// <param name="minY"></param>
        /// <param name="maxY"></param>
        /// <param name="minZ"></param>
        /// <param name="maxZ"></param>
        /// <returns></returns>
        private static Mesh CreateSimpleBoxMesh(float minX, float maxX, float minY, float maxY, float minZ, float maxZ)
        {
            Mesh box = new Mesh();
            List<Vertex> vertices = new List<Vertex>();
            // bottom

            vertices.Add(new Vertex(minX, maxY, minZ));
            vertices.Add(new Vertex(maxX, maxY, minZ));
            vertices.Add(new Vertex(maxX, minY, minZ));
            vertices.Add(new Vertex(minX, minY, minZ));

            box.Add(new Triangle(vertices[0], vertices[1], vertices[2]));
            box.Add(new Triangle(vertices[0], vertices[2], vertices[3]));

            // top

            vertices.Add(new Vertex(maxX, maxY, maxZ));
            vertices.Add(new Vertex(minX, maxY, maxZ));
            vertices.Add(new Vertex(minX, minY, maxZ));
            vertices.Add(new Vertex(maxX, minY, maxZ));

            box.Add(new Triangle(vertices[4], vertices[5], vertices[6]));
            box.Add(new Triangle(vertices[4], vertices[6], vertices[7]));

            // sides

            box.Add(new Triangle(vertices[5], vertices[0], vertices[3]));
            box.Add(new Triangle(vertices[5], vertices[3], vertices[6]));

            box.Add(new Triangle(vertices[1], vertices[0], vertices[5]));
            box.Add(new Triangle(vertices[1], vertices[5], vertices[4]));

            box.Add(new Triangle(vertices[7], vertices[1], vertices[4]));
            box.Add(new Triangle(vertices[7], vertices[2], vertices[1]));

            box.Add(new Triangle(vertices[3], vertices[2], vertices[7]));
            box.Add(new Triangle(vertices[3], vertices[7], vertices[6]));

            return box;
        }
        public void Init()
        {
            mesh = new Mesh <Vertex, EdgeBase, FaceBase>(false, true);

            v1 = new Vertex(3, 10);
            v2 = new Vertex(3, 6);
            v3 = new Vertex(6, 8);
            v4 = new Vertex(3, 3);
            v6 = new Vertex(13, 4);
            v7 = new Vertex(13, 11);

            mesh.Add(v1);
            mesh.Add(v2);
            edgeTwoToOne  = mesh.AddEdge(v2, v1);
            edgeTwoToOne2 = mesh.AddEdge(v2, v1);
            edgeOneToTwo  = mesh.AddEdge(v1, v2);

            mesh.Add(v3);
            edgeThreeToTwo = mesh.AddEdge(v3, v2);
            edgeTwoToThree = mesh.AddEdge(v2, v3);

            mesh.Add(v4);
            edgeFourToThree = mesh.AddEdge(v4, v3);

            mesh.Add(v7);
            mesh.Add(v6);
            edgeSevenToSix = mesh.AddEdge(v7, v6);

            v100 = new Vertex(101, 103);
            v101 = new Vertex(103, 103);
            v102 = new Vertex(108, 103);
            v103 = new Vertex(107, 103);
            v104 = new Vertex(109, 103);
            v105 = new Vertex(104, 101);
            v106 = new Vertex(106, 106);

            mesh.Add(v100);
            mesh.Add(v101);
            e100to101 = mesh.AddEdge(v100, v101);

            mesh.Add(v101);
            mesh.Add(v102);
            e101to102 = mesh.AddEdge(v101, v102);

            mesh.Add(v103);
            mesh.Add(v104);
            e103to104 = mesh.AddEdge(v103, v104);

            mesh.Add(v105);
            mesh.Add(v106);
            e105to106 = mesh.AddEdge(v105, v106);

            v200 = new Vertex(210, 180);
            v201 = new Vertex(90, 180);
            v202 = new Vertex(90, 60);

            mesh.Add(v200);
            mesh.Add(v201);
            mesh.Add(v202);
            e200to201 = mesh.AddEdge(v200, v201);
            e202to201 = mesh.AddEdge(v202, v201);

            v300 = new Vertex(210, 180);
            v301 = new Vertex(90, 180);
            v302 = new Vertex(90, 60);
            v303 = new Vertex(90, 170);

            mesh.Add(v300);
            mesh.Add(v301);
            mesh.Add(v302);
            mesh.Add(v303);
            e300to301 = mesh.AddEdge(v300, v301);
            e302to303 = mesh.AddEdge(v302, v303);

            comparer = new LeftToRightEdgeComparer();
        }
示例#21
0
        public BasicAttach(byte[] file, int address, uint imageBase, bool DX, Dictionary <int, string> labels)
            : this()
        {
            if (labels.ContainsKey(address))
            {
                Name = labels[address];
            }
            else
            {
                Name = "attach_" + address.ToString("X8");
            }
            Vertex = new Vertex[ByteConverter.ToInt32(file, address + 8)];
            Normal = new Vertex[Vertex.Length];
            int tmpaddr = (int)(ByteConverter.ToUInt32(file, address) - imageBase);

            if (labels.ContainsKey(tmpaddr))
            {
                VertexName = labels[tmpaddr];
            }
            else
            {
                VertexName = "vertex_" + tmpaddr.ToString("X8");
            }
            for (int i = 0; i < Vertex.Length; i++)
            {
                Vertex[i] = new Vertex(file, tmpaddr);
                tmpaddr  += SAModel.Vertex.Size;
            }
            tmpaddr = ByteConverter.ToInt32(file, address + 4);
            if (tmpaddr != 0)
            {
                tmpaddr = (int)((uint)tmpaddr - imageBase);
                if (labels.ContainsKey(tmpaddr))
                {
                    NormalName = labels[tmpaddr];
                }
                else
                {
                    NormalName = "normal_" + tmpaddr.ToString("X8");
                }
                for (int i = 0; i < Vertex.Length; i++)
                {
                    Normal[i] = new Vertex(file, tmpaddr);
                    tmpaddr  += SAModel.Vertex.Size;
                }
            }
            else
            {
                for (int i = 0; i < Vertex.Length; i++)
                {
                    Normal[i] = new Vertex(0, 1, 0);
                }
            }
            int maxmat  = -1;
            int meshcnt = ByteConverter.ToInt16(file, address + 0x14);

            tmpaddr = ByteConverter.ToInt32(file, address + 0xC);
            if (tmpaddr != 0)
            {
                tmpaddr = (int)unchecked ((uint)tmpaddr - imageBase);
                if (labels.ContainsKey(tmpaddr))
                {
                    MeshName = labels[tmpaddr];
                }
                else
                {
                    MeshName = "meshlist_" + tmpaddr.ToString("X8");
                }
                for (int i = 0; i < meshcnt; i++)
                {
                    Mesh.Add(new NJS_MESHSET(file, tmpaddr, imageBase, labels));
                    maxmat   = Math.Max(maxmat, Mesh[i].MaterialID);
                    tmpaddr += NJS_MESHSET.Size(DX);
                }
            }
            // fixes case where model declares material array as shorter than it really is
            int matcnt = Math.Max(ByteConverter.ToInt16(file, address + 0x16), maxmat + 1);

            tmpaddr = ByteConverter.ToInt32(file, address + 0x10);
            if (tmpaddr != 0)
            {
                tmpaddr = (int)unchecked ((uint)tmpaddr - imageBase);
                if (labels.ContainsKey(tmpaddr))
                {
                    MaterialName = labels[tmpaddr];
                }
                else
                {
                    MaterialName = "matlist_" + tmpaddr.ToString("X8");
                }
                for (int i = 0; i < matcnt; i++)
                {
                    Material.Add(new NJS_MATERIAL(file, tmpaddr, labels));
                    tmpaddr += NJS_MATERIAL.Size;
                }
            }
            Bounds = new BoundingSphere(file, address + 0x18);
        }
示例#22
0
        /// <summary>
        /// Create a physics mesh from data that comes with the prim.  The actual data used depends on the prim type.
        /// </summary>
        /// <param name="primName"></param>
        /// <param name="primShape"></param>
        /// <param name="size"></param>
        /// <param name="lod"></param>
        /// <returns></returns>
        private Mesh CreateMeshFromPrimMesher(string primName, PrimitiveBaseShape primShape, Vector3 size, float lod)
        {
//            m_log.DebugFormat(
//                "[MESH]: Creating physics proxy for {0}, shape {1}",
//                primName, (OpenMetaverse.SculptType)primShape.SculptType);

            List<Coord> coords;
            List<Face> faces;

            if (primShape.SculptEntry)
            {
                if (((OpenMetaverse.SculptType)primShape.SculptType) == SculptType.Mesh)
                {
                    if (!useMeshiesPhysicsMesh)
                        return null;

                    if (!GenerateCoordsAndFacesFromPrimMeshData(primName, primShape, size, out coords, out faces))
                        return null;
                }
                else
                {
                    if (!GenerateCoordsAndFacesFromPrimSculptData(primName, primShape, size, lod, out coords, out faces))
                        return null;
                }
            }
            else
            {
                if (!GenerateCoordsAndFacesFromPrimShapeData(primName, primShape, size, lod, out coords, out faces))
                    return null;
            }

            // Remove the reference to any JPEG2000 sculpt data so it can be GCed
            primShape.SculptData = Utils.EmptyBytes;

            int numCoords = coords.Count;
            int numFaces = faces.Count;

            // Create the list of vertices
            List<Vertex> vertices = new List<Vertex>();
            for (int i = 0; i < numCoords; i++)
            {
                Coord c = coords[i];
                vertices.Add(new Vertex(c.X, c.Y, c.Z));
            }

            Mesh mesh = new Mesh();
            // Add the corresponding triangles to the mesh
            for (int i = 0; i < numFaces; i++)
            {
                Face f = faces[i];
                mesh.Add(new Triangle(vertices[f.v1], vertices[f.v2], vertices[f.v3]));
            }

            return mesh;
        }
示例#23
0
        static void Main(string[] args)
        {
            var scene = new Scene
            {
                Background = new  Color(255, 0, 255).ToInt(),
                Name       = "My Scene"
            };

            var verts = new List <float[]>
            {
                new float[] { 0, 0, 0 },
                new float[] { 0, 0, 10.1234f },
                new float[] { 10, 0, 10 },
                new float[] { 10, 0, 0 }
            };

            var norms = new List <float[]>
            {
                new float[] { 0, 1, 0 },
                new float[] { 0, 1, 0 },
                new float[] { 0, 1, 0 },
                new float[] { 0, 1, 0 }
            };

            var vertices = Utilities.Flatten(verts).Cast <float>().ToList();//Geometry.ProcessVertexArray(verts);

            var normals = Utilities.Flatten(norms).Cast <float>().ToList();

            var face1 = new int[] { 0, 1, 2 };
            var face2 = new int[] { 0, 2, 3 };

            var faces = Geometry.ProcessFaceArray(new List <int[]> {
                { face1 }, { face2 }
            }, false, false);

            var geometry  = new Geometry(vertices, faces, normals);
            var geometry2 = new Geometry(vertices, faces, normals);
            var material  = MeshStandardMaterial.Default();

            var mesh = new Mesh
            {
                Geometry = geometry2,
                Material = material,
                Name     = "My Mesh"
            };

            //scene.Add(mesh);

            var material2 = MeshStandardMaterial.Default();

            material2.Roughness = 0.25;

            var mesh2 = new Mesh
            {
                Geometry = geometry,
                Material = material2,
                Position = new Vector3(20, 20, 20),
                Name     = "My Mesh2"
            };

            //scene.Add(mesh2);

            var material3 = MeshStandardMaterial.Default();

            var mesh3 = new Mesh
            {
                Geometry = geometry2,
                Material = material3,
                Position = new Vector3(30, 30, 30),
                Name     = "My Mesh3"
            };

            //scene.Add(mesh3);

            var line = new Line
            {
                Geometry = new Geometry(vertices),
                Material = new LineBasicMaterial {
                    Color = new Color(255, 0, 0).ToInt(), LineWidth = 20
                },
                Name = "My Curves"
            };

            //scene.Add(line);

            var colors = new List <int>
            {
                255, 0, 0,
                255, 255, 0,
                255, 0, 255,
                0, 255, 0
            };

            var pointsGeometry = new BufferGeometry
            {
                Attributes =
                {
                    { "position", new BufferAttribute
                        {
                            Array    = vertices.Cast <object>().ToArray(),
                            ItemSize = 3,
                            Type     = "Float32Array"
                        } },
                    { "color", new BufferAttribute
                        {
                            Array    = colors.Cast <object>().ToArray(),
                            ItemSize = 3,
                            Type     = "Uint8Array"
                        } }
                },
                BoundingSphere = new BufferGeometryBoundingSphere
                {
                    Center = new float[] { 0, 0, 0 },
                    Radius = 4
                }
            };

            var points = new Points
            {
                Geometry = pointsGeometry,
                Material = new PointsMaterial {
                    VertexColors = VertexColors.Vertex, Size = 10
                },
                Name = "My Points"
            };

            //scene.Add(points);

            var points2 = new Points
            {
                Geometry = pointsGeometry,
                Material = new PointsMaterial {
                    VertexColors = VertexColors.Vertex, Size = 10
                },
                Name = "My Points2"
            };

            //scene.Add(points2);

            var verts2 = new List <float[]>
            {
                new float[] { 0, 0, 0 },
                new float[] { 0, 0, 10 },
                new float[] { 10, 0, 10 },
                new float[] { 0, 0, 0 },
                new float[] { 10, 0, 10 },
                new float[] { 10, 0, 0 }
            };

            var norms2 = new List <float[]>
            {
                new float[] { 0, 1, 0 },
                new float[] { 0, 1, 0 },
                new float[] { 0, 1, 0 },
                new float[] { 0, 1, 0 },
                new float[] { 0, 1, 0 },
                new float[] { 0, 1, 0 }
            };

            var color2 = new List <float[]>
            {
                new float[] { 0, 0, 255 },
                new float[] { 0, 0, 255 },
                new float[] { 0, 0, 255 },
                new float[] { 255, 0, 0 },
                new float[] { 255, 0, 0 },
                new float[] { 255, 0, 0 },
            };

            var uv2 = new List <float[]>
            {
                new float[] { 0, 0 },
                new float[] { 1, 0.5f },
                new float[] { 1, 0 },
                new float[] { 0, 0 },
                new float[] { 0.5f, 1 },
                new float[] { 1, 0.5f }
            };

            var meshBG = new BufferGeometry
            {
                Attributes =
                {
                    { "position", new BufferAttribute
                        {
                            Array    = Utilities.OptimizeFloats(Utilities.Flatten(verts2).Cast <float>()).ToArray(),
                            ItemSize = 3,
                            Type     = BufferAttributeType.Float32Array.ToString()
                        } },
                    { "normal", new BufferAttribute
                        {
                            Array    = Utilities.Flatten(norms2),
                            ItemSize = 3,
                            Type     = BufferAttributeType.Float32Array.ToString()
                        } },
                    { "uv", new BufferAttribute
                        {
                            Array    = Utilities.Flatten(uv2),
                            ItemSize = 2,
                            Type     = BufferAttributeType.Float32Array.ToString()
                        } },
                    { "color", new BufferAttribute
                        {
                            Array    = Utilities.Flatten(color2),
                            ItemSize = 3,
                            Type     = BufferAttributeType.Float32Array.ToString()
                        } }
                },
                BoundingSphere = new BufferGeometryBoundingSphere
                {
                    Center = new float[] { 0, 0, 0 },
                    Radius = 5
                }
            };

            var mesh6 = new Mesh
            {
                Geometry = meshBG,
                Material = MeshStandardMaterial.Default(),
                Name     = "MeshfromBufferGeo"
            };

            (mesh6.Material as MeshStandardMaterial).VertexColors = VertexColors.Vertex;

            //scene.Add(mesh6);

            var verts3 = new object[]
            {
                0, 0, 0,
                0, 0, 10,
                10, 0, 10,
                10, 0, 0
            };

            var indexes = new object[] { 0, 1, 2, 0, 2, 3 };

            var norms3 = new object[]
            {
                0, 1, 0,
                0, 1, 0,
                0, 1, 0,
                0, 1, 0,
                0, 1, 0,
                0, 1, 0
            };

            var color3 = new object[]
            {
                0, 0, 255,
                0, 0, 255,
                0, 0, 255,
                255, 0, 0,
                255, 0, 0,
                255, 0, 0,
            };

            var uv3 = new object[]
            {
                0, 0,
                1, 0.5,
                1, 0,
                0, 0,
                0.5, 1,
                1, 0.5
            };

            var meshIBG = new BufferGeometry
            {
                Attributes =
                {
                    { "position", new BufferAttribute
                        {
                            Array    = verts3,
                            ItemSize = 3,
                            Type     = BufferAttributeType.Float32Array.ToString()
                        } },
                    { "index", new BufferAttribute
                        {
                            Array    = indexes,
                            ItemSize = 1,
                            Type     = BufferAttributeType.Int8Array.ToString()
                        } },
                    { "normal", new BufferAttribute
                        {
                            Array    = norms3,
                            ItemSize = 3,
                            Type     = BufferAttributeType.Float32Array.ToString()
                        } },
                    { "uv", new BufferAttribute
                        {
                            Array    = uv3,
                            ItemSize = 2,
                            Type     = BufferAttributeType.Float32Array.ToString()
                        } },
                    { "color", new BufferAttribute
                        {
                            Array    = color3,
                            ItemSize = 3,
                            Type     = BufferAttributeType.Float32Array.ToString()
                        } }
                },
                BoundingSphere = new BufferGeometryBoundingSphere
                {
                    Center = new float[] { 0, 0, 0 },
                    Radius = 5
                }
            };

            var mesh7 = new Mesh
            {
                Geometry = meshIBG,
                Material = MeshStandardMaterial.Default(),
                Name     = "MeshfromIndexedBufferGeo"
            };

            (mesh7.Material as MeshStandardMaterial).VertexColors = VertexColors.Vertex;

            //scene.Add(mesh7);

            var mesh4 = new Mesh
            {
                Geometry = geometry2,
                Material = material3,
                Position = new Vector3(30, 30, 30),
                Name     = "My Mesh4"
            };

            var sphereGeoAsChild = new SphereBufferGeometry
            {
                Radius         = 3,
                WidthSegments  = 22,
                HeightSegments = 22,
                PhiStart       = 0,
                PhiLength      = (float)Math.PI * 2,
                ThetaStart     = 0,
                ThetaLength    = (float)Math.PI * 2
            };

            var sphereMeshAsChild = new Mesh
            {
                Geometry = sphereGeoAsChild,
                Material = material,
                Position = new Vector3(-45, 10, 45),
                Name     = "My Sphere as a Child"
            };

            mesh4.Add(sphereMeshAsChild);
            //scene.Add(mesh4);

            var group = new Group();

            group.Add(mesh3);
            group.Add(mesh2);
            group.Add(mesh);

            //scene.Add(group);

            var group2 = new Group();

            group2.Add(mesh3);
            group2.Add(mesh2);
            group2.Add(mesh);

            //scene.Add(group2);

            var sphereGeometry = new SphereBufferGeometry
            {
                Radius         = 10,
                WidthSegments  = 10,
                HeightSegments = 5,
                PhiStart       = 0,
                PhiLength      = (float)Math.PI * 2,
                ThetaStart     = 0,
                ThetaLength    = (float)Math.PI * 2
            };

            var sphereMesh = new Mesh
            {
                Geometry = sphereGeometry,
                Material = material,
                Position = new Vector3(-45, 10, 45),
                Name     = "My Sphere"
            };

            //scene.Add(sphereMesh);

            #region Lights

            var pointLight = new PointLight
            {
                Color     = new Color(100, 100, 100).ToInt(),
                Decay     = 1,
                Intensity = 3,
                Name      = "My PointLight",
                Position  = new Vector3(10, 10, 10)
            };

            //scene.Add(pointLight);

            var ambientLight = new AmbientLight
            {
                Color     = new Color(255, 0, 255).ToInt(),
                Intensity = 5,
                Name      = "My AmbientLight"
            };

            //scene.Add(ambientLight);

            var targetObject = new Object3D {
                Position = new Vector3(3, 0, 0)
            };
            scene.Add(targetObject);

            var directionalLight = new DirectionalLight
            {
                Target   = targetObject,
                Position = new Vector3(-10, 10, 5),
                Name     = "My DirectionalLight"
            };

            scene.Add(directionalLight);

            var spotLight = new SpotLight
            {
                Target = new Object3D {
                    Position = new Vector3(3, 0, 3)
                },
                Position = new Vector3(20, 20, 0),
                Name     = "My SpotLight"
            };

            //scene.Add(spotLight);

            var hemiLight = new HemisphereLight
            {
                SkyColor    = new Color(0, 30, 255).ToInt(),
                GroundColor = new Color(30, 30, 30).ToInt(),
                Name        = "My HemisphereLight"
            };

            //scene.Add(hemiLight);

            #endregion

            //Console.WriteLine(geometry.ToJSON(true));

            Console.WriteLine(scene.ToJSON(false));

            Console.ReadLine();
        }
示例#24
0
文件: Sphere.cs 项目: matyjb/GK-3D
        private Mesh BuildIcosahedron(float radius, Vec4 color)
        {
            Mesh ico20 = new Mesh();
            //The golden ratio
            float t = (1 + (float)Math.Sqrt(5)) / 2;

            //Define the points needed to build a icosahedron, stolen from article
            Vec3[] vecs = new Vec3[12];
            vecs[0] = new Vec3(-radius, t * radius, 0).Normal();
            vecs[1] = new Vec3(radius, t * radius, 0).Normal();
            vecs[2] = new Vec3(-radius, -t * radius, 0).Normal();
            vecs[3] = new Vec3(radius, -t * radius, 0).Normal();

            vecs[4] = new Vec3(0, -radius, t * radius).Normal();
            vecs[5] = new Vec3(0, radius, t * radius).Normal();
            vecs[6] = new Vec3(0, -radius, -t * radius).Normal();
            vecs[7] = new Vec3(0, radius, -t * radius).Normal();

            vecs[8]  = new Vec3(t * radius, 0, -radius).Normal();
            vecs[9]  = new Vec3(t * radius, 0, radius).Normal();
            vecs[10] = new Vec3(-t * radius, 0, -radius).Normal();
            vecs[11] = new Vec3(-t * radius, 0, radius).Normal();

            // 5 faces around point 0
            ico20.Add(new Tri(vecs[0], vecs[11], vecs[5], color));
            ico20.Add(new Tri(vecs[0], vecs[5], vecs[1], color));
            ico20.Add(new Tri(vecs[0], vecs[1], vecs[7], color));
            ico20.Add(new Tri(vecs[0], vecs[7], vecs[10], color));
            ico20.Add(new Tri(vecs[0], vecs[10], vecs[11], color));

            // 5 adjacent faces
            ico20.Add(new Tri(vecs[1], vecs[5], vecs[9], color));
            ico20.Add(new Tri(vecs[5], vecs[11], vecs[4], color));
            ico20.Add(new Tri(vecs[11], vecs[10], vecs[2], color));
            ico20.Add(new Tri(vecs[10], vecs[7], vecs[6], color));
            ico20.Add(new Tri(vecs[7], vecs[1], vecs[8], color));

            // 5 faces around point 3
            ico20.Add(new Tri(vecs[3], vecs[9], vecs[4], color));
            ico20.Add(new Tri(vecs[3], vecs[4], vecs[2], color));
            ico20.Add(new Tri(vecs[3], vecs[2], vecs[6], color));
            ico20.Add(new Tri(vecs[3], vecs[6], vecs[8], color));
            ico20.Add(new Tri(vecs[3], vecs[8], vecs[9], color));

            // 5 adjacent faces
            ico20.Add(new Tri(vecs[4], vecs[9], vecs[5], color));
            ico20.Add(new Tri(vecs[2], vecs[4], vecs[11], color));
            ico20.Add(new Tri(vecs[6], vecs[2], vecs[10], color));
            ico20.Add(new Tri(vecs[8], vecs[6], vecs[7], color));
            ico20.Add(new Tri(vecs[9], vecs[8], vecs[1], color));
            return(ico20);
        }
        //vMarchCube1 performs the Marching Cubes algorithm on a single cube
        // TODO: Find out if what I am doing in this is correct
        void MarchCube1(int X, int Y, int Z)
        {
            int     iCorner, iVertex, iVertexTest, iEdge, iTriangle, iFlagIndex, iEdgeFlags = 0;
            float   fOffset;
            Vector3 sColor;

            bool[]    afCubeValue  = new bool[8];
            Vertex[]  asEdgeVertex = new Vertex[12];
            Vector3[] asEdgeNorm   = new Vector3[12];

            //Make a local copy of the values at the cube's corners
            for (iVertex = 0; iVertex < 8; iVertex++)
            {
                afCubeValue[iVertex] = Sample(X + (int)a2fVertexOffset[iVertex].X,
                                              Y + (int)a2fVertexOffset[iVertex].Y,
                                              Z + (int)a2fVertexOffset[iVertex].Z);
            }

            //Find which vertices are inside of the surface and which are outside
            iFlagIndex = 0;
            for (iVertexTest = 0; iVertexTest < 8; iVertexTest++)
            {
                if (afCubeValue[iVertexTest])
                {
                    iFlagIndex |= 1 << iVertexTest;
                }
            }

            //Find which edges are intersected by the surface
            iEdgeFlags = m_edgeTable[iFlagIndex];

            //If the cube is entirely inside or outside of the surface, then there will be no intersections
            if (iEdgeFlags == 0)
            {
                return;
            }

            //Find the point of intersection of the surface with each edge
            //Then find the normal to the surface at those points
            for (iEdge = 0; iEdge < 12; iEdge++)
            {
                //if there is an intersection on this edge
                int flagval = (1 << iEdge);
                if ((iEdgeFlags & flagval) == flagval)
                {
                    fOffset = fGetOffset(afCubeValue[a2iEdgeConnection[iEdge][0]] ? 1f : 0f,
                                         afCubeValue[a2iEdgeConnection[iEdge][1]] ? 1f : 0f, 0.5f);

                    asEdgeVertex[iEdge].X = X + (a2fVertexOffset[a2iEdgeConnection[iEdge][0]].X + fOffset * a2fEdgeDirection[iEdge].X);
                    asEdgeVertex[iEdge].Y = Y + (a2fVertexOffset[a2iEdgeConnection[iEdge][0]].Y + fOffset * a2fEdgeDirection[iEdge].Y);
                    asEdgeVertex[iEdge].Z = Z + (a2fVertexOffset[a2iEdgeConnection[iEdge][0]].Z + fOffset * a2fEdgeDirection[iEdge].Z);

                    asEdgeNorm[iEdge] = vGetNormal((int)asEdgeVertex[iEdge].X, (int)asEdgeVertex[iEdge].Y, (int)asEdgeVertex[iEdge].Z);
                }
            }

            //Draw the triangles that were found.  There can be up to five per cube
            for (iTriangle = 0; iTriangle < 5; iTriangle++)
            {
                if (m_triTable[iFlagIndex][3 * iTriangle] < 0)
                {
                    break;
                }
                // Hello I am N3X15 and I am lost
                Vertex[] hurr = new Vertex[3];

                for (iCorner = 0; iCorner < 3; iCorner++)
                {
                    iVertex = m_triTable[iFlagIndex][3 * iTriangle + iCorner];

                    /*
                     * vGetColor(sColor, asEdgeVertex[iVertex], asEdgeNorm[iVertex]);
                     * glColor3f(sColor.fX, sColor.fY, sColor.fZ);
                     * glNormal3f(asEdgeNorm[iVertex].fX,   asEdgeNorm[iVertex].fY,   asEdgeNorm[iVertex].fZ);
                     * glVertex3f(asEdgeVertex[iVertex].fX, asEdgeVertex[iVertex].fY, asEdgeVertex[iVertex].fZ);
                     */
                    hurr[iCorner] = asEdgeVertex[iVertex];
                }
                mMesh.Add(new Triangle(hurr[0], hurr[1], hurr[2]));
            }
        }