C++ Hit::setIntersection方法代码示例

bool Sphere::intersect(const Ray& ray, Hit& hit) const
{
  float a = (ray.direction.normalized()).dot(ray.direction.normalized());
  float b = 2.0f * (ray.direction.normalized()).dot(ray.origin - mCenter);
  float c = (ray.origin - mCenter).dot(ray.origin - mCenter) - (mRadius * mRadius);

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

  if (discriminant > 0) {

    float s1 = (- b + sqrtf(discriminant)) / 2 * a;
    float s2 = (- b - sqrtf(discriminant)) / 2 * a;

    // Tester le chemin le plus court ?
    if (s1 > 0) {
      if (s1 < s2 && hit.t() > s1) {
        hit.setT(s1);
	hit.setIntersection(ray.direction * s1);
      }
    }

    if (s2 > 0) {
      if (s2 < s1 && hit.t() > s2) {
        hit.setT(s2);
	hit.setIntersection(ray.direction * s2);
      }
    }
  }
  else if (discriminant = 0) {
    float s = - b / 2 * a;

    if (hit.t() > s) {
      hit.setT(s);
      hit.setIntersection(ray.direction * s);
    }
  }
  else {
    return false;
  }

  return true;
}

//.........这里部分代码省略.........
		bool bottom = bottomdisque()->intersect(ray,hit);
		return top || bottom;
		}
		

		// on calcule la normale en ce point, dans les coordonnées du cylindre toujours

		float theta = 0;
		Vec normale;
		normale.x = I.x;
		normale.y = I.y;
		normale.z = 0;

		if (normale.norm() == 0)
		{
			cout << "la norme de la normale est nulle" << endl;
		}
	
		if (R1>=R2){
			theta = atan((R1-R2)/h);
			normale = normale * (1/normale.norm())*cos(theta);
			normale = normale + Vec(0,0,sin(theta));
		}
		else
		{
			theta = atan(h/(R2-R1));
			normale = normale * (1/normale.norm())*sin(theta);
			normale = normale - Vec(0,0,cos(theta));
		}
	
		if ( hit.time() > t){
			hit.setTime(t);
			Vec locale = frame().inverseTransformOf(I);
			hit.setIntersection(locale);
			hit.setNormal(frame().inverseTransformOf(normale));
			hit.setMaterial(material());
			computeUV(hit);
#ifdef DEBUG_INTERSEC
			displayIntersectionDebug(ray,hit,O,I,t);
#endif
			topdisque()->intersect(ray,hit);
			bottomdisque()->intersect(ray,hit);
			return true;
		}else{
			return false;
		}

	}
	
	if (delta ==0)
	{
#ifdef DEBUG_INTERSEC
		cout << "delta est nul, il y a une solution" << endl;
#endif
		// une solution, regarder si on intersecte les disques et comparer les time obtenu pour trouver le plus petit
		float t;
		if (a==0)
		{
			t = -c/b;
		} 
		else 
		{
			t=(-b/(2*a));
		}
		

bool Plane::intersect(const Ray& ray, Hit& hit) const
{
#ifdef DEBUG_INTERSEC
	std::cout << "TENTATIVE d'intersection du rayon :\n" << ray << "avec le plan\n" << *this << std::endl;
#endif
	// on place le ray dans le répère associé au plan
	Ray ray_associe_plan(frame().coordinatesOf(ray.start()),
			     frame().transformOf(ray.direction()));
	
#ifdef DEBUG_INTERSEC
	std::cout << "rayon dans l'espace du plan : \n" << ray_associe_plan << std::endl;
#endif
	// on vérifie que le ray pointe vers le plan
	if ( ( ray_associe_plan.start().z <= 0 && ray_associe_plan.direction().z <= 0 )
	     || 
	     ( ray_associe_plan.start().z >= 0 && ray_associe_plan.direction().z >= 0 )
		)
	{
#ifdef DEBUG_INTERSEC
		std::cout << "PAS D'INTERSECTION" << std::endl;
#endif
		return false;
	}
	// on détermine le t de l'intersection dans la formule
	// zstart + t*zdir = 0
	float t = -ray_associe_plan.start().z/ray_associe_plan.direction().z;

	if ( hit.time() < t ){
#ifdef DEBUG_INTERSEC
		std::cout << "PAS D'INTERSECTION : " << t << " > " << hit.time() << std::endl;
#endif
		return false;
	}


#ifdef DEBUG_INTERSEC
	std::cout << "Intersection au temps : " << t << std::endl;
#endif
	// Calcul des coordonnées de l'intersection dans le plan et
	// rejet si on dépasse
	float u,v;
	u = ray_associe_plan.start().x+t*ray_associe_plan.direction().x;
	if ( width_ > 0 && (u > width_/2.0 || u < -width_/2.0) ){
#ifdef DEBUG_INTERSEC
		std::cout << "PAS D'INTERSECTION : u = " << u << ", width = " << width_ << std::endl;
#endif
		return false;
	}
	v = ray_associe_plan.start().y+t*ray_associe_plan.direction().y;
	if ( height_ > 0 && (v > height_/2.0 || v < -height_/2.0) ){
#ifdef DEBUG_INTERSEC
		std::cout << "PAS D'INTERSECTION : v = " << v << ", height = " << height_ << std::endl;
#endif
		return false;
	}
	qglviewer::Vec inter_plan = qglviewer::Vec(u,v,0);

#ifdef DEBUG_INTERSEC
	std::cout << "INTERSECTION d'un rayon avec le plan \n"<< *this << "\tau temps : " << t << std::endl;
#endif
 	hit.setTime(t);
	hit.setIntersection(frame().inverseCoordinatesOf(inter_plan));
	if ( ray_associe_plan.start().z <= 0 ){
		hit.setNormal(frame().inverseTransformOf(qglviewer::Vec(0,0,-1)));
	}else{
		hit.setNormal(frame().inverseTransformOf(qglviewer::Vec(0,0,1)));		
	}
	hit.setMaterial(material());
	
	// On envoie les coordonnées de la texture (entre 0 et 1 si la
	// partie est finie)
	if ( width_ > 0 ){
		u = u/width_ + 0.5;
	}
	if ( height_ > 0 ){
		v = v/height_ + 0.5;
	}
#ifdef DEBUG_INTERSEC
	std::cout << "Coordonnées de textures ("<< u << "," << v << ")" << std::endl;
#endif
	hit.setCoord(u,v);
	
	return true;
#ifdef DEBUG
	cerr << "Erreur lors du calcul de l'intersection d'un objet avec un rayon" << endl;
#endif
	return false;
}