Learn to create mist in Blender with Cycles for environments

When you’re creating expanse environments that are believable, one of the things you need take into account is the saturation of far away objects. As things get farther and farther away, they appear less saturated, almost like they’re covered in a slight mist. In order to create believable CG this is a very important detail to consider, particularly when creating your environments, as it greatly adds to the realism of your scene.

In this tutorial I’ll show you how to create an accurate, anti-aliased Z-pass with Cycles that can then be used to create this mist-like effect. This is done by creating a custom shader that makes use of the View Distance option of the Camera Data node for Cycles shaders.

Get Started with the Basics of Blender

If you’re new to Blender then you’re in the right place! Through this series I’m going to introduce you to the key basics of Blender, helping you get started with all the fundamentals that you need to begin working in Blender. This series is intended primarily for beginners that have a basic understanding of 3D.

I will be giving you a tour of the interface and navigation, modeling, animation, shading, lighting, and rendering with Cycles.

Where to go next with Blender and tutorials?

If you’ve completed this tutorial series and are eager for more training then here’s a few hand-picked tutorials just for you! To get the most value I encourage you to join our Citizen membership to get access to our complete tutorial library, including many exclusive training series that goes more in depth and cover challenging topics, like architectural visualization and and low poly asset creation.

Modeling: Modeling a Shipping Container and Modeling an M4 Assault Rifle

Animation: Intro to Character Rigging and Baker Charactering Animation Series

Physics and Dynamics: Shattering a Coffee Cup and Simulating and Rendering Fire

Texturing: Texturing a Truck Wheel and Rendering in Cycles and Introduction to Texturing in Cycles

Shading, Lighting, and Rendering: Rendering Realistic Headphones in Cycles and Rendering Stunning Long Hair in Blender

Compositing: Introduction to Compositing and Compositing Cycles Render Passes

Hair Rendering in Cycles Training Series

Blender 2.66 has been released (check out Jonathan’s overview) and with it  Cycles’ strand-rendering. This enables us to achieve believable hairstyles with relative ease, compared to the former Blender Internal method. However, shading and rendering is only half the battle. Strand editing and styling is where the war of believable hair is won or lost.

Create stunning hair for your characters in Blender by joining Citizen for just $10

In this multi-part citizen training series I’ll be walking you through my workflow from a bald-head mannequin to a long and flowing female hairstyle. Along the way we’ll be diving into particle hair systems, strand editing, and strand shading and rendering with Cycles.

The Challenge

Realistic long hairstyles are notoriously difficult to achieve with computer graphics. Several professional plugins have been developed for other apps that are strictly devoted to strand styling and rendering. With Blender’s built-in tools we’re able to get very specific with our groom. This works by creating multiple particle systems, dialing in the robust kinking and randomization settings, and finally rendering cylindrical strands complete with physically correct lighting. When combining these tools with real-world observation and patience you’ll be turning heads with your digital hairdo!

Changing hair color is easy!

Using the strand shader created during the tutorial, changing the color is very easy. This allows you to create a range of variations quickly.

Credits and License Info

Learn how to use the Light Path node for Cycles

Blender’s light path node is incredibly useful for all sorts of tasks, but it’s also a bit difficult to grasp at times and so many of us are left with no understanding of how to use it. This tutorial gives you an introduction to the light path node, showing you what can be done with it in Cycles. However, it’s easier to understand how to use this tool when we know how render engines work, so we will give you a basic introduction to raytracing. You’ll also learn why it works, and what you need to know in order to use it effectively.

We will be taking a look at how to control the influence of created materials on other objects in our scene. This includes changing the color of an object inside a reflection, in the shadow, through refraction, or any number of other ways. It also covers how to hide objects from specific light paths, such that it appears invisible in reflections, doesn’t cast shadows, etc.

Create fire in Blender with the Fire and Smoke Simulator

Using the simulation tools in Blender you can create stunning smoke and fire effects. These can be used to create rocket trails, explosions, campfires, candle flames, or even roiling expanses of smoke and flame.

Not a Citizen member? Get more cookies for just $10/month

In this tutorial we’re going to learn how to create a simple fire simulation that would be appropriate for a small bon fire. Fire simulation can be a bit daunting at first, in part due to the sheer number of parameters available for tweaking. Physics-based simulations always need quite a bit of experience to achieve the result you have in mind. During this tutorial we will share some tips and tricks for simulating and rendering fire.

Watch the final tutorial result:

Learn how to create a outdoor grassy scene in Blender with Cycles

In this tutorial series, go through the complete process of creating a grassy field with a cricket ball. The tutorial aims to teach important shading and texturing concepts that will enable you to theoretically be able to realistically shade and texture almost any object.

Through this part we go through shading and texturing the cricket ball as well as putting it into the scene we created in Part 1. We will also tweak the original lighting from that scene and do some simple composting. Some parts of the video might be a little hard to follow since it’s rather difficult to explain the thinking involved in figuring out what needs to be done to make a material and how to achieve that with nodes. I’ve done all I can to break it down logically and explain it as best as possible while not taking too long. I’m sure you’ve seen some screenshots of crazy node setups around, and I think those screenshots accurately portray the state of my mind while I create a material the first time – a total mess.

Join Citizen to get this tutorial and many more tutorials and training. Signing up is about the cost of fast food, just $10/month.

 Learn how to render realistic glass and other refractive materials in Blender with Cycles

Since the introduction of the Cycles render engine Blender users have had built-in access to physically correct glass rendering. Though it’s significantly faster and more accurate than what we’re used to with Blender Internal, refraction can still bog down render time and confuse us with it’s behavior. This tutorial is designed to be a relevant reference for anyone’s glass-rendering endeavors.

Join Citizen for this tutorial and many others for the cost of one fast food meal a month

WHAT YOU’LL LEARN:

Kent Trammell will walk you through the shading, lighting and rendering of refractive materials. First you will see how easy it can be to set up a basic glass shader with the Glass BSDF. Then you’ll see how to gain more control by building a custom glass shader with the Refractive and Glossy BSDFs. All along the way you’ll become familiar with optimizing Cycle’s render settings for best performance verses best result.  As a bonus you’ll be walked through a brilliant technique for faking believable caustics introduced by Bassam Kurdali on the Tube Open Movie blog.

Learn the basics of OSL scripting in Blender to create your own Cycles shaders 

One of the big new features of Blender 2.65 is the inclusion of the Open Shading Language (OSL) for the Cycles render engine. OSL has been developed by Sony Pictures Imageworks as a shading language for modern path-tracing render engines like Arnold or Cycles. The testbed for OSL, until now, has been a special version of the Arnold render engine used on the films The Amazing Spiderman, Men in Black 3, and Hotel Transylvania.

With Blender 2.65, Cycles has become the first publicly available render engine to support OSL.

Like this tutorial and want more? Consider joining Citizen for just $10 USD / month to support the site and get a PDF version of this tutorial

Introduction to OSL in Blender 2.65 – Part 3 – Integrating the Pie

This third installment of the Blender Cookie OSL introduction explains the internals of the Pie texture and how to improve the integration into the Cycles node system.

Basically an OSL shader (just like GLSL shaders and Renderman shaders) evaluates a point on a surface. The point is defined by a ray hitting the surface. It then performs a mathematical calculation on a property, like in our case the color. Consider a simple plane with object coordinates:

This is why you need texture coordinates to start a procedural texture. The shader needs to know relative to where to run the computation. The cool thing is that the shader is working like it’s doing the computations for all points simultaneously thus it works like some kind of 2D plotter. That essentially means you can use a large pool of mathematical functions to create patterns using OSL. A good tool to preview many of those functions is the Blender add-on 3D Function Surfaces: http://wiki.blender.org/index.php/Extensions:2.6/Py/Scripts/Add_Mesh/Add_3d_Function_Surface

But there is another implication. Remember how we left the turbulence-part out of the function for the final pattern? There was a good reason for this. We simply don’t need to calculate any kind of turbulence inside the shader when there is a vast variety of turbulence patterns right at our fingertips in Cycles. For example, the noise texture. If you use an external texture instead of a turbulence function from inside the shader for each point, the shader will look at the value of the external texture at that point and use it for the computation. So let’s remove one of the turbulence inputs, rename the other one to simply “Noise”. This way the user of the shader knows that they have to plug some kind of noise texture into that slot. Next, add the turb-part back to the output line:

#include "stdosl.h" 

shader node_Pie(

int Slices = 4,

float Hardness = 1,

float Angle = 0,

float Noise = 0,

point TextureVector = P,

output color Texture = 0

)

{

float angle_intern = 0;

    angle_intern = atan2(TextureVector[0],TextureVector[1]) + Angle*3.1415926/180.0;

    Texture = 0.5-0.5*sin(angle_intern * Slices - Noise - 0.5);

}

You can make the effect even stronger by adding a math node set to multiply:

Or change the appearance completely by using a different noise texture as input:

As you can see, OSL isn’t just making the writing of new shaders and textures easier, the fact that it is completely fit for data propagation through nodes is also making things a lot more versatile!

As a final brush-up, let’s remove the “Hardness” Input and the “– 0.5” at the end of the final line. The latter is simply rotating the pattern a little and not really needed:

#include "stdosl.h"

shader node_Pie(

int Slices = 4,

float Angle = 0,

float Noise = 0,

point TextureVector = P,

output color Texture = 0

)

{

float angle_intern = 0;

    angle_intern = atan2(TextureVector[0],TextureVector[1]) + Angle*3.1415926/180.0;

    Texture = 0.5-0.5*sin(angle_intern * Slices - Noise);

}

As a conclusion to this chapter for the Blender Cookie OSL Introduction here’s a comparison between the two textures in Blender Internal and OSL:

Lines of code for Blender Internal: 98

Lines of code for OSL: 15

Because OSL makes writing shaders really easy, we can expect a wealth of new shaders ported to OSL in the near future. Great times ahead for the Blender community!

There are literally thousands of shaders out there written in different shading languages that are just waiting to be ported to OSL. If you have a GLSL shader at hand and want to port it to OSL I recommend this short video tutorial by Thomas Dinges: http://www.openshading.com/tutorial-2-glsl-to-osl/

A nice resource of Renderman shaders that you can try to port to OSL can be found at http://www.renderman.org/RMR/RMRShaders.html

Additional OSL resources:

• OSL Introduction: http://code.google.com/p/openshadinglanguage/wiki/OSL_Introduction
• OSL Language Specification: https://github.com/imageworks/OpenShadingLanguage/blob/master/src/doc/osl-languagespec.pdf
• Tutorials and Links to example Shaders: http://www.openshading.com/
• Siggraph 2012 OSL Workshop Slides: http://blog.selfshadow.com/publications/s2012-shading-course/

Create the final composite of the shattered coffee cup for a seamless final animation

A very common task in visual effects is to break apart, shatter, and otherwise destroy objects. No matter if you’re smashing a car, demolishing a building, or creating some other destruction effect, it is no easy task and requires a lot of work and practice to get a convincing result.

In part 5 of this tutorial series learn how to composite the final animation in Blender by combining the unbroken and broken shards. This will be done with a series of techniques, primarily using the Difference Key node to detect changes in the render as the cup breaks.

Learn how to reduce noise and fireflies with caustics in Cycles

In this quick tip learn how to use the Light Paths node in Blender’s Cycles render engine to drastically reduce noise and fireflies when rendering with caustics. Normally caustics cause a lot of noise, and thus require a high number of samples to get a clean image. Because of this we commonly disable caustics to speed up the render times and get cleaner images. However, caustics also contribute a lot to the realism of a render as they are responsible for color bleed from bounce lighting.

By using Blender’s Light Path node to mix a glossy and diffuse shader we can drastically reduce the noise, keep caustics enabled, and produce a nicer image.

500 Samples, no caustics, glossy floor

500 samples, caustics, glossy floor

500 samples, caustics, glossy mixed with diffuse via Diffuse Ray on the floor