public bool IntersectsTriangle(Triangle3D triangle, out Triangle3DIntersectInfo intersectInfo) { intersectInfo = new Triangle3DIntersectInfo(); if (triangle.Normal.IsAlignedWith(Normal)) { return(false); } float t; List <Segment3D> otherTriSegments = triangle.GetSegments(); var firstTriIntersectionPoints = new List <Vector3>(); foreach (var segment in otherTriSegments) { Ray3D ray = new Ray3D(segment.StartPoint, segment.EndPoint); if (Raycast(ray, out t)) { firstTriIntersectionPoints.Add(ray.GetPoint(t)); } } List <Segment3D> thisTriSegments = GetSegments(); var secondTriIntersectionPoints = new List <Vector3>(); foreach (var segment in thisTriSegments) { Ray3D ray = new Ray3D(segment.StartPoint, segment.EndPoint); if (triangle.Raycast(ray, out t)) { secondTriIntersectionPoints.Add(ray.GetPoint(t)); } } if (firstTriIntersectionPoints.Count != 0 || secondTriIntersectionPoints.Count != 0) { intersectInfo = new Triangle3DIntersectInfo(this, triangle, firstTriIntersectionPoints, secondTriIntersectionPoints); return(true); } return(false); }
/// <summary> /// Performs a ray cast against the mesh tree and returns an instance of the 'MeshRayHit' /// class which holds information about the ray hit. The method returns the hit which is /// closest to the ray origin. If no triangle was hit, the method returns null. /// </summary> public MeshRayHit Raycast(Ray ray, TransformMatrix meshTransformMatrix) { // If the tree was not yet build, we need to build it because we need // the triangle information in order to perform the raycast. if (!_wasBuilt) { Build(); } // When the sphere tree is constructed it is constructed in the mesh local space (i.e. it takes // no position/rotation/scale into account). This is required because a mesh can be shared by // lots of different objects each with its own transform data. This is why we need the mes matrix // parameter. It allows us to transform the ray in the mesh local space and perform our tests there. Ray meshLocalSpaceRay = ray.InverseTransform(meshTransformMatrix.ToMatrix4x4x); // First collect all terminal nodes which are intersected by this ray. If no nodes // are intersected, we will return null. List <SphereTreeNodeRayHit <MeshSphereTreeTriangle> > nodeRayHits = _sphereTree.RaycastAll(meshLocalSpaceRay); if (nodeRayHits.Count == 0) { return(null); } // We now have to loop thorugh all intersected nodes and find the triangle whose // intersection point is closest to the ray origin. float minT = float.MaxValue; Triangle3D closestTriangle = null; int indexOfClosestTriangle = -1; Vector3 closestHitPoint = Vector3.zero; foreach (var nodeRayHit in nodeRayHits) { // Retrieve the data associated with the node and construct the mesh triangle instance MeshSphereTreeTriangle sphereTreeTriangle = nodeRayHit.HitNode.Data; Triangle3D meshTriangle = _octave3DMesh.GetTriangle(sphereTreeTriangle.TriangleIndex); // Check if the ray intersects the trianlge which resides in the node float hitEnter; if (meshTriangle.Raycast(meshLocalSpaceRay, out hitEnter)) { // The trianlge is intersected by the ray, but we also have to ensure that the // intersection point is closer than what we have found so far. If it is, we // store all relevant information. if (hitEnter < minT) { minT = hitEnter; closestTriangle = meshTriangle; indexOfClosestTriangle = sphereTreeTriangle.TriangleIndex; closestHitPoint = meshLocalSpaceRay.GetPoint(hitEnter); } } } // If we found the closest triangle, we can construct the ray hit instance and return it. // Otherwise we return null. This can happen when the ray intersects the triangle node // spheres, but the triangles themselves. if (closestTriangle != null) { // We have worked in mesh local space up until this point, but we want to return the // hit info in world space, so we have to transform the hit data accordingly. closestHitPoint = meshTransformMatrix.MultiplyPoint(closestHitPoint); minT = (ray.origin - closestHitPoint).magnitude; Vector3 worldNormal = meshTransformMatrix.MultiplyVector(closestTriangle.Normal); return(new MeshRayHit(ray, minT, _octave3DMesh, indexOfClosestTriangle, closestHitPoint, worldNormal, meshTransformMatrix)); } else { return(null); } }