@jdellinger98 Overall you have the right idea: using instancing, mirroring and other modifiers will reduce the workload and speed up the modeling process. Try to maintain a consistent shape transition when working with intersecting geometry on curved surfaces.
Using a single base model for the high poly and low poly.
It is possible to have a single base mesh that can be build up into a high poly cage mesh then quickly optimized down into an in-game low poly model. When taking this approach it's going to be important to consider factors like view distance, texture layout / size, damage states and in-game poly count limitations before committing to any modeling. All of these factors will help set a technical target for the low poly model and these restrictions will help inform how dense the base model should be.
This approach probably makes the most sense if the flutes on the column actually need to be in the low poly model. In cases like this, where the high poly and low poly model need to share a lot of surface details, this approach makes sense and can be very efficient. However, there's also a lot of situations where the in-game model doesn't need to be this detailed and in those cases this approach doesn't make sense because it would add artificial restrictions and unnecessary complexity to the modeling process.
Avoiding deformation around the perimeter of flutes on a curved surface.
It's likely (based on the description and images provided) that the undesired deformation of the cylinder around the fluted details is caused by too much manual mesh manipulation and the addition of excess geometry between the existing edge segments that make up the wall of the cylinder's shape. With subdivision modeling and curved shapes it's important to maintain the consistency of the cylinder's shape while also ensuring that the perimeter of intersecting geometry remains concentric with the walls of the underlying cylinder.
In general: It's important to match the segment counts of intersecting shape geometry whenever possible and it's considered best practice to maintain a relatively consistent segment spacing around the walls of cylindrical shapes. When matching up the segments of intersecting features it's also considered best practice to use the existing geometry of adjacent shapes as support by placing the intersecting geometry between existing edge segments. The last few pages has a number of good discussions on how this can be done.
The big thing is to keep all of the new geometry in line with the curvature of the cylinder walls.
Here's an example of what this could look like: Using a bit less geometry will make the mesh more efficient and potentially easier to work with. It's also worth noting that the intersecting geometry on the curved portion of the flutes lines up with the existing geometry of the cylinder wall segments. A flat walled flute wouldn't be an impossibility but rounded profiles seems to be more common for Ionic columns. Depending on how accurate the model needs to be it may be worth researching the exact flute profile for a specific structure or period.
Using triangles and n-gons.
Provided the mesh subdivides cleanly, without any major smoothing artifacts and barring any legitimate technical limitation, it's acceptable to use triangles and n-gons in a subdivision cage mesh. Whether or not this is acceptable depends entirely on the result and the workflow. It can be very easy to waste time and resources perfecting things that might not really matter in the long run.
The triangle on the flat area inside the volute at the top of the capital isn't causing any major smoothing issues so it should be fine. If the end goal of the project is to create a game ready asset then focus on what players are going to see. For most projects, it's extremely unlikely that players will see or care about high poly wire frames.
Here's a similar example that has several n-gons and a significant number of triangles. Most of the sloppy topology is confined to either the flat areas or minor shape transitions so minor smoothing artifacts aren't blatantly obvious. The base mesh will become all quads when it's subdivided and if it's going into ZBrush for a sculpting pass then automated quad re-meshing will provide a clean output. Either way: once everything is baked down and additional high frequency normal details are added any minor smoothing artifacts won't be visible.
Here's another example that shows how a simplified base mesh (with a few n-gons and triangles) can be built up into a high poly model by adding support loops with a bevel / chamfer modifiers. This makes it easier to adjust the edge width and add additional details before sending the high poly out for sculpting / baking. For the low poly the base mesh could be unwrapped and used as is or further optimized to meet any technical requirements.
This circles back to the opening discussion about figuring out what the
players will be looking at and how detailed something needs to be. Often
it doesn't make a lot of sense to spend extra time on something that
doesn't directly improve the visual quality of the model or directly
impact the story / game play. Focus on results and improving the visual quality of what the player will see up close or directly interact with.
To recap:
Evaluate how a model will be used and what the technical requirements
are before jumping in and committing a bunch of time to creating an
overly complex model. Minor smoothing artifacts may not be be visible in
the final bakes or when normal texture details are added.
When working with curved topology try to maintain a
relatively consistent segment spacing, match the segments of
intersecting geometry whenever possible and use existing geometry as
support loops.
If a subdivision mesh subdivides cleanly, without any major smoothing
artifacts and provided there's no technical limitations, it's fine to
have triangles and n-gons in a base / cage mesh.
@Welcj When it comes to game art and high poly models for baking: there's few legitimate technical reason to extend all of the edge loops across the flat areas and into adjacent shapes. Most of the time it will just create unnecessary complexity that will make it harder to edit the mesh in the future.
In general: it's acceptable to have a few extra edge loops running across the flats, provided they don't over-complicate the mesh or interfere with the topology of adjacent shapes. It's also acceptable to simplify the mesh by removing extra edge loops wherever they cross over flat areas, provided doing so doesn't generate visible smoothing artifacts.
Manually cutting in all of those loops across the entire mesh isn't advisable. Flat surfaces (with support loops around the shape perimeters)
are largely unaffected by topology changes and can be used as a place to
terminate excess edge loops. This thread has a number of good examples
of how this can be done so it's worth taking some time to skim through
it and find similar examples.
When creating high poly models:
If the object has multiple parts then consider modeling the parts separately.
If the object is a single part and there isn't a requirement for a continuous mesh then consider floating geometry.
If there are technical requirements for a continuous or watertight mesh then consider using the flat areas to terminate excess edge loops.
Which approach makes the most sense depends on what the model will be used for and what the specific technical requirements are.
As an example: some stock 3D certification programs have strict technical requirements to cover edge cases and this can mean that running extraneous edge loops across the entire mesh may be the only way to meet those requirements. Contrast this with game art where the same practice would generally be considered unnecessary at best and an egregious waste of time at worst. If the mesh is easy to work with and subdivides cleanly, without causing any major artifacts, then it should be passable.
Smoothing and shading errors on flat and curved surfaces:
There's been some discussion (in another thread) about resolving smoothing and shading errors on shapes similar to what's shown below. Since individual question threads can be difficult to locate in a search and will eventually be lost in the shuffle it makes sense to post this information here.
Here's some examples of subdivision smoothing and smooth shading errors that appear around details on flat and curved surfaces. Shaded previews in the top row and underlying geometry in the bottom row. Left to right are flat / curved surfaces in the first two columns and subdivision / poly models in the last two columns.
Undesired stretching and pinching are subdivision smoothing errors that
indicate a lack of support loops around shapes and topology issues
around shape transitions. Strong gradations around corners and scalene
triangles are a type of smooth shading error that indicates a lack of
smoothing splits around the adjacent shapes.
This thread has a lot of detailed examples that cover subdivision topology so the following will only cover the basics. More detailed discussions about these topics can be found directly above this post and a few pages back.
Flat surfaces generally only need support loops around shape intersections, shape transitions and the perimeter profile. Adding support loops around the shape transition where the rectangular pocket intersects the flat surface and across the inside of the space between the rounded ends of the pocket will resolve the smoothing issues when subdivision is applied.
Curved surfaces generally require a relatively consistent segment spacing and it's generally considered best practice to use the existing curve geometry as support loops by placing the intersecting geometry between curve segments and match the segments of both the intersecting and existing geometry whenever possible.
The important thing is to match the vertices along the curved areas of the intersecting geometry as closely as possible to the perpendicular edges that make up the wall of the curved surfaces on the underlying geometry.
This matching doesn't have to be perfect, it just needs to be close and any positional difference between the two can be taken up by the space between the outer support loops formed by the underlying geometry and the inner shape profile of the intersecting geometry.
*It's worth noting that these examples contain some excess edge loops that run off the curved surfaces and onto the flat areas. In most cases there's little benefit to carrying these loops across the entire mesh so just dissolve them off the flat, up to the outside support loop of the shape transitions.
Strong gradation in the low poly smooth shading can be resolved by using hard edges (smoothing groups) around shape intersections and shape profiles. Low poly flat surfaces can be ruthlessly optimized unless doing so would introduce undesired UV splits or long thin triangles.
Low poly curved surfaces can be optimized but it should be a balance between consistent segment sizes based on view distance, desired smoothing behavior and reasonable UV splits. Going too far one way or the other and only focusing on optimizing one element of a curved surface can have severe negative impacts on the overall visual result and performance of the model.
Some aspects of low poly optimization are contextual and depend on technical requirements and project goals and all of the examples here are middle of the road so mileage may vary. Balancing efficiency with resilience can be a good starting point.
@anotherdoseofcorey Translating approximate 2D shapes to a reasonably accurate 3D volume can be challenging so it's best practice to start off by blocking out the basic shapes to figure out how it all fits together.
Below are three possible options for creating the recessed area around the small cylinder. The first example produces a similar outer profile on the tapered area but won't be workable if it's moved up and onto the parallel sides of the large cylinder. The second example produces a similar outer profile on the parallel and tapered areas but doesn't quite match the inner taper / round over that's suggested by the shading in the concept. The third example is similar to the second example but has a tapered shape and has been rotated so the smaller cylinder clears the outer profile where the shape intersects the larger cylinder.
These results suggest that the intersecting shape is an oval, projected from above at an angle that's close to the angle of the taper on the large cylinder. The shading of the recessed area in the 2D illustration also suggest that the walls of the intersecting shape are tapered and the bottom of the recessed area is rounded.
From there it's the same as cutting in any other shape on a curved surface: place the intersecting geometry between the existing edges of the
cylinder wall, match the segment counts on both shapes and use the
existing geometry as support loops.
A more detailed discussions of this process can be found a couple of posts up and a few pages back.
This thread is a great resource, with a lot of examples, so it's worth taking the time to skim through it and look at how other artists have created similar shapes.
Support loops can be added after the basic shapes are established. To reduce the amount of work required the cut out can be rotated into place and mirrored. Here's a quick example of what this process could look like.
Details can be added with inset operations and since the tapered section in the first example was left long it can be trimmed down to size. The support loops around the taper transition on the large cylinder generate a few triangles inside of the recessed area but they don't cause any major smoothing issues and this area won't be seen so it's passable.
There's some stray geometry in the low poly model: mostly zero area faces that are connected to adjacent vertices. Moving the inner edges of the transverse rail slots revealed some of this stray geometry and it looks like it may be left over from previous modeling operations. It's also worth mentioning that having too many long, thin triangles in fan shapes can be less than
ideal and have a negative impact on baking and rendering performance.
Dissolving the excess geometry along the inside walls of the longitudinal slot and re-triangulating the mesh resolved all of the major issues and improved the triangulation. Double check the UV layout after cleaning up the geometry in case anything shifted and the unwrap needs to be adjusted.
There's also a significant amount of micro triangles along the outside edge of the rail profile and although this is an accurate representation of the object's actual shape it may not be worth the resources to represent such a minor detail in the low poly model. Merging down this excess geometry and relying on the normal map to add the illusion of this minor shape and depth change may be a better strategy.
@MKO It's likely the current smoothing artifacts are caused by a combination of factors: extruding directly off of the existing cylinder edge segments and the extra edge loops that run down into the corners.
Before trying to resolve the issue there's a few things that are worth considering:
Will the object ever be viewed this closely?
Will the object ever be viewed from this angle?
Will the smoothing artifact be visible when the grainy plastic texture is applied?
If the answers to any of these questions is no then it's probably not worth the time trying to resolve such a minor smoothing artifact. If any answer is yes then it's still worth considering how sharp the corners need to be. Depending on the texture size and view distance the benefit of using such sharp edges may be negligible at best. Using slightly softer edges tends to increase shape readability and can improve normal map performance when textures MIP down.
Here's a comparison that shows how the visible difference in corner sharpness tends to decrease as distance increases. It's also worth noting that increasing the depth of the groove around the features increases the contrast. At longer distances this increased contrast around the shapes can have a larger impact on the perceived sharpness than actually sharpening the corners.
A few post above (and a few pages back) there's some detailed discussions about how to minimize smoothing artifacts when adding shape intersections to curved surfaces. Definitely worth taking the time to read through that for a more detailed explanation.
The basic idea is to use the existing edges as support loops by placing the intersecting shape between the edge segments that make up the cylinder wall. From there it should be as simple as adding a few basic support loops and reducing the amount of superfluous geometry that runs through the shapes. If the corners need to be sharpened up it's possible to add support loops on either side of the corners and just live with the resulting n-gon. A large part of subdivision modeling is about balancing accuracy and efficiency. It's just not worth chasing perfection on such a minor surface discrepancy unless the feature is going to be a focal point that fills the entire screen.
Here's an example of what this could look like on a mesh with a similar segment count. It's certainly possible to do this with a lot less geometry but the basic principles are the same. All of the examples here are demonstrated on a flush rectangular feature with a groove around it (since it's harder to hide smoothing artifacts) but this will also work on a raised rectangular boss or a sunken rectangular pocket.
To recap:
Research solutions to similar problems, make some test samples and see if that resolves the issue.
Take the time to plan out the topology and match the segments of adjacent shapes during the block out.
Use the existing edges of curved surfaces as support loops and place intersecting geometry between them.
@DiamondDog A couple of post above there's a few discussions about blocking out
shapes, matching segments and creating base geometry that's suitable for
subdivision or re-meshing. Even though these aren't the exact same shapes it's the same basic principles so it's something that takes a bit of work to figure out how to apply existing information to a specific shape. Definitely take some time to skim through the pages and look for similar shapes.
That said: extruding off the existing grid is fine for basic shapes but with complex shape intersections (like that brass deflector) there's just too much going on for it to work well. Instead take the time to develop each shape independently, rotate them into position and merge them together. Blocking out the shapes, using Booleans to keep parts separate and
saving incremental versions before making destructive edits will make
the whole process lot easier if anything goes wrong.
Here's one way to approach the basic shape of the brass deflector: Start with the basic primitive shape, rotate it to match the reference, scale the peak down until it matches the reference, round over the top edges, round over the peak and make any final adjustments. Once all of the features match the references the shape can be added to the base model with a Boolean operation.
Here's an example of how extruding shape profiles from existing geometry can be combined with Boolean operations to quickly and accurately block out complex shapes. Start with features that have known dimensions and use those to scale the rest of the mesh. One big advantage to creating shapes separately is any adjustments to those parts won't require re-building the entire mesh.
To recap:
Block out the basic shapes for scale and create more complex shapes independently before joining them to the base mesh.
Research existing solutions for similar topology and make samples to see if they solve any issues that come up while modeling.
Maintain some kind of incremental history of changes to the shapes in case a part needs rework.
Splitting and straightening the UV islands to increase the overall texture density makes sense in theory but in practice it's a bit more complicated than that since there's multiple factors to consider.
In the overall scheme of things a single road wheel is a very small part of a tank and it's unlikely that every part of every road wheel would have it's own unique UV islands, much less it's own unique texture set. The reality is that having more UV islands requires more padding which in turn either reduces the overall texture density by taking up extra space or it reduces the overall efficiency by requiring the use of additional texture sheets.
It's common practice to either pack all of the running gear
together or to pack it into the extra space around the hull and turret
sheets. So, at a minimum, it's much more efficient to reuse the same geometry and UV islands for as much of the running gear as possible. Reducing the number of unique road wheels and reducing the number of UV splits in each road wheel will also help increase the texture density since space that would otherwise be wasted on padding can be used on the single reusable UV layout. If the UVs need to support camouflage patterning then the face of each road wheel can have it's own unique UV island while the rest of the road wheel can reuse the shared UV layout.
Here's a comparison of a few different UV unwrapping and packing strategies. The overall texture density (compared with the same texture size) is largely the same but it's worth noting the differences in usable UV space and the amount of UV distortion. Starting from the left the efficiency of the used area is: 39.84%, 38.24%, 37.87%, 36.8%.
Based on these results, having fewer UV splits and using fewer UV islands allowed the individual UV islands to be slightly larger and the packing was also more efficient since it left additional space for other items. Since the overall texture density is roughly the same the first UV layout in the example below would have more room for other parts or it would fit into less space on an existing UV layout.
The UV splits for the second and forth examples are identical and the only difference is the packing algorithm used to generate the second example is able to nest UV islands inside of each other. This is something the defualt UV packer in Blender cannot do so it's definitely worth investing a good UV packing add-on.
When it comes to baking there's a few things to consider: hard edges will reduce the gradation of the normal bakes but they will also increase the number of unique UV islands which can reduce the overall texture density through additional padding space. Straightening curved UV strips will generally increase the texture density by making it easier to pack things closer together but this extreme deformation of the UV s can introduce distortion and other artifacts. These strategies are not mutually exclusive so it doesn't have to be an all or nothing approach. There's an acceptable amount of normal gradation and there's an acceptable amount of texture distortion. It's important to run test bakes and figure out where the best balance is between UV efficiency and baking quality.
Here's an example of two different approaches to balancing these elements:
The low poly model in the top row has hard 90° shape transitions, matched with hard edges and UV splits and the UV layout has both straightened strips and nested circles. There's very little gradation or distortion in the normal map but the UV layout takes up most of the texture space.
The low poly model in the bottom row has hard 90° shape transitions (with hard edges and UV splits) around the outside faces and uses softer tapered transitions on the inside corners. There's some gradation and very little distortion in the normal map but the UV layout only takes up about two thirds of the texture space. The placement of the edge splits compliments the UV seams and the result could be further improved by using weighted normals but the point was to demonstrate that even in a worse case scenario the gradation doesn't render the result completely unusable.
What makes sense comes down to the project goals and to what comes out of the baking tests. It's really important to take the time to run some unwrapping, packing and baking samples to get a feel for what's going to make the most sense for balancing the quality and efficiency.
Here's a few examples how other professional artists have unwrapped the running gear on their tank models:
@LilacGear Welcome to polycount. A few post above there's a couple of discussions about adding or subtracting shapes from cylinders and curved surfaces and back on page 168 there's a little write up that covers working with a similar shapes on a curved surface. The principles covered in these discussions are the same that you'll want to apply to this shape.
Here's a couple examples of how this could be done. Start off by blocking out the shapes and adjusting the number of segments on the cylinder so there's room for the support loops to end on the existing edge segments on the cylinder walls. From there it's a simple matter of adding the necessary support loops and continuing the geometry on the inside of the angled cut out.
The corners can be sharpened by:
Sliding the edge segments closer to the center of the corners.
Adding additional support loops to the inside of the corner and merging them down to the outside vert in the corner's support loop.
Increasing the number of segments that make up the walls of the cylinder.
No need to over complicate the mesh though. As long as the additional geometry remains relatively consistent and parallel to the face that makes up the edge segment there shouldn't be any major smoothing issues.
Which approach and how much geometry is required will depend on what the model will be used for and how closely it will be viewed. There's more information on this topic in the last couple of pages so it's definitely worth skimming through and reading some of the other post here.
To recap:
Search for existing solutions to similar problems and see if they can help resolve the issues with your shape.
Block out the major forms, adjust the segment counts of adjacent shapes so the existing geometry can be used as support loops.
Leave room for support loops that run across curved shapes by placing intersecting geometry between the edge segments.
@DiamondDog The answer is it depends. Is there a workflow specific technical limitation or requirement for all quad grid topology?
If this type of topology isn't a hard technical requirement then the answer is: Yes, there are more efficient topology layouts and modeling strategies. Leaving extra geometry (that's a byproduct of modeling with automated tools) in a working mesh is one thing but manually adding in all of that extra geometry is something that should be avoided. Flat areas are arguably the lest effected by topology changes. There's minimal benefit to extending edge loops across flats and in most cases this will only complicate things and slow down any edits that need to be made in the future.
If this is a low poly mesh that needs to be cleaned up and optimized then a quick way to do this is to run a limited dissolve, triangulate the mesh and covert the triangles to quads. It's fine to leave the mesh messy until all of the shapes are finalized but there can also be some advantages to periodically cleaning sections of the mesh with a limited dissolve. Unless there's a specific shading or normal baking error then it's best to simplify the low poly mesh as much as possible, while still maintaining the overall shapes and desired smoothness.
If this is a high poly cage mesh that won't need further editing then it might be fine the way it is. However, if this is still a work in progress or if this needs to be sent to another artist then it would probably be best to selectively dissolve some of the excess edges. An important concept behind subdivision modeling is being able to control complex shapes and smoothing behavior with a minimal amount of geometry.
Here's a comparison of a similar shape with different topology layouts. The column on the left is the working mesh topology. The column in the middle is the final mesh topology and the column on the right is a shaded subdivision preview.
The first row is a low poly model that has a very simple and loosely organized working topology. To maintain consistency between applications the mesh shading is controlled by hard edges and the final mesh is triangulated before it's exported.
The second row is a high poly model that has a loose grid topology layout and the support loops are added to the working topology with a modifier that's controlled by edge weights. Support loops and working topology can be adjusted with minimal effort until the modifier is applied. Triangles and n-gons are kept within the flat areas and have a minimal impact on the mesh when subdivision is applied.
The third row is a high poly model that has support loops placed in the working topology. This provides direct control over the supporting geometry but also increases the complexity and amount of effort required to make any major changes to the shapes. Triangles and n-gons on the flat areas of the mesh subdivide without causing any major smoothing artifacts.
A great resource for learning about different modeling and topology strategies is the "How do I model this?" thread in the technical talk section. Here's a link to a couple of recent discussions about topology layouts, triangles, n-gons and quad grids in that thread:
@Yogifi There's a lot to unpack but the answer to most of these questions is: it often depends.
There's a significant amount of overlap between poly modeling and
subdivision modeling but they are still distinct processes that require
slightly different approaches. What's "right" or "best" depends entirely on how a
model will be used and what the limitations are. As an example: the requirements for a
VFX model that will be used in a close up in a feature film will be
quite different from the requirements for a background prop in a game. This is something that Arrimus mentions briefly at several points in his video.
One of the major issues with trying to extrapolate some kind of perfect rule set from general technical overviews is that, without any context to guide why and when something should be done, it becomes very attractive to try and use relatively meaningless technical statistics as some kind of quality indicator. This is a primary factor in the perpetuation of some long standing misconceptions about certain geometry elements and modeling strategies.
A good example of this is when an artist spends very little time on blocking out accurate shapes and instead jumps right into adding minor surface details and manually moving edge loops around for hours to maintain all quad geometry.
This raises the question of where is the added value of the all quad topology if the model's shape is inaccurate and it took significantly longer to make? Subdivision modeling is a commodity and developing an efficient workflow will help an artist bring value to their skills set. Excessive manual topology rework and manually replicating work done by automated tools is something to avoid whenever possible.
An all quad topology layout isn't inherently good
and a topology layout with a lot of triangles and n-gons isn't
inherently bad. It's much more important to judge a given model by
specific project
goals and evaluate how well the various geometry elements were used to
optimize the return on the time spent.
If all quad topology is a hard technical requirement then Boolean re-meshing workflows, including the one Arrimus covered in his video, can have a significant speed advantage over traditional subdivision workflows. (Though it's still worth mentioning that art fundamentals and an understanding of the basic concepts behind subdivision modeling are still an important part of this workflow.) Here's a couple of recent discussions with an artist who starts out with a Boolean re-meshing process and moves into a subdivision modeling workflow. This is a great example of how the overlapping modeling skills can transfer over.
Taking a broad view of things: the basic concepts, technical
fundamentals and best practices for poly modeling and subdivision
modeling are pretty cut and dry. This provides a solid foundation and is
a great place to start learning about how things work. However, there
comes a point where learning to be effective with subdivision modeling
becomes less about how things are done and more about why things are
done and when things are done. Building up this knowledge requires researching and practicing and can take some time to develop. It's all about picking up the tools and screwing up until the screw ups start to resemble completed work.
With the subdivision models: a lot of the artifacts and smoothing issues are caused by mismatched curve segments (where there isn't enough adjacent geometry to support the shapes) and incorrect edge placement to control the subdivision smoothing behavior. Placing the edges on the outside segments of the corners does result in all quads but it also causes the center segment of the corner to collapse inwards. In general, when it's not possible to match the adjacent segments, it's better to have the center corner segment connected to the nearby geometry and pull the shape outwards.
Flat surfaces are least likely to be effected by topology changes and are a good place to end extra edge loops. If smoothing artifacts are appearing on or around flat surfaces then then it's likely that either the geometry elements aren't completely coplanar or there's a missing support loop around the shape transitions. Sharp transitions between surfaces should generally be support by edge loops on both sides. It looks like there may be some spots where the geometry isn't fully supported and this could be causing some of the smoothing issues around the perimeter of the shapes.
With the low poly shading and topology: it's important to use both the geometry and sharp edges to control the smooth shading behavior. Adjusting the geometry, triangulation and placing hard edges will help resolve some of the distortion in the low poly model. It's also important to optimize the low poly mesh by removing any geometry that doesn't add to the visible profiles of the major shapes.
Here's an example of all smooth shaded, smooth shaded + hard edges and all smooth shaded + chamfer.
Here's an example that compares two different topology layouts used to optimize the geometry for high poly (top) and low poly (bottom) models. The n-gons and center segment edge connections in the corners facilitated the use of edge weights to control a bevel / chamfer modifier to quickly and automatically add all of the supporting geometry without causing any major smoothing artifacts.
There's a number of different strategies for creating low poly models. Starting with a fairly detailed base model that can be developed into both the subdivision cage mesh and the final low poly seems to be one of the more efficient approaches. It's also fine to keep the low poly topology organized with quads and n-gons while editing but it's also important to triangulate the mesh before exporting. Different applications can use different triangulation methodologies and without a set triangulation order there can be a triangulation mismatch between programs which can cause issues with baked normals.
Here's an example of the source low poly and two different triangulation methods:
A couple of great resources to learn more about normal baking are Joe Wilson's baking tutorial
and Alec Moody's video about controlling shading behavior.