コード例 #1
0
   ////////////////////////////////////////////////////////////////////////
   ///
   /// @fn void VuePerspectiveCiel::zoomerOutSmooth()
   ///
   /// Permet de faire un zoom out smooth selon l'incrément de zoom.
   /// 
   /// @return Aucune.
   ///
   ////////////////////////////////////////////////////////////////////////
   void VuePerspectiveCiel::zoomerOutSmooth()
   {
	   Vecteur3 deplacement = obtenirCamera().obtenirPosition()-obtenirCamera().obtenirPointVise();
       deplacement.normaliser();
       deplacement*=1.5f;
	   obtenirCamera().deplacerXYZ(deplacement);
   }
コード例 #2
0
ファイル: Camera.cpp プロジェクト: Altivar/ASIA1
Rayon CameraPinhole::genererRayon(int x, int y) const
{
	// calcule la direction dans le repere monde
	Vecteur2 uv = imageVersEcran(x, y);
	Vecteur3 uvw = ecranVersCamera(uv);
	Vecteur3 direction = cameraVersMonde(uvw);
	direction.normer();

	// retourne le rayon
	return Rayon(_position, direction);
}
コード例 #3
0
////////////////////////////////////////////////////////////////////////
///
/// @fn void NoeudBordure::assignerCoinBordure(Vecteur3 coinMin, Vecteur3 coinMax)
///
/// Cette fonction assigne les coins de la bordure
/// 
/// @param coinMin : le coin min du bordure
/// @param coinMax : le coin max du bordure
/// 
///
/// @return Aucune.
///
////////////////////////////////////////////////////////////////////////
void NoeudBordure::assignerCoinBordure(Vecteur3 coinMin, Vecteur3 coinMax)
{
	if(coinMax.estNul() == true)
		coinBordureMax_ = distanceP1P2_ +  coinMin;
	else
		coinBordureMax_ = coinMax;
	coinBordureMin_ = coinMin;
}
コード例 #4
0
////////////////////////////////////////////////////////////////////////
///
/// @fn VisiteurCollision::mettreDansPortail(NoeudPortail& noeud)
///
/// Fonction qui place la rondelle sur un portail
/// TODO: sortir avec une direction aleatoire
///
/// @param[in] noeud : le portail ou l'on veut placer la rondelle
///
/// @return Aucune.
///
////////////////////////////////////////////////////////////////////////
void VisiteurCollision::mettreDansPortail(NoeudPortail& noeud)
{	
	/// Trouver la vitesse de la rondelle
	Vecteur3 vitesseVect = rondelle_->obtenirVitesse();
	double vitesse = vitesseVect.norme();

	/// Donner une direction aleatoire a notre rondelle lors de la sortie de celle-ci
	for( int i = 0; i < 2; i++)
		vitesseVect[i] = rand()/((double)RAND_MAX);

	/// Donner la nouvelle vitesse
	vitesseVect.normaliser();
	rondelle_->modifierVitesse(vitesseVect*vitesse);

	/// Donner la nouvelle position
	rondelle_->assignerPositionRelative(noeud.obtenirPositionRelative());
	/// Desactiver l'attraction du portail en question
	noeud.desactiverAttraction();
}
コード例 #5
0
ファイル: PlayerHuman.cpp プロジェクト: mathieumg/hockedu
void PlayerHuman::PlayTick( float time )
{
	auto maillet = getControlingMallet();
	if(maillet)
	{
		if(mControllerType & CONTROLLER_TYPE_KEYBOARD)
		{
			// if any key is pressed
			if(EventManager::mMalletDirection.mValue)
			{
				Vecteur3 newPos;
				// give direction according to key pressed
				if(EventManager::mMalletDirection.IsFlagSet(MALLET_UP))
				{
					++newPos[VY];
				}
				if(EventManager::mMalletDirection.IsFlagSet(MALLET_DOWN))
				{
					--newPos[VY];
				}
				if(EventManager::mMalletDirection.IsFlagSet(MALLET_LEFT))
				{
					--newPos[VX];
				}
				if(EventManager::mMalletDirection.IsFlagSet(MALLET_RIGHT))
				{
					++newPos[VX];
				}

				// make sure final direction is length 8
				newPos.normaliser();
				newPos *= 8;
				newPos += maillet->getPosition();
				
				maillet->setTargetDestination(newPos);
			}
		}
		else if(mControllerType & CONTROLLER_TYPE_MOUSE)
		{
			maillet->setTargetDestination(EventManager::mMouseGamePos);
		}
	}
}
コード例 #6
0
ファイル: Droite3D.cpp プロジェクト: gravufo/MLGHockey
   ////////////////////////////////////////////////////////////////////////
   ///
   /// @fn double Droite3D::distancePoint( const Vecteur3& centre )
   ///
   /// Calcule la distance euclidienne entre la droite et un point.
   ///
   /// @param[in] centre : Point à partir duquel la distance doit être calculée.
   ///
   /// @return Distance du point à la droite.
   ///
   ////////////////////////////////////////////////////////////////////////
   double Droite3D::distancePoint( const Vecteur3& centre )
   {
      // En 2D
      const double ad = direction_[1];
      const double bd = -1.0 * direction_[0];
      const double cd = -1.0 * direction_[1] * pointDroite_[0] +
                        direction_[0] * pointDroite_[1];

      double num = fabs( ad * centre[0] + bd * centre[1] + cd );
      double den = sqrt( pow ( ad, 2 ) + pow ( bd, 2 ) );

      // En 3D
      const Vecteur3 centreNul(centre[0], centre[1], 0.0);
      const Vecteur3 vect( pointDroite_, centreNul );
      const Vecteur3 mult = produitVectoriel( vect, direction_ );
      num = mult.norme();
      den = direction_.norme();

      return ( num / den );
   }
コード例 #7
0
ファイル: Lumiere.cpp プロジェクト: Altivar/ASIA1
bool LumierePoint::calculerEclairement(const Intersection &intersection, const Scene &scene, Eclairement &eclairement) const
{
	// calcule la direction de la lumiere
	Vecteur3 L = _position - intersection._position;
	reel distance = L.calculerNorme();
	L.normer(distance);

	// teste si la lumiere est visible
	Rayon rayonLumiere(intersection._position, L);
	rayonLumiere.avancer();
	bool visible = scene.visibilite(rayonLumiere, distance);

	// initialise l'eclairement
	if (visible)
	{
		eclairement._couleur = _couleur;
		eclairement._incidence = L;
	}

	return visible;
}
コード例 #8
0
////////////////////////////////////////////////////////////////////////
///
/// @fn VisiteurCollision::visiter(NoeudPortail& noeud)
///
/// Fonction qui permet de taiter la collision entre la
///	rondelle et les portails
///
/// @param[in] typeNoeud : Le type du noeud.
///
/// @return Aucun
///
////////////////////////////////////////////////////////////////////////
void VisiteurCollision::visiter(NoeudPortail& noeud)
{
	/// fistances entre la rondelle et le portail
	GLdouble dx = noeud.obtenirPositionRelative()[X] - rondelle_->obtenirPositionRelative()[X];
	GLdouble dy = noeud.obtenirPositionRelative()[Y] - rondelle_->obtenirPositionRelative()[Y];
	/// vecteur de la direction qui pointe de la rondelle au portail
	Vecteur3 direction = Vecteur3(dx,dy,0);
	direction.normaliser();

	/// calcul de la distance entre deux points
	GLdouble distance = sqrt( (dx*dx) + (dy*dy) );
	/// savoir si la rondelle est dans le champs d'attraction
	GLdouble distAttraction = distance - noeud.obtenirRayonAttraction() - rondelle_->obtenirRayon();
	/// prendre en compte les rayons de nos objets
	distance = distance - rondelle_->obtenirRayon();

	/// si il y a collision, teleportation
	if (distance < 0) 
	{
		size_t nombrePortails = portails_.size();

		if (nombrePortails == 1.0) // il y a juste un portail
		{
			noeud.desactiverAttraction();
		}
		else
		{
			if (noeud.obtenirAttraction())
			{
				GestionnaireSon::obtenirInstance()->jouerSonCollision(ArbreRenduINF2990::NOM_PORTAIL);
				teleporter(noeud);
			}
		}
	}
	/// si il n'y a pas de collision, attirer la rondelle quand la rondelle est dans la zone d'attraction
	else
	{
		if (distAttraction < 0.0)
		{
			if (distance > 1.0f)
				noeud.varierRotation(1.0f / (GLfloat)distance * 10.0f);
			else
				noeud.varierRotation((GLfloat)distance + 1.0f);

			if (noeud.obtenirAttraction())
			{
				Vecteur3 vitesse = rondelle_->obtenirVitesse();

				for (int i = 0; i < 2; ++i) {
					vitesse[i] += direction[i] * (noeud.obtenirRayon()*FORCE_PORTAIL/distance);
				}
				rondelle_->modifierVitesse(vitesse);
			}
		}
		else
		{
			if (portails_.size() > 1)
				noeud.activerAttraction();	 
		}
	}
}