/// <summary>
        /// Picking sobre un triangulo
        /// </summary>
        public bool pickTriangle(out TgcTriangle triangle, out int triangleIndex)
        {
            pickingRay.updateRay();
            Vector3 segmentA = pickingRay.Ray.Origin;
            Vector3 segmentB = segmentA + Vector3.Scale(pickingRay.Ray.Direction, 10000f);
            float   minDist  = float.MaxValue;

            triangle      = null;
            triangleIndex = -1;

            //Buscar la menor colision rayo-triangulo
            for (int i = 0; i < triangles.Count; i++)
            {
                TgcTriangle tri = triangles[i];

                float   t;
                Vector3 uvw;
                Vector3 col;
                if (TgcCollisionUtils.intersectLineTriangle(segmentA, segmentB, tri.A, tri.B, tri.C, out uvw, out t, out col))
                {
                    float dist = Vector3.Length(col - segmentA);
                    if (dist < minDist)
                    {
                        minDist       = dist;
                        triangle      = tri;
                        triangleIndex = i;
                    }
                }
            }

            return(triangle != null);
        }
Example #2
0
        /// <summary>
        /// Crear a partir de un mesh
        /// </summary>
        public static TgcTriangleArray fromMesh(TgcMesh mesh)
        {
            TgcTriangleArray triangleArray = new TgcTriangleArray();

            Vector3[] vertices = mesh.getVertexPositions();
            int triCount = vertices.Length / 3;
            List<TgcTriangle> triangles = new List<TgcTriangle>(triCount);
            for (int i = 0; i < triCount; i++)
            {
                Vector3 v1 = vertices[i * 3];
                Vector3 v2 = vertices[i * 3 + 1];
                Vector3 v3 = vertices[i * 3 + 2];

                TgcTriangle t = new TgcTriangle();
                t.A = v1;
                t.B = v2;
                t.C = v3;
                t.Color = Color.Red;
                t.updateValues();
                triangles.Add(t);
            }

            triangleArray.triangles.AddRange(triangles);
            return triangleArray;
        }
        /// <summary>
        /// Crear a partir de un mesh
        /// </summary>
        public static TgcTriangleArray fromMesh(TgcMesh mesh)
        {
            TgcTriangleArray triangleArray = new TgcTriangleArray();

            Vector3[]          vertices  = mesh.getVertexPositions();
            int                triCount  = vertices.Length / 3;
            List <TgcTriangle> triangles = new List <TgcTriangle>(triCount);

            for (int i = 0; i < triCount; i++)
            {
                Vector3 v1 = vertices[i * 3];
                Vector3 v2 = vertices[i * 3 + 1];
                Vector3 v3 = vertices[i * 3 + 2];

                TgcTriangle t = new TgcTriangle();
                t.A     = v1;
                t.B     = v2;
                t.C     = v3;
                t.Color = Color.Red;
                t.updateValues();
                triangles.Add(t);
            }

            triangleArray.triangles.AddRange(triangles);
            return(triangleArray);
        }
        public override void init()
        {
            Device d3dDevice = GuiController.Instance.D3dDevice;

            //Cargar un mesh
            TgcSceneLoader loader = new TgcSceneLoader();
            TgcScene scene = loader.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Cimientos\\PilarEgipcio\\PilarEgipcio-TgcScene.xml");
            mesh = scene.Meshes[0];

            //Obtener los vértices del mesh (esta operacion es lenta, copia de la GPU a la CPU, no hacer a cada rato)
            Vector3[] vertices = mesh.getVertexPositions();

            //Iterar sobre todos los vertices y construir triangulos, normales y planos
            int triCount = vertices.Length / 3;
            triangles = new List<TgcTriangle>(triCount);
            normals = new List<TgcArrow>();
            planes = new List<TgcQuad>();
            for (int i = 0; i < triCount; i++)
            {
                //Obtenemos los 3 vertices del triangulo
                Vector3 a = vertices[i * 3];
                Vector3 b = vertices[i * 3 + 1];
                Vector3 c = vertices[i * 3 + 2];

                //Obtener normal del triangulo. El orden influye en si obtenemos el vector normal hacia adentro o hacia afuera del mesh
                Vector3 normal = Vector3.Cross(c - a, b - a);
                normal.Normalize();

                //Crear plano que contiene el triangulo a partir un vertice y la normal
                Plane plane = Plane.FromPointNormal(a, normal);

                //Calcular el centro del triangulo. Hay muchos tipos de centros para un triangulo (http://www.mathopenref.com/trianglecenters.html)
                //Aca calculamos el mas simple
                Vector3 center = Vector3.Scale(a + b + c, 1 / 3f);

                ///////////// Creacion de elementos para poder dibujar a pantalla (propios de este ejemplo) ///////////////

                //Crear un quad (pequeño plano) con la clase TgcQuad para poder dibujar el plano que contiene al triangulo
                TgcQuad quad = new TgcQuad();
                quad.Center = center;
                quad.Normal = normal;
                quad.Color = adaptColorRandom(Color.DarkGreen);
                quad.Size = new Vector2(10, 10);
                quad.updateValues();
                planes.Add(quad);

                //Creamos una flecha con la clase TgcArrow para poder dibujar la normal (la normal la estiramos un poco para que se pueda ver)
                normals.Add(TgcArrow.fromDirection(center, Vector3.Scale(normal, 10f)));

                //Creamos la clase TgcTriangle que es un helper para dibujar triangulos sueltos
                TgcTriangle t = new TgcTriangle();
                t.A = a;
                t.B = b;
                t.C = c;
                t.Color = adaptColorRandom(Color.Red);
                t.updateValues();
                triangles.Add(t);
            }

            //Modifiers
            GuiController.Instance.Modifiers.addBoolean("mesh", "mesh", true);
            GuiController.Instance.Modifiers.addBoolean("triangles", "triangles", true);
            GuiController.Instance.Modifiers.addBoolean("normals", "normals", true);
            GuiController.Instance.Modifiers.addBoolean("planes", "planes", false);

            //Camera
            GuiController.Instance.RotCamera.Enable = true;
            GuiController.Instance.RotCamera.targetObject(mesh.BoundingBox);
        }
Example #5
0
        /// <summary>
        /// Picking sobre un triangulo
        /// </summary>
        public bool pickTriangle(out TgcTriangle triangle, out int triangleIndex)
        {
            pickingRay.updateRay();
            Vector3 segmentA = pickingRay.Ray.Origin;
            Vector3 segmentB = segmentA + Vector3.Scale(pickingRay.Ray.Direction, 10000f);
            float minDist = float.MaxValue;
            triangle = null;
            triangleIndex = -1;

            //Buscar la menor colision rayo-triangulo
            for (int i = 0; i < triangles.Count; i++)
            {
                TgcTriangle tri = triangles[i];

                float t;
                Vector3 uvw;
                Vector3 col;
                if (TgcCollisionUtils.intersectLineTriangle(segmentA, segmentB, tri.A, tri.B, tri.C, out uvw, out t, out col))
                {
                    float dist = Vector3.Length(col - segmentA);
                    if (dist < minDist)
                    {
                        minDist = dist;
                        triangle = tri;
                        triangleIndex = i;
                    }
                }
            }

            return triangle != null;
        }