////////////////////////////////////////////////////////////////////////
///
/// @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);
}
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);
}
////////////////////////////////////////////////////////////////////////
///
/// @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;
}
////////////////////////////////////////////////////////////////////////
///
/// @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();
}
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);
}
}
}
////////////////////////////////////////////////////////////////////////
///
/// @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 );
}
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;
}
////////////////////////////////////////////////////////////////////////
///
/// @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();
}
}
}
