Source/System/NodeCores/Groups/Bindings/Python/osgSetupBindings_OSGGroup.py.in

   1 # PyOpenSG is (C) Copyright 2005-2009 by Allen Bierbaum
   2 #
   3 # This file is part of PyOpenSG.
   4 #
   5 # PyOpenSG is free software; you can redistribute it and/or modify it under
   6 # the terms of the GNU Lesser General Public License as published by the Free
   7 # Software Foundation; either version 2 of the License, or (at your option)
   8 # any later version.
   9 #
  10 # PyOpenSG is distributed in the hope that it will be useful, but WITHOUT ANY
  11 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  12 # FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
  13 # more details.
  14 #
  15 # You should have received a copy of the GNU Lesser General Public License
  16 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 #
  18 #
  19 # This script is derived from gen_bindings.py, it contains all class specific
  20 # tasks for the OSGGroupLib for the integration with the OpenSG CMake system
  21 # (GV)
  22 #
  23
  24 from goodies import *
  25
  26 import osggen
  27 import splitGenHelper
  28
  29 def preScanSetup(gen_classes, fc_infos, core_mods, free_funcs, free_func_mods, exc_types):
  30
  31   return
  32
  33
  34
  35 def excludeFCDSetup(opensg_src_dir, fc_ignore_list, skip_fcds):
  36
  37   fc_ignore_list.extend(["ShadowMapEngine", "SimpleShadowMapEngine"])
  38
  39
  40 scp_temp = None
  41 spb_temp = None
  42 sp_temp  = None
  43
  44 def genTemplatesSetup(template_builder, tbuilder, non_fc_template_instances):
  45
  46   global scp_temp
  47   global spb_temp
  48   global sp_temp
  49
  50   scp_temp = tbuilder.Template("OSG::ContainerMixinHead<OSG::StageDesc>",
  51                                "StageContainerParent")
  52
  53   spb_temp = tbuilder.Template("OSG::TraversalValidationHandlerMixin< OSG::ContainerMixinHead<OSG::StageDesc> >",
  54                                "StageParentBase")
  55   sp_temp  = tbuilder.Template("OSG::StageParent", "StageParent")
  56
  57   return
  58
  59
  60
  61 def postScanSetup(osg, template_alias_db):
  62
  63   splitGenHelper.exposeTemplateType(scp_temp)
  64
  65   splitGenHelper.exposeTemplateType(spb_temp)
  66
  67   spb_temp_decl = spb_temp.decl
  68   spb_temp_decl["editSFUpdateMode"].exclude()
  69   spb_temp_decl["getSFUpdateMode"].call_policies = return_internal_reference()
  70
  71   spb_temp_decl.add_declaration_code("""
  72 namespace
  73 {
  74
  75 void destroyedCallback(bp::object callable, OSG::FieldContainer* fc,
  76                        const OSG::UInt64 i)
  77 {
  78    callable(fc, i);
  79 }
  80
  81 void wrapAddDestroyedFunctor(alias_StageParentBase* spb, bp::object func,
  82                              const std::string& createSymbol)
  83 {
  84    spb->addDestroyedFunctor(boost::bind(destroyedCallback, func, _1, _2),
  85                             createSymbol);
  86 }
  87
  88 }
  89 """)
  90   spb_temp_decl["addDestroyedFunctor"].exclude()
  91   spb_temp_decl.add_registration_code("""
  92       def("addDestroyedFunctor", wrapAddDestroyedFunctor,
  93           (bp::arg("func"), bp::arg("createSymbol")))
  94    """)
  95
  96   splitGenHelper.exposeTemplateType(sp_temp)
  97
  98   return
  99
 100
 101 def postGenClassesSetup(osg, mb):
 102
 103   return
 104
 105
 106
 107 def postFCDInfoSetup(osg, mb, adddition_exp):
 108
 109   splitGenHelper.handlAutoSlotReplace(osg, "DynamicStateGeneratorStageData")
 110
 111   c = osg.class_("RenderCallbackStage")
 112   c["addPreRenderFunctor"].exclude()
 113   c["addPostRenderFunctor"].exclude()
 114   c["fillPreRenderStore"].exclude()
 115   c["fillPostRenderStore"].exclude()
 116
 117   c.add_declaration_code("""
 118 namespace
 119 {
 120
 121 void renderCallback(bp::object callable, OSG::DrawEnv* drawEnv)
 122 {
 123    callable(drawEnv);
 124 }
 125
 126 void wrapAddPreRenderFunctor(OSG::RenderCallbackStage* self,
 127                              bp::object callable,
 128                              const std::string& createSymbol)
 129 {
 130    self->addPreRenderFunctor(boost::bind(renderCallback, callable, _1),
 131                              createSymbol);
 132 }
 133
 134 void wrapAddPostRenderFunctor(OSG::RenderCallbackStage* self,
 135                               bp::object callable,
 136                               const std::string& createSymbol)
 137 {
 138    self->addPostRenderFunctor(boost::bind(renderCallback, callable, _1),
 139                               createSymbol);
 140 }
 141
 142 inline void
 143 fillFunctorStore(const bp::list& callables,
 144                  OSG::RenderCallbackStage::RenderFunctorStore& store)
 145 {
 146    const int length = bp::extract<int>(callables.attr("__len__")());
 147    store.resize(length);
 148
 149    for ( int i = 0; i < length; ++i )
 150    {
 151       store[i] = boost::bind(renderCallback, callables[i], _1);
 152    }
 153 }
 154
 155 void wrapFillPreRenderStore(OSG::RenderCallbackStage* self, bp::list callables)
 156 {
 157    OSG::RenderCallbackStage::RenderFunctorStore store;
 158    fillFunctorStore(callables, store);
 159    self->fillPreRenderStore(store);
 160 }
 161
 162 void wrapFillPostRenderStore(OSG::RenderCallbackStage* self, bp::list callables)
 163 {
 164    OSG::RenderCallbackStage::RenderFunctorStore store;
 165    fillFunctorStore(callables, store);
 166    self->fillPostRenderStore(store);
 167 }
 168
 169 }
 170 """)
 171   add_member_function(c, "addPreRenderFunctor", "wrapAddPreRenderFunctor")
 172   add_member_function(c, "addPostRenderFunctor", "wrapAddPostRenderFunctor")
 173   add_member_function(c, "fillPreRenderStore", "wrapFillPreRenderStore")
 174   add_member_function(c, "fillPostRenderStore", "wrapFillPostRenderStore")
 175
 176
 177   c = osg.class_("CubeMapGenerator")
 178   c["initData"].call_policies = return_internal_reference()
 179
 180
 181   c = osg.class_("DynamicStateGenerator")
 182   c.add_declaration_code("""
 183 namespace
 184 {
 185
 186 OSG::FrameBufferObjectRecPtr
 187 wrapGetRenderTarget(OSG::DynamicStateGenerator* dsg)
 188 {
 189    return OSG::FrameBufferObjectRecPtr(
 190              OSG::FrameBufferObject::ObjTransitPtr(dsg->getRenderTarget())
 191           );
 192 }
 193
 194 }
 195 """)
 196
 197
 198   c["getRenderTarget"].exclude()
 199   c.add_registration_code('def("getRenderTarget", wrapGetRenderTarget)')
 200
 201   return