---
title: Blender from a recovering POV-Ray user
date: "2011-02-07"
author: Chris Hodapp
tags:
- CG
- blender
---

{{< load-photoswipe >}}

This is about the tenth time I've tried to learn
[Blender](http://www.blender.org/). Judging by the notes I've
accumulated so far, I've been at it this time for about a month and a
half. From what I remember, what spurred me to try this time was
either known-Blender-guru Craig from [Hive13](http://www.hive13.org/)
mentioning
[Voodoo Camera Tracker](http://www.digilab.uni-hannover.de/docs/manual.html)
(which can output to a Blender-readable format), or my search for
something that would make it easier to do the 2D visualizations and
algorithmic art I always end up doing (and I heard Blender had some
crazy node-based texturing system...

Having a goal for what I want to render has been working out much
better than just trying to learn the program and hope the inspiration
falls into place (like it would appear all of my previous attempts
involved). This really has nothing to do with Blender specifically,
but really anything that is suitably complex and powerful. I have just
had this dumb tendency in the past few years to try to learn all of
the little details of a system without first having a motivation to
use them, despite this being completely at odds with nearly all things
I consider myself to have learned well. I'm seeing pretty clearly how
that approach is rather backwards, for me at least.

I took a lot of notes early on where I tried to map out a lot of its
features at a very high level, but most of this simply didn't matter -
what mattered mostly fell into place when I actually tried to make
something in Blender. However, knowing some of the fundamental
limitations and capabilities did help.

The interface is quirky for sure, but I am finding it to be pretty
intuitive after some practice. Most of my issues came from the big UI
overhaul after 2.4, as I'm currently using 2.55/2.56 but many of the
tutorials refer to the old version, and even official documentation
for 2.5 is sometimes nonexistent - but can I really complain? They
pretty clearly note that it is still in beta.

However, I'm starting to make sense of it. Visions and concepts that I
previously felt I had no idea how to even approach in Blender suddenly
are starting to feel easy or at least straightforward (what I'm
talking about more specifically here is how many things became trivial
once I knew my way around Bezier splines). This is good, because I've
got pages and pages of ideas waiting to be made. Some look like
they'll be more suited to [Processing](http://processing.org/) (like
the 2nd image down below) or
[OpenFrameworks](http://www.openframeworks.cc/) or one of the
too-many-completely-different-versions of Acidity I wrote.

<!-- TODO: Originals (get alt-text in?)
[![What I learned Bezier splines on, and didn&#39;t learn enough about texturing.](../images/hive13-bezier03.png){width=100%}](../images/hive13-bezier03.png)

[![This was made directly from some equations. I don't know how I'd do this in Blender.](../images/20110118-sketch_mj2011016e.jpg){width=100%}](../images/20110118-sketch_mj2011016e.jpg)
-->

{{< figure resource="hive13-bezier03.png" title="Hive13 bezier splines" caption="What I learned Bezier splines on, and didn't learn enough about texturing.">}}

{{< figure resource="20110118-sketch_mj2011016e.jpg" title="Processing sketch" caption="This was made directly from some equations. I don't know how I'd do this in Blender.">}}

[POV-Ray](http://www.povray.org) was the last program that I
3D-rendered extensively in (this was mostly 2004-2005, as my
much-neglected [DeviantArt](http://mershell.deviantart.com/) shows,
and it probably stress-tested the Athlon64 in the first new machine I
built more than any other program did). It's quite different from
Blender in most ways possible. POV-Ray makes it easy to do clean,
elegant, mathematical things, many of which would be either impossible
or extremely ugly in Blender. It's a raytracer; it deals with neat,
clean analytic surfaces, and tons of other things come for free (speed
is not one of them). However, I never really found a modeler for
POV-Ray that could integrate well with the full spectrum of features
the language offered, and a lot of things just felt really
kludgey. Seeing almost no progress made to the program, and being too
lazy to look into [MegaPOV](http://megapov.inetart.net/), I decided to
give up on it at some point. My attempts to learn something that
implemented RenderMan resulted mostly in me seeing how ingeniously
optimized and streamlined RenderMan is and not actually making
anything in it.

Blender feels really "impure" in comparison. It deals with ugly things
like triangle meshes and scanline rendering... ugly things that make
it vastly more efficient to accomplish many tasks. I'm quickly finding
better replacements for a lot of the techniques I relied on with
POV-Ray. For instance, for many repetitive or recursive structures, I
would rely on some simple looping or recursion in POV-Ray (as its
scene language was Turing-complete); this worked fairly well, but it
also meant that no modeler I tried would be able to grok the scene. In
Blender, I discovered the Array modifier; while it's much simpler, it
is still very powerful. On top of this, I have the interactivity of
the modeler still present. I've built some things interactively with
all the precision that I would have had in POV-Ray, but I built them
in probably 1/10 the time. That's the case for the two
work-in-progress Blender images here:

{{< figure resource="20110131-mj20110114b.jpg" title="20110131-mj20110114b" caption="This needs a name and a better background">}}

{{< figure resource="20110205-mj20110202-starburst2.jpg" title="20110205-mj20110202-starburst2" caption="This needs a name and a better background.">}}
