Transcripts
1. Intro: Hi and welcome to DCO. My name is David capacity
and in this video, I'll be sharing how to create this truss system that
is based on a curve. That then we create a subdivision and
then sweep it around. Then subdivided into this
wireframe trust system that can be applied
to any curve. So let's move this
around and show you some of the
capabilities here. We can change size or the radius of the
overall truss system. Here we have how many it's
going to be subdividing it by. And typically three
is the minimum. Here we have the subdivisions
of 20 is too much. We can always change it
to something like ten. Here we have only
one subdivision and the U and the V in that. So it creates just one segment. At the end. We extract
the wireframe and create this x design and plug it
into both sub D multi pipe. But also the pipe structure here that we can use
two different sizes. 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 Form: The first thing we
want to do is bring in a line segment that we can
use to create our trust. What we'll do is we'll go
here and bring in an arc. And that's what we use
for our example here. And there's different
ways to create an art, but we'll be using
the typical one where we have a plane input
a radius and an angle with the plane will
go here two x, z plane. The radius, I'll
plug in a value. And now using this segment, another segment that
I've created here, that we can also
use us an input, but we can hide that for now. Maybe we'll use that later. Here with this arc, we
need to create a frame or a segment that is
perpendicular to this line. So there's a component
called perpendicular frame, which will create a frame at the beginning of
this line segment. So plugging this
arc into the curve. And for parameter it's going
to ask us to a curve domain. So what I'll do is I'll
construct a point. And I'll use it here
at the 0 coordinate. And I'll plug that point
into the perimeter. And so basically we
can move this point. And I don't want to be, be this one because
it's previewing the point moving along the x. And we want to show it
moving along the curve. And we can change the
slider to be a max of 500. And we can change
where that is located. Now that we have this
perpendicular frame, we can use that to create a
segment that is a polygon. There are different
ways to do this. We can start with the circles subdivided with
points and use that, or you can use the
polygon component, which will create a polygon. On this frame. We can change the radius, but we can also
change the segment. So we'll go to three,
less than eight. This way we can create three
to eight subdivisions. And I'll go down to three. And the radius is
going to be the size. Well, we need to do now
is take this segment and sweep it around that arc. So we'll go here to sweep one. Sweep one is going to ask us to plug in a rail, a section. It says miter, we
won't use that one. But just keep in mind that we need to plug the correct ones into
the correct one. So polygons going to be the section and the rail
is going to be our arc. Now one of the things I want to, a technique that I want to
share is that if you want, if the idea for this script
is going to be to change, be able to change it any curve and change it into a
segment like this. Then you need to keep
in mind that we have this arc output going into
two different inputs. And it's a lot cleaner
to have one output here. Go into this one, in one, go into
this, went this way. We can change the arc. And this is why I have
here, if I do show, I have a different arc segment
here that they created using a spline or a nurbs curve. But here I'll bring in a curve component allowing
me to then select this. They can go to this component, right-click and set one curve. Now we can use that as the input and see that
it does also work. And it's maintaining all of the programming that
I've created here. So let's plug this
into the original one and leave this as
more of an option. We'll disable the
preview on this. The next thing we'll
do is we'll go here to our output and let's take
a look at our B-Raf. So it says Open be rep. So we know that this B-Raf is, consists of that hexagon, so that is six segments. The spring this down
to the three segments. This take this be rep, and we need to subdivide it. So to do that, there
are different ways. I'm going to show you the one of the approaches
that will maintain the arc of it or that
the flow of that curve.
3. Form Subdivisions: So what we'll do is we'll
go with one approach. And if there's a
different approach that I feel like is better, I might switch into that one, but for now, we'll take this be wrapped and we'll
deconstruct it. Basically taking an
exploding it into their own separate bases. We'll plug this into
the B-Raf input. Now the faces is what
we're looking at. When I hover here we have three different surfaces
that we want to plug it into an isotropic ISO trim. Every time we bring it in, we bring it in with divide, where at least I do
Divide domain squared. So we can subdivided
into u and v count. Now plugging the faces both into the domain and the surface. And plugging the segments
into the domain. As you can see, there's
something funky going on. And that is because
we have this, these phases coming out, not grafted, and then these segments come
out, grabbed it. So we need to go here
and grabbed the input. As you can see, we have
way too many subdivisions. I'll disable the preview here. Now, let's change
the u and v count because for this
to work correctly, it's either in the u and the v, we have to do one. And then in the other way, we can have as many as we want. So we'll go here to five. So these are the ones
that go across this way, perpendicular to the curb. And then these would be the ones that create the original. Alright, so now we
have one segment, we have seven segments here. And now we can take
this and create more subdivisions because
I think that's not enough. Go here to 100. So those are the
subdivisions that we can create along that arc. And the reason why
it's looking kinda weird is because we're
still previewing all of this that we don't
technically need to. So what we're doing is We're
sub-dividing it this way, but there are different
ways that we can solve the sub-divide the inside. So I'm going to show
you one technique. But there are different
ways we can do this. You can just create a
diagonal if we want to. So what we'll do is we'll first extract the wireframe of this. Then we'll go in and
add more detail. Because then that could
be two different options. We can have it be a trust
that's created just with straight segments that maybe are welded together, were
bolted together. But we could also
have some that have either diagonals or x's that connect either
to the middle. Or we can figure that out. So what we can do is take this, use a join B-Raf, basically joining it altogether. This way we don't have
redundant lines here. And that's a technique that I suggest when you're
just trying to do wireframe designs is we
don't have redundant lines. Now we see here that we have one open pyrene, which is fine. Now we want to go to be rough edges and extract all of the edges here. I'll disable the
preview on everything. And now you'll see that we
have aided that system. Now. It's created off of
that base curve. So we can also include that
base curve if we want to SR design. That's up to you. There are so many
different ways that we can develop this, that this is going to
be the most basic way that you can do it
in a few steps here. So you can just use a base curve and then create some kind of structure that looks like
it's fully developed. So now let's take this
and we're going to not just extract that wireframe, but let's extract
an x out of here. What we'll do is we'll
go to these surfaces before we joined it. And we're going to bring
in an area component, giving us the midpoint of every single one
of those panels. Now that we have the midpoint, we're going to go
to deconstruct be rep. We're going to basically deconstruct
all of these phases. But now we'll actually
take the output of the faces into the center or the centroid so we
can get the center. And now we're going to
take these vertices, which are these outer points, and plug them into the
outside to the center. So we'll go here to align component and start with
vertices as the start point, the centroid as the endpoint. Now if I disable the
preview on all of this, now we have a bit more of a complex design just because it goes from the
outside to the center, right? And let's play around
with some of these and change the slider so we can decrease it because
if you have diagonals, you have more support.
4. Wireframe Structure: For this next portion, now
that we have these two, Let's plug those into
a pipe component. This way we can see what it looks like when
it has a little bit of some structure to it. So let's go here to pipe a plug those interior
once into the input. And also the naked one. The naked ones are going to
be the ones on the outside and the interior ones will
be the ones on the inside. We can have this with
two different sizes. So we can say 1.5 for the outside and change the
caps here by right-clicking. We can go to round caps and
now have a different size. So I'll copy this over and have these be the input
for the inside ones. And happened to be
a smaller size. That's one way to kinda created pretty straightforward
with two different sizes. And the next way would be to
use the sub D multi pipe. I have my own method
of using this one. But you can basically
plug in all of your curves into
the curve input. I'll disable the
preview on this. And then I'll flatten the input. With this one. The creates a really
nice connection. A neat connection here. Now we can change the size, strength size. I'll go 1.500. What happens is it starts
making the segment large, but the connection small. Create a copy and
then go to node size. Then be able to increase that. But then I have to decrease
the size of the stroke size. Either way, those
two kind of work. And that kinda concludes the idea of the basics of how we can create
the stress. Now.
5. Array Structure: The cool thing is that
we can take this arc. We can create an
array of arcs here. So if I take this arc, go here to move. I'll take this art, move
it in the y-direction. So I'll go here to unit y. And I'll plug in the factor. I'll go here to series. The step is going to be 240. That's how much I
want them to be spaced out by the count. I only want five. And start at 0 is fine. Now we can do a series of numbers starting at
0 and ending at 960, stepping by 240 with
five different numbers. Plug that into the
factor and those unit vectors we'll go into here. Now, maybe the gap is
a little bit too big. Maybe this is just a
little bit too small. Now let's move around and let's play around with some
of these parameters. Because we can do now is
with all of these curves, we can plug those into. Here. What we need to do is
grasped each output. And now it's going to create that trust system
for all of those. So this is why I feel like
grasshoppers so valuable and so important is because it
allows us to program a design, let's say this
type of structure. And now we can apply
to any curve and play and change. How
many subdivisions. So if this is three, we're going to now go to for now it does have to calculate
all of those movements. So it does take a
little bit of time. But how cool is that? And this is just the
basics of creating this trust system
without any fancy. Other things that we could do. We can take these
segments around here and then twist them and
start turning them around. Reading more of a dynamic
design for each segment. What we'll do now is go
here to stress size. We have too many. It does make it a
little bit harder, especially when we have
these many subdivisions. So we'll go to three. Now we'll go here too. So we've done this
mostly parametric here.
6. Conclusion Dynamic Arcs from Rhino: What I will be doing now
is let's go here in Rhino. And let's create a set of
arcs that are more dynamic. So I'll just create
a basic arc here, starting here and in
here direction this way. Then under the top view, I'll create a copy. I'll create more than one copy. So I'll do copy or non project, so we don't move it up or down. Now in here, I'm
going to select it, go to cage edit, bounding box. And I'll do the default
for world spacebar, spacebar until I get the points. Now I'll take this, this over that again. But this edit. One more time, like
this, cage edit, mounting, boss,
Enter, Enter, Enter. Now select these two come over. Select the top ones. Who'd them up. Now we have all of
these different curves. Go in here in r9 into grasshopper and go to
Select set multiple curves. Now let's try it out. Let's try to see if those inputs worked out with our design. And they won't until
we graphed it. So let's go here to graft. And it will create those
segments right on that. So if you had,
let's say a design of something like this
that was slotted. You can take this
and now offset this, flip the direction,
and then be at a gap. This way, we will
do solve it now. And so I can kind of keep off-setting it until
I get to the outside. And this is just a rough sketch. That's how cool and that's
how useful it can be. To also combine
grasshopper with Rhino. Because you can create a lot of more dynamic and quick
changes if you're modeling, but you do miss out on some of the capabilities that you can do here. Instead
of grasshopper.
7. Bonus Content Further Modifications: So in this portion, I actually want to keep working
on this a little bit more and go back
to our original Ark. Then we can basically
disable the preview here. Most of it is just basically disable preview here and
even disable it, right? So we don't, it
doesn't compute it. We don't even need this one yet. And I'll go back to this one. I am now going to use
this era and just deconstructed or go
to Europe edges. And now I'll actually
copy over one of these, enable them to turn
both of these in, turn the preview on. So the option that
I'm creating here, it's going to be
with outer frames that have a specific size. And then here we'll
just do an array of these segments here
than being smaller. So how can we figure that out? Well, we need to go back to
our, I'll disable this one. We'll go back to our
arc, which is this one. Then we have our segment,
which is this one. What we'll do is we'll
create a pipe segment here. So we'll take this,
copy it over again, the polygon into the pipe. Let's disable the
preview on this. We can just take a
look at the segment. What I'm doing here is
just decreasing it. Now we'll do a ray
curb or curb array. We'll array this pipe or
this geometry along the arc. My apologies on the
background sounds. So let's go here and plug
this arc into occur. Now here we can pick how
many copies it creates. Vocal here to count. Now, I'll preview this pipe. This is another cool way
that we can develop. This. Change the size of
the outside one here. And then here is the size or the copies of the
ones on the inside. And then with this
one, change the size. What I'm seeing is
that at the end we can do a Boolean union, but I don't recommend
it because it will, I think it will cause
some issues. For now. We'll leave it like this.
I just wanted to show you some even more
options as to how you can do something like this or how you can develop
a structure like this. I'll leave this here on the
side and I'll group it. So this will be technically a different option
than this one. Now for this last extra content, I do want to show how
to not just create this extrusion or this
one segment like this. I do want to show you how
to make it more dynamic. So for that, we'll take
this or disable it. Well, even to save symbol that preview on this
because we don't need it. And same with some of this. We'll use the same
segment and we'll use the same arc here. Now, what we want to do here is create a perpendicular frame, but a set of
perpendicular frames. So we'll use the arc. Rather than just doing one. We'll do this,
we'll copy it over. And so I'll plug in the
frames into the plane. So we basically created a
set of copies of this shape. Now what I do want to make
sure is that I only do, let's say three for now. So the radius is going to be 42. Then if I plug in a
different radius, going to do a different
radius for the next one. Then if I plug into
the next radius, so making three
different sliders, plugging them in progressively. One per each. So just
make sure that you don't change the
number of counts here. Now with that, we can loft
together those lines. We can have the middle one. Same. So we'll do,
let's say 42 here. Then 42 here. Or you can write with this one. We can plug that into this one, into this design
that we have here. So this is just creating that base surface that
we can then develop. So sorry about the
background sound. But what I'll do is I'll
take this and I'll copy it over all of this. Copy it up. Then I'll plug in
this locked into the input. And now I will
enable all of this. Then I will also preview
this one at the end. So the cool thing is
that we know that we needed that base loft because it's the
same thing as this. It now we basically
subdivided it and created that same subdivision with
a different base surface. So let's go back here and take a look at
how this was created. Let's see how we can also
change it here on the fly. And have it be dynamically. So remember, we
can't change that, but we can change, or we could change it, but
we have to add more inputs. We'll go here to five. You'll see how that works. I hope you enjoyed
that extra contents. I will also have this on
the script Paltz portion. If you have any questions, check out my website and
send me a message there, I can answer any question. And thank you once
again for being here.
DCO Graphicstudio
