Benoit Paille (photographer) My favourite photographer, I love the amount of texture and colour he brings out in his portraits, and the beautiful simplicity of his work. He does some fantastic post-processing to bring out such amazing colours from his photos and whenever I’m working on a character render I look to his work for inspiration. The best places to ogle his work (depending on how you like to follow people) are DeviantArt and Flickr. You can also follow him on twitter.

James Gurney – Artist James Gurney is the fantastic painter behind the Dinotopia Books, who also writes about art in books and on his blog – Gurney Jouney. His blog in particular is a favourite of mine, as it combines some fantastic tips on art theory and various bits of Gurney’s work with a frankly inhuman frequency of updates. His watercolour sketches are always a joy to look at.

Selwy – Sculptor One of my favourite sculptors, and one who often posts some great resources on his site. In particular I recommend you check out his post and time-lapse video for his sculpt titled “Disunion” (pictured). It’s a fantastic thing to watch. he also has a great skull you can download from the downloads page of his site.

McBess (Illustrator)

Look at his drawings. LOOK AT THEM. He has a blog and stuff that you should read.

Aaron Diaz (Author, Dresden Codak)

Aside from producing my favourite (through until lately frustratingly slow to update) webcomic, Dresden Codak, Diaz also writes a fantastic blog on comic book art theory and character design that is always a great read. His superhero redesigns in particular shine out as an example of genuinely well thought out character design. Well worth a read.

All the modelling was done in blender 2.49, with some sculpting and texturing in blender 2.5. Most of the texturing was done in GIMP, with a whole bunch of textures from CGTextures.com. Rendering was done in V-Ray, thanks to Andrey Izrantsev’s fantastic blender 2.49 to vray exporter (though the newer 2.5 version is even better). Compositing was done in blender 2.5.

Click images for full size (1920×1080) versions.

Alternatively if you want to see them all nice and large you can view them on flickr.

Some blender screenshots for those interested:

Done for Gecko Animation Ltd, which I am now a part of!

A short experimental piece featuring a blend of Macro Photography and CG Animation. It started with an idea from David Parvin, of  Two Rivers Partnership, involving abstract forms and macro photography. With the footage shot, Jonathan Lax and myself worked on constructing a narrative from the forms we saw by combining CG elements with the original footage.

The CG elements were all done in blender (though some of the fluid sim stuff was done with RealFlow) and rendered in BI. Lots of animated node materials for the shifting surfaces and displacements.

Credits:
Director of Photography – David Parvin
Live Action Shoot – David Parvin, Jonathan Lax, Tobin Brett
CG Animation and Effects – Ben Simonds, Jonathan Lax
Editing – Jonathan Lax
Music and Sound FX – Alistair Lax

I’ve been playing around with Alchemy for a while now, and it’s a suberbly fun little program for coming up with visual ideas. For those of you who don’t know of it, its a 2D drawing application with all sorts of chaotic tools for creating shapes and patterns, that you can then start picking out shapes to develop ideas from. With the recent addition of .xcf import to blender, allowing you to import layered xcf files and automatically set them up for rendering, I started getting some ideas about combining alchemy and blender via GIMP. Here’s a little  video showing the process I used to create the images above, plus a hint at how I applied the same method in 3D to create an animated abstract 3D  character.

Here are a couple of other results (click the second for an animated walkcycle):

Anyway, let me know if you think of anything cool using this technique.

I created a couple of base meshes recently to give me something to start with when sculpting heads and bodies. I thought I’d make them avaliable. I’ve also included a GLSL matcap material I created that works quite well for sculpting. You’re free to use them for whatever you want. If you just want the matcap you can download the image directly to use in whatever application you prefer. Here’s a sculpt I made with the bust basemesh:

Download Basemeshes (zipped .blend format, at BlendSwap.com)

Download Basemeshes (zipped .obj format)

This work is licensed under a Creative Commons Attribution 3.0 Unported License.

When in edit mode, select the bones you want to change and put the following in a new text block, comment out any operations you dont want to perform, and hit alt-P to run the script:

import bpy

bones_list = bpy.data.armatures['RIG NAME'].bones
bones_selected = bpy.context.selected_bones

##Some tools for renaming bones and removing trailing numbers once you’ve renamed them. Handy when duplicating parts of your deform rig to create your control rigs. Switch bones_selected for bones_list to perform an operation on every bone in your rig.##

for item in bones_selected:
    item.name = item.name.replace(“DEF-”,”CON-”)   
    item.name = item.name.replace(“.001″,”") 
    item.name = item.name.replace(“.002″,”")

##Some tools for changing bone properties. use_deform turns off the bones “deform” option, always do this for bones you don’t want to directly deform your mesh (control/helper bones) . show_wire makes bone shapes visible in solid view mode, even if they only have edges.##

for item in bones_selected:
    item.use_deform = False
    item.show_wire = True

##Here are a couple of useful ones to try in pose mode. rotation_mode lets you set whether your bones use Euler or quarternion rotations, and custom_shape lets you set the bone shape used for all the bones you have selected. ##

bones_selected_pose = bpy.context.selected_pose_bones

for item in bones_selected_pose:
    item.rotation_mode = ‘XYZ’
    item.custom_shape = bpy.data.objects['NAME OF BONE SHAPE OBJECT']

I got Virgilio Vasconcelos’ new book, Blender 2.5 Animation Cookbook in the post from PACKT publishing the other day, and they asked me to write a review. I’ve  been doing a bit of rigging of my own lately, so it came along at a useful time for me; I’ve already picked up a couple of useful tips. It seems like a good guide to rigging so far, with info on most common rigging tasks, and I think enough information for beginners to get their heads around the topic.

Whilst the title suggests that the book centres on Animation, the book is really split about 50/50 between rigging and animation, which means as long as you can model it covers pretty much all you need to get animating, even if you don’t want to use a ready made rig like Mancandy or Pantin. The rigging portion takes you through rigging all the common aspects of rigging a biped, and whilst I’d differ on how to implement one or two aspects of some of the rigs, I’m by no means a champion rigger. It never hurts to know more than one method either. The book covers both creating and weight painting a deform rig, and then creating separate control rigs for different control methods (i.e. IK/FK), and keeps the two nice and separate (as they should be!). I think the lack of much discussion on using python for rigging is a bit of an oversight, given how useful knowing even a little bit of python can be when building a rig. Also a few of the controls that Virgilio outlines, like the isolation controls for the head and shoulders, only switch between on and off, and it isn’t difficult to make controls that smoothly interpolate between the two (go see Nathans mammoth rigging tutorials on CMI VFX for how to do that). Overall though the coverage is pretty solid though, and the book takes you through all the common hang ups, like creating a foot roll rig, stretchy and bendy limbs, rigging eyes, facial rigging with lattices and shapekeys, and creating interfaces for options like IK/FK switching, limb isolation and changing parent spaces. The book is particularly focussed on cartoony rigging, but it’s all applicable to more realistic rigs too.

On the animation side (which I know less about) the book teaches the layered technique, and has a nice progression through creating key poses, then extremes, breakdowns, and finally refining timing and tweaking curves in the graph editor. After demonstrating the basics the book moves on to a few common animation tasks, like having a character interact with props, creating walk cycles and animating speech. There’s also plenty of discussion of the principles of animation, which really is more important than the technical side. Anticipation, moving holds, squash and stretch, and symmetry are all talked about, and there are also some great tips on rendering silhouettes and mirrored previews of your animation to help spot your mistakes. There’s also a little discussion at the very end of the book on using grease pencil to plan and refine your animations. As I’m not much of an animator I can’t speak to any shortcomings the book might have but the book has a nice breadth, and I like the deference it pays to traditional animation too.

All the source .blend files for the book are available through Virgilio’s website, which are a great resource when trying to pick apart how a rig works so you can implement something in your own projects. If you’re interested in buying the book, I’d suggest you go and check them out. Also available is the main character rig “Otto”, used in the book. All in all the book should be a nice reference for anyone looking to start with rigging and animation. It’s an easy book to flip through and find the topic you’re stuck on, and whilst I disagreed with a couple of solutions, the book has an answer for most problems that might stump newbie blender-heads.

I’ve started doing some anatomy practice based on the idea outlined at the Art of Anatomy forums, to try and improve my anatomy knowledge. The aim is to study each part of the body piece by piece, and I’ve started with the feet.

Exercise One: Ref hunt and label anatomical landmarks.

Exercise Two: Draw from reference.

Exercise Three: Draw from memory.

Exercise Four: Sculpt

The Basics:

In real photography, depth of field is the effect whereby objects located away from the camera lenses plane of focus appear blurred. We can all read wikipedia (Depth of Field, Bokeh), so I’ll leave a deeper understanding of optics as an exercise for the reader. For the purposes of this post, there are two things we are concerned about: Achieving a result that is comparable with depth of field in real photography, and avoiding artefacts in still renders and animation. With this in mind, here is blenders defocus node:

This node takes two inputs: the image to be blurred (the yellow “image” input), and some way of telling the defocus node how much to blur different parts of that image (the grey value node labelled “Z”). The settings for the defocus nodes are as follows:

• Bokeh Type: Allows the user to set the shape of the aperture used to generate the bokeh effect. This allows you to mimic the effect that the aperture blades of a camera would have on the shape of the bokeh blur. The “angle” allows you to rotate the shape used.
• Gamma correction: Gamma corrects the image before blurring it, generally leave off if you have colour management turned on in your render settings, though it can give a nice effect sometimes of brightening the bokeh effect, which might be desirable.
• f-stop: With “Use Z-Buffer” enabled, this sets the amount of blur applied. Each halving of the default values will double the amount of blur.
• BThreshhold: Corrects artifacts around in-focus objects on a far-away (or non-existent) background. In general this can be left at one. Also note the tips later on always having a physical background where possible.
• Preview: For getting quick (but noisy) results to see how the size of the blur effect looks, turn this on. You’ll almost always want it switched of for final renders though. Handy when working with a large image and you’re still messing with compositor nodes. Samples is fairly self explanatory.
• Use Z-Buffer: Turn this on to use the cameras depth of field settings for the defocus. Remember to plug the z-pass from the render node directly into the defocus node. Turn it off to use any kind of mask or set the amount of blur manually using a value input.
• Z-Scale: With “Use Z-Buffer” turned off this multiplies the amount of blur caused by the Z input. If set to 1, a value of 1.0 from the input will give a blur radius of 1px. Turn up for more blurring.

Depending on how we want to achieve our depth of field effect, there are three different sources we can use for the latter input.

• Z-Buffer Method: This is the more straightforward method, in which we plug the z-buffer output from our render node straight into the Z input of the defocus node. This will then use the cameras Depth of Field settings (you can set it either to a used defined value, or to follow a specific object in the scene) to automatically generate the depth of field effect. This approach has several advantages:
  • It’s simple.
  • It allows the focal distance to be easily set and animated (for example to keep a moving object in focus).

  But it also poses some problems:

  • The amount foreground and background blur are not independently controllable.
  • Artifacts occur around foreground objects, where they border objects that are in focus, resulting in sharp edges on otherwise blurry objects. Note the sharp edges and artifacting on the out-of focus foreground area in the bottom left of the animated gif below.

The former issue is easy to solve, the latter one more difficult, but both require splitting apart the foreground and background blur and using a custom value input for the “Z” input of the defocus node. I’ll refer to this as a “mask” based method, as essentially what we will be creating is a mask input for the defocus node showing which parts we want blurred, and which should be in focus.

• Mask Method: In this method, we split the foreground and background blur and apply the defocus affect for each separately. First, we blur the background:

The “map to” node takes the z-buffer and turns it into a mask we can use for the defocus. Using the offset, we can set a distance from the camera (using negative value), ane with the size setting we can control the rate of falloff. Here is the result of the map to node below:

And here is it’s effect when used as the input for the blur node (don’t stare at this one waiting for it to animate… it wont).

Then we blur the foreground, using a more complex node setup that also fixes the artifacts around foreground objects.

The map to node works the same as before, isolating the foreground parts of the image (note that this time the scale value is negative, making the background black and the foreground white).  Then a ColourRamp node is used to flatten the values of the depth pass down from “float” values to something between 0 and 1. This is so that the blur applied later works correctly, but it does have the side effect that the foreground gets blurred a bit more evenly than the background. But given that the range involved is smaller anyway, you can kinda get away with this. You can always compensate with a higher size value on the defocus node if you need. The mask then gets dilated and blurred (so that some pixels around the edges of foreground objects are also defocussed, fixing the artifacts discussed above). The resulting mask looks like this (I’ve traced the outline of the mask before the dilate/blur to show what has been added):

This node is then used as the “Z” input for the second defocus node, which does the foreground blur on top of the already bacground-blurred image. The result:

As you can see the result doesn’t have the artifacts present in the more basic setup. However there are still some issues to think about:
• This method might not cope well with larger amounts of foreground blur due to the dilate/blur nodes.
• This is more difficult to animate than the basic method as the map to nodes now control what areas are in focus, instead of the handy camera properties. However if you still need to animate the DoF distance, these values can of course be keyed or even driven with constraints to provide similar functionality.
• This will render slower, as two (computationally intensive) defocus nodes have to be composited for each frame.

The third method for doing DOF blur is simpler to build, but takes a little longer to set up and render. It’s also not applicable in scenes where the transition between foreground and background are more continuous in nature. This is because we split the image into foreground, in-focus midground, and background layers and render and apply the defocus separately. On the bright side this works great for many standard kinds of shots. For this example the scene I’ve been using above isn’t so appropriate, so I’ll switch to something else:

• Layer Method: As with the mask method before, we start by blurring the background in the same way. But this time our foreground can be conveniently split into another layer entirely. Because of this we can quite easily do the foreground blur separately and just add it over the top. This way we can apply a uniform defocus to the foreground layer (no z input, just set the value), and not even have to worry about artefacts at the boundaries of objects.
  Background (not aliased, anti-aliasing occurs after all other nodes with FSAA on):
  
  Foreground:
  

• As discussed, there are some issues with artifacting when doing basic DoF, and to some extent you may always be fighting these.
• Bokeh in real physical cameras is a much more complex beast than the defocus node really allows for, and is affected and distorted by all manner of things. It interacts with lots of other aspects of a shot, such as vignetting and lens distortion, some of which you can fake with the compositor, others which may be more difficult or even impossible to apply as a post-processing effect. One reason for this is that real depth of field would actually require sampling points on surfaces that are occluded by geometry as the camera sees things, so it’s never going to match the real thing.

Further reading:

• Defocus node wiki documentation (blender 2.49, but all the settings are still the same).
• Depth of field on Wikipedia
• Bokeh on Wikipedia

Update: DoF distortion. 

My friend @Laxy pointed out a little addition that adds a nice extra touch to the last setup, which is a slight distortion caused by the depth of field around out of focus foreground objects. Far from being a CG artifact, this is visible if you hold up your finger in front of your eyes and look past it at something beyond. With your finger out of focus, you should see a very faint distortion of the in-focus objects behind it. I came up with a nice way of achieving this effect in blender, using a normal pass from the foreground layer and the displace node:

Because the normals of the foreground pass generally point away from the object around its  border, they can be blurred and used as an input for the displace node, which adds the distortion to the background before the foreground is laid over the top. You can see the result here (please note its  far far stronger than it should be, just so it’s obvious what I’m getting at):

Sculpted in ZBrush and rendered in blender. Just a rough sculpt but I liked the look of him.