This is part 1 in a series of posts describing how to extend Blender to fit with your own content production process, specifically with regard to producing content for iPhone.
~ 3D Bookshelf ~
3D Bookshelf is the world's first fully 3D eBook Reader. Available now on the AppStore for iPhone & iPod touch!
Efficient content production is vital when it comes to reducing development costs. When I started reviewing our own internal processes and tools, I began to see some big opportunities to optimise our content production process, and at the same time dramatically reduce our costs.
This serves two purposes. Firstly, we save some money up front and satisfy our customers quicker. Second, clients will be more likely to license our system if they know they can also save on content production costs.
The first step towards this goal was to make use of Blender in our content production process.
Blender
Blender is an advanced open source 3D content creation application. It's been around for quite some time, but I've only recently given it a full evaluation. The primary benefits it has to offer over similar commercial packages like 3DS Max and Maya are:
- It's free. The commercial alternatives can cost anything between 1000 US dollars to about 3500 US dollars.
- It's really easy to use. It makes excellent use of keyboard short-cuts to allow you develop efficient processes.
- It's really easy to extend. For example, writing an exporter means creating one python file and adding it to a scripts folder. No C/C++ projects or solutions, no need for Visual Studio etc.
- It's feature rich. For example, apart from the standard modeling capabilities, it's integrated with Bullet physics. You can model scenes with water-flows and so on.
- It's cross platform. Linux, Mac OSX and Windows.
Extending with Python
The most significant component of our iPhone middleware engine (UtopiaGL) is the rendering engine. It uses a proprietary file format which ensures that the 3D content is both legal and also optimised for the engine. In order to load content produced with Blender into the rendering engine, it must first be exported to our proprietary format.
Writing exporters for Blender is extremely straightforward, so long as you know Python. I hadn't used Python for a long time so I had to do a quick refresher course. Luckily, the tutorial page on the Python site is about all you need to get up and running.
Once I had the shell of my exporter set up, I decide to add full logging support. Python has a feature rich logging system so this was very easy to add. I wrote a simple Log class to abstract away the underlying logging system so I could turn the logging completely off, if required. I also added the logging initialisation and shutdown code to this class.
class Log:
"""My log class."""
def initialize_logger(self, filepath, outputlog, loglevelindex):
"""Create the logger for the exporter."""
self.outputlog = outputlog
if self.outputlog:
logfilepath = filepath + '.log'
self.logger = logging.getLogger('BlenderUtopiaGLExporter')
loglevels = [logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR, logging.CRITICAL]
self.logger.setLevel(loglevels[loglevelindex])
self.logfilehandler = logging.FileHandler(logfilepath, 'w')
self.logger.addHandler(self.logfilehandler)
self.logger.info('Begin')
self.logger.info('Exporting to file: <%s>' % filepath)
def close_logger(self):
"""Close the logfilehandler to ensure the log file is closed."""
if self.outputlog:
self.logger.info('End')
self.logger.removeHandler(self.logfilehandler)
self.logfilehandler.flush()
self.logfilehandler.close()
def info(self, text):
if self.outputlog:
self.logger.info(text)
def debug(self, text):
if self.outputlog:
self.logger.debug(text)
def warning(self, text):
if self.outputlog:
self.logger.warning(text)
def error(self, text):
if self.outputlog:
self.logger.error(text)
def critical(self, text):
if self.outputlog:
self.logger.critical(text)
def exception(self, text):
if self.outputlog:
self.logger.exception(text)
Having good logging support can make things easier if you want to be able to support the exporter beyond a small development team. I was a little surprised not to see this approach being used by any of the exporters supplied with Blender. Most seem to opt for just outputting to the console.
Debugging the Exporter
Logging support will help identify the cause of issues reported by the exporter when it's used in the wild. But you'll want to be able to use the python debugger to track down problems during development and to investigate the root cause of problems identified in the logs. Unfortunately, this isn't as straightforward as it should be, but it is possible.
First, you need to get hold of Winpdb. This is a platform independent python debugger. You can find out more about setting this up at the Winpdb site. On windows, don't forget to add the PYTHONHOME environment variable to your system before you install. Mine is set to point to C:\Python26.
Once you have the python debugger set up, you must load your exporter script into the text editor built into Blender and run with ALT-P (press this while focus is in the text editor window). Add the following line to your script beforehand. This is what kicks off the embedded debugging session.
# To use embedded debugging and specify a hardcoded debug
# session password, use the following..
import rpdb2; rpdb2.start_embedded_debugger("password")
# Or, to use embedded debugging with an interactive password,
# use this instead of the above..
# import rpdb2; rpdb2.start_embedded_debugger_interactive_password()
Once the script has been run using the approach above, you'll be able to attach Winpdb to this session. Run %PYTHONHOME%\Scripts\winpdb and from the File menu select Attach. Enter "password" or what ever you've specified as the password for your debugging session and you'll be up and running in the debugger.
What's Next?
With a logging system in place and the ability to debug issues as they arise, it's possible to progress quickly through the development of python scripts from within Blender.
In Part 2 of this series I'll talk about how to add a UI to a Blender exporter. I'll also talk about the Material to Shader mismatch that must be dealt with when exporting 3D content from Blender to be used by OpenGL.
