TGEA/TGB, GCC-XML, and Python

I recently spent a couple weeks evaluating technology options for our next game. It felt good to be in this mode... though, I think it felt better coming to a resolution. :)

We're going with Torque Game Engine Advanced. I also really want to use Torque Game Builder for the 2D and minigame elements. TGB is really, really advanced compared to the stock TGE/TGEA 2D game stuff. I think this will work out great. We've got TGB rendering using Direct3D9 and I should be able to get them glued together nicely with Python.

We've gathered a fair amount of experience using Torque and Python together. I've been satisfied hooking into the TorqueScript console using its "everything is a string" design. This gives us access to console objects and the ability to expose Python functions to the console system. It is pretty basic and has worked out pretty well...

While evaluating Ogre and Qt as a possible solutions for rendering/GUI, I checked out their Python wrappers: Python-Ogre and PyQT. They both use GCC-XML to parse the C++ code, generate an XML representation, and automatically generate binding code from the XML. This was really interesting... and a long story short: it works out great with Torque.

Here's the process:

1. GCC-XML is used to compile the Torque header files and generate a full XML representation of the namespaces, classes, enumerations, etc

2. I wrote a custom tool to take the C++ information generated by GCC-XML, filter it using pygccxml, and automatically generate a SIP interface file

3. SIP then generates the wrapper sources. Importantly, the wrapper code is in 100% C++, tight, and quite efficient. SIP generates very good bindings compared to tools like SWIG, Boost::Python, etc. It was written for PyQT and that rocks :)

There are some really, really big wins over the "everything is a string" method of the previous PyTorque bindings. The biggest thing is that it is now possible to derive new script classes directly from Torque C++ classes with full inheritance, virtual methods, variable access, enumerations, structures, etc... it is all accessible. There's quite a bit of new functionality... some of which is described in the example below. This is really powerul stuff!!!

I've been looking into C# a bit too... and it would definitely be possible to generate similar bindings using GCC-XML. I will probably look into this more once IronPython (Microsoft's Python implementation built on the DLR) is more mature.... that won't be for this game :)

I've got a bit more work to do on the bindings... want to get an integration pass done with TGEA + TGB... and then, WOOHOO!!!

-Josh Engebretson
President
Prairie Games, Inc
MMOWorkshop.com

Here's some example usage

[b]#The pytgb.engine module is a (fast) Python C++ wrapper for TGB
#The module is automatically generated by a tool which leverages:
# GCC-XML: http://www.gccxml.org
# pygccxml: http://www.language-binding.net/pygccxml/pygccxml.html
# SIP: http://www.riverbankcomputing.co.uk/sip/index.php[/b]

from pytgb.engine import *
 
[b]#This isn't your daddy's TorqueScript... 
#You can derive script classes directly from C++ classes with full inheritance[/b]
class MyBitmapButtonCtrl(GuiBitmapButtonCtrl):
    def __init__(self):
        [b]#We can call into the C++ constructor![/b]
        GuiBitmapButtonCtrl.__init__(self)
        
        [b]#Fields can be set/read and feature automatic type conversion[/b]
        self.toolTip = "Click me!"
        self.visible = True
        
        [b]#C++ Enumerations are fully supported[/b]
        self.buttonType = self.ButtonTypePush
        
        [b]#Dynamic variables can be set and read [/b]
        self.setDataField("myDynamicValue", "", "Wahwahweewah!")
        
        [b]#Our own Python attributes can of course be added[/b]
        self.coolness = True

    [b]#It is possible to override any virtual class method... defined in C++![/b]
    def onAction(self):
        #We can call base classes implementation.
        self.parentClass.onAction(self) 
        print "I was clicked!"
        
    def inspectPostApply(self):
        self.parentClass.inspectPostApply(self)
        print "I've been applied!"
        
    def onAdd(self):
        self.parentClass.onAdd(self)
        print "I've been added!"

    [b]#We can also add entirely new methods (and expose them to the console system... or not!)[/b]        
    def setCoolness(self, value):
        self.coolness = value

    def getCoolness(self):
        return self.coolness
        
[b]#This behaves exactly like the IMPLEMENT_CONOBJECT macro C++ side.  
#It hooks our (dynamic) Python class into the Torque console system
#as a first class citizen![/b]
IMPLEMENT_CONOBJECT(MyBitmapButtonCtrl)

[b]#If you need to access methods from TorqueScript... 
#they can be exposed as ConsoleMethods (just like C++ side)
#Though, keep in mind that we can derive new Python classes from C++ classes.  
#So, you often wouldn't need to expose them for scripting purposes![/b]
ConsoleMethod(MyBitmapButtonCtrl.setCoolness, "(boolean)", 3, 3)    
ConsoleMethod(MyBitmapButtonCtrl.getCoolness, "boolean ()", 2, 2)    


[b]#Console functions can also be exposed[/b]
def HelloWorld():
    return "Hello World!"

[b]#Again, just like C++ side[/b]
ConsoleFunction(HelloWorld, "()", 1, 1)

[b]#Console funtions can also take arguments[/b]
def HelloWorldWithArgument(arg):
    return "Hello World with Argument: %s", arg
    
ConsoleFunction(HelloWorldWithArgument, "(argument)", 2, 2)

[b]#Let's initialize TGB (this includes any platform specific stuff, for fonts or whatever)[/b]
TGBInitialize()

[b]#We're running the main loop here... neat[/b]
while Game.isRunning():
    Game.mainLoop()
    
[b]#Once we're out of the main loop, it is time to shut the system down[/b]
Game.mainShutdown()

[b]#Finally, let's clean up any platform specifics[/b]
TGBShutdown()