In the morning, the attendees got a high level overview of what Blender can do, followed by a crash course on scientific visualization as applied to cellular biology and biochemistry as well as an extensive Python lesson.  In the afternoon, we moved to the computer lab and covered some of the Blender fundamentals, giving a lot of the attendees their first hands-on experience with Blender.

Even though this is my third time running such an event, there is still lots of rooms for improvement.  (For example, Blender 2.5′s UI was corrupt on some of the machines running older Ubuntu installations and Intel graphics chip, which made running the tutorials very challenging)

Photos of the event are on Pisaca.  Special thanks to the Pisa Linux User Group, without them, this workshop would not have been possible.

We use Blender to visualize protein motions and interactions, as well as making short animations that show the inside of a cell in a way that had never been seen with the unaided eye.  Because one key focus of the project is scientific accuracy, a lot of time is spent to ensure that the visualization is not only nice-looking, but also scientifically accurate. The process involves using numerous third-party programs to convert the input data (atomic coordinates of a protein) into something Blender can read. We use Python extensively to help facilitate data conversion between different formats.  The result is this video:

To really appreciate the video, it helps to understand the science going on behind it.  If you are a bit lost, have a look at the explanatory note associated with the video.  The video is made and rendered with Blender in 1080p HD, we also toyed with stereoscopic rendering with some very good result.  You can download the HD stereo version from the SciVis site.

Currently, we are working to build an interactive protein viewer inside Blender.  Using Blender 2.5 as the platform, we built an interface that will allow biologist to load a text description of any protein (a PDB file), and Blender will display the imported file in an intuitive interactive viewer. (As shown below)

Why Blender? Blender is especially suitable for this task for several reasons. Its python support allows us to accomplish a lot of custom features in relatively very little coding.  Having a game engine and a physics engine built-in means we can use do realtime visualization all from one software package.  Its open source nature allows us to easily modify (at least have access to) the source code if needed.

Above is our BioBlender interface for Blender 2.5.  The protein on the right is MLCK backbone, a 1845 residue long protein.

There is still a lot of work to be done.  Blender is currently having a hard time handling large proteins that contains thousands of amino acid groups, the interface turns sluggish with as the number of object increases.   Surprisingly, the game engine performance is very fast, it manages to maintain 20fps on a laptop even with a fancy ambient occlusion shader.

The Sintel team simply isn’t doing a good enough job, they are doing a GREAT job, and I am sure color grading is a planned part of their pipeline.  I just got carried away a bit playing with these images :D

Even though snow should be white, it doesn’t hurt to give it some tone to communicate the extreme coldness.  Blue works well in this case.

Wow, the team is doing a great job with facial animation.  This looks like a very somber scene, so it calls for some gloomy color.  I also added a dark gradient from the top, anime style.  Split toning is used to maintain the skintone while pushing the background to a cool blue.

I am speculating here, but I wanted to create a contrast between the safety of the warm tent and the harsh cold outside.  So things close to the fire is made warmer, things further away is pushed to a chilling blue.  The histogram is also very left-biased (dark), so I brightened up the image a bit.

Here, our main character isn’t emphasized enough in this (what I assume would be) high motion scene due to the similarity in color. I added a warming filter to highlight Sintel to convey the classic warm-vs-cold, good-vs-evil, light-vs-dark concept.

Just added some warmth to make the image look a bit more organic and less CG.

Everything is done in Lightroom, which is an awesome postprocessing package for photos, but the same effect can be easily achieved in Blender’s composite engine.  But seriously, Sintel is going to be amazing.

Around the Blender community, I have seen some people approach Python with certain skepticism.  (“It’s programming, it must be hard!”)  But Python is intuitive.  Writing Python code is the closest one can get to writing in an natural language.  Compare with other languages, there is no semicolons, no excessive symbols and punctuations, no long compilation process before one can test the code.  To make a program in Python is a think-type-run process.

Blender 2.49 Scripting

Perhaps due to my recently found enthusiasm, I was given a chance to take a sneak peak at Michel Anders’ upcoming book Blender 2.49 scripting.  Flipping through this ~300 page book, I realized this is exactly what I would have asked for as a beginner wanting to learn how to script in Blender.  This wonderfully comprehensive book covers everything from editing object to working with material to PyDrivers, Constraints, IPOs and shapekeys.  The only notable omission seems to be the game engine component.

Sure you can look at the Blender API documentation for help, but ingredient lists does not make a cookbook.  As there still isn’t a centralized repository for Blender scripts in the Blender community,Michel managed to bridge a rather large knowledge gap with this book that is filled with useful snippet of code.

Python is not as fast as C, or as ubiquitous as Javascript.  But one can accomplish a task in Python at a fraction of the code and mental power it takes in other languages.  Which makes it an ideal language to learn as a beginner.

Blender 2.49 Scripting is available from Packt Publishing.  I eagerly awaits a second edition of the book, no doubt slewed for Blender 2.5 and Python 3?

I never finished it. But ever since I posted the above video, I have been getting a lot of inquiries as to how I did the vehicle physics system in Blender. So here is a quick guide followed by the sample file.

The key to stable driving dynamics is to use the built-in PhysicsConstraints module within Blender’s game engine. PhysicsConstraints is a python wrapper for the Bullet physics engine. No any homemade setup I’ve seen is as good as what’s already provided by Bullet Physics. So we’ll use that.  Because there isn’t a graphical interface for setting up the vehicle physics yet in Blender, we need to write a few lines of Python script.  The key component is the car body object, which is linked to the 4 wheels through a logic brick connection so that the script would recognize the linked objects as wheels. (As you can see, all the actual driving logic is all happening on the car body, the wheels have no real logic brick attached).

The entire setup is a bit complex, since there is a mix of logic brick and python. Take a look at the sample file if you are lost.  When one runs the game, the following happens:

0. World is initialized, but we don’t really care about that here.

1. The car body is initalized, scripts.carInit() is ran. In this script, it initializes the car as a “vehicle constraint”, aka constraint type11, and stores it as a Python object called vehicle.  The same script then looks for the 4 wheel by access a gamelogic actuator with specific names (in this case, wheel1, wheel3, etc), then the script attaches the wheels to the car body using the settings specified in the script. Variables such as RollInfluence, SuspensionStiffness, and TyreFriction can all be set on a per-tire basis once the vehicle object is created. The job of carInit() is now done.  Our car body is now considered to be a vehicle by the Blender game engine, and it will behave like one.

2. Every frame, scripts.carHandler() is ran. This script does the actual moving of the car, it applies engine force and steering to the vehicle object. But this script gets the user input (keyboard sensor inputs) from another source. (See #3 below)   Vehicle objects have methods such as applyBreaking(), applyEngineForce(), getWheelRotation(), getNumWheels, which you can all call.

3. Every time a key is pressed, script.keyHandler() is ran. It figures out which key is pressed and set the intermediate variable so that #2 (i.e. scripts.carHandler) would know how much throttle to apply, where to steer, etc.  This script is separated from scripts.carHandler() not because of technical limitations, but by design so that it’s easier to manage the code.

That’s all there is to it.  If the script layout is a bit confusing, it’s because it is.  I originally intended it to be a bigger project, thus everything is separated into nice neat functions.  Again, you can DOWNLOAD the whole setup for Blender 2.5 from here.

Controls:
Arrow Keys to move the car
Space bar for handbrake
R to reset car if it flips over
number row 1,2,3,4,5 to change camera

Hope that helped.

As some of you might know, Vancouver is a pretty major hub for media and film production. It’s home to Electronic Arts, Ubisoft, Rainmaker, a whole slew of movie and TV VFX studios, and more recently, Pixar. The ~30 attendees all had very strong industry background, except me. (To my disappointment, no attendee has worked at Emeryville) But more importantly, it was apparent that they all consider Blender to be immature, with limited features, and see it as a toy more than a production-ready tool.

Blender: Just a toy

To be fair, this view on Blender is not surprising to me. But I was surprised by the overwhelming positive response after the talk, people were impressed with what Blender can do, they did not seem to expect a free software to be able to do so much, so fast. I demoed with a pre-release Blender 2.5, showcasing sculpting, compositing, rendering, the game engine, as well as some of my previous work. People were positively surprised to see what Blender can do, and few perhaps would even start to see Blender as an alternative to Autodesk’s offerings. Of course, no one in their right mind would change the production pipeline overnight from Maya/Max to Blender, but establishing Blender as more than a toy in the industry is good enough for now.

oooooooooo

What I realized from this presentation, and the point of this post, is that if we want to get more people to use try out Blender, we need to show them what it can do. Listing features, talking about code refactoring, or focusing on the open source advantages, is not going to sell the product. We need to inspire. Let’s show people what Blender is capable of through artwork and video demostrations.

Show. Don’t tell.

Since I started working on this car project, I’ve been getting a lot of positive feedback which really helped me move the project forward. It’s only fair that I return the favor and share a bit of what I learned here. (The full scene file including model, lighting, material and texture is available at my site)

The entire scene is rendered with the internal renderer in Blender 2.5.  As an artist, I want precise control over each elements of the scene, and the internal renderer allows me to iterate through test renders extremely rapidly to get the look I wanted. A photon-tracer like LuxRender would be too slow for me, with little extra return in image quality in my opinion.

Supposedly, like eyes to a human, car headlights defines the character of a car.  There is really no shortcut to making a sparkly looking headlight, I just modeled everything as geometry and applied a lot of reflection/refraction to the material.  As long as the geometry is there, all the cool effects happen automatically once you hit render.  i also placed a lamp at where the light should be, to throw in a bit of extra lumen.

A lot of that ‘cinematic’ look is due to post-production color correction.  Here you can see my postprocessing nodes setup.

For the animation, I rendered out the entire video at 1280×720, as PNGs.  Because PNG is only 24bit, extra dynamic range is lost, which made all the post-processing and cross-fading look half-assed.  Next time I’ll definitely render to floating-point EXR formats, which should help when I start applying more aggressive processings.  I also realized that a single computer is NEVER fast enough;  The 40 second clip would have taken 83 days to render on a single core, but with the help of 24 cores spanning across 4 PCs, I managed to push out the video in less than 4 days.  Dropbox made file synchronization embarrassingly simple.

A lot of the technical issues with the video (bad driving dynamics; black pixels; flickering) only cropped up last minute in the final rendering, at which point I am just too annoyed to re-render it.  So hopefully I’ll fix these distractions later and release a better version soon.

That’s it for now.  Hope you like what I have so far.

into something prettier:

The visualization data is coming from EwE6, a well-respected ecosystem modeling software.  Blender uses inputs such as biomass, water turbidity and light level to create a realtime visualization that allows the user to ‘swim’ around in the ocean, watch the schools of fish interact, and see their population change over time.

To accomplish all this, the project consists of 3 layers:

The server core does all the heavy computation while the visualization layer does all the graphics, AI, as well as user interaction.  To facilitate the communication across these two separate processes, a third layer (called the GameClient) is created, providing the bridge.

Being a Blender artist, my main focus is on the visualization layer: the Blender Game Engine.  In the following few posts, I will outline the process in creating this application, and describe some of the issues we faced.  Please leave a comment if you are interested, it will motivate me to write more :)