When I first opened it, I just stared, completely confused.
If you’ve ever looked at a big Grasshopper script, you know what it’s like: the canvas stretches on forever, wires everywhere, logic that seems like alien code. My whole aim was to figure out how these inputs—things like LOA (Length Over All) and Block Coefficient—become a clean, ready-to-use ship.
The script felt like a total Black Box, and I was determined to figure it out.
First Big Discovery: It’s a Recipe, Not a Drawing
The biggest thing that surprised me? Parametric scaling.
At first, I thought changing the Length slider would just stretch the model, but that’s not what happens. The script recalculates everything from scratch. It doesn’t just stretch—it rebuilds the ship with new numbers.
The hull shape isn’t fixed to set dimensions, but to ratios (the coefficients). So when I doubled the LOA, the script automatically scaled the beam, adjusted the volume, and kept the hull shape the same. It instantly creates a whole family of ships, not just one design. Basically, this isn’t a static design—it’s an algorithm for infinite hull variations.
 |
| Screenshot showing the "Overall Dimensions" input sliders, highlighting LOA, Beam, |
The Core of It: Six Steps to Build a Hull
To really get what was happening, I had to stop focusing on each node and instead follow the path the data takes. It turns out, every complex parametric hull script can be broken down into these six steps:
Step 1: Inputs (Setting the Rules)
This is the starting point. The main numbers we choose as naval architects:
- LOA, Beam, Draft: set the size.
- Block Coefficient: controls how full or boxy the underwater hull is.
- Bilge Factor: shapes how rounded the hull corners are.
Step 2: The Math (Naval Architecture in Action)
Here’s where the magic happens. Expression components take our inputs and use hull-optimization formulas to produce precise 3D locations. For example, the Block Coefficient helps the script know exactly how wide the hull should be at every spot.
Step 3: Points (Building the Skeleton)
All that math becomes thousands of X, Y, Z points. Construct Point components drop these dots in 3D space. You don’t see them, but they’re the bones that define everything else.
Step 4: Curves (Drawing the Linesplan)
With the points ready, the script connects them using Interpolate Curve and NURBS Curve components. This is where you get waterlines, buttocks, and sections—the core lines plan of the hull.
 |
| Clear view of the Grasshopper canvas showing the wiring from Construct Point (C.P) to Nurbs Curve components(NURBS) |
Step 5: Surface (Skinning the Shape)
Now, all those curves get blended into a single smooth surface using Loft or Surface from Network of Curves. Suddenly, it actually looks like a hull.
Step 6: Brep (Making It Solid)
Final step: the script joins all the surfaces into a single Brep using Solid Union. A Brep (Boundary Representation) is just the geometric shell that defines the object’s boundary. If it’s closed, you’ve got a watertight solid—ready for hydrostatics and all the calculations you need.
 |
| Screenshot of the final 3D hull in the Rhino viewport, showing the smooth NURBS surface |
Why This Is a Game-Changer
What I realized is that Grasshopper’s real strength isn’t in drawing—it’s in setting up the logic.
If you understand how these steps connect, you can make tools that work way faster and smarter than any hand-drawn method. For anyone starting out in computational design, figuring out this workflow is the difference between just using tools and actually creating your own.
So, if you’re stuck in a messy script, don’t worry. Look past the chaos. Track down the inputs, follow the formulas, and watch as the points build your surface step by step.
You can get the original file I used right here and try following the flow yourself:
Comments
Post a Comment