C++ Intersection::SetTextureCoordinates方法代码示例

bool PlaneIntersector<real>::Intersect( const Plane<real>* plane, const Ray<real>& ray, Intersection<real>& oIntersection )
{
    const Vector3<real>& origin = ray.GetOrigin();
    const Vector3<real>& direction = ray.GetDirection();

    // Do not perform intersection if the direction of the ray is degenerated relative to the plane
    if ( fabs( direction.Y() ) > EPS )
    {
        // Compute the intersection point and see if it's inside the plane bounds
        real t = -origin.Y() / direction.Y();
        Vector3<real> intersectionPoint = origin + t * direction;
        bool isInsideXBounds = ( fabs( intersectionPoint.X() ) < plane->GetSizeX() * 0.5 ) ? true : false;
        bool isInsideZBounds = ( fabs( intersectionPoint.Z() ) < plane->GetSizeZ() * 0.5 ) ? true : false;

        // If the ray intersect and the intersection is in front
        if ( ( t > 0 ) && isInsideXBounds && isInsideZBounds )
        {
            oIntersection.SetPosition( intersectionPoint );
            oIntersection.SetNormal( Vector3<real>( 0, -sign<real>( direction.Y() ), 0 ) );
            oIntersection.IsInside( false );

            // Compute texture coodinates as (z=-0.5 => u=0 and x=-0.5 => v=0)
            real u = ( intersectionPoint.Z() + plane->GetSizeZ() * 0.5 ) / plane->GetSizeZ();
            real v = ( intersectionPoint.X() + plane->GetSizeX() * 0.5 ) / plane->GetSizeX();
            oIntersection.SetTextureCoordinates( Vector3<real>( u, v, 0 ) );

            return true;
        }
    }

    return false;
}

bool SphereIntersector<real>::Intersect( const Sphere<real>* sphere, const Ray<real>& ray, Intersection<real>& oIntersection )
{
	// Compute the equation corresponding to x²+y²+z²=0 with p+t*d to obtain a quadratic equation
	real a = ray.GetDirection().SquaredLength();
	real b = 2.0 * ray.GetDirection() * ray.GetOrigin();
	real c = ray.GetOrigin().SquaredLength() - sphere->GetRadius() * sphere->GetRadius();

	real discriminant = b*b - 4*a*c;

	// Discriminant >= 0 => the must be at least one intersection
	if ( discriminant >= 0 )
	{
		// Compute the two potential intersections and only keep the nearest
		real sqrtDisc = sqrt( discriminant );
		real t = 0;
		real t1 = ( -b - sqrtDisc ) / ( 2.0 * a );
		real t2 = ( -b + sqrtDisc ) / ( 2.0 * a );

		if ( t1 >= 0 )
		{
			t = t1;
			oIntersection.IsInside( false );
		}
		else if ( t2 >= 0 )
		{
			t = t2;
			oIntersection.IsInside( true );
		}
		else
			return false;

		oIntersection.SetPosition( ray.GetOrigin() + t * ray.GetDirection() );
		oIntersection.SetNormal( oIntersection.GetPosition().Normalized() );
		oIntersection.SetTextureCoordinates( oIntersection.GetPosition().Normalized() );

		// The normal must be flipped to coincide with the hit direction
		if ( oIntersection.IsInside() )
			oIntersection.SetNormal( -oIntersection.GetNormal() );

		return true;
	}

	return false;
}

bool CylinderIntersector<real>::Intersect( const Cylinder<real>* cylinder, const Ray<real>& ray, Intersection<real>& oIntersection )
{
	real nearestDistance = std::numeric_limits<real>::max();
	real distance = 0;
	bool hasIntersection = false;

	////////////////////////////////////////////
	//////////////////IFT 3355//////////////////
	////////////////////////////////////////////
	//Ici, vous calculerez l'intersection entre
	//le rayon "ray" et le cylindre "cylinder"
	//Pensez à initialiser les quatre attributs
	//de oIntersection (retourné par référence)
	//correctement si une intersection est trouvée.
	////////////////////////////////////////////
	//////////////////IFT 3355//////////////////
	////////////////////////////////////////////

    real halfHeight = cylinder->GetHeight() / 2;
    real radius = cylinder->GetRadius();

    // Intersection with extremeties.
    Vector3<real> extremeties[2] = {
        Vector3<real>(0, halfHeight, 0),
        Vector3<real>(0, -halfHeight, 0),
    };

    for (int k = 0; k < 2; ++k) {
        Vector3<real> plane = extremeties[k];
        real denom = ray.GetDirection() * plane;
	    bool intersectsPlane = fabs(denom) > EPS;

	    // Ray intersects with the extremety.
	    if (intersectsPlane) {
            // Intersection position on the infinite plane.
	        real t = ((plane - ray.GetOrigin()) * plane) / denom;
	        Vector3<real> intersectionPos = ray.GetOrigin() + t * ray.GetDirection();
	        // Ray intersects in the window.
            if ((plane - intersectionPos).Length() <= radius &&
                ray.GetDirection() * plane < 0 &&
                t > EPS && t <= nearestDistance) {
                oIntersection.SetNormal(plane);
                oIntersection.SetPosition(intersectionPos);
                oIntersection.SetTextureCoordinates(intersectionPos);
                oIntersection.IsInside(false);
                nearestDistance = t;
                hasIntersection = true;
            }
        }
    }




    // Intersection with main body
    Vector3<real> o = Vector3<real>(ray.GetOrigin().X(), 0, ray.GetOrigin().Z());
    Vector3<real> d = Vector3<real>(ray.GetDirection().X(), 0, ray.GetDirection().Z());
    real a = d*d;
    real b = 2 * d * o;
    real c = o * o - (radius*radius);

    real discr = b*b - 4*a*c;

    if (discr < -EPS) {
        return hasIntersection;           // No intersection.
    }
    else {
        real t1 = (-b - sqrt(discr)) / (2*a);
        real t2 = (-b + sqrt(discr)) / (2*a);
        real t = std::min<real>(t1, t2);
        Vector3<real> intersectionPos = ray.GetOrigin() + t * ray.GetDirection();
        if (t >= EPS && t < nearestDistance && fabs(intersectionPos.Y()) < halfHeight+EPS) {
            oIntersection.SetNormal(intersectionPos - Vector3<real>(0, intersectionPos.Y(), 0));
            oIntersection.SetPosition(intersectionPos);
            oIntersection.SetTextureCoordinates(intersectionPos);
            oIntersection.IsInside(false);
            nearestDistance = t;
            hasIntersection = true;
        }
    }

	return hasIntersection;
}