With the 2.8 release, Blender has added another rendering engine to its already impressive software: EEVEE. EEVEE is a real-time rendering engine that allows artists to preview their work quickly and accurately, as well as cutting down render times and a need for top-of-the-line GPUs or expert experience. This book will be an intermediate/advanced look at EEVEE, detailing the many ways you can use EEVEE to create awesome, fast concept art and get to your final render faster, with more ability to iterate on style, content, and direction. This book will go through three different mini-projects that will introduce various styles and content that will be immediately applicable to any project, for any user from professionals to hobbyists.

Figure 1.1: The Blender UI

We'll be using the Blender 3.0 release, which has some completely new and fantastic features that even industry pros will want to know more about. EEVEE has been updated in this version to be faster and expand the array of features already available. As more and more studios make use of real-time rendering and other ray-tracing shortcuts, the tips and tricks in this book will become more and more essential to animation as an industry, setting you up to be ahead of the curve when it comes to creating fast, interesting, and flexible art.

In this chapter, we'll learn what EEVEE is and configure Blender for our upcoming mini-projects.

The main topics we'll be covering are as follows:

• What is EEVEE? EEVEE as a rendering engine
• Why use EEVEE and what are the advantages of using EEVEE?
• Configuring the start of mini-projects

This chapter is mostly an introduction to the technology, but having the latest version of Blender downloaded from https://www.blender.org/ is recommended to be able to start exploring the world of EEVEE, and can provide a useful point of reference as we talk about limitations. Another great point of reference is Blender's docs: https://docs.blender.org/manual/en/latest/render/eevee/index.html.

We'll go over many of the things covered inside the EEVEE official docs, but reading through and being familiar with the various terms will help you to pick up some of these concepts faster as we encounter them in our mini-projects.

Before we dive headfirst into the absolutely astounding feature set that EEVEE provides, let's cover a little bit of what makes it so great, but also touch on some of the limitations.

EEVEE is an acronym that stands for Extra Easy Virtual Environment Engine, though originally it was named after the evolution Pokémon, Eevee. EEVEE is a real-time rendering engine. By real-time, we mean that we can preview our animations and designs in real time (or as close to it as physically possible). We can make changes to materials and instantly get an idea of what exactly is happening with those materials. We can move lights and cameras freely to understand what we're framing and how we're framing it. As you can imagine, this ability to see things in real time is a game-changer. But EEVEE isn't the only real-time engine being implemented in state-of-the-art graphics programs. Other real-time rendering engines that work similarly to EEVEE are Unreal Engine and Unity. As you may know, both of these are game engines, and as such are primarily used to create video games. As it utilizes the same rendering system as a game engine, it's very easy to see how EEVEE can be much faster than a render engine of a different style.

Most 3D artists are very familiar with ray-tracing. This is the most common method of scene calculation, where light rays are shot from lights then bounced off surfaces a specific number of times, providing illumination, material properties, and camera initialization. Being a real-time rendering engine, EEVEE does not perform light calculations like a ray-tracing engine such as Cycles would. EEVEE performs its scene calculation through a method called rasterization. Rasterization is a scene estimation model. This estimation model takes the scene information and provides a visual of what the scene should look like, not what it actually looks like. With this scene estimation technique, we can fake effects such as reflections, volume, and global illumination, but it is just that, a fake. We'll go over the optimum ways to fake some of the more advanced results that EEVEE can provide in our three mini-projects, because after all, 3D is all about how to make something look real, while in reality, it's all just pixels on a screen.

While EEVEE differs a lot from Cycles, it is also similar in some ways. EEVEE uses the same shading type as Cycles, which allows an easy transition from Cycles to EEVEE and back again. Most other render engines use this same type of shading, the Physically based shading model that has been the industry standard for many years now. Physically based shading or physically based rendering (shortened to PBR usually) is a way of calculating how light reflects off objects. It assumes that all objects will reflect light, some more than others, and their reflection values will make them shinier or more diffused. This allows light to be bounced off the objects in a scene. Because EEVEE uses PBR, we can use material shaders to determine how the light will bounce off something, or how the light will pass through something. These principles directly transfer from Cycles or another ray-tracing engine, so having some familiarity with those principles is recommended if you want to get the most out of this book.

Side Note

The Blender Foundation hosts a variety of demo files on their website, https://www.blender.org/download/demo-files/.

A fantastic way to understand the speed and utility of EEVEE is to take any of the labeled EEVEE files for a test run. Taking inspiration from the way other people have used EEVEE for different kinds of projects and in different production environments can really open your mind to the possibilities of the engine.

Why use EEVEE and what are the advantages of using EEVEE?

EEVEE is an absolutely fantastic set of tools when put in the right artist's hands. This book is a crash course on how to use the tools provided by Blender and EEVEE to create stellar artwork, and one of the first things to learn about a tool is when to use it and when not to.

There are four main ways we can use EEVEE when we're going about creating a 3D scene:

• The first is to use EEVEE to preview our scene, and when we're ready for the final render, switch to Cycles for a more realistic final result. This can save a 3D artist a lot of time by sacrificing some accuracy in the development stage. This is something that we will only cover briefly in this book.
• The second way of creating with EEVEE is to preview and render inside EEVEE. The pros of this are increased speed in previewing and in the final render, but because EEVEE is not a ray-tracing engine, the final render inside EEVEE will potentially be less realistic. This is the type of work we'll be doing in all of the projects that we create in this book.
• The third is the ability to see volumetrics in real time. We'll be exploring volumetrics in great detail in this book, and you'll use them in all the projects we'll work on.
• The last big advantage that we have in EEVEE is the ability to see emissions accurately in the viewport. We can use this as a shortcut to see the results of our light shaders without needing to add them to the compositor later. We'll use this in the third project we work on.

So, for extreme realism, we're always going to want to use a ray-tracing engine. But for speed? The ability to update and preview a scene in real time in the viewport is immensely helpful, particularly for more complicated scenes. It means that you can update, view, and make changes in seconds or minutes, rather than the slower workflow of updating, taking 20 minutes to render for a preview, make changes, and repeat. As artists, we can gain a better understanding of what exactly is happening in our scene, we can apply design and color theory more accurately, and provide the changes our art director wants, faster.

Limitations of EEVEE

In terms of the limitations of EEVEE, we'll cover specific points as we come to them, but when getting yourself set up to start our mini-projects, you should be aware of a few things:

• Firstly, EEVEE works with your GPU to render. While having a beefy GPU isn't exactly necessary, it should be noted that an older or less powerful GPU will slow down your render times a little bit.
• Secondly, because of how EEVEE evaluates lights and materials, there may be points that it fails, situations where you're using too many lights, too many refracted materials, or your GPU gets overloaded and crashes. This won't come up in the mini-projects we're working on in this book, but it's important information to know when you're working beyond this book on your own projects, or in a studio utilizing EEVEE in its pipeline.
• Shading is also a little different in EEVEE. Because we're using the GPU in EEVEE you'll probably run out of memory in EEVEE sooner than Cycles. In shaders, running out of memory will probably look like a texture that turns up pink. Don't worry about this for our projects though, we aren't creating complicated enough textures for this to happen to us. EEVEE also isn't able to utilize Particle Info nodes or bevels, but it does have added nodes such as Shader to RGB that we will explore.

  Side Note

  A great resource to read through for more information on where EEVEE is weak is the limitations page in the Blender documentation: https://docs.blender.org/manual/en/latest/render/eevee/limitations.html.

At its current development stage, EEVEE is not going to be the cure-all for every single problem you face when using a ray-tracing engine. The decision to use EEVEE should always be made with the following in mind:

• Do I need extremely realistic lighting or materials?
• Do I need to work on my CPU exclusively?
• Am I creating effects that need extensive volumetric rendering or similar?
• Do I need extremely complicated materials or utility nodes such as Bevel, Particle Info, or IES Texture?

If you answered yes to any of those questions, use Cycles for your final render, but consider using EEVEE to preview your work. If none of those features are a concern, EEVEE is the way to get results quickly. An alternate third approach is to combine rendered aspects from Cycles and EEVEE, rendering the aspects best done realistically in Cycles and everything else in EEVEE.

As stated previously, many game engines use very similar techniques to EEVEE, so if you're interested in creating game art inside of Unity or Unreal, you'll have a much easier time transferring that knowledge from the concepts we'll cover in this book to your engine of choice.

Before we start implementing the mini-projects, we need to set up and customize Blender.

If for some reason you don't have Blender already set up on your computer, let's walk through the steps to install it and talk a little bit about general settings to make your life easier.

Download and install the latest version at blender.org. We'll be using the 3.0 release in this book, but if you have computer compatibility problems with that version, feel free to use 2.93, being aware that some aspects covered herein are not available in version 2.93.

After downloading and setting up, we should be ready to roll! Blender is a highly customizable program, though, so if you also want to take time to set up a different color palette or change your viewports, feel free to do that. Some important add-ons to activate in Blender that we will get a lot of use out of are good to set up too.

Navigate to Edit in the toolbar, then select Preferences.

Figure 1.2: The Preferences window

Let's add Import Images as Planes and Node Wrangler to start with, as we'll get a lot of use out of them. In the search bar, start typing the title of the add-on and it should appear in the window. These add-ons are pre-installed, so we don't have to import a package to activate them; we just have to activate them in the Blender Preferences window.

Figure 1.3: Customizing your Blender preferences

File structure

When downloading the GitHub files, it is incredibly important to keep the filenames the same. Blender references texture files, which means that it looks at a file path that you determine to add the textures files to our main Blender file. If Blender loses the file path, it will show up as bright pink in the Rendered and Material views.

Figure 1.4: The pink textures of death

If you find this happening to you, there's an easy fix. All you need to do is tell Blender the new place to find the textures:

1. Select File | External Data | Find Missing Files.

Figure 1.5: Find Missing Files menu

2. Toggle on the Settings menu on the right side.

Figure 1.6: Settings menu in Find Missing Files

3. Check the box that says Find All.

Figure 1.7: Find All

4. Navigate to the file location that contains all the textures for the Blender file.
5. Press Enter.

Blender will have found all the texture files, matched them to the original texture names, and refreshed them. Your Material and Rendered views should now be normal, with no bright pink textures.

An overview of the mini-projects

In order to feel like you're able to apply EEVEE to projects, we're going to be working through three different mini-projects so you can understand different applications, different techniques, and even how to blend EEVEE with other ways of rendering. I want you to have fun and look back after finishing this book knowing that you made something tangible and feel confident that you can apply the techniques to your own work.

Mini-project 1: Chapters 2, 3, and 4: Stylized render: We'll look at how to make something you'd see in a Studio Ghibli movie. The emphasis will be on Non-Physical Rendering (NPR) techniques and how to use EEVEE to support your personal style.

Figure 1.8: The final image from mini-project 1

Mini-project 2: Chapters 5, 6, 7, and 8: Environment scene: We'll look at new features such as Geometry Nodes and how to create more realistic style renders in EEVEE, including shortcuts and tips for faster rendering.

Mini-project 3: Chapters 9, 10, 11, and 12: Sci-fi scene: Kitbashing, rendering effects, and some extremely advanced aspects will be covered to create an out-of-this-world sci-fi scene.

We talked about the what and why of EEVEE in this chapter and outlined the contents of the book and what you'll be learning.

In the next chapter, we'll jump headfirst into the how of EEVEE, starting with our first mini-project.