Transcripts
1. Introduction: Hi and welcome to DCO. My name is David for
petty, and in this video, I'll be sharing with
you how to create this shade structure will be starting with
the base geometry, which is going to be a circle. Then we split it in a few
other ways, like here. Then we move on to
creating the base R, which we start with a
straight forward arc. Then later on, we
re-map the numbers and go over some techniques that we can use for any design. This one in particular, we can play around
with so many of the parameters at the end. But the basics are really
where it's at on this one. So I'll be sharing with you
all of those things here. And thank you for being here. I'll be sharing how the
program works by walking through all of the
steps in detail. This way you can understand
how it all functions. The program is a little
bit intimidating at first if you've
never used it. But once you get
used to it, you'll see how important it is to understand it and how you can
use it to your advantage. I'll also be sharing the
script so you have it by your side as we move
through the exercise. This way you can always reference
back to what I'm doing. So hopefully you're
excited about getting started with Grasshopper.
And let's jump right in.
2. Base Geometry: So first thing
we'll do is open up a new Rhino file.
I'll type in here. Units will be working
with feet, I'll hit. Okay. Now we can start here with the new
grasshopper file. The first thing we'll do is
look here under Display. I'll have draw icons, drop fancy wires,
and draw full names. And with that, now
we'll get started. We'll start by
constructing a point. So we'll go, we'll go
here to construct, will route that through
a point component. This way, we're able to change the location of where
we have the design. So we'll go from this point. Now, we'll be creating a reference plane that is
in the x and z direction. And this is how I visualize
it as I go here to the bottom left of my viewport and a
half d x, y, and z here. And we see that x positive and z positive will go x, z plane. And we'll plug that
into the point. We'll plug the point
into the origin. Now we'll use that plane
to create our circle. So we'll go here to circle. As you can see when we
bring in the circle, it actually has
the default plane, which is going to
be the x and y. And this is why we
created the x z plane. So we can plug that
into the plane input. Now the radius we can change. So let's go here to 15. What I'm going to do is disable
the preview on the plane. So we don't see that plane here. Now, we can move on to
creating the base geometry. Now what we need to do is take this line or this circle and offset it to the
inside, to the outside. And the way to do this is first, let's change the name
here to structure size. I'll make it all caps for mine, but you can do whatever you want for the naming, structure size. What matters the most
is that you're able to understand what it changes. Everyone has a
different preference, so there's no real
standard for this. So we'll go here
to offset curve. And then we'll take this circle, will plug it into the
offset automatically. It gives us an offset of
one on the default plane, which is going to be the
circle already has a plane. So we can either plug
that in here into the plane or just leave
that without one. Either way it's going to work. Distance is going
to be by how much? So we'll say 1.50. This way we have two
decimal points and it gives us a little
bit of more room to change and see the design change will go 1.5 or the
distance here. And then I'll go
here, create a copy, then do a negative component, allowing me to then offset
this not just to the inside, to the outside but
also to the inside. This is going to be structure of size one or two. Structure offset. We can always change the name. It's just for now. We have this. So now what we need
to do is create a plane in between these two that I use
boundary surfaces, which is a component
that will create a, it says here when you hover, it says create a
planar surface from a collection of boundary edges. But when we plug them in, so let's plug this one in first. And holding down Shift,
we'll add another one. So this one just
work automatically, but typically you do want
to flatten the input. This way. You kinda create
that surface in-between. But now that we have that
we need to do is split this surface into
the ground plane because this technically
won't be able to, You won't be able to develop
it because it kinda, the lowest point is
just one small point. This way we can just, the next step is
going to be to split this at a specific height. To do that, we need
to create a line. So we'll go here to
the outside upset. And we'll go here to endpoint. Then here we have a start and end point, which are the same. And what do I want to do
is bring in the mid point. This way we can create a line
from the start to the end, which is going to
be the midpoint. So the diameter length. Go here to line component between the start point
and this endpoint. Now with this, we can
split the surface. But the only thing that I would
do different is I want to have the ability to
move this up or down. But mostly down. Because
when we move it up, actually from this point up, it's going to split the arc. And to do this, we'll take a mood component. We'll be taking this
line or this geometry, bringing it into
the motion units z. Then negative y because we actually want
to move this down. Move this down, and then
we'll give this a value. We'll say 1.50. Then here changed the
name to structure split. This is going to determine
where. Let me show you here. So I'll disable the
preview on the line and both the midpoint and
the start and end point. Now with this curve, we're going to bring
in surface split. We're going to
take this surface, these and this curve that
we moved up and down, we're going to split it. What happens is we
have two fragments, because it's split it into
two through this curve. Now we only need to
pick one of them, because here we
have two outputs. The two, every time we want
to pick one of the items. Inside of a component,
we've got a list item. As long as they're coming
in, not dashed lines, which means grafted or
in individual groups. Then in here, we
can go index of 0. And if that's not
the one we want, which we don't, we
want the one on top. We go here to list and
reverse. This way. It always picks index of 0, which is the list
flipped backwards. It picks that 1 first. So here we can move
this up and down. And if it looks funky, it's because we have
overlapping geometry. So let's see this one, this one, and this one. Not this one. And disable the premium. The way I do it,
this middle click. Then there's this guy with that's blindfolded
disabled preview. Or you can also right-click on each component and disable the preview on
each or enable it. So with that, we have our base geometry that we're going to be
using for our design. Next thing we'll do
is split it down the middle and then have to recreate some of
those geometries. And so we'll be going over
all the steps right here.
3. Base and Arc array: Alright, so let's
take this surface. Now that this is the
leftover surface, Let's go back to this curve, but before we moved it down, so let's go up to here. Now we actually need
to take this curve, which is the one here
in the middle and split this new one that we have selected from
the first split, which is going to be
the ground plane. Now we're going to do a
surface wet once again, but this time
using, like I said, this surface and then
using this line segment As the cutting one. We're going to be
doing the same thing, which means to select or let's remove the
overlapping geometry. So all of this middle click
the Save we'll preview. Now we're going to be
taking this and going to item, list item. With this one. We'll take this, plug
it into the input, and we'll be taking a different
approach on this one. On this one I showed you how to use the index and reverse it. But here I'll show you
how to add the list item. One of the cool things that
this component analysis, you can add more parameters, which means that if
under the list here, we have three values. I can add 123
outputs. In this way. I can use those individually by using the surface component. This will be this bottom
left one will copy this, going to be bottom-right. And then this is
going to be the top. Now I can disable the
preview on all of this and we can look at these individually. Here's the thing. Since this is like a circle, we can technically just do one side in merit
to the other side. So I'm not too worried about having both of these separate. What matters is that we're
going to take this surface. We're now going to
be moving it to one side and extruding
it by twice the depth. What we'll do is take this. I'll go to move. It's going to move
it up by default. So what we want to
do is actually move it in which direction? In the x, positive y. And then we're going to
extrude it by negative bias. So we'll go here to, or it could be negative y and
extrude by positive. We'll go here to unit y, will be moving it in
this direction by 1.50. So we'll give it a
specific value here. Now, we'll go Extrude. But the trick is to take the surface rather than
extrude it will move it, and then extrude it
by the same amount, but then twice as much. We'll go here to negative. And then times two. So star two or x2, which will give me
a empty parameter for a and for B. We have to. Now it's going to
do that negative. Now we can extrude
this by twice as much. Now I can disable the
preview on all of this, because the next portion, we're now going to be taking this rectangle here and be arraying it around
to create that form. But now let's take this
and let's actually go to our midpoint or original point that we'll
use to create a y, z plane, which is going
to be our mirror plane. That mirror plane is, we'll use for a mirror input. And then we'll, I'll bring
this all the way over here and plug in this into the geometry. Now, whatever we do to one side, it will do to the other side, and we don't have to. It's actually easier for
the computer to do that. But not that. We're even doing too much, we're just doing one forum. So with this, that will plug those into a novel, leave
those there for now. Now we'll focus on. The next portion. Now let's
go back to this line, which that line is what's
splits this surface, right? Where this line overlaps with the surface before we
cut it, which is this one. Where these two overlap, I want to extract a curve
because that's what I want to use to extrude and
use as my base surface. So we'll go here to
the intersect tan. This will be rep with curve. Bring this down. There'll be using this as my era in this
line as my curve input. Now instead of
selecting both of them, I'll be selecting just one. So I'll go here to
item or list item. Now, just pick one of
them. Whichever one. Because it doesn't
really matter. We can mirror it anyway. Um, so we'll take
this and we'll be extruding it in the y-direction. We'll go here to extrude this line segment that
overlaps with that. We're going to extrude in
the y-direction by how much? Well, we know that we went
two times this amount. So halfway, it's only going to be here in the y-direction, and we will use that
input for this. So this is symmetrical
also this way. And this way we only need
to create one segment here to read the form that
we're trying to go for it. We'll take this, plug that
into the curve and put why? Because I only want the
outer edge of that surface. And when it's a planar surface, you can literally just plug in that component into a curve. And it will give you
the curve outline, and it gives it to
you as one polyline. This way we can now array this, the route, this, this curve. What happens though
is that if we take a look at that curve, which is actually our
original line, well, we have an entire
segment here and we only need a segment from this side all the
way to this side. So if you haven't noticed, one of the tricks that I
like to use is intersecting geometry to extract information. So we have this overall
line and we have this segment of this surface segments
that are overlapping. If I go here to
this surface here, it starts here and ends here. Now, if I go to a B-Raf, IRB will go up and where
those two intersect. So take this as my B
ramp, where the curve, which is the original, where they intersect here. Now we're going to go to this curve and we're
going to do when array, array and array, this
geometry through this curve. We can pick the
number of segments, so we'll go count five. Now we can take this and just to see what that
looks like altogether, will go to loft. And yeah, technically
we've recreated that in the more segments we have, the closer it is to
the actual curve. We're going to do now
is with these segments, we're going to change the
size of them and move them. This way we can make it
more of a dynamic design. But let's go back also. And let's play around and change some of these parameters. Let's now move on to
the next portion. I'm going to go over a few techniques that
will be super useful for changing a set of geometries here to
make it more dynamic. So let's go over that.
4. Arch Form: Okay, now let's take this lofted portion and
let's just delete it. We're going to be taking
these segments and scaling them relative to a graph. So what we'll do is we'll take this will go to
an area component because each one has to be scaled relative to
each center point. We will take this geometry, plug that into the geometry
or the area component, which will give us the centroid, which is the center
point of that rectangle. Now let's go here to
a scalar component, which will allow
us to then scale those geometries relative to it. As you can see, when you don't plug in, a different centroid, is going to scale
them all relative to the center point of the default, which is going to be 000. So we plug in all of
these center points, so it uses those as the
reference to scale firm. Now for the factor, well, we can go here to
1.5 and we can see that we can already
plug in a value, but we only have one value. And so the trick to get this to scale up to a large value in the middle and then
down to another two. Same value than it is. We need to take this all of these and
graph them according to. When you graph them according to a sine wave or a specific graph, you're able to change
it, change those values. So let me show you
without talking too much. Let me show you if we go
here to a graph mapper, which looks a little
bit intimidating, but it's actually super useful. So by default it
comes with nothing. So we'll right-click here
graph types and we'll go to sine, sine wave. What it does is
it's, it kinda gives you this sine wave and it plots values through this graph
to change the scale value. So what we need to do now
is go here to a range, because we need a
range of points. Specifically the exact same appoints that we have for this. So we'll go here to arrange and steps will go to the same
number as the count. We see we have all of these lines that represent
the different steps. That if we now plug
this into the factor, we'll see that it turns red because we have
this at the bottom. If we raise this, we'll see that we have this small to large and that's
good and everything. But what happens
is we need this to be at one and this
to be more than one. For that, I like to be specific about the number
that I'm going to pick. I like to use something
called a re-map numbers. And so this part is
a little bit tricky, but it does come
down to practice. I do this all the time. So you'll see me like, Oh, why is he doing that? Well, a lot of
these things you'll just have to do
over and over again because it's the
process that you take for doing specific things. So for remapping numbers, we're going to bring
in three different components all at once. Re-map numbers is one,
bounds, it's another. And the third one is
construct domain. These three always
come in together because to remap your numbers, you need to first know all of your values,
which are the ys. Then all of the values with bounds that gives us the biggest and smallest number. So we can now use
that as our source. And to construct from, let's say, to construct
a specific number. So we'll go here to 1.5. And we'll have two
different values. So we can construct it from
this number to this number. The domain goes into the target. So this is what I always
do when we're scaling. We typically go from 0 to one is going to
make it smaller. From one to two is going to make it larger and that one
is going to stay the same. And so that is for scaling, but for moving
things it's going to be a little bit
different because the value that you use as the exact amount that you're
going to be moving it. Okay. So now that I've gone over that, let me show you what really matters the most about this is that the initial incoming
value is 0.1.190.4. So we have 11 values coming in. They're all smaller than one. Now we have remapped
them with this. Now they're giving
us the values. So the input was that, and the output is going
to be 1.07 up to three. So now we're saying that we can pick this map number,
change the factor. If we go here to one. It keeps. So let me show you here
by selecting this, it keeps this at one which is the same size as
it was originally. And then here, we're able to change the scale as it
goes to the center. Now, the importance
about this is we don't even necessarily have
to do with scale. We can do it with offset, we can do it with
rounding off the edges. We can do it pick a different, many different methods to
create different geometries. But I'm showing you the most
efficient way of doing this. So then later on, once he knows some techniques, you can then apply those
to many other designs and then have a lot of fun using
this method of modeling. So with that being said, we'll take that and
we'll loft it together. Here at the end. It's actually
giving us an extra. What it is, is the range
of steps is giving us ten, but we actually have 11 objects. What happens is when I use ten, that is not correct. We have to do a plus
one, giving us 11. Or it might be minus one. Let's go here. Yeah, it's gonna be minus one. So my apologies on that. But once we get that
little adjustment and then we're able to see, that's the other thing
is you'll be able to see if there's an issue. And usually when there's
an issue it's new. It is the code that is broken because the computer is gonna do whatever
you program into it. So with that being said,
let's move this around. We can even make it smaller too. So I think that
actually it's sometimes be cool like that. So 0.5 is going to be half the size of
what it was before. And then two is going to be twice the size of what it was. And then here we have, if you recall, by
default, we have our X, Z plane, which means that we can mirror using this plane,
SR, mirror plane. This loft, which I like to have holes because it's
not going to be a solid. Disabled the preview here, and then use that
as the near plane. And I feel like that
looks really cool. But the last thing
we will be doing is taking this geometry. And rather than it just
scaling down here, we're actually going to
be moving all of this to the right and create some
kind of shade structures. So like when you're
standing under this, you should be able
to be covered. So let's go over those steps.
5. Conclusion: What we'll do is disable
the preview on this, which is going to be all the
law and the mirror plane because we need to
recreate that law. And the way to recreate
it is going to be okay, we scaled it, but
now we're going to scale it and move
it to the right. Maybe the scale too much. So we'll go 1.5 and then
move this to the right. Now, here's the thing. We can move it a specific value, but it's going to move
them all the same. Or we can take these values
and remap them again, but to move components. And so the reason why we see two here is because we
have our originals. I'll disable the
preview on that. Now we can take these and
move them to the right. So we'll go here to
move. We'll move these in the y-direction. Look here. Rather than using one value. I'll take all of this, copy it down, and then use this, these remap values as the move. So it moves them. Bind z, nothing here
at the beginning. We'll go here by one. Actually, here by 0. Then here. The reason why is because since we're using a mood component and not a
scale, when we move by 0. Well, that means that this
moves by 0 and this moves a maximum of three,
three feet overhang. So this would be the overhang. Now I can disable the
preview on this and plug these slides into
the locked component, which gives us this. Therefore, if I disable the
preview on all of this and bring back our mirror and app. Now we see that we can change these values here to meet our whatever we
want for our design. Now, at this point we can
disable the preview on, I keep saying that on
all of this stuff, including the stuff
at the beginning. And even these points here. Now I'll go to. And lastly, Okay, now
that we have this, we're going to deconstruct
both of these, get this outside curve, and create that surface between those two
will go here too. Listitem. And the thing is, when you have a list item, you can't just plug in. Let's say this be rep in and
be able to pick anything. We need to go here to
deconstruct the wrap, which will basically
exploded into the different
things that it has. So it has phases which
are the surfaces, edges which are the lines, and vertices which
are the points, will be using the
edges as the input. Now, use an index and change
the value using the slider. I'll reverse. Now we'll leave it like this. So the ninth curve is
the one that I want. Now I can disable the preview
on this and do that again. But for the other one. Let's see if it works
with the item nine. This one actually, that's
gonna be the B-Raf to plug in. The edges, the ninth edge, that one and this one, perfect. Now that I was able
to select, those two, will go to loft and
select both of those. What happens is this
one and this one, they're both leftover that we actually have to flip
it curb direction. Now we can use the
path component to create that surface
between those two. Let's go back here
and let's change. Let's also be aware that
this is going to be the psi, the amount that is
going to go out buy. We can also use some
funky stuff like this. When you have this graph, you want to visualize the center point
and it's starting and ending here. And you cannot. I think that one is fine. Just before we couldn't
have since we remapped it. It's fine for it to
be down here now. If you want to get crazier. So for the most part,
completed the tutorial. Just want to show you
a few more things. If you don't like this,
there are other graph types. Bezier, which means it starts here and now
that you've had, but if we bring it
down like this, we have some kind of control
points that we can use. I think that's kinda cool. Right? And then back here. So different graph types
play around with them. Sign. This one is kind of
artistic like this. More. I like to keep it
straightforward because for the most part, the concept is what? The technique is, what matters. Then later on, you can come up with whatever
design you want. And with that being said, hopefully you found that
interesting and useful. Thank you very much
for being here and I hope to see you next time.
DCO Graphicstudio
