Changeset 20497

Show
Ignore:
Timestamp:
07/08/07 16:45:54 (1 year ago)
Author:
patrick
Message:

Updated for VR Juggler 2.3.11. Usage of OpenGL, OpenSG, and OSG are now much
cleaner. User code must import PyJuggler?.vrj.opengl, PyJuggler?.vrj.osg,
PyJuggler?.vrj.opensg and/or PyJuggler?.vrj.direct3d depending on what
application type is being written.

Bumped version to 1.3.5.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • PyJuggler/trunk/ChangeLog

    r20406 r20497  
    11DATE        AUTHOR      CHANGE 
    22----------- ----------- ------------------------------------------------------- 
     3Jul-08-2007 patrick     Updated for VR Juggler 2.3.11. Usage of OpenGL, OpenSG, 
     4                        and OSG are now much cleaner. User code must import 
     5                        PyJuggler.vrj.opengl, PyJuggler.vrj.osg, 
     6                        PyJuggler.vrj.opensg and/or PyJuggler.vrj.direct3d 
     7                        depending on what application type is being written. 
     8                        NEW VERSION: 1.3.5 
    39Jun-30-2007 patrick     Updated for enhancements to vrj::OsgApp in VR Juggler 
    410                        2.3.0. This allows subclasses of vrj.OsgApp to override 

  • PyJuggler/trunk/configure.ac

    r20405 r20497  
    416416GADGETEER_PATH([1.3.9], , 
    417417               [AC_MSG_ERROR([*** Gadgeteer is required for PyJuggler ***])]) 
    418 VRJUGGLER_PATH([2.3.4], , 
     418VRJUGGLER_PATH([2.3.11], , 
    419419               [AC_MSG_ERROR([*** VR Juggler is required for PyJuggler ***])]) 
    420420 
    …… 
    624624                 src/gadget/Makefile 
    625625                 src/jccl/Makefile 
    626                  src/osgapp/Makefile 
    627                  src/opensgapp/Makefile 
     626                 src/opengl/Makefile 
     627                 src/opensg/Makefile 
     628                 src/osg/Makefile 
    628629                 src/snx/Makefile 
    629630                 src/vpr/Makefile 

  • PyJuggler/trunk/dist/__init__.py

    r20406 r20497  
    66__all__     = ["vrj", "cluster", "gadget", "snx", "jccl", "vpr"] 
    77__build__   = 1 
    8 __version__ = '1.3.4.%d' % __build__ 
     8__version__ = '1.3.5.%d' % __build__ 
    99__date__    = string.join(string.split('$Date$')[1:3], ' ') 
    1010__author__  = 'Patrick Hartling <patrick@infiscape.com>' 

  • PyJuggler/trunk/dist/vrj.py

    r19730 r20497  
    66from __vrj import * 
    77 
    8 # Attempt to import everything from __osgapp into our namespace.  If it fails, 
    9 # then Open Scene Graph is not available for use.  For people who don't want 
    10 # to use vrj.OsgApp, this is fine.  For those who do, they have to have 
    11 # OSG and PyOSG installed. 
    12 try: 
    13    from __osgapp import * 
    14 except: 
    15    pass 
     8__doc__ = '''PyJuggler.vrj is a module that imports the symbols from 
     9PyJuggler.__vrj into its namespace. PyJuggler.vrj.opengl, PyJuggler.vrj.osg, 
     10and PyJuggler.vrj.opensg are optional modules, and importing one or both may 
     11fail if the module was not compiled or if the Open Scene Graph and/or OpenSG 
     12libraries are not available at run time. 
    1613 
    17 # Attempt to import everything from __opensgapp into our namespace. If it 
    18 # fails, then OpenSG is not available for use. For people who don't want to 
    19 # use vrj.OpenSGApp, this is fine. For those who do, they have to have OpenSG 
    20 # and PyOpenSG installed. 
    21 try: 
    22    from __opensgapp import * 
    23 except: 
    24    pass 
    25  
    26 __doc__ = '''PyJuggler.vrj is a module that imports the symbols from 
    27 PyJuggler.__vrj, PyJuggler.__osgapp, and PyJuggler.__opensgapp into its 
    28 namespace. PyJuggler.__osgapp and PyJuggler.__opensgapp are optional modules, 
    29 and importing one or both may fail if the module was not compiled or if the 
    30 Open Scene Graph and/or OpenSG libraries are not available at run time. 
    31  
    32 Refer to the PyJuggler.__vrj, PyJuggler.__osgapp, and PyJuggler.__opensgapp 
     14Refer to the PyJuggler.__vrj, PyJuggler.vrj.osg, and PyJuggler.vrj.opensg 
    3315modules for class documentation. 
    3416''' 

  • PyJuggler/trunk/examples/cxx/PyAppLoader/app.py

    r19730 r20497  
    99# import PyJuggler.vrj first. 
    1010from PyJuggler import * 
     11from PyJuggler import vrj.opengl 
    1112import gmtl 
    1213 
    1314 
    14 class SimpleGlApp(vrj.GlApp): 
     15class SimpleGlApp(vrj.opengl.App): 
    1516   mButton0 = gadget.DigitalInterface() 
    1617   mButton1 = gadget.DigitalInterface() 
    …… 
    2223 
    2324   def __init__(self): 
    24       vrj.GlApp.__init__(self) 
     25      vrj.opengl.App.__init__(self) 
    2526 
    2627   def init(self): 

  • PyJuggler/trunk/examples/cxx/PyExtApp/PyExtApp.h

    r19730 r20497  
    1212#include <gadget/Type/DigitalInterface.h> 
    1313#include <gadget/Type/PositionInterface.h> 
    14 #include <vrj/Draw/OGL/GlApp.h> 
     14#include <vrj/Draw/OpenGL/App.h> 
    1515 
    1616 
    …… 
    1818namespace python = boost::python; 
    1919 
    20 class PyExtApp : public vrj::GlApp 
     20class PyExtApp : public vrj::opengl::App 
    2121{ 
    2222public: 
    2323   PyExtApp(const std::string& moduleName) 
    24       : vrj::GlApp(), mModuleName(moduleName), mModule(), 
    25         mModuleDict(), mPythonFunc() 
     24      : vrj::opengl::App() 
     25      , mModuleName(moduleName) 
     26      , mModule() 
     27      , mModuleDict() 
     28      , mPythonFunc() 
    2629   { 
    2730      /* Do nothing. */ ; 

  • PyJuggler/trunk/examples/python/contextApp/contextApp.py

    r20488 r20497  
    1818# import PyJuggler.vrj first. 
    1919from PyJuggler import * 
     20import PyJuggler.vrj.opengl as vrj.opengl 
    2021 
    2122 
    22 class ContextApp(vrj.GlApp): 
     23class ContextApp(vrj.opengl.App): 
    2324   def __init__(self): 
    24       vrj.GlApp.__init__(self) 
     25      vrj.opengl.App.__init__(self) 
    2526 
    2627      self.mCubeDlHolder = vrj.GlContextData() 

  • PyJuggler/trunk/examples/python/pyopensgnav/pyopensgnav.py

    r20488 r20497  
    1717 
    1818from PyJuggler import * 
     19import PyJuggler.vrj.opengl as vrj.opengl 
     20import PyJuggler.vrj.opensg as vrj.opensg 
    1921 
    2022 
    21 class PyOpenSGNav(vrj.OpenSGApp): 
     23class PyOpenSGNav(vrj.opensg.App): 
    2224   def __init__(self, filename): 
    23       vrj.OpenSGApp.__init__(self) 
     25      vrj.opensg.App.__init__(self) 
    2426 
    2527      self.mFileToLoad = filename 
    …… 
    99101 
    100102   def contextInit(self): 
    101       vrj.OpenSGApp.contextInit(self) 
     103      vrj.opensg.App.contextInit(self) 
    102104      self._initGLState() 
    103105 
    …… 
    146148   def exit(self): 
    147149      self.mSceneRoot = None 
    148       vrj.OpenSGApp.exit(self) 
     150      vrj.opensg.App.exit(self) 
    149151 
    150152   def _initGLState(self): 

  • PyJuggler/trunk/examples/python/pyosgnav/pyosgnav.py

    r20488 r20497  
    1717 
    1818from PyJuggler import * 
     19import PyJuggler.vrj.opengl as vrj.opengl 
     20import PyJuggler.vrj.osg as vrj.osg 
    1921 
    2022 
    …… 
    135137         self.mNavData.mCurPos = pos 
    136138 
    137 class PyOsgNav(vrj.OsgApp): 
     139class PyOsgNav(vrj.osg.App): 
    138140   def __init__(self, filename): 
    139       vrj.OsgApp.__init__(self) 
     141      vrj.osg.App.__init__(self) 
    140142 
    141143      self.mFileToLoad = filename 
    …… 
    169171   # about PyOSG.osgUtil.SceneView. 
    170172   def configSceneView(self, newSceneViewer): 
    171       vrj.OsgApp.configSceneView(self, newSceneViewer) 
     173      vrj.osg.App.configSceneView(self, newSceneViewer) 
    172174 
    173175      newSceneViewer.getLight().setAmbient(osgVec4(0.3, 0.3, 0.3, 1.0)) 

  • PyJuggler/trunk/examples/python/simpleGL/simpleGL.py

    r20488 r20497  
    1818# import PyJuggler.vrj first. 
    1919from PyJuggler import * 
     20import PyJuggler.vrj.opengl as vrj.opengl 
    2021 
    2122 
    22 class SimpleGlApp(vrj.GlApp): 
     23class SimpleGlApp(vrj.opengl.App): 
    2324   def __init__(self): 
    24       vrj.GlApp.__init__(self) 
     25      vrj.opengl.App.__init__(self) 
    2526 
    2627      self.mButton0 = gadget.DigitalInterface() 

  • PyJuggler/trunk/src/Makefile.in

    r19730 r20497  
    55include @topdir@/src/common.mk 
    66 
    7 DIRS=   vpr jccl snx gadget cluster vrj 
     7DIRS=   vpr jccl snx gadget cluster vrj opengl 
    88 
    99ifeq (@HAVE_OSG@, Y) 
    10 DIRS+=  osgapp 
     10DIRS+=  osg 
    1111endif 
    1212 
    1313ifeq (@HAVE_OPENSG@, Y) 
    14 DIRS+=  opensgapp 
     14DIRS+=  opensg 
    1515endif 
    1616 
    …… 
    3030          done 
    3131        cp $(top_srcdir)/dist/__init__.py $(PYTHON_PACKAGES) 
    32         cp $(top_srcdir)/dist/vrj.py $(PYTHON_PACKAGES) 
    33  
     32        cp $(top_srcdir)/dist/vrj.py $(PYTHON_PACKAGES)/vrj/__init__.py 

  • PyJuggler/trunk/src/common-targets.mk.in

    r20409 r20497  
    130130 
    131131install: 
    132         $(MKINSTALLDIRS) $(PYTHON_PACKAGES) 
    133         cp -p $(MOD) $(PYTHON_PACKAGES) 
     132        $(MKINSTALLDIRS) $(PYTHON_PACKAGES)/$(MOD_SUBDIR) 
     133        cp -p $(MOD) $(PYTHON_PACKAGES)/$(MOD_SUBDIR) 
    134134 
    135135# Rule for generating a .cpp file from a .pyste file. 

  • PyJuggler/trunk/src/direct3d/_App.cpp

    r19730 r20497  
    88 
    99// Includes ==================================================================== 
    10 #include <vrj/Draw/Direct3D/D3dDrawManager.h> 
    11 #include <vrj/Draw/Direct3D/D3dApp.h> 
     10#include <vrj/Draw/Direct3D/DrawManager.h> 
     11#include <vrj/Draw/Direct3D/App.h> 
    1212#include <vrj/Kernel/Kernel.h> 
    1313#include <pyjutil/InterpreterGuard.h> 
    …… 
    2121{ 
    2222 
    23 struct vrj_D3dApp_Wrapper : vrj::D3dApp, wrapper<vrj::D3dApp> 
     23struct vrj_direct3d_App_Wrapper 
     24   : vrj::direct3d::App, wrapper<vrj::direct3d::App> 
    2425{ 
    25    vrj_D3dApp_Wrapper(vrj::Kernel* const& kernel = NULL) 
    26       : vrj::D3dApp(kernel) 
     26   vrj_direct3d_App_Wrapper(vrj::Kernel* const& kernel = NULL) 
     27      : vrj::direct3d::App(kernel) 
    2728   { 
    2829      /* Do nothing. */ ; 
    2930   } 
    3031 
    31    virtual ~vrj_D3dApp_Wrapper() 
     32   virtual ~vrj_direct3d_App_Wrapper() 
    3233   { 
    3334      /* Do nothing. */ ; 
    …… 
    3738   { 
    3839      vpr::DebugOutputGuard og(pyjDBG_CXX, vprDBG_VERB_LVL, 
    39                                "vrj_D3dApp_Wrapper::draw()\n", 
    40                                "vrj_D3dApp_Wrapper::draw() done.\n"); 
     40                               "vrj_direct3d_App_Wrapper::draw()\n", 
     41                               "vrj_direct3d_App_Wrapper::draw() done.\n"); 
    4142      PyJuggler::InterpreterGuard guard; 
    4243 
    …… 
    5354   void contextInit(LPDIRECT3DDEVICE9 renderDevice) 
    5455   { 
     56      vpr::DebugOutputGuard og( 
     57         pyjDBG_CXX, vprDBG_VERB_LVL, 
     58         "vrj_direct3d_App_Wrapper::contextInit()\n", 
     59         "vrj_direct3d_App_Wrapper::contextInit() done.\n" 
     60      ); 
     61      PyJuggler::InterpreterGuard guard; 
     62 
     63      try 
     64      { 
     65         if ( override contextInit = this->get_override("contextInit") ) 
     66         { 
     67            contextInit(renderDevice); 
     68         } 
     69         else 
     70         { 
     71            vrj::direct3d::App::contextInit(renderDevice); 
     72         } 
     73      } 
     74      catch (error_already_set) 
     75      { 
     76         PyErr_Print(); 
     77      } 
     78   } 
     79 
     80   void default_contextInit(LPDIRECT3DDEVICE9 renderDevice) 
     81   { 
     82      vrj::direct3d::App::contextInit(renderDevice); 
     83   } 
     84 
     85   void contextClose() 
     86   { 
     87      vpr::DebugOutputGuard og( 
     88         pyjDBG_CXX, vprDBG_VERB_LVL, 
     89         "vrj_direct3d_App_Wrapper::contextClose()\n", 
     90         "vrj_direct3d_App_Wrapper::contextClose() done.\n" 
     91      ); 
     92      PyJuggler::InterpreterGuard guard; 
     93 
     94      try 
     95      { 
     96         if ( override contextClose = this->get_override("contextClose") ) 
     97         { 
     98            contextClose(); 
     99         } 
     100         else 
     101         { 
     102            vrj::direct3d::App::contextClose(); 
     103         } 
     104      } 
     105      catch (error_already_set) 
     106      { 
     107         PyErr_Print(); 
     108      } 
     109   } 
     110 
     111   void default_contextClose() 
     112   { 
     113      vrj::direct3d::App::contextClose(); 
     114   } 
     115 
     116   void contextPreDraw() 
     117   { 
     118      vpr::DebugOutputGuard og( 
     119         pyjDBG_CXX, vprDBG_VERB_LVL, 
     120         "vrj_direct3d_App_Wrapper::contextPreDraw()\n", 
     121         "vrj_direct3d_App_Wrapper::contextPreDraw() done.\n" 
     122      ); 
     123      PyJuggler::InterpreterGuard guard; 
     124 
     125      try 
     126      { 
     127         if ( override contextPreDraw = this->get_override("contextPreDraw") ) 
     128         { 
     129            contextPreDraw(); 
     130         } 
     131         else 
     132         { 
     133            vrj::direct3d::App::contextPreDraw(); 
     134         } 
     135      } 
     136      catch (error_already_set) 
     137      { 
     138         PyErr_Print(); 
     139      } 
     140   } 
     141 
     142   void default_contextPreDraw() 
     143   { 
     144      vrj::direct3d::App::contextPreDraw(); 
     145   } 
     146 
     147   void contextPostDraw() 
     148   { 
     149      vpr::DebugOutputGuard og( 
     150         pyjDBG_CXX, vprDBG_VERB_LVL, 
     151         "vrj_direct3d_App_Wrapper::contextPostDraw()\n", 
     152         "vrj_direct3d_App_Wrapper::contextPostDraw() done.\n" 
     153      ); 
     154      PyJuggler::InterpreterGuard guard; 
     155 
     156      try 
     157      { 
     158         if ( override contextPostDraw = this->get_override("contextPostDraw") ) 
     159         { 
     160            contextPostDraw(); 
     161         } 
     162         else 
     163         { 
     164            vrj::direct3d::App::contextPostDraw(); 
     165         } 
     166      } 
     167      catch (error_already_set) 
     168      { 
     169         PyErr_Print(); 
     170      } 
     171   } 
     172 
     173   void default_contextPostDraw() 
     174   { 
     175      vrj::direct3d::App::contextPostDraw(); 
     176   } 
     177 
     178   void bufferPreDraw() 
     179   { 
     180      vpr::DebugOutputGuard og( 
     181         pyjDBG_CXX, vprDBG_VERB_LVL, 
     182         "vrj_direct3d_App_Wrapper::bufferPreDraw()\n", 
     183         "vrj_direct3d_App_Wrapper::bufferPreDraw() done.\n" 
     184      ); 
     185      PyJuggler::InterpreterGuard guard; 
     186 
     187      try 
     188      { 
     189         if ( override bufferPreDraw = this->get_override("bufferPreDraw") ) 
     190         { 
     191            bufferPreDraw(); 
     192         } 
     193         else 
     194         { 
     195            vrj::direct3d::App::bufferPreDraw(); 
     196         } 
     197      } 
     198      catch (error_already_set) 
     199      { 
     200         PyErr_Print(); 
     201      } 
     202   } 
     203 
     204   void default_bufferPreDraw() 
     205   { 
     206      vrj::direct3d::App::bufferPreDraw(); 
     207   } 
     208 
     209   void pipePreDraw() 
     210   { 
     211      vpr::DebugOutputGuard og( 
     212         pyjDBG_CXX, vprDBG_VERB_LVL, 
     213         "vrj_direct3d_App_Wrapper::pipePreDraw()\n", 
     214         "vrj_direct3d_App_Wrapper::pipePreDraw() done.\n" 
     215      ); 
     216      PyJuggler::InterpreterGuard guard; 
     217 
     218      try 
     219      { 
     220         if ( override pipePreDraw = this->get_override("pipePreDraw") ) 
     221         { 
     222            pipePreDraw(); 
     223         } 
     224         else 
     225         { 
     226            vrj::direct3d::App::pipePreDraw(); 
     227         } 
     228      } 
     229      catch (error_already_set) 
     230      { 
     231         PyErr_Print(); 
     232      } 
     233   } 
     234 
     235   void default_pipePreDraw() 
     236   { 
     237      vrj::direct3d::App::pipePreDraw(); 
     238   } 
     239 
     240   void init() 
     241   { 
    55242      vpr::DebugOutputGuard og(pyjDBG_CXX, vprDBG_VERB_LVL, 
    56                                "vrj_D3dApp_Wrapper::contextInit()\n", 
    57                                "vrj_D3dApp_Wrapper::contextInit() done.\n"); 
    58       PyJuggler::InterpreterGuard guard; 
    59  
    60       try 
    61       { 
    62          if ( override contextInit = this->get_override("contextInit") ) 
    63          { 
    64             contextInit(renderDevice); 
    65          } 
    66          else 
    67          { 
    68             vrj::D3dApp::contextInit(renderDevice); 
    69          } 
    70       } 
    71       catch (error_already_set) 
    72       { 
    73          PyErr_Print(); 
    74       } 
    75    } 
    76  
    77    void default_contextInit(LPDIRECT3DDEVICE9 renderDevice) 
    78    { 
    79       vrj::D3dApp::contextInit(renderDevice); 
    80    } 
    81  
    82    void contextClose() 
     243                               "vrj_direct3d_App_Wrapper::init()\n", 
     244                               "vrj_direct3d_App_Wrapper::init() done.\n"); 
     245      PyJuggler::InterpreterGuard guard; 
     246 
     247      try 
     248      { 
     249         if ( override init = this->get_override("init") ) 
     250         { 
     251            init(); 
     252         } 
     253         else 
     254         { 
     255            vrj::direct3d::App::init(); 
     256         } 
     257      } 
     258      catch (error_already_set) 
     259      { 
     260         PyErr_Print(); 
     261      } 
     262   } 
     263 
     264   void default_init() 
     265   { 
     266      vrj::direct3d::App::init(); 
     267   } 
     268 
     269   void apiInit() 
    83270   { 
    84271      vpr::DebugOutputGuard og(pyjDBG_CXX, vprDBG_VERB_LVL, 
    85                                "vrj_D3dApp_Wrapper::contextClose()\n", 
    86                                "vrj_D3dApp_Wrapper::contextClose() done.\n"); 
    87       PyJuggler::InterpreterGuard guard; 
    88  
    89       try 
    90       { 
    91          if ( override contextClose = this->get_override("contextClose") ) 
    92          { 
    93             contextClose(); 
    94          } 
    95          else 
    96          { 
    97             vrj::D3dApp::contextClose(); 
    98          } 
    99       } 
    100       catch (error_already_set) 
    101       { 
    102          PyErr_Print(); 
    103       } 
    104    } 
    105  
    106    void default_contextClose() 
    107    { 
    108       vrj::D3dApp::contextClose(); 
    109    } 
    110  
    111    void contextPreDraw() 
     272                               "vrj_direct3d_App_Wrapper::apiInit()\n", 
     273                               "vrj_direct3d_App_Wrapper::apiInit() done.\n"); 
     274      PyJuggler::InterpreterGuard guard; 
     275 
     276      try 
     277      { 
     278         if ( override apiInit = this->get_override("apiInit") ) 
     279         { 
     280            apiInit(); 
     281         } 
     282         else 
     283         { 
     284            vrj::direct3d::App::apiInit(); 
     285         } 
     286      } 
     287      catch (error_already_set) 
     288      { 
     289         PyErr_Print(); 
     290      } 
     291   } 
     292 
     293   void default_apiInit() 
     294   { 
     295      vrj::direct3d::App::apiInit(); 
     296   } 
     297 
     298   void exit() 
    112299   { 
    113300      vpr::DebugOutputGuard og(pyjDBG_CXX, vprDBG_VERB_LVL, 
    114                                "vrj_D3dApp_Wrapper::contextPreDraw()\n", 
    115                                "vrj_D3dApp_Wrapper::contextPreDraw() done.\n"); 
    116       PyJuggler::InterpreterGuard guard; 
    117  
    118       try 
    119       { 
    120          if ( override contextPreDraw = this->get_override("contextPreDraw") ) 
    121          { 
    122             contextPreDraw(); 
    123          } 
    124          else 
    125          { 
    126             vrj::D3dApp::contextPreDraw(); 
    127          } 
    128       } 
    129       catch (error_already_set) 
    130       { 
    131          PyErr_Print(); 
    132       } 
    133    } 
    134  
    135    void default_contextPreDraw() 
    136    { 
    137       vrj::D3dApp::contextPreDraw(); 
    138    } 
    139  
    140    void contextPostDraw() 
     301                               "vrj_direct3d_App_Wrapper::exit()\n", 
     302                               "vrj_direct3d_App_Wrapper::exit() done.\n"); 
     303      PyJuggler::InterpreterGuard guard; 
     304 
     305      try 
     306      { 
     307         if ( override exit = this->get_override("exit") ) 
     308         { 
     309            exit(); 
     310         } 
     311         else 
     312         { 
     313            vrj::direct3d::App::exit(); 
     314         } 
     315      } 
     316      catch (error_already_set) 
     317      { 
     318         PyErr_Print(); 
     319      } 
     320   } 
     321 
     322   void default_exit() 
     323   { 
     324      vrj::direct3d::App::exit(); 
     325   } 
     326 
     327   void preFrame() 
     328   { 
     329      vpr::DebugOutputGuard og( 
     330         pyjDBG_CXX, vprDBG_VERB_LVL, 
     331         "vrj_direct3d_App_Wrapper::preFrame()\n", 
     332         "vrj_direct3d_App_Wrapper::preFrame() done.\n" 
     333      ); 
     334      PyJuggler::InterpreterGuard guard; 
     335 
     336      try 
     337      { 
     338         if ( override preFrame = this->get_override("preFrame") ) 
     339         { 
     340            preFrame(); 
     341         } 
     342         else 
     343         { 
     344            vrj::direct3d::App::preFrame(); 
     345         } 
     346      } 
     347      catch (error_already_set) 
     348      { 
     349         PyErr_Print(); 
     350      } 
     351   } 
     352 
     353   void default_preFrame() 
     354   { 
     355      vrj::direct3d::App::preFrame(); 
     356   } 
     357 
     358   void latePreFrame() 
     359   { 
     360      vpr::DebugOutputGuard og( 
     361         pyjDBG_CXX, vprDBG_VERB_LVL, 
     362         "vrj_direct3d_App_Wrapper::latePreFrame()\n", 
     363         "vrj_direct3d_App_Wrapper::latePreFrame() done.\n" 
     364      ); 
     365      PyJuggler::InterpreterGuard guard; 
     366 
     367      try 
     368      { 
     369         if ( override latePreFrame = this->get_override("latePreFrame") ) 
     370         { 
     371            latePreFrame(); 
     372         } 
     373         else 
     374         { 
     375            vrj::direct3d::App::latePreFrame(); 
     376         } 
     377      } 
     378      catch (error_already_set) 
     379      { 
     380         PyErr_Print(); 
     381      } 
     382   } 
     383 
     384   void default_latePreFrame() 
     385   { 
     386      vrj::direct3d::App::latePreFrame(); 
     387   } 
     388 
     389   void intraFrame() 
     390   { 
     391      vpr::DebugOutputGuard og( 
     392         pyjDBG_CXX, vprDBG_VERB_LVL, 
     393         "vrj_direct3d_App_Wrapper::intraFrame()\n", 
     394         "vrj_direct3d_App_Wrapper::intraFrame() done.\n" 
     395      ); 
     396      PyJuggler::InterpreterGuard guard; 
     397 
     398      try 
     399      { 
     400         if ( override intraFrame = this->get_override("intraFrame") ) 
     401         { 
     402            intraFrame(); 
     403         } 
     404         else 
     405         { 
     406            vrj::direct3d::App::intraFrame(); 
     407         } 
     408      } 
     409      catch (error_already_set) 
     410      { 
     411         PyErr_Print(); 
     412      } 
     413   } 
     414 
     415   void default_intraFrame() 
     416   { 
     417      vrj::direct3d::App::intraFrame(); 
     418   } 
     419 
     420   void postFrame() 
     421   { 
     422      vpr::DebugOutputGuard og( 
     423         pyjDBG_CXX, vprDBG_VERB_LVL, 
     424         "vrj_direct3d_App_Wrapper::postFrame()\n", 
     425         "vrj_direct3d_App_Wrapper::postFrame() done.\n" 
     426      ); 
     427      PyJuggler::InterpreterGuard guard; 
     428 
     429      try 
     430      { 
     431         if ( override postFrame = this->get_override("postFrame") ) 
     432         { 
     433            postFrame(); 
     434         } 
     435         else 
     436         { 
     437            vrj::direct3d::App::postFrame(); 
     438         } 
     439      } 
     440      catch (error_already_set) 
     441      { 
     442         PyErr_Print(); 
     443      } 
     444   } 
     445 
     446   void default_postFrame() 
     447   { 
     448      vrj::direct3d::App::postFrame(); 
     449   } 
     450 
     451   void reset() 
    141452   { 
    142453      vpr::DebugOutputGuard og(pyjDBG_CXX, vprDBG_VERB_LVL, 
    143                                "vrj_D3dApp_Wrapper::contextPostDraw()\n", 
    144                                "vrj_D3dApp_Wrapper::contextPostDraw() done.\n"); 
    145       PyJuggler::InterpreterGuard guard; 
    146  
    147       try 
    148       { 
    149          if ( override contextPostDraw = this->get_override("contextPostDraw") ) 
    150          { 
    151             contextPostDraw(); 
    152          } 
    153          else 
    154          { 
    155             vrj::D3dApp::contextPostDraw(); 
    156          } 
    157       } 
    158       catch (error_already_set) 
    159       { 
    160          PyErr_Print(); 
    161       } 
    162    } 
    163  
    164    void default_contextPostDraw() 
    165    { 
    166       vrj::D3dApp::contextPostDraw(); 
    167    } 
    168  
    169    void bufferPreDraw() 
    170    { 
    171       vpr::DebugOutputGuard og(pyjDBG_CXX, vprDBG_VERB_LVL, 
    172                                "vrj_D3dApp_Wrapper::bufferPreDraw()\n", 
    173                                "vrj_D3dApp_Wrapper::bufferPreDraw() done.\n"); 
    174       PyJuggler::InterpreterGuard guard; 
    175  
    176       try 
    177       { 
    178          if ( override bufferPreDraw = this->get_override("bufferPreDraw") ) 
    179          { 
    180             bufferPreDraw(); 
    181          } 
    182          else 
    183          { 
    184             vrj::D3dApp::bufferPreDraw(); 
    185          } 
    186       } 
    187       catch (error_already_set) 
    188       { 
    189          PyErr_Print(); 
    190       } 
    191    } 
    192  
    193    void default_bufferPreDraw() 
    194    { 
    195       vrj::D3dApp::bufferPreDraw(); 
    196    } 
    197  
    198    void pipePreDraw() 
    199    { 
    200       vpr::DebugOutputGuard og(pyjDBG_CXX, vprDBG_VERB_LVL, 
    201                                "vrj_D3dApp_Wrapper::pipePreDraw()\n", 
    202                                "vrj_D3dApp_Wrapper::pipePreDraw() done.\n"); 
    203       PyJuggler::InterpreterGuard guard; 
    204  
    205       try 
    206       { 
    207          if ( override pipePreDraw = this->get_override("pipePreDraw") ) 
    208          { 
    209             pipePreDraw(); 
    210          } 
    211          else 
    212          { 
    213             vrj::D3dApp::pipePreDraw(); 
    214          } 
    215       } 
    216       catch (error_already_set) 
    217       { 
    218          PyErr_Print(); 
    219       } 
    220    } 
    221  
    222    void default_pipePreDraw() 
    223    { 
    224       vrj::D3dApp::pipePreDraw(); 
    225    } 
    226  
    227    void init() 
    228    { 
    229       vpr::DebugOutputGuard og(pyjDBG_CXX, vprDBG_VERB_LVL, 
    230                                "vrj_D3dApp_Wrapper::init()\n", 
    231                                "vrj_D3dApp_Wrapper::init() done.\n"); 
    232       PyJuggler::InterpreterGuard guard; 
    233  
    234       try 
    235       { 
    236          if ( override init = this->get_override("init") ) 
    237          { 
    238             init(); 
    239          } 
    240          else 
    241          { 
    242             vrj::D3dApp::init(); 
    243          } 
    244       } 
    245       catch (error_already_set) 
    246       { 
    247          PyErr_Print(); 
    248       } 
    249    } 
    250  
    251    void default_init() 
    252    { 
    253       vrj::D3dApp::init(); 
    254    } 
    255  
    256    void apiInit() 
    257    { 
    258       vpr::DebugOutputGuard og(pyjDBG_CXX, vprDBG_VERB_LVL, 
    259                                "vrj_D3dApp_Wrapper::apiInit()\n", 
    260                                "vrj_D3dApp_Wrapper::apiInit() done.\n"); 
    261       PyJuggler::InterpreterGuard guard; 
    262  
    263       try 
    264       { 
    265          if ( override apiInit = this->get_override("apiInit") ) 
    266          { 
    267             apiInit(); 
    268          } 
    269          else 
    270          { 
    271             vrj::D3dApp::apiInit(); 
    272          } 
    273       } 
    274       catch (error_already_set) 
    275       { 
    276          PyErr_Print(); 
    277       } 
    278    } 
    279  
    280    void default_apiInit() 
    281    { 
    282       vrj::D3dApp::apiInit(); 
    283    } 
    284  
    285    void exit() 
    286    { 
    287       vpr::DebugOutputGuard og(pyjDBG_CXX, vprDBG_VERB_LVL, 
    288                                "vrj_D3dApp_Wrapper::exit()\n", 
    289                                "vrj_D3dApp_Wrapper::exit() done.\n"); 
    290       PyJuggler::InterpreterGuard guard; 
    291  
    292       try 
    293       { 
    294          if ( override exit = this->get_override("exit") ) 
    295          { 
    296