Siggraph 2015 Rewind - Tim Clapham: Unleashing Creative Possibilities with C4D
Share this video
Learn advanced MoGraph techniques from Tim Clapham of HelloLuxx. You'll learn how to blend clones and transition between various objects and clone states, and how to trigger animations. You'll also see how to create an undulating cloth-like effect by combining the Displacer and Jiggle deformers.
01:24 | Petals - MultiShader |
---|---|
02:53 | Petals- Blend Mode |
05:02 | Lux - Hexagons |
10:40 | AGDA - Morph clones based on shader |
18:09 | AGDA - Take System |
19:53 | Cloner Stop Motion Animation |
24:03 | Trigger Keyframed Animation in loner |
28:35 | Cloth Effect with Deformers |
Transcript
- My name's Tim Clapham, thanks for the introduction. Thank you Maxon for bringing
me over here. And this is my Twitter if you want to follow me on Twitter. I'm
originally from the UK, live in Australia now, so a bit of a flight over. I run a
production company in Sydney called Luxx and if you want to see the work that we
do, then check out Luxx.tv for all of the work that I've done over the years. I had
a great time working with a lot of professionals, directors and different
studios, broadcasters. Also had a blog, which turned into helloluxx.com and it
started out as a small free tutorial site. It's evolved into much more of a portal
for training and for just sharing the knowledge, really. So if you're interested
in any of our free Cinema 4D, After Effects tutorials, head on over. We also
sell professional training. We have training for Houdini, loads of Cinema 4D
by myself and lots of other amazing artists from around the world that
contribute. Just released a new product, Learn XParticles, it's five mini projects
that take you through X-particles and hopefully teach you a lot of the cool
things that you can do with it. So, today we're going to be focusing on MoGraph. And
in this example scene here, we're going to off with a little petal. I want to talk
about the cloner and the blend mode really, and all the things that you can do
with blend mode. But first of all let's just have a look at this material here.
And we have a multi-shader, and the multi-shader allows you to bring in a
whole bunch of images, or shaders. You can bring them all in from one folder. Right
here we've got a whole bunch of petals, but the great thing about this is that it
allows you to just create one material and still have diversity. So if we come down
here you can see that I've got this cloner set up. Now this flower obviously is meant
to be seen fairly small, it's not meant to be seen at high detail. If we select these
petals and just have a look you can see that they're, only you know four polygons
each. So trying to keep this simple scene, keep
it nice and efficient. Now, we have a random effector here, and under the
parameter tab you can see that the color mode is set to on. And if we enable this,
you can see that the petals are now changed because it's picking them from
that multi-shader. And we can change the random seed if we're not happy with it and
we can get a whole different variety. Nice and easy. We've got a bend deformer on
here as well. We can use this to open and close this flower. But actually I've
already got one up here. If we unhide that, which is closed, and you can see
it's fairly low res. Drop these into a cloner object, and this cloner object is
set to a grid array. And by default, it just iterates through these clones so we
just see one after the other. But if we come to the object tab and we change it to
blend mode here, then what happens is it blends the parameters instead. So it's
blending the parameter of that bend deformer. And it's just starting here and
it's interpolating through up to here, so it's a fairly simple example. If we add
in--we've got a little bit of random rotation here, but we'll take our plane
effect. If we enable that, this doesn't actually do anything yet, but coming to
the parameter here, what we want to do is just choose to modify clone. And if we
drag this up, you can see that it's changing that blend and how it occurs. So
now we've pushed it to 100. Because we've only got two clones, 100 is the very last
one. But if we come to the effector tab and look at our minimum and maximum
values, if we take that maximum value and take that to minus 100 instead, instead of
the second clone it's going to use the first clone. So now we can only see all of
those closed flowers. We can then take another effector, like
this plane effector, and then we can use the modify clone parameter. And we can use
that and we can essentially control that blend. So if we set that up to 100, come
to the falloff--we can just enable some simple simple spherical falloff--and you
can see now that we only get that blending occurring anywhere inside that falloff. We
can also change the falloff here, and we can change it to a source file. And we can
drop--not a source file, a source link. We can drop any object in there and it will
use the vertices, or we can even use this, which is an emitter, and it will use the
particles. You can drop splines into there as well. And now if we rewind, press play,
you can see that as the particles fly over the flowers, they're like little bees
flying in, and the flowers are opening for them. You get the idea. So I though it'd
be cool to show you a real world example of how I've used this. We did a project,
worked with a couple of guys, Nathan Drabsh and Breckon Littlefoot, and this is
for a cinema in Australia called Hoyts and they do a luxury... They sit down and they
bring you the popcorn, that kind of thing. They called it Lux as well, which is...
They stole my name. So let's just have a look at this.
♪ [music] ♪
So the thing with this, if we just scrub
back through, especially a shot like this, we've got all of these hexagons
tessellating together perfectly. And, you know up here we've got this perfectly
mirror finish. And then we come down here and you can see that we've got this lovely
bevel. So what's actually happening is we're using the blend mode of the cloner
to go from having this bevel to no bevel. So let's just have a quick look at that
scene and how that rig was set up. So here we have first hexagon. Here we have the
other one without the bevel. If we come to the picture viewer quickly, we've got
this. I put this in because I thought it kind of looked a bit complicated. It's not
really. So in Cinema we can have a primitive spline that's a hexagon, but we
only get the radius. But these...we need all these values so that we know how to
offset our hexagon to make our rig so that it tessellates perfectly, and we only have
our radius. But you can see that if we have our radius we know that that's the
same size as this side, and we know that here we can find this length by the square
root of three multiplied by t, and we already know what t is because we've got
the radius. So we can use these really simple formulas to calculate how we should
offset those. So here's a little bit of Xpresso
that's...set that up. And it's really simple. These are user data, and they're
just really linked to the cloner so that we can control the count. And then here
the size controls the size of the spline. And then we take that and that goes into
here. So that float function is...you can see down here it's the square root of
three, and then we actually multiply that by the radius and then we divide it by two
and that gives us the position offset. So you could've, like, you know just scrubbed
the values until you get that all lining up perfectly, but by doing it this way
you're sure that it's going to be an absolute perfect fit. So I've dropped this
into a cloner and if we enable that, and you can see at the moment that even though
this cloner down here is set to blend mode it's not actually blending here, because
we've got render instances enabled. Now render instances allow you to create
hundreds and thousands of objects, but you only really use the RAM from the very
first object. If we disable that, you can see now that we are getting that blend.
And we can just do a quick render of that, and you can see we blend from this. We've
got a bevel, now we haven't, so. We drop that into another cloner to create the
other offset, and there we go. And if we come up, just enable this Xpresso. We can
select the Boolean and here's the user data I was talking about. And now we can
just grab this and we can you know, just create as many as we like, nice and easy.
And we can also scale it so everything fits together.
The other thing in the Xpresso was just this; when I enable the Boolean, I've set
it so that it switches render instances off, because with render instances off we
get the proper blend. But also we've got a Boolean here, so we're kind of blending
between all of those objects, and we're also going to bool it. It's going to be a
little bit slow, so by just setting up that simple automation it means that the
whole scene, you know, is really nice and snappy and we haven't got to worry about
any problems with, you know the file being slow to work with. So I've got just a
simple extruding here. Oops. And if we just come in a little bit closer, let's
just enable these effectors. These are just set up just as before where we're
modifying the clone. And when we use this one we modify clone again so that we can
get that blend. And with some falloff we can just smooth that off. And then added
in a shader effector here, using some noise to just offset these on y. Which
means that we can, you know, we can just grab this and we can just pull it up and
down, and we get a nice snappy result. You know we can have loads more of these if we
want, and everything would still be nice and quick. So we've got a really nice
quick playback. We can come in when we're ready, when we're happy with this. Just
come in here, enable this bool, it's going to change the render instances, and then
we can render and everything should work nicely, like so. And there you go. So, I
wanted to show another example of how we can use blend, and this is for a job that
I did for the Australian Graphic Design Association. They invite me to do a
creative response for their awards. It was really fun, because it was an open brief.
And the only rules were I had to have triangles in it. Other than that you could
do whatever you wanted. And so there's no client leaning over your shoulder, which
is always pleasant. So let's just have a look at that, and then I'll show you how I
created some of the shots.
♪ [music] ♪
So one of the problems in this project was the sheer amount of clones on this object.
So if you look at this shot here, you know we've got probably 200,000 clones. And on
the shot before you can see here, I think there's about 50,000 clones all rendered
with sub-surface scattering using Vray. And all of these clones are like morphing
between shapes. So obviously the challenge here was to make it so that I could set
this up and everything was nice and efficient. And to do that I used a very
similar technique to what I just showed you. So with the blend mode, you can
actually use it to morph geometry as well. So here we've got the objects and you can
see they're both using the same point count and the same point order. So if we
take this one for instance, and we add a post-morph tag, enable points so we can do
a point morph. You can just drag this in and create an absolute morph. And now you
can see I've just created a really simple morph. You can do this with a cloner as
well. So if we unhide this and enable it you can see here we've got it set to blend
mode. I've just got two children in here; these two. But by using blend mode, you
can see it's blending between those morphs, those two shapes, and it's
creating the intermediates. It's interpolating the geometry. So if we take
this, we can create as many as we like. On top of that you can also use an effector
to control that blend. So not only are we morphing the geometry, but we can grab
this spline for instance, and we can use that to control how that blend occurs. So
you really do have a lot of control. But I wanted to try that with a shader. So
I've got a plane object here. Rather than showing you 50,000 clones, let's just look
at it with a few hundred. So here we've got them just cloned across a plane
object. And again you can see it's blending through nicely. If we enable this
plane effector just as before with the modified clone parameter, so we take it so
it's only showing the very first one, and in here we've got six objects. I've also
got a shader effector here with some noise. And if we open this up you can see
that we're using displace for annoy. And that's actually an animated noise, so it's
just going to evolve and undulate. But what will happen is it'll take those
grayscale values and if it's black it's going to show the first clone, if it's
white it's going to show the last one, but on the gray values it's going to blend
between. So if we enable that, you can see that we get this nice sort of undulating
effect. But when we press play you can see it's a little bit slow. We really want it
to be a bit quicker than that. And obviously there aren't that many clones
here. If we've got hundreds of thousands, or even tens of thousands, it's going to
really start to slow down and workflow is going to become a bit prohibitive.
So what can we do? We could use render instances. So if we select this and we
enable render instances, you can see that now you get a much faster playback. But
because we have render instances, it doesn't really create geometry, it's only
showing that each clone--it's not actually doing the blends so you get this stop
motion effect which isn't what I wanted. So I was thinking, well how can I do it
with render instances and also make it so that I've got all of those blend shapes?
Well I thought well okay we'll just create the blend shapes. So that's what I did.
There we go. So if we unhide this one here you can see that what I've done is I've
blended it but I've created 200. So now if we have a look at this you can see that
we've got every frame that we need. We don't need to interpolate because we've
just made them all. So we put those 200 clones in like so, and we get exactly the
same result as before, but now we're using render instances, and when we press play
we're getting a reasonably fast playback. We can see everything. Of course the other
issue here is that we've got like fairly low res geometry, and if you'll have a
look of these, you know obviously if I have any close-up shots we're going to see
all the polygons, all the edges. We don't want to see that. So we need to subdivide
it. But again, because render instances aren't real geometry, we can't just use a
subdivision surface, because if we do that half of them disappear. And that's because
half of them aren't real geometry. Even though they look like that. So using that
isn't an option. But you can still do it, you can just do it with a material. So
here we've got a material, we've got some displacement. We're using sub-poly
displacement but we've set that to a very small height. So any set to 0.01, so
you're not going to see that but when we render it you're going to get that nice
smooth subdivided surface. So it means that we can create our subdivision with a
material, we can use render instances, everything's nice and quick, nice and
snappy. Here's one of the scenes from that job. And the rock itself was... I bought
it on TurboSquid, it's like a couple of million polygons. This is just a small
section of it, but you can see that because it's scanned, some of the polys up
here are a bit messy. I didn't really want to spend all my time going around the
mesh, finding everything, pulling those around. So we can just drop a smoothing
deformer on there, and that just smooths it all out a little bit.
So here's the cloner. Let's enable that. And you can see that we're using the blend
mode once again. We've got 50,000 clones on there. Now it may look like we've got
this super high-detail rock, but actually if we just come back you can see that what
I've done is just deleted all of the polys that we don't need--we can't see. Just to
keep it as efficient as possible. Add in our plane effector just as before. We've
got a random effector for some scale, we've got the shader effector with the
noise, just as I showed you in the previous scene, and then we've got a plane
effector here that we're using to wipe that on. Because I'm using a display tag
as well I've got the level of detail set down to 10, so even though we've got
50,000 clones we can view it as box mode with a lower level of detail, and it means
that we can scrub the scene, and you know even on this old Mac Pro under here, it's
still fairly snappy. So it's all these kind of things that mean
you can get your work done nice and efficiently, you don't have to worry about
the overhead or any technical limitations. Here's the actual scene that I used. I
wanted to show you this because it's a good example of the new take system. So
this was rendered in Vray just to show you the take system just works with all the
other renderers as well. No problem at all. And you can see that in here we've
got three cloners; one for the close-up shot, one for the wide, one for the front.
I've got my three cameras, I've got various effectors, I've got different
lights. I've even got animated materials on some shots on the other shots they're
not animated. If we come into the render settings you can see that we've got three
different render settings here. If I come down to my layers you can see I've also
got some layers so I can solo the various shots nice and easily. Now previously we
used to have to go through, change the render settings, set the layers, switch
the cloner off, switch the other one on. We don't need to do that anymore, we can
just set up some takes. And here's my takes, very simple. So if we select this
first one, you can see that in here it's set to enable this cloner, make it
visible, whereas the others it's set to disable them and hide them. With the
textures, I've set that up so that it swaps the actual material that's in the
tag so that I can just change the take, soon as I do that it changes all of these
parameters, we jump to that camera. If we come into the render settings you can see
it's changed to the correct render setting. And we just switch to the other,
and it does it. Everything's automatic. We can even come here, we just tick these, we
come up, which is save marked takes with assets, and that'll save each one of those
takes as a separate project with all the assets you need. It'll set the camera, the
render settings, you can just save them into your render farm directory and then
just hit render and go. It's so efficient, I've used it for about the last eight
months and I use it on every job and I just couldn't live without it.
It's awesome. So, the next thing that I wanted to show you is a way of using the
cloner object but this time to create, like stop frame animation. So rather than
before we were blending between parameters of objects, or we were blending geometry,
this time we can create a whole bunch of frames. So here if we have a look at this
you can see I've created all of these splines, it's a simple little kind of
cartoony explosion, all drawn in Illustrator. I've got these in a cloner,
but this time the cloner, and the important thing here is that the cloner is
set to sort mode. So sort mode means that we can use effectors to determine which of
its children it's going to show. We've got a count of one, so if I enable this it's
only going to show one of these splines. And just to keep it efficient, I'm just
keeping the splines in here, and then I'm going to create the geometry afterwards by
adding in a loft. And there it is, a little humble little explosion. I've got a
plane effector here, and once again we can use the modify clone parameter, but this
time rather than doing the blend, it's going to show the different children. So
what've we got? We've got nine in here, so you can see as I come, as I increase that
we see the next one and then the next one. So we can essentially drag that through,
and we've created this little explosion. Of course it still works with falloff and
everything else, so we can set that up to 100, and then enable falloff. I'm going to
use a linear falloff here. There's my effector. I've got some keys on here just
so it moves through. If we press play you can see that it just animates. So it's
very simple, but it's a way of kind of automating stop motion and keeping it
fairly parametric. So rather than it being a tedious task, we can take this we can
duplicate it, and we can keep the whole thing parametric, and we can create quite
complex animations using a stop frame technique. It could work perfectly well
with a 3D object. And the great thing about this is if you want to control your
timing, we can just set it so that that falloff just moves through over ten
frames--well, nine frames. And then we're on ones. Or we can move it through in 18
frames then we're on twos. Or you can make the falloff a bit bigger.
Here's another example of a very similar thing. This time we've got a planet here,
it's actually just a sphere and some atmosphere. And then I've got a plane
effect just sitting in here. And if we just enable this, you can see I've set the
falloff so it just kind of fits into the atmosphere. This little white thing out
here is just a standard emitter. Here's my cloner, just as before. It's the very same
setup, this time I've just had a little spaceship that I've added to it. So if we
enable this emitter and press play you can see that we get all these particles flying
across. There we go there's one. And then we can set our cloner up to clone onto an
object, but the object that we're going to use is the emitter. So we put the emitter
into here, so if we enable this... Oh. And let's enable that one, you can see that we
get these little spaceships. We can also make sure that they always point at the
camera, because they're 2D. But you can see that as they hit the falloff it
triggers the animation. So we're kind of creating this procedural animation using
stop motion techniques. So it's pretty cool. We're in 3D space, we can move
around. They're always going to face us. Nice and efficient, nice and quick. If you
had to do this by hand it would be pretty laborious, so it's great to be able to,
you know use the cloner object and it's slightly an unusual way of using it I
think. Next thing I wanted to show you was
another thing with cloner. This time, a way that you can actually trigger key
framed animation. So previously we were creating animation with the cloner, with
sort mode, or with blend mode. This time we're going to use some key framed
animation. So if I just rewind and we have a look at this, you can see that's really
simple just a box unfolding. Let's enable this cloner object. Okay so now if we
rewind you can see that they're all--what's going to happen is they're all
going to animate. Let's put render instances on. You can see they all animate
simultaneously. Now I've got a shader effector here. In here we have this, just
this very small bitmap, just created in Illustrator, just some really simple pixel
text, but we can use that to control the visibility. So the shader effector has the
parameter here, the visibility is set. And if we enable this it's just going to hide
some of those so we can create some simple type. If we look next to the visibility
check box we have this time offset. Now time offset is pretty cool, it allows you
to offset any key framed animation. So if you use a random effector, your animation
will randomly trigger at different times. If you're using a shader effector like
this, then you can trigger your animation with a material, or with a shader. So you
could use noise so that, again it was random. Or you could use a gradient so the
animation starts one side and moves across to the other side. The time effector,
however, is a slightly different beast. The way that this works is it increments a
value over time. So if you were doing rotation you could say okay let's rotate
one degree each frame, and your object's just going to continually rotate. If you
use it with the time offset, however, essentially it's going to slow things
down. If we come and, let's have a look at the timeline. See here that--you know, I
would say it's a really simple animation, but it lasts 25 frames, so the last key is
on frame 25. The time effector--time offset I've set to 25. So it's never
actually going to animate, it's already offset the time. It's never going to reach
those keys. So by doing that with the time effector we can press play and it's never
actually going to animate, but it is animating internally we're just pushing it
past those keys, so it's like it's always, it's done the animation.
So... There we go. So you can see it's not working. But it is internally, so what we
can do is we can negate that value and we can then use another effector and say
minus 25. So I've got a plane effector here and that's set to minus 25 so
whenever that passes over those clones, it's going to trigger the animation. This
is a trick shown to me by Pear Anders, who is one of the geniuses that wrote MoGraph.
It's a really simple little trick, but it just means that we can then trigger that
animation. So you can see now, here's my plane effector. If I drag it through it's
triggering that animation. It's fairly simple but even just that little thing is,
there's a lot of power there, especially with a more complex scene. At the moment
obviously it's very linear. We're just using a linear fall off, but with the
cloner object we have this thing called weight. And if we come to the transform
tab we can make that visible. And we can see that we get these red dots over all of
our clones. And the red dot signifies that they're all the same weight. And weighting
with MoGraph works in a very similar way to like a vertex map, where you're
weighting for deformation and you can control the influence a deformer has on a
mesh. And in that example, obviously you're going to be weighting the vertices,
but here we're weighting clones, and it controls the influence that the effectors
have. And this random effector is set to
transform the weight. So if we enable that and come back to our cloner you can see
now they're all different colors, so we've just randomized that weight. And it just
means that it's not going to be quite so uniform. Now when we grab this effector
and we pull it through, you can see that it happens in a much more random, a bit
more organic kind of, or more pixelated way. So there's one more thing that I was
going to show you guys. If we come back to this job here, now this was rendered in
VRay for Cinema 4D. I was really fortunate to be able to use the beta of version 3;
it's awesome. And my favorite thing in it is this new, well I think it was new with
version 3. It's this ray-traced, refractive sub-surface scattering. And
it's like, it looks amazing and it's beautiful. So I thought I'd show you how I
set up this shot with this kind of globby thing that runs over.
Now I'm not going to go into the material setup, but just to create the geometry.
And it's really simple, again using the rock that I bought from TurboSquid. So
here we go. So here's the rock itself. You can see--there were two versions of the
rock; a lower res version that someone had redone the topology. So I worked with the
low res one for this. And I wanted it to be hidden inside the high res rock, so to
make it hidden inside I used a displace deformer. So displace deformer's a really
cool thing because it work just like displacement on a material but it allows
you to use a falloff, and it also allows you to use a whole bunch of shaders and
see that real-time in the view port, whereas normally with a displacement
material you don't see the feedback until you render. So the displacer object allows
you to see that. You can see that when I enable that all it does is it pushes it
in. I've set the displacement to be minus 15. Let's just hide those edges for a sec.
Oh, did I just change that? Yes, we don't want to do that, do we? To make the mesh a
bit smoother we can add on a smoothing deformer. And the smoothing deformer's
really cool. It's a bit like a subdivision surface. Again it's a deformer, so we can
use it with fall off. And we can control the number of iterations and the type of
smoothness that we're doing. We can also drop in a vertex map etc. , here, to
control the stiffness of it. Now I animated this object, then added--now
which one did I animate? Well I animated one of them. But then I've got these
constraints on here so that we don't have to animate all the objects we don't need
to put them as children, we can just use a position constraint, link them all to the
one animated object, and they're all going to move with it together. I think it was
this one? Yeah, so it's the displacer out and this one is pushing the object back
out. So we moved it in minus 15 so it hides inside the rock, and then twenty so
it comes out. So if we just play that through, you can see that as this
displacer comes down, you kind of get this first motion. We've got a few problems
with the mesh, it's like a really high res mesh and the topology--some of the
polygons are a bit messed up and inverted. So we can just add in another smoothing
deformer to help fix any of those issues. It's all a bit static at the moment
though, so one of the great that things we can do is use the jiggle deformer. The
jiggle deformer is really nice because it allows you to jiggle things around. And it
can give you a kind of a cloth feeling. I did a little bit of noise on there, add
the jiggle deformer, press play. So we've got all of these deformers running through
on this, a fairly high res mesh. And you can see just the jiggle deformer itself is
creating all of these lovely creases and we get this nice wobble and so it feels
like a bit of jelly or a piece of cloth or something. One of the awesome things about
the jiggle deformer as well is that it's got this caching system. And you can see
this one's already been cached. So we can really--we can switch off all these
deformers, we don't need those, and now we should get a much quicker faster playback.
So once you've set it up, use your jiggle deformer you can cache it on there. It's
just caching it on that one object and your playback is going to be much quicker.
You're not using--you're not having to calculate all those different deformers.
And you can see that's how we kind of got this effect.
♪ [music] ♪
In this example here there's just one of
them, though, but what I actually did was layered up several of them on top of each
other. And I think that's why the sub-surface effect looks so nice, because
we've got these various shaders using sub-surface, layered on top of each other.
And because it's a ray-traced sub-surface, it's kind of calculating through each
mesh. And if we just enable all of these, you can see the kind of effect. Really
simple. And then what I did at that point, then I just converted it into a cloth
object. Made the logo inside and just pulled it backwards. And that's how I
created the end part. So I hope you enjoyed that presentation. But before we
finish, what I'd like to do is show you my reel. So thanks for coming. And let's just
check out the reel.
♪ [music] ♪
Thank you, thanks for watching.