Do you know Momo? He is a cute little monkey traumatized from being a second character in the Yo Frankie game project. Now what if you could carry Momo with you wherever you go? Your dream is closing to come true!

(wth are you writing about? — if I had an editor for my blog she would probably write that down)

Alex Ku is working in the Google Summer of Code 2012 to bring porting the Blender Game Engine to the Android platform. His work is progressing smoothly and there are already some visible-shareable results. Today he announced the first Blenderplayer.apk release, so I couldn’t help but testing it.

So it works, is that all? well, not really. There are still bugs and non-supported features. But skinning-armature, mouse click, glsl shaders (partially), physics they all work.

This sample file is part of the examples that go with the book I’m finishing up writing with Mike Pan. We are already on author review stage, so I should be able to talk more about it soon. Since I’m ‘giving the file away’ anyways I may as well explain it 🙂 This file showcase the use of dynamic parenting and bone parenting in BGE. It’s a good technique for character customization (as you can see with the hats).

Kudos for Alex Ku’s work and all the other developers that are helping this project,

From time to time I go to re-visit some projects I keep track of. This week I resumed working in a BGE (Blender Game Engine) project and decided to test if the file would work online. How so? Burster is a webplugin for the BGE that allows you to embed (and even secure) your .blend files in a website.

Burster got some really good upgrades lately, and not it works as a plugin is expected to (it tells the user a new version is online, suggest it to update, …). So what you see next is a screencapture of the Nereus Program (the project I’m working on, aka my day job) website.

BGE embed in a webpage, cool


Where you see this Baltic Visualization box, it’s a BGE application running. Cool, right? Before someone ask if this is all realtime let me explain. This is a fancy videoplayer made in the BGE to play videos (also made with Blender, but not necessarily). It’s all about point-click, animate, sync videos, … Next you can see the same file running in the BGE with Physics debug on.

Physics Visualization on

In order to have this going I had to:

  • pack all the textures in the file
  • open all the external scripts (originally in //scripts/) in the Blender Text Editor
  • remove all the ‘from . import’ from my scripts (the modules were calling each other)
  • fix all the python module controllers:
import bpy
for obj in
  for cont in
    if cont.type == 'PYTHON' and cont.mode == 'MODULE':
      cont.module = cont.module.replace('script.', '')


Note: not all modules/python functions are supported. Read the  are Security page in the Burster plugin site.

And I did all my tests locally. Mainly because I had to hardcode the address of the videos in my harddrive. I believe it may be (or it will at some point) possible to load videos from the server. I’m yet to find the right solution for this.

For questions on Burster please refer to their website 😉


A quick proof of concept test for the following technique:

  • environment re-mapped into the couch (sofa) – using IBL Toolkit
  • shape-key deformed and animated geometry

The final goal is to have the mapping handled internally by the render engine (Luxrender, although I used Cycles for this test). That way the light support geometry (e.g. the ceiling) can be transformed as well and the shadows should dance around.

They are two key elements here, to help  to produce this effect.

Sofa modeled using the background plate as reference

First of all we need to model the sofa geometry. For that we need to project the background in the 3d view as it will look in the final render. This is accomplished with a GLSL filter running on top of the 3dview.

Sofa UV mapped to the background panorama

The second part is to project the UV to match the original image. This would be really tricky if the object were in the edge of the image, but for this case is more doable. Both those problems are handled by IBLToolkit.

(and yes, I know the animation could be better and I could map only one of the pillows. This is a quick tech test though ;))

Render with ARLuxrender (branch of luxrender). A small teaser from a paper I’m writing with Aldo Zang (arlux developer). Try to guess what is real and what is fake here 😉

Render of the week - Blender + luxrender (arlux)


Background Plate + Lighting - captured environment


Against all the odds the sofas are real (so far it seems that most people tend to think they are the 3d elements). The carpet is pure 3D though (well, based of a 2D image actually). The spheres are also 3d, but we have a lot of the scene elements modeled as “support meshes”. That’s how the spheres can get the right reflection and lighting.

Also can you see what the carpet is covering ?
Ah, and this image has no post-processing or compositing on it. It comes blended with the real elements straight from the render.


* updated on 23.05.212 *

I’m writing an addon to help with scene reconstruction and lighting with IBL files. It also works as a handy workflow to expand panoramas with rendered elements.

It’s still in its Beta version and I’m evaluating it in production only now, so things will likely change.

quick render test

However if you want to take a first glance at it you will need:

Some screens:

blender, top right cycles rendering background, top left addon to add the background with glsl shader

ARLuxrender at work

Note: my goal is to use arluxrender as the final renderer, but all the modelling and editing is to be done inside Blender.

The original teaser with old screenshots can be found here:

For further discussions you can visit the Blender Artists forum thread as well.


If you do some real testing with it, please let me know your thoughts.


Project developed with Aldo Zang at the Visgraf lab

Not only of domes can an artist leave of. The fisheye mode shown in the previous post is sufficient for planetarium productions, but may not satisfy artists looking for ‘real’ fisheye lens. The most common lens found in today’s market are ‘equisolid’ lens (ref: HDRI for CGI).

After a productive holiday we now have something new to play with 😉

model by Jar-Artist

model by Jar-Artist

Models/scene gently provided by Jar-Artist


The proof is in the pudin

It’s “easy” to put up a nice artistic effect together and simply assume everything is working as it should. However, I wanted to make a system that could match the effect produced by real lens. For that I had to build a fail proof experiment. People not into coding may not know, but building a reliable testing and debugging setup is one of the keys for efficient coding. In my opinion it’s always worthy to put time into this. Note: this is also why Blender users can help a lot with bug fixing by simply building proper test files for the (also carefully/methodologically) reported bugs).

1 – Photoshooting

Take some pictures with a tripod rotating the camera on its center (the focal centre actually). We have been doing this for the past two weeks so it was smooth. Those pictures were taken by Aldo Zang in the Visgraf Lab at IMPA.

2 – Stiching

I don’t get tired of recommending Hugin for stitching and panorama making – This open source project sometimes works better even than autopano pro (a pretty good commercial alternative).


3 – Rendering

I put the panorama as a background plate, calibrated the aligment, added a simple floor + spheres. This was done with the (yet to be released) IBL Toolkit. Apart from that my Blender camera needs to match the settings of the real camera+lens I’m aiming at.

In this case all the pictures for the stitching were taken with a Nikon DX2S and a fisheye 10.5mm lens. I created new presets for the sensor dimensions and the render output.

4 – Results

I was quite pleased when I compared the rendered output with the original image. The aspects we should be looking at are only field of view and line distortion across the lens:


Also note the bottom left corner of the photo. This subtle shadowing is due to the vignetting of the lens. This is not present in the cycles render because I’m not implementing a real camera model (as shown here and here).


The complete patch can be found here. The core is the following function (simplified here). I elaborated this from the ‘classic’ fisheye equisolid formula: radius = 2 * focallens * sin ( angle / 2):

__device float3 fisheye_equisolid_to_direction(
float u, float v, float lens, float width, float height)
    u = (u - 0.5) * width;
    v = (v - 0.5) * height;

    float r = sqrt(u*u + v*v);
    float phi = acos(u/r);
    float theta = 2 * asin(r/(2 * lens));

    if (v < 0) phi = -phi;

    return make_float3(

I hope you like it. If you can share any work you did with this feature I would love to see it.

What if we could render fisheye images directly from Blender? Yesterday I found out about the Equirectangular mode in Cycles. It got me quite thrilled (it’s been awhile since I was waiting for that).

This is only possible because Cycles is a full ray tracer render engine. Every pixel in the image is generated from a ray coming from the camera to anywhere in the scene. Enough talking. A quick hack in the code and tcharan:


IBL background plate + ibl toolkit (alignment addon) + cycles 'use panorama' + fisheye patch

And the nice thing is, it previews in 3D just as well:

What comes next? I will talk with Brecht to see if there is any pending design to have this implemented as another camera option. I would like to have an option to set the angle (so we don’t need to do only 180 degrees fisheyes). And to toggle between hemispherical and angular fisheye modes.

I you compile your own Blender and want to try the patch, get it here or:

Index: intern/cycles/kernel/kernel_montecarlo.h
--- intern/cycles/kernel/kernel_montecarlo.h    (revision 45899)
+++ intern/cycles/kernel/kernel_montecarlo.h    (working copy)
@@ -215,13 +215,29 @@
 __device float3 equirectangular_to_direction(float u, float v)
+   u = (u - 0.5f) * 2.f;
+   v = (v - 0.5f) * 2.f;
+   float r = sqrt(u*u + v*v);
+   float theta = acosf(u/r);
+   if (v < 0.f) theta = -theta;
+   return make_float3(
+       sqrtf((1.f - r*r)),
+       -cosf(theta)*r,
+       sinf(theta)*r
+   );
    float phi = M_PI_F*(1.0f - 2.0f*u);
    float theta = M_PI_F*(1.0f - v);
    return make_float3(
 /* Mirror Ball <-> Cartesion direction */


* IBL from HDR Labs
* IBL Toolkit explained here.

There is a new addon landing. If you work with IBL in Blender for modeling come by soon. In the mean time enjoy the teaser (or poke me to provide some feedback and perhaps even join the alpha testing period).

IBL autosetup for Cycles and Luxrender

IBL Re-Aligment

Home made panoramas also work 😉

Point projection for calibration tweaking

Ideas, questions, comments, feel free to drop a line 😉

credits: Dalai Felinto, Mike Pan (Blender) and Sherman Lai (post processing)

 It’s available on Ted Talk the presentation from Dr. Pauly on the ocean’s shifting baseline. The key idea is that we need to stick to a baseline in order to develop a more reliable feeling on the changes that are happening.

But what happens when we can’t see the baseline? In this case the use of simulations – films and images – can be of great help. In the final slide of his presentation, Dr. Pauly showed an image to suggest a simulated ocean in 2010. You can see this at ~ 8:12.

This is not one my favourite works, but it’s an important one. This image was made based on a still from the first animation made in Blender I worked on, back from early 2009: The Life in The Chesapeake Bay. It’s nice to look back and admire how many chances to improve my work I got.

To work with science communication is a thrill, and to have this work recognized really makes my day. Note that this image is not being used only to illustrate a particular ocean scenario. The image is there to make a point. To reenforce the role of art in the understanding of our lives.

. . .

And yes, it’s always great to spread Blender around the world, even when people are unaware of it (I was going to do a screenshot from the Blender file but I can’t find it – it took TedTalk way too long to make the stream online available 😉


A belated thank you for Villy Christensen, Sherman Lai and Mike Pan for the opportunity of doing the  original project together. And for York University and the unexpected strike in late 2008 😉 God and his crooked lines, go figure.