void Torus::ObjectSpace_AppendAllIntersections(
     const Vector& vantage, 
     const Vector& direction, 
     IntersectionList& intersectionList) const
 {
     double u[4];
     const int numSolutions = SolveIntersections(vantage, direction, u);
     for (int i=0; i < numSolutions; ++i)
     {
         Intersection intersection;
         const Vector disp = u[i] * direction;
         intersection.point = vantage + disp;
         intersection.distanceSquared = disp.MagnitudeSquared();
         intersection.surfaceNormal = SurfaceNormal(intersection.point);
         intersection.solid = this;
         intersectionList.push_back(intersection);
     }
 }
    void Spheroid::ObjectSpace_AppendAllIntersections(
        const Vector& vantage, 
        const Vector& direction, 
        IntersectionList& intersectionList) const
    {
        double u[2];
        const int numSolutions = Algebra::SolveQuadraticEquation(
            b2*c2*direction.x*direction.x + a2*c2*direction.y*direction.y + a2*b2*direction.z*direction.z,
            2.0*(b2*c2*vantage.x*direction.x + a2*c2*vantage.y*direction.y + a2*b2*vantage.z*direction.z),
            b2*c2*vantage.x*vantage.x + a2*c2*vantage.y*vantage.y + a2*b2*vantage.z*vantage.z - a2*b2*c2,
            u
        );

        for (int i=0; i < numSolutions; ++i)
        {
            if (u[i] > EPSILON)
            {
                Intersection intersection;
                Vector displacement = u[i] * direction;
                intersection.distanceSquared = displacement.MagnitudeSquared();
                intersection.point = vantage + displacement;

                // The surface normal vector was calculated by expressing the spheroid as a 
                // function z(x,y) = sqrt(1 - (x/a)^2 - (y/b)^2),
                // taking partial derivatives dz/dx = (c*c*x)/(a*a*z), dz/dy = (c*c*y)/(b*b*z), 
                // and using these to calculate the vectors <1, 0, dz/dx> and <0, 1, dy,dz>.
                // The normalized cross product of these two vectors yields the surface normal vector.
                const double x = intersection.point.x;
                const double y = intersection.point.y;
                const double z = intersection.point.z;

                // But we need to handle special cases when z is very close to 0.
                if (fabs(z) <= EPSILON)
                {
                    if (fabs(x) <= EPSILON)
                    {
                        // The equation devolves to (y^2)/(b^2) = 1, or y = +/- b.
                        intersection.surfaceNormal = Vector(0.0, ((y > 0.0) ? 1.0 : -1.0), 0.0);
                    }
                    else
                    {
                        // The equation devolves to an ellipse on the xy plane : 
                        // (x^2)/(a^2) + (y^2)/(b^2) = 1.
                        intersection.surfaceNormal = Vector(-1.0, -(a2*y)/(b2*x), 0.0).UnitVector();
                    }
                }
                else
                {
                    intersection.surfaceNormal = Vector((c2*x)/(a2*z), (c2*y)/(b2*z), 1.0).UnitVector();
                }

                // Handle special cases with polarity: the polarity of the components of
                // the surface normal vector must match that of the <x,y,z> intersection point,
                // because the surface normal vector always points (roughly) away from the vantage, just
                // like any point on the surface of the spheroid does.

                if (x * intersection.surfaceNormal.x < 0.0)     // negative product means opposite polarities
                {
                    intersection.surfaceNormal.x *= -1.0;
                }

                if (y * intersection.surfaceNormal.y < 0.0)     // negative product means opposite polarities
                {
                    intersection.surfaceNormal.y *= -1.0;
                }

                if (z * intersection.surfaceNormal.z < 0.0)     // negative product means opposite polarities
                {
                    intersection.surfaceNormal.z *= -1.0;
                }

                intersection.solid = this;

                intersectionList.push_back(intersection);
            }
        }
    }
    void TriangleMesh::AppendAllIntersections(
        const Vector& vantage, 
        const Vector& direction, 
        IntersectionList& intersectionList) const
    {
        // Iterate through all the triangles in this solid object, 
        // looking for every intersection.
        TriangleList::const_iterator iter = triangleList.begin();
        TriangleList::const_iterator end  = triangleList.end();
        for (; iter != end; ++iter)
        {
            const Triangle& tri = *iter;
            const Vector& aPoint = pointList[tri.a];
            const Vector& bPoint = pointList[tri.b];
            const Vector& cPoint = pointList[tri.c];

            // The variables u, v, w are deliberately left 
            // uninitialized for efficiency; they are only 
            // assigned values if we find an intersection.
            double u, v, w;     

            // Sometimes we have to try more than one ordering of the points (A,B,C) 
            // in order to get a valid solution to the intersection equations.
            // Take advantage of C++ short-circuit boolean or "||" operator:
            // as soon as one of the function calls returns true, we don't call any more.
            if (AttemptPlaneIntersection(vantage, direction, aPoint, bPoint, cPoint, u, v, w) ||
                AttemptPlaneIntersection(vantage, direction, bPoint, cPoint, aPoint, u, v, w) ||
                AttemptPlaneIntersection(vantage, direction, cPoint, aPoint, bPoint, u, v, w))
            {
                // We found an intersection of the direction with the plane that passes through the points (A,B,C).
                // Figure out whether the intersection point is inside the triangle (A,B,C) or outside it.
                // We are interested only in intersections that are inside the triangle.
                // The trick here is that the values v,w are fractions that will be 0..1 along the
                // line segments AB and BC (or whichever ordered triple of points we found the solution for).
                // If we just checked that both v and w are in the range 0..1, we would be finding
                // intersections with a parallelogram ABCD, where D is the fourth point that completes the
                // parallelogram whose other vertices are ABC.
                // But checking instead that v + w <= 1.0 constrains the set of points
                // to the interior or border of the triangle ABC.
                if ((v >= 0.0) && (w >= 0.0) && (v + w <= 1.0) && (u >= EPSILON))
                {
                    // We have found an intersection with one of the triangular facets!
                    // Also determine whether the intersection point is in "front" of the vantage (positively along the direction)
                    // by checking for (u >= EPSILON).  Note that we allow for a little roundoff error by checking
                    // against EPSILON instead of 0.0, because this method is called using vantage = a point on this surface,
                    // in order to calculate surface lighting, and we don't want to act like the surface is shading itself!
                    if (u >= EPSILON)
                    {
                        // We have found a new intersection to be added to the list.
                        const Vector displacement = u * direction;

                        Intersection intersection;
                        intersection.distanceSquared = displacement.MagnitudeSquared();
                        intersection.point = vantage + displacement;
                        intersection.surfaceNormal = NormalVector(tri);
                        intersection.solid = this;
                        intersection.context = &tri;   // remember which triangle we hit, for SurfaceOptics().

                        intersectionList.push_back(intersection);
                    }
                }
            }
        }
    }
    void Cuboid::ObjectSpace_AppendAllIntersections(
        const Vector& vantage, 
        const Vector& direction, 
        IntersectionList& intersectionList) const
    {
        double u;
        Intersection intersection;
        Vector displacement;

        // Check for intersections with left/right faces: x = +a or x = -a.
        if (fabs(direction.x) > EPSILON)
        {
            // right face (x = +a)
            u = (a - vantage.x) / direction.x;
            if (u > EPSILON)
            {
                displacement = u * direction;
                intersection.point = vantage + displacement;
                if (ObjectSpace_Contains(intersection.point))
                {
                    intersection.distanceSquared = displacement.MagnitudeSquared();
                    intersection.surfaceNormal = Vector(+1.0, 0.0, 0.0);
                    intersection.solid = this;
                    intersection.tag = "right face";
                    intersectionList.push_back(intersection);
                }
            }

            // left face (x = -a)
            u = (-a - vantage.x) / direction.x;
            if (u > EPSILON)
            {
                displacement = u * direction;
                intersection.point = vantage + displacement;
                if (ObjectSpace_Contains(intersection.point))
                {
                    intersection.distanceSquared = displacement.MagnitudeSquared();
                    intersection.surfaceNormal = Vector(-1.0, 0.0, 0.0);
                    intersection.solid = this;
                    intersection.tag = "left face";
                    intersectionList.push_back(intersection);
                }
            }
        }

        // Check for intersections with front/back faces: y = -b or y = +b.
        if (fabs(direction.y) > EPSILON)
        {
            // front face (y = +b)
            u = (b - vantage.y) / direction.y;
            if (u > EPSILON)
            {
                displacement = u * direction;
                intersection.point = vantage + displacement;
                if (ObjectSpace_Contains(intersection.point))
                {
                    intersection.distanceSquared = displacement.MagnitudeSquared();
                    intersection.surfaceNormal = Vector(0.0, +1.0, 0.0);
                    intersection.solid = this;
                    intersection.tag = "front face";
                    intersectionList.push_back(intersection);
                }
            }

            // back face (y = -b)
            u = (-b - vantage.y) / direction.y;
            if (u > EPSILON)
            {
                displacement = u * direction;
                intersection.point = vantage + displacement;
                if (ObjectSpace_Contains(intersection.point))
                {
                    intersection.distanceSquared = displacement.MagnitudeSquared();
                    intersection.surfaceNormal = Vector(0.0, -1.0, 0.0);
                    intersection.solid = this;
                    intersection.tag = "back face";
                    intersectionList.push_back(intersection);
                }
            }
        }

        // Check for intersections with top/bottom faces: z = -c or z = +c.
        if (fabs(direction.z) > EPSILON)
        {
            // top face (z = +c)
            u = (c - vantage.z) / direction.z;
            if (u > EPSILON)
            {
                displacement = u * direction;
                intersection.point = vantage + displacement;
                if (ObjectSpace_Contains(intersection.point))
                {
                    intersection.distanceSquared = displacement.MagnitudeSquared();
                    intersection.surfaceNormal = Vector(0.0, 0.0, +1.0);
                    intersection.solid = this;
                    intersection.tag = "top face";
                    intersectionList.push_back(intersection);
                }
            }

            // bottom face (z = -c)
            u = (-c - vantage.z) / direction.z;
            if (u > EPSILON)
            {
                displacement = u * direction;
                intersection.point = vantage + displacement;
                if (ObjectSpace_Contains(intersection.point))
                {
                    intersection.distanceSquared = displacement.MagnitudeSquared();
                    intersection.surfaceNormal = Vector(0.0, 0.0, -1.0);
                    intersection.solid = this;
                    intersection.tag = "bottom face";
                    intersectionList.push_back(intersection);
                }
            }
        }
    }
Exemple #5
0
IntersectionList Sphere::AllIntersections(const Ray& inray) const
{
	Ray ray = LorentzTransform(inray, RefFrame);

#define D ray.Direction
#define O ray.Origin
#define S InitialPosition
#define V RefFrame.Velocity

	double r1, r2;

	{
		double tmp181 = (D.x*O.x);
		double tmp180 = (-tmp181);
		double tmp179 = (D.y*O.y);
		double tmp149 = (D.z*O.z);
		double tmp176 = (D.x*S.x);
		double tmp174 = (D.y*S.y);
		double tmp148 = (D.z*S.z);
		double tmp139 = (O.t*V.x);
		double tmp171 = (D.x*tmp139);
		double tmp146 = (O.x*V.x);
		double tmp137 = (S.t*V.x);
		double tmp168 = (D.x*tmp137);
		double tmp91 = (S.x*V.x);
		double tmp12 = V.x*V.x;
		double tmp143 = (O.t*tmp12);
		double tmp85 = (S.t*tmp12);
		double tmp57 = (O.t*V.y);
		double tmp163 = (D.y*tmp57);
		double tmp133 = (O.y*V.y);
		double tmp55 = (S.t*V.y);
		double tmp160 = (D.y*tmp55);
		double tmp69 = (S.y*V.y);
		double tmp7 = V.y*V.y;
		double tmp130 = (O.t*tmp7);
		double tmp63 = (S.t*tmp7);
		double tmp122 = (O.t*V.z);
		double tmp121 = (D.z*tmp122);
		double tmp50 = (O.z*V.z);
		double tmp46 = (S.t*V.z);
		double tmp118 = (D.z*tmp46);
		double tmp39 = (S.z*V.z);
		double tmp2 = V.z*V.z;
		double tmp115 = (O.t*tmp2);
		double tmp32 = (S.t*tmp2);
		double tmp147 = (tmp149 - tmp148);
		double tmp145 = (tmp147 - tmp146);
		double tmp144 = (tmp145 + tmp91);
		double tmp142 = (tmp144 - tmp143);
		double tmp141 = (tmp142 + tmp85);
		double tmp140 = (O.x - S.x);
		double tmp138 = (tmp140 + tmp139);
		double tmp136 = (tmp138 - tmp137);
		double tmp135 = (D.x*tmp136);
		double tmp134 = (tmp141 + tmp135);
		double tmp132 = (tmp134 - tmp133);
		double tmp131 = (tmp132 + tmp69);
		double tmp129 = (tmp131 - tmp130);
		double tmp128 = (tmp129 + tmp63);
		double tmp127 = (O.y - S.y);
		double tmp126 = (tmp127 + tmp57);
		double tmp125 = (tmp126 - tmp55);
		double tmp124 = (D.y*tmp125);
		double tmp123 = (tmp128 + tmp124);
		double tmp120 = (tmp123 + tmp121);
		double tmp119 = (tmp120 - tmp50);
		double tmp117 = (tmp119 - tmp118);
		double tmp116 = (tmp117 + tmp39);
		double tmp114 = (tmp116 - tmp115);
		double tmp113 = (tmp114 + tmp32);
		double tmp112 = tmp113*tmp113;
		double tmp111 = (4 * tmp112);
		double tmp110 = O.x*O.x;
		double tmp109 = O.y*O.y;
		double tmp108 = (tmp110 + tmp109);
		double tmp107 = O.z*O.z;
		double tmp106 = (tmp108 + tmp107);
		double tmp105 = Radius * Radius;
		double tmp104 = (tmp106 - tmp105);
		double tmp103 = S.x*S.x;
		double tmp102 = (tmp104 + tmp103);
		double tmp101 = S.y*S.y;
		double tmp100 = (tmp102 + tmp101);
		double tmp99 = (O.z*S.z);
		double tmp98 = (2 * tmp99);
		double tmp97 = (tmp100 - tmp98);
		double tmp96 = S.z*S.z;
		double tmp95 = (tmp97 + tmp96);
		double tmp94 = (O.t*tmp91);
		double tmp93 = (2 * tmp94);
		double tmp92 = (tmp95 - tmp93);
		double tmp90 = (S.t*tmp91);
		double tmp89 = (2 * tmp90);
		double tmp88 = (tmp92 + tmp89);
		double tmp35 = O.t*O.t;
		double tmp87 = (tmp35*tmp12);
		double tmp86 = (tmp88 + tmp87);
		double tmp84 = (O.t*tmp85);
		double tmp83 = (2 * tmp84);
		double tmp82 = (tmp86 - tmp83);
		double tmp28 = S.t*S.t;
		double tmp81 = (tmp28*tmp12);
		double tmp80 = (tmp82 + tmp81);
		double tmp79 = (-O.t);
		double tmp78 = (tmp79 + S.t);
		double tmp77 = (tmp78*V.x);
		double tmp76 = (S.x + tmp77);
		double tmp75 = (O.x*tmp76);
		double tmp74 = (2 * tmp75);
		double tmp73 = (tmp80 - tmp74);
		double tmp72 = (O.t*tmp69);
		double tmp71 = (2 * tmp72);
		double tmp70 = (tmp73 - tmp71);
		double tmp68 = (S.t*tmp69);
		double tmp67 = (2 * tmp68);
		double tmp66 = (tmp70 + tmp67);
		double tmp65 = (tmp35*tmp7);
		double tmp64 = (tmp66 + tmp65);
		double tmp62 = (O.t*tmp63);
		double tmp61 = (2 * tmp62);
		double tmp60 = (tmp64 - tmp61);
		double tmp59 = (tmp28*tmp7);
		double tmp58 = (tmp60 + tmp59);
		double tmp56 = (S.y - tmp57);
		double tmp54 = (tmp56 + tmp55);
		double tmp53 = (O.y*tmp54);
		double tmp52 = (2 * tmp53);
		double tmp51 = (tmp58 - tmp52);
		double tmp49 = (O.t*tmp50);
		double tmp48 = (2 * tmp49);
		double tmp47 = (tmp51 + tmp48);
		double tmp45 = (O.z*tmp46);
		double tmp44 = (2 * tmp45);
		double tmp43 = (tmp47 - tmp44);
		double tmp42 = (O.t*tmp39);
		double tmp41 = (2 * tmp42);
		double tmp40 = (tmp43 - tmp41);
		double tmp38 = (S.t*tmp39);
		double tmp37 = (2 * tmp38);
		double tmp36 = (tmp40 + tmp37);
		double tmp34 = (tmp35*tmp2);
		double tmp33 = (tmp36 + tmp34);
		double tmp31 = (O.t*tmp32);
		double tmp30 = (2 * tmp31);
		double tmp29 = (tmp33 - tmp30);
		double tmp27 = (tmp28*tmp2);
		double tmp26 = (tmp29 + tmp27);
		double tmp20 = D.x*D.x;
		double tmp19 = D.y*D.y;
		double tmp18 = (tmp20 + tmp19);
		double tmp17 = D.z*D.z;
		double tmp16 = (tmp18 + tmp17);
		double tmp15 = (D.x*V.x);
		double tmp14 = (2 * tmp15);
		double tmp13 = (tmp16 - tmp14);
		double tmp11 = (tmp13 + tmp12);
		double tmp10 = (D.y*V.y);
		double tmp9 = (2 * tmp10);
		double tmp8 = (tmp11 - tmp9);
		double tmp6 = (tmp8 + tmp7);
		double tmp5 = (D.z*V.z);
		double tmp4 = (2 * tmp5);
		double tmp3 = (tmp6 - tmp4);
		double tmp1 = (tmp3 + tmp2);
		double tmp25 = (tmp1*tmp26);
		double tmp24 = (4 * tmp25);
		double tmp23 = (tmp111 - tmp24);

		if (tmp23 < 0.0)
			//Determinant is less than 0 (No solutions)
			return IntersectionList();

		double tmp22 = sqrt(tmp23);
		double tmp178 = (tmp180 - tmp179);
		double tmp177 = (tmp178 - tmp149);
		double tmp175 = (tmp177 + tmp176);
		double tmp173 = (tmp175 + tmp174);
		double tmp172 = (tmp173 + tmp148);
		double tmp170 = (tmp172 - tmp171);
		double tmp169 = (tmp170 + tmp146);
		double tmp167 = (tmp169 + tmp168);
		double tmp166 = (tmp167 - tmp91);
		double tmp165 = (tmp166 + tmp143);
		double tmp164 = (tmp165 - tmp85);
		double tmp162 = (tmp164 - tmp163);
		double tmp161 = (tmp162 + tmp133);
		double tmp159 = (tmp161 + tmp160);
		double tmp158 = (tmp159 - tmp69);
		double tmp157 = (tmp158 + tmp130);
		double tmp156 = (tmp157 - tmp63);
		double tmp155 = (tmp156 - tmp121);
		double tmp154 = (tmp155 + tmp50);
		double tmp153 = (tmp154 + tmp118);
		double tmp152 = (tmp153 - tmp39);
		double tmp151 = (tmp152 + tmp115);
		double tmp150 = (tmp151 - tmp32);
		double tmp21 = (tmp22 / 2.);
		r2 = ((tmp150 + tmp21) / tmp1);
		r1 = ((tmp150 - tmp21) / tmp1);

	}

#undef D
#undef O
#undef S
#undef V

	IntersectionList lst;
	Intersection isect;
	isect.SurfaceVel = Vector3d::zero();
	isect.RefFrame = RefFrame;
	isect.Object = ObjectRef(this);
	isect.Colour = ColourSource;
	isect.IncomingDir = ray.Direction;
	{
		isect.Position = ray.Origin + ray.GetFourVelocity() * r1;
		Vector3d PosAtTime = subvec<3>(InitialPosition) + RefFrame.Velocity * (InitialPosition.t - isect.Position.t);
		isect.Normal = normalize(subvec<3>(isect.Position) - PosAtTime);
		lst.push_back(isect);
	}
	{
		isect.Position = ray.Origin + ray.GetFourVelocity() * r2;
		Vector3d PosAtTime = subvec<3>(InitialPosition) + RefFrame.Velocity * (InitialPosition.t - isect.Position.t);
		isect.Normal = normalize(subvec<3>(isect.Position) - PosAtTime);
		lst.push_back(isect);
	}
	return lst;
}