Jeu sur les expressions

C'est vrai que là, il n'y a rien à dire !! Si ce n'est bien joué Sequelles . Je cherchais aussi à raccourcir mon expression un utilisant une boucle de type pingpong, mais je n'avais pas pensé à utiliser l'astuce que tu as employée avec le filtre paramètre glissière. Ben maintenant j'ai la réponse! Merci Sequelles.

 

le tricheur!!!!!!
lol
jme fais chier a faire ca que avec des maths et voila le resultat

 

En regardant l'expression de Sequelles cela me fait rappeler que la méthode d'interpolation linear marche aussi avec des ensembles. Du coup, mon expression pour le calque blanc devient plus simple:

Pj=this_comp.layer("jaune").position;
Pr=this_comp.layer("rouge").position;
u=linear(time, Math.ceil(time)-1, Math.ceil(time), Pj, Pr);
v=linear(time, Math.ceil(time)-1, Math.ceil(time), Pr, Pj);
p=position;
if(time>0) [p=u]
if(time>1) [p=v]
if(time>2) [p=u]
if(time>3) [p=v]
if(time>4) [p=u]
if(time>5) [p=v]
p


Encore bravo pour la solution très simple proposé par sequelles.

 

pour les non-matheux c'est juste exceptionnel de vous lire lol
félicitations

 

Le nouveau jeu: le rebond!

rebond.mov

 

Je crois que j'ai trouvé.

Voici le .clip test.

Voici l'expression .

 

un peu trop facile

un autre?tablo.mov

 

Je crois avoir plus ou moins trouvé !

A mon avis, voilà comment tu as procédé :

Tu t’es basé sur le script d’equation « dbspring.mm » (double ressort), que tu as converti en expression. Puis, à partir de là, tu as modifié cette expression pour obtenir ton animation.
En partant de ce raisonnement, j’ai essayé de retrouver l'animation.

1ère étape : conversion du script equation « dbspring.mm » en expression

Pour le calque 1 voici l’expression
Pour le calque 2, c’est la même expression que pour le calque 1 sauf qu’il faut remplacer à la fin p1 par p2.

Voici le résultat de cette conversion : clip1

N.B : les calques sont des calques 3D

2ème étape : Modification des expressions

Je pense que tu as joué sur la longueur du ressort.

Voilà comment j’ai procédé :


3ème étape : Animation

J’ai masqué le calque jaune, créé une caméra et une lumière, puis j’ai commencé par réaliser la 1ère ligne de l’animation.
Pour cela j’ai dupliqué le calque rouge et mis l’expression :

D=this_comp.layer("rouge").position-this_comp.layer("jaune").position
this_comp.layer(this_layer,-1).position+[40,-Math.abs(D[2])/8,D[2]/8]

dans la propriété position. Enfin j’ai dupliqué ce calque 7 fois.

Ensuite j'ai créé la 1ère colonne de l’animation.
Pour cela j’ai dupliqué un des calques et mis l’expression :

D=this_comp.layer("rouge").position-this_comp.layer("jaune").position
this_comp.layer("rouge").position+[-D[2]/6,30, -D[2]/6]

J’ai ensuite dupliqué ce calque et mis l’expression :

D=this_comp.layer("rouge").position-this_comp.layer("jaune").position
this_comp.layer(this_layer,-1).position+[-D[2]/6,30,- D[2]/6]

Enfin j’ai dupliqué ce calque 4 fois.
Pour la deuxième ligne, j’ai procédé comme pour la première mais cette fois le calque référent est le 2ième calque de la 1ère colonne. Et ainsi de suite.

Voici le résultat de mon animation :Tablo

Le mouvement n’est pas exactement le même que le tien mais il est assez difficile de le décrypter (voir impossible).

 

Waou!!!

mais non... dans l'animation il n'y a pas de notion d'élasticité, l'animation viens juste d'une expression wiggle.

L'expression qui m'intéressait été plutôt: comment ranger des calques en ligne et en colonne selon leurs index. Du coup l'ensemble des positons est contrôlables par les calques formant les coins du tableau.

 

Voici la nouvelle animation:Tablo
J'ai mis une expression wiggle pour les 3 premiers calques et pour les 60 calques restant j'ai mis l'expression:

A=this_comp.layer(2).position-this_comp.layer(1).position
B=this_comp.layer(3).position-this_comp.layer(2).position
n=index
p=position
if(n>3) [p=this_comp.layer(1).position+A/8*(n-3)]
if(n>10) [p=this_comp.layer(2).position+B/6*(n-10)]
if(n>15) [p=this_comp.layer(3).position-A/8*(n-15)]
if(n>23) [p=this_comp.layer(this_layer,-1).position-B/6]
if(n>28) [p=this_comp.layer(this_layer,-1).position+A/8]
if(n>35) [p=this_comp.layer(this_layer,-1).position+B/6]
if(n>39) [p=this_comp.layer(this_layer,-1).position-A/8]
if(n>45) [p=this_comp.layer(this_layer,-1).position-B/6]
if(n>48) [p=this_comp.layer(this_layer,-1).position+A/8]
if(n>53) [p=this_comp.layer(this_layer,-1).position+B/6]
if(n>55) [p=this_comp.layer(this_layer,-1).position-A/8]
if(n>59) [p=this_comp.layer(this_layer,-1).position-B/6]
if(n>60) [p=this_comp.layer(this_layer,-1).position+A/8]
p

Bon, l'inconvenient de cette expression est qu'il faut la modifier en fonction du nombre de calque contenu dans le Tablo.

 

Nouveau jeu: Balles.mov

Le jeu consiste à trouver les expressions qui permettent de faire éclater un calque au point d'impact des balles au moment de l'impact, puis de faire tomber les balles après l'impact.

 

quel filtre utilises-tu pour faire éclater le calque ?

 

Le filtre "Eclat" (Simulation>Eclat).

 

On peut relier la force qui fait éclater le calque à un calque en mode 3D.
Si je nomme ce calque "balle1", la position de la Force correspondante dans le filtre Eclat sera:
[thisComp.layer("balle1").position[0],thisComp.layer("balle1").position[1]]
et la profondeur
thisComp.layer("balle1").position[2]/thisComp.width

reste à animer le calque balle1, on peu ajouter un caméra et des lumières et les utiliser dans le filtre éclat dans Système de Caméra et Type de lumière.

Par contre pour faire passer automatiquement le calque "balle" devant ou derrière les éclats... je cherche...

 

Pas besoin d’ajouter de caméra, n'y de lumière d'ailleurs.
La profondeur de la force n'a pas été modifiée (valeur par défaut).