- Yeah, my name's Casey Hupke. I'm a freelancer cinema guy out in Los Angeles.
I do a lot of design and do a little direction, make a lot of content for
concerts and installations. And for the past year I've been tinkering around in my
office at home working on a VR short that I was hoping to show off at NAB this year
but, like every personal project that a creative has, delays and scheduling
conflicts come up and you just don't finish things. So today, we're going to be
talking about some of the things that I've learned in VR filmmaking. It's really hard
to really call it filmmaking. I feel like when you're creating an experience in a VR
world or a VR field, it's more of you kind of give up your directorial authorship and
your authority as a director to tell people where to look. You can't really
frame something. There's not rule of threes. If you try to use a spiral on the
screen to see if everything looks good or was formulated correct you'd be wrong
because it's a giant 360 panoramic. So you have to do a lot of sleight of hand and a
lot of tricks to get people to look at the stuff you want to look at, because there's
always going to be those people that are sitting with the head-mounted display on
for the first time that are just looking at a rock texture on the ground or some
dust particles that are over here. And you're like, "Guys, there's a portal and a
planet exploding over there. Stop looking over there." So we're going to talk about
some tricks. There's a lot of ways to get into VR. There's a lot of points of entry.
Some people think that it's a real-time thing. Some people aren't really aware of
the different versions. But if you're walking around NAB today, you're probably
going to come in contact with at least 12 different branded versions of a Google
Cardboard. So just grab one of those and go on YouTube and look for some 360 videos
and play around with it. It's a really fun way to do it. There's also the Oculus
Rift, the HTC Vive. There's the OSVR and the PlayStation VR. All of these are
different technologies, basically the same. The only one that's really that much
different than the rest is the HTC Vive, which has more of a room aware type thing
going on with it. And the formats that exist for VR, we have
basically YouTube 360, which is if you imagine a exploded map, any map that you'd
see of the world, it's an unwrapped version of a sphere. And then if you take
that picture of the map and then rewrap it on a sphere that you're inside, that's
effectively 360 VR. You can kind of look around and see the whole image. And then
the stereoscopic version of that is that happening in two eyes. Oculus has a little
bit of a different thing going on with the way it handles some of its stuff. Oculus
and Vive and OS, those are a little bit different then YouTube VR. They also use
cubic mapping and other stuff like that. It's a lot of white paper stuff that we
could get into, but I want to talk more about creating stuff in cinema and
breaking things up. Here's an example of a 360 video. It's inside of a cube, colored
all weirdly. It's blown up in 360. On the top, we have stereo VR. You can see it.
It's just two of that image for the left and the right eye, very similar to
stereoscopic 3D. While I've been working on this space-based short film, these are
some cool new things that I found on the internet that have been shared with me.
This little guy right here is a web page that's hosted on GitHub that lets you
randomly create procedural planet maps. You can basically generate and control the
surface, the shallow depth of the water. But normal map, the bunt map, the clouds,
you have complete control over generating infinite worlds. And I use these shaders
in conjunction with Octane to create a lot of planets and stuff that I've been
working on in my short. In my short, there's about 17 to 90 planets in your
field of view at once, that are kind of all just rising up on the horizon,
crumbling down, and sucking through this wormhole. So yeah, I use this a lot. I've
spent a lot of time trying to figure out how to make planets on the fly really
fast. And sometimes you don't need to make the tool yourself because it already
exists on the internet. This thing was amazing. This guy that I
met on the internet, named Patrick, shared this with me recently. It's a procedural
Skybox generator that allows you to make nebulas and star fields and starscapes up
to, I think, 8K resolution. And it's great. It works. You can drop the Skybox
right in Unity or right in Unreal and you have, as you can see in these screenshots,
just immense layer of control. Both of these applications are free. And then did
you guys know that there's Quicklook on Windows? There is. And also
hashtagmotiondesign.com. It's a community of slack. It's a slack community. If
you're creative, if you use cinema, if you're on MoChat, on Twitter, or if you're
on any social networking and you are looking for people to talk to about
Cinema, illustration, what graphics card is the best graphics card for Octane, this
is where you want to go. Vote Hupke. And then, yeah, so here's a little 360 render
of what we're going to be making. The reason why I'm opening with this is
because the focus of what we're going to be doing is shattering and exploding a
very large planet. In the viewport, it looks very, very large. In a 360 render,
it's suddenly not that important. So, without further ado. Thanks to Aaron
Frebowitz for doing my branding. And let's go ahead and take a look at my reel since
I skipped over that. Thanks Adam Elder for cutting my reel.
♪ [music] ♪
Yep, that's some stuff that I worked on
with some really amazing people in LA and around the world. And every day that
I get a new job in this industry, I'm super stoked. So thanks to everyone I've
collaborated with on all those jobs. You've all been a huge part of letting me
do what I do for a living. So yeah, let's get into it. Let's go ahead and start
talking about our overview of our scene. We're basically going to be creating a 360
degree environment in which a planet explodes. I have a little video for us to
look at of what all the layers that we're going to be making look like in the end.
We're going to render the volume with turbulence. We're going to fracture the
pieces of the planet with NitroBlast and NitroVertex. We're going to play around
with ways in Xpresso to dynamically control when rigid body tags become active
and start doing their thing. And we're going to play with xrefs. So whenever I
start working on a project, the first thing that I do is do a quick little
layout with block geometry for what I want. So let's go ahead and start with
making somewhere for our... Well, actually, let's go ahead and start with
setting up our project to function in the VR world. There is a plugin from
Cineversity called CV-VRCam. And it is available to you inside of the CV Toolbox,
which if you're not aware of it it's one of the best things you could possibly do
upon first loading up Cinema. You have amazing tools that have been
around forever, like Natural Selection, ArtSmart, CV-VRCam, Spline to Object,
Daily, StopMotion. There's so many free plugins available inside CV Toolbox that I
really encourage you all to get in there, check them out on the website and
everything. We've already got it installed, so there's no reason to show
you how to install it. Let's go ahead and hit this guy right here, merge camera rig.
And what this is going to do, we'll take notice, is going to drop a rig of cameras
for forward, left, reverse, right, up, and down. And if we make a floor object, we'll
notice that this camera is off the ground. The reason why it's off the ground is it's
set at the height of a tall person. And that's a thing that you want to consider
when working in the VR space because real world values matter and you have to
constantly be aware of point of convergence, like you are with
stereoscopic 3D. The distance between a pupil, the distance between objects that
are in your foreground, then the objects that are in your background, you want to
be aware of that stuff. So it's really important that CV-VRCam kind of sets this
up for you as this height. Originally, when I was working with it I was basing
it, my regular height, off the C4D figure and I didn't realize this for a while, but
the C4D default figure is 600 centimeters tall. He's 20 feet tall. That's a giant
person. But yeah, I was basing off that and a lot of my earlier renders and tests
were like, "Uh, this is weirdly scaled." So let's delete that. We've already got
our camera set up now. Just like that. For Octane, which we're going to be using a
pretty decent amount of, it's pretty easy to set up and pretty straightforward to
set up how you render a 360 view. You basically just go add your Octane camera
tag to your camera, change your camera type to panoramic, and then if you're
doing stereo, go ahead and go into stereo and set it to side-by-side.
And then in your output settings, let's go to plugins CV-VRCam, create render
settings. Right now there's not one for Octane, but Rick and Co are adding one in.
So we're just going to go ahead and duplicate YouTube VR 2160 by control
dragging it down. And we're just going to call this Octane VR. And the resolution
for Octane VR, because it's rendering the two side-by-side, is going to be our width
times 2. Oh, let's undo that. Let's unlock our ratio. It's going to be our width
times 2 and our height, agh, times 2. And our height divided by 2. So that's going
to give us two 1080 focals and let's go ahead and just do a quick little Octane
render so you can see. Well, we'll do that after we do our layout. All right, so
let's lay out our scene that we've set up for our stage. We have our terrain object
and we have our portal and we have our planet. That's what we're going to be
building today. On Thursday, if you guys come back or you guys check out the
archives, for the guys watching the stream, we're going to be filling this
environment with a whole bunch of particles. Today, we're going to be
shattering this stuff and playing around with rigid body dynamics and sort of
establishing a scene. And on Thursday, we're going to go over using particles to
sort of travel and direct the viewers eyes back to the giant planet that they're not
looking at for some reason. So let's make a landscape to work with. Let's go ahead
and make a landscape object. I like the landscape object. It's a really quick way
to make terrain. We're just going to scale this up a little bit. I'm going to make a
figure, just for a reference for human size. I'm going to make it 180 centimeters
tall, which is a pretty tall person. But to help us get a sense of scale in our
world, it's important that we have a point of reference like this average human
shaped figure. So let's make our landscape much bigger. We don't need it that tall at
all. Because we want this to have sort of a plateau on the top. And I'm going to
adjust the landscape position to be on his feet. I'm going to keep adjusting
everything around where this figure's feet are. And since he's facing this way and
the camera is facing that way, let's just go ahead and make this all the same so we
can kind of always think about this guy in perspective. Next, let's go ahead and
create the basis of our planet. They incorrectly spelled sphere. Let's take the
sphere out here. Let's go ahead and go into our forward cam. Let's make our
figure not visible. Let's go ahead and drop this in an interesting spot. Let's
scale it up. And let's see. Okay, now it feels like a really big planet. But, let's
open up our Octane settings. For a lot of my rendering, I'm going to be using, this
is kind of like my default setup for working in pre-vis with Octane. On
Thursday, I'm going to be going more in-depth on the Octane render side of
this, like texturing and mixed textures and all that kind of stuff. I'm going to
talk about it a little bit today, but mainly Thursday is going to be particles
and lighting and rendering. This is going to more about setting up the big chunks
and big, heavy framework portions of our scene. All right, so let's go to make sure
our output module is set to our Octane VR. We're going to be doing our
pre-visualization before we go to full nuts, 8KY VR.
Let's just focus, let's just learn to walk. And let's go ahead for render times'
sake, well we'll keep it with that. This is going to be fine. Let's go ahead and
save this file so we don't end up flipping over a table when I crash halfway through
without ever saving. Name it something innocuous that won't mean anything to me
in six months' time when I look at this directory again. And let's go ahead and
set this. Let's go ahead and load our Octane Live Viewer window. Let's lock this
to the aspect. Oh, we can unlock it. Let's go ahead and hit render. We're still
rendering stereo VR. Everything is black because we don't have any lights. We have
no shaders inside. I'm going to go ahead and hit undefined, reload this. Let's just
switch it to left eye. That should be not doing like that. Let's switch back to
YouTube 3160. Let's lock this and reload it. There we go. Reinitialize. Okay, so in
our viewport, in our regular world that we normally would work in, this planet seems
just massive. It seems really big. It seems almost too big for the scene scale
that we have and it's colliding with our landscape. So let's just move back a
little bit. And if you notice, in our viewport it gets even smaller as it goes
because we have to consider this whole, giant world where nothing's really going
on. Because as people are going to be looking at this stuff, they're going to be
looking over to see what the textures look like on the ground and what the particles
are doing. So we can't really rely on just working in this perspective view. We have
to constantly be considering this entire panoramic 360 cutout. So I'm going to
leave that right there. And then, behind that, I'm going to make the basis of our
portals. They're going to be torus objects. We're
going to set it up with that for now. Let's go ahead in our top view. Move this
torus to the back of our sphere right here. And let's, whoop, careful. Let's
make a giant, lard, lead donut just hanging out behind the sphere here. And
this is going to work as the object that supplies us motion for X particles. This
is going to work as the object that supplies us a service to a Turbulence
FD [sp] fluids from. This is going to do a lot of work for us and it's
just one simple little torus. So yeah, let's perspectively get this at a nice
view. Let's open up our live viewer. Reload. Let's actually go ahead and do
this. I'm going to go into my other scene and I'm going to grab the lighting setup
that I've already made, and I'm going to bring this over into our step one. And
boom, we're lit. But I need to relink an image texture really quick for us so it's
being lit correctly. So I'm going to select this environment tag. I'm going to
go to my main... Oh, we got the image texture. Okay, cool. It's all good. And
now, I'm just going to...well, we can make the materials at the next one. Okay, so
now we have three basic utilities to work with. For our sphere, this is what's going
to be our planet that we're going to explode. We are going to explode this with
a plugin called NitroVertex. So I'm going to make a Nitro... Okay, we're just going
to use NitroBlast because Vertex isn't loaded right now. And that happens
sometimes. So, we're going to grab our sphere.
And we are going to, we're basically just going to use this tool. It's a plugin that
fractures objects volumetrically in cinema. There's a lot of different
versions you can do. I wouldn't say that this is necessarily supposed to be a
tutorial on how to use NitroBlast. It's more or less the tool that I'm using to
fracture it. And I think the takeaway that I would say to get out of what I'm talking
about fracturing, is that a bad fracture is a fracture that's just a one-step
fracture where pieces drift apart and scale down. A good fracture is where we
have an object drifting and then extra pieces start crumbling off of it and we
see things sort of disintegrate and start doing something really interesting and
cool, more about living in that whole subarea. So let's go ahead and just make
this split up into 30 pieces. Thirty piece for now. We're going to do something
crazier. Hit fracture. Doing its thing. It's going to give us a group of 30
pieces. And then in those 30 pieces, I'm just going to, for the purposes of this
presentation, just select some randomly. And then under this depth area, there's
this really cool feature where I can now add these as additional pieces to do
something called a depth fracture, which is going to then take these X pieces that
I've created and create new subfractures. The stuff that it's doing, the dynamics
here, they're cool. But for our planet, we're not really going to get into it. So
what I'm going to do is I'm going to take these pieces out of here and I'm going to
hit SHIFT+G to get rid of the top ones. And then this deep break, we're not going
to use it, so I'm going to hit SHIFT+G to get those. I'm going to select this one on
the top. I'm going to select these ones on the bottom. I'm going to hit ALT+G to
group them. And then I'm going to take this other group right here, drag it out.
And I'm just going to kill our NitroBlast stuff for now, or for good for this setup.
I'm going to hit CTRL+Z to undo my camera that I just did. And here we go. Make a
fracture. Put this in there. And I'm going to hit
SHIFT+G to ungroup it. And now I have all these pieces. So let's take a look at this
group. This group is a group of larger pieces and this group is a group of
smaller pieces. So I'm going to do the same procedure. I'm going to make a
fracture object. I'm going to put it in as a child, hit SHIFT+G. And then we have a
setup. So I'm going to go ahead and blow this away. I'm going to go into our NAB
project where I've already set all this stuff up in advance so we can talk about
it more in-depth. I'm going to paste it on in. And what we've done here is, let's go
ahead and kill the X particle stuff for now, is we've created two groups of
fracture object. So fracture object is, if you will, it's kind of like a MoGraph
object but it doesn't iterate objects. It takes objects and lets you apply MoGraph
effectors to them. So in both of these fractures, I have one called fine and one
called large. Pretty descriptive of what they are. And then I have a series of
effectors that's I've applied to both of them. And in all of their ranges, I've
applied key frames. So the random effector, that's going to throw objects
out into random positions in their various space. That's pretty self-explanatory.
What the plane effector is doing is scaling down the pieces over life. So if
we take this and just scrub it, we can see that our facture happens. We get our
little, fine pieces coming out first. And then our bigger pieces start to drift out
along with it. Let me turn off our base sphere so we can see the whole thing
break. And then in the center, we have this object that is slowly shrinking these
pieces off. It's really important to resolve them off
to nothing, because I'm going to be having particles emitting from these that are
then going to suck back into our donut shaped lard lead vortex, otherwise known
as Donutonia. And we're also going to be emitting turbulence fluids from them. So
we want them to go away because we don't want to overload the CN GPU with all these
turbulence fields. Okay, so this is a very CPU unintensive methodology for creating
what I think is an interesting base for a fracture. In my short, when I do this, I
have about five steps that are like this. It's like large, medium, small, fine,
super fine, extra fine. And they're all at just various levels and scales. One other
cool thing that we need to do is we need to have our terrain object actually break
up. And I've been, for a long time, trying to figure out, I've been Googling hard,
asking everyone I know, how to control rigid body dynamics with Xpresso or
Python. Everyone always had a different way to do it. I never really found a way
that worked entirely efficient. So I finally found a Lester Banks post a while
ago from this guy named Belaz [SP], I think. I know we've had an exchange
before. Belaz, if you see this and I probably butchered your name. And I think
I've mentioned you in one of my streams before, but you shared a really helpful
tip for how to dynamically control rigid body dynamics. So I'm going to go ahead
and grab this little null setup here. And we have our ground here. This is our
ground terrain. I've already pre-fractured it and we already have all of the rigid
body tags on it. So let's go ahead and grab these two groups, dynamics control
and platform. And let's bring them into, we don't need landscape. You stay here
buddy. Let's go ahead and bring them into a new file and break down what's going on
here. So, on a small level we have this little
example here. Let's make a plane and just drop this and scale this up here. And
let's make a collider. Sorry, X particles, not right now. I want a other collider. Oh
also, I'm really sorry, guys. If you're not familiar with what's happening when
that little thing pops up. That's called the commander. It's the hot key to access
that is SHIFT+C. It's basically ruined me. I don't even know what this menu bar up
here does anymore. If you ask me for a specific object, you're like, "Hey, man.
Where do you find the platonic?" I don't even remember where it is in here. Okay, I
know what the basic stuff does, but a simulate tool or when I make xrefs I do it
with commander. I know they're up here somewhere, but yeah, commander, it's
great, SHIFT+C. Good times had by all. Okay, let's crack open this Xpresso. This
is a very small chain of expressions, but what it's doing is so smart. It's taking
in a hierarchy of two things. It's taking in the hierarchy of this cube right here.
You'll notice that next to us, in this side right here, we have collider body
tags on these objects which allow these bodies, if there were other dynamic
objects in the scene, to have collisions. Since they're not doing anything right
now, what this is doing is we're bringing in this plane effector with a spherical
falloff and we're sampling its strength or its value or something. We're basically
getting data from it. It's doing 0 or it's doing 1. And then we're sampling that and
we're comparing it against nothing. Basically, you're on or you're off. You're
a Boolean statement. If you're higher than 0.4 then something's going to happen. And
what that something is going to happen is a condition.
The condition is going to say, "Were you a collider? Now you're a rigid body if you
have been touched by this falloff range." What's happening up here is we're
iterating through all the tags within the hierarchy. The hierarchy meaning simply
the top null up here. So now if I take...oh, and then I've done one other
thing. And I know that there are better ways to do this. I just couldn't think of
one when I was setting this up the other day. There's a key frame happening right
here. And I'm going to go ahead and turn this off and we're going to demonstrate
what's going on here. I'm going to set this to 1, because that means, if you're
1, be dynamic. So let's minimize this. Let's hit play. Let's grab a plane
effector and just move it over. That should have...why did that not work? Let
me try this in my other file. Ah, man. There's something always happens like
this. Guys, it's not fair. All right, I'm going to copy this, paste it, move my
plane effector. There we go. They're dynamic and they fall. The problem is,
when they come back around if I don't have that 0 to 1 key frame, they won't be
dynamic any longer. So yeah, this is what basically allowing us to iterate through a
list of objects and say, "Okay, you're dynamic now." You can see it collide with
the other one, kind of bounce off the side there. It's super fun to be able to do
this, because otherwise you end up with a whole bunch of rigid bodies inside of a
scene that are all being calculated and all being amassed.
Or sometimes, if you have a really weird mesh that you've fractured and broken up,
then you end up with a kind of like a big explosion right off the bat. So let's go
ahead and apply this setup that we just made to our untitled file here. So, we
have all these. There's only one thing that I need to do to my rigid body tags
that I have for this floor, our giant, massive floor. Let's go ahead and move
this below here. Is I need to just make one, quick, little change. Go to my
collision, dynamics, and then set custom initial velocity. And that's just
something that if I don't have that on, the setup won't really work that well. And
then I'm just going to take these pieces and I'm going to put them in my sample
RBD. You see that they switch back to colliders immediately. And if I hit
F8...oh, you know what? I broke this one. So let's just delete this, go back to our
other project where it wasn't broken, copy it, bring it in. Because I'm sure you guys
don't want to see me sit up here and troubleshoot. And also, since I just had
the dynamics run a sim, these pieces over here have fallen away and we should go
back and grab our platform again. Bring it back into our other file. Let's grab
these. Scroll back up, drop it in our sample RBD. And we can just delete these
cubes. Hit play. Grab our plane. And wonder frustratingly why it's not working.
I lose the object. Yes, I lost the object. So, what happened is when I deleted the
cube that it was referencing, it had an object that was referencing a dynamic body
tag and I got rid of it. So it lost its place. And this is really, really helpful
because the floor object that I have and the dynamics, like the way that I wanted
this thing to break and chunk up in my simulation, I wanted to have just complete
control over the animation process, because let's say we have our viewer. Over
in the distance, say, straight ahead of this, we have our planet. And the
crumbling is starting and they're not paying attention. They're looking at
something else. So one thing that can happen, and this is, for the times that
I've tested this, it gets kind of disorienting. But if you start seeing the
ground falling from behind you, you're going to start looking forward, seeing
where that's going. So we make a bunch of these. We fracture this just half a dozen
times more, and split it up through our scene. And we end up with just a really
nice animatable, art directable fracture that doesn't have any slow drift when it
first starts or anything like that. So there's one other thing that I want to do
involving NitroBlast, since we have plenty of time. I want to show you some cool
things you can do with NitroBlast and its deep fracturing. So let's go ahead and
make a new sphere for our planet. Actually, that's what we were going to do.
Let's go back to our step one. We've now basically established all of our base
scene. I'm going to do what we just did one more time. Drag this into here. Open
up our Xpresso. Replace this dynamics body with this dynamics body. Our plane
effector, we're going to pop out of our CV-VRCam. And we're going to drag our
plane effector over here, have it right in front. Okay, cool. So our scene is getting
big and getting established. One really cool thing that we could do is let's go
ahead and take our planet and let's save this file. Let's hit SHIFT+C, type xref,
and I'm going to convert this object selection to an xref and I'm going to
save this as "xref NAB Planet 001." I'm going to go ahead and save that. I don't
really care about the cache being missing. It's totally fine. Yes, I would like to
now open the project for editing. What I've done now is created a file that is
now referenced in my master file, where I can just work on the planet. This is
really, this is something that really becomes important when you're working with
large files and large scenes because I can go back to my master project where
everything we're rendering out of and just hit that X. And it's out of the scene.
It's completely off. It's more killed than putting it in the layer and turning
everything off in a layer, then hitting all the traffic lights. And this xref, if
you're working and collaborating with a team, it affords you the opportunity to
pass off a file with someone on your team. So if we were working in a studio
environment, I'd be like, "Tina, I need you on the planet.
Jeff, you're working on the ground fracture. Casey, work on the portal thing.
You, other thing." And I'd break out this whole master scene into individual xrefs
where everyone can work on their individual files and then through the
master file all we'd have to do is hit reload to check for the updates. So let's
make some changes to this planet inside the xref so can actually see, in action,
what the xref's doing. So we already have it open. I'm going to save this. So
basically, we have this set up as a very efficient and CPU light fracture. But
there's another way that we can do this that I think is really interesting, enough
that I wanted to show it on its own. This is one way to do it with pre-fracturing an
object and doing it with MoGraph effectors. But for another test, shall we
try something? Let's go ahead and make sure all this stuff is nicely turned off
and invisible. I'm going to go ahead and open up NitroBlast main and I'm going to
fracture this into, pick a number, someone, a two-digit number. Fifty? All
right. Fifty pieces. And let's make this dynamic. Hit save and fracture. And boom,
we have 50 pieces. Oh, you know what I did? Let's undo that. Another reason why I
really like NitroBlast is that it keeps everything as one recorded action. I've
used other plugins. I've used some plugins where every single step that it took along
the way to fracture the object was actually a piece of history in the undo.
And if you don't check the box to say "keep original object", which why wouldn't
you keep the original object, it loses it. So right now, with NitroBlast, this is
something that I found out on my own and I actually emailed this in as a portal
request. If your object is a child of another object, NitroBlast won't create
its helpful hierarchy with you. So let's go ahead and save. We've got 50
pieces already decided. Fracture. Now it's going to give us this really cool thing
called NitroBlast sphere. It's a new hierarchy that we have. Actually, let's
undo this really quick and show you one of the smart things that NitroBlast is going
for us. Let's go into our fracture object over here. Let's copy our lighting setup.
Go to our xref. Save. Paste in our lighting setup. Open our Octane settings.
And let's take a look at the texture that we're going to be building more in-depth,
possibly today if we have time. We're looking good on time right now. You can
see that it brought in the settings that we had in our previous file, too, because
it inherited some parameters from our parent scene. The xref, that is. So yeah,
let's go ahead and live viewer it up and look at our planet. We're using a mixture
of noises and...oh, oh. Oh. So I'm going to do one thing because it lost its
reference to an image texture, weirdly. Not the most important. Mainly what I want
to show you with this, because we're going to rebuild the shader anyway, is that our
UVs are distributed spherically in our shader. And, let's go ahead and hit pause
on this, after we fracture...whoa, come back. Hey task bar, out of my way. Let's
maximize things again, because they're all helpful. Let's move this task bar that
just won't get out of my way. Let's close that one, close that one.
Okay, so that's paused, not initialized. We're going to fracture our sphere that is
a child of no one. It's tagged. It's going to do it for us. Save, fracture. We get 50
pieces. Go ahead and reinitialize. The UVs are the same. Why that's important is if
you look at wire frame, we have a pretty heavily fractured object. Not heavily. In
my scene files that are a little difficult to navigate and move around because of how
heavy the geometry is, this wire frame looks nasty. It looks pretty chunky. I'm
going to have a still from something to show. Yeah, so here's an example of a
fractured sphere. Then NitroBlast goes ahead and takes the UVs for the pieces. It
makes them smooth and keeps the spherical a nice, so it wraps through all the pieces
as you go. All right, so now we're going to do deep fracturing and we're going to
explain some interesting things that you can do with an unsung hero in MoGraph
called the ghost collider tag. It's something that I never really used in
MoDyamics. We're just going to grab a bunch of pieces, bunch of various pieces
here, happy little pieces. And save. We're going to add them to our depth list. And
let's go ahead and make this 60. Let's go back to depth and let's depth fracture.
And what this is going to do is it's going to walk through all those individual
pieces that we just selected and turn those 60 pieces, or now, however many, 13
pieces into new fractures that are each 60 pieces. So we're going to have a new level
of detail. Also, it applies this inner texture to the
object for us. We've already designed what we want our inner texture to look like, so
a couple ways to replace all these texture tags. If you CTRL+click and open
everything, and scroll, you can see that it could be pretty daunting to replace all
those. But, if you just hold down option and click on the material and drag the
material over to the material that you want to replace everything in the scene
with and let go, whoop. That material is gone. It's now been replaced by a newer,
better material known as not yellow. So let's go ahead and hit CTRL+click on this
to just do a regular expand. My depth fracture has now been set up into this
little hierarchy here where I have a ghost collider and then I have objects with a
ghost collider that are applying it to the children that are basically saying...let's
go ahead and make a plane. Or actually, not plane. Let's make an attractor. And
let's take this attractor and center it to our sphere. So it's directly at the
center. We want to use this attractor force to push all the pieces away. So I'm
going to go ahead and set this attractor strength to -110. Hit F8 and play. In our
scene, we have gravity on. So I'm going to hit CTRL+D and go to dynamics and turn
gravity to 0. Also, from my testing, when you're working in xrefs, I can set this
time scale to 25 and gravity to 0, and then in my master scene file, if I have
other dynamics, I can have that time scale and that gravity set to a different scale
as well. So say I'm not a math wizard or I don't
have a degree in physics. If I want something to look bigger and feel slower,
and feel more grand and more epic, I need it to move a little bit slower and have a
little more drag, a little more resistance. So my planet, I can set its
time scale to 20 and just have things just crumble and slowly drift and make it look
like and feel like it's much further away than it actually is without actually doing
it. I like to play around with scale and time scale like that to get different
results. Okay, so let's go ahead and see what this attractor is doing. I also want
to do one more thing here. I'm going to select all of these object, which
basically, these objects are saying, "Whenever any of these pieces collide with
any of these pieces, then they should fracture again." Well, I want to control
when that happens myself so I'm going to go ahead and right click and remove all.
So now it'll function just like our heavy fractured object. It won't actually
function like depth fracturing or deep fracturing was doing anything. But what
we're going to make is a sphere and we're going to call this tiny breaker. And I'm
going to make it a child of the attractor because the attractor and the sphere are
both kind of, to me, they're two pieces of the same function. We want to blow the
planet up. The attractor is pushing things out. And then the tiny breaker is going to
cause the pieces...well, you'll see. Let's make this much stronger so we can see the
pieces. All right, so our big pieces are all going out, but we're not seeing
anything happen to those tiny pieces. There's no, as far as we know, this is
just single fracture, a single event fracture that's not very interesting. So,
let's set this radius to 0, key frame it. Let's go to frame 59.
And let's make its radius 2,200. Or this big. And I'm going to move it out of the
hierarchy. Okay, and then, in this little tag right here, I'm going to put this
sphere in there. And so now, whenever this NitroBlast depth tag has a collision range
of 15 centimeters, which I'm actually going to lower a little bit to 6, with
this sphere called sphere breaker, those little pieces are going to all of a sudden
become freed. They're going to be allowed to go ahead and do their whole, full
dynamic run. So let's just close this. Let's make this invisible. And let's hit
play. And you know what? Since we're doing a live demonstration and watching a
timeline move at two frames per second is about as fun as watching me do a cache,
let's change our MoGraph time scale to 200%, 400%. We don't have time for this.
And let's hit F8. And we'll watch these pieces kind of flow out. Or not. The time
scale, let's move the time scale back to 100 and did we break something? I have a
different window selected. Good catch. Give this man a shirt. All right, so let's
watch this in one viewport. So we see our main pieces. They're flowing out. They're
starting to do their thing. And then as soon as this guy comes into play, which
should be any second now, the pieces underneath you can start to see.
They become active a little bit. And let's go ahead and do something. Let's call this
attractor one and attractor two. And then let's make this one, they should both be
set to acceleration. I tried to force because I was wondering what was going on.
Let's set this one right here to much stronger and let's go to our dynamic body
tag right here, go to force, and change it to include. And you big pieces only get to
deal with attractor one. And yes, automatically the other pieces will use
attractor two once they become active. So let's go ahead and hit play. It's still so
slow. We made it very big. So let's go ahead and do our time scale again. We're
running out of time. Go, go. All right, there we go. Now our sphere has come
through and our tiny pieces have been given a new layer of attractor. They have
that attractor two, which is twice as much acceleration. So this was one way that I
did a lot of the planets, too, where I basically just had three or four levels of
depth fracturing, three or four of these tiny breaker spheres, and just a whole
bunch of different triggers to cause all these tiny pieces to sort of pop out, if
you will. So yeah, it's a lot of combination of doing things on a recursive
to the 13th step level to get the fracture field really realistic. One of the things
on Thursday we're going to talk about to kick this to the next level, one of the
problems I always have with the way the fracturing tools that we have available to
us right now, all these pieces kind of look a little kind of game engine-y.
They don't have deformations or they don't have point deformations on them to give
them interesting phong angles or surfaces. So we're going to talk about using bump
maps in Octane to apply some displacement to the surfaces to get a more realistic
look to the internal structure. So, now that we have this version of our break
going, which I like, we have two methods. We have one, using the fracture object
that's very easy and controllable and approachable to most people. And then we
have this secondary methodology, using deep fracturing. But what does this mean
for our other project? Well, let's go back into our main file where we have our xref.
And as you can see, it just updated. Everything that we just did in that file
is updated so our master scene has access to everything we just did. One thing we do
want to do though when we're working, I like working with the same lighting setups
in both, just so I can kind of test things on their own. But we want to make sure
that we save this with that stuff off so that when we come back in here it's not
getting double the lighting. You can always drop this down and see that you
have access to the entire hierarchy of the project that we just made. So if you want
to switch from our NitroBlast setup to our fracture setup, we have that control
outside the xref. And since we're doing all that, we got this setup too. Let's go
ahead and prep the xref for our floor. I'm just going to select this and call it
floor. And then our vortex, I know the cache is not found. Leave me alone. What
do you want me to do? So it's creating it and in a second it's going to say, "Hey, I
made it. Do you want to play with it?" Or maybe it'll crash. Yay, cool. So now
we've got our xref for this file opened and in here we can create a whole bunch of
different setups for the way we're going to animate our objects, our floor falling.
We're going to play with using multiple levels of gravity to kick the pieces up
first and have them fall down. We're going to have second pieces of geometry that are
underneath that are kind of pushing things up. And on Thursday we're going to
introduce a whole bunch of particles and stuff, and texturing into this whole flow.
I really wanted to take time talking about the principles of fracturing because I've
been working with...it's been coming up a lot lately and I think that it's good to
kind of talk about how you can get away with multiple techniques.