Transcripts
1. Intro: Hi, I'm Valerie, and
welcome to AI for Motion. If you ever feel intimidated
by expressions and you want to leverage AI to help you
in your animation workflow, then this one is for you. In five lessons, I will show
you how to use AI tools like HAGPT to generate expressions that automate your animations, build smart setups and save
you hours of manual work. We'll cover everything from creating carouselels,
hover effects, bouncing I panels to automating cursor clicks without writing a single line of call yourself. The great news is that you don't need to be an expert
in after effects. You know the basics,
you're ready. By the end of this course, you will have a reusable setup you can apply to
your own projects. And most importantly,
you will have a whole new way of thinking
about animation with AI. So if you are ready to
animate smarter and faster, let's jump into the first
lesson. I'll see you there.
2. Building a Smart Carousel Animation: There, and welcome to the
first lesson of the course. I hope you've already
downloaded the course folder. I called it expressions for SAS because the
animations we're going to create in this course
are mostly used in SAS explainer videos. All right. So first, let's begin by checking what's
inside this folder. It's nothing too complicated. Inside the hat GPT folder, you'll find PDF files of the conversations I had with
Chat GPT during this course. That means inside these PDFs, you'll see my exact
conversations with the chat but saved as PDF files. I added those because
for each one of us, the chat might give
slightly different answers. And in case the AI gives you something completely
off topic in your chat, you can always go back
to these PDF files and copy the exact
expressions I used. But don't worry. I'm sure that no matter which
AI you're using, we'll all get very
similar results because at the end of the day, we're generating very
simple lines of code. All right, let's move
on to the next one. There's an Assets folder that contains all the images
we'll use in this course, like the animal pictures and
the software icon logos. You'll also see an AE folder with the After Effects
project files. One file includes
the final animation we'll be working
toward in this course, and the other is the
version without animation, which we'll start
with right now. So let's open that one
and begin the lesson. Before we move on, let's
make sure we're all using the same workspace layout so
everything stays in sync. To do this, go to Window, then workspace and
choose default. If your layout still looks
different from mine, it's probably because some
panels were moved around. To fix this, we can reset
the workspace together. Now we should all be
seeing the same thing. Now, at this point, don't do anything, just
watch and listen. We'll get hands on very soon. Let me first walk you through the project panel so you can
understand what's in there. Inside the Assets folder, we have the animal images
and software icons. There's also a
solids folder with the solids I used as
backgrounds for each lesson. Each lesson folder
contains the main comp for that lesson and a sub folder with the pre comps
related to it. I already prepared
the scenes we're going to practice
with in this course. In each lesson, we'll
practice something different. Don't worry. I'll
also explain how I set up each scene before
we start animating. For now, we can close
all the precomps and focus on the first lesson
in which we'll create a super cool carousel animation with a lot of micro
animations like opacity, scaling, and even drop
shadow animations, but without actually creating keyframes for these
micro animations. We'll do it all
using expressions. But don't worry.
You don't need to know expressions at
all to make it work. We're going to use AI to generate the
expressions we need. Before jumping into
the animation, let me quickly
explain how I set up this scene because there's a
lot you can learn from it. As you can see, I've got
a few pre comps here, each one with an animal picture. You might ask, why did
you precompose them? Why not just use the
picture layer as it is? So let me enter this precomp
and explain why I did that. First of all, it's
because all the pictures are different sizes and I need
them to be the same size. Moreover, I wanted to create
the rounded edges look. I created a rounded square
using a shape layer, then I used the
track Matty function to use this shape as an
alpha for the picture. This shape is now used as
a mask for the picture. It's better than applying
a regular mask directly on the picture layer
because it lets me freely position the
image however I want. Most importantly, it
allows me to easily swap pictures later if a
client asks for changes. I simply select the
image I want to replace, then hold Alt or Option on Mac and drag the
new one onto it. After that, I can adjust the new picture to
fit the layout. As you can see, the rounded
corners stay the same, and I'm ready to keep working. Alright, I'll press Control
Z to undo my changes. Oh, and by the way, when I work on projects that include
lots of pictures, I use medium sized
pre comp dimensions. A size like 1080 by 1080
usually works well. With that said, I hope
you see the benefit of setting it up this way and now we can start
working together. Get ready to make some magic. So now let's begin creating the Advanced
carousel animation. As I mentioned earlier,
we're going to use AI to help us with this. In our case, we'll use the
free version of hat GPT. If you don't have
an account yet, go ahead and create one. But honestly, by now, most people already have one. I'm using the paid version, but here you'll see me using the free version
called GPT four oh. It works the same way
with older versions too. Though by the time you're
watching this course, that version might
not exist anymore. Anyway, let's start building. First, I want to share
three important tips that will make this process
much more efficient for you. One, when asking for
help with After Effects, always start by showing GPT a screenshot of your pre comp. That way, it can see
the whole setup, which makes your request
easier to understand. Two, when writing your
first message or task, always end it with
a question like, do you understand what I mean? This helps GPT think
through your idea more carefully and often explains it back to you even better
than you described it. Three, if things don't go as planned and GPT isn't
giving you what you want, don't keep trying
in the same chat, close it and start a new one. That resets its
memory. If you keep asking in the same thread
after several failed attempts, it'll stay locked into
your original prompt, which might not
even be accurate. So it's better to start fresh. All right. With that in mind, let's start creating
the karoel animation. According to our first tip, we'll begin by
taking a screenshot of our scene to share with GPT. In my case, I'll search
for the Snipping tool. Here are the shortcuts
for both PC and MAC. PC users shift Windows S. Mac users Command Shift four. You don't need to capture
the entire interface, just the important panels. In our case, what matters
most is the preview panel, so GPT can see the layout
and the Layers panel, so it can read the layer names. We want GPT can see our scene. So make sure the
screenshot includes the preview panel and
the layers panel, so it can also see
the layer names. Now let's copy the screenshot
and paste it into Chat GPT. Next, we'll explain
what we want it to do. I'm going to write it
using simple English with some grammar mistakes just to show you
that perfect English isn't necessary to
get good results. That's where our second rule
helps. So let's try it. I recommend always starting by mentioning what
software you're using. Then briefly describe
what's in your scene. Our goal is to give GPT a basic task without getting too deep into the
details at the start. For example, a
specific value like 20% isn't very important
at this point. All the values can
be fine tuned later, so don't worry
about being exact. Just focus on describing the animation idea the
way you imagine it. Like I'm doing here, I'm telling you that I
want the opacity of the non centered
precomps to be lower to make the centered
one stand out more. And now, once you've
described everything, don't forget our second rule. If you're not sure you
explained your idea clearly, finish your message by asking, Do you understand what I mean? Now, you should know
that the answer GPT gives will be a little
different for each of us. And that's totally fine.
The most important thing is to check that it understands your vision in the first
part of its answer. If something isn't right, you can correct it before
moving forward. For example, I noticed that GPT suggested scaling the
centered precomp by 20%, which in its mind, means going from a
scale of 100 to 120. But in my case, my default
precomp scale is not 100, so I don't want to
scale it to 20. I'm going to tell GPT
that in a simple way, my default scale is 40. Then I go back to my project, check what looks good, and
I see that 60 works well. So I go back to the
chat and tell it 60. Before continuing, I'll also look at GPT's other suggestions. In this case, I see it's offering two different
motion styles. I want the animation
to be smooth, so I'll mention that
in the chat as well. With that done,
let's run the task. Now, we have a few
answers generated with some simple explanations, you don't have to
read them all, but if you want to start learning
how expressions work, it's a good idea to read them. The nice thing is, even if you don't understand
expressions, GPT usually gives
clear explanations inside the expression code
without breaking anything. It also tells us which property we should apply
the expression to, and that's the
important part for us. Just remember, before
you move forward, if you have any questions, keep reading the rest
of GPT's answer. Most of the time, you'll find the explanation you
need right there. Alright. So now let's go to the first scale expression
and copy the code. Now, open your project and press S to reveal
the scale property. To open the expression input, hold Alt or Option on Mac, and click the Scale Stopwatch. Now, press Control or Command
V to paste the expression. To complete the action, click anywhere outside the
expression panel. And there we have it.
The first precomp is now scaled to 60. Let's open the action
grid and place the precomp in the center
to see if it's working. Looks good. Now let's do the same for the
opacity property. Let's check it. Awesome. It looks really nice.
If you run into any errors or something
doesn't work, don't worry. You can simply copy the
expressions I used. They're listed in
the chat GPT folder. In the next lessons, I'll show you how to fix
expression errors. But for now, just follow along and get comfortable
with the process. Alright, now let's select all
the precomps and move them, so the one we're
currently looking at is placed in the center. I Great. Now, to apply these two expressions to the
rest of the layers, first open the opacity property, right click on it, and
choose Copy expression only. Then select the rest
of the precomps and press Control or
Command V to paste it. Let's do the same for
the scale property. Awesome. And now we need to control the position of
all the layers at once. To do this, let's create a new null layer and parent
all the precomps to it. Make sure not to confuse
the track Mat Piwip with the parent and
link Pick Whip. Those are two different things. Awesome. Now, we can move the
null layer left or right, and we'll get that
smooth carousel effect. Just imagine how many key frames it would take to create this manually by animating and
timing every single precomp. And that's the real power
of knowing how to use AI to help with real
tasks in our projects, even if you don't know
expressions at all. With that done, we've only
scratched the surface of what's possible with
AI and expressions. Now let's take it
to the next level. Let's say I want to change the scaling and opacity
values in the expressions. To do that, I need to
open each expression, find the correct parameters, and manually adjust
them for each layer. As you can imagine, that
takes a lot of time. So now let's learn how AI can
help automate this process. When you want to control expression
parameters dynamically, the setup is a little different. You've just learned how
to make a simple setup. Now we'll build a
more advanced one. To start, let's select
our precomps and double press E to
reveal the expressions. Now we'll delete all
the expressions, to do that hold down
Alt or Option on Mac, and click on the
property stopwatch. Let's do this for
all the precomps. And don't forget to
clear the expression from the centered
pre comp, as well. Great. Now let's go
back to Chat GPT and ask it to create a new
expression setup for us. I'll write the request
in a very simple way, and I can even include some of the expression terms like
the ones we saw earlier. So GPT understands which
parameters we want to control. So I'll just copy
these sentences from the expression GPT gave earlier, so it understands exactly which parameters I
want to control. Next, I'll add the opacity
parameters, as well. I'm simply telling
GPT that I want to be able to control both
of these properties. Let's see what it
suggests. Here we go. Without even knowing
this was possible, I just asked GPT if
it could be done, and it gave me the full
process step by step. It gave me the
expressions and also suggested which numbers
to use in the controller. Now, we might not fully understand what everything
means, but that's okay. Let's just follow the
steps and see what we get. First, I'll create
a new null layer just like GPT instructed, and now I'll make sure to label the layers exactly
as it suggested, so we don't run into
any errors later on. Awesome. Now, let's see
what the next steps are. We'll keep following
GPT's guidance and create four different
slider controls. You can find them in
the effects panel either by right clicking on
the null layer and going to expression controls or by typing the name of the effect into
the effects search bar. Great. Now, let's add this
effect to the null layer. Use Control or Command D to
duplicate it three times, so you end up with
four sliders in total. Finally, rename each slider with the exact names GPT gave. Just copy the names
from the chat and paste them into
the effect name field. Let's do this for
all four sliders. Awesome. Before we go further, this is a great time to save a backup copy of your project, just in case after
effects crashes. Let's save it as a new file. You can call it
something like practice. It's always smart to
keep a version of the project before
animation starts, especially in more
complex scenes so you don't lose your prepared layout if you ever need to start over. All right. Now, let's go back to the chat and copy the
scale expression. We'll test it on the
centered pre comp. In our case, that's picture six. Okay, so now we don't see the pre comp at all,
but that's okay. We're not getting an
expression error, so it's probably just a parameter issue
in the controller. As you can see, all
the controller values are currently set to zero. That's most likely the problem. If you do see any expression
errors, here's my tip. Delete the controller
name and type it again manually instead of copy
pasting it from the chat. For some reason, after
effects sometimes doesn't recognize pasted
text from other programs. Even if the name looks
the same, it won't work. And that's what causes those
weird expression errors. So just retype the
names manually, and the issue should go away. Anyway, let's continue
following GPT steps. Let's go back to the chat and copy the opacity expression. Now paste it onto the
opacity property. Then return to the chat and check what it
says to do next. And here it is. Step three, he
suggests adjusting the control values. So
let's do that quickly. All right. Now, let's
test it by moving our null layer from side to
side and see what happens. Amazing. It works perfectly. Now I can adjust the controllers
for the carousel setup and preview how everything looks just by moving the null layer. The great thing about this
setup is that you can always come back and tweak
the values anytime you want. Moreover, after we
finish the lesson, you can save this project with this cool setup to use it as a template for your
future projects. The only thing
you'll need to do is replace the pictures with
ones that are relevant to your project and adjust the controller if you want to make it look a bit different. For now, let's copy the
expressions we added to this precomp and paste them
onto the rest of the layers. To view both properties, first press T to
show the opacity, then hold Shift and press S to also reveal the
scale property. Now, let's copy just
the expressions and paste them to
the other layers. All right. Now we can test the controller and see
if everything works. As you can see, the fox layer isn't reacting to the
scale controller, so we probably forgot to paste the scale
expression onto that one. Not a big deal. Just copy the scale expression from one of the other precomps and paste it onto the fox layer. Great. Now, I want to mention
something really important when working
with precomps. If you decide to
collapse your precomps to maintain the highest
possible image quality, be aware that it might change the appearance
of your scene. As you can see here, the
opacity looks different now. But in our case, this
is super easy to fix. Just adjust the opacity
controller in our setup, and it will automatically
update all the layers. Awesome. Now, let's take it
one step further and make the design look even better by adding a simple
drop shadow effect. Let's tweak the shadow
parameters and also change the shadow color so it blends well with the background. Here's a great tip. When
adding a drop shadow, first sample the background
color from your scene, then fine tune the color values. That's how you get more
natural looking shadows. The shadow looks awesome, but I want it to appear only
on the centered precomp. I'm trying to create a
subtle elevated look. But as you can imagine, animating and timing
the drop shadow for each layer manually
would take forever. That's where our AI
friend comes in again. To help GPT understand
the context better, I'll take a screenshot
of my scene. It's important that GPT sees the drop shadow effect in
the layers in the timeline. So take a screenshot and
paste it into the chat. Now, let's try to explain
what we're trying to achieve. Again, using very
simple language. GPT is now suggesting
some steps. But since I already
have a controller that manages the whole setup, I'm wondering if I can add this drop shadow automation
to the same controller. So let's ask it.
Great. It says we can. Let's follow the steps
and see what happens. I'll copy the name now and go back to my project
to follow the steps. So first, we need to create another slider control
as he suggested, and we can paste the name
we copied a second ago. Okay. Let's also set it to 100, as we saw in the suggestion. Back to GPT. Let's
see what's next. Okay, I don't really
understand all of it. There's a lot of
explanation going on. Let's just skip ahead and
copy the expressions. The most important thing
for me is to check where the AI says to paste
the expression. In this case, it
says to apply it to the opacity property of
the drop shadow effect. So let's do that now. Now I can control the
drop shadow from here. I'll set it to 100 for
now and check if it disappears automatically when I move the null layer
to the sides. That's awesome. It
works perfectly. Now I'll adjust the shadow
color to better fit my design. And with that done, let's copy this drop shadow effect and paste it onto the
rest of the precomps. Et's move the null around
and see if everything works. Nice. The shadow only appears when the precomp
is in the center. I'm happy with how the
automation turned out. Since we now have a drop shadow applied to all the precomps, let's slightly tweak
the opacity, too, because the drop
shadow changed how it looks a bit. All right. So now we can animate the
scene however we want. In my case, I'll just create a simple side motion
for the carousel. At the beginning
of the animation, I'll start by showing
the elephant. Then after 3 seconds, I'll bring the tiger
into the center. Finally, 3 seconds later, I'll move the leopard
to the center. I just realized I
might not have placed the elephant and the tiger
perfectly in the center, so I'll go to the first keyframe and adjust
the nulls position value. I'll do the same for the tiger. Awesome. Now, as we usually do, let's improve the motion by adjusting the keyframe velocity. But this time,
instead of holding Alter option and double
clicking on a keyframe, I'll use a shortcut I
discovered not long ago to quickly open the
keyframe velocity panel. After selecting your
keyframes just hit Control Shift K or Command Shift K on Mac,
and there you have it. Now, let's change the
velocity to something like 75% for both incoming and outgoing
keyframes. Let's preview that. Awesome. Looks great. Now
let's go to Second nine and copy paste the first keyframe there so we get a nice
looping animation. Press in to shorten the
work area and go into the Speedgraph
editor to check if the velocity is consistent
across the full animation. Alright, everything looks good. And with that, we finish
the first lesson. The most important thing
I want you to take from this lesson is that sometimes it's worth spending a few
extra minutes building an automated setup before
jumping into animation. It can save you a
lot of time later, because when the client comes
back and asks for changes, you'll be able to adjust things
super quickly instead of dealing with tons of keyframes and redoing everything manually. I recommend practicing
this lesson further by adding a cool blur
effect to the setup. You can ask Chat GPT to make all the non
centered pre comps blurry and keep only
the centered pre comp in focus and see
what it suggests. The possibilities are endless, and I hope you now
understand how easy it is to build stuff like this
with the help of AI. I never used complex
expressions in my own projects, but now I feel confident
that I can build almost any automation I need without actually learning
expressions or coding. Alright, now let's open the second lesson
and close this one. And before starting to
watch the next lesson, don't forget to take
a ten minute break to refresh before we continue.
See you in the next one.
3. Bouncy UI Animation: Hi, and welcome back. In this lesson, we're
going to create a bouncy motion for the
UI panel you see here. But before jumping
into the animation, let me quickly show you
how I set up the scene. So I have a main
precomp of my avatar, and if we open the
precomps for this lesson, you'll see there's
one for the Avatar picture and one for the button. Inside the Avatar
picture precomp, I want to give you a quick tip. When working on
scenes like this, avoid making your precomp
dimensions too large. It's better to work
with small dimensions since we don't need to see
this picture up close. Also, just like in
the previous lesson, I use the track Mat
function to mask the picture with a circle I created using the Ellipse tool. Now let's explore the
main avatar comp. Here I have the
rest of the layers, including the button precomp, which is just a simple
rounded rectangle with a stroke and a text layer. All right, I'll close those precomps and let's
get into the animation. This scene, I want to create an intro animation
for the UI panel, but I want to make
it more interesting. I want to add some
secondary motion and make it move
in a bouncy way. Once again, I don't really
know what expressions to use, but I do know how I
want the intro to look. In my case, I want the panel to enter the
scene from the bottom. So let's create that basic
animation real quick. First, let's open the
position property. We can zoom in on the timeline to see the time
codes more clearly. Since I want the precomp to
end at its current position, I'll go to, let's say, second one and create a keyframe there. Next, I'll go to
the beginning of the timeline and move the
precomp down out of the frame. So now we have a very
simple animation. Before we add any easy
Es to the keyframes, let's take a quick screenshot
of the scene and ask hat GPT to help us make
this animation bounce. Make sure the
position property is open so GPT can
see the keyframes we've created. All right. Now let's go to Chat GPT. And instead of continuing
the chat from lesson one, let's start a new conversation by clicking on the
new chat icon. Great. Now we can paste the screenshot and
start chatting. First, always begin by telling GPT what software you're using. Next, describe what
you're trying to create. And before we move on, I've
got a question for you. How should we end our
message before GPT helps us? That's right. We need to ask, do you understand what I mean? That's the most important step. We want GPT to describe
our vision back to us before it
gives a solution. Only then can we be sure
it's on the right track? So GPT already prepared the expression and
explained how to apply it. He also gave us
some tips in case we want to adjust
the bounce settings. Here's what he thinks
we want to achieve. As you can see, he
got it really well, and he even mentioned a
new more accurate term for what we're trying to create. He knows we want to create an overshoot and
bounce animation. He already prepared
the expression and explained how to apply it. And he also suggested what
to do in case we want to adjust some of the parameters
of the overshoot motion. All right, let's copy the
expression and apply it to our position animation
to see what happens. I Awesome. We already have a
nice bouncy effect. But in my opinion, the
animation feels a bit slow. Let's bring the last
keyframe a bit earlier in the timeline. Place
it around frame 20. Now, zoom out in the preview
and check if the expression GPT gave you is also triggering an overshoot
on the first keyframe. If it does, don't worry. Just go back to the chat
and ask GPT to make the overshoot bounce effect apply only to the
second keyframe. Alright, back to the lesson. Now, let's easy ease the keyframes and
see what we've got. As you can see, the bouncy
effect is barely visible now, and that's because
the velocity of the keyframes changed
after easing. In that case, we can follow GPT's suggestion and adjust the amount of bounce
in the expression. Even if you know nothing
about expressions, GPT usually writes them
with short notes inside. So you'll know which values
affect the motion the most. All we need to do now is try different values until we
find something we like. First, I'll change the
bounce value in small steps. Then I'll try a bigger jump
to see what it gives me. I'm showing you this because I want you to feel free to change values and play around with the settings when
practicing on your own. Nothing bad can really happen. Worst case, you just press undo or ask GPT again for help. Alright, now that we found
a bounce value that works, I want to fix a pause that's
happening in the animation. It's important that
you understand why that pause is there.
Really simple. When we easy ease keyframes,
their velocity changes. And as you can see here
in the graph editor, the speed at this final
keyframe is currently zero. To fix this, we can convert the final keyframe
back to linear by holding control or command on Mac and clicking on it once. Now, the speed is around
13 54 pixels per second. Before it was stuck at zero. Now we've got motion
again. So now the animation will continue smoothly with the bounce effect. But as you can see, it's
a bit too much right now, and it's because we originally adjusted it based on
the eased keyframe. But now we have a
regular linear keyframe. So now we'll fine
tune the bounce settings again to
match the new speed. I'm showing you this process
because I want you to explore and get hands
on when needed. Don't be afraid to test things. It's the best way
to learn quickly. Now, let's make the
animation start more slowly by pulling the handle of the first key
frame to the right. In my opinion, it already looks awesome, and we're
ready to move on. Of course, you can always change the values to get a slightly
different look if you want. But now I want to make this
animation look even more dynamic by adding a simple rotation animation along
with the position. I'll also try to add
a fun bouncy motion to the rotation, if
that's possible. So let's start by creating
the rotation animation. Select the layer, press R, and then go to frame 20. Create a keyframe
here. This will be the final rotation position. Then go back to the beginning of the timeline and
rotate the precomp. Let's rotate it
to 25 degrees and adjust the position
at that point so the UI panel is
hidden off screen. All right, it looks nice, but I want to go
back to Chat GPT and try to come up with a
more interesting animation. Let's just tell it what we did and what we want to achieve. I want the rotation
to feel a bit wiggly. And since I'm not sure I
explain myself clearly, I'll ask GPT. Do you
get what I mean? Now I can see some explanations, and GPT is using terms like
jitter or shaking motion. So maybe I'll ask it to make the layer jiggle a
little and then stop. Let's see if it
understands the task. After reading the explanation, I'm still not sure
it's what I meant. So in that case,
I'll just try it out and correct GPT if needed. That's the helpful
part of exploring AI and after effects. I really want you to
follow these same steps and not be afraid when trying
things out on your own. Okay, so now I see that the
motion is a bit jiggly, but it still doesn't
look how I imagined. Before going back to the chat, I'll try adjusting some of the values in the expression
to see if that helps. After some testing, I still don't get the
exact motion I want, so let's cancel the expression, and now go back to the chat
and explain it better. I'll start by saying, This
isn't exactly what I meant, and then describe my idea
in an even simpler way. As always, I'll
finish by asking, Do you understand what I mean? This time, GPT says,
I fully understands. So let's see if that's true. Awesome. This is exactly
what I was going for. Now I can play around
with the values and tweak things until
it looks perfect. So let's play around
with these three values under the setting section
in the expression. All right. I think
it looks nice. After that, I'll adjust
the keyframes and see how they interact with
the rotation expression. Looks great now.
I'll also adjust the velocity to better
match the position motion. Again, it was really
important for me to show you this back and forth
process with GPT. Sometimes we don't get
what we want right away, but if you explain
things clearly, GPT will get it eventually. Alright. Now that we've created the intro for the UI panel, let's enter the
precomp and create some cool micro
animations inside it. In this case, I want to add some bouncy scale animation to layers like the
Avatar picture, the star, and the button. For the other
layers, we can reuse the bouncy position animation we created earlier
for the main precomp. So let's go back to
chat GPT and ask it to create a bounce or
pop up scale animation. We can also mention that we
want it to be similar to the popping position
animation we used earlier. So here we've got all the explanations and suggestions for the pop
up scale animation. Let's go back to the project and create the scale animation for the Avatar picture so we can
add GPTsEpression to it. Just like before, since I want the final scale to be what it is at the end of the animation, I'll go to frame 20 and create a keyframe with
the current value. Then at the beginning
of the timeline, I'll set the scale to zero. You can also isolate this layer so we can focus only on it. Now that we've got the
keyframes in place, let's try using the
expression GPT gave us. Great. It works perfectly. Now, I'll adjust the easing, so it matches the
position animation we created for the main UI panel. After that, I'll
play around with the expression
settings to see what looks best for this
specific layer. Alright, let's apply
the same expression to the next element
we want to pop out. Let's do it for the
button precomp. First, create the
scale animation, then apply the expression. Just select the layer and paste the expression. Let's
see how it looks. Now, adjust the
velocity and tweak the bounce effect until it feels just right for this layer. Awesome. This looks great. Let's do the same thing for
the star and the big number. Now, to apply the expression, select both layers and hit Control V. Let's
see how it looks. Since the number layer
is pretty small, I prefer to make
the bounce a bit more noticeable so
it pops nicely. That looks great, too.
Now, let's create a pop up animation for
the icon I have here. This file is really big, but I scaled it down to a
very small value. So let's see if the
expression still works on it. Sometimes GPT might create an expression that's based on the actual scale
value of the layer, and that might not work
well for every layer, especially if they're
all scaled differently. If that happens to you, just
go back to GPT and ask it to build the expression using percentages
like we're doing now. If you run into any issues, just explain that you're working with layers that have
different scale values, and you want a universal
pop up animation that works no matter what
the layers scale is. All right. Now that
we've finished the pop up scale animations, let's create a simple position
intro for the text layers. First, go to frame 20 and create a keyframe for
their current position. Then go back to the beginning
of the timeline and move the text layers down
and out of the frame. Now, copy the same bouncy
position expression we used for the main UI panel and paste it onto
the text layers. Finally, adjust the easing
and see how it looks. That looks great, but we
do have a small problem. You can see the text
layers entering the scene outside the borders
of the main blue shape. I've got a question for you. What do we need to
do to fix this? We need to make the text layers use the alpha mat of that shape. Then just turn the visibility
of the shape layer back on. Now, everything looks perfect. We've got the text visible
only within the shape layer. The last thing we need to do is time the micro animations we created inside the
avatar pre comp to match the animation
in the main comp. Let's start the
intro animation for the layers inside this
comp from frame 15. At this point, you can
arrange it however you like. In my case, I want the text layers to
enter the scene first, so I'll start with
the name coming in. Then after two frames,
the next line of text. After that, I'll make
the avatar picture appear followed by the icon. And finally, I'll
finish with the star, the number, and the button. Now, let's check the animation and see how it all looks
together in the main comp. I think the inside animation
should start a bit earlier. I let's try moving it to frame five. Yes, that looks much better. And with that, we
finished this lesson. I hope it gave you a little
more confidence to go out and start automating
your own animations. Also, I hope this lesson helped you see that
sometimes it's better not to create a
single controller for all the layers like
we did in Lesson one. In this case, it was a
smarter choice to control each layer separately and
adjust the values one by one. With that said, we're
now ready to move on to the next lesson
where we'll create a very cool hover
effect for the icons. It's going to be awesome,
so see you there.
4. Advanced Hover Animation Setup: Come back. In this lesson, I want to teach
you how to create an advanced hovering
animation setup. But before we start,
let me explain why I precompose my icons instead
of using the original layers. The main reason is that each
icon has a different size. If I animated them as is, the scene would be much
harder to control. When you work on
scenes like this, I suggest doing the same. It also makes it really easy to swap icons in the future
if you ever need to. As for the pre comp size, I suggest working with
small dimensions, something like 300 pixels for both width and
height should be fine. Use bigger dimensions
only if you know the icons will appear
up close in your seen. Anyway, as you can see, the size of this icon
layer is very large, and I scaled it down to 14. Same thing for the
Illustrator icon. They came in at the
same original size. But the Photoshop icon had
a different original size, so I scaled that one to 46. And for the Figma icon,
I used a scale of 33. My goal was to make them all appear the same size visually, and that's why I
precompose them and use the same dimensions
for all the precomps. All right, so I hope
you get the idea. Now, let's start building
the hovering setup. Let's imagine we don't have
a clue what to do first. So we're going to ask
Chat GPT to help us. With that in mind, I've
got a question for you. What will help us
explain the situation to Chat GPT clearly? We need to take a
screenshot of our scene. So let's do that real quick. Make sure your
screenshot includes the preview panel and
the layers panel. Here's a small bonus tip. To improve the clarity
of your message to GPT, you can draw a quick sketch
or arrow on your screenshot. In this case, I'm
drawing an arrow from the cursor to the
icon. All right. So now let's copy
this screenshot and go back to chat GPT. Let's create a new conversation and paste the screenshot in. And as always, let's begin by telling it what
software we're using. Then let's try to explain the animation we're
trying to create. Don't worry about making
grammar mistakes. Just try to be as
specific as you can. This time, I'll already
tell GPT that I want to control the different
parameters of the hover effect because maybe I'll want to
change them later. I'll mention the parameters
I already know about, and I'll also ask
GPT if there are any other parameters I'm missing that could improve the setup. And as always, let's finish by asking, do you
understand what I mean? So here we have all
the steps we need, and I can see GPT actually added a really nice parameter I
didn't even think about, which is being able to control the default size of the icons. Great. So let's keep going
and see what else we've got. I noticed in step three that GPT explains how to make
the motion smoother. That gave me the idea to ask if we can add this parameter to the controller so
we can adjust it without having to open
the expression manual. And here it is. GPT gave us the expression for
that parameter, too. So now let's follow the
steps from the beginning. First, let's go back
to our project and create a controller layer
using a null object. Make sure to name this layer
exactly as GPT suggested, because if the
names don't match, the expression won't work. All right. Next, let's create the three sliders and label them exactly
as he recommended. Now, we'll adjust the default
values for each controller, just like GPT told us to. And before applying
the expressions, let's also add that
final controller for smooth motion and set the
default value as suggested. Now, let's copy the updated
scale expression GPT created and paste it onto the scale property
of the first icon. Let me resize this panel a bit. If you're having trouble opening the expression
field, no worries. Just cancel the current
expression and Alt click on the Stopwatch
again. All right. After pasting the
expression, I see an error, so I'll click the expression
to reveal the error message, then use the shortcut to open the screenshot tool and
take a snapshot of it. Make sure your screenshot includes the full error message. That's really important.
Now, paste that screenshot into the GPT chat and let it
take care of the problem. Here we can see the explanation. Looks like the issue
is with a name I used. I might have typed
something wrong, but even if you
don't see a mistake, I still suggest you delete the name and type
it again manually. Like I explained in Lesson one, copying names from outside
sometimes causes weird bugs. And there we go.
The error is gone, and the expression
works perfectly. Great. Now we can start
playing around with the parameters to
see how they affect the motion and overall
look of the scene. Now, before applying
this expression to all the other precomps, let's try to improve the
hovering effect by making the icon move up slightly when
the cursor hovers over it. Let's go back to GPT and
tell it that we want the icon or precomp to move
up smoothly when hovered. Awesome. GPT suggests adding
another controller so we can adjust this
parameter whenever we want. Let's do
that real quick. Now, apply the expression
to the position property, just like GPT tells us. Let's check it out. Try changing the value on the new slider
to see what looks best. Once we're happy
with how it looks, we can copy the expressions
from this layer and paste them onto the
rest of the icon precomps. Everything looks great,
and the best part. Now we're controlling all the icons from a single controller. You can change all the parameter
values anytime you want. How cool is that? You can
even flip the effect around. So instead of icons growing
on hover, they shrink. So now we can even
reverse the effect, make the icons shrink
when hovered instead of growing. All right. I'll reset everything
back to normal. And now let's start
animating the cursor layer. At this point, as always, you can create any kind
of animation you want. You don't have to copy
exactly what I'm doing. My main goal in this
course is to help you learn how to build
expression setups using AI, not to focus on detailed
animation design. And I hope by now
you're starting to realize just
how easy it is to generate complex
expression systems that used to take a lot of time to learn and create
manually all thanks to AI. I Alright, I think my animation
looks pretty good, and with that, we've
finished this lesson. You can go ahead and open the next lesson and
close this one. In the next lesson,
we'll learn how to make a cool hovering effect for
buttons instead of icons. We'll also talk about what
to do in situations where AI refuses to give us the result we want no
matter how hard we try. It's going to be awesome,
so I'll see you there. But before jumping
into the next one, I recommend taking
a ten minute break.
5. Hover Color Change Automation: Hi, and welcome back.
In this lesson, we're going to create a cool
hover color change effect, and we'll also talk
about what to do when we run into annoying
issues with hat GPT. As always, let me quickly show you how I built
this simple scene. What I have here is just a few precomps
representing buttons. Inside each precomp, there's a text layer and a
rounded rectangle. It's important to know that
all the methods we use in this course work just as well
with regular layers too. You don't have to use precomps
if you don't want to. Alright. Now, let's start
building the expression. I want the buttons
to change color when I hover over
them with the cursor. First things first, let's take a quick screenshot of the
scene and the layers. Now, let's copy the screenshot, head to chat GPT, start a new conversation,
and paste it in. Then we'll describe our
idea in a very simple way. Since we have no clue how
to make the color change, we'll just ask GPT what effects we should
use and how to do it. And as always, we'll
finish by asking, Do you understand what I mean? All right. So here we
have the full process, and we can also see the
effects GPT suggested. I think the tint effect
is better in this case, since it comes from the color correction family of effects. Then I noticed GPT created an expression for
the fill effect. But for now, let's ignore
that and go back to the project to understand what the tint effect actually does, since that's the
one I want to use. Search for the effect in
the effect and presets panel and add it to one
of the button precomps. Let's now change
the colors inside the tint effect to get the look we want when the
button has hovered. Once that's done, check out
the amount to tint property. This controls how strongly
the new colors are applied. But let's say we didn't notice GPT created the expression
for the fill effect, and we copied that
expression and pasted it into the amount
to tint property anyway. As you probably guessed, we'll get an error message. Now, let's say I
don't understand the error, but I
still want to fix it. First, we can cancel
the expression. In situations like
this, the best thing to do is take a screenshot of your current setup and make sure GPT can clearly see what
effect you're using. Then paste the screenshot
into the chat and tell GPT, I'm using the tint effect. Can you tell me where exactly I should paste the expression? And right away, GPT gives us new steps in
a working expression. Let's copy that and
test it in the project. Nice. It works. But honestly, I don't love how the effect only triggers when the cursor is
at the center of the button. And I'm not a fan of the weird midtone color blending that happens when the cursor is getting close to the center. Let's say I don't understand
why that happens. I just want the color
change to happen instantly when the cursor
touches the button. In that case, just
go back to GPT, tell it you don't like
the current behavior, and describe what
you want instead as if you're talking
to an assistant. A after explaining, GPT will create a new
expression for us. Let's copy and paste it
into the expression panel. Awesome. It looks
much better now. Let's try collapsing the
pre comp to check if anything breaks or needs
adjusting in the expression. Everything still looks great,
so we're good to move on. So now we've applied expressions to effects and basic
layer properties. But let's take it
one step further and try using expressions
on layer styles. For example, right
click on the precomp, go to layer styles and
add a stroke effect. Open the stroke settings,
set the size to ten, and change the color to white. Now, I want this stroke to appear only when the
button is hovered. That way, we'll create a more unique and
dynamic hover effect. Take a screenshot of
this updated setup and go back to Chat GPT. In the chat, briefly describe the situation and explain
what you want to happen. And there it is. GPT
tells us to apply the expression to the opacity property of the stroke effect. Let's do that and
see what happens. Great. It looks really cool. Now we can copy this
layer style from the first precomp and paste it onto the rest of the
button precomps. After quickly confirming
that it works, let's do the same
for the tint effect. Copy and paste it to the others. I Looks awesome. Everything's working perfectly. Now, let's create
a quick animation for the cursor to
practice a bit. As usual, you can animate
it however you like. But don't spend too
much time on it. We want to move forward and keep exploring what AI
can help us build. For example, I want
the cursor itself to change color when it
hovers over a button. Why? Because in some
scenes like this one, the contrast between
the hover color and the cursor isn't
strong enough. The cursor becomes, but first
let's finish the animation, and then we'll try using AI to help us
generate the idea and the solution to make the cursor
more noticeable on hover. All right. So once we are
happy with the animation, let's start working
on the cursor changing color automation. Let's take a screenshot showing
the cursor hovering over the button and send it to GPT so it can understand
our issue visually. Once pasted, we'll
explain what we want to do and how we hope to
solve the problem. O. GPT suggests using the fill effect on
the cursor and then using the expression
on the color property of this effect. So let's follow the steps. First, we need to
add the fill effect on one of the button precomps. Next, let's change the
color. Let's say to yellow. We can also scale down
the cursor shape a bit, set the size to 65. And now let's paste
the expression GPT gave us into the
property it suggested. I see that the cursor doesn't
change the color at all, even if we try to
change it manually. But nothing happens. The
color doesn't change. We've pasted the expression
into the correct property, so now let's tell
GPT what happened. We'll ask if maybe
it's better to control the opacity of the
effect instead. That worked when we used opacity for the stroke layer
style earlier. All right, so let's copy the new expression from GPT
and go back to the project. Cancel the expression on
the color property and instead apply it to the
opacity of the fill effect. Still, nothing happens. Now, the cursor is
invisible for some reason, even though we don't have
any expression errors. Let's keep trying. Take a screenshot of the
situation and tell GPT. We applied the expression, but now we can't see
the cursor at all. A GPT responds with a longer explanation and a new
version of the expression. Let's give it a try.
Copy the expression, and let's quickly
go over the rest of the explanation
to see if there's anything important
we might need. Let's say we don't really
understand what he's saying. So let's just go back to the project and paste
the new expression. Okay, I still can't
see the cursor at all. Changing the values
does nothing. Honestly, after trying
more than twice, I'm starting to feel that maybe this approach just won't work. When I check the animation,
nothing happens. So clearly, something's
wrong here. We can cancel the
expression, and moreover, in situations like
this, I prefer to just try a completely
different approach. So let's remove the fill effect from the cursor and try it with the tint effect instead because that worked
better earlier. So let's add the tint
effect to the cursor, then change the color to yellow and now take a new screenshot
and go back to the chat, et GPT know that the
fill effect didn't work, and now we want to try tint. Let him do his thing. Then
copy the new expression. It might be a bit complex
and try it in the project. Still not working. No errors, but the color isn't changing. Let's try again and show
him the current situation. Take a new screenshot
and make sure to include the expression
in the picture. After pasting the screenshot, let him know that this
expression doesn't work. In the meantime, while he's
generating the answer, let's go back to the project
and cancel the expression. We can also try changing the second color of the
tint effect to yellow. Maybe that'll help. All right. The new expression is ready. I'll quickly scan
his explanation and suggestions to see if there's any important clue
for this setup. I didn't find anything critical, so let's just copy the new expression and see what happens. Still doesn't work. Now, before starting a new conversation
with the chat, I want to try one last thing. Let's go back to the
chat and tell him again that it's not working. But this time,
I'll also give him some technical
information and let him know that the opacity stays
at zero the whole time. Sometimes adding just a
little technical detail like that helps GPT better
understand what's going wrong. So let's just copy the new expression and see what happens. Awesome. This time,
it works perfectly. I wanted to show you this
entire process so you'll understand that sometimes you need to switch your approach, try a different effect,
or add a bit of technical detail to help
AI assist you better. Remember that when dealing
with tricky setups like this. Let's watch the animation
we just created. Awesome. Looks nice.
Now, before we wrap up, I want to give you a quick tip. Earlier, we added
a stroke effect to all the button precomps. Let's say now you want to
change the stroke color, but you don't want to do
it manually on each one, especially if you
might change the color again later. Here's a trick. Search for the color property using the search bar
in the timeline panel. So now we can see
the color property of the stroke for
all the precomps. Then use the pick whip
of the property itself, not the layer
parenting pick whip to link all stroke color
properties to the first one. Do this for each of
the button precomps. Now, you're controlling
the stroke color for all buttons from
a single place. This works for any
effect property. You can use this trick if
you don't want or don't need to set up
complex controllers like we did in the first lesson. Another smart way to
control the properties of an effect from one layer is to copy it with
the property links. That way, after you paste it onto the rest of the
layers in the scene, you'll be controlling
all the properties of that effect from
just one layer, and you don't need to parent
the properties one by one. And with that, we've
finished this lesson. Let's close all the layers
and watch the animation. Notice that even
though we don't have a lot of layers or
effects in the scene, the preview render
times are super slow. That's happening
because we've got some complex expressions
inside the layers. Telling you this because
I want you to know using too many expressions in your project can
really slow it down. Alright, the animation
looks great, and we can move on
to the next lesson. So let's open it and
close the current one. In the next one, we'll
learn how to create a super useful cursor click automation. It's going
to be a great one. So see you there.
6. Automating Cursor Clicks with Markers: Come back. In this lesson, we'll learn how to create a
super useful cursor click automation focused on making layers react to the click
animation of the cursor. To start, let's first create the clicking cursor animation. And what I mean by that
is, I want to activate the cursor's click without creating keyframes for
every single click. Whenever you need a clicking
animation for a cursor, it's best to have the cursor
in a separate precomp. So let's start by
creating the cursor. And this time, let's
make it look beautiful. Select the ellipse tool and set the fill to use
a radial gradient. We'll deal with the
colors in a second, so don't worry if it doesn't
look exactly like mine. Next, turn off the stroke. Quick tip. If you want to
switch the fill style quickly, just hover over the fill box, hold Alt or Option
on Mac, and click. This will cycle
through fill types. Same thing goes for
the stroke box. Now, hold Shift and draw a
small circle in the scene. Let's set the size to 100 so
we're all on the same page. Next, align it to the center and start editing the gradient. From my previous gradient tests, I have a bunch of saved colors. I'll drag them out
to delete them. Now, pick a nice color for
the first gradient stop. Make sure the opacity
is set to 100. Do the same for
the second color. I'll choose a dark pink, and again, make sure
the opacity is 100. If you want to add
more color stops, just click along the line. You can then choose any
color for the new point. If you change your
mind, drag the color stop out of the
line to delete it. Now, to adjust the
gradient appearance, switch to the selection tool to reveal the gradient handles. Zoom in and tweak them to
get the look you want. If you accidentally
click somewhere else and the handles disappear, just reselect the
ellipsis shape layer or open the gradient fill property
from inside the layer. If that still doesn't
work, you can adjust the start point or
endpoint values manually. That will make the
handles appear again in the viewer. All right. Now, let's add a
little highlight to the sphere to make
it look even better. Right click on the shape layer, go to Layer Styles and
choose inner shadow. Open the effect settings, change the color to
something bright. And then change the
blending mode to screen so it blends
with the base color. Now, you'll see the
highlight, tweak the values to get a
soft, glowing look. Once you're happy with
the cursor's design, we'll move on to creating
the actual click animation. Like I mentioned earlier, to
automate the clicks later, we should precompose the cursor. Call the new precomp cursor, make sure both checkboxes
are selected and click Okay. Now go inside the
cursor precomp. Here you can create any
click animation you want. We'll start with something
simple and then add some micro animation
to enhance the effect. So first, let's create a
simple scale animation. We'll make it ten frames long. I'll start at 100% scale, then shrink it down to 70%
and bring it back up to 100. Now, I'll easy ease the
keyframes and adjust the motion in the graph editor to make it feel more natural. Looks good. But I think we can make the
click feel even stronger. So let's go back and drop the middle keyframe
to 60 instead of 70. Yep, much better now. Now, let's add a
little micro animation to make the click
look even cooler. Kind of like a ripple effect. So I'll select the
Ellipse tool again, but this time, I'll turn off the fill and turn on the stroke. I'll color it white and set the stroke width to
four just for now. Now I'll create a
slightly bigger circle. Let's make it 400 in size, and I'll align it to the center. For the animation,
I'll go to the end of the click animation and set
a keyframe for the scale. Then I'll go back
to the beginning and set the scale to zero. Now I'll also animate
the stroke width. At the end of the animation,
I'll set it to zero. And at the beginning,
let's set it to 20. Let's try 60. Hmm.
Let's try 40 instead. I'll easy ease the keyframes
and adjust the velocity, so it starts quickly
and eases out. Now, I'll move this ripple
shape behind the main sphere. Let's preview that.
In my opinion, it's too fast, so I'll
select all the key frames. And while holding Alt
or Option on Mac, I'll drag one of the
last key frames to frame 15 to stretch it out. Let's play that back
again. Yeah, looks great. Now that the click animation is finished, let's
clean things up. We don't want a giant
precomp for no reason. So let's resize the precomp
to fit the animation. Set both width and
height to 500 pixels. Awesome. Let's head back to the main comp and figure
out how to activate this click animation without duplicating keyframes every time we want the cursor to click. So let's ask our new friend Chachi PT to help us
automate the click. First, take a screenshot
where we can clearly see the preview panel
and the Layers panel. Now, start a new conversation, paste in the screenshot
and explain the situation. It's important to tell
GPT that we already have a click animation ready
inside the cursor pre comp. Since this task
is fairly simple, and I explained it clearly, I won't ask, Do you understand?
I'll just ask how to do. Now, I see GPT gave me two options and both involve
the time remap function. So I understand that no
matter which method I choose, I'll need to enable time
remapping on my cursor comp. I've decided to go with
GPT's second suggestion, which uses an expression that activates the animation
using markers. Let's see if that
works. First, enable time remapping on the cursor
layer. Nothing happens yet. That's fine. Let's go
back to the chat and copy the expression GPT gave us
for the time remap property. Now return to the project. Alt click on the
Stopwatch next to Time remap and paste
in the expression. Nothing happens yet. That's
fine. Now, let's test it out. Go to second one and add a
marker to the cursor layer. Check the shortcut for adding a marker on your device
if you're unsure. Boom, it works perfectly. Now go forward another second
and add another marker. Nice. Let's preview it again. Awesome. Now, let's delete
the test markers and create a simple hover animation for the cursor as it
moves over each icon. At the moment, the
cursor motion is linear, so it doesn't pause when
reaching the icons. Instead of manually
creating pause keyframes, let's just easy ease all
the position keyframes. This will make the
speed slow down to zero before and
after each one, which gives a pause effect. If you want to fine
tune the easing, you can do it manually in
the graph editor or just use the shortcut Control Shift
K or Command Shift K on Mac to open the keyframe velocity panel
and adjust the influence. Now we've got nice smooth motion with pauses between icons. Let's go ahead and add markers at each point where
the cursor pauses. That way, the clicking
animation will trigger exactly where we want just
by using those markers. Let's preview the whole
thing. How cool is that? We're triggering
the click animation just by placing markers. No need to copy keyframes
or ripple layers manually. Imagine how long this
would take if we had to duplicate all the keyframes and layers for
every single click. Now, let's take this automation
one step further and make the icons react to the
clicking animation without animating them manually. I'll go to the point where
the cursors hovering over one of the icons and take
a screenshot of the scene, making sure it
includes the markers and the keyframes
we just created. Then I'll paste that
screenshot into chat GPT and explain
what I want to do. This time, since
I'm not 100% sure I explained it
clearly, I'll ask GPT. Do you understand what I mean? I love asking that because
GPT will often reply using the correct professional
terms for what I'm trying to build so I can learn how to better
communicate these ideas. All right, GPT understood
and gave me the steps. Since I added the screenshot, it already knows
what's in my scene. So all I need to do now
is follow the final step. That step is applying
the expression to the scale property of
the icon precomps. Let's try it on one icon
and see what happens. Perfect. It works great. But I'm not a big fan of how the scale animation
feels a bit stiff. So let's go back to the chat and ask if it can be smoother. As you can see, GPT already anticipated that and asked if
I want the motion smoother, so I'll say yes and wait
for the updated expression. Let's test the new version. Awesome. That looks much better. Now that we're happy
with the results, we can apply this expression
to the rest of the icons. But before we do that, I have
a quick question for you. What's the correct way to copy an expression in after effects? We need to use copy
expression only, not just regular copy. Looks great. And with that,
we finished this lesson. I hope you learned a lot of
new and most importantly, useful techniques
during this session. Thanks for watching, and I'll
see you in the next one.
7. Outro: Hello, it's me again. I just wanted to say thanks a lot for joining
me in this course, and congratulations
on finishing it. I hope you learn a
lot of new ways to use AI to speed up your
animation workflow, and you now feel more
confident using expressions. If you enjoy the course, I'd appreciate if you
leave a quick review. It helps me a lot. Thanks again for watching and I'll
see you in the next one.