Reading time: 15 minutes
Video length: 24 minutes

Introduction

This lighting tutorial is split into two sections:

1. The YouTube video – a free chapter of the EEVEE course. A blend between EEVEE techniques and applied lighting foundations
2. A written article: general photographic lighting tips and tricks for 3D portraits

Huge thanks to Yaw Onyina for the permission to use his astonishing Tribal Character 3D model (more precisely, .blend file) for this lighting tutorial.

Yaw is a medical doctor, 3D artist and data scientist crafting stunning portraits in Blender.

Download Project Files

—

Character Lighting in Blender | EEVEE (4 Difficulty Levels)

—

Lighting Tips and Tricks for 3D Portraits

A theory extract

No matter the render engine – EEVEE or Cycles – here are the character lighting tips that will help you create cinematic-looking portrait shots.

Front light is flat

As a rule of thumb, If the light sits between the camera and the face – directly in line with the camera – the face goes flat. No nose shadow, no cheekbone. Think passport photo, but in the worst possible way. Of course, frontal isn’t always bad – Breezeh built an entire liminal world around the on-camera flash (even though not exactly for portraits).

Usually though, it’s worth moving the key light off-axis. Even a few degrees. Suddenly there’s shape.

Actually, the original light placement in that .blend by Yaw featured exactly that type of light direction. A bit fronty, yet slightly off-axis.

–

Focal length changes the face

It’s a camera decision, not a lighting one, yet focal length (and the distance to the subject) shapes the portrait just as much as where you put the light.

Short focal lengths (12-35mm) usually also means that you pushed the camera closer to the subject. And close cameras distort – the nose gets bigger, the forehead pushes forward and so on. When extreme, you get the potato face.

Long focal lengths (85mm and above) – aka the camera is far away – compress everything. It flattens the spatial relationship between the nose and the ears. It can make faces look more like faces. Arguably, it can look more appealing.

In 3D it’s worth trying different focal lengths, because the same light at 24mm vs 120mm reads completely differently on the face. The shadows and reflections land in different places and so on.

Quick tip: the lens compression effect really clicks when you see it animated. Search for “focal length compression comparison” on YouTube – watching it move can be the aha moment.

—

Big light = soft shadow. Small light = hard shadow

Large area light close to the subject: soft, gradual, flattering shadows. Small or distant light: harsh, crisp, contrasted shadows. For portraits, you almost always want soft. You can always pull back, but start soft.

—

Falloff

When a light is really close to the subject, brightness drops dramatically from face to chest. When it’s far away, everything gets lit uniformly. Neither is wrong! But pushing the light(s) too far away can flatten it out. And we usually try to avoid flat.

A bit of falloff adds life to a render.

—

Skin subsurface scattering

Skin isn’t opaque. Light enters the surface, bounces around under it, exits slightly tinted – warm, red. That’s what makes a face look like a face. Without SSS dialed in, no lighting setup in the world will save you. With SSS, even a single-light setup can look gorgeous.

Quick tip: In EEVEE, realtime subsurface scattering work wonders not only for skin, but also for… alien skin.

Or simulating translucency in plants.

—

Try single-light setup

Before lightmaxxing, try nailing a single area light. If anything, it’s a great exercise. Multiple lights can muddy the waters and even fight each other.

Just one light, placed slightly above and to the side, can produce a portrait that blows people away. The shadows – especially the soft shadows – are doing the sculpting.

Despair – Portrait by Yaw Onyina

Quick tip: The subtle secondary light bounces created by Raytracing, and SSS add nuance to the single-light schemes. So it’s never truly one-light.

Quick tip #2: not all lights are the same: a gridded studio lights with half-frost diffusion are way different from… some other types of lights. In 3D too. The ‘Single-light’ setups are about light qualities.

There are add-ons for Blender which imitate real-world photographic lamps with different modifiers: grids, various softboxes and so on. Light Wrangler for instance.

—

Choose HDRi with a strong key

When using 360° HDRi environments for lighting your characters, find a strong key light within the HDRI. It can be anything. A big and bright opening in this Hangar HDRi, for instance.

E.g. Choosing this HDRi, I don’t care about airplanes. I care about big bright areas.

That’s your key light. Treat it exactly like positioning a studio light. Spin the panorama until the light sculpts the face from an interesting angle – off-axis, with shape to it. And don’t limit yourself to Z rotation only. Tilting on X or Y can throw up light directions that feel genuinely cinematic.

—

Decouple background and light exposure

Physical accuracy and ‘looking cinematic’ are not the same thing. A physically correct HDRI result often gives you a blown-out backdrop or an underlit face. So decouple them (using the Light Path node) – control the background brightness separately from the light hitting your character.

Slightly muted backdrop, well-lit subject. That’s often the sweet spot. Just don’t push it so far that the shot starts to look lit (as cinematographers say).

It’s a common practice, in cinematography, to expose for the background – to make sure it isn’t blown out, and then push more light onto the talent.

Quick tip: Patrick O’Sullivan channel – Wandering DP has many great lighting breakdowns. “Exposing for the sky” is a recurring topic there.

—

The double HDRI trick

Use one HDRI for the backdrop – the story, the location, the mood. Use a completely different one to actually light the character. They don’t need to perfectly match visually (however, it’s good if they’re in the same ballpark as for their colors). What matters is that the lighting HDRI has good light quality and direction (read: the well-defined key light). A hangar door. An overcast sky. Whatever casts the right shape on the face.

Pick the backdrop for atmosphere. Pick the lighting HDRI for how it sculpts.

—

Match your lights to the environment

When you go Full Cinematic Setup and layer studio lights (all these Blender lights) on top of an HDRI, color match them. Cool environment? Cool lights. Greenish scene? Your fill can be quite green and it’ll sit naturally – the HDRI will motivate it. Sample colours from the HDRI. Use them as your palette.

—

Eye light / Catch light

Add an eye light. Eyes without a catch light can look glassy. A small area light, placed far enough to register as a glint is enough.

—

Add a kicker

A kicker – or backlight, or rim light – is a strong light placed behind and to the side of the character. It traces the edge of the head, the shoulder, the jaw. It helps to separate the character from the background. With it, the subject pops.

It’s not that you always need backlight. But it can be super effective. The trick is motivation. The kicker needs to feel like it could exist in the scene – a window behind the character or just a bright spot on the backdrop.

You can even start with the backlight – making it a Reverse Key Light setup. And then wrap the light around the back of the head, onto the face, using a bounce card or an area light.

The trick is motivation. The kicker needs to feel like it could exist in the scene – a window behind the character, or just a light blob in the background plate.

Quick tip: It works beautifully in real-world cinematography, outside CG, when you have just one lamp, but still want to have both the kicker and the key light.

—

Haze

A thin layer of volume scatter gives the scene depth in a way that’s immediately cinematic. My outie is a cinematographer and he’s very generous with using haze machines on set. Haze helps to pop the character out of the background.

—

Shallow Depth of Field

Adding depth of field can help make a portrait feel more photographic and dreamy.

A very shallow depth of field (low f-stop, say f/1.4–f/2 or in Blender, or even crazy low values like f/0.1) puts almost – everything except the tiny sliver of depth – out of focus. It can look truly cinematic.

Experiment with the bokeh ratio for vintage lens weirdness or an anamorphic squeeze.

—

Post-pro and Color Management

Not a part of lighting per se, post-pro and color management settings are not to be neglected.

View Transform in the Color Management settings: AgX or Filmic are solid defaults. ACES 2.0 has more punch and contrast. Avoid anything that oversaturates highlights if you’re going for photorealism – Khronos PBR works well for product shots where you need to preserve brand colors, but tends to make skin look like it’s been Instagrammed.

Film grain / sensor noise: a small amount grounds the image. Like It’s the silver halide reacting to light thing. Chromatic aberration: Tiny amounts only – just enough to push that ‘analog photography feel’ further.

—

Start with one light. Get it right first.

Everything above is additive. A single well-placed light with decent SSS settings – or a single HDRi rotated the right way – will beat a messy ten-light rig every time. Learning the fundamentals – direction, size, falloff, skin response is still what makes a portrait work.

Once that foundation is nailed, adding extra lights becomes a creative choice rather than trying to fix a flat-looking image.

Actually the light setups in Yaw Onyina’s character portraits are usually quite simple – yet they work beautifully. Not least because the models themselves are exceptionally well made – but tsss… that’s another story.

Desheveled Sailor by Yaw Onyina – 3d Generalist and Medical Doctor

—

Bonus EEVEE tips

Turn off denoising and Fast GI for portrait work

Two Eevee render settings that quietly ruin HDRI portrait quality: denoising and Fast GI approximation. Denoising smooths things out, but it also smears fine detail – skin pores, hair strands, contact shadows. Switch it off and the image gets crispier in a good way.

—

Environment Shadow Threshold

Fine tuning the Shadow Threshold in the Environment settings can have an interesting effect. Higher threshold means softer, more ambient lighting. And lower threshold means harsher shadows.

—

Shadow jitter: the microshadows

When you use a soft area light, turn on shadow jitter – both in the light settings and in the global render settings. Without it, you lose the tiny shadows under the nose, along the eyelids, beneath the chin and so on. Those microshadows are what make a face look… more photographic.

For sharp, small light sources like a sun lamp, jitter doesn’t matter as much – it’s the big soft lights where you really feel the difference.

—

Links and Resources

HDRIs and Textures

Polyhaven – HDRIs

Free CC0 HDRIs up to 16K. One of the best sources for lighting environments (used throughout the video – South Africa outdoor, workshop interior, hangar).

Blender

Official Blender download

EEVEE

EEVEE Realistic Lighting and Rendering course

Post-processing and Color Grading

Free minimal post-processing setup for Blender’s compositor

Courses

CreativeShrimp.com/courses – Deep-dive Blender courses on Eevee, photoreal lighting, and rendering. That’s us

Cinematography

Wandering DP – cinematography lighting breakdowns

Lighting Techniques

Reverse Key Lighting – Creative Shrimp tutorial

Light Falloff – Creative Shrimp short

Photography Inspiration

Breezeh – flash photography aesthetic (liminal walks)

Steve McCurry

Richard Avedon

Joey L.

Dan Winters

Edward Weston

Hyperrealist Art Inspiration

Alyssa Monks

Gottfried Helnwein

Books

Direction and Quality of Light – Neil Van Niekerk

Commercial Photographer’s Master Lighting Guide – Robert Morrissey

Light Science and Magic – an Introduction to Photographic Lighting – Fil Hunter

Master Lighting Guide for Portrait Photographers – Cristopher Grey

Credits

Yaw Onyina – the author of the Tribal Character model

Photontown Studio – Omar Hewady and Ahmed Naguib’s studio. Facial animation specialists. They made the animation in this video and honestly, they nailed it.

The post How to Light 3D Portraits in Blender (Photographic Lighting Techniques) appeared first on Creative Shrimp.

—

As it turns out, we’ve been using photogrammetry quite a lot in our Creative Shrimp projects. We’ve been using it to digitize historical artifacts; for capturing details that would be a pain in the neck to model in any other way. We’ve built some miniature movie sets, like this Millennium Falcon, then photo-scanned it for fun.

Most importantly though, we’ve been using photoscanning to create life-like 3d environments. Mostly abandoned hallways and such, made of the shards of Brest (Belarus), Warsaw, Vilnius and other places we’ve been to.

—

A GENERIC PHOTOSCANNING WORKFLOW

There are a few really interesting things that we can do with photogrammetry as 3d artists and as environment artists…

But first, here’s a quick refresher of what a typical photogrammetry workflow entails.

• capture a bunch of photos of an object or an interior space from different angles;
  using the best capturing device you have; making sure there’s enough overlap between the photos and everything’s sharp and clear;
• load these photos into your photogrammetry software of choice;
  eg Meshroom, Colmap, Metashape, Reality Capture, etc
• let the software calculate similarities between the source photos and spit out a point cloud that can then be used to deliver a high density 3d surface;
• optionally, with texture;

That’s how it works. That’s the generic workflow anyway.

—

CAPTURING EQUIPMENT

What equipment do you need to start photo-scanning?

We often hear that you just need a device with a sensor and you can start doing photogrammetry. And that is true. But as a 3d artist, I find it somewhat frustrating how much photographic equipment has accumulated over time, in addition to my DSLR camera (I use a Sony A7iii with a Tamron 24-75mm f/2.8 lens or some of my primes because primes are generally sharper, but there was a time when we were using a Canon 80D with a Sigma 17-55 f/2.8 or pretty much any DSLR or mirrorless camera available).

Then you start thinking about getting a tripod. It is a must-have for keeping shots steady.

A ruler and a color checker come next.

And then: “Should we get a drone?”

It escalates quickly.

Let’s put it like this: a low or medium-range DSLR or mirrorless camera is probably all you need if you have just started.

But what camera is best for photoscanning? This video is as close as it gets to answering the question “What camera is best for photoscanning?”. There, we talk about the 3 parameters of any capturing device that make all the difference in photoscanning quality.

And in this one we talk about what are the optimal camera settings for capturing the highest quality photos for 3d reconstruction.

—

PHOTOSCANNING SOFTWARE

As for the software, there are many options to choose from.

What we’ve been using mostly is Reality Capture and Agisoft Metashape. Fantastic tools, really fast and good quality. And commercial as well. Reality Capture has an interesting pricing option called PPI or Pay-per-Input (here’s our video with some advice as for optimizing the cost).

Meshroom and Colmap are the open-source alternatives. Which are also quite capable, in fact fantastic considering the price, just not as obscenely fast as Reality Capture and Metashape just yet.

Somewhat counter-intuitively, the open-source tools are arguably *more* demanding about the quality of the photos (for now). In other words, you may need slightly more expensive equipment and a more powerful computer to get the reconstruction results that are on par with the aforementioned commercial software options.

Still, we should absolutely support open-source, because we know what happens to commercial enterprises.

It’s also worth noting there are also mobile apps like Luma AI and Polycam.

—

5 PHOTOGRAMMETRY WORKFLOWS FOR ENVIRONMENT ARTISTS

When it comes to environmental design and photogrammetry, there are different ways to use the toolset offered by 3d reconstruction software. Here are 5 workflows (not the exhaustive list!) that are distinct in their goals and the type of data that you gather.

Distinct enough so we can write about each of them separately.

1. THE WHOLE SEAMLESS ENVIRONMENTS

2. MODULAR ASSETS

3. CHARACTERS

4. PBR MATERIALS AND MAPS

5. LIGHTING

—

WORKFLOW 1a: (CAPTURING) THE WHOLE SEAMLESS ENVIRONMENTS

The first workflow on our list is capturing the whole seamless environments. This might seem silly, what would you do with such a model anyway? But it’s the one that has given us some amazing location snapshots.

When we arrived at the abandoned warehouse near Brest (Belarus), our goal was to digitize the Volga car that has been standing there for half a century, collecting dust and bird excrement.

And that’s what we did.

But then, before leaving the place, Nik proposed to bring a drone next time to capture an isometric view basically.

And when I saw it reconstructed in Reality Capture, I thought, damn! I can totally imagine this as a game level in some indie RPG that uses the isometric view.

Especially if you pepper it up with dramatic lighting.

—

Double so if you throw in a playable character (this is a quick demo put together in Godot by Aidy).

—

If you’re lucky enough to have some amazing historical locations nearby, like this 18th century Bernardine monastery in Brest, rebuilt into a military hospital, a gem in our collection of abandoned places, photographed some 15 years ago, you can totally get some nice environments captured almost in one piece. Given you have enough time to spend there.

Even though it’s not a super flexible workflow, capturing the entire space like that, walking with a wide angle lens and an on-camera flash through the dark and cold corridors, you can’t argue with the photorealistic output it produces.

It just looks… real. Which it is.

Even with a cinematic lighting treatment in Blender it still looks arguably better than many games. It’s hard to beat that kind of photorealism, which comes unfortunately at the cost of flexibility.

—

THE CONS

Aside from that, a notable downside of such approach is that as every polygon and texel in such model is unique, the meshes and textures end up pretty heavy.

• The good locations are hard to find
• The lack of versatility
• Performance

—

That being said, even the lower res environment scans found on Sketchfab like this funerary monument by Morbase | Museu Virtual can work really well as a base for your next Blender animation.

Once you start throwing in lights, effects and particles.

—

WORKFLOW 1b: (CAPTURING) THE WHOLE ENVIRONMENTS – RADIANCE FIELDS

When it comes to creating the complete snapshots of environments, the neural radiance fields (or NERFs) seem to do an even better job.

Unlike the traditional techniques, these novel view-synthesis methods can actually capture a lot of extra data: the wispy details like vegetation, or hair, but amazingly also the dynamic material properties like reflection and refraction.

The stuff that was unthinkable using more traditional photogrammetry tools now comes to life thanks to Gaussian Splatting and other NERF algorithms.

The demo below was created in the Inria’s open source Gaussian Splatting Github app. The beginner tutorial by The NeRF Guru, without which it would be impossible for me to make sense of it, is linked here.

A caveat: it requires a powerful GPU (I have RTX 2080ti, but NVIDIA GPU with 24GB VRAM or more is recommended).

Speaking about reflections, here’s a quick demo of the highly glossy scenery that we built and scanned just before going to Blender Conference 2023.

Honestly it’s pretty mind-boggling to see it captured by the means of photogrammetry at all.

I wonder what happens when the animation part of the puzzle falls into place. Will it be a photogrammetry bingo card completed?

—

This tech is becoming mainstream really quickly, too. We can already try gaussian splatting in the Luma AI and Polycam apps (for our smartphones).

—

THE CONS

• tricky to edit
• non-versatile

The problem with radiance fields is that it isn’t super clear how to edit this stuff just yet. The tools for editing gaussian splats and NERFs are still in their infancy, in other words.

But this tech is developing fast. We should watch this space.

P.S. Here you can see a demo testing the thin-structures capabilities of gaussian splatting in Luma AI.

—

WORKFLOW 2. (EXTRACTING) MODULAR ASSETS

A far more versatile workflow of course would be a modular one.

Meaning, finding a cool location and dissecting it for props. With the goal of creating the asset library that captures the essence of this environment. So we can make *any* kind of environment like the one we’ve just scanned.

Incidentally, that’s the industry standard.

—

Going back to our warehouse environment, we could have scanned:

• The hero assets like this Volga
  
• The medium and small-scale props
  
• Surface textures
  
• Decals

Whatever can be salvaged there. The goal is cohesiveness. Scanning such library around the same environment is like a locked-in art direction. Everything in this warehouse was equally dusty, forsaken and coming roughly from the same historical slice. Imagine fine-tuning such a look across dozens of models. Using this workflow, you get it for free.

Have a look at any of the Scans Factory packs to see how realistic an environment composed of such modular props can look.

—

Of course, then each asset would have had to be optimized; meaning, polycount reduced and the geometry details transferred from the high to the low res meshes (as normal maps for example);

—

Sometimes this process is a breeze.

Say, when you can take a prop back home or back to studio and scan it on a turntable, and maybe flip it during the scanning process, so the software reconstructs a full 360 degrees watertight mesh.

Then it requires almost no post-processing, maybe aside from some polycount reduction (and that can be done automatically) and texture baking (and that can be automatized as well, to a certain extent).

—

But it isn’t always like that. In fact, it’s almost never like that!

—

THE CONS

• Planning
• Post-pro and clean-up

More often than not, raw scans are pretty messy and require an enormous amount of post-pro to make them useable.

Like, imagine cleaning-up something like that.

—

But anyway, nothing is more satisfying than scattering the photoscanned assets that have been prepared in advance. Gathered in the same location. Carefully optimized. The resulting environments can look just as cohesive as the full location scans.

—

WORKFLOW 3. CHARACTERS

Speaking about modular props, characters also fall into this category and can be made with the help of photogrammetry. Let’s say, the background NPCs for your environments like those seen in Ian Hubert’s videos.

—

As a quick reminder, it goes like this. First you make a quick scan, add a few bones in Blender, then animate these bones to rotate the torso and the head a little bit while recording the motion. And you get a nice background character doing the background character stuff.

The advantage of this workflow is that we don’t have to use a proper A or T-pose for scanning, we can just scan the characters in the poses they’re supposed to be, like sitting or riding a bicycle.

—

A more advanced variation of this workflow would be to apply the real motion capture data to such quick character scans using one of the markerless motion tracking apps like Mixamo or Rokoko Vision. You can even record your own motion and transfer it to the skeleton with these apps, like Aidy is doing here.

Still, it’s way simpler if the character doesn’t need to move.

People tend to fidget and make the scanning process more complicated than it needs to be. It’s my motionless body you see in this scan by the way.

—

THE CONS

• people are tricky to scan

—

WORKFLOW 4. PBR MATERIALS AND MAPS

Yet another application for photogrammetry in environment creation is, of course, capturing the PBR materials.

The process is no different from capturing props (or characters for that matter!): first we take a bunch of photos of whatever surface we want to scan, hovering over the muddy ground like a fairy; then reconstruct a high-definition mesh in photogrammetry software.

But then, we bake the detail from that mesh onto a flat plane to derive such maps as:

• the diffuse color (or albedo)
• ambient occlusion,
• normals,
• and most importantly the height data that contains the detail about the surface displacement

Then, these maps can be made seamless in Gimp by offsetting and painting across them all at once using the clone brush. This is a fairly new functionality that imitates the Affinity Photo approach to multi-layer editing, and we’re proud to have influenced this feature developed for Gimp with the help of ZeMarmot.

And voila! We’ve got the ingredients for a seamless PBR material.

The shaders like that work extremely well with displacement. No surprise, because in the end we feed it the real heightmap derived from the real surface. The result looks extremely realistic (and runs in realtime thanks to Eevee Next).

—

Additionally, we can use the extracted heightmaps for blending between different materials to create a much-needed variation. In Blender via nodes or alternatively, in Quixel Mixer.

—

THE CONS

• less flexible than procedural workflows (in Substance Designer and so on)

Aside from that, variation isn’t the biggest pro of this technique. The photoscanned materials are quite limited by the source footage. By its resolution and other properties. And simply by the physical availability, unlike their procedural counterparts.

—

WORKLOW 5. LIGHTING

The last type of data that can be extracted from a real-world location, that we will have a look in this article, is lighting. Lighting can be extracted and thrown away or extracted and… cherished.

Let’s talk about removing it first.

—

Typically, the shadows, at least the indirect ones, are removed from textures as soon as possible with the help of Agisoft Texture De-Lighter or other de-lighting tools.

So we can set our own lighting in Blender.

—

Alternatively, the lighting can be flattened during the capturing phase, by using an on-camera flash. This also gives the supernatural ability to shoot in the dark.

—

Or we can go as far as removing both shadows and reflections using the flash AND the polarizing filters. In the process called cross-polarization.

We don’t have time to go into that. But cross-polarization happens when you put a polarizing filter on both the lens and the light.

Like in this video by James Candy.

—

THE CONS

If you were capturing for a virtual movie set though, the lighting data would become precious. Definitely worth retaining!

To capture a full range of light, each shot can be taken multiple times using different exposure settings, then merged into a singular HDR image in the process called exposure bracketing. In Darktable for example.

And then, the photoscan can be made from such high dynamic range images. And as a result, such environment would emit a proper amount of light. So that the 3d objects put into such scene would receive a proper amount of light. And integrate seamlessly.

Imagine a better HDRI panorama that is fully three-dimensional – this is it.

—

THE CONS

• Processing for HDR takes time
• Versatility!

Unfortunately, preparing the HDR images can be time-consuming and the use-cases for such a workflow are truly specific.

—

CONCLUSION

Alright! These are just some of the things we can do with photogrammetry, as 3d artists.

Despite producing a non-versatile output sometimes, the tech itself is actually pretty versatile nevertheless. There is something for everyone.

So no matter whether you’re a 3d artist, a director, a cinematographer or a level designer; or maybe you work as a scientist or archaeologist, photogrammetry gives us some powerful tools and workflows to bridge the gap between our physical world and the digital realms we create.

—

Before we wrap it up, I’d like to say thanks to everyone who helped us on the ground to gather the content: Eugeny, Nik, Pawel, Kaciaryna, Ryncuk, Aidy, Lena – thank you so much indeed!

—

Feel free to check our Photogrammetry Course. Thank you!

The post Photoreal Environments and Photogrammetry: 5 Workflows For 3D Artists and Environment Artists appeared first on Creative Shrimp.

In this tutorial we’ll take an in-depth look at the problems with ngons to raise our 3d modeling game.

Blender 2.8 beta has been used for all demos.

What is an Ngon?

An ngon is simply a face with more than 4 edges.

There are modeling methods like boolean operations or software like computer-aided design (or CAD) that tend to output ngons in large numbers.

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:

“Quad only is a stupid myth that serves no one.”

“NGons should never be present in a final model.”

“It is better to avoid Ngons altogether since quads and tris will always subdivide properly.”

“…This hatred and phobia of Ngons needs to stop.”

“Ngons as intelligent modeling strategy? No.”

In my opinion there is a certain bias towards the no-ngons modeling strategy. 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.

Ngons Problems

1. Rendering (shading) issues

Ngons are associated with degraded surfaces that are supposed to be flat, but the shading or the curvature suggests that they aren’t. 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 such shape before it gets passed to render engine.

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 it look so strange? What’s wrong with it? It must be ngons.

In addition to that, shading issues associated with ngons tarnish the boolean ops based workflow and we become suspicious of the entire workflow for that matter.

2. Limited use of subdivision surfaces

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 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, car creation for example.

3. Awful looking wireframe

Chaotic-looking topology is another reason why ngons are frowned upon.

4. Deformation

Ngons often lead to animation (or more precisely, deformation) problems. Topology for animation relies on proper edge flow, and thus ngons are a big no-no if the mesh is supposed to be bent or deformed in any other way.

5. Interoperability

Ultimately, ngons behave in an unpredictable way when the mesh is imported/exported to game engines or to other modeling and sculpting applications (because some applications do not handle ngons well and there are always no guarantees about how exactly ngons will be interpreted, because there are no standards).

But all things considered, are ngons really that evil as we might have thought about it?

Before moving on let’s get down to basics and talk about triangulation.

3D Modeling Basics: Triangulation

On rendering, every ngon is subdivided into triangles or triangulated.

And so are quads. Quads are also split into triangles.

That’s how most render engines work, because triangles form the simplest closed area and thus are easy to rasterize and raytrace.

Under the hood, all shading and rendering calculations use triangles as basic units, even though it may seem that we, 3d modelers, work with quads or ngons.

So, every ngon gets split into triangles, but how exactly? For example there are five 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 the inherent problem of ngons (bad shading) can partly be attributed to non optimal triangulation among other things.

Now let’s go ahead and take a closer look at the disadvantages of using ngons.

Disadantages of Using Ngons – Closer Look

1. Rendering (shading) issues: Triangulation

So what do we actually mean when we say “a non optimal triangulation” and what is an optimal triangulation then?

There are different methods of triangulation. In Blender, we have the clip and beauty methods. Beauty arranges the new triangles evenly, while clip splits the polygons with so called ear clipping algorithm, that generally performs a bit faster but produces a noticeably worse set of triangles.

So just by changing the triangulation method we can get a more optimal triangulation and as a result, much better shading.

2. Rendering (shading) issues: 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 in the Loop Tools Addon amongst other methods). 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 are a different story, we will talk about it shortly.

3. Rendering (shading) issues: smoothing

As for smooth shading errors in relation to ngons, controlling smooth shading by marking edges sharp often does the trick. Marking edges sharp means telling 3d modeling application to stop trying to smooth out the connection between two surfaces based on their normals.

Taking control of smoothing, e.g. marking edges sharp manually or paying attention to auto smooth angle turns out to be liberating in terms of what modeling styles can be used. Together with the bevel modifier it opens up 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). This workaround unleashes enormous creative potential.

4. Shading issues: bad topology

The source of rendering glitches can be sloppy topology in general (like, not having enough polygons to support some mesh editing operations or having an uneven distribution of polygons).

Another defining characteristic of all kinds of bad topology issues is poles. To explain that, let’s revisit topology basics once again.

3D Modeling Basics: N-Poles

A pole is when 3 or more edges converge at a single vertex.

Sometimes 3 and 5 poles are called N or E poles respectively, though we prefer using the number in the name as it’s easier to remember since the number of edges coming to a point defines the pole. 3 edges come to a point for the 3 pole, 5 edges for the 5 pole, 6 edges for a 6 pole etc.

So why do we have those poles in a quad filled mesh? Because without those poles we can’t effectively have the topology flow to match the 3d shape of whatever it is that we’re trying to create. So we just try our best to place those poles in sensible places.

So why are poles noteworthy?

• This is where our edge loop selection or creation gets terminated
• No matter how much we subdivide the mesh our poles won’t change
• These areas can shade not as smoothly and predictably as a uniformly grid like mesh with no poles

If like in Scooby Doo we were to unmask the real villain we would finally locate and unmask the ngon and find a 3 pole or 5 pole or more underneath complaining they would have ruined the shading on our mesh and would have gotten away with it too (if it wasn’t for those meddling kids).

5. Displacement

The other case in which we may want to work with quadrilaterals and avoid poles is displacement.

So why do ngons and triangles get so much criticism? It’s 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.

6. Limited use of subdivision surfaces.

Because subdivision algorithms like Catmull-Clark used in Blender, 3ds max, Zbrush and other 3d modeling apps requires strict rules for mesh topology (that means having good edge flow and using mostly quads and having no poles), ngons don’t work well with subdivision. I would say, mainly because of long thin triangles and also poles which 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 from start to end it 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 tradeoff for using boolean ops which are amazing for mechanical design though.

On the other hand, some shapes are easier modeled without subdivision and without all-quads for that matter.

7. Beveled edges

The curved or beveled edges that we lose by waiving the subsurf modifier can be created with the bevel modifier instead. It works perfectly fine with ngons and helps us to achieve these sexy bevels with proper smooth shading.

In that sense ngons are much more appropriate for hard-surface modeling rather than automotive, organic or, god forbid, character modeling. Conversely, quadrilateral geometry could be better suited for organic, automotive and character modeling.

8. Awful looking wireframe

That’s… arguable. In fact, in many cases ngons make for much 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.

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 meshes, originated from subdivision surfaces.

9. Deformation

Deformation is a pretty serious problem of ngons.

Although, with enough geometry and more or less uniform polygonal density meshes with ngons can bend reasonably well, but not perfect by any means. So if you know that the mesh isn’t going to be deformed, then it’s ok. If it is going to be deformed, proceed with caution.

Again, following good modeling practices like having enough polygons is always helpful, no matter whether it’s 4-sided polygons or n-sided polygons.

10. Interoperability

Unfortunately there are no guarantees that ngons will import/export as expected because often times 3d applications make arbitrary decisions on how ngons should be triangulated. Once ready to export, it’s worth double-checking what triangulation algorithm you’d like to use.

Conclusion

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 some of their disadvantages are continuation of their merits and can be ignored in favor of 3d modeling possibilities you get in exchange. And they do have pros such as:

• Less polygons overall
• Elegant wireframe (arguably)
• Boolean operations unlocked
• Bevel modifier
• Quick concepting

I would say, the real 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 uv maps. And probably, physics engine operations on ngons could be problematic.

In my opinion, the other issues discussed in this video can be mitigated or even framed positively.

A Few Practical Takeaways:

Curved and going to be deformed = quads. Flat and not going to be deformed = ngons.

Pay attention to smooth shading settings, what surfaces should be marked as sharp, what’s the auto smooth angle and so on.

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 poles!

Ngons 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. 

On a side note, there are numerous ways of masking the shading artifacts with the help of the data transfer modifier, shrinkwrap modifier and so on.

Links:

Blender

Hard-surface Modeling in Blender (Blender Market)

Hard-surface Modeling in Blender (Gumroad)

Master Car Creation in Blender

masterxeon1001 on Youtube

Vitaly Bulgarov – Artstation

Khan Academy Pixar SubD Explained

Aidy Burrows on Twitter

Gleb Alexandrov on Twitter

Over to You

Embracing polygons with more than four 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. Let us know in the comments below, do you use ngons in your modeling?

The post Are Ngons Really That Evil in 3D Modeling? appeared first on Creative Shrimp.

Hi, Aidy Burrows here, bump map creation can itself be a bumpy ride and as for normal maps? Who can say what normal really is anyway?!

Well, actually in this context probably a mathematician could easily tell us BUT! The point is from an artist’s point of view there are some bumps to navigate so the process can be smoother (gotta love a 3D pun to get us started!)

BEWARE! Before we let our guard down after some slick puns let’s not forget why we’re here! The dangers of bump/normal maps are that we don’t directly see them like we would a color map, instead we see more how the light bouncing off the surface has changed because of them.

That means it isn’t always immediately obvious what the problem with the bump/normal map might be, where the problem stems from or how to fix it. So to immunise ourselves to all of this we’re going to hold these problems betwixt tweezers for inspection!

CONTENTS

Problem 1 – Default image settings

Problem 2 – Color Spaces in multiple menus

Problem 3 – File types

Problem 4 – Oversharp bump artifacts

Problem 5a – Baking from a shader

Problem 5b – Baking from an object

PROBLEM 1: The default image settings i.e. 8 bit images aren’t optimal for normal/bump images.

Here are our default new image settings below, notice the unchecked 32 bit float checkbox meaning our new image will be 8 bit.

If we leave everything as is and bake with this default lower bit depth, we can get problems such as these…

Notice the strange swirly mosaic tiled look to the middle cube. Those artifacts aren’t there without the normal map (on the left) or on the high resolution mesh that was used to bake the normals from (on the right).

Here’s another example using an 8 bit bump map on a simple plane…

On the left is the texture we’re using as a bump map for the plane in the viewport on the right. Again we can see the ‘banding’ artifacts.

We are asking a lot of our textures here though seeing how the object is so clean, smooth, defined and shiny. If on the other hand your material is actually quite rough and/or grungy often we can hide these banding artifacts on the normal map…

Above is that same central cube from before but instead of a very low roughness setting of just 0.05 here we’re hiding a lot of the artifacts in the 8 bit image with a roughness value of 0.4

So in conclusion for proper versatility make sure we have that 32 bit float checkbox enabled for bump/normal maps!

Now we have the bit depth out of the way let’s move on to…

PROBLEM 2: There are different ‘color spaces’ which can be set in different editors that we need to make sure we get right (again the default settings don’t help us here).

Here in this next image you’ll see 2 editors on top of each other. On top we have the image node selected in the shader editor and below the normal map texture being used in the image editor. This is what the cube was using earlier to show the 8 bit texture problem.

Notice in each of those editors we have the properties panel open (toggled with the ‘N’ shortcut key) and highlighted is where we can set the ‘color-space’ of the image.

Let’s ask ourselves, will this be plugged into any color sockets on our shader? The answer is – NO! So we need to remember this is ‘non-color’ data.

8 BIT

For an 8 bit image, Blender will probably default the color space here to ‘sRGB’. Which means that the image is not being treated as just data, so we need to counteract that. Luckily that’s pretty easy to do because in the image editor we have a pulldown menu that we can set to ‘non-color’.

The thing to bare in mind there is that in order for this normal map to shade properly we need to explicitly tell Blender in the shader editor that this image should NOT be treated as a typical color image. That whatever values are stored in the red, green and blue channels have been altered (by the sRGB profile) to something we don’t want.

You might be wondering WHY are they altered? Well, very basically this is because it makes the texture more useable for the monitor and more pleasing and intuitive to the human eye.

As we know though this texture isn’t to be directly seen by the human eye, this is for altering normals, so we want to reverse the changes of that color space. That’s what the ‘non-color’ option on the image node is doing!

PRO TIP!

If we want to control this manually ourselves we can simply add a gamma node set to 0.454 (linear to sRGB) or 2.2 (sRGB to linear) instead of switching that non-color setting.

One final note on this (which may change down the line if this is a bug!) if you switch the color space in the image editor from sRGB to ‘non-color’ there. Then you may find that switching the color/non-color toggle on the image node in the shader editor actually has no effect at all. (If this isn’t a bug perhaps greying out that option to indicate it isn’t relevant in that case could help clarify things)

32 BIT

Here it’s probably worth mentioning that there may be a couple of things that end up being changed by the developers or potentially (and understandably) there are some bugs in the current 2.80 beta ointment. Whatever the case, what follows here should be the most robust and consistent way of working with 32 bit images to get what we need.

For a 32 bit float image, blender will probably default the color space to ‘linear’ instead of ‘sRGB’.

It is fine to use linear color space but as I mentioned there are some bugs lurking, i’ve had it sometimes flip on me where instead of setting the image node to ‘color’ i’ve needed to set it to ‘non-color’. Spooky! So I think seeing how non-color space is intended for textures like normal/bump maps anyway let’s just stick with that!

Note: If we change the color space in one editor it’ll reflect that change in the other editor.

So use non-color space for 32 bit, but you may find (for now anyway) that the non-color/color toggle of the image node might then not do anything.

Here’s how a baked normal map will show up in 32 bit non-color space.

Remember as mentioned before if we want to control this manually ourselves we can simply add a gamma node set to 2.2 (sRGB to linear) or 0.454 (linear to sRGB) instead of switching the image node from ‘color’ to ‘non-color’. In fact, the color/non-color pulldown on the image node actually doesn’t currently do anything now that we’ve set the color space in the image editor to ‘non-color’. Again I suspect this bug may well be sorted any moment.

One interesting thing to note is that the 32 bit normal map looks a bit pale and lighter than we’re used to. It would be useful to be able to view it in the more typical darker shades like we had with the 8 bit image and I wouldn’t be surprised if that option returns soon too.

So in conclusion, this is fairly simple to remember as we’re setting the image itself to non-color and the image node that goes into the normal map in the shader editor to ‘non-color’. The only exception i’ve found is that when about to bake and generate the normal map itself, the image node that you have selected to tell Blender to bake to that image can be left at its default ‘color’ setting.

After we’ve created our working normal/bump maps, we’ll probably want to save them so that leads us to…

PROBLEM 3: Which file format/settings are best to use to save the bump/normal maps externally?

As we know, for an ideal texture we need the full bit depth. But what images can we save to and still expect to keep all that data in good shape?

After we’ve generated our normal map, from the image editor we’ll want to go Image > Save a copy… (don’t use ‘save as’ because if you choose the wrong filetype there’s no going back!)

That will show us all our potential filetypes…

Note we’re only using ‘RGB’ so we’ll be saving using that, ‘RGBA’ would be required if we also want to save out the alpha channel which we’re not doing in these examples.

In the below comparison, let’s take a look at using the same normal map that was baked for the cube above (the unsaved generated 32 bit version) compared to the results of saving that out as 8 bit and 16 bit PNGs….

(note : if the gif image above seems to be skipped over, this may be a Firefox issue)

As we can see the 8 bit PNG image shows those artifacts we’ve spotted before, but the 16 bit PNG seems to be almost identical to the full 32 bit generated bake.

I did some further tests and noted some filesizes below. It seems pointless to upload the images and display them here as all 16 bit or above tests looked identical to the generated 32 bit bake too!

(all examples are for a 1024 x 1024 texture size)

8 bit png = 117 KB

16 bit png (default 15% compression) = 1,080 KB

16 bit png (0% compression) = 6,156 KB

16 bit png (100% compression) = 792 KB

32 bit (Full float) OpenEXR (no codec) = 12,305 KB (Largest!)

32 bit (Full float) OpenEXR (Zip lossless codec) = 4,350 KB (Smallest lossless option)

32 bit (Full float) OpenEXR (Pxr24 lossy codec) = 637 KB (Smallest lossy option! Not including 8 bit)

Note for OpenEXR there are even more codecs to try in the pulldown menu, so if space is a concern you may find different codecs squeeze that image file down even smaller and with no noticeable loss of what you need that image to do. Go hunt the best of both worlds!

For the PNG 16 bit file compression can be useful here. The same results but differing filesizes, low compression generates a faster file but at a larger size (nearly 10 times larger!), and vice versa for high compression, something useful to bare in mind if generating lots and lots of frames in an animation as that compressing time can add up!

If for some reason we need the texture in the highest possible fidelity we can possibly save out to, then this is where OpenEXR comes in for full 32 bit juicy potential. Again there is a cost to balance as the filesize is double the size of the uncompressed PNG.

For the codec option we can have ‘none’ for the raw info but that will be the largest filesize available. I’d recommend trying Pxr24 to see if you can get away with a much smaller filesize. I’ve tried this previously and had indistinguishable results from the raw version at a fraction of the size. In fact in this case that ends up being the smallest filesize of them all! (Not including the 8 bit image of course!)

PROBLEM 4: An undesirable sparkly/jagged overly sharp animation

Sometimes the bump node has a kind of look to the shading in Eevee that can be problematic in animations. So we may need to know in those occasions how to swap those bump/height textures out for a normal map instead.

On the left of the comparison there you should be able to make out that sparkly overly sharp look when compared to the right side, especially in the last few seconds. The best bet is to watch in full screen and make sure it’s set to playback at the highest resolution. Otherwise compression might be obscuring the truths!!!

So as shown a height map used for a bump node and that same height map converted to a normal map and then plugged in a normal map node will shade differently. That is something we may need to bare in mind, to the point where we may want to tweak the shader settings, the specularity of lamps and the bump strength to make them look more similar to each other.

So in conclusion, despite the extra care sometimes needed to alter settings and have the normal map give a closer overall result to what we were already getting with the bump node, it’s still worth it for the especially helpful way it can eliminate that overly sparkly/jagged/sharp look.

PROBLEM 5: How to even bake a normal or a bump map anyway?

There are 2 methods I’d like to go over for baking some simple normal or bump maps.

METHOD 1 – BAKING FROM THE SHADER

First let’s take a look at what is probably the simplest. Here I’ve got a simple 2D plane, on that plane is a whole network of procedural textures such as noise texture nodes working together to create the height map going into the bump node for this shader.

Instead of all those nodes (which create that texture on the right) I want to bake all that bump information down into just 1 single texture.

1. UV Unwrap

We may have some UV’s already which you can check in the UV image editor. However, assuming we don’t for some reason, or they need to be changed let’s head over to the 3d view. While in edit mode, press A to make sure everything is selected and then press ‘U’ for the unwrap menu (see below), for a simple plane several of these options will give us what we need.

For 3D geometry the ‘Smart UV project’ option is a good one (again which also would work fine for the 2D plane), so if unsure give that a try.

Here notice i’m in the UV Editing workspace and in the uv editor on the left we can see the orange selected outline of the uv’s filling the entire grid space. A simple plane clearly won’t waste any texture space!

2. Create an image to bake to

There are several ways to create images in Blender, let’s do it this time from within the shader editor. I’ll switch the workspace (from UV editing) back again (as the previous workspace had the shader editor on the left) and then I’ll zoom in to get a better look at the nodes and go Shift A > Texture adding in a new ‘Image Texture’ node.

Click ‘New’ on the image node…

and from there we can name it, set the resolution and choose ‘32 bit Float’.

Once the new image is created, open up the properties sidebar with ‘N’ and find the ‘properties’ section, here we can change the color space from ‘linear’ to ‘non-color’. Note we can confirm this is 32 bit by looking at the checkbox next to ‘Float Buffer’.

The image node doesn’t need to be hooked up to anything it simply just needs to be present in the shader editor so that we can select it and let Blender know this is the image we want to overwrite when we hit the bake button (in a moment!).

3. Bake

Ok, we’re ready to bake! Eevee doesn’t have options to bake as I write this so in our main properties window on the render settings tab we’ll make sure our render engine is set to ‘Cycles’.

Also on the render tab at the bottom we’ll find the bake settings themselves.

Note also the samples in the sampling section are only set to ‘1’, that’ll be useful in a moment but not relevant while baking our normals.

NORMAL

If I want to bake the bump information of the shader into a normal map, I can keep the shader setup as it is. In the bake settings simply select ‘Normal’ as the bake type.

Then with a quick glance that the correct image node is still selected in the shader editor (the one i’ve called ‘bake to me’ 2 images ago) we hit the bake button.

That’s it!

All’s that’s left is to save the result somewhere. (See Problem 3!)

BUMP

If instead we want to bake the bump information, then we create an emission shader and hook what is going into the bump node up to that emission shader and that would need to hook into the main material output.

In the bake settings we can then select ‘Emit’ as our bake type and then as before we’re ready to hit the bake button!

Note: Something to keep in mind is that the rendering process for the Emit pass (and several other passes for that matter (but not the normal pass!)) will take the render samples into account. So since we only need one sample for the emit shader to give us everything we need, to save needlessly wasting baking time we can set that down to just 1 pass in our render sampling settings.

METHOD 2 – BAKING FROM ANOTHER OBJECT

The first 2 steps are the same as baking from the shader. So see above for more details.

1. UV Unwrap

2. Create an image to bake to

3. Bake

Here’s where things start to diverge a little, to bake from another object we’ll need to enable ‘selected to active’ in the baking panel and set the ray distance. In this example about 0.2 seems to work just fine. Though if after baking it doesn’t look quite right, try changing this ray distance setting to a higher value.

To actually perform the bake we need to select the object we want to bake from (typically some higher resolution mesh) and then shift select the object we’ll be baking to (so that it becomes the active object and therefore our target mesh).

Then as before make sure we have the correct image node selected in the shader editor and then hit that bake button!

• 8 bit (i.e. the default option) needs to be changed if we’re to get normal/bump maps that are useable in the majority of cases (i.e. shiny and clean and not grungy and rough surfaces)
• When generating your 32 bit float textures for your bump/normal maps, set them to non-color in the image or node editor
• When set to non-color in the image editor color space, the color space setting of the image node in the shader editor can be ignored. This maybe a little buggy though so keep an eye on this.
• If you want the most data of all saving into your image texture then use an openEXR format (Float Full) – Sometimes you can save a lot of space if you try a lossy codec such as Pxr24.
• If relying heavily on bump nodes in Eevee and find there is a lot of undesirable sparkly/jaggedness to the animation then try swapping the bump map out for a normal map.
• Reference for a couple of easy ways to bake out normal/bump maps.

See you out there on the open road to endless 3D possibilities!

Aidy on Twitter – game development veteran and overenthusiastic tutorial maker using a whole lot of Blender and UE4.

The post 5 Must Know Tips With Bump/Normal Maps (Blender 2.8) appeared first on Creative Shrimp.

[video_embed maxwidth=”800″][/video_embed]

NEW – PAINT APPS

MyPaint – a nimble, distraction-free tool for digital painters. Supports innovative features like spectral paint and linear color mixing.

NEW – INFORMATION TECHNOLOGY

Two Minute Papers – bite-sized science videos by Karoly Zsolnai every week.

NEW – MEDIA PLAYERS

VLC – a free and open source cross-platform multimedia player that plays almost everything.

NEW – LIFESTYLE

The Puttytribe – a vibrant community of multipotentialites (people who have a dozen projects or jump from passion to passion).

NEW – DESIGN

Zimri Mayfield – graphic design inspiration, logo redesigns and charming personality of Zimri.

PHOTOGRAPHY

Peter McKinnon – photography and cinematography tips by a vlogging coffee adept.

3D SOFTWARE

Gaea – advanced toolset for procedural terrain design and world building. Has a free version.

BLENDER ADDONS

D-Noise – a free ai-accelerated denoising add-on for Blender, based on Nvidia Opti-X technology. Only supports Nvidia GPUs.

Theory Studios Blender build – a branch of Blender that includes Intel Denoiser, Embree, Scramble Distance and Dithered Sobol features.

PRODUCTIVITY

Google Docs – online editing, sharing, and collaborating on documents.

COLLABORATION TOOLS

Perforce – collaboration tools that are compatible with Unreal Engine among other things.

PRINT SERVICES

Redbubble – printing and shipping services. T-shirts, device cases, posters, stickers, you name it.

Zazzle – an online marketplace that allows designers to create customized products like clothing and accessories.

Teespring – a platform for custom merchandise with no upfront cost.

GAMEDEV

Mathew Wadstein – Unreal Engine 4 and the Blueprint tutorials, lots of them. 

Matthew Palaje – helping out the game development community by sharing awesome indie devlogs.  

Game maker’s toolkit – Does Half-Life teach without tutorials? How games get balanced? And other game development theory gems by Mark Brown.

COLOR

Color Hunt – trendy color palettes for designers and artists.

VIDEO EDITING

Shotcut – a free, open source, cross-platform video editor.

Kdenlive – free non-linear video editor aimed at GNU/Linux, but also works on BSD and MacOS.

Cinelerra GG Infinity – a resource-saving 8k video editing software for Linux.

Davinci Resolve – cross-platform professional 8K editing, color correction, visual effects, audio editing and more. Has a free version.

TEXTURES

CC0 Textures – public domain PBR textures by StruffelProductions (Lennart Demes).

Texture Ninja – public domain textures by Joost Vanhoutte.

NEW: MATERIALS

Materialize – a stand alone tool for creating materials for use in games from images.

PixaFlux – PBR texture composer, visual scripting of image operations.

ArmorPaint – a stand-alone software designed for physically-based texture painting.

ASSET MANAGEMENT

Connecter – free visual asset manager for 3d artists.

PHOTOGRAMMETRY

fSpy – open source still image camera matching.

BLENDER COMMUNITY

Blender Community – an independent community agregator.

AUDIO EDITING

Reaper – digital audio workstation with a free trial.

OVER TO YOU

Did we miss anything? Don’t hesitate to tell us if we forgot to mention some amazing resource, we’ll make sure to add it in the next round of updates.

Want to see even more useful links? Check the Resources mega collection.

And feel free to subscribe to the newsletter to get ahead in computer graphics.

Let's get better at digital graphics and art! Join 3000+ members in the Creative Shrimp community. Subscribe to list

The post 30+ Useful Tools for 3D Artists and Designers appeared first on Creative Shrimp.

Download a daily build of Blender 2.8.

Blender Eevee Demos (April, 2019)

Baroque Executive office (Blender eevee interior) by 1D_Inc

NOARA – Teaser by Pierrick PICAUT

Porsche 917 Blender 2.8 EEVEE Demo by HEAVYPOLY

Procedural PBR in Blender – Showcase by Simon Thommes

Tiger – Blender 2.8 Eevee development test by Daniel Bystedt

Blender EEVEE motion reel 2019 by Metapoint

F1 Racer Eevee Demo by katarn66

Heroes of Bronze “Before the Storm” Teaser by Martin Klekner

Blender Eevee Demo 2019 by Lorenzo Zitta

Test EEVEE render blender 2.8 timelapse (My concept planetary buggy) by Alex Pi

Eevee blender 2.80 demo VR dream by Damien Monteillard

Cosmic Drift – Blender 2.8 EEVEE Demo by Curtis Holt

Komikaze Demo (Blender 2.8 EEVEE) by Rahul Parihar

Blender 2.8 | Demo testing Eevee by Jason Cumbers

cargo360 – Blender 2.8 Eevee demo by Minge Yeung

LEGO® EEVEE Demo by Renderbricks

Blender EEVEE – Taryn Hangar by HEAVYPOLY

Laserscan Demo French Fries Blender 3D Eevee by Dee van Hoven

T-cell : Houdini and Blender Eevee by NaotoFukui

Concept demo | Eevee in Blender 2.8 by William Davis

concept demo 2 – Eevee viewport | Blender 2.8 by William Davis

Blender 2.8 EEVEE alembic test by Patrick Noland

bloodcells by Oliver Zangenberg

Blender 2.80 eevee demo Orange tip Butterfly by Damien Monteillard

Real Time Character Rendering in Blender 2.8 (EEVEE) by Juras

“First snow” Blender 2.80 Archiviz DEMO by PLANE

cueva demo 1 hecho con eevee blender by Leonardo Angulo

Landing | Cinematic footage with Blender 2.8 Eevee by victorvdr9

Oblivion Environment art (Parte 1) by Jose Javier Carceles Marmol

Oblivion Environment Art Animation Reel (part 2) by Jose Javier Carceles Marmol

SF71H Ferrari F1 car presentation with Blender 2.80 Eevee real-time render engine by Azzurro-Design

Blender 2.80 (EEVEE) First Person Camera by 3D Vision

Sci-Fi Helmet – Blender 2.8 Eevee by DanGry

Strawberry cake cutting system by boolean – Blender 2.8 Eevee procedural texture by Sakura Rtd

Reaction Diffusion #1 – Blender 2.8 EEVEE Render by Mario Hawat

Under The Dome – Blender 2.8 EEVEE particle path simulation with compositor by Mario Hawat

Crystal Madness – Blender 2.8 EEVEE with Tissue addon by Mario Hawat

Blender 2.8 Eevee Gem test by Dmitry Beley

Blender 2.8, eeVee test, dancing crowd, VJ Loop by Ramzesmeister

Skin ZShader for Blender/EEVEE preview 2 by Zen Shaders

Red Ship (Oculus Quill – Blender Eevee 2.80) by Sebastián Sanabria

Dancing tumor – Blender 2.8 by Twinmiaou

Google Indie Showcase – Animating in Blender by Louis du Mont

Sphere Bot Animation — Matcap / Cycles / Eevee by Louis du Mont

Blender Eevee test by Hirokazu Yokohara

2AM vibes – Blender Eevee environment by Nathan Timothy Anderson

Blender 2.8 R/C Buggy rigging display with Eevee viewport renderer by Sobschack

The house – teaser by Jan Urschel

Angel (Oculus Medium / Blender Eevee) by Sebastian Sanabria

Breach in Sector HBY 22 Detected by Philipp Höhnel

SONY TPS-L2 by Max Mustermann

Drone concept design by Front

IV – teaser trailer by Tomasz Artur Bolek

721 Dark St. by Joni Mercado

Over to You

Do you have any cool Eevee demos to share? Drop me or Aidy a line on Twitter or in the comments down below!

The post 50+ Hand-picked Eevee Demos (Blender 2.8 Beta) appeared first on Creative Shrimp.

P.S. If you want to jump into that boat too, download a daily build of Blender 2.8.

And check out the previous Eevee demos collection.

Blender Eevee Demos (November, 2018)

Blender 2.8 EEVEE – ALIEN(1979) scene by ArtNix

Countryside Real Time by Vadim Ignatiev

SPACE SUIT REALTIME EEVEE by Albin MERLE

SSS in Blender Eevee by Monaime Zaim

Smoke test on eevee (blender 2.8) by Leandro Dreamer

Blender EEVEE short workflow and render by Neveselov

Test EEVEE blender 2.8 volumetric light by MFS.Junior 3D

Twisting Corridor | Blender 2.8 Eevee Realtime Viewport by Aidy Burrows

Elevator Dive  | Blender 2.8 Eevee Realtime Viewport by Aidy Burrows

Mandelbulb Fractals rendered test in 4k using Eevee by infango (original scene by Jonas Dichelle)

Blender 2.80 EEVEE Real Time Rendering [2.80.4 Alpha2 – Experimental build] Screen Space Reflections by WurmiSaft

Ink Drop (Smoke Simulation) with Eevee – Blender 2.8 by YafuLinux

Blender 2.8 Eevee – Alien facemocap by Emiliano Colantoni

Blender 2.8 EEVEE Hair – This is getting ridiculous by Da Paulus

Blender 2.8 Realistic Lighting Setup | How to use Irradiance Volumes in EEVEE by HEAVYPOLY

Procedural Cloud System for Eevee by Simon Thommes

Eevee smoke benchmark by LapisSea

Goodnight Claire – Blender 2.8 development test by Daniel Bystedt

Zbrush 2018 Mech – realtime render by Daniel Bystedt

Creating Foliage in Blender. Grease Pencil + Eevee by Jama Jurabaev

Space Suit in Blender by Jama Jurabaev

SPECTRAL – BLENDER 2.8 EEVEE by Emiliano Colantoni

Mandelbulb Fractals rendered in Eevee by Jonas Dichelle

ToyCar Eevee demo by BlenderBelich

Blender 2.8 EEVEE Volumetric – Disco Disco by Da Paulus

Blender Eevee – The showcase of Hermans by Leonardo Braz

Blender 2.8 EEVEE Autofocus Fun by Zacharias Reinhardt

Commodore Amiga CDTV rendered in Blender Eevee by Piotr Zgodziński

Cafe Racer Hoverbike 3D Printable Kit EEVEE Demo by HEAVYPOLY

Blender Eevee Viewport Test(GTX 1080 TI) by Uygar GÜRKAN

Blender Eevee Render Engine Test by Ilia Sibiryakov

Eevee Viewport test with Sphere Bot // Blender 3D Realtime Render by Louis du Mont

EEVEE Test by Олег Фрумсон

Catwoman Blender Eevee by katarn66

Demoreel 2018 Damien Monteillard 3D Modeler – 3dminfographie – Blender Cycles Eevee

Metaballs by Fin O’Riordan

Motion Graphics by Alex @meta.point

Your Turn!

Eevee is getting new features almost daily. How about grabbing the daily build of Blender 2.8?

If you know any other remarkable Eevee demos that we have missed, I would appreciate if you leave a comment and tell us about it.

The post 35+ Top-notch Eevee Demos (Blender 2.8 Alpha Builds) appeared first on Creative Shrimp.

FREE 2D SOFTWARE

PureRef – the simple way of viewing and organizing images, as developers say. Plus it has the Always on Top mode and its UI color scheme resembles Half-Life. Oh, and it’s free!

PHOTOGRAMMETRY SOFTWARE

Meshroom – a free, open-source 3D reconstruction software featuring the whole photogrammetric pipeline from point cloud generation to texturing.

NEW – VIDEO EDITING SOFTWARE

HandBrake – an open-source tool for converting video from nearly any format to a selection of modern, widely supported codecs.

AviDemux – a free video editor designed for simple cutting, filtering and encoding tasks. Can also be used for datamoshing.

FREE 3D SOFTWARE

SculptGL – a digital sculpting web app with sources available on Github. Features dynamic topology, remeshing, matcaps, you name it.

MagicaVoxel – a free lightweight 8-bit voxel art editor and interactive path tracing renderer.

NEW – TEXTURING SOFTWARE

Substance Designer – 3D material creation tool, defacto the standard in the 3d graphics industry for PBR texturing.

WEBSITE CREATION SOFTWARE

SquareSpace – a paid website authoring, marketing and analytics platform.

IMAGE EDITING APPS

Canva – create designs and documents in your browser, drag-n-drop style.

8Bit Photo Lab – a photo filtering app capable of simulating the ‘8-bit’ look of various computers and consoles from the 80s and 90s.

NEW – 2D CONTENT PUBLISHING PLATFORMS

Gfycat – upload and share high-quality looping GIFs. The embedded player looks neater than your usual GIFs!

Imgur – an image sharing platform and a passionate community where memes and viral images flourish.

NEW – 3D CONTENT PUBLISHING PLATFORMS

Sketchfab – the biggest 3D content publishing community, aimed at turning 3D into a mainstream media format. Sketchfab is a marketplace as well as a hub for Creative Commons content.

FREE BLENDER ADD-ONS

Animation Nodes – a node-based parametric modeling and visual scripting system designed for motion graphics in Blender. How cool is that.

Sverchok – a powerful parametric modeling toolset for Blender, featuring >150 nodes for creating and manipulating geometry.

PAID BLENDER ADD-ONS

FLIP Fluids – a paid liquid simulation add-on for Blender, based on a modern FLIP-based fluid solver.

E-LEARNING

Pluralsight – one of the biggest technology learning platforms. Digital-Tutors is now part of this platform.

Gnomon – computer graphics education for careers in the entertainment industry.

GAME ENGINES

Godot – free and open source game engine, being developed at a high rate. The Blender of game engines.

Armory – an open-source 3D game engine with full Blender integration.

NEW – COLOR AND LIGHT

Crafting Physically-based Materials – from Google Filament documentation

BOOKS. COLOR AND LIGHT

Color and Light: A Guide for the Realist Painter by James Gurney – A meticulous study of color and light in paintings.

BOOKS. VISUAL CULTURE

James Elkins: How to Use Your Eyes – A book that gives you a glimpse into the inner workings of our visual system.

NEW – PHOTOGRAPHY

The Art of Photography – the best photography channel on Youtube by Ted Forbes.

NEW – CROWDFUNDING

Kickstarter – a crowdfunding platform with >150k projects successfully funded.

Indiegogo – yet another crowdfunding platform with a huge group of backers.

NEW – TYPOGRAPHY

Google Fonts – an extensive catalogue of open source designer web fonts.

Fontsquirrel – as they describe themselves, Free Font Utopia. High quality free fonts licensed for commercial use.

3D ASSETS

yobi3d – a robust 3D model search engine with the Search by Image and Search by 3D Model functionality.

NEW – PRINT SERVICES

Printful – on-demand online printing and shipping, can be paired with Gumroad for semi-automatic orders.

FREE IMAGES AND TEXTURES, ICONS AND PHOTOS

TextureHaven – high quality textures (8K, PBR) by Rob Tuytel. Licensed under Creative Commons 0.

PAID IMAGES AND TEXTURES, ICONS AND PHOTOS

Poliigon – a huge library of textures, materials and HDR’s.

NEW – MISC

NormalMapOnline – an online normal map generator.

terrain.party – the easy way to extract real-world height maps.

MUSIC AND AUDIO (Creative Commons)

OtisMcDonald – Producer and multiinstrumentalist Joe Bagale released 30 tracks under a copyright free license on Youtube Music Library. I love these tracks.

NEW – ANALYTICS

SocialBlade – user statistics for Youtube, Instagram, Twitter, etc.

BLENDER COMMUNITY

Blender Network – Blender Foundation’s official partnership program, an online directory and social network for Blender professionals.

Aidy Burrows – CG artist, veteran game developer, lead instructor at CG Masters.

James B. Candy – 3D scanner and film maker at Classy Dog Films.

Bill Barber – tutorial maker, runs BlenderBrit website.

Leonardo Braz – 3D artist with a huge potential.

Grant Wilk – 3D generalist, creator of Remington Graphics.

Troy Sobotka – acolyte of moving pixels, an expert of color science.

Paul Chambers – professional CG generalist, runs a blog.

Mason Menzies – environment 3D artist

Rachel Frick – a super stylish CG artist

James O’Brien (Vadim Ignatiev) – CG artist. Check his car and city renders!

YanSculpts (Yanal Sosak) – a passionate hard working character artist.

Penfinity – Blender tutorials and amazing hard-surface modeling expertise by Wesley Vanitou.

Ian Lloyd Dela Cruz – Blender 3D privateer, creator of Ice Tools Pro

Lawrence Jaeger – 3D & motion Designer

Jim Morren – 3D character artist and asset creator.

Sean Kennedy – professional VFX artist, runs OpenVisualFX blog with tips and training for free & open-source VFX software.

Daniel Martinez Lara – the director of award-winning animated shorts, artist, developer of Grease Pencil

Daniel Bystedt – Blender artist, senior character artist at Goodbye Kansas Studios.

Jerry Perkins (masterxeon1001) – creator of HardOps and other add-ons for Blender, member of TeamC.

MACHIN3 – creates modeling add-ons and 3D assets.

ARTISTS AND CONTENT CREATORS

CaptainDisilluision – a famous superhero debunking internet hoaxes.

Vitaly Bulgarov – concept designer, 3D artist and hard-surface modeler, level = godlike.

Tor Frick – art director, concept designer and 3D generalist.

David Revoy – a digital artist using 100% open-source.

Ben Nicholas – senior concept artist, designer and photographer helping people to deal with depression by tweeting his journey.

OVER TO YOU

What have I missed? Tell me in the comments if you know some other crazy useful website. Much appreciated!

Want to see even more useful links? Check the Resources mega collection.

And feel free to subscribe to the newsletter to get ahead in art and computer graphics.

Let's get better at digital graphics and art! Join 3000+ members in the Creative Shrimp community. Subscribe to list

The post 60 Useful Links for 3D Artists and Content Creators appeared first on Creative Shrimp.

Enjoy 35 demos of Eevee and make sure to download a daily build of Blender 2.8.

Blender Eevee Demos (February, 2018)

1. Blender Eevee by Volkan Kacar

2. Blender Eevee Test: Interior Scene by Leroy Xie

3. Blender 2.8 Eevee Blade runner 2049 by Emiliano Colantoni

4. Morning Meet Comp aka EEVEE kicks ass by Heavypoly

5. Still Life // Blender 2.80 EEVEE Demo by el profesor

6. Blender 2.8 Eevee Test (Clock) by Ponkotsu

7. blender 2.8 eevee viewport – bug creature sss by Daniel Bystedt

8. Blender Eevee Space Render by Paul Siedler

9. Flying Trabant – Blender 2.8 EEVEE Showcase by Zacharias Reinhardt

10. Blender Eevee Test: Class Room Scene by Leroy Xie

11. Blender 2.80 EEVEE Test – SNES by Thomas Radeke

12. Blender Eevee Render Improvement by K.B Santoso

13. Guitars Stage – Eevee (Blender 2.80) by Davide Tirindelli

14. Blender 2.8 Eevee – Archviz scene by Emiliano Colantoni

15. Blender 2.8 Eevee – SSS the real one! by Emiliano Colantoni

16. Blender 2.8 Eevee – Wasp bot by Emiliano Colantoni

17. Blender Eevee Interior Test by K.B Santoso

18. Blender 2.8 EEVEE – Volumetrics Test Japanese Mountains show around by Dominik Graf

19. Blender’s Eevee looks delicious!! by Miloud Djarloul

20. Blender eevee pizza – Material setup by Cineca VisitLab

21. Eevee + CMV Realtime Material Experiment by Reynante Martinez

22. This Clip was entirely made with Eevee – Testing Blender’s new render engine by
Dorian Zgraggen

23. Clouds in blender EEVEE! #2 by Jakob Scheidt

24. Eevee render engine test by Andri Viyono

25. Blender EEVEE – Pagani Huayra BC by Bazejoo

26. Mr. Elephant. ~ View-port testing Eevee in Blender Glenn Melenhorst

27. Blender EEVEE: Jellyfish by Jakob Scheidt

28. Eevee Blender – Trixy Viewport by ONdata Studio

29. Eevee First Test by Mike Pan

30. Blender Eevee – Bad Experiment / Animation Test by Alessandro Chiffi

31. Bloom / Blender 2.8 (Test build) Eevee PBR Engine RealTime by Yuri Zhestnikov

32. Blender 2.8 Eevee 2BOT by Emiliano Colantoni

33. Blender 2.8 Eevee Test-2 volumetrics by Emiliano Colantoni

34. Blender Eevee viewport demo – wanderer by Daniel Bystedt

35. Weybec Shorts – EEVEE by Weybec Studio

Rock’n’Roll!

It was impressive, right? How about grabbing the daily build of Blender 2.8 and testing it out?

Can’t wait to see what you’ll create.

Share this article to bring the realtime future closer!

P.S. What’s your favorite Eevee demo so far?

The post 30+ Must-See Eevee Demos (Blender 2.8 Development Builds) appeared first on Creative Shrimp.

Software: Blender, Cycles, Krita, Gimp

Production time: 7 days each render

1. Magical Books (And Where to Find Them)

2. Sci-fi Game Concept Art (in Blender)

3. The Classroom Environment

4. Kitchen – Still Life

5. Grungy Environment

6. The Letter Blocks – Textures and Lighting

7. A Drone Concept (FL Eye)

8. Eye of Destruction

9. The Hallway

10. Alchemy – Textures and Lighting

What’s your favorite Blender render? Let me know in the comments below.

The post 10 Blender Renders That I Made for Poliigon (Some of Them Rock) appeared first on Creative Shrimp.