｡◕‿◕｡ Hey, what's up, Gleb Alexandrov here for
CreativeShrimp.com. Welcome to yet another 3d modeling tutorial. some people
say that Ngons should be avoided at all cost, while others say that this hatred
and phobia of N-sided polygons needs to stop. in this tutorial we'll take an
in-depth look at the common problems with Ngons to raise our 3d modeling
game, so by the end of this video we'll know, are Ngons really that evil? but
first things first, an Ngon is simply a face with more than 4 edges. this in
fact is a shape with 5 edges. a cap of this cylinder is an Ngon too and it
has 32 edges. this shape is an Ngon as well (in fact it's a polygon
with 171 edges). there are modeling methods like boolean operations or
software like computer-aided design or CAD that tend to output Ngon in
large numbers. for example here we see the after-boolean mesh and these
polygons shown in blue are N-sided polygons or Ngons. Ngons seem to have
a bad reputation among 3d modelers, well, that is a divisive topic and people feel
strongly about the issue, some for it and some against it, some people say that
it's better to avoid Ngons altogether while others say that hatred and phobia
for Ngons needs to stop. in my opinion there's definitely a certain bias
towards the no Ngons modeling strategy, so let's take a look at what is
considered to be the disadvantages of using Ngons in 3d modeling, then try to
defend the opposite point of view. first we're going to outline the common
problems, such as rendering issues, limited to use of subdivision surfaces,
awful-looking wireframe and so on very briefly, then play the devil's advocate
and take a much deeper look. Ngons are associated with degraded
surfaces that are supposed to be flat, but the shading or the curvature
suggests that they aren't and it looks strange. if all vertices of an Ngon
don't lie in the same plane it can look really weird, because it isn't clear how
to display a shape before it gets passed to render engine. for example if we will
be moving just one vertex around, the triangulation of the entire shape
will keep changing. we'll talk about triangulation and what it does to the
mesh a bit later on so keep watching. Ngons can be the cause of shading issues
that ruin otherwise great boolean operations for aspiring 3d modelers. it's
not easy to get over the initial frustration of seeing an after-boolean
mesh. why does this look so strange? what's wrong with it? it must be Ngons! in addition to that shading issues associated with Ngons tarnish the
boolean operations based workflow and we become suspicious of the entire workflow
for that matter. Ngons are claimed to not only look glitchy but also result in
all sorts of mesh editing problems: they disrupt the edge flow of your model and
make standard modeling operations like extrusion and so on less effective,
because we can't use subdivision surfaces. unlike quads or triangles, Ngons subdivide poorly in many cases so it's a potential showstopper for
workflows that need subdivision surfaces for whatever purposes, automotive
design for example. chaotic looking topology is another reason why
Ngons are frowned upon, especially if we talk about triangulated version,
which we can see by the way by enabling that triangulate modifier (we'll talk
about this in more detail later on) Ngons often lead to animation
or more precisely, deformation problems topology for animation relies on proper
edge flow and those angles are a big no-no if the mesh is supposed to be bent
or deformed in any other way. in other words it's a really serious
consideration of using all quad topology. ultimately Ngons behave in
an unpredictable way when the mesh is imported or exported to game engines or
to other modelling and sculpting applications, because some applications
do not handle Ngons well and there are always no guarantees about how how
exactly Ngons will be interpreted because there are no standards. for
example here we see the mesh with Ngons exported from Blender and taken into
ZBrush and it's turned out to be shredded like that.
so you're probably thinking: wow Ngons look really evil! but are Ngons really
that evil? before moving on let's get down to basics and talk about
triangulation. on rendering every Ngon is subdivided into triangles or
triangulated and so our quads. quads are also split into triangles. so technically
every quad is made of two triangles and triangulation can be very important and
here's why. let's take a look at this plane. let's
push the vertices around and then change the triangulation method, duplicate the
plane to show an otherwise identical plane side by side, so here I used the
fixed method as a method of triangulating the quads, and for the duplicated mesh
I used a different method of triangulation. and as you can see,
depending on how the planes are triangulated causes quite different
profiles. [exploding brains sound] mind blown! just let it sink in... so on rendering every Ngon gets split
into triangles, but how exactly? for example there are 5 possibilities to
split a pentagon into triangles and it gets even more complicated in case of
higher ordered Ngons. so Ngon is always an implicit surface, and different
types of triangulation produce different looking results, some better than others.
that's a crucial thing to understand because what we perceive as an immanent
problem of Ngons (for example bad shading) can partly be
attributed to a non optimal triangulation among other things. now
let's go ahead and take a closer look at the disadvantages of using Ngons. so
what do we actually mean when we say a non optimal triangulation and what is an
optimal triangulation then? in Blender we have two methods of triangulation:
the first one is clip it's used by default, is the fastest one and as you
can see it often produces a pretty weird result. the second method is called
beauty and it arranges the new triangles evenly while clip splits the polygons
with so-called 'ear clipping algorithm' that generally performs a little bit
faster but produces a noticeably worse set of triangles. so just by changing the
triangulation method get a more optimal triangulation and as
a result much better shading. the next rendering / shading issue is related to
non planar surfaces. if a surface should be perfectly flat by design, let's just
make sure it is flat, for example by using the flatten command or by scaling
the problematic Ngon on the local y axis (in this particular case) and giving
it a scale factor of zero. that effectively makes it flat. and by the way
perfectly flat surfaces with sharp hard surface connections are an ideal case
for using Ngons as they always shade in a proper way. curved surfaces is a
different story, we will talk about it shortly. but what
about the smooth shading errors in relation to Ngons? for example if we add
the bevel modifier here the smooth shading algorithm will go haywire. it
becomes clear what's going on under the hood if we enable triangulation. so we
have a set of long thin triangles that mess with the shading and with normals
and probably the easiest solution in this case would be to harden normals in
the bevel modifier, but more general method of resolving such errors in
relation to Ngons would be controlling smooth shading by marking edges sharp.
doing it means telling 3d modelling application to stop trying to smooth out
the connection between two surfaces based on their normals. taking control of
smoothing or marking edges sharp manually or paying attention to auto
smooth angle turns out to be very liberating in terms of what modeling
styles can be used. together with bevel modifier it opens up the entire domain
of boolean operations, because now we can sharpen some edges and still get a
gradual transition from one surface to the other, with the help of the bevel
modifier. like for example can be seen here. despite some of this flaws in
geometry that can be easily fixed, bevel modifier gives us a nice all quads bevel
around our Ngons and this workaround unleashes enormous creative potential. it
turns out that angles are not that big of a deal if all the right boxes can be
ticked: beveled edges, no smoothing artifacts and so on.
I should say it's not immediately obvious when you start learning and
unpacking boolean operations, but once you get your head around typical
topology issues related to boolean operations and how Ngons fit into this
grand scheme of things, this entire workflow becomes much much more
attractive. ok another source of rendering glitches can be a sloppy
topology in general. like not having enough polygons to support some mesh
editing operations or having an uneven distribution of polygons. yes for example
this model has Ngons and no, the reason for incorrect shading is not having
enough geometry to work with in first place. with a few more knife cuts or
subdivisions the resulting shading becomes more acceptable as there are
less triangles that are super long and thin
after triangulation. as a rule of thumb an even distribution of polygons and
having enough polygons is good, because it helps to contain most of the issues
related to Ngons, especially to overly large badly triangulated Ngons. so
that's definitely something to keep in mind when dealing with shading issues of
any kind. and another defining characteristic of all kinds of bad
topology issues is poles. so what these poles have to do with Ngons? to explain that let's revisit topology basics once again. a pole is
when 3, 5 or more edges converge at a single vertex but not 4 because
when 4 edges converge at a single vertex its simply a grid, a normal quad
based topology. in other words a pole we should be mindful of is a vertex that
doesn't have 4 edges connected to it and isn't along the boundary of the mesh.
there are many sinister things associated with poles, but before we talk
about it, the benefit of these poles are that they are the points where the
direction of face loops can change, so in many cases they are very useful, but
alright, let's talk about the dark side of poles. on this match there are two
types of the most common poles: in red the 5 pole and in blue the 3 pole.
so what's the big deal with poles? this is where our edgeloop selection or
creation gets terminated. this behavior is often attributed to Ngons and as
we can see is rather related to poles because for example these polygons are
perfectly quad and yet we experience all kinds of issues with edge loops. the
second issue is that no matter how much we subdivide the mesh our poles won't
change. let's quickly set up the example. I'm gonna add the subdivision
surface modifier, crank up the number of view subdivisions and here they are, we
can see two poles causing weird pinching to the geometry no matter how much we
subdivide it. and these areas can shade not as smoothly and predictably as a
uniformly grid like mesh with no poles. like this match should be perfectly
smooth, but because of the underlying topology with [mm-hmm] with poles we get
this weird artifact striking across the mesh. the other case in which we may want
to work with quadrilaterals or quads is displacement. so as we've already noticed,
poles lead to pinching and other problems with geometry and displacement
is one of these cases where it's very hard to hide these artifacts. the left
mesh is composed of quads that are arranged in a uniform manner, say, like a
grid, while the right mesh has this weird pole over here. and after we displace the
mesh it just manifests itself. so probably one of the reason why Ngons and
triangles get so much criticism is because that's where we are guaranteeing
the creation of a pole and therefore issues of shading under certain
deformation and where the selection of an edge loop or creation of an edge loop
will terminate. it's like a chain reaction of a weird stuff. so if like in
Scooby-doo we were to unmask the real villain, we would finally locate an
unmask the Ngon and find a three or five pole or more underneath, complaining
they will have ruined the shading of our mesh and would have gotten away with it
too! ಠ~ಠ ok this can be a tricky subject because most poles are created usually
to turn the flow of faces and help reduce unnecessary edges in
places they aren't contributing largely to the silhouette, so it's not all bad to
have those poles in, of course, what I want to say is that there are disadvantages
to them, if you intend to then rely on subdivision modifier to flawlessly
smooth them out. yeah. the next potential reason of not using Ngons is broken
subdivision surfaces. because subdivision algorithms like Catmull Clark used in
Blender, 3ds Max, ZBrush and other 3d modeling apps require strict rules for
mesh topology, that means having good edge flow and mostly quads and having no
poles, Ngons don't work well with subdivision, I would say mainly because
of poles that lead to pinching and other modeling issues from hell®. that's a shame
because subdivision surfaces are great for approximating curved meshes, so not
being able to use them from start to end makes it a lot harder to model smooth
flowing surfaces. in practice that means that after we start carving boolean
shapes and all that stuff the only way to reestablish good edge
flow would be retopology. I think it's a decent trade-off for using boolean
operations which are amazing for mechanical design though. so for example
after applying all boolean operations we can select all faces with more than 4
vertices and that means we will select all Ngons so as we see, no chance this
mesh will subdivide in a proper way because pretty much all areas where the
boolean operations took place are full of Ngons, so to get to the stage where
the geometry can be deformed in a nice way,
redrawing topology would be required I would say. on the other hand some shapes
are easier modeled without subdivision and without all quads for that matter.
the curved or beveled edges that we lose by waving the subsurf modifier can be
recreated with the bevel modifier instead. it works perfectly fine with
Ngons and helps us to achieve these sexy bevels with proper smooth shading.
as a quick example I have setup this boolean operations based mesh over there
and because we introduced some Ngons into the mesh, we can no longer use
subdivision surface modifier. but what we can do instead is just
substitute it with the bevel modifier. what I gonna do is just limit the method
by angle, increase the number of segments and the width, the all-quads bevel will
help us to achieve the correct shading and we should be good to go. in that
sense Ngons are much more appropriate for hard surface modeling,
rather than automotive, organic or god forbid, character modeling.
conversely quadrilaterals could be better suited for character modeling and
so on. of course that's a little bit of an oversimplification, but it describes
the situation pretty well, I guess. the next argument against Ngons is
that the wireframe ends up looking ugly that's definitely arguable, in fact in
many cases Ngons make for more elegant wireframe, especially if we don't
show a triangulated version. by collapsing the edges that don't follow
the contours of the surface we make it more, not less readable in my opinion. of
course the same principle can be applied to quad-based geometry. in Blender we
have the wireframe slider and if we move it all the way to the left,
the redundant polygons that don't contribute to the overall shape of the
mesh will be hidden. in addition to that, one notable advantage of using Ngons is
having less polygons overall. as a rule of thumb, boolean meshes and other kinds
of meshes with Ngons require less polygons to describe the surface area
than the mesh is originated from for example subdivision surfaces. that may or
may not be a big of a deal, it all depends on what kind of model are you
working on, but in some cases it can make a difference.
this robot for example is not shy of Ngons and it is just below 4 million
triangles (which is pretty cool for this amount of bells and whistles). the next
potential showstopper for using Ngons in your meshes is deformation. it could be
a pretty serious disadvantage indeed. Ngons are better be left static and if
you know that the model is going to be deformed, a clean topology is a must have.
although with enough geometry and more or less uniform polygonal density meshes
with Ngons can bend reasonably well. so as a quick demo, this
mesh is going to survive some deformation, so I'm giving it a little
bit of subdivision before the boolean modifiers are applied. so hopefully all
the Ngons should be pretty much contained by now. this means that's no
serious triangulation issues will happen (fingers crossed). again following good
modeling practices like having enough polygons is always helpful no matter
whether it's four-sided polygons or n sided polygons and as we've said before,
adding a quad bevel around the sharp edges won't hurt as well. and finally we
have the interoperability issue to talk about. if a model has Ngons sadly there
are no guarantees that these Ngons will be interpreted as expected because
oftentimes 3d applications make arbitrary decisions on how Ngons should
be triangulated. there are no standards. to demonstrate it I'm going to give it a
spin in different applications. so I'm exporting the mesh with Ngons in the
.obj format. of course exported it without triangulation. so the first one is SculptGL, the web based sculpting software which I like. as we can see, our Ngon got
triangulated in a pretty strange way, the thin and long triangle strips, something
like that, and we can see a broken silhouette. next I'm going to import this
same mesh in Sketchfab and see how it treats our Ngon. and immediately it's
clear that Sketchfab triangulated it just like the 'beauty' algorithm in
Blender does. the silhouette seems to be correct and everything looks pretty good.
and the third application is gonna be ZBrush and no matter what checkbox is
ticked on import, the result in mesh will look pretty weird. ZBrush is awesome
piece of software, but it doesn't treat non triangulated Ngons very well. so
to conclude, once ready to export it's worth double-checking what triangulation
algorithm has been used. so are Ngons really that evil? the
key takeaway is that Ngons are neither universally good or bad, it depends on
what modeling goal you want to achieve. in conclusion there are numerous
disadvantages of using Ngons, but interestingly some of their
disadvantages are continuation of their merits and can be ignored in favor of 3d
modeling possibilities to get in exchange. and they do have pros such as
less polygons overall, boolean operations unlocked, bevel modifier, quick concepting,
stuff like that. I would say the strongest arguments against Ngons are
bad deformation and interoperability, these are just bad things. also I've
heard that Ngons make it really tough to get good to UV maps and probably
physics engine operations on Ngons could be a little bit problematic. in my
opinion the other issues discussed in this video can be mitigated or even
framed positively. before we call it a day, here are a few practical takeaways.
if it's curved and going to be deformed, use quads. if it's flat and not going to
be deformed, feel free to use Ngons. it's a little bit more complicated than
that, but it's a good thing to remember and usually the right progression is quads
then Ngons so for example sub D modeling tools like subdivision surface
modifier and so on followed by boolean operations and
everything else that produces Ngons. when you stumble across any kind of
shading issues, pay attention to the auto smooth shading settings. for
example the auto smooth angle, this is the maximum angle between the surfaces
which will be considered to be smooth. that appears to be a quick fix to many
Ngon-related issues. for that matter there are many other things that affect
the look of the smooth shading and normals for example the harden normals
feature of the bevel modifier and of course there is a good old 'mark edges
sharp' method. what we need to do is just select a bunch of polygons that we want
to be sharp and mark them as sharp and to see the effect
we just have to enable the auto smooth these things usually allow to work with
the Ngons in a less problematic way. if it's going to be exported to game engine
or to application that doesn't handle Ngons well, triangulate it first to reduce
the chances of incorrect triangulation. watch out for N-poles especially 5
poles, these are the real villains. they lead to geometry pinching and all kinds
of different issues that cannot be easily fixed.
and no matter engines or quads, having enough polygons to allow deformation and
an even distribution of polygons for that matter is always a good practice.
lastly, when working with Ngons, retopology may be required. as someone said
on the internet (and I love the phrasing) think of it (of Ngons) as a higher level
wrapper around your basic triangular mesh. in other words, don't be afraid to
incorporate Ngons into your modeling tool set. you can always retopologize
it later. embracing polygons with more than 4 edges will open up a wonderful
world of boolean operations for you, especially if you're interested in hard
surface modeling. if not for production, then at least for concepting. this
realization was one of the key things that allowed us to put together Hard
Surface Modeling course for Blender. alright, enough, that was Gleb Alexandrov for CreativeShrimp.com, feel free to leave your comment below, do you like
Ngons or not? do you use it in your daily 3d modelling practice? ok cheers! (｡◕‿‿◕｡)
