Transcripts
1. INTRO: Hi everyone and welcome to DCO. My name is David confetti and in this video I'll be
sharing how to create this suspended late design that was created here
inside a grasshopper. At the end I'll be showing how I turned it into
something like this. If we go here to shaded mode
and if we hide everything, go back to the design. Here, you can probably see that it's a
straightforward design. I'll be actually doing all
of the steps in detail. And we'll be going
over out to take this design from a random
generated surface. Then we can add
and remove points. Then we created another
random generated set of points that was
then projected down. Then that was used to create
the suspended light Design. I'll be gone. Like I
said, I'll be going over all of the steps here. If you have any
questions or anything, make sure to let me know. Thank you very much
for being here. And let's go ahead
and jump right in. I'll be sharing how the
program more exciting, walking through all of
the steps in detail. This way you can understand
how it all functions. 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. 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 SURFACE: The first thing we're
going to do for this exercise is notice that the units I'm using
are going to be in feet. Then starting with a
brand new project, we're going to bring
in a plane surface. But honestly this
could be anything. For the most part, I'll be using the plane and that
will represent, let's say, a surface
that you can bring in. So you're not limited to four, it being a rectangle, it could be any shape. But for now we'll be using
a base rectangle for this. Let's go here to a plane. Surface. Here on the
plane will go x, y plane. We can even move this
up, this plane up. Let's tapers off the
ground by ten feet. Say ten instructor points here. Having this be ten, unit of ten up. Now what we're gonna do is
plug in a size for x and y. Go here to 15. There'll be 15. By 15. We can always change this round. I'm starting with it being
a little bit smaller. But the cool thing about this is that we
can always change the slider and
increase the size. Next thing we'll do is
we're going to take this and sub-divide
it using points. Now there are different ways in which we can sub-divide this. The tool that come
in mind would be surface frames or
divide surface. This will give us a u and v point count, right
on that surface. So now let's change the
u and v count number of three and then less than 15. So we have a slider
from three to 15. Now let's change this
around a little bit. Now with these points, we're now going to move
them down randomly. What this is going to do
is then give us kinda like a topographical
surface that would be kind of wavy randomly. And that would be the
surface that will be projecting the other
set of points onto. Great. So now that we have this, we're going to visualize
that we have these points and we want to move
them down randomly. So we need to bring
in a move components. And the motion is
going to be unit Z, and then negative for it to
come down a specific amount. But now let's plug
these points and we see that it moves it
down by the same amount. Now, one of the things
that we need to notice is that the points will probably be flattened because it's going to organize the
information that way. But other than that, the thing that comes to mind
is that we need to know exactly how many points we
have so we can generate the exact number of
points randomly.
3. RANDOM NUMBERS: What I do is I'll
take list length, which will give me the exact number of points that we have here
under the list length. I'll go to quotation marks. Now we can actually
see how many we have. We have 64 points. The reason why that's critical
is that's gonna be one of the inputs for
our random number. But let's go ahead and bring, and move this over. And we're going to
bring in a random. So this is going to generate a random number for
the set of numbers. So this is how many
total number or a value. So you want that would be 64. I can obviously skip this, but this is more for show
you how many points we have. Then seed is going to be
like a randomized option. Then range, we need
to construct that. So I like to use
a struct domain. This will give us a
start and endpoints that we can plug into the range here. So we'll go start at 0, will go 0 less than 3.5000. And we'll copy that
one twice. And use a. It doesn't matter
which one we use, as long as one is
different than the other, then we can actually
see here that we have 64 values and their
random between 0.12.45. The reason why we want
that random number is because here we only have one
value that we plugged in. And this is why it's static. Because if we gonna slider here, it's only one number, one
value that it changes. Now we're going to in
that random number, like to organize it
a little bit here. Sometimes I get a
little carried away. But let me plug in now the, into the motion which is z down. We're going to plug
in the random values. Now this is why I said that the numbers need
to be flattened. This because
degenerate 64 numbers then here it's bringing
them out in sets. But here if we go to flatten, it'll take care of that issue. Now let's disable
the preview on. Actually, no, we
can be right here. As you can see, we've
kind of created some random points moving down and we can change the number of divisions
that we have. For this, we can change the upper and lower number
so we can lower this. We can also make it be the same. This takes care of creating
those first random points. Now we're going to
take those points and we're going to plug it into a component that will create a surface through these points. We're going to go here, double-click and bring
in surface from points. Now there are other components that we could use for this. But I think this one actually
gives us the best result. So we'll take these points and we'll plug them
into the points. For the UK count. We actually have to go down here when we
see the division. We're going to plug this end, but you're going to see that
it's not going to work. Or actually it does work. But it gives us an issue. We have to do a plus one. I use a relay here, bringing a plus one and
that fixes the issue. It's because the number
you have to add one to the account to account
for one of the sides. And that takes care of the
issue with this surface. Now you see we have this undulated wavy thing that we can use as
our base surface to project those
random points onto. Technically there wouldn't
be random points, so it would be the
same as these. But with this, you can
see, let's lower this. There'll be changing how many
subdivisions we have here. Then we can also, under this one, we can change the direction
if we don't like that. And then the seed is going
to be more random points or more on random solutions
that will go to five. And then plug something like that looks good. Now with this,
we're going to use this as our base
surface and so we can basically hide these
points that we don't need. We also have this base plane. You can probably hide that also. Now we can move on to
creating the random generated or not random generated points are going to be in
the same grid points, but then they're gonna
be rejected down to this kind of random
generated surface. And the surface,
What's cool is we can, we don't like that. We can always change it around and see if there's a better one, or just using the
UMD account here. The output is also a match. No, it's an untrimmed surface. What we'll do is
take this random, these points that are
generated on that surface. And we're going to copy it.
4. PROJECT POINTS: Now we're going to copy these two sliders and
plug them into here. An increase account will disable the preview on
all the other ones. And let's increase the upper
limit of our subdivisions. Now we can take
these and project them down onto the surface. So we'll go to reject point, plugging in the points into the point input
and go all the way over here and bringing that
surface into the geometry. And by default it
says 00 negative one, which means it's going
to project it down. So it kinda takes
care of it for us. And the idea now is that
since we have those set of points that we projected
down onto that surface, now we can create a line
segment between those two. These down here would be 0, the end point, and
then the start point. Going to be nice. Since they are set up
as an grafted sets. It actually an x. Each point. From that one down to this one. I'll disable the preview
on the points up here. As you can see now
you've started to see the the shape of the
original surface here. One of the cool things is we can always change this around to get a different solution and to
keep it light with using. Since we have so
many subdivisions and the more
subdivisions we create, it's going to get super heavy. We want to take these
points and we want to create a mesh. So we'll go here to primitive. We can go to Mesh sphere. But if you do have the
polyhedron plug-in installed, you can use the ecosphere, which is the one
that we'll be using. I'll plug in the
points into the plane and the scale will decrease. Do something like 0.8 or less. And of course we can
always take this and do a point attractor or something
like that where we can change the size of all of the
lights and stuff like that. But that's not the
point of this. The point of this one was
to show you how to create this really cool
suspended light system with a base random surface. And then this generated
grid that's projected down. So lastly, for to kinda
end the tutorial, what I'll do is I'll
show you how to create the top frame and how to
connect it to the 0s. So you can have basically
that suspended light system with some kind of structure
to connect it to. What we'll do is go
to the points that were generated up here, which would be these. Construct that grid.
5. FINALIZE AND BAKE: It will do is we take
those points and bring in the Delaunay mesh, which I always have
a hard time saying and I don't know if
I'm saying correctly, but either way the points
will come in grafted. That's when you see
that dashed line. It will flatten the input. This way. It brings them all
in one big list and then calculates the points in
how close they are to each other and generates this. What we want now is go
here to match edges. We can extract the wire frame using this triangulated look. Now if that's not the exact
look that you're going for, there are other things that
we can do to sub-divide it, but I actually think that
that looks pretty cool. So what we'll do is we'll take
this and we'll go to curb. We'll just bring
that into one input. I mean, that's not
really necessary. We can technically just
plug all of that input. Sometimes it's leaner
to do it this way. So I'll plug it all of these and then I'll flatten
the input this way. Everything I'm saying
at once, we have 2601. And so creating a pipe for so many curves would actually
make it really laggy, would have noticed
that makes it not. So laggy would be
using multi pipe sub d. That actually helps a lot
because it makes it all one. And it's really light
where if we make any changes on the
script and we'll see then update pretty quickly. It also looks really
nice and connections. So let's go ahead and
plug that into input. It's obviously way too big here. Let's go to tap round and let's decrease
the size of this. Go here too. I do this every time and it's because he just
kinda works for me, but I'll just show you. So I will go to create two
numbers that are the same, so 1.5000 and make sure to have a lot of decimal points because sometimes I'll have to
go to a low number. I create two of these. I multiply one to the other. The reason why is because
there has to be a proportion between the two for
it to work correctly. From my experience. And this is what I do. I plug this into the strep size. I plugged is into the node
science and End Offset. You're gonna see that it
kinda gets really crazy. So we'll have to
decrease all of these, but we'll just have
to decrease this one. You'll see that
they'll start to work. This is why sometimes
we have to go to a low maximum number, so we have more slider
to work with that. That makes sense. And then we'll do
the same thing here. I'll do the upper limit to two. Depending on whether you want the connection to
be larger or not. That's where you do
this larger one, this one, this is going
to be connection. This is gonna be, some might
say that is because you need to decrease this number mark here will decrease this one. Kind of creates a wireframe
for that entire design. Until let's go ahead and bake it and take a look at
what it looks like here. I'll go to a new layer, call this structure.
Then I'll hit Tab. It creates a new layer
and call this Light. I'll make my structure
layer, my current layer. And then I'll middle
click and then bake. I'll do the same
thing with the light. I'll make that my current layer. Go to the Mesh. Elected middle click, Bake. Now I will disable
the preview here on. Don't draw any
previous geometry. Let's take a look at this.
DCO Graphicstudio
