Under the Hood with Fusion 360 Engineers

PHIL EICHMILLER: There we go.

JEFF STRATER: The cabin doors are shut.

PHIL EICHMILLER: The cabin doors are shut. You may put on your seat belt.

[LAUGHTER]

Welcome, everybody, to Under The Hood With Fusion 360 Engineers. Good morning. And glad to see you all here. I'm Phil Eichmiller. I work on Fusion 360 as a quality engineer at the Portland office, along with Jeff here. And I'm a longtime product designer. I've used Inventor for years and years, making consumer goods. And I teach.

I've been teaching for 10 years at Portland Community College in the CAD program there. I teach Inventor mostly. But recently I've managed to get them to be letting me teach a Fusion class. So it's a lot of fun to interact with people that are breaking into the CAD world or just freshening up their skills.

JEFF STRATER: And Jeff, software architect, I've been on Fusion from the very beginning and worked on Inventor before that, so definitely bleed CAD. But in reality, I'm really just Phil's intern.

[LAUGHTER]

PHIL EICHMILLER: All right, so--

[DISTANT CHEERING]

JEFF STRATER: We're not getting anything like that.

PHIL EICHMILLER: Hey.

[LOUD CHEERING]

All right. Thank you. OK. Well, welcome to the course objectives slide.

[LAUGHTER]

So I'm not going to read through this. But I'm assuming you're here because you read the description of the class. We really want to take you on a tour through some of the critical areas of understanding and various levels in Fusion that are going to help you hopefully as CAD people, aficionados, if you will, understand more about what's going on, right? Because there's a visual language to all CAD programs. And there's things that you may or may not notice. There's hundreds of details and things like that. And so we want to make sure that you're aware of everything that's going on that's really critical to great designs and workflows.

JEFF STRATER: And we'll try not to go too deep in to many areas. I also want to put in a plug for the handout. The course handout is online. We ended up with over 100 pages of stuff that we had to cut down in order to make it fit. So there's stuff in there that we're not going to have time to cover today, if you're interested.

PHIL EICHMILLER: So the first stop on our tour is the Fusion timeline. The timeline is one of the big differentiators between Fusion and other programs because we decided to take, compared to Inventor, per se-- how many Inventor users in here? We've got some hands-- how the model browser for parts contains a concept of history. You can move the under part marker around, but there isn't that for assemblies. And because Fusion is parts and assembly sort of all in one environment with one file type, we separated it out and made the timeline.

JEFF STRATER: Right. So talking about the timeline versus a feature tree, there are some cosmetic differences. Clearly one is vertical. One's horizontal. We chose the vertical for a couple of reasons, first, because we like it. It takes up less real estate on the screen and gives you a little more to work with. But more importantly to our understanding here is this nature of Fusion having a history-based parametric assembly environment.

And if you're coming from Inventor, if you're coming from SolidWorks, Pro/Engineer, this is a bit of an inversion. The idea that assembly operations are time based is critical to understanding how to work in Fusion. So the fact that components can come and go over a period of time is a bit weird, if you're not used to it.

But that's the other reason why the thing's horizontal, because you can't just group the features under components because the components themselves are in history. It's a little bit interesting. The thing to know about the timeline is it really is a time machine.

When you move around in history, you're going back to the point in time when those features were created. And this is certainly true in Inventor in a part design. But it's even more true in Fusion, again, because of the assembly nature.

So often we'll see on the Fusion forum a question, I went to edit the sketch. Where did all my components go? And the reason is you're going back in time to the time when that sketch was first created. If there were no components then, or if they were in different positions, you're going back to that point in time. And we'll go into why that is, but that's an important thing. So yeah, the timeline really is a time machine, and these are my favorite time travel movies. Primer is especially cool.

PHIL EICHMILLER: And you don't want to end up like Michael J. Fox. We all know what happened in that one. So why does Fusion roll back on edit? And as you can see in this simple example here, it's all about dependencies.

As you create the timeline items, obviously in this example, there's a sketch, which creates an extrude, and then there's a fillet that's based on that extrude. So those features are dependent on each other as you progress forward. The fillet obviously can't be applied when the sketch is just there.

JEFF STRATER: Right. So what we're trying to prevent-- so the question is really, when you edit a sketch, the timeline rolls back, again, to that point in time when this sketch was first being created. And what we're trying to do here is to prevent these circular dependencies, right?

So unfortunately, we don't have these nice little arrows in our timeline. We thought a lot about how to express those things. But as Phil said, the extrude is clearly dependent on the sketch. The fillet is clearly dependent on the extrude.

But what if there was a way to make the sketch dependent on the fillet? These dependencies are used to determine what order features need to be computed. And when there's a nice linear set of dependencies, we know what to compute first, second, third. And this is how the system works underneath.

We have all these features. We sort them into an order. And then we compute them in that order. So if we allowed you to, say, for instance, project the arc from that fillet back into this sketch, we'd set up one of these cycles, right? And we recover from that.

So the other thing to know about these dependencies is anytime you can pick geometry in a command, if you're in a parametric design, you're creating a dependency on that geometry. So if you project an edge into a sketch, if you pick a face as a two-faced termination when you're creating extrude, you're creating a dependency on another feature in your timeline. So in order to prevent these circular dependencies, we roll back as if you were creating that sketch for the first time. Anything downstream-- we usually talk about upstream and downstream of any point in time.

Anything downstream we hide to prevent you from creating those cycles. There's been a couple cases where some of our defensive mechanisms have failed. And you'll know right away because you'll get this cyclic dependency. Fortunately, there aren't too many of those.

PHIL EICHMILLER: So just to sort of illustrative in a very simple example what we're talking about, if I go down here and double click on my sketch, to edit it, the timeline is rolled back to that point in time. And the rest of the features are grayed out and not computed. And when you stop sketch, everything is computed on the way forward.

So if you were to make the sketches visible here, for instance, and so by me dragging it and the model updating, it's still just rebuilding the timeline. The second I let go of that sketch line, it pushes it through. And there's no sketch tools here for me to do something like project this fillet edge into that sketch. Just I just have access to it because there's a little bit that's visible and have some freedom here.

JEFF STRATER: And it's just one more example. This is the tightest circular dependency we can think of, draw a circle, extrude it with a bit of draft. And if you were able to project that smaller circle back into the sketch, then we'd have a two-feature dependency. So we don't want that.

PHIL EICHMILLER: Which brings us to why is all of this important? And so we're now going down a layer down under to like what's making all of this tick in the timeline, which is the concept of CAD naming and matching, right? So as you create objects, they take on a personality, and that is cataloged and used in all the compute as you work with your models.

JEFF STRATER: So basically, this topic is really about how does Fusion or AnyCAD system, for that matter, make sure that when you create one of these geometric dependencies, and you pick some geometry, and you go back and make an upstream edit, how do we make sure that we get the right thing? Another way to look at this is how do we prevent yellow errors in your timeline or red-- or yellow warnings in your timeline or red failures in your timeline? This whole system internally is called naming and matching. It's naming things and finding them.

PHIL EICHMILLER: So in the example there, you have this model here. And editing the sketch, you'll see that this is in pure, old-school terms, this is a round, right? The fillet command created it, but the shape is a round. You're rounding off the corner. And if I were to go-- and hang on a second. I've got to-- there we are-- go edit the sketch and just pull this down, right?

So the that edge was on the extrude that was created by this profile. And it's all because Fusion's keeping track of everything that's actually in the sketch. So how do we know which edge to fillet? Well, when it's turned like this, now in pure terms, it's now a fillet. It's not a round anymore. But it's still the same radius being applied by the fillet command to that edge. So that's just kind of a simple type illustration of what's going on as the update happens.

JEFF STRATER: So how do we make sure that we find that right edge? So it turns out that in the CAD world, everything is based on this one paper from 1996 by a professor at Purdue University, Christof Hoffman, called "Generic Naming in a Generative Constraint-Based Design Tool."

PHIL EICHMILLER: [INAUDIBLE].

JEFF STRATER: Yeah. So in case you're ever interested in the theoretical basis.

PHIL EICHMILLER: And that's not the generative you've been hearing about so much this week.

JEFF STRATER: So at the root of everything is-- a feature is responsible for naming the faces that it produces. So let's look at a simple example of extrude. Extrude has three categories of faces that it can create. Not all extrudes create all these faces.

But they have these three categories. And that is the start face-- there's always one and only one start face-- an end face-- again, one and only one of those-- and then lateral faces, meaning the sides of the extrude. And regardless of whether there's draft or no draft, you still have these same three categories of faces.

So if you're paying attention, it's obvious how we can distinguish the start face and the end face. But what about all those side faces? In this case, there's six of them. So it turns out that Fusion keeps track of individual sketch objects and gives them names too.

So as you create lines or arcs in the sketcher, they get an integer assigned to them. In this case, there's six of them, so six integers. And those lateral faces now have two categories on them. They have the fact that they're a lateral face, and then-- go forward. And then they also get that tag from the sketch, curve that is driving them.

So with that information now, we can uniquely identify all eight faces of this extruded hexagon. And this is important, as we'll find out, when you go to do upstream edits. And remember, the goal of this is to prevent failures in finding the right edge or face.

PHIL EICHMILLER: So taking a look at it in person, here's a version of that same file, or that same design I should say. I've kind of added some tags on it. And there's a little bit of help there. There's a fillet based on one of those edges.

Now, this is a red body with yellow face overrides for illustration purposes, and you'll see what I mean. What we're getting at is something we see often, where people assume way too much WYSIWYG in what they're doing. And so this is the kind of thing that can happen.

Let's say that, for instance, you want this edge to actually be over here. You don't want a regular polygon. You want to have something with a little more shape to it. And this is just a hypothetical. It's often tempting to do something like this.

So if I go to Extend and extend this out, and it makes the profile get bigger. And so the customer or user I should say, is saying, oh, look, that's what I want. And I don't need this one anymore. So hey, look, I've still got a six-sided figure. And I stop the sketch, and I've lost my fillet. I have a red warning in the timeline, or a complete error. And also, look, there's a new face, right?

This face is taking the body color because that's the hierarchy of how appearances are applied. And it's no longer yellow because it's not the same face. So the advice here is-- let's see, back up a little bit. Whoops. Just kind of back this up.

JEFF STRATER: So is it obvious why that face failed? Because that longer vertical line has a different identity.

PHIL EICHMILLER: So I'm just going to go ahead just drag this over here just to make it approximately that size, just for the sake of brevity. But so now I have the shape I want. But what I'm trying to do in every instance of every edit that I do ever is preserve every one of these things that's there that has these downstream dependencies.

If I have to destroy something, I know that I have to go look for those dependencies and find something like maybe a sketch that's become dislodged or whatnot. But this is the goal, right? This is what you're always trying to do is make that adjustment to your model and have everything that comes down from it, like this fillet, for instance, or the color know where it's supposed to be.

JEFF STRATER: So the key takeaway of this little section here is everything is based on your sketch. And so you need to be careful when you're editing sketches to not just delete things and recreate them, thinking that they're the same things, because they're not. This one rule, I think, would probably eliminate 80% of the yellow features that we see.

PHIL EICHMILLER: Or, likewise, deleting a body that has-- this, for instance, it has a sketch reference on top of it, right? You can see where that would now dislodge that sketch, even though you've made maybe another body that looks exactly the same. So this brings us kind of just a little bit deeper into, well, what are all these references, right? There's a myriad of these things that you can refer to in Fusion, right?

So the sketch being the sort of the foundation of the foundation, like Jeff said that one time, and I really like that. But what's underneath that, right? So in a decreasing order of stability, you're going to find this is pretty much the list that you should pay attention to.

If you were in Kevin Schneider's class yesterday, you saw him using work planes, right? Well, look at the top of the list here, origin work geometry. That's a reference that'll never fail. You can't delete the origin, unless you delete the component that owns that origin. And we'll get into a little bit more later about how components have their own origins and stuff like that. But the work geometry derived from origin geometry obviously would also be quite stable, unless you just delete it, or other work geometry, and that's what Kevin showed when he offset that plane, if you happened to see that.

But below that there's a body reference, right? If you're projecting in, for instance, the entire body into a sketch, and we'll get the silhouette of that body, that body can change quite a bit. And it will still put the same projection into that sketch, or it will do its best to have all that same information, unless, of course, you've added new edges and whatnot.

The face is another stable one. But then you get down towards the bottom. And when you're projecting vertexes into your sketches-- and, Jeff, you can explain [INAUDIBLE].

JEFF STRATER: Right. So an edge, you saw how we named faces. We don't really name edges. We name edges just at the intersection of two faces. Vertexes, vertices, they need three faces to identify. So you can see that each of those get less stable the more down you go.

This is why I always tell people turn off auto project edges on reference in sketch because that's the hierarchy of stability. You're auto projecting one of the least stable things that you can. And then the last one on this topic is the difference between warnings and errors in Fusion.

So when we started out in Fusion, we wanted to make the system a bit more flexible and not error out in all cases. We introduced this concept of warning. This has come to backfire on us in a big way. Yes, in cases like this, where you get a yellow feature, the rest of your design continues to compute OK, and you might think it's OK. But is not. You've lost key design intent.

So in this case, we've put a work access through an edge. And the edges failed. The work axis is still there. Anything downstream of the work axis or work plane or face or whatever will still continue to compute. But you've lost the intent that that thing needs to be at that same location. So when you see these yellow things, it's not like-- if any of you are software people, we all tend to ignore compiler warnings, also a bad habit. But it's worse in Fusion.

PHIL EICHMILLER: So-- and the way you would get into this mess would be similar to what I did with the red and yellow block. You went back and just hacked off part of the sketch, and then that face no longer exists. And therefore this edge is just going to hang out in space there, when you're assuming it's moved over to follow that. And that's where you got the yellow warning.

So now we're going to kind of-- so we kind of just went way down from the timeline to dependencies and then down into what makes those dependencies tick. We're going to shift gears here. And another subject that often brings some confusion-- and I've been having discussions with people all week about this, and I've got some great ideas that I'm going to bring back to UX when I get back to town, maybe discuss some ways that we could make this a little bit more clear. But we're going to talk about it right now. And it's this. It's how do joints decide what direction they're going?

So joints define a coordinate system at the attachment point between two components, right? So I made this illustration here so that you could see how this-- I took the liberty of grabbing the graphics from the actual xyz origin of the component just to point out to you the actual the code of the way the joint origin works. You'll see, when you place a joint, the little circular puck shows up. And it's got a little rising sun in it sort of coming over, or maybe it's a sunset coming over the horizon there.

Z, in this coordinate system, not in your world coordinate system, but in the joint coordinate system, z is always facing out from the puck. So when you look in the Command dialog, you'll see values for z. That's the direction that you're talking about. And likewise for x and y. So the y is determined by the direction of sort of the s shape. And x is determined by that little horizontal line that runs through the middle of it. So as you're trying to make offsets or edit your joints in such a way that they do the mechanical things you want, like if it's a slider joint, it needs to slide along x or y or whatever, and you make those picks in your Dialog box, this is the x, y, and z that it's referring to, not your world coordinate system.

JEFF STRATER: Right. So the key here is a joint is a relationship between two local coordinate systems on two components. A rigid joint is nothing more than sticking those things together. The flip option just flips whether the z is aligned or opposed. It's not a relationship between to two planes, like a mate or a flush.

It's not a relationship between two edges. It's a relationship between these two coordinate systems. Once you internalize that, joints will make a whole lot more sense.

PHIL EICHMILLER: And so in this example of a revolute joint, you can see as opposed to a rigid joint, for instance, a revolute has one more degree of freedom, and it's just to rotate around a certain axis. And so that's why you have the ability to pick which axis. And that, again, is the axis of the joint origin and not your actual model. If you can imagine something turned in space completely off axis from the world coordinates, how would x, y, and z even relate at that point? It has to be at the joint origin.

JEFF STRATER: Right. So the key point here is there's no difference between a rigid joint and a revolute joint as far as how things are joined together. It's still this two coordinate system stuck together and their axes oriented. We just add one degree of freedom for the revolution.

PHIL EICHMILLER: So what you just saw there was that I had the origins turned on for these components. So what does a component actually own? It owns an origin, and that's relative to the world around it. And I'll show some more examples of that in a second.

But I want to just demonstrate putting a joint on here. And I'm not using anywhere-- I'm not anywhere near where that actual component origin is. And you'll see that this is giving me a good idea of what direction things are. And it's somewhat arbitrary at this point, right?

I just know that, for instance, in this case, I want these things to be joined right here and in that relative orientation to each other. Now, you can make adjustments and turn things around and so forth. And if this was a slider joint, for instance, now I can pick which access to slide along. Notice that it's sliding along the z-axis. It's sliding along the axis that's normal to the joint origin.

And where's the z-axis in the model? And where's the z-axis in the actual components? It's not in that direction, right? It's the--

JEFF STRATER: Yeah, these are local coordinate systems. And you can change it. If you want this thing to slide along the x-axis of these joint coordinate systems, you can do that.

PHIL EICHMILLER: Yeah. And that's the direction that that little puck was facing, or the little edge in the puck. And there's another example, too. So other join types just expose more of these degrees of freedom.

JEFF STRATER: So pin spot, exposes two, one rotation, one translation. Ball joint is three rotations. So you get the idea. It's all the same thing. It's just exposing more and more of these degrees of freedom.

PHIL EICHMILLER: So another kind of topic that we'd like to explain is something pretty cool that Fusion has, and it's the as-built joint versus a regular joint, right? So there's some advantages to this. And it's important to understand the difference because of what they offer is completely different.

So why do these two types of joints exist? And what's the difference between them? Jeff, do you want to expand on it at all?

JEFF STRATER: Right. So joints in Fusion do two things. They control the positioning of components relative to each other, and they control motion, if they happen to have motion in them, as we've seen. As-built joint takes that first step out of it. It assumes that things are already in the right position, and it doesn't need to reposition things. Then you just need to define the motion, if there is any. As-built joints, though, require the components to be reliably positioned with respect to each other, which is why they exist only in a parametric design not in a direct modeling design.

PHIL EICHMILLER: So I have an example to kind of show you. So this is an example of sort of a top-down design of a simple mechanism, where everything is designed in place. And of course, naturally you would have things like some small gaps in here. I'm not going to zoom in and show you. But there's some small gaps for clearances and things like that, right?

So really, the as-built joint takes advantage of the ability to relate the bodies and the geometry together and do that sort of top-down design is something I really think Fusion does better than almost anything because these could start off as bodies and then eventually become components when you need to add motion to it. And the time to do that would be after you've made the components is to use an as-build joint right here. And it's asking me for a couple of things, one component to move and one component to stay still.

It Defaults to rigid, does that little bumblebee dance. That's what that is. It's the bumblebee dance. Switch it to Revolute, and now it's asking for one more thing, which is a position. Where is this going to rotate from? And so you can see I can pick anywhere along this cylindrical axis of rotation here. And it's going to let me do that. And really for this hinge, this is totally arbitrary, but it's not going to change the position of these parts relative to each other.

So I could put this up here, or I could put it somewhere else. I tend to, when I do this, I put it out somewhere out on the edge where I can see it instead of buried down inside of things, as long as I'm confident that it's the right reference. Now I'll cancel that and say, OK, what's the alternate, right? And so here's our joint, which is-- it's a hinge itself.

If you happen to be assembling parts, now, I'm just sort of showing you why this would be a problem for this type of workflow because now I've pulled this apart so I can apply a joint. I have to capture the position, which we're going to get into in a minute. And so now my model references are these edges.

And as long as they actually truly mate, which they actually never really would-- there would be a gap there. So now I've just assembled it, and I have to either re-add that intelligence, like, hey, what is the tolerance there to allow for motion or accidentally just crush it and move this thing a few thousandths out of an inch out of the way in the wrong position. And on top of that, I've captured a position that really doesn't matter.

So hopefully you can see the difference there. And if you're inserting parts, obviously the as-build joint condition, you can still actually do as-build joints if you align things and move things into place and then provide an as-build joint. But most the time people are doing assembly by putting stuff in and then jointing it, which does both. It makes the position and makes the relationship between those two coordinate systems.

JEFF STRATER: So which kind of leads us to our next topic about the assembly-centric timeline and capture position itself.

PHIL EICHMILLER: The mysteries of capture position, brought to you by the assembly-centric timeline. How many of you have seen this and had no idea what it means? All right. And what it means is, it means that you've moved something out of position, and then you've asked for a compute to happen by starting something else that requires a compute, like placing a sketch or doing another feature or something like that.

We're going to stay here and do the demo. Fusion allows you to do something that's pretty unique with capture position, and this is expressed in other CAD programs. In Inventor, you might see it as a positional representation, for instance. But this is for forward creation.

And you're focused on what when you're making this? Let's say you're making this knife right here. You're focused on the actual mechanism, not the slot that's on the side. So as a designer, I want to define the motion of these parts relative to each other and then make geometry that allows that to happen once this is a physical object.

So let's take a look at the utility knife. And this is available in your Samples file. So if you open up Fusion, go to the data panel over here, and go out to your project list and find the samples, you can find this. And so you can examine it and kind of see for yourself. But I'll just demonstrate it for you right now.

The slot in the side here, which actually depends on this motion, is defined by first an axis. And I'll turn on my construction so you can see it. This plane is irrelevant to this operation. But there are the two axes that are used in this sketch to make the slot.

But if I roll back, you see the slot, of course, doesn't exist yet and neither does the sketch. So I didn't make this model, but let's say after I made this I'm like, OK, I want to capture this position. But first I'm going to put my axis on there and then move it to the range of motion as defined by this joint here.

So this slider has its own range of motion, and you can see it. Hopefully you can see that's minus 28 millimeters. So that's me making sure you're not going to poke yourself when this thing's in your pocket, right? So that's the most important thing in this design.

And then I'll step one more step. Oh, and capturing that position so that it will compute, by the way, along the way. And then add, of course, my next axis and then go forward and do the sketch and the slot and so forth and finish out the model. And then one more capture position to put the knife in an activated state so you can kind of see more about the design intent, if you're going to render it or whatnot.

So in that case, if you wanted to show it in and out, for instance, there you go. You can easily display that. Now, editing the joint limits of the slider-- so if I were to take it to-- let's say we used a smaller blade or something changed, and I'm just going to go minus 20 because that shows pretty well. You can see that the joint has changed, and the axis needs to update. So when I hit OK, the timeline is going to compute and rebuild the whole model and watch the slot.

JEFF STRATER: So this idea of being able to do modeling based on the position of your components, based on joints is pretty powerful.

PHIL EICHMILLER: I don't know if we-- well, OK, I think we might have got a little out of order here, but that's all right. Let's talk about the different types of move for just a second. That'll help us understand a little bit more about this. The move command in Fusion actually, it encompasses all sorts of move, and you have to pay attention to what you're moving.

So you have bodies, components, faces, and sketch objects. Actually, all have completely different properties in terms of what it is you're moving, right? So if you're moving a body, a body is just a container for 3D shapes. And if you're moving it, you're moving it relative to the component that owns it. And that component starts off with its own origin.

So if I'm moving a body or a sketch, you can take this sort of example right here. So here's a sketch. Let's say this car is a single component. And it has its own coordinate system. Now, I've used car as an examples so you could think of this yourself.

If you're in an automobile, what is your frame of reference to the rest of the world? It is the coordinate system of your automobile moving through the streets. And what's inside is your body, right? So here's the coordinate system of the component. Here's our sketch. And here's a body. Now, the body can move to the backseat without actually-- it just moves relative to the coordinate system itself. So you can see the body moves, and that shows up in the timeline as a move and not a capture position because it doesn't need to be computed the way a component move would.

JEFF STRATER: Right. So Move Component is a different operation entirely. You're taking that entire component, including its coordinate system, and moving it around in space. And that is inherently a different operation than moving the body within. And this is something that's not obvious at first. But if you think about it, it makes perfect sense.

So the next slide asks the question, OK, why is there no Move Component feature in the timeline? This was really a design choice on our part, more than anything else. We wanted you to have the ability, especially once you have joints in your design, to be able to drag components, to exercise the degrees of freedom of those joints. If every time you did that we generated a feature in the timeline, you would not be happy because you would have hundreds of Move Component features.

However, this is what capture position does. So at the point in time when the position of the component is important, if you want to do that position-based modeling, if you want a projected edge from one component into a sketch owned by another, then we need to capture that position. So Capture Position is really the Move Component feature. It doesn't need to be there, unless it needs to be there.

PHIL EICHMILLER: So the way this and the reason why this is important to us is that we see this expressed in the forum a lot where someone says, oh, every time I do something that causes a compute, it takes like four minutes. And you look. It's a relatively simple design. And then you see that there's hundreds of capture positions in there because they've come from a modeling system where it's pain free to drag things around.

Inventor's a great example. You can move things around in an assembly without creating a history of where it's been. In Fusion, you're creating a history of where it's been. So they see this dialogue that says capture position or continue. Really, what it should say is capture a position or revert, right?

And so what you probably want to do is revert. But people see capture position, and they think, well, that sounds like a pretty good idea. I think I'll do that. And it causes all kinds of chaos.

I was working with some robotics students in Portland. And they had imported some of these robotics models that are sort of heavy. There's some circuit boards, and it's a lot of edges in there. And we were working on how can they use Fusion to do the robotics stuff. Hopefully, you've taught that. It's a really neat activity for kids.

But anyway, and so they did not understand this, of course. And so I'll use my phone as an example. They brought in this complex robot, and they wanted to move it around and then move it around. And every time it asked them, well, do you want to capture the position, they said, yeah. And eventually-- and all they were doing was looking at it. So rather than tumbling the model, they were just turning the thing around in space and capturing the position and then finally got it set down somewhere close to where the floor would be, for lack of a better word.

And then every single thing they did that computed, the timeline would compute, hundreds of parts doing this over and over again as they flew through space. And it's like, why is this taking forever? And you just go in and delete all that stuff, and it actually works. So that's another kind of a tip there. If you do have extra capture positions, be careful that you haven't moved multiple components because then you wouldn't want to be surprised by deleting a capture position for something that you actually intended to move.

But if you just move one component three times and have three capture positions, you can get rid of the early ones because the final capture position is going to be the computed place of where it actually is. And you can just watch the model and see it not move when you delete those extra ones. So that's a just little bit of help there.

JEFF STRATER: OK, last topic is probably maybe the most important one is performance. Everybody wants to get the best performance, so we have a few areas that we'll discuss about performance. The first thing is there's no one measure of performance.

There's at least five that we know of. There's what you usually think of as graphics performance. That's when you've got a model, and you want to be able to rotate the view or zoom and pan. But the model's not changing. You're just moving it around in space. That's graphics performance.

Selection performance is just the ability to select stuff and how fast that happens. There's one topic on that, which we included. Compute performance, you make a edit to a sketch or a feature, and the model updates. That's compute performance. Open performance, just how big is your design, how long does it take to download from the cloud and open. And sketch performance is kind of a beast all in its own.

PHIL EICHMILLER: So let's take a look at some of just the tools, what I call tools for performance that you're going to find in Fusion, right? So starting with the browser, so if you go to the browser-- hang on just a second here. There's this concept that's attached to objects, which is called display detail control. So those of you who have used other systems might know this as level of detail control.

So this advice kind of comes in for when you've made a large model, and things are starting to slow down, and you can see the little hiccup that Fusion gives when it goes to redraw the level of detail. So as you're zooming in, it has to recalculate where are the edges. Things get a little tessellated and so forth.

So this control is just a property of a component. Now, here's the sub-component. You could make it a property of your entire design, which is also a component. The idea is that you can turn it to fixed, and you could set it to one of these levels.

So really low is fine. And it's set to low right now. And we're on a fairly large resolution, and you can see some aliasing across the top here. But it's not going to slow me down or keep me from making accurate picks and clicks on my model. And it's never going to really need to-- well, it's still doing it. I don't know why it's still doing it. I'll talk to the graphics folks. But I'm pretty sure I hit OK on that. So there you go.

JEFF STRATER: So of our areas of performance, this one is strictly graphics, right? And this is a good tip. You can set the accuracy low for doing just basic design work. Set it back up high if you want to render something.

PHIL EICHMILLER: Some other places of performance would be found in Preferences. So I'd urge you, if you don't do anything in Preferences, to come over here and take a look at what's in there. So going from-- let's see. Here's one right here is default measure is a good place to start here. Default measure's on.

And what default measure is just this little display that shows up down in the corner here. And did I hit OK?

JEFF STRATER: I think you turned it off.

PHIL EICHMILLER: Oh, I turned it off? Oh. It showed default measure.

JEFF STRATER: Anyhow. If you've noticed when you click on an edge, it'll show one edge and how long the thing is.

PHIL EICHMILLER: There we are. So I must have got it confused. [INAUDIBLE].

JEFF STRATER: So one of the things that we found from a customer post in the forum was it was taking forever to select a face. And if you notice, if you select the face, it tells you what the surface area is. It turned out in this particular model, it was taking like four seconds to calculate the surface area of that face. And my opinion only, that's a useless thing to report anyways. So I tend to turn that preference off so that we don't pay that price.

PHIL EICHMILLER: So the reason that setting is there is for this idea, right? If I'm measuring things, look, I can find an edge, and I can find the radius rather quickly, rather than starting up the Measure tool and getting into some sort of workflow, where I'm doing that, right? So that's what it's there for is to kind of give you that instant head's up. But most of the time you're probably ignoring it.

And again, if you're into a really seriously deep design, maybe turning that off isn't really going to be much impact to what you're doing, right? Let's go in here again. So I'll turn that off. These don't affect performance. But if you don't need the tool tips, I would say turn them off as well just because, to me, it's visual clutter, and it just pops up in your eye. And so ergonomically, it's going to be constantly flashing at you. So that's just my opinion as well.

Going over to the Design tab, there's, again, auto project edges on a reference. That's that one setting. Auto look at sketch, that's the one that's going to have the view constantly flipping the model around for you. This is just purely, again, ergonomics performance. If you're looking at a frame of reference, and you go to edit the sketch and suddenly the model decides to turn upside down, now you're going to spend several seconds turning it back around again. And let's see.