Contenu mis en avant
Dépliage

Plugin Cinema 4D

Alvéole

Plugin Cinema 4D

Projecteur UV

Plugin Cinema 4D

Physique élémentaire

 

Algorithmes de physique élémentaire en 2DSans transitionTransition progressiveTransition élastiqueSuivi rigideSuivi soupleSuivi rigide élastiqueGravité et inertieLiaison souple avec inertie et gravitéLiaison avec inertie, masse et gravitéLiaison élastique avec inertie et gravitéCorde avec inertie et gravité
Algorithmes de physique élémentaire en 2D
Sans transition
// Boucle
cible = souris
Transition progressive
Rapidité
0.1 
// Initialisation
cible = souris
// Boucle
cible += (souris - cible) * rapidite
Transition élastique
Rapidité
0.1

Élasticité
0.8
// Initialisation
cible = souris
vitesse = 0
// Boucle
vitesse = (vitesse + (souris - cible) * rapidite) * elasticite
cible += vitesse
Suivi rigide
Longueur : 60 
// Boucle
direction = (cible - souris).getNormalized()
cible = souris + direction * longueur
Suivi souple
Longueur : 60 
// Boucle
difference = cible - souris
longueurDiff = difference.getLength()
    
direction = Vector()
if (longueurDiff > 0) direction = difference / longueurDiff
    
longueurCible = longueur
if (longueur > longueurDiff) longueurCible = longueurDiff;
    
cible = souris + direction * longueurCible
Suivi rigide élastique
Longueur : 60
Rapidité : 0.1
Élasticité : 0.8 
// Initialisation
cible = souris
vitesse = 0
// Boucle
direction = (cible - souris).getNormalized()
destination = souris + (direction * longueur)
vitesse = (vitesse + (destination - cible) * rapidite) * elasticite
cible += vitesse
Gravité et inertie
Gravité : 0.8
Friction : 0.01 
// Initialisation
cible = souris
vitesse = 0
// Boucle
destination = cible + vitesse + gravite
vitesse = destination - cible
vitesse *= friction
cible = destination
Liaison souple avec inertie et gravité
Longueur : 70
Gravité : 0.8
Friction : 0.01 
// Initialisation
cible = souris
vitesse = 0
attache = true
// Boucle
destination = cible + vitesse + gravite
 
difference = destination - souris
longueurDiff = difference.getLength()
 
if (attache && longueurDiff >= longueur) {
	
	direction = difference.getNormalized()
	destination = souris + (direction * longueur);
}
 
vitesse = destination - cible
vitesse *= friction
cible = destination
Liaison avec inertie, masse et gravité
Longueur : 70
Gravité : 0.8
Friction : 0.01
Masse : 0.5 
// Initialisation
cible = souris
vitesse = 0
attache = true
// Boucle
destination = cible + vitesse + gravite
    
difference = destination - souris
longueurDiff = difference.getLength()
    
deplacement = (cible - destination).getNormalized()
destinationLiee = destination
    
if (attache && longueurDiff >= longueur) {
	
	direction = difference.getNormalized()
	destinationLiee = souris + (direction * longueur);
}
    
liaison = destinationLiee - destination
destination += liaison
    
vitesse = destination - cible
    
inertie = vitesse.getNormalized() * masse * (deplacement • liaison)
    
vitesse += inertie
vitesse *= friction
    
cible = destination
Liaison élastique avec inertie et gravité
Longueur : 80
Gravité : 0.8
Friction : 0.01
Rapidité : 0.1
Élasticité : 0.8 
// Initialisation
cible = souris
vitesse = 0
attache = true
elasticiteVitesse = 0
// Boucle
destination = cible + vitesse + gravite
    
difference = destination - souris
longueurDiff = difference.getLength()
    
if (attache && longueurDiff >= longueur) {
	
	direction = difference.getNormalized()
	
	destinationLiee = souris + (direction * longueur)
	liaison = destinationLiee - destination
	    
	elasticiteVitesse += liaison * elasticite
	elasticiteVitesse *= rapidite
	destination += elasticiteVitesse
}
    
vitesse = destination - cible
vitesse *= friction
    
cible = destination
Corde avec inertie et gravité
Gravité : 0.8 
// Initialisation
attache = true
    
points = [
	{ x : 0, y : 0 },
	{ x : 20, y : 0 },
	{ x : 40, y : 0 },
	{ x : 60, y : 0 },
	{ x : 80, y : 0 },
	{ x : 100, y : 0 },
	{ x : 120, y : 0 },
	{ x : 140, y : 0 },
	{ x : 160, y : 0 },
	{ x : 180, y : 0 },
	{ x : 200, y : 0 },
	{ x : 220, y : 0 },
	{ x : 240, y : 0 },
	{ x : 260, y : 0 },
]
    
// Liens de chaque point (exemple : le point 1 est lié au point 0 et au point 2).
// Les longueurs pourraient être factorisées pour gagner en mémoire
liens = [
	[{ 'id' :  1, 'long' : 20 }],
	[{ 'id' :  0, 'long' : 20 },  { 'id' :  2, 'long' : 20 }],
	[{ 'id' :  1, 'long' : 20 },  { 'id' :  3, 'long' : 20 }],
	[{ 'id' :  2, 'long' : 20 },  { 'id' :  4, 'long' : 20 }],
	[{ 'id' :  3, 'long' : 20 },  { 'id' :  5, 'long' : 20 }],
	[{ 'id' :  4, 'long' : 20 },  { 'id' :  6, 'long' : 20 }],
	[{ 'id' :  5, 'long' : 20 },  { 'id' :  7, 'long' : 20 }],
	[{ 'id' :  6, 'long' : 20 },  { 'id' :  8, 'long' : 20 }],
	[{ 'id' :  7, 'long' : 20 },  { 'id' :  9, 'long' : 20 }],
	[{ 'id' :  8, 'long' : 20 },  { 'id' :  10, 'long' : 20 }],
	[{ 'id' :  9, 'long' : 20 },  { 'id' :  11, 'long' : 20 }],
	[{ 'id' :  10, 'long' : 20 },  { 'id' :  12, 'long' : 20 }],
	[{ 'id' :  11, 'long' : 20 },  { 'id' :  13, 'long' : 20 }],
	[{ 'id' :  12, 'long' : 20 }],
]
    
// Vitesse des points
vitesses = [
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
]
    
// Position des points avant le calcul de la liaison
pointsAvantLiaisons = [ 
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
]
    
// Position finale des points
pointsApresLiaisons = [ 
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
	{ x : 0, y : 0 },
]
// Boucle
nb = points.length;
    
// Forces
    
for (i = 0 ; i < nb ; i++) {
	
	pointsAvantLiaisons[i] = points[i] + vitesses[i] + gravite
	
	if (i === 0 && attache) {
		points[i] = souris
		pointsAvantLiaisons[i] = souris
	}
}
    
// Liaisons
			
for (k = 0 ; k < 20 ; k++) { // 20 = itérations pour l'approximation du calcul des liaisons
    
	for (i = 0 ; i < nb ; i++) {
		
		pointAvantLiaisons = pointsAvantLiaisons[i]
		liensPoint = liens[i]
		
		pointAvecLiaison = { x : 0, y : 0 }
		direction = { x : 0, y : 0 }
		liaison = { x : 0, y : 0 }
		liaisonMoyenne = { x : 0, y : 0 }
		liensNb = liensPoint.length
		
		for (lien in liensPoint) {
			
			lienPoint = pointsAvantLiaisons[lien.id]
			
			direction = pointAvantLiaisons - lienPoint
			direction.normalize()
			
			pointAvecLiaison = lienPoint + direction * lien.long
			
			liaison = pointAvecLiaison - pointAvantLiaisons
			liaisonMoyenne += liaison
		}
		
		
		if (liensNb > 0) {
			liaisonMoyenne /= liensNb
			pointsApresLiaisons[i] = pointAvantLiaisons + liaisonMoyenne
		}
		
		
		if (i === 0 && attache) {
			pointsApresLiaisons[i] = souris
		}
	}
	
	for (i = 0 ; i < nb ; i++) {
		pointsAvantLiaisons[i] = pointsApresLiaisons[i]
	}
}
    
// Finalisation
    
for (i = 0 ; i < nb ; i++) {
	
	pointApresLiaisons = pointsApresLiaisons[i]
	
	vitesses[i] = pointApresLiaisons - points[i]
	points[i] = pointApresLiaisons;
}
person
create
Les plus récents
keyboard_arrow_down