Recherche expression rebond

Bravo oscarus, très complet.
Pour ce qui est de la partie purement physique, en plus de l'équation de l'horaire (x = 1/2at² + Vot + Xo, que l'on dérive deux fois pour avoir la vitesse ainsi que l'accélération), il faudrait utiliser les équations sur la quantité de mouvement.
Je pense qu'avec ces deux équations il doit être possible de calculer assez facilement un rebond... il me semble même que je l'avais fait, mais je m'en souviens plus. Je peux toujours chercher, si ça t'intéresse.

 

En fait j'y réfléchissais et ce n'est pas si compliqué (dans un cas simplifié évidemment, sans tenir compte de la rotation).
Tu as considères un mouvement uniquement sur l'axe Y. Tu appliques x = 1/2at² + Vot + Xo, tu prends tout d'abord une vitesse initiale nulle, puis pour a, F = m a, m g = m a, donc a = g. Tu connais la différence de hauteur (x), tu as t. Ensuite tu dérives l'équation pour avoir la vitesse, v = at + Vo, tu as a et Vo, t tu viens de la calculer, tu as v au moment du contact.
Ensuite, tu reposes le problème en fait, mais à l'envers, en partant à partir de Vo = v, et a = -g. Et ainsi de suite.
En programmation à l'aide d'une boucle ça ne doit pas être difficile à réaliser, je le ferais peut-être pour le flash ce week-end.
Reste à appliquer cette équation en expression javascript, et le tour et joué, AE devient une simulation de cinétique

 

je ne sais pas si fb2k est interesse, mais moi qui suis resté aux equations a 0 inconnus, je serais content que tu fasses la recherche pour donner une solution "prete" a l'emploi".

 

J'ai retrouvé l'equation Gravity:
____________________________________________________
// Gravity - Version 1.3

// This script applies gravitational force to the layer in layer popup 1.
// The velocity of the layer at the start of the work area
// will be used as the initial velocity.

// LAYER PROPERTY CHANNEL
// ------ ---------- --------
// 1: Layer affected by gravity doesn't matter doesn't matter
// 2: doesn't matter doesn't matter doesn't matter

if (time() == start_time) {
vel = tmap (time() + step_time, value(pop_layer(1), position)) -
value(pop_layer(1), position);
damping = 0.95; // Damping force (0 = infinite friction, 1 = none)
grav = 0.9; // magnitude of gravity force
grav_dir = {0,1,0}; // direction of gravity
accel = grav * grav_dir; // gravity vector

new_pos = value(pop_layer(1), position);
} else {

vel = vel*damping + accel; // Add discrete acceleration to velocity
new_pos = new_pos + vel; // Add discrete velocity to position

// Check new position against borders of comp and bounce back
if (new_pos[X] < 0) {
new_pos[X] = 0;
vel = {-vel[X], vel[Y]};
}
if (new_pos[Y] < 0) {
new_pos[Y] = 0;
vel = {vel[X], -vel[Y]};
}
if (new_pos[X] > comp_size[X]) {
new_pos[X] = comp_size[X];
vel = {-vel[X], vel[Y]};
}
if (new_pos[Y] > comp_size[Y]) {
new_pos[Y] = comp_size[Y];
vel = {vel[X], -vel[Y]};
}
}
value(pop_layer(1), position) = new_pos;
____________________________________________________

Maleureusement je n'arrive pas à la traduire pour les expressions.

Au fait, pour faire des rebonds on peu utiliser le Laboratoire de particules ça marche très bien.

Mais j'aimerai bien savoir si c'est posible avec les expressions...

 

je serais interesse par tes rebonds avec le labo de part.
tu peut devellopper un peu stp
merki

 

Tu appliques le filtre sur un solide de la taille de la comp

Tu peux appliquer une vidéo à un particule:
Matrice de calque/Utiliser le calque.
Type de décalage temporel: Relatif

Tu peux faire rebondir la particule sur les bord d'un masque:
Mur/Bordure

 

pour l'expression je crois que j'ai trouvé

Il faut créer une animation du calque avec des images clés. Placer un marker là ou on veux que le solide soit libéré. Il continue sur ça lancé puis retombe et rebondit sur le bas de la comp.

 

C'EST PAS COOL !!!!!!!!!!

Avec une image, on peut pas faire de copier-coller pour tester. Ce qui augmente nettement les chances de rater.

Allez, sequelles, un petit effort svp.

 

quand je le copie dans le message ça me bouffe des bouts:

t=marker.key (1).time
grav=[0,30]
vel=position.velocityAtTime(t)
A=position.valueAtTime(t)
while(t<time){
t+=thisComp.frameDuration,
A+=vel*thisComp.frameDuration,
vel+=grav;
if(A[1]>thisComp.height) vel[1]=-vel[1]*.6
}
if(time<marker.key (1).time){A=position}
A

 

Pour ceux aui ont la v6, voici le projet.

2 problemes neanmoins.

Le solide descend partiellement en dessous de la compo (j'ai essaye height/2 mais le resultat n'a pas ete concluant) ; Le rebond ne s'arrete pas et meme la fin ne semble pas diminuer.

 

Pour ceux qui n'ont pas la v6, voici l'expression dans un fichier txt.

 

t'es jamais content

bon voilà une version plus élaborée
avec les controleurs d'expression et tout et tout.

 

Je n'ai pas regarde exactement ce que tu as fait, mais le resultat est excellent et surement a la hauteur de ce que demandais fb2k.

Et en ce qui me concerne, SI SI, je suis tres content.

PS : il n'y a pas d'autres demande ? Profitons-en, Sequelles est en forme.

 

En effet, c'est à la hauteur de mes espérances !
Pour le montage de ma question initiale, c'est trop tard pour l'utiliser mais je le garde au frais pour une autre fois.

Encore merci !