I have been dabbling with a bit of 3D graphics programming for the last couple of
days; trying my hand at exporting models designed using the free 3D modelling software
Blender and getting them rendered using
OpenGL. Blender supports
a Python based scripting system where pretty
much everything in Blender can be accessed via Python scripts. So, along the way I
happened to see what Python was all about.
Exporting co-ordinates and normal vectors from Blender turned out to be fairly
straightforward. The following script does a quick and dirty job of producing
a file with all the numbers.
import Blender;
from Blender import *;
import Blender.Scene;
from Blender.Scene import *;
f = open( "co.csv", "w" )
scenes = Scene.Get(); # iterate thru all ze scenes
for sc in scenes:
objects = sc.getChildren(); # run thru all ze objects in this scene
for obj in objects:
if( obj.getType() != "Mesh" ): # we are interested only in meshes
continue;
print "exporting ", obj.name;
f.write( "# " + obj.name + "\n" ); # write the name of the object into
# the file; our renderer ignores
# lines starting with the '#' character
data = obj.getData(0, 1); # get co-ord data
for face in data.faces: # blender gives us the co-ords face-wise
#
# first we write out the normal vector for this polygon
#
f.write( "--" +
( '%f' % face.no.x ) + "," +
( '%f' % face.no.y ) + "," +
( '%f' % face.no.z ) + "\n" );
#
# now, write out all the vertices
#
for v in face.verts:
f.write( ( '%f' % v.co.x ) + "," +
( '%f' % v.co.y ) + "," +
( '%f' % v.co.z ) + "\n" )
f.close();
Nothing spectacular about the script really. Here's a screenshot of how Blender's
default suzanne monkey model looks like in my OpenGL program.
But one problem I quickly ran into was with regard to the scale of the co-ordinates
output by Blender. Sometimes Blender's data would cause the model to be rendered in
gigantic proportions and I'd have to render it far into the screen to make it fit inside
the window. What I really needed was a script that could post-process the
co-ordinates from Blender (basically, scale them down). I figured I'll write it in
Python (I could have done the scaling while exporting them from Blender of course, but
where's the fun in that!) and boy was it cool, or was it cool!
Python supports this super-cool feature called "List comprehension" that allows you
to succintly express operations that you want performed on elements in a collection. In
my case the file containing the list of co-ordinates looked like this:
-3.448783,-1.912737,-0.861946
-3.281278,-2.116843,-0.861946
-2.328871,-1.164436,-3.555760
-2.328871,-1.164436,-3.555760
-3.573251,-1.679874,-0.861946
-3.448783,-1.912737,-0.861946
And I wanted each of those numbers scaled down by a factor. The script turned
out to be remarkably short and it has elegance written all over it!
import string;
#
# open the source, dest files
#
src = open( "co.csv", "r" );
dst = open( "cos.csv", "w" );
#
# process each line
#
line = src.readline();
while( len( line ) > 0 ):
#
# process it only if it is a non-comment and non
# normal line
#
if( line[0] != "#" and line[0:2] != "--" ):
line = string.join( [ str( float( x ) * 0.25 )
for x in string.split( line, "," ) ], "," ) + "\n";
dst.write( line );
line = src.readline();
src.close();
dst.close();
Take special note of the highlighted line. Believe it or not, but that single line of code
splits a line of comma delimited text, converts each resulting token into a float,
multiplies it with 0.25, converts the value back into a string and then concatenates the list
of converted values into a comma delimited string again! Now I know that some of you're
thinking that we have traded off clarity of code for expressive power and that is true to an
extent here. But it isn't anymore obtuse than, say a regular expression! I guess it boils
down to personal preference at the end of the day.
I could have written 20 lines to do the same thing but I sure wouldn't be feeling
as pleased as I am feeling right now! Python rocks!
