Exemplo n.º 1
0
        //Решение Tri
        private void Tri()
        {
            int q, w, e, r;

            if (Int32.TryParse(TriCountBox.Text, out q) && Int32.TryParse(TriMax.Text, out w) && Int32.TryParse(TriMin.Text, out e) && Int32.TryParse(TriModa.Text, out r) && q > 0)
            {
                TriBox.Items.Clear();
                chartTri.Series["Числа"].Points.Clear();
                chartTri.Series["График"].Points.Clear();

                int    x = DateTime.Now.Millisecond;
                int    n = Convert.ToInt32(TriCountBox.Text);
                double min = Convert.ToInt32(TriMin.Text), max = Convert.ToInt32(TriMax.Text), moda = Convert.ToInt32(TriModa.Text);

                if (moda >= max || moda <= min)
                {
                    moda         = Math.Round((min + max) / 2.0);
                    TriModa.Text = Convert.ToString(moda);
                }

                Tri tri = new Tri();
                tri.SolveTri(n, min, max, moda);

                for (int i = 0; i < tri.list.Count; i++)
                {
                    TriBox.Items.Add(tri.list[i]);
                }
                foreach (var i in tri.Dic)
                {
                    chartTri.Series["График"].Points.AddXY(i.Key, i.Value);
                    chartTri.Series["Числа"].Points.AddXY(i.Key, i.Value);
                }
            }
        }
Exemplo n.º 2
0
 public EdgeDistStatus(Edge edge, Tri tri, Vector3 point, float margin)
 {
     _edge                = edge;
     _tri                 = tri;
     _withinMargin        = edge.DistanceTo(point) < margin;
     _withinSegmentBounds = edge.IsWithinSegmentBounds(point);
 }
Exemplo n.º 3
0
        public static MeshData Create(Vertex3[] verticesIn, short[] indices)
        {
            Vector3[] vertices = new Vector3[verticesIn.Length];
            Vector3[] normals  = new Vector3[verticesIn.Length];
            Vector2[] uv       = new Vector2[verticesIn.Length];
            Tri[]     tri      = new Tri[indices.Length / 3];

            for (uint i = 0; i < verticesIn.Length; ++i)
            {
                vertices[i].X = verticesIn[i].x;
                vertices[i].Y = verticesIn[i].y;
                vertices[i].Z = verticesIn[i].z;

                normals[i].X = 0.0f;
                normals[i].Y = 0.0f;
                normals[i].Z = 1.0f;

                uv[i].X = 0;
                uv[i].Y = 0;
            }

            for (int i = 0; i < indices.Length / 3; i += 3)
            {
                MeshPoint p1 = new MeshPoint(3 * i + 0, 3 * i + 0, 3 * i + 0);
                MeshPoint p2 = new MeshPoint(3 * i + 1, 3 * i + 1, 3 * i + 1);
                MeshPoint p3 = new MeshPoint(3 * i + 2, 3 * i + 2, 3 * i + 2);

                tri[i] = new Tri(p1, p2, p3);
            }

            return(new MeshData(vertices, normals, uv, tri));
        }
Exemplo n.º 4
0
        private IEnumerable <Tri> MeshTriangles(MeshComponent mesh)
        {
            if (mesh.Triangles == null || mesh.Triangles.Length == 0)
            {
                yield break;
            }

            float3[] verts = new float3[mesh.Vertices.Length];

            // transform all vertices to clip space
            for (int i = 0; i < verts.Length; i++)
            {
                float4 vClip = MVP * new float4(mesh.Vertices[i], 1.0f);
                vClip    = vClip / vClip.z;
                verts[i] = vClip.xyz;
            }

            for (int i = 0; i < mesh.Triangles.Length; i += 3)
            {
                var tri = new Tri
                {
                    p0 = verts[mesh.Triangles[i]],
                    p1 = verts[mesh.Triangles[i + 1]],
                    p2 = verts[mesh.Triangles[i + 2]],
                };
                if (PointClipped(tri.p0) && PointClipped(tri.p1) && PointClipped(tri.p2))
                {
                    continue;
                }
                yield return(tri);
            }
        }
Exemplo n.º 5
0
        private double3 ReturnTriIntersect(int Exclude, double3 O, double3 D)
        {
            Triangle Tri;

            if (Exclude == 1)
            {
                Tri = new Triangle(B, C, D);
            }
            else if (Exclude == 2)
            {
                Tri = new Triangle(A, C, D);
            }
            else if (Exclude == 3)
            {
                Tri = new Triangle(A, B, D);
            }
            else if (Exclude == 4)
            {
                Tri = new Triangle(A, B, C);
            }
            else
            {
                throw new Exception("Internal Error");
            }
            var t = Tri.Intersection(O, D);

            return(O + t * D);
        }
Exemplo n.º 6
0
        public IList <Tri> SearchForPathBetweenTris(Tri from, Tri to)
        {
            var alreadySeen = new HashSet <Tri>();
            var queue       = new Queue <List <Tri> >();

            var list = new List <Tri>();

            list.Add(from);
            queue.Enqueue(list);

            while (queue.Count > 0)
            {
                var curList = queue.Dequeue();
                var endTri  = curList.Last();

                if (endTri == to)
                {
                    return(curList);
                }

                foreach (var nextTri in endTri.GetAdjacentTris())
                {
                    if (!alreadySeen.Contains(nextTri))
                    {
                        var nextList = new List <Tri>(curList);
                        nextList.Add(nextTri);
                        queue.Enqueue(nextList);
                    }
                }
            }

            return(null);
        }
Exemplo n.º 7
0
        public static void Draw(GraphicsDevice GD)
        {
            Assets.Shader.CurrentTechnique = Assets.Shader.Techniques["Pretransformed"];
            Assets.Shader.Parameters["xWorld"].SetValue(World);

            foreach (EffectPass pass in Assets.Shader.CurrentTechnique.Passes)
            {
                pass.Apply();

                if (Sierpinski_Triangle_Active)
                {
                    foreach (Sierpinski_Triangle_Part Tri in TriParts)
                    {
                        Tri.Draw(GD);
                    }
                }
                else
                {
                    foreach (Koch_snowflake_part flake in SnowflakeParts)
                    {
                        flake.Draw(GD);
                    }
                }
            }
        }
 public void Add(Tri t)
 {
     if (tris != null)
     {
         tris.Add(t);
     }
     else
     {
         if (boundsChildA.Intersects(t.Bounds))
         {
             if (childA == null)
             {
                 childA = new SpatialBinaryTreeNode(level + 1, maxLevels, boundsChildA);
             }
             childA.Add(t);
         }
         if (boundsChildB.Intersects(t.Bounds))
         {
             if (childB == null)
             {
                 childB = new SpatialBinaryTreeNode(level + 1, maxLevels, boundsChildB);
             }
             childB.Add(t);
         }
     }
 }
Exemplo n.º 9
0
        public void Update()
        {
            Ray   pickRay   = MathExtra.CalculateCursorRay(AIGame.camera.ProjectionMatrix, AIGame.camera.ViewMatrix);
            float rayLength = 0f;

            for (int i = 0; i < triangle.Length; i++)
            {
                Tri thisTri = triangle[i];
                if (MathExtra.Intersects(pickRay, thisTri.p1, thisTri.p3, thisTri.p2, thisTri.normal, false, true, out rayLength))
                {
                    Vector3 rayTarget = pickRay.Position + pickRay.Direction * rayLength;
                    groundCursorPosition.X =
                        rayTarget.X / (
                            //heightMap.Size * (heightMap.GridSpacing - 1)) *
                            //(((float)heightMap.Size * ((float)heightMap.GridSpacing - 1)) /
                            Settings.TERRAIN_TEXTURE_SIZE);
                    groundCursorPosition.Y = rayTarget.Y;
                    groundCursorPosition.Z =
                        rayTarget.Z / (
                            // heightMap.Size * (heightMap.GridSpacing - 1)) *
                            //(((float)heightMap.Size * ((float)heightMap.GridSpacing - 1)) /
                            Settings.TERRAIN_TEXTURE_SIZE);
                }
            }
            lastGroundCursorPos = groundCursorPosition;
        }
Exemplo n.º 10
0
 /// <summary>
 /// Sous - tri de <see cref="TriFiltreEditor.Trier(string)"/>
 /// </summary>
 /// <param name="cartes">Cartes uniques non triées</param>
 public void TrierAKA(List <GameObject> Cartes)
 {
     for (int i = 0; i < Cartes.Count; i++)
     {
         for (int j = 0; j < i; j++)
         {
             if ((Cartes[j].GetComponent <Carte>().GetType() == typeof(Sort) ||
                  Cartes[j].GetComponent <Carte>().GetType() == typeof(Assistance)) &&
                 Cartes[i].GetComponent <Carte>().GetType() == typeof(Entite))
             {
                 GameObject Carte = Cartes[i];
                 Cartes[i] = Cartes[j];
                 Cartes[j] = Carte;
             }
             else if ((Cartes[j].GetComponent <Carte>().GetType() == typeof(Entite) &&
                       Cartes[i].GetComponent <Carte>().GetType() == typeof(Entite)) &&
                      Cartes[j].GetComponent <Entite>().CoutAKA > Cartes[i].GetComponent <Entite>().CoutAKA)
             {
                 GameObject Carte = Cartes[i];
                 Cartes[i] = Cartes[j];
                 Cartes[j] = Carte;
             }
         }
     }
     tri = Tri.NOM;
     Debug.Log("La liste a été triée par AKA");
     PutCardsInScrollView("allCards", Cartes, true);
 }
Exemplo n.º 11
0
        public void TriTest()
        {
            var tests = new Dictionary <string, string>();

            //addition
            tests["5 3 8"] = "5+3=8";
            //subtraction
            tests["5 3 2"] = "5-3=2";
            //multiplication
            tests["5 3 15"] = "5*3=15";
            //division
            tests["9 3 3"] = "9/3=3";


            foreach (var item in tests)
            {
                using (StringWriter sw = new StringWriter())
                {
                    Console.SetOut(sw);

                    using (StringReader sr = new StringReader(
                               string.Format(
                                   item.Key)))
                    {
                        Console.SetIn(sr);

                        Tri.Main(null);

                        string expected = item.Value + Environment.NewLine;

                        Assert.Equal(expected, sw.ToString());
                    }
                }
            }
        }
Exemplo n.º 12
0
        public SpatialBinaryTree(Mesh m, int maxLevels, bool outputProgress = false)
        {
            var boundingBox = new BoundingBox(
                new Interval(m.vertices.Min(v => v.x), m.vertices.Max(v => v.x)),
                new Interval(m.vertices.Min(v => v.y), m.vertices.Max(v => v.y)),
                new Interval(m.vertices.Min(v => v.z), m.vertices.Max(v => v.z)));

            root = new SpatialBinaryTreeNode(0, maxLevels, boundingBox);

            var triCount = m.triangles.Length / 3;

            for (var i = 0; i < triCount; i++)
            {
                var v1 = m.vertices[m.triangles[i * 3]];
                var v2 = m.vertices[m.triangles[i * 3 + 1]];
                var v3 = m.vertices[m.triangles[i * 3 + 2]];
                var t  = new Tri(v1, v2, v3);
                Add(t);

                if (triCount > 20 && (i % (triCount / 20) == 0))
                {
                    Debug.Log("Spatial Tree Progress: " + (i + 1) + " / " + triCount);
                }
            }
        }
Exemplo n.º 13
0
 /// <summary>
 /// Sous - tri de <see cref="TriFiltreEditor.Trier(string)"/>
 /// </summary>
 /// <param name="cartes">Cartes uniques non triées. </param>
 public void TrierPuissance(List <GameObject> Cartes)
 {
     for (int i = 0; i < Cartes.Count; i++)
     {
         for (int j = 0; j < i; j++)
         {
             if ((Cartes[j].GetComponent <Carte>().GetType() == typeof(Sort) ||
                  Cartes[j].GetComponent <Carte>().GetType() == typeof(Assistance)) &&
                 Cartes[i].GetComponent <Carte>().GetType() == typeof(Entite))
             {
                 GameObject Carte = Cartes[i];
                 Cartes[i] = Cartes[j];
                 Cartes[j] = Carte;
             }
             else if ((Cartes[j].GetComponent <Carte>().GetType() == typeof(Entite) &&
                       Cartes[i].GetComponent <Carte>().GetType() == typeof(Entite)) &&
                      Cartes[j].GetComponent <Entite>().getPuissance() > Cartes[i].GetComponent <Entite>().getPuissance())
             {
                 GameObject Carte = Cartes[i];
                 Cartes[i] = Cartes[j];
                 Cartes[j] = Carte;
             }
         }
     }
     tri = Tri.PUISSANCE;
     // On doit mettre les autres tris à false
     Debug.Log("La liste a été triée par Puissance");
     PutCardsInScrollView("allCards", Cartes, true);
 }
Exemplo n.º 14
0
    // Tính toán theo hướng của Tri
    private int calTri(Tri tri)
    {
        GameObject curHex = hexMatrix[(int)tri.Pos.x, (int)tri.Pos.y];
        int        res    = curHex.GetComponent <Hex>().Num;

        if (res == 0)
        {
            return(-1);
        }
        while (true)
        {
            curHex = getHex(curHex.GetComponent <Hex>().Pos, (tri.Direction + 3) % 6);
            if (curHex != null)
            {
                if (curHex.GetComponent <Hex>().Num > 0)
                {
                    res += curHex.GetComponent <Hex>().Num;
                }
                else
                {
                    return(-1);
                }
            }
            else
            {
                break;
            }
        }
        return(res);
    }
Exemplo n.º 15
0
        public Sphere(float radius, uint subdivisions, Vec4 color)
        {
            Mesh        ico20 = BuildIcosahedron(radius, color);
            Queue <Tri> tris  = new Queue <Tri>();

            foreach (var item in ico20)
            {
                tris.Enqueue(item);
            }

            uint j = 0;

            while (subdivisions > j)
            {
                for (int i = 0; i < 20 * Math.Pow(4, j); i++)
                {
                    Tri     t     = tris.Dequeue();
                    Vertex3 newV0 = ComputeHalfVertex(t.v0, t.v1, radius);
                    Vertex3 newV1 = ComputeHalfVertex(t.v1, t.v2, radius);
                    Vertex3 newV2 = ComputeHalfVertex(t.v2, t.v0, radius);

                    tris.Enqueue(new Tri(t.v0, newV0, newV2, t.ks, t.kd, t.n));
                    tris.Enqueue(new Tri(t.v1, newV1, newV0, t.ks, t.kd, t.n));
                    tris.Enqueue(new Tri(t.v2, newV2, newV1, t.ks, t.kd, t.n));
                    tris.Enqueue(new Tri(newV0, newV1, newV2, t.ks, t.kd, t.n));
                }
                j++;
            }
            foreach (var item in tris)
            {
                Triangles.Add(item);
            }
        }
Exemplo n.º 16
0
    public MeshBuffers(Device device, TriMesh mesh)
    {
        int vertexCount = mesh.VertexPositions.Count;

        VertexInfo[] vertexInfos = new VertexInfo[vertexCount];
        for (int i = 0; i < vertexCount; ++i)
        {
            vertexInfos[i] = new VertexInfo {
                position = mesh.VertexPositions[i],
                normal   = mesh.VertexNormals[i]
            };
        }
        this.vertexBuffer = Buffer.Create(device, BindFlags.VertexBuffer, vertexInfos);

        int faceCount = mesh.Faces.Count;

        int[] indices = new int[faceCount * 3];
        for (int i = 0; i < faceCount; ++i)
        {
            Tri face = mesh.Faces[i];

            indices[i * 3 + 0] = face.Index0;
            indices[i * 3 + 1] = face.Index1;
            indices[i * 3 + 2] = face.Index2;
        }

        this.indexBuffer = Buffer.Create(device, BindFlags.IndexBuffer, indices);
        this.indexCount  = indices.Length;
    }
Exemplo n.º 17
0
        static void Main()
        {
            Tri  t    = new Tri();
            bool text = t.Res();

            Console.WriteLine(text == true ? "Точка принадлежит треугольнику!" : "Точка снаружи");
            Console.ReadKey();
        }
Exemplo n.º 18
0
        public void TestTriDate()
        {
            ObservableCollection <Oeuvre> triées = Tri.TriDate(CréationOeurves());

            for (int i = 0; i < triées.Count - 1; i++)
            {
                Assert.IsTrue(triées[i].Sortie.CompareTo(triées[i + 1].Sortie) <= 0);
            }
        }
Exemplo n.º 19
0
 private IEnumerable <Tri> DrawNewPolys(IEnumerable <EdgeDistStatus> edges, Vert vert, HashSet <Tri> triList)
 {
     foreach (EdgeDistStatus status in edges)
     {
         Tri newTri = TriFromEdgeToPoint(status.Edge, vert, -status.Tri.Normal);
         triList.Add(newTri);
         yield return(newTri);
     }
 }
Exemplo n.º 20
0
 public Triangle(Tri t)
 {
     v0 = t.v0;
     v1 = t.v1;
     v2 = t.v2;
     ks = t.ks;
     kd = t.kd;
     n  = t.n;
 }
Exemplo n.º 21
0
        public void TestTriCroissant()
        {
            ObservableCollection <Oeuvre> triées = Tri.TriCroissant(CréationOeurves());

            for (int i = 0; i < triées.Count - 1; i++)
            {
                Assert.IsTrue(triées[i].Nom.CompareTo(triées[i + 1].Nom) <= 0);
            }
        }
Exemplo n.º 22
0
        public void RemoveTri(Tri t)
        {
            // First remove all references to this tri from its points.
            foreach (Point p in t.Points)
            {
                p.Tris.Remove(t);
            }

            Tris.Remove(t);
        }
Exemplo n.º 23
0
        /// <summary>
        /// Filtrer les entités par type d'élémentaires.
        /// </summary>
        /// <param name="filtre"></param>
        public void FiltreElementaire(string filtre)
        {
            // Dans le cas du filtre d'une entité élementaire
            if (filtre == "TERRE" || filtre == "EAU" || filtre == "FEU" || filtre == "AIR")
            {
                Entite.Element elementFiltre = Entite.Element.NONE;
                switch (filtre)
                {
                case "TERRE":
                    elementFiltre = Entite.Element.TERRE;
                    break;

                case "FEU":
                    elementFiltre = Entite.Element.FEU;
                    break;

                case "EAU":
                    elementFiltre = Entite.Element.EAU;
                    break;

                case "AIR":
                    elementFiltre = Entite.Element.AIR;
                    break;

                default:
                    Debug.LogError("Ce cas ne peut pas arriver");
                    break;
                }
                ResetFiltres();
                filtreElementaire = elementFiltre;
                PutCardsInScrollView("allCards", CartesCorrespondantesElement(elementFiltre), true);
            }
            else if (filtre == "ASTRAL" || filtre == "MALEFIQUE")
            {
                Entite.Ascendance ascendanceFiltre = Entite.Ascendance.NONE;
                if (filtre == "ASTRAL")
                {
                    ascendanceFiltre = Entite.Ascendance.ASTRALE;
                }
                else
                {
                    ascendanceFiltre = Entite.Ascendance.MALEFIQUE;
                }
                ResetFiltres();
                filtreAscendance = ascendanceFiltre;
                PutCardsInScrollView("allCards", CartesCorrespondantesAscendance(ascendanceFiltre), true);
            }
            else
            {
                throw new Exception("Ce filtre n'existe pas");
            }

            ListeFiltreElementaires.SetActive(false);
            tri = Tri.NONE;
        }
Exemplo n.º 24
0
    // constructor 2
    public Tri(Vector3 posA, Vector3 posB, Vector3 posC, int currentDiv, Tri parent)
    {
        curDiv = currentDiv;

        pos1 = posA;
        pos2 = posB;
        pos3 = posC;

        parentTri = parent;
        myChunk   = parentTri.myChunk;
        maxDiv    = PlanetCreator.maxSubdivisions;
    }
Exemplo n.º 25
0
    void AddTri(Vector3 a, Vector3 b, Vector3 c)
    {
        int curVertCount = newVerticies.Count;

        newVerticies.Add(Tri.offsetAtPos(a));
        newVerticies.Add(Tri.offsetAtPos(b));
        newVerticies.Add(Tri.offsetAtPos(c));

        newTriangles.Add(curVertCount + 0);
        newTriangles.Add(curVertCount + 1);
        newTriangles.Add(curVertCount + 2);
    }
Exemplo n.º 26
0
        public void UnshareVert(Tri tri, Vert newVert)
        {
            tris.Remove(tri);
            newVert.tris.Add(tri);

            foreach (var v in unsharedVerts)
            {
                if (!v.unsharedVerts.Contains(newVert))
                {
                    v.unsharedVerts.Add(newVert);
                }
            }
            newVert.unsharedVerts.AddRange(unsharedVerts);
        }
Exemplo n.º 27
0
    private void Start()
    {
        mesh = mf.mesh;

        masterTri = new Tri(
            Tri.offsetAtPos(startPointA),
            Tri.offsetAtPos(startPointB),
            Tri.offsetAtPos(startPointC),
            0, null, this);

        smallestTris.Add(masterTri);

        UpdateMesh();
    }
Exemplo n.º 28
0
    //Initialize the mesh with a plane
    public void InitPlane(float scale)
    {
        Tri t1 = new Tri();        // = Tri;
        Tri t2 = new Tri();        // = Tri;

        t1.v1  = new Vector3(-scale, -scale);
        t1.v2  = new Vector3(-scale, scale);
        t1.v3  = new Vector3(scale, scale);
        t1.uv1 = new Vector2(0, 0);
        t1.uv2 = new Vector2(0, 1);
        t1.uv3 = new Vector2(1, 1);

        t2.v1  = new Vector3(scale, scale);
        t2.v2  = new Vector3(scale, -scale);
        t2.v3  = new Vector3(-scale, -scale);
        t2.uv1 = new Vector2(1, 1);
        t2.uv2 = new Vector2(1, 0);
        t2.uv3 = new Vector2(0, 0);

        //t1.vel = new Vector2(-0.1f,0.1f);
        //t2.vel = new Vector2(0.1f,-0.1f);
        t1.vel = new Vector2(0, 0);
        t2.vel = new Vector2(0, 0);

        this.tris = new List <Tri>();
        tris.Add(t1);
        tris.Add(t2);


        //Vector2[] verts2 = {new Vector3(-1,-1), new Vector3(-1,1), new Vector3(1,1), new Vector3(1,-1)};
        //int[] tris2 = {0,1,2,2,3,0};

//		tris.Clear();
//		tris.Add(new int[]{0,1,2});
//		tris.Add(new int[]{2,3,0});
//
//		verts = verts2;
//
//		trivels = new List<Vector2>();
//		for (int i = 0; i < tris.Count; i++)
//		{
//			trivels.Add(new Vector2(0,0));
//		}

        //Debug.Log("verts len: " + verts.Length);
        //Debug.Log("tris len: " + tris.Count);

        RefreshMesh();
    }
Exemplo n.º 29
0
        public async Task <List <Candidature> > PostTrier(Tri t)
        {
            using (var httpClient = new HttpClient(_clientHandler))
            {
                StringContent content = new StringContent(JsonConvert.SerializeObject(t), Encoding.UTF8, "application/json");

                using (var response = await httpClient.PostAsync("https://localhost:44304/api/Trier", content))
                {
                    string apiResponse = await response.Content.ReadAsStringAsync();

                    liste = JsonConvert.DeserializeObject <List <Candidature> >(apiResponse);
                }
            }
            return(liste);
        }
Exemplo n.º 30
0
        public Vector3?IsIntersected(Ray ray)
        {
            float rayLength = 0f;

            for (int i = 0; i < triangle.Length; i++)
            {
                Tri thisTri = triangle[i];
                if (MathExtra.Intersects(ray, thisTri.p1, thisTri.p3, thisTri.p2, thisTri.normal, false, true, out rayLength))
                {
                    Vector3 rayTarget = ray.Position + ray.Direction * rayLength;
                    return(rayTarget);
                }
            }
            return(null);
        }
Exemplo n.º 31
0
            public bool Res()
            {
                Tri t = new Tri();

                xp = new int[] { 0, 2, 4 }; // массив х вершин треугольника
                yp = new int[] { 0, 2, 2 }; // массив  у вершин треугольника
                x = 2;  // координата x точки 
                y = 1; // координата y точки 
                npol = xp.Length;
                int res = t.Triangle(npol, xp, yp, x, y);

                if (res == 1) // точка внутри
                {
                    return true;
                }
                return false; // иначе - снаружи
            }
Exemplo n.º 32
0
        public static void Weld(int precision, Vector3[] vertices, Tri[] tris)
        {
            int p = (int)Math.Pow((double)10, (double)precision);

            Dictionary<Vector3, int> pointHash = new Dictionary<Vector3, int>();
            Dictionary<int, int> remapList = new Dictionary<int, int>();
            for (int i = 0; i < vertices.Length; i++)
            {
                Vector3 vertex = vertices[i];
                vertex.X = (float)((int)(vertex.X * p));
                vertex.Y = (float)((int)(vertex.Y * p));
                vertex.Z = (float)((int)(vertex.Z * p));

                int existing_index;
                if (!pointHash.TryGetValue(vertex, out existing_index))
                {
                    pointHash.Add(vertex, i);
                }
                else
                {
                    remapList.Add(i, existing_index);
                }
            }

            foreach (Tri tri in tris)
            {
                int existing_index;
                if (remapList.TryGetValue(tri.P1.Vertex, out existing_index))
                {
                    tri.P1.Vertex = existing_index;
                }
                if (remapList.TryGetValue(tri.P2.Vertex, out existing_index))
                {
                    tri.P2.Vertex = existing_index;
                }
                if (remapList.TryGetValue(tri.P3.Vertex, out existing_index))
                {
                    tri.P3.Vertex = existing_index;
                }
            }
        }
Exemplo n.º 33
0
        private void SetUpIndices()
        {
            indices = new short[divisions.X * divisions.Y * 6];
            int indiceID = 0;
            
            triangle = new Tri[divisions.X * divisions.Y * 2];
            int triID = 0;

            int[] index = new int[6];

            for (int y = 0; y < divisions.Y - 1; y++)
            {
                for (int x = 0; x < divisions.X - 1; x++)
                {
                    index[0] = x + y * divisions.X;
                    index[1] = x + (y + 1) * divisions.X;
                    index[2] = (x + 1) + y * divisions.X;
                    index[3] = (x + 1) + (y + 1) * divisions.X;

                    indices[indiceID] = (short)(index[0]);
                    indices[indiceID + 1] = (short)(index[1]);
                    indices[indiceID + 2] = (short)(index[2]);
                    
                    indices[indiceID + 3] = (short)(index[2]);
                    indices[indiceID + 4] = (short)(index[1]);
                    indices[indiceID + 5] = (short)(index[3]);

                    //Create ray collision triangles
                    triangle[triID] = new Tri(triID, vertices[index[0]].Position, vertices[index[1]].Position, vertices[index[2]].Position);
                    triangle[triID + 1] = new Tri(triID, vertices[index[2]].Position, vertices[index[1]].Position, vertices[index[3]].Position);

                    //Update vertices normals
                    vertices[index[0]].Normal = triangle[triID].normal;
                    vertices[index[1]].Normal = (triangle[triID].normal + triangle[triID + 1].normal) / 2;
                    vertices[index[2]].Normal = (triangle[triID].normal + triangle[triID + 1].normal) / 2;
                    vertices[index[3]].Normal = triangle[triID + 1].normal;

                    indiceID += 6;
                    triID += 2;
                }
            }
        }
        // Takes an array of points and returns an array of triangles.
        // The points form an arbitrary polygon.
        static Tri[] Triangulate(MeshPoint[] ps)
        {
            List<Tri> ts = new List<Tri>();
            if (ps.Length < 3)
            {
                throw new Exception("Invalid shape!  Must have >2 points");
            }

            MeshPoint lastButOne = ps[1];
            MeshPoint lastButTwo = ps[0];
            for (int i = 2; i < ps.Length; i++)
            {
                Tri t = new Tri(lastButTwo, lastButOne, ps[i]);
                lastButOne = ps[i];
                lastButTwo = ps[i - 1];
                ts.Add(t);
            }
            return ts.ToArray();
        }
Exemplo n.º 35
0
    //Initialize the mesh with a plane
    public void InitPlane(float scale)
    {
        Tri t1 = new Tri();// = Tri;
        Tri t2 = new Tri();// = Tri;

        t1.v1 = new Vector3(-scale,-scale);
        t1.v2 = new Vector3(-scale,scale);
        t1.v3 = new Vector3(scale,scale);
        t1.uv1 = new Vector2(0,0);
        t1.uv2 = new Vector2(0,1);
        t1.uv3 = new Vector2(1,1);

        t2.v1 = new Vector3(scale,scale);
        t2.v2 = new Vector3(scale,-scale);
        t2.v3 = new Vector3(-scale,-scale);
        t2.uv1 = new Vector2(1,1);
        t2.uv2 = new Vector2(1,0);
        t2.uv3 = new Vector2(0,0);

        //t1.vel = new Vector2(-0.1f,0.1f);
        //t2.vel = new Vector2(0.1f,-0.1f);
        t1.vel = new Vector2(0,0);
        t2.vel = new Vector2(0,0);

        this.tris = new List<Tri>();
        tris.Add(t1);
        tris.Add(t2);

        //Vector2[] verts2 = {new Vector3(-1,-1), new Vector3(-1,1), new Vector3(1,1), new Vector3(1,-1)};
        //int[] tris2 = {0,1,2,2,3,0};

        //		tris.Clear();
        //		tris.Add(new int[]{0,1,2});
        //		tris.Add(new int[]{2,3,0});
        //
        //		verts = verts2;
        //
        //		trivels = new List<Vector2>();
        //		for (int i = 0; i < tris.Count; i++)
        //		{
        //			trivels.Add(new Vector2(0,0));
        //		}

        //Debug.Log("verts len: " + verts.Length);
        //Debug.Log("tris len: " + tris.Count);

        RefreshMesh();
    }
Exemplo n.º 36
0
    public void Slice(Vector2 a, Vector2 b)
    {
        if (this.tris.Count > maxPieces) return;
        //Debug.Log(this.tris.Count + " " + maxPieces);

        //Debug.Log("Slice begin. Tris len: " + tris.Count);

        Vector2 s = b-a;
        List<Tri> removethese = new List<Tri>();
        List<Tri> addthese = new List<Tri>();
        foreach (Tri tri in tris)
        {
            //slice this triangle

            //intersect edge 1
            Vector2 t1a = tri.v1;
            Vector2 t1s = tri.v2-tri.v1;
            float t1 = LineLineIntersectReturnT(t1a, t1s, a, s);
            bool isect1valid = t1 > 0 && t1 < 1;
            //intersect edge 2
            Vector2 t2a = tri.v2;
            Vector2 t2s = tri.v3-tri.v2;
            float t2 = LineLineIntersectReturnT(t2a, t2s, a, s);
            bool isect2valid = t2 > 0 && t2 < 1;
            //intersect edge 3
            Vector2 t3a = tri.v3;
            Vector2 t3s = tri.v1-tri.v3;
            float t3 = LineLineIntersectReturnT(t3a, t3s, a, s);
            bool isect3valid = t3 > 0 && t3 < 1;

            int numvalid = (isect1valid?1:0) + (isect3valid?1:0) + (isect2valid?1:0);
            if (numvalid == 2)
            {
                Vector2 isect1 = t1a + t1 * t1s;
                Vector2 isect2 = t2a + t2 * t2s;
                Vector2 isect3 = t3a + t3 * t3s;

                //figure out which vertex of the triangle is shared by the two intersected edges
                Vector2 common;
                Vector2 p1, p2, o1, o2;
                Vector2 commonuv, o1uv, o2uv;
                if (isect1valid && isect2valid)
                {
                    common = tri.v2;
                    p1 = isect1;
                    p2 = isect2;
                    o1 = tri.v1;
                    o2 = tri.v3;
                    commonuv = tri.uv2;
                    o1uv = tri.uv1;
                    o2uv = tri.uv3;
                }
                else if (isect2valid && isect3valid)
                {
                    common = tri.v3;
                    p1 = isect2;
                    p2 = isect3;
                    o1 = tri.v2;
                    o2 = tri.v1;
                    commonuv = tri.uv3;
                    o1uv = tri.uv2;
                    o2uv = tri.uv1;
                }
                else //if (isect3valid && isect1valid)
                {
                    common = tri.v1;
                    p1 = isect3;
                    p2 = isect1;
                    o1 = tri.v3;
                    o2 = tri.v2;
                    commonuv = tri.uv1;
                    o1uv = tri.uv3;
                    o2uv = tri.uv2;
                }

                //create new triangles
                Tri nt1 = new Tri();
                Tri nt2 = new Tri();
                Tri nt3 = new Tri();

                nt1.v1 = p1;
                nt1.v2 = common;
                nt1.v3 = p2;

                nt2.v1 = o1;
                nt2.v2 = p1;
                nt2.v3 = p2;

                nt3.v1 = p2;
                nt3.v2 = o2;
                nt3.v3 = o1;

                //UVs
                Vector2 o1_common = common - o1;
                Vector2 o2_common = common - o2;
                float p1_onto_o1_common = Vector2.Dot(p1-o1, o1_common.normalized) / o1_common.magnitude;
                Vector2 p1uv = o1uv + p1_onto_o1_common * (commonuv - o1uv);
                float p2_onto_o2_common = Vector2.Dot(p2-o2, o2_common.normalized) / o2_common.magnitude;
                Vector2 p2uv = o2uv + p2_onto_o2_common * (commonuv - o2uv);

                nt1.uv1 = p1uv;
                nt1.uv2 = commonuv;
                nt1.uv3 = p2uv;
                //Debug.Log("p1_onto_o1_common: " + p1_onto_o1_common);
                //Debug.Log("p2_onto_o2_common: " + p2_onto_o2_common);
                //Debug.Log("nt1 uvs: " + p1uv + " " + commonuv + " " + p2uv + " " + o1uv + " " + o2uv);
                //Debug.Log("nt1 pos: " + p1 + " " + common + " " + p2 + " " + o1 + " " + o2);

                nt2.uv1 = o1uv;
                nt2.uv2 = p1uv;
                nt2.uv3 = p2uv;

                nt3.uv1 = p2uv;
                nt3.uv2 = o2uv;
                nt3.uv3 = o1uv;

                //Give them velocities
                //Vector2 velcommon = (common - (p1 + (p2-p1) * 0.5f));
                //Vector2 nearest = PointNearestPointOnLine(common, a, s);
                //Vector2 velcommon = (common - nearest).normalized;
                Vector2 sPerp = new Vector2(-s.y, s.x);
                //Debug.Log(Vector2.Dot(s, sperp));
                Vector2 velcommon = sPerp.normalized;
                float veladjust = 1.0f;
                if (Vector2.Dot((common - a), sPerp) > 0)
                {
                    veladjust = 1.0f;
                }
                else
                {
                    veladjust = -1.0f;
                }
                nt1.vel = this.driftFactor * velcommon * veladjust + tri.vel;
                nt2.vel = this.driftFactor * -velcommon * veladjust + tri.vel;
                nt3.vel = nt2.vel;

                addthese.Add(nt1);
                addthese.Add(nt2);
                addthese.Add(nt3);

                //tag old ones for removal
                removethese.Add(tri);

            }//if there was a valid slice made
        }//loop over all triangles to check slices

        //Remove tris tagged for removal
        foreach (Tri tri in removethese)
        {
            this.tris.Remove(tri);
        }

        //Add tris created by slice
        foreach (Tri tri in addthese)
        {
            this.tris.Add(tri);
        }

        //Debug.Log("Slice end. Tris len: " + tris.Count + " Removed: " + removethese.Count + " Added: " + addthese.Count);
        //Debug.Log(this.ToString());
    }
Exemplo n.º 37
0
        private ContactResult? GroundIntersection(Vector3 rayStart, Vector3 rayEnd)
        {
            double[,] heightfield = World.Heightmap.GetDoubles();
            List<ContactResult> contacts = new List<ContactResult>();

            double min = 2048.0;
            double max = 0.0;

            // Find the min and max of the heightfield
            for (int x = 0 ; x < World.Heightmap.Width ; x++)
            {
                for (int y = 0 ; y < World.Heightmap.Height ; y++)
                {
                    if (heightfield[x, y] > max)
                        max = heightfield[x, y];
                    if (heightfield[x, y] < min)
                        min = heightfield[x, y];
                }
            }


            // A ray extends past rayEnd, but doesn't go back before
            // rayStart. If the start is above the highest point of the ground
            // and the ray goes up, we can't hit the ground. Ever.
            if (rayStart.Z > max && rayEnd.Z >= rayStart.Z)
                return null;

            // Same for going down
            if (rayStart.Z < min && rayEnd.Z <= rayStart.Z)
                return null;

            List<Tri> trilist = new List<Tri>();

            // Create our triangle list
            for (int x = 1 ; x < World.Heightmap.Width ; x++)
            {
                for (int y = 1 ; y < World.Heightmap.Height ; y++)
                {
                    Tri t1 = new Tri();
                    Tri t2 = new Tri();

                    Vector3 p1 = new Vector3(x-1, y-1, (float)heightfield[x-1, y-1]);
                    Vector3 p2 = new Vector3(x, y-1, (float)heightfield[x, y-1]);
                    Vector3 p3 = new Vector3(x, y, (float)heightfield[x, y]);
                    Vector3 p4 = new Vector3(x-1, y, (float)heightfield[x-1, y]);

                    t1.p1 = p1;
                    t1.p2 = p2;
                    t1.p3 = p3;

                    t2.p1 = p3;
                    t2.p2 = p4;
                    t2.p3 = p1;

                    trilist.Add(t1);
                    trilist.Add(t2);
                }
            }

            // Ray direction
            Vector3 rayDirection = rayEnd - rayStart;

            foreach (Tri t in trilist)
            {
                // Compute triangle plane normal and edges
                Vector3 u = t.p2 - t.p1;
                Vector3 v = t.p3 - t.p1;
                Vector3 n = Vector3.Cross(u, v);

                if (n == Vector3.Zero)
                    continue;

                Vector3 w0 = rayStart - t.p1;
                double a = -Vector3.Dot(n, w0);
                double b = Vector3.Dot(n, rayDirection);

                // Not intersecting the plane, or in plane (same thing)
                // Ignoring this MAY cause the ground to not be detected
                // sometimes
                if (Math.Abs(b) < 0.000001)
                    continue;

                double r = a / b;

                // ray points away from plane
                if (r < 0.0)
                    continue;

                Vector3 ip = rayStart + Vector3.Multiply(rayDirection, (float)r);

                float uu = Vector3.Dot(u, u);
                float uv = Vector3.Dot(u, v);
                float vv = Vector3.Dot(v, v);
                Vector3 w = ip - t.p1;
                float wu = Vector3.Dot(w, u);
                float wv = Vector3.Dot(w, v);
                float d = uv * uv - uu * vv;

                float cs = (uv * wv - vv * wu) / d;
                if (cs < 0 || cs > 1.0)
                    continue;
                float ct = (uv * wu - uu * wv) / d;
                if (ct < 0 || (cs + ct) > 1.0)
                    continue;

                // Add contact point
                ContactResult result = new ContactResult ();
                result.ConsumerID = 0;
                result.Depth = Vector3.Distance(rayStart, ip);
                result.Normal = n;
                result.Pos = ip;

                contacts.Add(result);
            }

            if (contacts.Count == 0)
                return null;

            contacts.Sort(delegate(ContactResult a, ContactResult b)
            {
                return (int)(a.Depth - b.Depth);
            });

            return contacts[0];
        }
Exemplo n.º 38
0
        public void SetUpCollision(int tID, int x, int y)
        {
            triangle[tID] = new Tri();
            triangle[tID].p1 = GetPosition(x, y);
            triangle[tID].p2 = GetPosition(x, y + 1);
            triangle[tID].p3 = GetPosition(x + 1, y);
            triangle[tID].normal = MathExtra.GetNormal(triangle[tID].p1, triangle[tID].p2, triangle[tID].p3);
            triangle[tID].id = tID;

            triangle[tID + 1] = new Tri();
            triangle[tID + 1].p1 = GetPosition(x + 1, y);
            triangle[tID + 1].p2 = GetPosition(x, y + 1);
            triangle[tID + 1].p3 = GetPosition(x + 1, y + 1);
            triangle[tID + 1].normal = MathExtra.GetNormal(triangle[tID + 1].p1, triangle[tID + 1].p2, triangle[tID + 1].p3);
            triangle[tID + 1].id = tID + 1;
        }
Exemplo n.º 39
0
        /// <summary>
        /// Helper to add HeightMap squares into Tri (triangle) List and adjust bounding box.
        /// </summary>
        private void AddTrisFromHeightmap(float xPos, float yPos, ref List<Tri> triangles, ref float zLower, ref float zUpper)
        {
            int xInt = (int)xPos;
            int yInt = (int)yPos;

            // Corner 1 of 1x1 rectangle
            int x = Util.Clamp<int>(xInt+1, 0, World.Heightmap.Width - 1);
            int y = Util.Clamp<int>(yInt+1, 0, World.Heightmap.Height - 1);
            Vector3 pos1 = new Vector3(x, y, (float)World.Heightmap[x, y]);
            // Adjust bounding box
            zLower = Math.Min(zLower, pos1.Z);
            zUpper = Math.Max(zUpper, pos1.Z);

            // Corner 2 of 1x1 rectangle
            x = Util.Clamp<int>(xInt, 0, World.Heightmap.Width - 1);
            y = Util.Clamp<int>(yInt+1, 0, World.Heightmap.Height - 1);
            Vector3 pos2 = new Vector3(x, y, (float)World.Heightmap[x, y]);
            // Adjust bounding box
            zLower = Math.Min(zLower, pos2.Z);
            zUpper = Math.Max(zUpper, pos2.Z);

            // Corner 3 of 1x1 rectangle
            x = Util.Clamp<int>(xInt, 0, World.Heightmap.Width - 1);
            y = Util.Clamp<int>(yInt, 0, World.Heightmap.Height - 1);
            Vector3 pos3 = new Vector3(x, y, (float)World.Heightmap[x, y]);
            // Adjust bounding box
            zLower = Math.Min(zLower, pos3.Z);
            zUpper = Math.Max(zUpper, pos3.Z);

            // Corner 4 of 1x1 rectangle
            x = Util.Clamp<int>(xInt+1, 0, World.Heightmap.Width - 1);
            y = Util.Clamp<int>(yInt, 0, World.Heightmap.Height - 1);
            Vector3 pos4 = new Vector3(x, y, (float)World.Heightmap[x, y]);
            // Adjust bounding box
            zLower = Math.Min(zLower, pos4.Z);
            zUpper = Math.Max(zUpper, pos4.Z);

            // Add triangle 1
            Tri triangle1 = new Tri();
            triangle1.p1 = pos1;
            triangle1.p2 = pos2;
            triangle1.p3 = pos3;
            triangles.Add(triangle1);

            // Add triangle 2
            Tri triangle2 = new Tri();
            triangle2.p1 = pos3;
            triangle2.p2 = pos4;
            triangle2.p3 = pos1;
            triangles.Add(triangle2);
        }
Exemplo n.º 40
0
        /// <summary>
        /// Helper to find ray hit in triangle
        /// </summary>
        bool HitRayInTri(Tri triProj, Vector3 pos1RayProj, Vector3 vecRayProj, out Vector3 posHitProj, out Vector3 normalProj)
        {
            float tol = m_floatToleranceInCastRay;
            posHitProj = Vector3.Zero;

            // Calculate triangle edge vectors
            Vector3 vec1Proj = triProj.p2 - triProj.p1;
            Vector3 vec2Proj = triProj.p3 - triProj.p2;
            Vector3 vec3Proj = triProj.p1 - triProj.p3;

            // Calculate triangle normal
            normalProj = Vector3.Cross(vec1Proj, vec2Proj);

            // Skip if degenerate triangle or ray parallell with triangle plane
            float divisor = Vector3.Dot(vecRayProj, normalProj);
            if (Math.Abs(divisor) < tol)
                return false;

            // Skip if exit and not configured to detect
            if (divisor > tol && !m_detectExitsInCastRay)
                return false;

            // Skip if outside ray ends
            float distanceProj = Vector3.Dot(triProj.p1 - pos1RayProj, normalProj) / divisor;
            if (distanceProj < -tol || distanceProj > 1 + tol)
                return false;

            // Calculate hit position in triangle
            posHitProj = pos1RayProj + vecRayProj * distanceProj;

            // Skip if outside triangle bounding box
            Vector3 triProjMin = Vector3.Min(Vector3.Min(triProj.p1, triProj.p2), triProj.p3);
            Vector3 triProjMax = Vector3.Max(Vector3.Max(triProj.p1, triProj.p2), triProj.p3);
            if (
                posHitProj.X < triProjMin.X - tol || posHitProj.Y < triProjMin.Y - tol || posHitProj.Z < triProjMin.Z - tol ||
                posHitProj.X > triProjMax.X + tol || posHitProj.Y > triProjMax.Y + tol || posHitProj.Z > triProjMax.Z + tol
            )
                return false;

            // Skip if outside triangle
            if (
                Vector3.Dot(Vector3.Cross(vec1Proj, normalProj), posHitProj - triProj.p1) > tol ||
                Vector3.Dot(Vector3.Cross(vec2Proj, normalProj), posHitProj - triProj.p2) > tol ||
                Vector3.Dot(Vector3.Cross(vec3Proj, normalProj), posHitProj - triProj.p3) > tol
            )
                 return false;

            // Return hit
            return true;
        }
Exemplo n.º 41
0
        /// <summary>
        /// Helper to add ray hit in a Tri (triangle).
        /// </summary>
        private void AddRayInTri(Tri triProj, RayTrans rayTrans, ref List<RayHit> rayHits)
        {
            // Check for hit in triangle
            Vector3 posHitProj;
            Vector3 normalProj;
            if (HitRayInTri(triProj, rayTrans.Position1RayProj, rayTrans.VectorRayProj, out posHitProj, out normalProj))
            {
                // Hack to circumvent ghost face bug in PrimMesher by removing hits in (ghost) face plane through shape center
                if (Math.Abs(Vector3.Dot(posHitProj, normalProj)) < m_floatToleranceInCastRay && !rayTrans.ShapeNeedsEnds)
                    return;

                // Transform hit and normal to region coordinate system
                Vector3 posHit = rayTrans.PositionPart + (posHitProj * rayTrans.ScalePart) * rayTrans.RotationPart;
                Vector3 normal = Vector3.Normalize((normalProj * rayTrans.ScalePart) * rayTrans.RotationPart);

                // Remove duplicate hits at triangle intersections
                float distance = Vector3.Distance(rayTrans.Position1Ray, posHit);
                for (int i = rayHits.Count - 1; i >= 0; i--)
                {
                    if (rayHits[i].PartId != rayTrans.PartId)
                        break;
                    if (Math.Abs(rayHits[i].Distance - distance) < m_floatTolerance2InCastRay)
                        return;
                }

                // Build result data set
                RayHit rayHit = new RayHit();
                rayHit.PartId = rayTrans.PartId;
                rayHit.GroupId = rayTrans.GroupId;
                rayHit.Link = rayTrans.Link;
                rayHit.Position = posHit;
                rayHit.Normal = normal;
                rayHit.Distance = distance;
                rayHits.Add(rayHit);
            }
        }
Exemplo n.º 42
0
 /// <summary>
 /// Helper to parse FacetedMesh for ray hits.
 /// </summary>
 private void AddRayInFacetedMesh(FacetedMesh mesh, RayTrans rayTrans, ref List<RayHit> rayHits)
 {
     if (mesh != null)
     {
         foreach (Face face in mesh.Faces)
         {
             for (int i = 0; i < face.Indices.Count; i += 3)
             {
                 Tri triangle = new Tri();
                 triangle.p1 = face.Vertices[face.Indices[i]].Position;
                 triangle.p2 = face.Vertices[face.Indices[i + 1]].Position;
                 triangle.p3 = face.Vertices[face.Indices[i + 2]].Position;
                 AddRayInTri(triangle, rayTrans, ref rayHits);
             }
         }
     }
 }
Exemplo n.º 43
0
		private void SetUpCollision( int indiceID, int tID, int x, int y ) {
			triangle[ tID ] = new Tri();
			triangle[ tID ].p1 = heightmapVertices[ x + y * size.X ].Position;
			triangle[ tID ].p2 = heightmapVertices[ x + ( y + 1 ) * size.X ].Position;
			triangle[ tID ].p3 = heightmapVertices[ ( x + 1 ) + y * size.X ].Position;
			triangle[ tID ].normal = MathExtra.GetNormal( triangle[ tID ].p1, triangle[ tID ].p2, triangle[ tID ].p3 );
			triangle[ tID ].id = indiceID / 6 - 1;

			triangle[ tID + 1 ] = new Tri();
			triangle[ tID + 1 ].p1 = heightmapVertices[ ( x + 1 ) + y * size.X ].Position;
			triangle[ tID + 1 ].p2 = heightmapVertices[ x + ( y + 1 ) * size.X ].Position;
			triangle[ tID + 1 ].p3 = heightmapVertices[ ( x + 1 ) + ( y + 1 ) * size.X ].Position;
			triangle[ tID + 1 ].normal = MathExtra.GetNormal( triangle[ tID + 1 ].p1, triangle[ tID + 1 ].p2, triangle[ tID + 1 ].p3 );
			triangle[ tID + 1 ].id = indiceID / 6;
		}
Exemplo n.º 44
0
		private void UpdateCollisions( List<Point> verticiesToUpdate ) {
			int tID = 0;
			int indiceID = 0;
			List<int> TriangleIDs = new List<int>();

			foreach( Point vec in verticiesToUpdate ) {
				int x = vec.X;
				int y = vec.Y;

				if( x > 0 && y > 0 && x < size.X - 1 && y < size.Y - 1 ) {
					tID = ( x + y * ( size.X - 1 ) ) * 2;
					indiceID = ( ( x + y * ( size.X - 1 ) ) + 1 ) * 6;

					triangle[ tID ] = new Tri();
					triangle[ tID ].p1 = heightmapVertices[ x + y * size.X ].Position;
					triangle[ tID ].p2 = heightmapVertices[ x + ( y + 1 ) * size.X ].Position;
					triangle[ tID ].p3 = heightmapVertices[ ( x + 1 ) + y * size.X ].Position;
					triangle[ tID ].normal = MathExtra.GetNormal( triangle[ tID ].p1, triangle[ tID ].p2, triangle[ tID ].p3 );
					triangle[ tID ].id = indiceID / 6 - 1;

					triangle[ tID + 1 ] = new Tri();
					triangle[ tID + 1 ].p1 = heightmapVertices[ ( x + 1 ) + y * size.X ].Position;
					triangle[ tID + 1 ].p2 = heightmapVertices[ x + ( y + 1 ) * size.X ].Position;
					triangle[ tID + 1 ].p3 = heightmapVertices[ ( x + 1 ) + ( y + 1 ) * size.X ].Position;
					triangle[ tID + 1 ].normal = MathExtra.GetNormal( triangle[ tID + 1 ].p1, triangle[ tID + 1 ].p2, triangle[ tID + 1 ].p3 );
					triangle[ tID + 1 ].id = indiceID / 6;

					TriangleIDs.Add( tID );
					TriangleIDs.Add( tID + 1 );

					quadTree.UpdateBoundingBox( quadTree.NodeList[ 0 ], tID );
					quadTree.UpdateBoundingBox( quadTree.NodeList[ 0 ], tID + 1 );
				}
			}

		}
Exemplo n.º 45
-20
        static void Main()
        {

            Tri t = new Tri();
            bool text = t.Res();
            Console.WriteLine(text == true ? "Точка принадлежит треугольнику!" : "Точка снаружи");
            Console.ReadKey();

        }