Transcripts
1. Introduction: Hi and welcome to DCO. My name is David for
petty and in this video, I'll be sharing out to
create this bus system. We'll start with
the outer frame, then move on to techniques for creating the inside pattern. Then we do an array
in a linear way. And those are the basics of what we'll be
going over today. So thank you very
much 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 Arch: The first thing we'll
do is go here inside of the new Rhino file and
a new grasshopper file. I'll type in units and
I'll be working with feet. And then here inside of
the grasshopper bowel, I'll go to New Document
and I'll make sure to have the Drawer icon spans
the wires and names. This way we're both
on the same page. Now let's get started
with our base geometry, which is going to be a
curve or a line segment. To keep it simple
for this exercise, let's go ahead and
create an arc. So we'll start here by
bringing in x, z plane, which will allow us to change the base grid to an orientation where we can
place that arc upright. Otherwise it's going to be
created here on the ground. Let me show you here. Let's
go to an arc component. Now, let's go here. Take the plane input or the output and plug
that into the input. And as you can see,
let me unplug this. By default, it will create
it here in the x, y plane. And you can see that
when you hover over the input is going to say x, y. We're going to
change that to x, z. But now let's change
the radius to size. That's reasonable.
Nothing too large. We don't want too many
subdivisions to start, and we can always change
this as we move along. So I'll double-click,
bring in a slider or 15. So if you just type in 15, It'll give you one
from 0 to 100. Now we can plug that
in as a radius. So this is going to be obeys
geometry and technically this slider is going to be
the size of her design. So we'll go here
to number slider, change this to structure size. This way we can keep track of
what our sliders are doing. Sometimes I go fairly quick
when I'm getting into flow. So it's good to always
keep those organized. Now we're going to move on and offset this to create
that trust design. When we have this space curve, well, what we need
to do is offset it. So we'll go here
to offset curve. We're going to offset this arc. Well, so we'll plug that
arc into the input here. And when you do an offset, it's going to always ask
you for a reference plane. What happens though
is when this arc is plugged into a curve, it automatically will give you the same plane
that the arccosine. So it kind of references that, but it's always a
good practice to plug in this plane into the
plane and put in this way, it will use this
reference plane, SR, offset geometry,
reference point. So with that being said, let's move on to not just offsetting it by
a default of one. But we'll go here to 1.50. I also want to offset
it to the inside. What I'll do is I'll take this, copy it down, or we
can add another input. I do the lake to keep them
in a separate component. So we can either go 1.5
bringing a negative component. Now we can plug in
this one additionally, so holding down Shift and we can now do it to the outside,
into the inside. But I actually like
personally having two separate
components where this bottom one and this
top one are going to be offsets from the center, but they're going to be
in a different component. Another way of doing this would be to, let me copy this here. We'll do both of the inputs into this one and then
go to a list item. Plug that in. And since we
know we have two curves, we will have to
flatten the input because it's actually
bringing in it, bringing it in grafted. So we'll go up to
flatten it here. And then here for the output, we could have two
separate outputs or inside of this component. So there's two different
ways of doing it. Whichever one you
feel comfortable with is the direction
you should go. And also these are techniques
that may work on one, it may not work on the other
end and all the way around. So with that being said, I will delete this for
now and just use these two as our base offsets. Now what we want to
do is take these two and close this into
a closed polyline. And so there are two
ways of doing that. Technically, we can
loft this together. But one of the techniques
I like to use too close to offset curves is
go to the end points, which will give us the
endpoints of this in this. So we'll plug in the curve
until the curve input. We'll do the same
thing down here. So I'm sliding it, tapping
Alt to make a copy. And now we have the
start and end points. While we know that
when we have points, we can create line segments. So I'll create a line segment between the start and end point. And now I'll tie the
start points together, giving us the start
point and start point, creating a line segment
between the two. Now doing the same, tapping Alt and
copying it over and now creating the line
segment for this other side. Now what we need to do is we'll move this
stuff to the side. We'll label this
structure offset. Now we're going to
join them together. So let's go here to join curves. Now we'll move these
a little bit down and then plug all of those
into the current input. Now here at the end, when
I hover over the input, it'll say four values, which are going to
be those four lines. And then here under the output
it says one lowest plane, our curve, which is
great when we go here now and I middle
click and bake. When we select that line, I'll move it over to the side. This is also a way
that you can test or make sure that things
are going correctly, right? If I would have selected
this and moved it to the side and it was not joined. Then I would be worried because that's one
of the things I wanted to do here on the
script is joined that curve. But now that it's joined, well, we can take these
joints, joint curves, and go here to boundary surface, which is going to
create a surface with a bounding curve
as long as it's planar. And so with this, we can
move forward and start creating a little
bit more detail and adding a few more things. But this is going to be the most important
critical base geometry for creating this design. So let's move on to adding a few more details and I'll go over a few techniques for that.
3. Frame and Array: Alright, so for
this next portion, we're going to offset this curve to the inside and
just create an outer frame. And that outer frame will become what supports the
inside subdivisions. So let's take this line
work and let's offset it. So we'll go to an
offset curve similar to what we did with
the original line. And we'll plug this
into the curve input. And to the outside. It's upsetting to the
outside, which is good. Now we can give it a value. So we'll say 1.50. I'll
be a little bit too much. We'll go down like this. If you want it to
go to the inside, we can also do that. So actually it's going to be better for it
to go to the inside. Otherwise, it's going to go lower than our
construction plane here. And I think it's going
to be better this way. Negative the inside
right now and said 0. So it's not offsetting
it by anything. And then here it will
change the values. So we'll go here to two. Then 0.2 here between
this line and this line. Now we're going to do
something similar with this, but we're going to create
the surface between those two as long as
they're on the same plane. Like I mentioned, we
can add both of these. The plaintiff or to the edges input and then
flatten the input here. Next we're going to take this. Now, we'll extrude it
in the y direction. And one of the ways
I guide myself is using this bottom left x, y, z coordinate system. We can extrude it here
in the y-direction. So we'll go here to Extrude. Extrude you can plug in
both surfaces and curves. Unlike in Rhino and rhino, you have to type in
extrude curve or surface. But this one, we can
plug it into this one. And now the direction, well, it's not going to get do
anything unless we tell it what direction
will go to unit y. Now, we'll do this once again. Copy this slider over. This is the structure. Reframe that. And this is going
to be frame offset. If we go back to the start, Let's see if everything is
still working and it is, so is the upset. The outer frame and the depth of that frame
here. Okay, cool. So now that we've
created the outer frame, there are different ways to
create the inside portion. I'll be going over two
different ways of doing it. The Let's go over some of those. We'll take this original
surface and let's hide it. So right-click disabled preview. And what we're going
to do is create the segments that go in here
using this original curve. So this arc and will be creating
one segment and arraying it around this and then
moving it halfway. So let's start first by going
back to the original Ark. And let's also find this line
segment that we have here, which was the one that
closed the two offsets. So with this, we're
then going to go to a ray curb or curb array. And we'll plug in the
lines into the geometry. This arc as a curve. And you'll see that
it's actually, we should do the other side because the curve is
the other way round. So this one is the one that
will actually work, right? So if we select this, this
is a start, This is the end. It's going to array it this way. If you have it organized
all the way around, then it's probably because the way that the arc is
created, you have it backwards. So with that we have
the count amounts. So we can go here to 15. This is a way to be able
to sub-divide it here. Now the only thing
is that we have a first and last
curve that we don't want to do that to select all
of them except for those. There are a few tricks
that we can use here. Let me share with you
the way to do this. So if we go here under Geometry, Let's lower this to like five. We have five subdivisions where we technically only need 123. And then the first and
last, we don't need. What we need to do is go
to select only non-zero, but 123, and then
subtract the last one.
4. Truss Webbing: So now that we have
our lines here, well, we need to get rid of the
first and the last one. So we'll go here to list item. And since we have five, we need to pick
not the first one, but the second curve and
then subtract the last one. What I'll do so bring
in a series of numbers. That count will go to five
because we have five here. But we can lower that.
This step is going to be by one because
we want a series of numbers stepping by one and starting not at 0, but at one. Then here we need to plug in that geometry into
the list item, then the series into the index. Now we have five numbers. We actually want to
decrease this to three. So what we need to do
is five minus two. So we actually need to subtract two numbers from the
total count number. And what this does, so what series does
is it'll create a series of numbers
starting at one, which is this one, and then ending three numbers later because we have
to get rid of two. Then the count will be three and the series of
numbers will be 123. And that create, that selects
only the inside ones. And if we increase the count, it'll do the same
for all of them. What happens is we
technically just removed the first and last item from
this entire list of arrays. And so that is one way that
I like to do that by using basically the data and the
numbers that we plugged in to figure out how to basically
remove the first and last. Now with this, now we can move into turning this into a pipe. But let's go here to
a pipe component. And we'll plug in those
curves into the pipe input. And now we'll go caps. And then radius 0.888. This is going to be, let's call it re number. And then here, starting one, ending up being by
one, starting at one, and stabbing or count
two less than the total. That's basically the equation of how to remove the first and last when you do
an array like this. Now with this, so let's
hide most of this stuff. Now with the pipes now,
they're all the way out here in the
front, which is cool. But what happens is it
technically doesn't work because we're all
the way to the outside. But we need to move it
in the y-direction by the same amount as the pipe or more. We'll just center it. And so let me show you
how since this was extruded in the
y-direction by 0.98, then we need to move this in the y direction by half of that. So we'll bring in
a mood component. Will move it, move this pipe. In which direction?
In the y direction. Basically moves it
to the other side. And then we'll do times 0.5. We can hide. Here's the thing,
the line segment. All of these line segments here are a little bit too long, so they will go into the
outside portion of the frame. So what we need to do is take this and we'll scale it down. Relative to the center of
each, will get a scale. We'll bring in a
midpoint because we reference the scale, we
need it from the center. So it does it equally
from each side. Will center it and then factor. It has to be smaller than one. For it to be smaller
will go to 0.998. Now we can select this
and plug our geometry n, which is going to be the
line work here with this. And even down here caps round. Now we can plug that line
work into the pipe component. The pipe component, we
unplug from the original. So you can right-click here, Disconnect this one
and the scaled ones. We'll connect again. What I'm doing is
changing the scale of that pipe and also here, changing that some of the
subdivisions so we can see exactly how that works. I'll disable the preview on
most of this stuff except for our final portion. That is one way to get the structure
working like that is to take these segments, create it down here, a ray it. And that will basically take care of the subdivisions here. Now the next one is
going to be different, which is creating a circle here and arraying it and
seeing what that looks like. And so those will be the two techniques
that I'll go over. And then we'll go ahead and take this design and array it. This way you can see what it
looks like when you create one basically block
of your geometry. And then you can go
further and array it and create other things, right? So we'll be going over
those things right now.
5. Truss Webbing circular: So what I'll do is
I'll take most of this stuff that we have here. And I'll just be middle
click and disabled preview. This way we can work on the rest of the
design solid group, this also control gene. Once you get that group,
you can kinda see this is going to be the iteration
for one of the patterns. Now we'll be creating another
iteration for the inside. Let's go to our base arc. And let's go here
to divide curb. We're basically going to be
doing the same thing where we select only the
first and last. But what we'll do is
we'll take these points, will bring in a y, x, z plane, and please that
exactly where those points are. Now, we're going to go to a circle component and we'll
use the plane as the input. The radius is going to
be the structure offset. This way it ties
it to the outside, but we can also technically
make it a little bit smaller. So the radius, we can, we can have its own slider
here if we want to. Sometimes the
construction planes are a little of noxious
like they get in the way. So I'll select it,
disabled the preview. And then in here, well, it actually wouldn't look
too bad if we do like half a circle at the
beginning and then goes on. This is going to
determine our account. So we'll go to 15. Now at this point, well,
we have our circles. We also have this
surface up here. What I'm going to do is wherever the surface overlaps
with the lines, I'm going to get the line work. I'll go here to
intersect physical. And then we'll go
B-Raf and curve. So it'll be this surface
here as the input. And the curve is going
to be the circle. As you can see, it cuts it here. And so now we can use this and do something similar
to what we did here. Well, the pipe component, I'll copy it down here. Copy it up here, and then use these
lines as our curb input and preview
our stuff here. So let's go here to flatten. What happens is
caps are loud here. And here's the other thing
that I'm noticing is that actually that may not
be the best one to use. What I mean is this surface
may not be the best. Why? Because it's the outside. So after that we have
offset it to the inside. If I use that. So if I go here to boundary
surfaces and create one on the inside frame and use that
as my intersecting surface. It actually cuts it off and it basically fixes the
issue that we had. Here. We have this
one, this one. I want to bring this over here. And let's zoom out and organize
this a little bit better. And so by using the
intersecting technique, we don't need to do
any of the list item thinks that we did here where we basically subtract the
first and last one. Now, all we need to do
is intersect those two. So that's a good thing too. Now, I'll go in here and
let's change the array. Next is do what we did here, which is moving halfway. And copy this here, plug that in and
then preview it. And it's now previewing
it in the right location. That's disabled
the preview here. So this is going to be the circle size two
and then this is going to be one actually. Then here, right-click. And then circle size too. This one is scale. And then here under the radius, we're going to then go here
to this one and change these two options we
have on the inside. I'll disable this so we
can see the final portion. The depth is a little bit
too much on this one. And it keeps it
right at the center. So two different options with this one and
with the frame. Now we can create a, an array with these two. So that's what we'll be
doing with these two.
6. Truss Webbing and Conclusion: What I'll do is I'll
take these top ones. Basically the other option, and I'll Control G and group it. Now, let's take this and
array it in the y-direction. I'll take this.
These two will go to a mood component and
also a series component. This will let us pick more than one number so
we can create an array. And then we need a direction which is going to be in the unit y in this direction. Now we'll go to the series
component into the factor. The count is going to be how many copies you
want to create. So we'll go here to
the step amount is how much space in-between the two copies will
go here to 15. And starting is going to be, what is it going to
have the first gap at? So we'll go to start
0. It should be fine. Now, we can plug in
our geometry for both this one and plug the
y factor into the motion. And the reason why it creates that many copies is
because here at the, at the output we have 12. Let's see. We have five different values
and they go 015304516. That's the copies
that it's creating. Now if we want to
array other things, The way to do it, to have separate outputs. This way you can put them
into different layers. Well, we can use
this, copy it up. Now, we can array, let's say this design. Let's disable the preview
on our original stuff. And we're able to see that yes, we're a rated in
the y-direction. There's 15 feet between them. We have five of them total. And that's a technique
I typically use when I want to erase this
in a linear way. Now there are other
things that we can do like creating a curve or creating a segment that
you can array this through. But the idea for this tutorial is more like the techniques that will allow you to
create something like this. And then later on, I
will share with you guys other techniques that can let
you create more of like a, not such a linear extrusion, but more of a dynamic design. So with that being said, let's move forward
here and let's array. Not just that, but
we'll use this one down here as another option. Now what I will do is
disable the preview on it. And we'll be keeping it here. And we'll be moving
on to the next step. Though. We've had
these two iterations. Now I want to hide
those because there is one more iteration that I want to show that it's
actually really cool. And we already have most
of the work done for that. The way to do that is we'll go to this surface
that we had here. This surface that we had
created on the inside. We want to bring in the circles. Let's decrease the size. We're going to subtract the
circles from this surface. Go here to region difference. And we'll subtract from the
inside surface those circles. As you can see, it creates the outer boundary
of that region, so it subtracts the circles. Now we can go to
boundary surfaces again. Disabled the preview. When you do Region
difference and you have a lot of objects, it does sometimes
lag a little bit, but just keep that in mind. So we're here at
0.8, we'll do 0.75. Now we'll extrude that. Rather than move, it will go to extrude in the y-direction. The surface will extrude
in the y-direction. And we'll bring in a
slider for the depth of this and move it halfway. Once again, the same way
that all of these removed. The center will go to this one disabled or take this
copy it up and then we'll move this portion to the center. Good, Now we have this, and let's disable the preview on this
because it's getting in the way it's halfway
through this. Let's see here. This is
going to be the array. So before we array it, so sorry about that. Before we re, we actually move it in the y-direction
half the distance. So we'll plug this motion, this one down here, and it's going to be the
y-direction to the center. Now, we can disable the
preview on all of this stuff. And now we can array it
again. Copy this up. And we'll use this input to
a ray through all of them. So we're just basically copying the array portion of it
and arraying it this way. Now these are circles, right? So with the circle,
we can be polylines, we can create polygons. And so you don't necessarily just have
to stick with circles. We can do any other design. So with that being said, hopefully you found
that interesting. I will be doing a render showing you what this looks
like at the end. Last thing that I
would do is probably create more of a
cover structure. It'll be glass for the
design that I'll be showing. But yeah, hopefully you found that interesting
and useful. Let me know if you
have any questions. I'd love to help you through learning more techniques
for parametric design.
DCO Graphicstudio
