def wrap_Rotation(self):
simtk = self.mb.namespace('SimTK')
rot = simtk.class_('Rotation_<double>')
rot.alias = "Rotation"
rot.include()
rot.member_functions().exclude()
rot.constructors().exclude()
rot.member_operators().exclude()
# Expose only methods needed for movie maker for now
fn = rot.member_function('setRotationFromThreeAnglesThreeAxes')
fn.include()
fn.call_policies = call_policies.return_internal_reference()
simtk.enum('BodyOrSpaceType').include()
simtk.class_('CoordinateAxis').include()
simtk.class_('CoordinateAxis').constructors(arg_types=[None]).exclude()
simtk.class_('CoordinateAxis').member_function(
'crossProduct').exclude()
simtk.variable('XAxis').include()
simtk.variable('YAxis').include()
simtk.variable('ZAxis').include()
fn = rot.member_function('convertThreeAxesRotationToThreeAngles')
fn.include()
fn = rot.member_function('setRotationFromQuaternion')
fn.include()
fn.call_policies = call_policies.return_internal_reference()
def wrap_ImageWindow(self):
self.mb.class_('ImageWindowReceiver').exclude()
self.mb.class_('ImageWindowDispatcher').exclude()
cls = self.mb.class_('ImageWindow')
cls.include()
cls.variables('handle').exclude()
# get/set image
fn1 = cls.member_function("getImage")
fn1.call_policies = call_policies.return_internal_reference()
fn2 = cls.member_function("setImage")
fn2.call_policies = call_policies.with_custodian_and_ward(1,2)
cls.add_property( 'image'
, cls.member_function( 'getImage' )
, cls.member_function( 'setImage' ) )
# get/set name
cls.add_property( 'name'
, cls.member_function( 'getName' )
, cls.member_function( 'setName' ) )
# 3D window controls
fn = cls.member_function("getView3DControl")
fn.call_policies = call_policies.return_internal_reference()
cls.add_property('view3DControl', fn)
fn = cls.member_function("getLocalView3DControl")
fn.call_policies = call_policies.return_internal_reference()
cls.add_property('localView3DControl', fn)
fn = cls.member_function("getTriviewControl")
fn.call_policies = call_policies.return_internal_reference()
cls.add_property('triViewControl', fn)
# exclude constructor that takes void* argument
for ctor in cls.constructors(arg_types = [None]):
arg_t = ctor.argument_types[0]
if (declarations.is_pointer(arg_t)):
ctor.exclude()
def ParseHUD(self, mb):
# CHud
cls = mb.class_('CHud')
cls.include()
if self.settings.branch == 'swarm':
mb.free_function('GetHud').include()
mb.free_function('GetHud').call_policies = call_policies.return_value_policy(call_policies.reference_existing_object)
else:
mb.variables('gHUD').include()
cls.member_functions( 'FindElement' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
if self.settings.branch != 'swarm': # ASW should use HudIcons() / CHudIcons
#cls.member_functions( 'GetIcon' ).call_policies = call_policies.return_value_policy( call_policies.manage_new_object )
#cls.member_functions( 'AddUnsearchableHudIconToList' ).call_policies = call_policies.return_value_policy( call_policies.manage_new_object )
#cls.member_functions( 'AddSearchableHudIconToList' ).call_policies = call_policies.return_value_policy( call_policies.manage_new_object )
# The HUD only cleans up when you close the game, so internal references should't be a problem.
cls.member_functions( 'GetIcon' ).call_policies = call_policies.return_internal_reference()
cls.member_functions( 'AddUnsearchableHudIconToList' ).call_policies = call_policies.return_internal_reference()
cls.member_functions( 'AddSearchableHudIconToList' ).call_policies = call_policies.return_internal_reference()
cls.variables('m_HudList').exclude()
if self.settings.branch == 'swarm':
cls.member_functions('GetHudList').exclude()
cls.member_functions('GetHudPanelList').exclude()
cls = mb.class_('CHudElement')
cls.include()
cls.member_functions('GetName').exclude()
cls.variables('m_pyInstance').exclude()
cls.member_functions('SetActive').virtuality = 'not virtual'
cls.member_functions('IsActive').virtuality = 'not virtual'
cls.member_functions('ShouldDraw').virtuality = 'not virtual' # TODO: What if we need better control in Python?
cls.member_functions('ProcessInput').virtuality = 'not virtual' # TODO: Do we ever need this in Python?
cls = mb.class_('CPyHudElementHelper')
cls.include()
cls.rename('CHudElementHelper')
cls.member_functions('GetNext').exclude()
# HudIcons
if self.settings.branch == 'swarm':
cls = mb.class_('CHudIcons')
cls.include()
# FIXME
cls.member_functions( 'GetIcon' ).call_policies = call_policies.return_internal_reference()
#cls.member_functions('GetIcon').call_policies = call_policies.return_value_policy(call_policies.reference_existing_object)
#cls.member_functions('GetIcon' ).call_policies = call_policies.return_value_policy( call_policies.manage_new_object )
cls.member_functions('AddUnsearchableHudIconToList').exclude()
cls.member_functions('AddSearchableHudIconToList').exclude()
#cls.member_functions('AddUnsearchableHudIconToList').call_policies = call_policies.return_value_policy( call_policies.manage_new_object )
#cls.member_functions('AddSearchableHudIconToList').call_policies = call_policies.return_value_policy( call_policies.manage_new_object )
mb.free_function('HudIcons').include()
mb.free_function('HudIcons').call_policies = call_policies.return_value_policy(call_policies.reference_existing_object)
# CHudTexture
cls = mb.class_('CHudTexture')
cls.include()
cls.variables().exclude()
def set_call_policies( self ):
boost_ns = self.__mb.namespace( 'boost' )
engine_funcs = boost_ns.member_functions( name="engine"
, function=lambda decl: not decl.has_const )
engine_funcs.call_policies = call_policies.return_internal_reference()
distribution_funcs = boost_ns.member_functions( name="distribution"
, function=lambda decl: not decl.has_const )
distribution_funcs.call_policies = call_policies.return_internal_reference()
def set_call_policies(self):
boost_ns = self.__mb.namespace('boost')
engine_funcs = boost_ns.member_functions(
name="engine", function=lambda decl: not decl.has_const)
engine_funcs.call_policies = call_policies.return_internal_reference()
distribution_funcs = boost_ns.member_functions(
name="distribution", function=lambda decl: not decl.has_const)
distribution_funcs.call_policies = call_policies.return_internal_reference(
)
def customize( self, mb ):
event_clss = mb.classes( lambda cls: cls.name in ( 'event_t', 'do_nothing_t' ) )
for cls in event_clss:
cls.exposed_class_type = cls.EXPOSED_CLASS_TYPE.WRAPPER
cls.held_type = 'std::auto_ptr< %s >' % cls.wrapper_alias
cls.add_registration_code( register_sptr % 'std::auto_ptr< %s >' % cls.decl_string, False )
cls.add_registration_code( impl_conv_code % { 'from' : cls.wrapper_alias
, 'to' : cls.decl_string }
, False)
for base in cls.recursive_bases:
if base.access_type == 'public':
cls.add_registration_code( #from class to its base
impl_conv_code % { 'from' : cls.decl_string
, 'to' : base.related_class.decl_string }
, False)
cls.add_registration_code( #from wrapper to clas base class
impl_conv_code % { 'from' : cls.wrapper_alias
, 'to' : base.related_class.decl_string }
, False)
simulator = mb.class_( 'simulator_t' )
simulator.member_function( 'get_event' ).call_policies \
= call_policies.return_internal_reference()
schedule = mb.member_function( 'schedule' )
schedule.add_transformation( ft.transfer_ownership(0), alias='schedule' )
def customize( self, mb ):
event_clss = mb.classes( lambda cls: cls.name in ( 'event_t', 'do_nothing_t' ) )
for cls in event_clss:
cls.add_wrapper_code( decref_code % { 'cls' : cls.wrapper_alias } )
cls.add_wrapper_code( 'PyObject* m_pyobj;' )
cls.set_constructors_body( 'm_pyobj=0;' )
cls.mem_fun( 'notify' ).add_override_precall_code( incref_code )
cls.mem_fun( 'notify' ).add_default_precall_code( incref_code )
cls.held_type = 'std::auto_ptr< %s >' % cls.wrapper_alias
cls.add_registration_code( impl_conv_code % { 'from' : cls.wrapper_alias
, 'to' : cls.decl_string }
, False)
for base in cls.recursive_bases:
if base.access_type == 'public':
cls.add_registration_code( #from class to its base
impl_conv_code % { 'from' : cls.decl_string
, 'to' : base.related_class.decl_string }
, False)
cls.add_registration_code( #from wrapper to clas base class
impl_conv_code % { 'from' : cls.wrapper_alias
, 'to' : base.related_class.decl_string }
, False)
schedule = mb.mem_fun( 'schedule' )
schedule.add_transformation( ft.transfer_ownership(0), alias='schedule' )
simulator = mb.class_( 'simulator_t' )
simulator.mem_fun( 'get_event' ).call_policies \
= call_policies.return_internal_reference()
def customize(self, mb):
event_clss = mb.classes(lambda cls: cls.name in ("event_t", "do_nothing_t"))
for cls in event_clss:
cls.add_destructor_code(decref_code)
cls.add_wrapper_code("PyObject* m_pyobj;")
cls.set_constructors_body("m_pyobj=0;")
cls.mem_fun("notify").add_override_precall_code(incref_code)
cls.mem_fun("notify").add_default_precall_code(incref_code)
cls.held_type = "std::auto_ptr< %s >" % cls.wrapper_alias
cls.add_registration_code(impl_conv_code % {"from": cls.wrapper_alias, "to": cls.decl_string}, False)
for base in cls.recursive_bases:
if base.access_type == "public":
cls.add_registration_code( # from class to its base
impl_conv_code % {"from": cls.decl_string, "to": base.related_class.decl_string}, False
)
cls.add_registration_code( # from wrapper to clas base class
impl_conv_code % {"from": cls.wrapper_alias, "to": base.related_class.decl_string}, False
)
schedule = mb.mem_fun("schedule")
schedule.add_transformation(ft.transfer_ownership(0), alias="schedule")
simulator = mb.class_("simulator_t")
simulator.mem_fun("get_event").call_policies = call_policies.return_internal_reference()
def customize(self, mb):
event_clss = mb.classes(lambda cls: cls.name in
('event_t', 'do_nothing_t'))
for cls in event_clss:
cls.add_destructor_code(decref_code)
cls.add_wrapper_code('PyObject* m_pyobj;')
cls.set_constructors_body('m_pyobj=0;')
cls.mem_fun('notify').add_override_precall_code(incref_code)
cls.mem_fun('notify').add_default_precall_code(incref_code)
cls.held_type = 'std::auto_ptr< %s >' % cls.wrapper_alias
cls.add_registration_code(
impl_conv_code % {
'from': cls.wrapper_alias,
'to': cls.decl_string
}, False)
for base in cls.recursive_bases:
if base.access_type == 'public':
cls.add_registration_code( #from class to its base
impl_conv_code % { 'from' : cls.decl_string
, 'to' : base.related_class.decl_string }
, False)
cls.add_registration_code( #from wrapper to clas base class
impl_conv_code % { 'from' : cls.wrapper_alias
, 'to' : base.related_class.decl_string }
, False)
schedule = mb.mem_fun('schedule')
schedule.add_transformation(ft.transfer_ownership(0), alias='schedule')
simulator = mb.class_('simulator_t')
simulator.mem_fun( 'get_event' ).call_policies \
= call_policies.return_internal_reference()
def customize( self, mb ):
event_clss = mb.classes( lambda cls: cls.name in ( 'event_t', 'do_nothing_t' ) )
for cls in event_clss:
cls.exposed_class_type = cls.EXPOSED_CLASS_TYPE.WRAPPER
cls.held_type = 'std::auto_ptr< %s >' % cls.wrapper_alias
cls.add_registration_code( register_sptr % 'std::auto_ptr< %s >' % cls.decl_string, False )
cls.add_registration_code( impl_conv_code % { 'from' : cls.wrapper_alias
, 'to' : cls.decl_string }
, False)
for base in cls.recursive_bases:
if base.access_type == 'public':
cls.add_registration_code( #from class to its base
impl_conv_code % { 'from' : cls.decl_string
, 'to' : base.related_class.decl_string }
, False)
cls.add_registration_code( #from wrapper to clas base class
impl_conv_code % { 'from' : cls.wrapper_alias
, 'to' : base.related_class.decl_string }
, False)
simulator = mb.class_( 'simulator_t' )
simulator.mem_fun( 'get_event' ).call_policies \
= call_policies.return_internal_reference()
schedule = mb.mem_fun( 'schedule' )
schedule.add_transformation( ft.transfer_ownership(0), alias='schedule' )
def wrap_one_QList(self, cls):
cls.include()
cls.variables().exclude()
# Avoid constructor that takes Node* argument
for ctor in cls.constructors(arg_types=[None]):
arg_t = ctor.argument_types[0]
if (declarations.is_pointer(arg_t)):
ctor.exclude()
for fn_name in ['detach_helper_grow',
'node_construct',
'node_destruct',
'node_copy',
'fromVector',
'toVector',
'toSet',
'fromSet']:
cls.member_functions(fn_name).exclude()
for fn_name in ['back', 'first', 'front', 'last']:
cls.member_functions(fn_name).call_policies = \
call_policies.return_internal_reference()
# TODO - add python sequence operators
cls.include_files.append("qlist_py_indexing.h")
cls.add_registration_code("""
def(bp::indexing::container_suite<
%s,
bp::indexing::all_methods,
list_algorithms<qlist_container_traits<%s > > >())
""" % (cls.demangled, cls.demangled) )
def customize(self, mb):
mb.variable('prefered_color').alias = 'PreferedColor'
mb.classes().always_expose_using_scope = True
image = mb.class_('image_t')
image.variable('data').expose_address = True
image.variable('none_image').expose_address = True
mb.class_('Andy').variable('userData').expose_address = True
mb.class_('D').variable(
'a'
).getter_call_policies = call_policies.return_internal_reference()
def wrap_Quaternion(self):
simtk = self.mb.namespace('SimTK')
cls = simtk.class_('Quaternion_<double>')
cls.alias = 'Quaternion'
cls.include()
t = cls.demangled
cls.include_files.append("vec3_container_traits.hpp")
cls.add_registration_code("""
def(bp::indexing::container_suite<
%s,
bp::indexing::all_methods,
list_algorithms< vec_container_traits< %s > > >())
""" % (t, t) )
cls.member_function('normalizeThis').call_policies = \
call_policies.return_internal_reference()
def wrap_Rotation(self):
simtk = self.mb.namespace('SimTK')
rot = simtk.class_('Rotation_<double>')
rot.alias = "Rotation"
rot.include()
rot.member_functions().exclude()
rot.constructors().exclude()
rot.member_operators().exclude()
# Expose only methods needed for movie maker for now
fn = rot.member_function('setRotationFromThreeAnglesThreeAxes')
fn.include()
fn.call_policies = call_policies.return_internal_reference()
simtk.enum('BodyOrSpaceType').include()
simtk.class_('CoordinateAxis').include()
simtk.class_('CoordinateAxis').constructors(arg_types=[None]).exclude()
simtk.class_('CoordinateAxis').member_function('crossProduct').exclude()
simtk.variable('XAxis').include()
simtk.variable('YAxis').include()
simtk.variable('ZAxis').include()
fn = rot.member_function('convertThreeAxesRotationToThreeAngles')
fn.include()
fn = rot.member_function('setRotationFromQuaternion')
fn.include()
fn.call_policies = call_policies.return_internal_reference()
def finalize_class(self, z):
"""Finalizes a class z"""
beautify_func_list(z._funs)
_FT.beautify_memvars(z)
# ignore all non-public members
for t in z.decls():
try:
if t.access_type != 'public' or t.name.startswith('~'):
t.exclude()
except:
pass
# if a function returns a pointer and does not have a call policy, create a default one for it
for f in z._funs:
if not f.ignore and f.call_policies is None and \
_FT._T.is_ref_or_ptr(f.return_type) and not _FT._T.is_ref_or_ptr(_FT._T.remove_ref_or_ptr(f.return_type)):
f.call_policies = _CP.return_internal_reference()
def ParseServerOnly(self, mb):
# Accessor class game server
mb.add_registration_code( "bp::scope().attr( \"steamgameserverapicontext\" ) = boost::ref(steamgameserverapicontext);" )
cls = mb.class_('CSteamGameServerAPIContext')
cls.include()
cls.no_init = True
cls.mem_fun('Init').exclude()
cls.mem_fun('Clear').exclude()
cls.mem_fun('SteamGameServerUtils').exclude()
cls.mem_fun('SteamGameServerNetworking').exclude()
cls.mem_fun('SteamGameServerStats').exclude()
if self.steamsdkversion > (1, 16):
cls.mem_fun('SteamHTTP').exclude()
cls.mem_funs('SteamGameServer').call_policies = call_policies.return_internal_reference()
self.ParseGameServer(mb)
def finalize_class(self, z):
"""Finalizes a class z"""
beautify_func_list(z._funs)
_FT.beautify_memvars(z)
# ignore all non-public members
for t in z.decls():
try:
if t.access_type != 'public' or t.name.startswith('~'):
t.exclude()
except:
pass
# if a function returns a pointer and does not have a call policy, create a default one for it
for f in z._funs:
if not f.ignore and f.call_policies is None and \
_FT._T.is_ref_or_ptr(f.return_type) and not _FT._T.is_ref_or_ptr(_FT._T.remove_ref_or_ptr(f.return_type)):
f.call_policies = _CP.return_internal_reference()
def customize(self, mb ):
cls = mb.class_( 'properties_tester_t' )
count = cls.member_function( 'count' )
set_count = cls.member_function( 'set_count' )
count.exclude()
set_count.exclude()
cls.add_property( "count", count, set_count )
cls.add_property( "count_ro", count )
get_nested = cls.member_function( 'get_nested' )
get_nested.call_policies = call_policies.return_internal_reference()
set_nested = cls.member_function( 'set_nested' )
cls.add_property( "nested_", get_nested, set_nested )
cls.add_property( "nested_ro", get_nested )
cls = mb.class_( 'properties_finder_tester_t' )
cls.add_properties( exclude_accessors=True )
self.failUnless( 6 == len( cls.properties ) )
self.failUnless( cls.name in [pr.name for pr in cls.properties] )
def customize(self, mb):
cls = mb.class_('properties_tester_t')
count = cls.member_function('count')
set_count = cls.member_function('set_count')
count.exclude()
set_count.exclude()
cls.add_property("count", count, set_count)
cls.add_property("count_ro", count)
get_nested = cls.member_function('get_nested')
get_nested.call_policies = call_policies.return_internal_reference()
set_nested = cls.member_function('set_nested')
cls.add_property("nested_", get_nested, set_nested)
cls.add_property("nested_ro", get_nested)
cls = mb.class_('properties_finder_tester_t')
cls.add_properties(exclude_accessors=True)
self.failUnless(6 == len(cls.properties))
self.failUnless(cls.name in [pr.name for pr in cls.properties])
def customize(self, mb):
event_clss = mb.classes(lambda cls: cls.name in ("event_t", "do_nothing_t"))
for cls in event_clss:
cls.exposed_class_type = cls.EXPOSED_CLASS_TYPE.WRAPPER
cls.held_type = "std::auto_ptr< %s >" % cls.wrapper_alias
cls.add_registration_code(register_sptr % "std::auto_ptr< %s >" % cls.decl_string, False)
cls.add_registration_code(impl_conv_code % {"from": cls.wrapper_alias, "to": cls.decl_string}, False)
for base in cls.recursive_bases:
if base.access_type == "public":
cls.add_registration_code( # from class to its base
impl_conv_code % {"from": cls.decl_string, "to": base.related_class.decl_string}, False
)
cls.add_registration_code( # from wrapper to clas base class
impl_conv_code % {"from": cls.wrapper_alias, "to": base.related_class.decl_string}, False
)
simulator = mb.class_("simulator_t")
simulator.mem_fun("get_event").call_policies = call_policies.return_internal_reference()
schedule = mb.mem_fun("schedule")
schedule.add_transformation(ft.transfer_ownership(0), alias="schedule")
def ParseServerOnly(self, mb):
# Accessor class game server
mb.add_registration_code(
"bp::scope().attr( \"steamgameserverapicontext\" ) = boost::ref(steamgameserverapicontext);"
)
cls = mb.class_('CSteamGameServerAPIContext')
cls.include()
cls.no_init = True
cls.mem_fun('Init').exclude()
cls.mem_fun('Clear').exclude()
cls.mem_fun('SteamGameServerUtils').exclude()
cls.mem_fun('SteamGameServerNetworking').exclude()
cls.mem_fun('SteamGameServerStats').exclude()
if self.steamsdkversion > (1, 16):
cls.mem_fun('SteamHTTP').exclude()
cls.mem_funs(
'SteamGameServer'
).call_policies = call_policies.return_internal_reference()
self.ParseGameServer(mb)
def ParseServer(self, mb):
# Entity index functions
mb.free_functions('INDEXENT').include()
mb.free_functions('ENTINDEX').include()
mb.free_functions('INDEXENT').call_policies = call_policies.return_internal_reference()
# Don't care about the following functions
mb.free_functions('UTIL_VarArgs').exclude()
mb.free_functions('UTIL_LogPrintf').exclude()
mb.free_functions('UTIL_FunctionToName').exclude()
mb.free_functions('UTIL_FunctionFromName').exclude()
# Exclude for now
mb.free_functions('UTIL_GetDebugColorForRelationship').exclude()
mb.free_functions('UTIL_Beam').exclude()
mb.free_functions('UTIL_StringFieldToInt').exclude()
mb.free_functions('UTIL_EntitiesAlongRay').exclude()
# Replace the following
mb.free_functions('UTIL_SetSize').exclude()
mb.free_functions('UTIL_PySetSize').rename('UTIL_SetSize')
mb.free_functions('UTIL_SetModel').exclude()
mb.free_functions('UTIL_PySetModel').rename('UTIL_SetModel')
# Must use return_by_value. Then the converter will be used to wrap the vgui element in a safe handl
mb.free_functions('UTIL_GetLocalPlayer').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.free_functions('UTIL_GetCommandClient').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.free_functions('UTIL_EntityByIndex').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.free_functions('UTIL_GetListenServerHost').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.free_functions('UTIL_PlayerByName').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.free_functions('UTIL_PlayerByUserId').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.free_functions('UTIL_FindClientInVisibilityPVS').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.free_functions('UTIL_EntitiesInPVS').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.free_functions('UTIL_FindClientInPVS').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
if settings.ASW_CODE_BASE:
mb.free_functions('UTIL_FindClientInPVSGuts').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.free_functions('UTIL_GetLocalPlayerOrListenServerHost').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
# Helper for message stuff
if self.isServer:
cls = mb.class_('hudtextparms_s')
cls.include()
cls.rename('hudtextparms')
# Tracefilters
mb.class_('CTraceFilterMelee').include()
mb.class_('CTraceFilterMelee').calldefs('CTraceFilterMelee').exclude()
mb.class_('CTraceFilterMelee').add_wrapper_code(
"CTraceFilterMelee_wrapper(::CBaseEntity const * passentity, int collisionGroup, ::CTakeDamageInfo * dmgInfo, float flForceScale, bool bDamageAnyNPC )\r\n" + \
" : CTraceFilterMelee( boost::python::ptr(passentity), collisionGroup, boost::python::ptr(dmgInfo), flForceScale, bDamageAnyNPC )\r\n" + \
" , bp::wrapper< CTraceFilterMelee >(){\r\n" + \
" // constructor\r\n" + \
"}\r\n"
)
mb.class_('CTraceFilterMelee').add_registration_code(
'def( bp::init< CBaseEntity const *, int, CTakeDamageInfo *, float, bool >(( bp::arg("passentity"), bp::arg("collisionGroup"), bp::arg("dmgInfo"), bp::arg("flForceScale"), bp::arg("bDamageAnyNPC") )) )\r\n'
)
# Include explode functions
mb.free_functions('ExplosionCreate').include()
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NODAMAGE\" ) = SF_ENVEXPLOSION_NODAMAGE;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_REPEATABLE\" ) = SF_ENVEXPLOSION_REPEATABLE;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NOFIREBALL\" ) = SF_ENVEXPLOSION_NOFIREBALL;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NOSMOKE\" ) = SF_ENVEXPLOSION_NOSMOKE;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NODECAL\" ) = SF_ENVEXPLOSION_NODECAL;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NOSPARKS\" ) = SF_ENVEXPLOSION_NOSPARKS;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NOSOUND\" ) = SF_ENVEXPLOSION_NOSOUND;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_RND_ORIENT\" ) = SF_ENVEXPLOSION_RND_ORIENT;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NOFIREBALLSMOKE\" ) = SF_ENVEXPLOSION_NOFIREBALLSMOKE;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NOPARTICLES\" ) = SF_ENVEXPLOSION_NOPARTICLES;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NODLIGHTS\" ) = SF_ENVEXPLOSION_NODLIGHTS;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NOCLAMPMIN\" ) = SF_ENVEXPLOSION_NOCLAMPMIN;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NOCLAMPMAX\" ) = SF_ENVEXPLOSION_NOCLAMPMAX;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_SURFACEONLY\" ) = SF_ENVEXPLOSION_SURFACEONLY;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_GENERIC_DAMAGE\" ) = SF_ENVEXPLOSION_GENERIC_DAMAGE;" )
from pyplusplus.module_builder import call_policies
wrap = Wrapper()
mb = wrap.mb
# Special fix up
containers.extend_std_containers(mb)
namespaces.include_default_copy_constructors(mb)
ns_hwdb4cpp = mb.namespace('hwdb4cpp')
ns_hwdb4cpp.include()
namespaces.extend_array_operators(ns_hwdb4cpp)
for c in ns_hwdb4cpp.classes(allow_empty=True):
c.include()
if c.name.startswith('database'):
for f in c.mem_funs('get_wafer_entry', allow_empty=True):
f.call_policies = call_policies.return_internal_reference()
for f in c.mem_funs('get_dls_entry', allow_empty=True):
f.call_policies = call_policies.return_internal_reference()
for f in c.mem_funs('get_hxcube_entry', allow_empty=True):
f.call_policies = call_policies.return_internal_reference()
# expose only public interfaces
namespaces.exclude_by_access_type(mb, ['variables', 'calldefs', 'classes'],
'private')
namespaces.exclude_by_access_type(mb, ['variables', 'calldefs', 'classes'],
'protected')
wrap.finish()
def customize(self, mb):
mb.global_ns.calldefs().create_with_signature = True
hello_world = mb.free_function('hello_world')
hello_world.add_transformation(ft.output(0))
calc = mb.class_('calculator_t')
assign_funs = calc.member_functions(
lambda decl: decl.name.startswith('assign'))
assign_funs.add_transformation(ft.output(0), ft.output(1))
clone_and_assign_5 = calc.member_function('clone_and_assign_5')
clone_and_assign_5.add_transformation(ft.output(0))
clone_and_assign_5.call_policies = call_policies.return_value_policy(
call_policies.manage_new_object)
window = mb.class_('window_t')
window.member_function('resize').add_transformation(
ft.input(0), ft.input(1))
window.member_function('resize_in_out').add_transformation(
ft.inout(0), ft.inout(1))
point3d = mb.class_('point3d_t')
point3d.add_wrapper_code('')
point3d.member_function('initialize').add_transformation(
ft.input_static_array(0, size=3))
point3d.member_function('position').add_transformation(
ft.output_static_array(0, size=3))
distance = point3d.member_function('distance')
distance.add_transformation(ft.output(1))
distance.transformations[0].controller.add_pre_call_code(
'//dddddddddddddd')
distance.transformations[0].controller.add_post_call_code(
'//qqqqqqqqqqqqq')
image = mb.class_("image_t")
image.always_expose_using_scope = True
image.member_function("get_size")
image.member_function("get_size").add_transformation(
ft.output(0), ft.output(1))
image.member_function("get_one_value").add_transformation(ft.output(0))
image.member_function("get_size2").add_transformation(
ft.output(0), ft.output(1))
image.member_function("input_arg").add_transformation(ft.input(0))
image.member_function("fixed_input_array").add_transformation(
ft.input_static_array(0, 3))
image.member_function("fixed_output_array").add_transformation(
ft.output_static_array(0, 3))
mb.free_function("get_cpp_instance").call_policies \
= call_policies.return_value_policy(call_policies.reference_existing_object)
mb.variable("cpp_instance").exclude()
cls = mb.class_("no_virtual_members_t")
cls.member_function("member").add_transformation(ft.output(0))
cls = mb.class_("ft_private_destructor_t")
cls.member_function("get_value").add_transformation(ft.output(0))
mb.decls(lambda decl: decl.name.startswith("_")).exclude()
cls = mb.class_("bug_render_target_t")
cls.member_function("get_statistics",
arg_types=['float &'] * 2).add_transformation(
ft.output(0), ft.output(1))
cls = mb.class_('modify_type_tester_t')
do_nothing = cls.member_function('do_nothing')
do_nothing.add_transformation(
ft.modify_type(0, declarations.remove_reference))
clone = cls.member_function('clone')
clone.call_policies = call_policies.return_value_policy(
call_policies.manage_new_object)
clone.add_transformation(
ft.modify_type(0, declarations.remove_reference))
cls = mb.class_('input_c_buffer_tester_t')
write_mf = cls.member_function('write')
write_mf.add_transformation(ft.input_c_buffer('buffer', 'size'))
write_s = cls.member_function('write_s')
write_s.add_transformation(ft.input_c_buffer('buffer', 'size'))
resource = mb.class_('resources_t')
resource.held_type = 'std::auto_ptr< %s >' % resource.decl_string
transfer_ownership_tester = mb.class_('transfer_ownership_tester_t')
tester = transfer_ownership_tester.member_function('tester')
tester.add_transformation(ft.transfer_ownership(0))
render_queue_listener_t = mb.class_('render_queue_listener_t')
render_queue_ended = render_queue_listener_t.member_function(
'render_queue_ended')
render_queue_ended.add_transformation(ft.inout(2))
ft_bugs = mb.namespace('ft_bugs')
h = ft_bugs.member_function('h')
h.add_transformation(ft.modify_type(0, remove_const_ref))
h.call_policies = call_policies.return_internal_reference()
h2 = ft_bugs.member_function('h2')
h2.add_transformation(ft.modify_type(0, remove_const_ref))
h2.call_policies = call_policies.return_internal_reference()
ft_bugs.class_('B').always_expose_using_scope = True
ft_bugs.member_function( 'get_a' ).call_policies \
= call_policies.return_value_policy( call_policies.reference_existing_object )
ft_bugs2 = mb.namespace('ft_bugs2')
g = ft_bugs2.member_function('g')
g.add_transformation(ft.modify_type(0, remove_const_ref))
g.call_policies = call_policies.return_internal_reference()
def Parse(self, mb):
# Exclude everything by default
mb.decls().exclude()
# Accessor class for all
mb.add_registration_code( "bp::scope().attr( \"steamapicontext\" ) = boost::ref(steamapicontext);" )
cls = mb.class_('CSteamAPIContext')
cls.include()
cls.mem_fun('Init').exclude()
cls.mem_fun('Clear').exclude()
cls.mem_fun('SteamUser').exclude()
cls.mem_fun('SteamMatchmaking').exclude()
cls.mem_fun('SteamUserStats').exclude()
cls.mem_fun('SteamApps').exclude()
cls.mem_fun('SteamMatchmakingServers').exclude()
if settings.ASW_CODE_BASE:
cls.mem_fun('SteamNetworking').exclude()
cls.mem_fun('SteamRemoteStorage').exclude()
mb.class_('CSteamAPIContext').mem_funs('SteamFriends').call_policies = call_policies.return_internal_reference()
mb.class_('CSteamAPIContext').mem_funs('SteamUtils').call_policies = call_policies.return_internal_reference()
# CSteamID
mb.class_('CSteamID').include()
mb.class_('CSteamID').mem_funs('Render').exclude()
mb.class_('CSteamID').calldefs( lambda decl: HasArgType(decl, 'char') ).exclude()
mb.class_('CSteamID').mem_funs('SetFromString').exclude() # No definition...
mb.class_('CSteamID').mem_funs('SetFromSteam2String').exclude() # No definition...
mb.class_('CSteamID').mem_funs('BValidExternalSteamID').exclude() # No definition...
mb.enum('EResult').include()
mb.enum('EDenyReason').include()
mb.enum('EUniverse').include()
mb.enum('EAccountType').include()
mb.enum('ESteamUserStatType').include()
mb.enum('EChatEntryType').include()
mb.enum('EChatRoomEnterResponse').include()
mb.add_registration_code( "bp::scope().attr( \"QUERY_PORT_NOT_INITIALIZED\" ) = (int)QUERY_PORT_NOT_INITIALIZED;" )
mb.add_registration_code( "bp::scope().attr( \"QUERY_PORT_ERROR\" ) = (int)QUERY_PORT_ERROR;" )
# Friends
cls = mb.class_('ISteamFriends')
cls.include()
cls.mem_funs().virtuality = 'not virtual'
cls.mem_fun('GetFriendGamePlayed').exclude()
mb.enum('EFriendRelationship').include()
mb.enum('EPersonaState').include()
mb.enum('EAvatarSize').include()
#if not settings.ASW_CODE_BASE:
# mb.enum('k_EFriendFlags').include()
mb.add_registration_code( "bp::scope().attr( \"k_cchPersonaNameMax\" ) = (int)k_cchPersonaNameMax;" )
# Utils
cls = mb.class_('ISteamUtils')
cls.include()
cls.mem_funs().virtuality = 'not virtual'
cls.mem_fun('GetImageRGBA').exclude()
cls.mem_fun('GetImageSize').exclude()
#mb.class_('ISteamUtils').mem_funs('GetImageSize').add_transformation( FT.output('pnWidth'), FT.output('pnHeight'))
#mb.class_('ISteamUtils').mem_funs('GetCSERIPPort').add_transformation( FT.output('unIP'), FT.output('usPort'))
# Disable known warnings, but exposed in other modules
DisableKnownWarnings(mb)
def Parse(self, mb):
mb.decls().exclude()
# Get item
getitem_wrapper = 'static ::vec_t GetItem( %(cls_name)s const & inst, int i ) {\r\n' + \
' if( i < 0 || i > %(nitems)s ) {\r\n' + \
' PyErr_SetString(PyExc_IndexError, "Index out of range" );\r\n' + \
' throw boost::python::error_already_set();\r\n' + \
' }\r\n' + \
' return inst[i];\r\n' + \
'}\r\n'
getitem_reg = '%(cls_name)s_exposer.def( "__getitem__", &::%(cls_name)s_wrapper::GetItem );\r\n'
# Set item
setitem_wrapper = 'static void SetItem( %(cls_name)s & inst, int i, ::vec_t v ) {\r\n' + \
' if( i < 0 || i > %(nitems)s ) {\r\n' + \
' PyErr_SetString(PyExc_IndexError, "Index out of range" );\r\n' + \
' throw boost::python::error_already_set();\r\n' + \
' }\r\n' + \
' inst[i] = v;\r\n' + \
'}\r\n'
setitem_reg = '%(cls_name)s_exposer.def( "__setitem__", &::%(cls_name)s_wrapper::SetItem );\r\n'
# String
str_vmatrix_wrapper = 'static boost::python::object Str( VMatrix const & inst ) {\r\n' + \
' return boost::python::object(VMatToString(inst));\r\n' + \
'}\r\n'
str_reg = '%(cls_name)s_exposer.def( "__str__", &::%(cls_name)s_wrapper::Str );\r\n'
# Classes
cls = mb.class_('Vector')
cls.include()
cls.mem_opers(
'=').exclude() # Breaks debug mode and don't really need it
cls.add_wrapper_code(getitem_wrapper % {
'cls_name': 'Vector',
'nitems': '2'
})
cls.add_registration_code(getitem_reg % {'cls_name': 'Vector'}, False)
cls.add_wrapper_code(setitem_wrapper % {
'cls_name': 'Vector',
'nitems': '2'
})
cls.add_registration_code(setitem_reg % {'cls_name': 'Vector'}, False)
cls = mb.class_('Vector2D')
cls.include()
cls.mem_opers(
'=').exclude() # Breaks debug mode and don't really need it
cls.add_wrapper_code(getitem_wrapper % {
'cls_name': 'Vector2D',
'nitems': '1'
})
cls.add_registration_code(getitem_reg % {'cls_name': 'Vector2D'},
False)
cls.add_wrapper_code(setitem_wrapper % {
'cls_name': 'Vector2D',
'nitems': '1'
})
cls.add_registration_code(setitem_reg % {'cls_name': 'Vector2D'},
False)
cls = mb.class_('QAngle')
cls.include()
cls.mem_opers(
'=').exclude() # Breaks debug mode and don't really need it
cls.add_wrapper_code(getitem_wrapper % {
'cls_name': 'QAngle',
'nitems': '2'
})
cls.add_registration_code(getitem_reg % {'cls_name': 'QAngle'}, False)
cls.add_wrapper_code(setitem_wrapper % {
'cls_name': 'QAngle',
'nitems': '2'
})
cls.add_registration_code(setitem_reg % {'cls_name': 'QAngle'}, False)
cls = mb.class_('Quaternion')
cls.include()
cls.mem_opers(
'=').exclude() # Breaks debug mode and don't really need it
# Call policies
mb.mem_funs(
'AsVector2D'
).call_policies = call_policies.return_internal_reference()
# Transform functions that take pointers as arguments
mb.free_functions('SolveInverseQuadraticMonotonic').add_transformation(
FT.output('a'), FT.output('b'), FT.output('c'))
mb.free_functions('ComputeTrianglePlane').add_transformation(
FT.output('intercept'))
mb.free_functions(
'CalcSqrDistAndClosestPointOnAABB').add_transformation(
FT.output('distSqrOut'))
mb.free_functions(
'SolveInverseReciprocalQuadratic').add_transformation(
FT.output('a'), FT.output('b'), FT.output('c'))
mb.free_functions('SolveQuadratic').add_transformation(
FT.output('root1'), FT.output('root2'))
mb.free_functions('SolveInverseQuadratic').add_transformation(
FT.output('a'), FT.output('b'), FT.output('c'))
mb.free_functions('QuaternionAxisAngle').add_transformation(
FT.output('axis'), FT.output('angle'))
mb.free_functions('RotationDeltaAxisAngle').add_transformation(
FT.output('deltaAxis'), FT.output('deltaAngle'))
# Compressed color
mb.class_('ColorRGBExp32').include()
# cplane_t
mb.class_('cplane_t').include()
mb.class_('cplane_t').var('pad').exclude()
# matrix3x4_t
mb.class_('matrix3x4_t').include()
mb.class_('matrix3x4_t').mem_opers().exclude()
# -----
# Add custom item access functions to the Vector class
mb.global_ns.mem_opers('[]').exclude()
mb.class_('Vector').add_registration_code(
'def( bp::init< const Vector & >(( bp::arg("vOther") )) )')
mb.class_('QAngle').add_registration_code(
'def( bp::init< const QAngle & >(( bp::arg("vOther") )) )')
# Vars
mb.vars('vec3_origin').include()
mb.vars('vec3_angle').include()
mb.vars('vec3_invalid').include()
mb.vars('nanmask').include()
# Mathlib.h functions
mb.free_function('RandomAngularImpulse').include()
mb.free_functions('VectorMaximum').include()
mb.free_functions('VectorMAInline').include()
mb.free_functions('VectorMA').include()
mb.free_functions('RoundInt').include()
mb.free_functions('Q_log2').include()
mb.free_functions('SinCos').include()
mb.free_functions('TableCos').include()
mb.free_functions('TableSin').include()
if self.settings.branch == 'swarm':
mb.free_functions('IsPowerOfTwo').include()
mb.free_functions('SmallestPowerOfTwoGreaterOrEqual').include()
mb.free_functions('LargestPowerOfTwoLessThanOrEqual').include()
mb.free_functions('FloorDivMod').include()
mb.free_functions('GreatestCommonDivisor').include()
mb.free_functions('IsDenormal').include()
mb.free_functions('MatrixVectors').include()
mb.free_functions('VectorRotate').include()
mb.free_functions('TransformAnglesToLocalSpace').include()
mb.free_functions('MatrixInitialize').include()
mb.free_functions('MatrixCopy').include()
mb.free_functions('MatrixInvert').include()
mb.free_functions('MatricesAreEqual').include()
mb.free_functions('MatrixGetColumn').include()
mb.free_functions('MatrixSetColumn').include()
mb.free_functions('ConcatRotations').include()
mb.free_functions('ConcatTransforms').include()
mb.free_functions('MatrixMultiply').include()
mb.free_function('QuaternionSlerp').include()
mb.free_function('QuaternionSlerpNoAlign').include()
mb.free_function('QuaternionBlend').include()
mb.free_function('QuaternionBlendNoAlign').include()
mb.free_function('QuaternionIdentityBlend').include()
mb.free_function('QuaternionAngleDiff').include()
mb.free_function('QuaternionScale').include()
mb.free_function('QuaternionDotProduct').include()
mb.free_function('QuaternionConjugate').include()
mb.free_function('QuaternionInvert').include()
mb.free_function('QuaternionNormalize').include()
mb.free_function('QuaternionAdd').include()
mb.free_function('QuaternionMult').include()
mb.free_functions('QuaternionMatrix').include()
mb.free_functions('QuaternionAngles').include()
mb.free_functions('AngleQuaternion').include()
mb.free_function('QuaternionAxisAngle').include()
mb.free_function('AxisAngleQuaternion').include()
mb.free_function('BasisToQuaternion').include()
mb.free_function('MatrixQuaternion').include()
mb.free_functions('MatrixRowDotProduct').include()
mb.free_functions('MatrixColumnDotProduct').include()
mb.free_functions('anglemod').include()
mb.free_functions('RemapVal').include()
mb.free_functions('RemapValClamped').include()
mb.free_functions('Lerp').include()
mb.free_functions('Sqr').include()
mb.free_functions('FLerp').include()
mb.free_functions('Sign').include()
mb.free_functions('ClampArrayBounds').include()
mb.free_functions('AngleVectors').include()
mb.free_functions('AngleVectors').include()
mb.free_functions('AngleVectorsTranspose').include()
mb.free_functions('AngleMatrix').include()
mb.free_functions('AngleMatrix').include()
mb.free_functions('AngleIMatrix').include()
mb.free_functions('VectorAngles').include()
mb.free_functions('VectorMatrix').include()
mb.free_functions('VectorVectors').include()
mb.free_functions('SetIdentityMatrix').include()
mb.free_functions('SetScaleMatrix').include()
mb.free_functions('MatrixBuildRotationAboutAxis').include()
mb.free_functions('MatrixTranspose').include()
mb.free_functions('MatrixInverseTranspose').include()
mb.free_functions('PositionMatrix').include()
mb.free_functions('MatrixPosition').include()
mb.free_functions('VectorRotate').include()
mb.free_functions('VectorIRotate').include()
mb.free_functions('MatrixAngles').include()
mb.free_functions('VectorCompare').include()
mb.free_functions('VectorTransform').include()
mb.free_functions('VectorITransform').include()
mb.free_functions('BoxOnPlaneSide').include()
mb.free_functions('VectorFill').include()
mb.free_functions('VectorNegate').include()
mb.free_functions('VectorAvg').include()
mb.free_functions('BoxOnPlaneSide2').include()
mb.free_functions('ClearBounds').include()
mb.free_functions('AddPointToBounds').include()
mb.free_functions('BuildGammaTable').include()
mb.free_functions('TexLightToLinear').include()
mb.free_functions('LinearToTexture').include()
mb.free_functions('LinearToScreenGamma').include()
mb.free_functions('TextureToLinear').include()
mb.free_functions('SolveQuadratic').include()
mb.free_functions('SolveInverseQuadratic').include()
mb.free_functions('SolveInverseQuadraticMonotonic').include()
mb.free_functions('SolveInverseReciprocalQuadratic').include()
mb.free_functions('VectorYawRotate').include()
mb.free_functions('Bias').include()
mb.free_functions('Gain').include()
mb.free_functions('SmoothCurve').include()
mb.free_functions('SmoothCurve_Tweak').include()
mb.free_functions('ExponentialDecay').include()
mb.free_functions('ExponentialDecay').include()
mb.free_functions('ExponentialDecayIntegral').include()
mb.free_functions('SimpleSpline').include()
mb.free_functions('SimpleSplineRemapVal').include()
mb.free_functions('SimpleSplineRemapValClamped').include()
mb.free_functions('RoundFloatToInt').include()
mb.free_functions('RoundFloatToByte').include()
mb.free_functions('RoundFloatToUnsignedLong').include()
mb.free_functions('IsIntegralValue').include()
mb.free_functions('Float2Int').include()
mb.free_functions('Floor2Int').include()
mb.free_functions('FastFToC').include()
mb.free_functions('ClampToMsec').include()
mb.free_functions('Ceil2Int').include()
mb.free_functions('GetBarycentricCoords2D').include()
mb.free_functions('QuickBoxSphereTest').include()
mb.free_functions('QuickBoxIntersectTest').include()
mb.free_functions('GammaToLinearFullRange').include()
mb.free_functions('LinearToGammaFullRange').include()
mb.free_functions('GammaToLinear').include()
mb.free_functions('LinearToGamma').include()
mb.free_functions('SrgbGammaToLinear').include()
mb.free_functions('SrgbLinearToGamma').include()
mb.free_functions('X360GammaToLinear').include()
mb.free_functions('X360LinearToGamma').include()
mb.free_functions('SrgbGammaTo360Gamma').include()
mb.free_functions('LinearToVertexLight').include()
mb.free_functions('LinearToLightmap').include()
mb.free_functions('ColorClamp').include()
mb.free_functions('ColorClampTruncate').include()
mb.free_functions('Catmull_Rom_Spline').include()
mb.free_functions('Catmull_Rom_Spline_Tangent').include()
mb.free_functions('Catmull_Rom_Spline_Integral').include()
mb.free_functions('Catmull_Rom_Spline_Integral').include()
mb.free_functions('Catmull_Rom_Spline_Normalize').include()
mb.free_functions('Catmull_Rom_Spline_Integral_Normalize').include()
mb.free_functions('Catmull_Rom_Spline_NormalizeX').include()
mb.free_functions('Catmull_Rom_Spline_NormalizeX').include()
mb.free_functions('Hermite_Spline').include()
#mb.free_functions('Hermite_SplineBasis').include()
mb.free_functions('Kochanek_Bartels_Spline').include()
mb.free_functions('Kochanek_Bartels_Spline_NormalizeX').include()
mb.free_functions('Cubic_Spline').include()
mb.free_functions('Cubic_Spline_NormalizeX').include()
mb.free_functions('BSpline').include()
mb.free_functions('BSpline_NormalizeX').include()
mb.free_functions('Parabolic_Spline').include()
mb.free_functions('Parabolic_Spline_NormalizeX').include()
mb.free_functions('QuinticInterpolatingPolynomial').include()
#mb.free_functions('GetInterpolationData').include()
mb.free_functions('RangeCompressor').include()
mb.free_functions('CalcSqrDistanceToAABB').include()
mb.free_functions('CalcClosestPointOnAABB').include()
mb.free_functions('CalcSqrDistAndClosestPointOnAABB').include()
mb.free_functions('CalcDistanceToAABB').include()
#mb.free_functions('CalcLineToLineIntersectionSegment').include() # TODO
mb.free_functions('Approach').include()
mb.free_functions('ApproachAngle').include()
mb.free_functions('AngleDiff').include()
mb.free_functions('AngleDistance').include()
mb.free_functions('AngleNormalize').include()
mb.free_functions('AngleNormalizePositive').include()
mb.free_functions('AnglesAreEqual').include()
mb.free_functions('RotationDeltaAxisAngle').include()
mb.free_functions('RotationDelta').include()
mb.free_functions('ComputeTrianglePlane').include()
mb.free_functions('PolyFromPlane').include()
mb.free_functions('ClipPolyToPlane').include()
mb.free_functions('ClipPolyToPlane_Precise').include()
mb.free_functions('CalcTriangleTangentSpace').include()
mb.free_functions('TransformAABB').include()
mb.free_functions('ITransformAABB').include()
mb.free_functions('RotateAABB').include()
mb.free_functions('IRotateAABB').include()
mb.free_functions('MatrixTransformPlane').include()
mb.free_functions('MatrixITransformPlane').include()
mb.free_functions('CeilPow2').include()
mb.free_functions('FloorPow2').include()
mb.free_functions('RGBtoHSV').include()
mb.free_functions('HSVtoRGB').include()
# Vector.h functions
mb.free_functions('VectorClear').include()
mb.free_functions('VectorCopy').include()
mb.free_functions('VectorAdd').include()
mb.free_functions('VectorSubtract').include()
mb.free_functions('VectorMultiply').include()
mb.free_functions('VectorDivide').include()
mb.free_functions('VectorScale').include()
mb.free_functions('VectorMA').include()
mb.free_functions('VectorsAreEqual').include()
mb.free_functions('ComputeClosestPoint').include()
mb.free_functions('VectorAbs').include()
mb.free_functions('VectorLength').include()
mb.free_functions('DotProduct').include()
mb.free_functions('CrossProduct').include()
mb.free_functions('VectorMin').include()
mb.free_functions('VectorMax').include()
mb.free_functions('VectorLerp').include()
mb.free_functions('RandomVector').include()
mb.free_functions('QAnglesAreEqual').include()
#mb.free_functions('QAngleToAngularImpulse').include()
#mb.free_functions('AngularImpulseToQAngle').include()
mb.free_functions('VectorNormalize').include()
mb.free_functions('VectorNormalizeFast').include()
# Vector2d.h functions
mb.free_functions('Vector2DClear').include()
mb.free_functions('Vector2DCopy').include()
mb.free_functions('Vector2DAdd').include()
mb.free_functions('Vector2DSubtract').include()
mb.free_functions('Vector2DMultiply').include()
mb.free_functions('Vector2DDivide').include()
mb.free_functions('Vector2DMA').include()
mb.free_functions('Vector2DMin').include()
mb.free_functions('Vector2DMax').include()
mb.free_functions('Vector2DLength').include()
mb.free_functions('DotProduct2D').include()
mb.free_functions('Vector2DLerp').include()
mb.free_functions('Vector2DNormalize').include()
mb.free_functions('ComputeClosestPoint2D').include()
# QAngle functions
mb.free_function('RandomAngle').include()
# VMatrix
cls = mb.class_('VMatrix')
cls.include()
cls.mem_opers(
'=').exclude() # Breaks debug mode and don't really need it
cls.mem_opers('[]').exclude()
cls.mem_funs('Base').exclude()
cls.mem_funs('As3x4').exclude()
cls.mem_funs('GetTranslation').exclude()
cls.vars('m').exclude()
cls.add_wrapper_code(str_vmatrix_wrapper % {'cls_name': 'VMatrix'})
cls.add_registration_code(str_reg % {'cls_name': 'VMatrix'}, False)
mb.free_functions('MatrixSetIdentity').include()
mb.free_functions('MatrixTranspose').include()
mb.free_functions('MatrixCopy').include()
mb.free_functions('MatrixMultiply').include()
mb.free_functions('MatrixGetColumn').include()
mb.free_functions('MatrixSetColumn').include()
mb.free_functions('MatrixGetRow').include()
mb.free_functions('MatrixSetRow').include()
mb.free_functions('MatrixTranslate').include()
mb.free_functions('MatrixBuildRotationAboutAxis').include()
mb.free_functions('MatrixBuildRotateZ').include()
mb.free_functions('MatrixRotate').include()
mb.free_functions('MatrixFromAngles').include()
mb.free_functions('MatrixToAngles').include()
# Exclude
if self.settings.branch not in ['swarm', 'source2013']:
mb.vars('pfVectorNormalizeFast').exclude()
mb.vars('pfVectorNormalize').exclude()
mb.vars('pfInvRSquared').exclude()
mb.vars('m_flMatVal').exclude()
mb.vars('quat_identity').exclude(
) # <- Does not even exist except for a declaration?
# Exclude some functions
mb.mem_funs('Base').exclude(
) # Base gives a pointer to the address of the data. Not very python like.
mb.free_functions('AllocTempVector').exclude()
mb.class_('Vector2D').mem_funs('Cross').exclude() # Declaration only?
mb.free_function('ConcatRotations').exclude() # Declaration only?
# Remove any protected function
mb.calldefs(matchers.access_type_matcher_t('protected')).exclude()
# Remove any function with "float *" values
# A lot of functions have two versions (or more), of which one takes "float *" arguments
vec_t = mb.typedef('vec_t')
excludetypes = [
pointer_t(float_t()),
pointer_t(const_t(float_t())),
pointer_t(declarated_t(vec_t)),
pointer_t(const_t(declarated_t(vec_t))),
]
mb.calldefs(calldef_withtypes(excludetypes)).exclude()
# Silent warnings of generating class wrappers
mb.classes().disable_warnings(messages.W1027)
# Include functions with "float *" parameter. For these functions we should transform the "float *" parameter
mb.free_functions('CalcClosestPointOnLine2D').include()
mb.free_functions('CalcClosestPointOnLine2D').add_transformation(
FT.output('t'))
mb.free_functions('CalcDistanceToLine2D').include()
mb.free_functions('CalcDistanceToLine2D').add_transformation(
FT.output('t'))
mb.free_functions('CalcDistanceSqrToLine2D').include()
mb.free_functions('CalcDistanceSqrToLine2D').add_transformation(
FT.output('t'))
mb.free_functions('CalcClosestPointOnLineSegment2D').include()
mb.free_functions(
'CalcClosestPointOnLineSegment2D').add_transformation(
FT.output('t'))
mb.free_functions('CalcDistanceToLineSegment2D').include()
mb.free_functions('CalcDistanceToLineSegment2D').add_transformation(
FT.output('t'))
mb.free_functions('CalcDistanceSqrToLineSegment2D').include()
mb.free_functions('CalcDistanceSqrToLineSegment2D').add_transformation(
FT.output('t'))
mb.free_functions('CalcClosestPointOnLine').include()
mb.free_functions('CalcClosestPointOnLine').add_transformation(
FT.output('t'))
mb.free_functions('CalcDistanceToLine').include()
mb.free_functions('CalcDistanceToLine').add_transformation(
FT.output('t'))
mb.free_functions('CalcDistanceSqrToLine').include()
mb.free_functions('CalcDistanceSqrToLine').add_transformation(
FT.output('t'))
mb.free_functions('CalcClosestPointOnLineSegment').include()
mb.free_functions('CalcClosestPointOnLineSegment').add_transformation(
FT.output('t'))
mb.free_functions('CalcDistanceToLineSegment').include()
mb.free_functions('CalcDistanceToLineSegment').add_transformation(
FT.output('t'))
mb.free_functions('CalcDistanceSqrToLineSegment').include()
mb.free_functions('CalcDistanceSqrToLineSegment').add_transformation(
FT.output('t'))
def Parse(self, mb):
if self.settings.branch == 'source2013':
self.steamsdkversion = (1, 30)
# Exclude everything by default
mb.decls().exclude()
# Generic steam api call return result
mb.typedef('SteamAPICall_t').include()
# CSteamID
cls = mb.class_('CSteamID')
cls.include()
constpchararg = pointer_t(const_t(declarated_t(char_t())))
cls.constructors(matchers.calldef_matcher_t(arg_types=[constpchararg, None])).exclude()
cls.mem_funs('Render').exclude()
cls.mem_funs('SetFromStringStrict').exclude()
cls.mem_funs('SetFromString').exclude() # No definition...
cls.mem_funs('SetFromSteam2String').exclude() # No definition...
cls.mem_funs('BValidExternalSteamID').exclude() # No definition...
mb.enum('EResult').include()
mb.enum('EDenyReason').include()
mb.enum('EUniverse').include()
mb.enum('EAccountType').include()
mb.enum('ESteamUserStatType').include()
mb.enum('EChatEntryType').include()
mb.enum('EChatRoomEnterResponse').include()
mb.enum('EChatMemberStateChange').include()
# Generic API functions
mb.free_function('SteamAPI_RunCallbacks').include()
# Accessor class client
mb.add_registration_code( "bp::scope().attr( \"steamapicontext\" ) = boost::ref(steamapicontext);" )
cls = mb.class_('CSteamAPIContext')
cls.include()
cls.no_init = True
cls.noncopyable = True
cls.mem_fun('Init').exclude()
cls.mem_fun('Clear').exclude()
if self.steamsdkversion > (1, 11):
cls.mem_fun('SteamHTTP').exclude()
if self.steamsdkversion > (1, 15):
cls.mem_fun('SteamScreenshots').exclude()
if self.steamsdkversion > (1, 20):
cls.mem_fun('SteamUnifiedMessages').exclude()
cls.mem_fun('SteamMatchmakingServers').exclude() # Full python class wrapper
cls.mem_fun('SteamNetworking').exclude()
cls.mem_fun('SteamRemoteStorage').exclude()
if self.steamsdkversion > (1, 16):
cls.mem_fun('SteamAppList').exclude()
cls.mem_fun('SteamController').exclude()
cls.mem_fun('SteamMusic').exclude()
cls.mem_fun('SteamMusicRemote').exclude()
cls.mem_fun('SteamUGC').exclude()
cls.mem_fun('SteamHTMLSurface').exclude()
cls.mem_funs('SteamApps').call_policies = call_policies.return_internal_reference()
cls.mem_funs('SteamFriends').call_policies = call_policies.return_internal_reference()
cls.mem_funs('SteamUtils').call_policies = call_policies.return_internal_reference()
cls.mem_funs('SteamMatchmaking').call_policies = call_policies.return_internal_reference()
cls.mem_funs('SteamMatchmakingServers').call_policies = call_policies.return_internal_reference()
cls.mem_funs('SteamUser').call_policies = call_policies.return_internal_reference()
cls.mem_funs('SteamUserStats').call_policies = call_policies.return_internal_reference()
mb.add_registration_code( "bp::scope().attr( \"QUERY_PORT_NOT_INITIALIZED\" ) = (int)QUERY_PORT_NOT_INITIALIZED;" )
mb.add_registration_code( "bp::scope().attr( \"QUERY_PORT_ERROR\" ) = (int)QUERY_PORT_ERROR;" )
self.ParseSteamApps(mb)
self.ParseSteamFriends(mb)
# User
cls = mb.class_('ISteamUser')
cls.include()
cls.no_init = True
cls.noncopyable = True
cls.mem_funs().virtuality = 'not virtual'
# Utils
cls = mb.class_('ISteamUtils')
cls.include()
cls.no_init = True
cls.noncopyable = True
cls.mem_funs().virtuality = 'not virtual'
cls.mem_fun('GetImageRGBA').exclude()
cls.mem_fun('GetImageSize').exclude()
self.ParseMatchmaking(mb)
self.ParseUserStats(mb)
#mb.class_('ISteamUtils').mem_funs('GetImageSize').add_transformation( FT.output('pnWidth'), FT.output('pnHeight'))
#mb.class_('ISteamUtils').mem_funs('GetCSERIPPort').add_transformation( FT.output('unIP'), FT.output('usPort'))
if self.isserver:
self.ParseServerOnly(mb)
def Parse(self, mb):
if self.settings.branch == 'source2013':
self.steamsdkversion = (1, 30)
# Exclude everything by default
mb.decls().exclude()
# Generic steam api call return result
mb.typedef('SteamAPICall_t').include()
# CSteamID
cls = mb.class_('CSteamID')
cls.include()
constpchararg = pointer_t(const_t(declarated_t(char_t())))
cls.constructors(
matchers.calldef_matcher_t(
arg_types=[constpchararg, None])).exclude()
cls.mem_funs('Render').exclude()
cls.mem_funs('SetFromStringStrict').exclude()
cls.mem_funs('SetFromString').exclude() # No definition...
cls.mem_funs('SetFromSteam2String').exclude() # No definition...
cls.mem_funs('BValidExternalSteamID').exclude() # No definition...
mb.enum('EResult').include()
mb.enum('EDenyReason').include()
mb.enum('EUniverse').include()
mb.enum('EAccountType').include()
mb.enum('ESteamUserStatType').include()
mb.enum('EChatEntryType').include()
mb.enum('EChatRoomEnterResponse').include()
mb.enum('EChatMemberStateChange').include()
# Generic API functions
mb.free_function('SteamAPI_RunCallbacks').include()
# Accessor class client
mb.add_registration_code(
"bp::scope().attr( \"steamapicontext\" ) = boost::ref(steamapicontext);"
)
cls = mb.class_('CSteamAPIContext')
cls.include()
cls.no_init = True
cls.noncopyable = True
cls.mem_fun('Init').exclude()
cls.mem_fun('Clear').exclude()
if self.steamsdkversion > (1, 11):
cls.mem_fun('SteamHTTP').exclude()
if self.steamsdkversion > (1, 15):
cls.mem_fun('SteamScreenshots').exclude()
if self.steamsdkversion > (1, 20):
cls.mem_fun('SteamUnifiedMessages').exclude()
cls.mem_fun(
'SteamMatchmakingServers').exclude() # Full python class wrapper
cls.mem_fun('SteamNetworking').exclude()
cls.mem_fun('SteamRemoteStorage').exclude()
if self.steamsdkversion > (1, 16):
cls.mem_fun('SteamAppList').exclude()
cls.mem_fun('SteamController').exclude()
cls.mem_fun('SteamMusic').exclude()
cls.mem_fun('SteamMusicRemote').exclude()
cls.mem_fun('SteamUGC').exclude()
cls.mem_fun('SteamHTMLSurface').exclude()
cls.mem_funs(
'SteamApps'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs(
'SteamFriends'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs(
'SteamUtils'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs(
'SteamMatchmaking'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs(
'SteamMatchmakingServers'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs(
'SteamUser'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs(
'SteamUserStats'
).call_policies = call_policies.return_internal_reference()
mb.add_registration_code(
"bp::scope().attr( \"QUERY_PORT_NOT_INITIALIZED\" ) = (int)QUERY_PORT_NOT_INITIALIZED;"
)
mb.add_registration_code(
"bp::scope().attr( \"QUERY_PORT_ERROR\" ) = (int)QUERY_PORT_ERROR;"
)
self.ParseSteamApps(mb)
self.ParseSteamFriends(mb)
# User
cls = mb.class_('ISteamUser')
cls.include()
cls.no_init = True
cls.noncopyable = True
cls.mem_funs().virtuality = 'not virtual'
cls.mem_fun('DecompressVoice').exclude()
cls.mem_fun('GetAuthSessionTicket').exclude()
cls.mem_fun('GetEncryptedAppTicket').exclude()
cls.mem_fun('GetVoice').exclude()
cls.mem_fun('InitiateGameConnection').exclude()
cls.mem_fun('RequestEncryptedAppTicket').exclude()
cls.mem_fun('BeginAuthSession').exclude()
mb.free_function('PySteamUser_GetAuthSessionTicket').include()
mb.free_function('PySteamUser_GetAuthSessionTicket').rename(
'SteamUser_GetAuthSessionTicket')
# Utils
cls = mb.class_('ISteamUtils')
cls.include()
cls.no_init = True
cls.noncopyable = True
cls.mem_funs().virtuality = 'not virtual'
cls.mem_fun('GetImageRGBA').exclude()
cls.mem_fun('GetImageSize').exclude()
cls.mem_fun('GetAPICallResult').exclude()
self.ParseMatchmaking(mb)
self.ParseUserStats(mb)
#mb.class_('ISteamUtils').mem_funs('GetImageSize').add_transformation( FT.output('pnWidth'), FT.output('pnHeight'))
#mb.class_('ISteamUtils').mem_funs('GetCSERIPPort').add_transformation( FT.output('unIP'), FT.output('usPort'))
if self.isserver:
self.ParseServerOnly(mb)
# SCRIPT POUR ../input_output/cxml.h
# mb.namespace("BasicXmlProcess").exclude()
# cxmlnode=mb.class_("CXmlNode")
# cxmlnode.mem_fun("GetChild").call_policies = call_policies.return_value_policy( call_policies.return_opaque_pointer )
# cxmlnode.decls("t_nodeData").exclude()
# cxml=mb.class_("CXml")
# cxml.mem_fun("GetRoot").call_policies = call_policies.return_value_policy( call_policies.return_opaque_pointer )
# mb.class_("CoreString").include()
# for cons in cxmlnode.constructors("CXmlNode"):
# for el in cons.arguments:
# if el.name=="rowData":
# cons.exclude()
# ####################################################
# SCRIPT POUR ../input_output/progressionInfo.h
mb.class_("progressionInfo").mem_fun("GetMainOperation").call_policies = call_policies.return_internal_reference( 1 )
mb.class_("progressOperation").mem_fun("GetState").exclude()
# ####################################################
# SCRIPT POUR ../input_output/exportRecepteurSurf/std_rsbin.h
rsbin=mb.namespace("formatRSBIN").class_("rsurf_data")
rsbin.mem_fun("GetFileInfos").add_transformation( FT.output('rs_size'),FT.output('nodes_size') ,FT.output('nbtimestep'),FT.output('timestep'),FT.output('recordType'))
rsbin.mem_fun("GetNodePositionValue").add_transformation( FT.output('x'),FT.output('y'),FT.output('z'))
rsbin.mem_fun("GetRsInfo").add_transformation( FT.output('nbfaces'),FT.output('rs_name'),FT.output('xmlid'))
rsbin.mem_fun("GetFaceInfo").add_transformation( FT.output('vertexA'),FT.output('vertexB'),FT.output('vertexC'),FT.output('recordCount'))
rsbin.mem_fun("GetFaceEnergy").add_transformation( FT.output('idstep'),FT.output('energy'))
rsbin.mem_funs("SetRsBinData").exclude()
rsiso=mb.namespace("formatRSBIN").class_("rsurf_iso_contouring")
rsiso.mem_fun("GetMinMax").add_transformation( FT.output('min'),FT.output('max'))
rsiso.mem_fun("GetIsoLevelCurves").add_transformation( FT.output('curvlst'))
def ParsePanel(self, mb):
# List of functions that should be overridable
mb.mem_funs('SetVisible').virtuality = 'virtual'
mb.mem_funs('SetParent').virtuality = 'virtual'
mb.mem_funs('SetEnabled').virtuality = 'virtual'
mb.mem_funs('SetBgColor').virtuality = 'virtual'
mb.mem_funs('SetFgColor').virtuality = 'virtual'
mb.mem_funs('SetCursor').virtuality = 'virtual'
mb.mem_funs('InvalidateLayout').virtuality = 'virtual'
mb.mem_funs('SetBorder').virtuality = 'virtual'
mb.mem_funs('SetPaintBorderEnabled').virtuality = 'virtual'
mb.mem_funs('SetPaintBackgroundEnabled').virtuality = 'virtual'
mb.mem_funs('SetPaintEnabled').virtuality = 'virtual'
mb.mem_funs('SetPaintBackgroundType').virtuality = 'virtual'
mb.mem_funs('SetScheme').virtuality = 'virtual'
mb.mem_funs('ApplySchemeSettings').virtuality = 'virtual'
mb.mem_funs('OnCommand').virtuality = 'virtual'
mb.mem_funs('OnMouseCaptureLost').virtuality = 'virtual'
mb.mem_funs('OnSetFocus').virtuality = 'virtual'
mb.mem_funs('OnKillFocus').virtuality = 'virtual'
mb.mem_funs('OnDelete').virtuality = 'virtual'
mb.mem_funs('OnThink').virtuality = 'virtual'
mb.mem_funs('OnChildAdded').virtuality = 'virtual'
mb.mem_funs('OnSizeChanged').virtuality = 'virtual'
mb.mem_funs('OnTick').virtuality = 'virtual'
mb.mem_funs('OnCursorMoved').virtuality = 'virtual'
mb.mem_funs('OnCursorEntered').virtuality = 'virtual'
mb.mem_funs('OnCursorExited').virtuality = 'virtual'
mb.mem_funs('OnMousePressed').virtuality = 'virtual'
mb.mem_funs('OnMouseDoublePressed').virtuality = 'virtual'
mb.mem_funs('OnMouseReleased').virtuality = 'virtual'
mb.mem_funs('OnMouseWheeled').virtuality = 'virtual'
mb.mem_funs('OnMouseTriplePressed').virtuality = 'virtual'
mb.mem_funs('OnKeyCodePressed').virtuality = 'virtual'
mb.mem_funs('OnKeyCodeTyped').virtuality = 'virtual'
mb.mem_funs('OnKeyCodeReleased').virtuality = 'virtual'
mb.mem_funs('OnKeyFocusTicked').virtuality = 'virtual'
mb.mem_funs('OnMouseFocusTicked').virtuality = 'virtual'
mb.mem_funs('PaintBackground').virtuality = 'virtual'
mb.mem_funs('Paint').virtuality = 'virtual'
#mb.mem_funs('PaintBorder').virtuality = 'virtual' # TODO: Don't believe we are ever interested in painting borders in python
mb.mem_funs('PaintBuildOverlay').virtuality = 'virtual'
mb.mem_funs('PostChildPaint').virtuality = 'virtual'
mb.mem_funs('PerformLayout').virtuality = 'virtual'
mb.mem_funs('SetMouseInputEnabled').virtuality = 'virtual'
mb.mem_funs('SetKeyBoardInputEnabled').virtuality = 'virtual'
mb.mem_funs('SetDragEnabled').virtuality = 'virtual'
mb.mem_funs('OnRequestFocus').virtuality = 'virtual'
mb.mem_funs('OnScreenSizeChanged').virtuality = 'virtual'
# Transformations
mb.mem_funs( 'GetPos' ).add_transformation( FT.output('x'), FT.output('y') )
mb.class_('Panel').mem_funs( 'GetSize' ).add_transformation( FT.output('wide'), FT.output('tall') )
mb.class_('Panel').mem_funs( 'GetBounds' ).add_transformation( FT.output('x'), FT.output('y'), FT.output('wide'), FT.output('tall') )
mb.mem_funs( 'GetMinimumSize' ).add_transformation( FT.output('wide'), FT.output('tall') )
mb.mem_funs( 'LocalToScreen' ).add_transformation( FT.inout('x'), FT.inout('y') )
mb.mem_funs( 'ScreenToLocal' ).add_transformation( FT.inout('x'), FT.inout('y') )
mb.mem_funs( 'ParentLocalToScreen' ).add_transformation( FT.inout('x'), FT.inout('y') )
mb.mem_funs( 'GetInset' ).add_transformation( FT.output('left'), FT.output('top'), FT.output('right'), FT.output('bottom') )
mb.mem_funs( 'GetPaintSize' ).add_transformation( FT.output('wide'), FT.output('tall') )
mb.mem_funs( 'GetClipRect' ).add_transformation( FT.output('x0'), FT.output('y0'), FT.output('x1'), FT.output('y1') )
mb.mem_funs( 'GetPinOffset' ).add_transformation( FT.output('dx'), FT.output('dy') )
mb.mem_funs( 'GetResizeOffset' ).add_transformation( FT.output('dx'), FT.output('dy') )
mb.mem_funs( 'GetCornerTextureSize' ).add_transformation( FT.output('w'), FT.output('h') )
# Exclude list
mb.mem_funs('QueryInterface').exclude()
# Custom implemented
mb.mem_funs('PaintBackground').exclude()
mb.mem_funs('Paint').exclude()
mb.mem_funs('InvalidateLayout').exclude()
# We don't care about build mode, since we can easily reload modules in python
# We also don't want the user to be able to call methods like Delete.
mb.mem_funs('IsBuildModeEditable').exclude()
mb.mem_funs('SetBuildModeEditable').exclude()
mb.mem_funs('IsBuildModeDeletable').exclude()
mb.mem_funs('SetBuildModeDeletable').exclude()
mb.mem_funs('IsBuildModeActive').exclude()
#mb.mem_funs('SetAutoDelete').exclude()
#mb.mem_funs('IsAutoDeleteSet').exclude()
mb.mem_funs('OnDelete').exclude()
mb.mem_funs('MarkForDeletion').exclude()
mb.mem_funs('SetBuildGroup').exclude()
mb.mem_funs('IsBuildGroupEnabled').exclude()
mb.mem_funs('CreateControlByName').exclude()
mb.mem_funs('LoadKeyBindings').exclude()
mb.mem_funs('SaveKeyBindingsToBuffer').exclude()
mb.mem_funs('LookupBoundKeys').exclude()
mb.mem_funs('OnKeyTyped').exclude()
mb.mem_funs('HasHotkey').exclude()
mb.mem_funs('GetDragData').exclude()
if self.settings.branch == 'swarm':
mb.mem_funs('GetDragFailCursor').exclude()
mb.mem_funs('GetDropCursor').exclude()
mb.mem_funs('GetDropTarget').exclude()
mb.mem_funs('IsDroppable').exclude()
mb.mem_funs('OnPanelDropped').exclude()
mb.mem_funs('OnPanelEnteredDroppablePanel').exclude()
mb.mem_funs('OnPanelExitedDroppablePanel').exclude()
mb.mem_funs('OnDragFailed').exclude()
mb.mem_funs('OnDropContextHoverHide').exclude()
mb.mem_funs('OnDropContextHoverShow').exclude()
mb.mem_funs('OnDroppablePanelPaint').exclude()
mb.mem_funs('OnGetAdditionalDragPanels').exclude()
mb.mem_funs('OnDragFailed').exclude()
mb.vars('m_PanelMap').exclude()
mb.vars('m_MessageMap').exclude()
mb.mem_funs('GetPanelMap').exclude()
if self.settings.branch == 'source2013':
mb.mem_funs('GetChildren').exclude()
# Must use return_by_value. Then the converter will be used to wrap the vgui element in a safe handle
mb.mem_funs( 'GetChild' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetBorder' ).call_policies = call_policies.return_value_policy( call_policies.reference_existing_object )
if self.settings.branch == 'source2007':
mb.mem_funs('GetBorderAtIndex').call_policies = call_policies.return_value_policy( call_policies.reference_existing_object )
mb.mem_funs( 'GetParent' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'FindSiblingByName' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'FindChildByName' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'HasHotkey' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetPanelWithKeyBindings' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'LookupBinding' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'LookupBindingByKeyCode' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'LookupDefaultKey' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'LookupMapForBinding' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetTooltip' ).call_policies = call_policies.return_internal_reference()
mb.mem_funs( 'GetDragDropInfo' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetDragPanel' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetPanel' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'FindPanelAnimationEntry' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'FindDropTargetPanel' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
if self.settings.branch == 'swarm':
mb.mem_funs( 'GetNavDown' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetNavDownPanel' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetNavLeft' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetNavLeftPanel' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetNavRight' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetNavRightPanel' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetNavUp' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetNavUpPanel' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'NavigateDown' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'NavigateLeft' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'NavigateRight' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'NavigateTo' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'NavigateUp' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'SetNavDown' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'SetNavLeft' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'SetNavRight' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'SetNavUp' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
# Exclude
mb.mem_funs('OnUnserialized').exclude()
mb.mem_funs('GetSizer').exclude()
mb.mem_funs('GetUnpackStructure').exclude()
if self.settings.branch == 'swarm':
# Tooltip class
cls = mb.class_('Tooltip')
cls.include()
def ParsePanel(self, mb):
#all_classes = mb.classes(self.panel_cls_list)
if not novguilib: # FIXME/TODO
mb.mem_funs('PyDeletePanel').rename('DeletePanel')
mb.mem_fun('PyOnMessage').rename( 'OnMessage' )
# List of functions that should be overridable
mb.mem_funs('SetVisible').virtuality = 'virtual'
mb.mem_funs('SetParent').virtuality = 'virtual'
mb.mem_funs('SetEnabled').virtuality = 'virtual'
mb.mem_funs('SetBgColor').virtuality = 'virtual'
mb.mem_funs('SetFgColor').virtuality = 'virtual'
mb.mem_funs('SetCursor').virtuality = 'virtual'
mb.mem_funs('InvalidateLayout').virtuality = 'virtual'
mb.mem_funs('SetBorder').virtuality = 'virtual'
mb.mem_funs('SetPaintBorderEnabled').virtuality = 'virtual'
mb.mem_funs('SetPaintBackgroundEnabled').virtuality = 'virtual'
mb.mem_funs('SetPaintEnabled').virtuality = 'virtual'
mb.mem_funs('SetPaintBackgroundType').virtuality = 'virtual'
mb.mem_funs('SetScheme').virtuality = 'virtual'
mb.mem_funs('ApplySchemeSettings').virtuality = 'virtual'
mb.mem_funs('OnCommand').virtuality = 'virtual'
mb.mem_funs('OnMouseCaptureLost').virtuality = 'virtual'
mb.mem_funs('OnSetFocus').virtuality = 'virtual'
mb.mem_funs('OnKillFocus').virtuality = 'virtual'
mb.mem_funs('OnDelete').virtuality = 'virtual'
mb.mem_funs('OnThink').virtuality = 'virtual'
mb.mem_funs('OnChildAdded').virtuality = 'virtual'
mb.mem_funs('OnSizeChanged').virtuality = 'virtual'
mb.mem_funs('OnTick').virtuality = 'virtual'
mb.mem_funs('OnCursorMoved').virtuality = 'virtual'
mb.mem_funs('OnCursorEntered').virtuality = 'virtual'
mb.mem_funs('OnCursorExited').virtuality = 'virtual'
mb.mem_funs('OnMousePressed').virtuality = 'virtual'
mb.mem_funs('OnMouseDoublePressed').virtuality = 'virtual'
mb.mem_funs('OnMouseReleased').virtuality = 'virtual'
mb.mem_funs('OnMouseWheeled').virtuality = 'virtual'
mb.mem_funs('OnMouseTriplePressed').virtuality = 'virtual'
mb.mem_funs('OnKeyCodePressed').virtuality = 'virtual'
mb.mem_funs('OnKeyCodeTyped').virtuality = 'virtual'
mb.mem_funs('OnKeyCodeReleased').virtuality = 'virtual'
mb.mem_funs('OnKeyFocusTicked').virtuality = 'virtual'
mb.mem_funs('OnMouseFocusTicked').virtuality = 'virtual'
mb.mem_funs('PaintBackground').virtuality = 'virtual'
mb.mem_funs('Paint').virtuality = 'virtual'
#mb.mem_funs('PaintBorder').virtuality = 'virtual' # TODO: Don't believe we are ever interested in painting borders in python
mb.mem_funs('PaintBuildOverlay').virtuality = 'virtual'
mb.mem_funs('PostChildPaint').virtuality = 'virtual'
mb.mem_funs('PerformLayout').virtuality = 'virtual'
mb.mem_funs('SetMouseInputEnabled').virtuality = 'virtual'
mb.mem_funs('SetKeyBoardInputEnabled').virtuality = 'virtual'
mb.mem_funs('SetDragEnabled').virtuality = 'virtual'
mb.mem_funs('OnRequestFocus').virtuality = 'virtual'
mb.mem_funs('OnScreenSizeChanged').virtuality = 'virtual'
# Transformations
mb.mem_funs( 'GetPos' ).add_transformation( FT.output('x'), FT.output('y') )
mb.class_('Panel').mem_funs( 'GetSize' ).add_transformation( FT.output('wide'), FT.output('tall') )
mb.class_('Panel').mem_funs( 'GetBounds' ).add_transformation( FT.output('x'), FT.output('y'), FT.output('wide'), FT.output('tall') )
mb.mem_funs( 'GetMinimumSize' ).add_transformation( FT.output('wide'), FT.output('tall') )
mb.mem_funs( 'LocalToScreen' ).add_transformation( FT.inout('x'), FT.inout('y') )
mb.mem_funs( 'ScreenToLocal' ).add_transformation( FT.inout('x'), FT.inout('y') )
mb.mem_funs( 'ParentLocalToScreen' ).add_transformation( FT.inout('x'), FT.inout('y') )
mb.mem_funs( 'GetInset' ).add_transformation( FT.output('left'), FT.output('top'), FT.output('right'), FT.output('bottom') )
mb.mem_funs( 'GetPaintSize' ).add_transformation( FT.output('wide'), FT.output('tall') )
mb.mem_funs( 'GetClipRect' ).add_transformation( FT.output('x0'), FT.output('y0'), FT.output('x1'), FT.output('y1') )
mb.mem_funs( 'GetPinOffset' ).add_transformation( FT.output('dx'), FT.output('dy') )
mb.mem_funs( 'GetResizeOffset' ).add_transformation( FT.output('dx'), FT.output('dy') )
mb.mem_funs( 'GetCornerTextureSize' ).add_transformation( FT.output('w'), FT.output('h') )
# Exclude list
mb.mem_funs('SetParent', lambda decl: HasArgType(decl, 'Panel')).exclude() # Custom wrapper
if not novguilib: # FIXME/TODO
mb.mem_funs('PyOnMessage').exclude() # Custom wrapper
mb.mem_funs('QueryInterface').exclude()
# Custom implemented
mb.mem_funs('PaintBackground').exclude()
mb.mem_funs('Paint').exclude()
mb.mem_funs('InvalidateLayout').exclude()
# We don't care about build mode, since we can easily reload modules in python
# We also don't want the user to be able to call methods like Delete.
mb.mem_funs('IsBuildModeEditable').exclude()
mb.mem_funs('SetBuildModeEditable').exclude()
mb.mem_funs('IsBuildModeDeletable').exclude()
mb.mem_funs('SetBuildModeDeletable').exclude()
mb.mem_funs('IsBuildModeActive').exclude()
#mb.mem_funs('SetAutoDelete').exclude()
#mb.mem_funs('IsAutoDeleteSet').exclude()
if not novguilib: # Overriden in ASW_CODE_BASE to prevent delete. Instead a friendly Python cleanup is done.
mb.mem_funs('DeletePanel').exclude()
mb.mem_funs('OnDelete').exclude()
mb.mem_funs('MarkForDeletion').exclude()
mb.mem_funs('SetBuildGroup').exclude()
mb.mem_funs('IsBuildGroupEnabled').exclude()
mb.mem_funs('CreateControlByName').exclude()
mb.mem_funs('LoadKeyBindings').exclude() # Not sure why this one is giving problems. Not that it is important.
mb.mem_funs('OnKeyTyped').exclude()
mb.mem_funs('HasHotkey').exclude()
mb.vars('m_PanelMap').exclude()
mb.vars('m_MessageMap').exclude()
mb.mem_funs('GetPanelMap').exclude()
# Must use return_by_value. Then the converter will be used to wrap the vgui element in a safe handle
mb.mem_funs( 'GetChild' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'GetBorder' ).call_policies = call_policies.return_value_policy( call_policies.reference_existing_object )
mb.mem_funs( 'GetParent' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'FindSiblingByName' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'FindChildByName' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'HasHotkey' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'GetPanelWithKeyBindings' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'LookupBinding' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'LookupBindingByKeyCode' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'LookupDefaultKey' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'LookupMapForBinding' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'GetTooltip' ).call_policies = call_policies.return_internal_reference()
mb.mem_funs( 'GetDragDropInfo' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'GetDragPanel' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'GetPanel' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'FindPanelAnimationEntry' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'FindDropTargetPanel' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
if settings.ASW_CODE_BASE:
mb.mem_funs( 'GetNavDown' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'GetNavDownPanel' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'GetNavLeft' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'GetNavLeftPanel' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'GetNavRight' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'GetNavRightPanel' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'GetNavUp' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'GetNavUpPanel' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'NavigateDown' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'NavigateLeft' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'NavigateRight' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'NavigateTo' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'NavigateUp' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'SetNavDown' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'SetNavLeft' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'SetNavRight' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs( 'SetNavUp' ).call_policies = call_policies.return_value_policy( call_policies.return_by_value )
# Exclude
mb.mem_funs('OnUnserialized').exclude()
mb.mem_funs('GetSizer').exclude()
mb.mem_funs('GetUnpackStructure').exclude()
# Tooltip class
cls = mb.class_('Tooltip')
cls.include()
def customize(self, mb):
mb.class_('numbers_t').operator(
'[]').call_policies = call_policies.return_internal_reference()
def ParseServer(self, mb):
# Entity index functions
mb.free_functions('INDEXENT').include()
mb.free_functions('ENTINDEX').include()
mb.free_functions('INDEXENT').call_policies = call_policies.return_internal_reference()
# Don't care about the following functions
mb.free_functions('UTIL_VarArgs').exclude()
mb.free_functions('UTIL_LogPrintf').exclude()
mb.free_functions('UTIL_FunctionToName').exclude()
if self.settings.branch == 'swarm':
mb.free_functions('UTIL_FunctionFromName').exclude()
mb.free_function('UTIL_GetModDir').exclude()
# Exclude for now
mb.free_functions('UTIL_GetDebugColorForRelationship').exclude()
mb.free_functions('UTIL_Beam').exclude()
mb.free_functions('UTIL_StringFieldToInt').exclude()
mb.free_functions('UTIL_EntitiesAlongRay').exclude()
# Replace the following
mb.free_functions('UTIL_SetSize').exclude()
mb.free_functions('UTIL_PySetSize').rename('UTIL_SetSize')
mb.free_functions('UTIL_SetModel').exclude()
mb.free_functions('UTIL_PySetModel').rename('UTIL_SetModel')
# Must use return_by_value. Then the converter will be used to wrap the vgui element in a safe handl
mb.free_functions('UTIL_GetLocalPlayer').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.free_functions('UTIL_GetCommandClient').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.free_functions('UTIL_EntityByIndex').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.free_functions('UTIL_GetListenServerHost').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.free_functions('UTIL_PlayerByName').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.free_functions('UTIL_PlayerByUserId').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.free_functions('UTIL_FindClientInVisibilityPVS').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.free_functions('UTIL_EntitiesInPVS').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.free_functions('UTIL_FindClientInPVS').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
if self.settings.branch == 'swarm':
mb.free_functions('UTIL_FindClientInPVSGuts').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.free_functions('UTIL_GetLocalPlayerOrListenServerHost').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
# Helper for message stuff
cls = mb.class_('hudtextparms_s')
cls.include()
cls.rename('hudtextparms')
# Tracefilters
mb.class_('CTraceFilterMelee').include()
mb.class_('CTraceFilterMelee').calldefs('CTraceFilterMelee').exclude()
mb.class_('CTraceFilterMelee').add_wrapper_code(
"CTraceFilterMelee_wrapper(::CBaseEntity const * passentity, int collisionGroup, ::CTakeDamageInfo * dmgInfo, float flForceScale, bool bDamageAnyNPC )\r\n" + \
" : CTraceFilterMelee( boost::python::ptr(passentity), collisionGroup, boost::python::ptr(dmgInfo), flForceScale, bDamageAnyNPC )\r\n" + \
" , bp::wrapper< CTraceFilterMelee >(){\r\n" + \
" // constructor\r\n" + \
"}\r\n"
)
mb.class_('CTraceFilterMelee').add_registration_code(
'def( bp::init< CBaseEntity const *, int, CTakeDamageInfo *, float, bool >(( bp::arg("passentity"), bp::arg("collisionGroup"), bp::arg("dmgInfo"), bp::arg("flForceScale"), bp::arg("bDamageAnyNPC") )) )\r\n'
)
# Include explode functions
mb.free_functions('ExplosionCreate').include()
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NODAMAGE\" ) = SF_ENVEXPLOSION_NODAMAGE;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_REPEATABLE\" ) = SF_ENVEXPLOSION_REPEATABLE;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NOFIREBALL\" ) = SF_ENVEXPLOSION_NOFIREBALL;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NOSMOKE\" ) = SF_ENVEXPLOSION_NOSMOKE;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NODECAL\" ) = SF_ENVEXPLOSION_NODECAL;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NOSPARKS\" ) = SF_ENVEXPLOSION_NOSPARKS;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NOSOUND\" ) = SF_ENVEXPLOSION_NOSOUND;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_RND_ORIENT\" ) = SF_ENVEXPLOSION_RND_ORIENT;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NOFIREBALLSMOKE\" ) = SF_ENVEXPLOSION_NOFIREBALLSMOKE;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NOPARTICLES\" ) = SF_ENVEXPLOSION_NOPARTICLES;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NODLIGHTS\" ) = SF_ENVEXPLOSION_NODLIGHTS;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NOCLAMPMIN\" ) = SF_ENVEXPLOSION_NOCLAMPMIN;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_NOCLAMPMAX\" ) = SF_ENVEXPLOSION_NOCLAMPMAX;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_SURFACEONLY\" ) = SF_ENVEXPLOSION_SURFACEONLY;" )
mb.add_registration_code( "bp::scope().attr( \"SF_ENVEXPLOSION_GENERIC_DAMAGE\" ) = SF_ENVEXPLOSION_GENERIC_DAMAGE;" )
def Parse(self, mb):
# Exclude everything by default
mb.decls().exclude()
# Generic steam api call return result
mb.typedef('SteamAPICall_t').include()
# CSteamID
cls = mb.class_('CSteamID')
cls.include()
constpchararg = pointer_t(const_t(declarated_t(char_t())))
cls.constructors(matchers.calldef_matcher_t(arg_types=[constpchararg, None])).exclude()
cls.mem_funs('Render').exclude()
cls.mem_funs('SetFromStringStrict').exclude()
cls.mem_funs('SetFromString').exclude() # No definition...
cls.mem_funs('SetFromSteam2String').exclude() # No definition...
cls.mem_funs('BValidExternalSteamID').exclude() # No definition...
mb.enum('EResult').include()
mb.enum('EDenyReason').include()
mb.enum('EUniverse').include()
mb.enum('EAccountType').include()
mb.enum('ESteamUserStatType').include()
mb.enum('EChatEntryType').include()
mb.enum('EChatRoomEnterResponse').include()
mb.enum('EChatMemberStateChange').include()
# Generic API functions
mb.free_function('SteamAPI_RunCallbacks').include()
# Accessor class for all
mb.add_registration_code( "bp::scope().attr( \"steamapicontext\" ) = boost::ref(steamapicontext);" )
cls = mb.class_('CSteamAPIContext')
cls.include()
cls.mem_fun('Init').exclude()
cls.mem_fun('Clear').exclude()
cls.mem_fun('SteamApps').exclude()
cls.mem_fun('SteamMatchmakingServers').exclude()
cls.mem_fun('SteamHTTP').exclude()
cls.mem_fun('SteamScreenshots').exclude()
cls.mem_fun('SteamUnifiedMessages').exclude()
cls.mem_fun('SteamNetworking').exclude()
cls.mem_fun('SteamRemoteStorage').exclude()
cls.mem_funs('SteamFriends').call_policies = call_policies.return_internal_reference()
cls.mem_funs('SteamUtils').call_policies = call_policies.return_internal_reference()
cls.mem_funs('SteamMatchmaking').call_policies = call_policies.return_internal_reference()
cls.mem_funs('SteamUser').call_policies = call_policies.return_internal_reference()
cls.mem_funs('SteamUserStats').call_policies = call_policies.return_internal_reference()
mb.add_registration_code( "bp::scope().attr( \"QUERY_PORT_NOT_INITIALIZED\" ) = (int)QUERY_PORT_NOT_INITIALIZED;" )
mb.add_registration_code( "bp::scope().attr( \"QUERY_PORT_ERROR\" ) = (int)QUERY_PORT_ERROR;" )
# Friends
cls = mb.class_('ISteamFriends')
cls.include()
cls.mem_funs().virtuality = 'not virtual'
cls.mem_fun('GetFriendGamePlayed').exclude()
mb.enum('EFriendRelationship').include()
mb.enum('EPersonaState').include()
mb.add_registration_code( "bp::scope().attr( \"k_cchPersonaNameMax\" ) = (int)k_cchPersonaNameMax;" )
# User
cls = mb.class_('ISteamUser')
cls.include()
cls.mem_funs().virtuality = 'not virtual'
# Utils
cls = mb.class_('ISteamUtils')
cls.include()
cls.mem_funs().virtuality = 'not virtual'
cls.mem_fun('GetImageRGBA').exclude()
cls.mem_fun('GetImageSize').exclude()
self.ParseMatchmaking(mb)
self.ParseUserStats(mb)
#mb.class_('ISteamUtils').mem_funs('GetImageSize').add_transformation( FT.output('pnWidth'), FT.output('pnHeight'))
#mb.class_('ISteamUtils').mem_funs('GetCSERIPPort').add_transformation( FT.output('unIP'), FT.output('usPort'))
def customize(self, mb ):
mb.class_('numbers_t').operator('[]').call_policies = call_policies.return_internal_reference()
def add_autowrap_classes_to_builder(builder, component_name, classes):
# Convience dict for call policies
call_policies_collection = {
"reference_existing_object":
call_policies.return_value_policy(
call_policies.reference_existing_object),
"return_opaque_pointer":
call_policies.return_value_policy(call_policies.return_opaque_pointer),
"return_internal_reference":
call_policies.return_internal_reference(),
"copy_const_reference":
call_policies.return_value_policy(call_policies.copy_const_reference)
}
# Classes which have methods taking or returning PETSc vec or mat need to add
# this custom wrapper code to allow wrapping of PETSc opaque pointers. Any
# methods returning them also needs to set up opaque pointer management by
# choosing the Py++ 'return_opaque_pointer' option.
petsc_mat_custom_code = "BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID( _p_Mat )"
petsc_vec_custom_code = "BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID( _p_Vec )"
# Remove any classes not in this module. Also use the class to collect cell and population writers.
cell_writers = []
population_writers = []
classes_not_in_module = []
for eachClass in classes:
# Collect writers
if eachClass.full_path is not None:
if "/cell_based/src/writers/cell_writers/" in eachClass.full_path:
if "Abstract" not in eachClass.name:
cell_writers.append(eachClass.name)
if "/cell_based/src/writers/population_writers/" in eachClass.full_path:
if "Abstract" not in eachClass.name:
population_writers.append(eachClass.name)
if not eachClass.needs_auto_wrapper_generation():
continue
if eachClass.component != component_name:
full_class_names = eachClass.get_full_names()
for eachTemplatedClassName in full_class_names:
classes_not_in_module.append(
eachTemplatedClassName.replace(' ', ''))
builder.classes(lambda decl: decl.name.replace(' ', '') in
classes_not_in_module).exclude()
# Exclude all iterators
builder.classes(lambda x: x.name in ("Iterator", )).exclude()
# Set up the class in the Py++ builder
for eachClass in classes:
if not eachClass.needs_auto_wrapper_generation():
continue
if eachClass.component == component_name:
short_class_names = eachClass.get_short_names()
full_class_names = eachClass.get_full_names()
for idx, eachTemplatedClassName in enumerate(full_class_names):
# Add the class to the builder
print "Processing: ", eachTemplatedClassName, " aka ", short_class_names[
idx]
this_class = builder.class_(eachTemplatedClassName)
this_class.include()
# Rename the class with its short name, avoids having complicated
# class names, which Py++ would have to deal with, in the C++ wrapper code.
if (short_class_names[idx] != eachTemplatedClassName):
this_class.rename(short_class_names[idx])
# Set up member function excludes and pointer management
has_members = False
try:
this_class.member_functions()
has_members = True
except RuntimeError:
pass
has_constructors = False
try:
this_class.constructors()
has_constructors = True
except RuntimeError:
pass
add_petsc_vec_code = False
add_petsc_mat_code = False
petsc_vec_code_will_auto = False
petsc_mat_code_will_auto = False
if has_constructors:
for eachConstructor in this_class.constructors():
for eachArgType in eachConstructor.arguments:
declaration_string = eachArgType.decl_type.decl_string
default_value = eachArgType.default_value
if "Vec" in declaration_string and not "CellVecData" in declaration_string:
add_petsc_vec_code = True
if "Mat" in declaration_string:
add_petsc_mat_code = True
# Workaround for Bug with default arguments and templates.
# Assume the template value in the argument is the same as
# in the default.
if default_value is not None:
if "DIM" in default_value:
print "INFO: Found method default arguement with incomplete type. Guessing the type."
if "3" in declaration_string:
eachArgType.default_value = default_value.replace(
"DIM", str(3))
if "2" in declaration_string:
eachArgType.default_value = default_value.replace(
"DIM", str(2))
if has_members:
for eachMemberFunction in this_class.member_functions():
# Exclude any specified member functions
if eachClass.excluded_methods is not None and eachMemberFunction.name in eachClass.excluded_methods:
eachMemberFunction.exclude()
continue
# PETSc Vec and Mat args need special care
for eachArgType in eachMemberFunction.arguments:
declaration_string = eachArgType.decl_type.decl_string
default_value = eachArgType.default_value
if default_value is not None and "nullptr" in default_value:
eachArgType.default_value = default_value.replace(
"nullptr", "NULL")
#pprint (vars(eachArgType))
if "Vec" in declaration_string and not "CellVecData" in declaration_string:
add_petsc_vec_code = True
if "Mat" in declaration_string:
add_petsc_mat_code = True
# Bug with default arguments and templates
if eachArgType.default_value is not None:
if "DIM" in eachArgType.default_value:
print "INFO: Found method default arguement with incomplete type. Guessing the type."
if "3" in declaration_string:
eachArgType.default_value = default_value.replace(
"DIM", str(3))
if "2" in declaration_string:
eachArgType.default_value = default_value.replace(
"DIM", str(2))
# If there are explicit call policies add them
break_out = False
if eachClass.pointer_return_methods is not None:
for eachDefinedPointerPolicy in eachClass.pointer_return_methods:
if eachMemberFunction.name == eachDefinedPointerPolicy[
0]:
if eachDefinedPointerPolicy[
1] in call_policies_collection.keys(
):
eachMemberFunction.call_policies = call_policies_collection[
eachDefinedPointerPolicy[1]]
break_out = True
break
if break_out:
continue
# PETSc Vec and Mat need special care
if "Vec" in str(eachMemberFunction.return_type
) and not "CellVecData" in str(
eachMemberFunction.return_type):
eachMemberFunction.call_policies = call_policies_collection[
"return_opaque_pointer"]
petsc_vec_code_will_auto = True
continue
if "Mat" in str(eachMemberFunction.return_type):
eachMemberFunction.call_policies = call_policies_collection[
"return_opaque_pointer"]
petsc_mat_code_will_auto = True
continue
if declarations.is_pointer(
eachMemberFunction.return_type):
eachMemberFunction.call_policies = call_policies_collection[
"reference_existing_object"]
continue
if declarations.is_reference(
eachMemberFunction.return_type):
eachMemberFunction.call_policies = call_policies_collection[
"return_internal_reference"]
continue
# Explicitly remove abstract class constructors
# if "Abstract" in eachClass.name:
# this_class.constructors().exclude()
# Set up variable excludes
if eachClass.excluded_variables is not None:
for eachVariable in eachClass.excluded_variables:
this_class.variables(eachVariable).exclude()
# Add declaration code
if add_petsc_vec_code and not petsc_vec_code_will_auto:
print "Petsc Vec found: Adding custom declaration code."
this_class.add_declaration_code(petsc_vec_custom_code)
if add_petsc_mat_code and not petsc_mat_code_will_auto:
print "Petsc Mat found: Adding custom declaration code."
this_class.add_declaration_code(petsc_mat_custom_code)
if eachClass.declaration_code is not None:
for eachLine in eachClass.declaration_code:
this_class.add_declaration_code(eachLine)
# If this is a suitable class (i.e. concentrete cell population)
# add writer template functions.
if eachClass.full_path is not None:
if "/cell_based/src/population/" in eachClass.full_path:
if "Abstract" not in eachClass.name and "CellwiseDataGradient" not in eachClass.name:
if "BasedCellPopulation" in eachClass.name:
for eachWriter in cell_writers:
writer_prefix = 'def("AddCellWriter' + eachWriter + '", &'
writer_suffix = '::AddCellWriter<' + eachWriter + '>)'
this_class.add_registration_code(
writer_prefix +
eachTemplatedClassName + writer_suffix)
for eachWriter in population_writers:
writer_prefix = 'def("AddPopulationWriter' + eachWriter + '", &'
writer_suffix = '::AddPopulationWriter<' + eachWriter + '>)'
this_class.add_registration_code(
writer_prefix +
eachTemplatedClassName + writer_suffix)
# Bug with null type in default template arguements
for eachTemplate in ["<2>", "<3>"]:
builder.class_("AbstractPdeModifier" +
eachTemplate).constructors().exclude()
builder.class_('AbstractPdeModifier' +
eachTemplate).calldefs().use_default_arguments = False
# Don't return non-const reference for ChastePoint
returns_non_const_ref = builder.class_('ChastePoint<3>').member_functions(
return_type="::boost::numeric::ublas::c_vector<double, 3> &")
returns_non_const_ref.exclude()
returns_non_const_ref = builder.class_('ChastePoint<2>').member_functions(
return_type="::boost::numeric::ublas::c_vector<double, 2> &")
returns_non_const_ref.exclude()
return builder, classes
def ParsePanel(self, mb):
# List of functions that should be overridable
mb.mem_funs('SetVisible').virtuality = 'virtual'
mb.mem_funs('SetParent').virtuality = 'virtual'
mb.mem_funs('SetEnabled').virtuality = 'virtual'
mb.mem_funs('SetBgColor').virtuality = 'virtual'
mb.mem_funs('SetFgColor').virtuality = 'virtual'
mb.mem_funs('SetCursor').virtuality = 'virtual'
mb.mem_funs('InvalidateLayout').virtuality = 'virtual'
mb.mem_funs('SetBorder').virtuality = 'virtual'
mb.mem_funs('SetPaintBorderEnabled').virtuality = 'virtual'
mb.mem_funs('SetPaintBackgroundEnabled').virtuality = 'virtual'
mb.mem_funs('SetPaintEnabled').virtuality = 'virtual'
mb.mem_funs('SetPaintBackgroundType').virtuality = 'virtual'
mb.mem_funs('SetScheme').virtuality = 'virtual'
mb.mem_funs('ApplySchemeSettings').virtuality = 'virtual'
mb.mem_funs('OnCommand').virtuality = 'virtual'
mb.mem_funs('OnMouseCaptureLost').virtuality = 'virtual'
mb.mem_funs('OnSetFocus').virtuality = 'virtual'
mb.mem_funs('OnKillFocus').virtuality = 'virtual'
mb.mem_funs('OnDelete').virtuality = 'virtual'
mb.mem_funs('OnThink').virtuality = 'virtual'
mb.mem_funs('OnChildAdded').virtuality = 'virtual'
mb.mem_funs('OnSizeChanged').virtuality = 'virtual'
mb.mem_funs('OnTick').virtuality = 'virtual'
mb.mem_funs('OnCursorMoved').virtuality = 'virtual'
mb.mem_funs('OnCursorEntered').virtuality = 'virtual'
mb.mem_funs('OnCursorExited').virtuality = 'virtual'
mb.mem_funs('OnMousePressed').virtuality = 'virtual'
mb.mem_funs('OnMouseDoublePressed').virtuality = 'virtual'
mb.mem_funs('OnMouseReleased').virtuality = 'virtual'
mb.mem_funs('OnMouseWheeled').virtuality = 'virtual'
mb.mem_funs('OnMouseTriplePressed').virtuality = 'virtual'
mb.mem_funs('OnKeyCodePressed').virtuality = 'virtual'
mb.mem_funs('OnKeyCodeTyped').virtuality = 'virtual'
mb.mem_funs('OnKeyCodeReleased').virtuality = 'virtual'
mb.mem_funs('OnKeyFocusTicked').virtuality = 'virtual'
mb.mem_funs('OnMouseFocusTicked').virtuality = 'virtual'
mb.mem_funs('PaintBackground').virtuality = 'virtual'
mb.mem_funs('Paint').virtuality = 'virtual'
#mb.mem_funs('PaintBorder').virtuality = 'virtual' # TODO: Don't believe we are ever interested in painting borders in python
mb.mem_funs('PaintBuildOverlay').virtuality = 'virtual'
mb.mem_funs('PostChildPaint').virtuality = 'virtual'
mb.mem_funs('PerformLayout').virtuality = 'virtual'
mb.mem_funs('SetMouseInputEnabled').virtuality = 'virtual'
mb.mem_funs('SetKeyBoardInputEnabled').virtuality = 'virtual'
mb.mem_funs('SetDragEnabled').virtuality = 'virtual'
mb.mem_funs('OnRequestFocus').virtuality = 'virtual'
mb.mem_funs('OnScreenSizeChanged').virtuality = 'virtual'
# Transformations
mb.mem_funs( 'GetPos' ).add_transformation( FT.output('x'), FT.output('y') )
mb.class_('Panel').mem_funs( 'GetSize' ).add_transformation( FT.output('wide'), FT.output('tall') )
mb.class_('Panel').mem_funs( 'GetBounds' ).add_transformation( FT.output('x'), FT.output('y'), FT.output('wide'), FT.output('tall') )
mb.mem_funs( 'GetMinimumSize' ).add_transformation( FT.output('wide'), FT.output('tall') )
mb.mem_funs( 'LocalToScreen' ).add_transformation( FT.inout('x'), FT.inout('y') )
mb.mem_funs( 'ScreenToLocal' ).add_transformation( FT.inout('x'), FT.inout('y') )
mb.mem_funs( 'ParentLocalToScreen' ).add_transformation( FT.inout('x'), FT.inout('y') )
mb.mem_funs( 'GetInset' ).add_transformation( FT.output('left'), FT.output('top'), FT.output('right'), FT.output('bottom') )
mb.mem_funs( 'GetPaintSize' ).add_transformation( FT.output('wide'), FT.output('tall') )
mb.mem_funs( 'GetClipRect' ).add_transformation( FT.output('x0'), FT.output('y0'), FT.output('x1'), FT.output('y1') )
mb.mem_funs( 'GetPinOffset' ).add_transformation( FT.output('dx'), FT.output('dy') )
mb.mem_funs( 'GetResizeOffset' ).add_transformation( FT.output('dx'), FT.output('dy') )
mb.mem_funs( 'GetCornerTextureSize' ).add_transformation( FT.output('w'), FT.output('h') )
# Exclude list
mb.mem_funs('QueryInterface').exclude()
# We don't care about build mode, since we can easily reload modules in python
# We also don't want the user to be able to call methods like Delete.
mb.mem_funs('IsBuildModeEditable').exclude()
mb.mem_funs('SetBuildModeEditable').exclude()
mb.mem_funs('IsBuildModeDeletable').exclude()
mb.mem_funs('SetBuildModeDeletable').exclude()
mb.mem_funs('IsBuildModeActive').exclude()
#mb.mem_funs('SetAutoDelete').exclude()
#mb.mem_funs('IsAutoDeleteSet').exclude()
mb.mem_funs('OnDelete').exclude()
mb.mem_funs('MarkForDeletion').exclude()
mb.mem_funs('SetBuildGroup').exclude()
mb.mem_funs('IsBuildGroupEnabled').exclude()
mb.mem_funs('CreateControlByName').exclude()
mb.mem_funs('LoadKeyBindings').exclude()
mb.mem_funs('SaveKeyBindingsToBuffer').exclude()
mb.mem_funs('LookupBoundKeys').exclude()
mb.mem_funs('OnKeyTyped').exclude()
mb.mem_funs('HasHotkey').exclude()
mb.mem_funs('GetDragData').exclude()
if self.settings.branch == 'swarm':
mb.mem_funs('GetDragFailCursor').exclude()
mb.mem_funs('GetDropCursor').exclude()
mb.mem_funs('GetDropTarget').exclude()
mb.mem_funs('IsDroppable').exclude()
mb.mem_funs('OnPanelDropped').exclude()
mb.mem_funs('OnPanelEnteredDroppablePanel').exclude()
mb.mem_funs('OnPanelExitedDroppablePanel').exclude()
mb.mem_funs('OnDragFailed').exclude()
mb.mem_funs('OnDropContextHoverHide').exclude()
mb.mem_funs('OnDropContextHoverShow').exclude()
mb.mem_funs('OnDroppablePanelPaint').exclude()
mb.mem_funs('OnGetAdditionalDragPanels').exclude()
mb.mem_funs('OnDragFailed').exclude()
mb.vars('m_PanelMap').exclude()
mb.vars('m_MessageMap').exclude()
mb.mem_funs('GetPanelMap').exclude()
if self.settings.branch == 'source2013':
mb.mem_funs('GetChildren').exclude()
# Must use return_by_value. Then the converter will be used to wrap the vgui element in a safe handle
mb.mem_funs( 'GetChild' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetBorder' ).call_policies = call_policies.return_value_policy( call_policies.reference_existing_object )
if self.settings.branch == 'source2007':
mb.mem_funs('GetBorderAtIndex').call_policies = call_policies.return_value_policy( call_policies.reference_existing_object )
mb.mem_funs( 'GetParent' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'FindSiblingByName' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'FindChildByName' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'HasHotkey' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetPanelWithKeyBindings' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'LookupBinding' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'LookupBindingByKeyCode' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'LookupDefaultKey' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'LookupMapForBinding' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetTooltip' ).call_policies = call_policies.return_internal_reference()
mb.mem_funs( 'GetDragDropInfo' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetDragPanel' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetPanel' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'FindPanelAnimationEntry' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'FindDropTargetPanel' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
if self.settings.branch == 'swarm':
mb.mem_funs( 'GetNavDown' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetNavDownPanel' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetNavLeft' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetNavLeftPanel' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetNavRight' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetNavRightPanel' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetNavUp' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'GetNavUpPanel' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'NavigateDown' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'NavigateLeft' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'NavigateRight' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'NavigateTo' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'NavigateUp' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'SetNavDown' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'SetNavLeft' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'SetNavRight' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
mb.mem_funs( 'SetNavUp' ).call_policies = call_policies.return_value_policy(call_policies.return_by_value)
# Exclude
mb.mem_funs('OnUnserialized').exclude()
mb.mem_funs('GetSizer').exclude()
mb.mem_funs('GetUnpackStructure').exclude()
if self.settings.branch == 'swarm':
# Tooltip class
cls = mb.class_('Tooltip')
cls.include()
def ParseClient(self, mb):
# Dynamic lights
mb.class_('PyDLight').include()
mb.class_('PyDLight').rename('DLight')
mb.class_('PyELight').include()
mb.class_('PyELight').rename('ELight')
cls = mb.class_('PyDBaseLight')
cls.include()
cls.rename('DBaseLight')
cls.mem_funs().exclude()
cls.mem_funs(
'GetColor'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs(
'GetDirection'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs(
'GetOrigin'
).call_policies = call_policies.return_internal_reference()
cls.add_property('origin', cls.member_function('GetOrigin'),
cls.member_function('SetOrigin'))
cls.add_property('color', cls.member_function('GetColor'),
cls.member_function('SetColor'))
cls.add_property('die', cls.member_function('GetDie'),
cls.member_function('SetDie'))
cls.add_property('radius', cls.member_function('GetRadius'),
cls.member_function('SetRadius'))
cls.add_property('flags', cls.member_function('GetFlags'),
cls.member_function('SetFlags'))
cls.add_property('minlight', cls.member_function('GetMinlight'),
cls.member_function('SetMinlight'))
cls.add_property('decay', cls.member_function('GetDecay'),
cls.member_function('SetDecay'))
cls.add_property('style', cls.member_function('GetStyle'),
cls.member_function('SetStyle'))
cls.add_property('direction', cls.member_function('GetDirection'),
cls.member_function('SetDirection'))
cls.add_property('innerangle', cls.member_function('GetInnerAngle'),
cls.member_function('SetInnerAngle'))
cls.add_property('outerangle', cls.member_function('GetOuterAngle'),
cls.member_function('SetOuterAngle'))
mb.add_registration_code(
"bp::scope().attr( \"DLIGHT_NO_WORLD_ILLUMINATION\" ) = (int)DLIGHT_NO_WORLD_ILLUMINATION;"
)
mb.add_registration_code(
"bp::scope().attr( \"DLIGHT_NO_MODEL_ILLUMINATION\" ) = (int)DLIGHT_NO_MODEL_ILLUMINATION;"
)
mb.add_registration_code(
"bp::scope().attr( \"DLIGHT_ADD_DISPLACEMENT_ALPHA\" ) = (int)DLIGHT_ADD_DISPLACEMENT_ALPHA;"
)
mb.add_registration_code(
"bp::scope().attr( \"DLIGHT_SUBTRACT_DISPLACEMENT_ALPHA\" ) = (int)DLIGHT_SUBTRACT_DISPLACEMENT_ALPHA;"
)
mb.add_registration_code(
"bp::scope().attr( \"DLIGHT_DISPLACEMENT_MASK\" ) = (int)DLIGHT_DISPLACEMENT_MASK;"
)
# Base particle
cls = mb.class_('Particle')
cls.include()
cls.vars('m_Pos').rename('pos')
cls.var('m_pNext').exclude()
cls.var('m_pPrev').exclude()
cls.var('m_pSubTexture').exclude()
# Simple particle
mb.class_('SimpleParticle').include()
mb.class_('SimpleParticle').vars('m_flDieTime').rename('dietime')
mb.class_('SimpleParticle').vars('m_flLifetime').rename('lifetime')
mb.class_('SimpleParticle').vars('m_flRoll').rename('roll')
mb.class_('SimpleParticle').vars('m_flRollDelta').rename('rolldelta')
mb.class_('SimpleParticle').vars('m_iFlags').rename('flags')
mb.class_('SimpleParticle').vars('m_uchColor').rename('color')
mb.class_('SimpleParticle').vars('m_uchEndAlpha').rename('endalpha')
mb.class_('SimpleParticle').vars('m_uchEndSize').rename('endsize')
mb.class_('SimpleParticle').vars('m_uchStartAlpha').rename(
'startalpha')
mb.class_('SimpleParticle').vars('m_uchStartSize').rename('startsize')
mb.class_('SimpleParticle').vars('m_vecVelocity').rename('velocity')
mb.enum('SimpleParticleFlag_t').include()
# Textures
cls = mb.class_('CParticleSubTexture')
cls.include()
cls.no_init = True
cls.calldefs().exclude()
cls.vars().exclude()
cls = mb.class_('CParticleSubTextureGroup')
cls.include()
cls.no_init = True
cls.calldefs().exclude()
cls.vars().exclude()
# CParticleCollection
cls = mb.class_('CParticleCollection')
cls.include()
cls.no_init = True
cls.mem_funs().virtuality = 'not virtual'
cls.vars().exclude()
cls.calldefs().exclude()
cls.mem_fun('IsValid').include()
# CNewParticleEffect
cls = mb.class_('CNewParticleEffect')
cls.include()
cls.no_init = True
cls.mem_funs().virtuality = 'not virtual'
cls.mem_fun('IsReleased').exclude()
cls.mem_funs('AddParticle').exclude()
cls.mem_funs(
'GetPMaterial'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs('ReplaceWith').exclude()
cls.vars('m_pNext').exclude()
cls.vars('m_pPrev').exclude()
cls.mem_funs(
'GetOwner').call_policies = call_policies.return_value_policy(
call_policies.return_by_value)
if self.settings.branch == 'swarm':
cls.mem_funs(
'Create'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs(
'CreateOrAggregate'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs(
'CreateOrAggregatePrecached'
).call_policies = call_policies.return_internal_reference()
else:
cls.mem_funs('Create').exclude() # TODO/FIXME
#mb.class_('CNewParticleEffectHandle').include()
#mb.class_('CNewParticleEffectHandle').mem_funs('GetParticleEffect').exclude()
# ParticleManager
cls = mb.class_('CParticleMgr')
cls.include()
cls.calldefs('CParticleMgr').exclude()
cls.no_init = True
cls.mem_funs(
'GetPMaterial'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs('AllocParticle').exclude()
cls.mem_funs('CreateEffect').exclude()
cls.mem_funs('GetModelView').exclude()
cls.mem_funs('PMaterialToIMaterial').exclude()
if self.settings.branch == 'swarm':
cls.mem_funs(
'CreateNonDrawingEffect'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs(
'FirstNewEffect'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs(
'NextNewEffect'
).call_policies = call_policies.return_internal_reference()
mb.free_function('ParticleMgr').include()
mb.free_function(
'ParticleMgr').call_policies = call_policies.return_value_policy(
call_policies.reference_existing_object)
# Add effects
mb.free_function('AddSimpleParticle').include()
mb.free_function('AddEmberParticle').include()
mb.free_function('AddFireSmokeParticle').include()
mb.free_function('AddFireParticle').include()
cls = mb.class_('CParticleProperty')
cls.include()
cls.mem_funs(
'Create').call_policies = call_policies.return_internal_reference(
)
cls.mem_funs(
'GetParticleEffectFromIdx'
).call_policies = call_policies.return_internal_reference()
mb.mem_funs(
'GetOuter').call_policies = call_policies.return_value_policy(
call_policies.return_by_value)
mb.mem_funs('GetBaseMap').exclude()
mb.mem_funs('GetDataDescMap').exclude()
mb.mem_funs('GetPredDescMap').exclude()
if self.settings.branch == 'swarm':
mb.mem_funs('CreatePrecached').exclude()
def ParseClient(self, mb):
# Dynamic lights
mb.class_('PyDLight').include()
mb.class_('PyDLight').rename('DLight')
mb.class_('PyELight').include()
mb.class_('PyELight').rename('ELight')
cls = mb.class_('PyDBaseLight')
cls.include()
cls.rename('DBaseLight')
cls.mem_funs().exclude()
cls.mem_funs('GetColor').call_policies = call_policies.return_internal_reference()
cls.mem_funs('GetDirection').call_policies = call_policies.return_internal_reference()
cls.mem_funs('GetOrigin').call_policies = call_policies.return_internal_reference()
cls.add_property( 'origin' , cls.member_function( 'GetOrigin' ), cls.member_function( 'SetOrigin' ) )
cls.add_property( 'color' , cls.member_function( 'GetColor' ), cls.member_function( 'SetColor' ) )
cls.add_property( 'die' , cls.member_function( 'GetDie' ), cls.member_function( 'SetDie' ) )
cls.add_property( 'radius' , cls.member_function( 'GetRadius' ), cls.member_function( 'SetRadius' ) )
cls.add_property( 'flags' , cls.member_function( 'GetFlags' ), cls.member_function( 'SetFlags' ) )
cls.add_property( 'minlight' , cls.member_function( 'GetMinlight' ), cls.member_function( 'SetMinlight' ) )
cls.add_property( 'decay' , cls.member_function( 'GetDecay' ), cls.member_function( 'SetDecay' ) )
cls.add_property( 'style' , cls.member_function( 'GetStyle' ), cls.member_function( 'SetStyle' ) )
cls.add_property( 'direction' , cls.member_function( 'GetDirection' ), cls.member_function( 'SetDirection' ) )
cls.add_property( 'innerangle' , cls.member_function( 'GetInnerAngle' ), cls.member_function( 'SetInnerAngle' ) )
cls.add_property( 'outerangle' , cls.member_function( 'GetOuterAngle' ), cls.member_function( 'SetOuterAngle' ) )
mb.add_registration_code( "bp::scope().attr( \"DLIGHT_NO_WORLD_ILLUMINATION\" ) = (int)DLIGHT_NO_WORLD_ILLUMINATION;" )
mb.add_registration_code( "bp::scope().attr( \"DLIGHT_NO_MODEL_ILLUMINATION\" ) = (int)DLIGHT_NO_MODEL_ILLUMINATION;" )
mb.add_registration_code( "bp::scope().attr( \"DLIGHT_ADD_DISPLACEMENT_ALPHA\" ) = (int)DLIGHT_ADD_DISPLACEMENT_ALPHA;" )
mb.add_registration_code( "bp::scope().attr( \"DLIGHT_SUBTRACT_DISPLACEMENT_ALPHA\" ) = (int)DLIGHT_SUBTRACT_DISPLACEMENT_ALPHA;" )
mb.add_registration_code( "bp::scope().attr( \"DLIGHT_DISPLACEMENT_MASK\" ) = (int)DLIGHT_DISPLACEMENT_MASK;" )
# Base particle
cls = mb.class_('Particle')
cls.include()
cls.vars('m_Pos').rename('pos')
cls.var('m_pNext').exclude()
cls.var('m_pPrev').exclude()
cls.var('m_pSubTexture').exclude()
# Simple particle
mb.class_('SimpleParticle').include()
mb.class_('SimpleParticle').vars('m_flDieTime').rename('dietime')
mb.class_('SimpleParticle').vars('m_flLifetime').rename('lifetime')
mb.class_('SimpleParticle').vars('m_flRoll').rename('roll')
mb.class_('SimpleParticle').vars('m_flRollDelta').rename('rolldelta')
mb.class_('SimpleParticle').vars('m_iFlags').rename('flags')
mb.class_('SimpleParticle').vars('m_uchColor').rename('color')
mb.class_('SimpleParticle').vars('m_uchEndAlpha').rename('endalpha')
mb.class_('SimpleParticle').vars('m_uchEndSize').rename('endsize')
mb.class_('SimpleParticle').vars('m_uchStartAlpha').rename('startalpha')
mb.class_('SimpleParticle').vars('m_uchStartSize').rename('startsize')
mb.class_('SimpleParticle').vars('m_vecVelocity').rename('velocity')
mb.enum('SimpleParticleFlag_t').include()
# Textures
cls = mb.class_('CParticleSubTexture')
cls.include()
cls.no_init = True
cls.calldefs().exclude()
cls.vars().exclude()
cls = mb.class_('CParticleSubTextureGroup')
cls.include()
cls.no_init = True
cls.calldefs().exclude()
cls.vars().exclude()
# CNewParticleEffect
cls = mb.class_('CNewParticleEffect')
cls.include()
cls.mem_funs().virtuality = 'not virtual'
cls.mem_funs('AddParticle').exclude()
cls.mem_funs('GetPMaterial').call_policies = call_policies.return_internal_reference()
cls.mem_funs('ReplaceWith').exclude()
cls.vars('m_pNext').exclude()
cls.vars('m_pPrev').exclude()
cls.mem_funs('GetOwner').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
if self.settings.branch == 'swarm':
cls.mem_funs('Create').call_policies = call_policies.return_internal_reference()
cls.mem_funs('CreateOrAggregate').call_policies = call_policies.return_internal_reference()
cls.mem_funs('CreateOrAggregatePrecached').call_policies = call_policies.return_internal_reference()
else:
cls.mem_funs('Create').exclude() # TODO/FIXME
#mb.class_('CNewParticleEffectHandle').include()
#mb.class_('CNewParticleEffectHandle').mem_funs('GetParticleEffect').exclude()
# ParticleManager
cls = mb.class_('CParticleMgr')
cls.include()
cls.calldefs('CParticleMgr').exclude()
cls.no_init = True
cls.mem_funs('GetPMaterial').call_policies = call_policies.return_internal_reference()
cls.mem_funs('AllocParticle').exclude()
cls.mem_funs('CreateEffect').exclude()
cls.mem_funs('GetModelView').exclude()
cls.mem_funs('PMaterialToIMaterial').exclude()
if self.settings.branch == 'swarm':
cls.mem_funs('CreateNonDrawingEffect').call_policies = call_policies.return_internal_reference()
cls.mem_funs('FirstNewEffect').call_policies = call_policies.return_internal_reference()
cls.mem_funs('NextNewEffect').call_policies = call_policies.return_internal_reference()
mb.free_function('ParticleMgr').include()
mb.free_function('ParticleMgr').call_policies = call_policies.return_value_policy( call_policies.reference_existing_object )
# Add effects
mb.free_function('AddSimpleParticle').include()
mb.free_function('AddEmberParticle').include()
mb.free_function('AddFireSmokeParticle').include()
mb.free_function('AddFireParticle').include()
cls = mb.class_('CParticleProperty')
cls.include()
cls.mem_funs('Create').call_policies = call_policies.return_internal_reference()
cls.mem_funs('GetParticleEffectFromIdx').call_policies = call_policies.return_internal_reference()
mb.mem_funs('GetOuter').call_policies = call_policies.return_value_policy( call_policies.return_by_value )
mb.mem_funs('GetBaseMap').exclude()
mb.mem_funs('GetDataDescMap').exclude()
mb.mem_funs('GetPredDescMap').exclude()
if self.settings.branch == 'swarm':
mb.mem_funs('CreatePrecached').exclude()
def customize( self, mb ):
mb.global_ns.calldefs().create_with_signature = True
hello_world = mb.free_fun( 'hello_world' )
hello_world.add_transformation( ft.output(0) )
calc = mb.class_('calculator_t' )
assign_funs = calc.mem_funs( lambda decl: decl.name.startswith( 'assign' ) )
assign_funs.add_transformation( ft.output(0), ft.output(1) )
clone_and_assign_5 = calc.mem_fun( 'clone_and_assign_5' )
clone_and_assign_5.add_transformation( ft.output(0) )
clone_and_assign_5.call_policies = call_policies.return_value_policy( call_policies.manage_new_object )
window = mb.class_( 'window_t' )
window.mem_fun( 'resize' ).add_transformation( ft.input(0), ft.input(1) )
window.mem_fun( 'resize_in_out' ).add_transformation( ft.inout(0), ft.inout(1) )
point3d = mb.class_( 'point3d_t' )
point3d.add_wrapper_code( '' )
point3d.mem_fun( 'initialize' ).add_transformation( ft.input_static_array(0, size=3) )
point3d.mem_fun( 'position' ).add_transformation( ft.output_static_array(0, size=3) )
distance = point3d.mem_fun( 'distance' )
distance.add_transformation( ft.output(1) )
distance.transformations[0].controller.add_pre_call_code( '//dddddddddddddd' )
distance.transformations[0].controller.add_post_call_code( '//qqqqqqqqqqqqq' )
image = mb.class_( "image_t" )
image.always_expose_using_scope = True
image.member_function( "get_size" )
image.member_function( "get_size" ).add_transformation( ft.output(0), ft.output(1) )
image.member_function( "get_one_value" ).add_transformation( ft.output(0) )
image.member_function( "get_size2" ).add_transformation( ft.output(0), ft.output(1) )
image.member_function( "input_arg" ).add_transformation( ft.input(0) )
image.member_function( "fixed_input_array" ).add_transformation( ft.input_static_array(0,3) )
image.member_function( "fixed_output_array" ).add_transformation( ft.output_static_array(0,3) )
mb.free_function("get_cpp_instance").call_policies \
= call_policies.return_value_policy(call_policies.reference_existing_object)
mb.variable( "cpp_instance" ).exclude()
cls = mb.class_("no_virtual_members_t")
cls.member_function("member").add_transformation( ft.output(0) )
cls = mb.class_("ft_private_destructor_t")
cls.member_function("get_value").add_transformation( ft.output(0) )
mb.decls(lambda decl: decl.name.startswith("_")).exclude()
cls = mb.class_("bug_render_target_t")
cls.mem_fun("get_statistics", arg_types=['float &']*2).add_transformation( ft.output(0), ft.output(1) )
cls = mb.class_( 'modify_type_tester_t' )
do_nothing = cls.mem_fun( 'do_nothing' )
do_nothing.add_transformation( ft.modify_type(0, declarations.remove_reference ) )
clone = cls.mem_fun( 'clone' )
clone.call_policies = call_policies.return_value_policy( call_policies.manage_new_object )
clone.add_transformation( ft.modify_type(0, declarations.remove_reference ) )
cls = mb.class_( 'input_c_buffer_tester_t')
write_mf = cls.mem_fun( 'write' )
write_mf.add_transformation( ft.input_c_buffer( 'buffer', 'size' ) )
write_s = cls.mem_fun( 'write_s' )
write_s.add_transformation( ft.input_c_buffer( 'buffer', 'size' ) )
resource = mb.class_( 'resources_t' )
resource.held_type = 'std::auto_ptr< %s >' % resource.decl_string
transfer_ownership_tester = mb.class_( 'transfer_ownership_tester_t' )
tester = transfer_ownership_tester.mem_fun( 'tester' )
tester.add_transformation( ft.transfer_ownership( 0 ) )
render_queue_listener_t = mb.class_( 'render_queue_listener_t' )
render_queue_ended = render_queue_listener_t.mem_fun( 'render_queue_ended' )
render_queue_ended.add_transformation( ft.inout(2) )
ft_bugs = mb.namespace( 'ft_bugs' )
h = ft_bugs.mem_fun( 'h' )
h.add_transformation( ft.modify_type(0, remove_const_ref ) )
h.call_policies = call_policies.return_internal_reference()
h2 = ft_bugs.mem_fun( 'h2' )
h2.add_transformation( ft.modify_type(0, remove_const_ref ) )
h2.call_policies = call_policies.return_internal_reference()
ft_bugs.class_( 'B' ).always_expose_using_scope = True
ft_bugs.mem_fun( 'get_a' ).call_policies \
= call_policies.return_value_policy( call_policies.reference_existing_object )
ft_bugs2 = mb.namespace( 'ft_bugs2' )
g = ft_bugs2.mem_fun( 'g' )
g.add_transformation( ft.modify_type(0, remove_const_ref ) )
g.call_policies = call_policies.return_internal_reference()
def ParseHUD(self, mb):
# CHud
cls = mb.class_('CHud')
cls.include()
if self.settings.branch == 'swarm':
mb.free_function('GetHud').include()
mb.free_function(
'GetHud').call_policies = call_policies.return_value_policy(
call_policies.reference_existing_object)
else:
mb.vars('gHUD').include()
cls.mem_funs(
'FindElement').call_policies = call_policies.return_value_policy(
call_policies.return_by_value)
if self.settings.branch != 'swarm': # ASW should use HudIcons() / CHudIcons
#cls.mem_funs( 'GetIcon' ).call_policies = call_policies.return_value_policy( call_policies.manage_new_object )
#cls.mem_funs( 'AddUnsearchableHudIconToList' ).call_policies = call_policies.return_value_policy( call_policies.manage_new_object )
#cls.mem_funs( 'AddSearchableHudIconToList' ).call_policies = call_policies.return_value_policy( call_policies.manage_new_object )
# The HUD only cleans up when you close the game, so internal references should't be a problem.
cls.mem_funs(
'GetIcon'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs(
'AddUnsearchableHudIconToList'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs(
'AddSearchableHudIconToList'
).call_policies = call_policies.return_internal_reference()
cls.vars('m_HudList').exclude()
if self.settings.branch == 'swarm':
cls.mem_funs('GetHudList').exclude()
cls.mem_funs('GetHudPanelList').exclude()
cls = mb.class_('CHudElement')
cls.include()
cls.mem_funs('GetName').exclude()
cls.vars('m_pyInstance').exclude()
cls.mem_funs('SetActive').virtuality = 'not virtual'
cls.mem_funs('IsActive').virtuality = 'not virtual'
cls.mem_funs(
'ShouldDraw'
).virtuality = 'not virtual' # TODO: What if we need better control in Python?
cls.mem_funs(
'ProcessInput'
).virtuality = 'not virtual' # TODO: Do we ever need this in Python?
cls = mb.class_('CPyHudElementHelper')
cls.include()
cls.rename('CHudElementHelper')
cls.mem_funs('GetNext').exclude()
# HudIcons
if self.settings.branch == 'swarm':
cls = mb.class_('CHudIcons')
cls.include()
# FIXME
cls.mem_funs(
'GetIcon'
).call_policies = call_policies.return_internal_reference()
#cls.mem_funs('GetIcon').call_policies = call_policies.return_value_policy(call_policies.reference_existing_object)
#cls.mem_funs('GetIcon' ).call_policies = call_policies.return_value_policy( call_policies.manage_new_object )
cls.mem_funs('AddUnsearchableHudIconToList').exclude()
cls.mem_funs('AddSearchableHudIconToList').exclude()
#cls.mem_funs('AddUnsearchableHudIconToList').call_policies = call_policies.return_value_policy( call_policies.manage_new_object )
#cls.mem_funs('AddSearchableHudIconToList').call_policies = call_policies.return_value_policy( call_policies.manage_new_object )
mb.free_function('HudIcons').include()
mb.free_function(
'HudIcons').call_policies = call_policies.return_value_policy(
call_policies.reference_existing_object)
# CHudTexture
mb.class_('CHudTexture').include()
#mb.free_function( "gWarn" ).include( )
#mb.free_function( "gError" ).include( )
#mb.free_function( "gCError" ).include( )
for c in mb.namespace( "xfx" ).classes( ):
c.add_registration_code( ''.join( ( 'bp::register_ptr_to_python< boost::shared_ptr< ', c.demangled, ' const > >( );' ) ), False )
c.add_registration_code( ''.join( ( 'bp::implicitly_convertible< boost::shared_ptr< ', c.demangled, ' >, boost::shared_ptr< ', c.demangled, ' const > >( );' ) ), False )
mb.class_( "DrawTools" ).member_functions( "PushDraw2DSprite" ).rename( "push_draw_2d_sprite" )
mb.class_( "DrawTools" ).member_functions( "PushDraw2DText" ).rename( "push_draw_2d_text" )
mb.class_( "DrawTools" ).member_functions( "PushDraw3DSprite" ).rename( "push_draw_3d_sprite" )
mb.class_( "DrawTools" ).member_functions( "PushDraw3DText" ).rename( "push_draw_3d_text" )
mb.member_functions( "Instance" ).call_policies = call_policies.return_value_policy( call_policies.reference_existing_object )
mb.free_function( "gGetApplication" ).call_policies = call_policies.return_value_policy( call_policies.reference_existing_object )
mb.class_( "BooksManager" ).member_function( "GetBook" ).call_policies = call_policies.return_internal_reference( )
mb.class_( "Shader" ).member_function( "GetTextureInfoOnStage" ).call_policies = call_policies.return_internal_reference( )
mb.class_( "Pack" ).member_function( "FindFile" ).call_policies = call_policies.return_internal_reference( )
mb.class_( "Pack" ).member_function( "GetFirstFile" ).call_policies = call_policies.return_internal_reference( )
mb.class_( "Pack" ).member_function( "GetLastFile" ).call_policies = call_policies.return_internal_reference( )
mb.class_( "ParticleSystem" ).member_functions( "GetSubSystem" ).call_policies = call_policies.return_internal_reference( )
mb.class_( "ParticleSystem" ).member_functions( "GetParticle" ).call_policies = call_policies.return_internal_reference( )
mb.class_( "BaseParticleSystem" ).member_function( "EmitterTransformation", return_type = '::xfx::Mat4 &' ).call_policies = call_policies.return_internal_reference( )
mb.class_( "Quaternion" ).member_function( "FromAxisAngle" ).call_policies = call_policies.return_self( )
mb.class_( "Mat3" ).member_functions( return_type = '::xfx::Mat3 &' ).call_policies = call_policies.return_self( )
mb.class_( "Mat4" ).member_functions( return_type = '::xfx::Mat4 &' ).call_policies = call_policies.return_self( )
mb.class_( "Euler" ).member_functions( lambda x: x.name in ( "FromMat4", "FromVec3", "FromQuaternion" ) ).call_policies = call_policies.return_self( )
mb.class_( "Renderer" ).member_function( "GetFrameStatistics", return_type = '::xfx::Renderer::FrameStatistics &' ).call_policies = call_policies.return_internal_reference( )
mb.class_( "Renderer" ).member_function( "GetDrawTools", return_type = '::xfx::DrawTools &' ).call_policies = call_policies.return_internal_reference( )
mb.class_( "MeshState" ).member_function( "GetShaderParams", return_type = '::xfx::ShaderParams &' ).call_policies = call_policies.return_internal_reference( )
mb.class_( "Application" ).member_function( "HWnd" ).call_policies = call_policies.return_value_policy( call_policies.return_opaque_pointer )
# SCRIPT POUR ../input_output/cxml.h
# mb.namespace("BasicXmlProcess").exclude()
# cxmlnode=mb.class_("CXmlNode")
# cxmlnode.mem_fun("GetChild").call_policies = call_policies.return_value_policy( call_policies.return_opaque_pointer )
# cxmlnode.decls("t_nodeData").exclude()
# cxml=mb.class_("CXml")
# cxml.mem_fun("GetRoot").call_policies = call_policies.return_value_policy( call_policies.return_opaque_pointer )
# mb.class_("CoreString").include()
# for cons in cxmlnode.constructors("CXmlNode"):
# for el in cons.arguments:
# if el.name=="rowData":
# cons.exclude()
# ####################################################
# SCRIPT POUR ../input_output/progressionInfo.h
mb.class_("progressionInfo").mem_fun("GetMainOperation").call_policies = call_policies.return_internal_reference( 1 )
mb.class_("progressOperation").mem_fun("GetState").exclude()
# ####################################################
# SCRIPT POUR ../input_output/exportRecepteurSurf/std_rsbin.h
rsbin=mb.namespace("formatRSBIN").class_("rsurf_data")
rsbin.mem_fun("GetFileInfos").add_transformation( FT.output('rs_size'),FT.output('nodes_size') ,FT.output('nbtimestep'),FT.output('timestep'),FT.output('recordType'))
rsbin.mem_fun("GetNodePositionValue").add_transformation( FT.output('x'),FT.output('y'),FT.output('z'))
rsbin.mem_fun("GetRsInfo").add_transformation( FT.output('nbfaces'),FT.output('rs_name'),FT.output('xmlid'))
rsbin.mem_fun("GetFaceInfo").add_transformation( FT.output('vertexA'),FT.output('vertexB'),FT.output('vertexC'),FT.output('recordCount'))
rsbin.mem_fun("GetFaceEnergy").add_transformation( FT.output('idstep'),FT.output('energy'))
rsbin.mem_funs("SetRsBinData").exclude()
rsiso=mb.namespace("formatRSBIN").class_("rsurf_iso_contouring")
rsiso.mem_fun("GetMinMax").add_transformation( FT.output('min'),FT.output('max'))
rsiso.mem_fun("GetIsoLevelCurves").add_transformation( FT.output('curvlst'))
def Parse(self, mb):
# Exclude everything by default
mb.decls().exclude()
# Generic steam api call return result
mb.typedef('SteamAPICall_t').include()
# CSteamID
cls = mb.class_('CSteamID')
cls.include()
constpchararg = pointer_t(const_t(declarated_t(char_t())))
cls.constructors(
matchers.calldef_matcher_t(
arg_types=[constpchararg, None])).exclude()
cls.mem_funs('Render').exclude()
cls.mem_funs('SetFromStringStrict').exclude()
cls.mem_funs('SetFromString').exclude() # No definition...
cls.mem_funs('SetFromSteam2String').exclude() # No definition...
cls.mem_funs('BValidExternalSteamID').exclude() # No definition...
mb.enum('EResult').include()
mb.enum('EDenyReason').include()
mb.enum('EUniverse').include()
mb.enum('EAccountType').include()
mb.enum('ESteamUserStatType').include()
mb.enum('EChatEntryType').include()
mb.enum('EChatRoomEnterResponse').include()
mb.enum('EChatMemberStateChange').include()
# Generic API functions
mb.free_function('SteamAPI_RunCallbacks').include()
# Accessor class for all
mb.add_registration_code(
"bp::scope().attr( \"steamapicontext\" ) = boost::ref(steamapicontext);"
)
cls = mb.class_('CSteamAPIContext')
cls.include()
cls.mem_fun('Init').exclude()
cls.mem_fun('Clear').exclude()
cls.mem_fun('SteamApps').exclude()
cls.mem_fun('SteamMatchmakingServers').exclude()
cls.mem_fun('SteamHTTP').exclude()
cls.mem_fun('SteamScreenshots').exclude()
cls.mem_fun('SteamUnifiedMessages').exclude()
cls.mem_fun('SteamNetworking').exclude()
cls.mem_fun('SteamRemoteStorage').exclude()
cls.mem_funs(
'SteamFriends'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs(
'SteamUtils'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs(
'SteamMatchmaking'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs(
'SteamUser'
).call_policies = call_policies.return_internal_reference()
cls.mem_funs(
'SteamUserStats'
).call_policies = call_policies.return_internal_reference()
mb.add_registration_code(
"bp::scope().attr( \"QUERY_PORT_NOT_INITIALIZED\" ) = (int)QUERY_PORT_NOT_INITIALIZED;"
)
mb.add_registration_code(
"bp::scope().attr( \"QUERY_PORT_ERROR\" ) = (int)QUERY_PORT_ERROR;"
)
# Friends
cls = mb.class_('ISteamFriends')
cls.include()
cls.mem_funs().virtuality = 'not virtual'
cls.mem_fun('GetFriendGamePlayed').exclude()
mb.enum('EFriendRelationship').include()
mb.enum('EPersonaState').include()
mb.add_registration_code(
"bp::scope().attr( \"k_cchPersonaNameMax\" ) = (int)k_cchPersonaNameMax;"
)
# User
cls = mb.class_('ISteamUser')
cls.include()
cls.mem_funs().virtuality = 'not virtual'
# Utils
cls = mb.class_('ISteamUtils')
cls.include()
cls.mem_funs().virtuality = 'not virtual'
cls.mem_fun('GetImageRGBA').exclude()
cls.mem_fun('GetImageSize').exclude()
self.ParseMatchmaking(mb)
self.ParseUserStats(mb)
def Parse(self, mb):
mb.decls().exclude()
# Get item
getitem_wrapper = 'static ::vec_t GetItem( %(cls_name)s const & inst, int i ) {\r\n' + \
' if( i < 0 || i > %(nitems)s ) {\r\n' + \
' PyErr_SetString(PyExc_IndexError, "Index out of range" );\r\n' + \
' throw boost::python::error_already_set();\r\n' + \
' }\r\n' + \
' return inst[i];\r\n' + \
'}\r\n'
getitem_reg = '%(cls_name)s_exposer.def( "__getitem__", &::%(cls_name)s_wrapper::GetItem );\r\n'
# Set item
setitem_wrapper = 'static void SetItem( %(cls_name)s & inst, int i, ::vec_t v ) {\r\n' + \
' if( i < 0 || i > %(nitems)s ) {\r\n' + \
' PyErr_SetString(PyExc_IndexError, "Index out of range" );\r\n' + \
' throw boost::python::error_already_set();\r\n' + \
' }\r\n' + \
' inst[i] = v;\r\n' + \
'}\r\n'
setitem_reg = '%(cls_name)s_exposer.def( "__setitem__", &::%(cls_name)s_wrapper::SetItem );\r\n'
# String
str_vmatrix_wrapper = 'static boost::python::object Str( VMatrix const & inst ) {\r\n' + \
' return boost::python::object(VMatToString(inst));\r\n' + \
'}\r\n'
str_reg = '%(cls_name)s_exposer.def( "__str__", &::%(cls_name)s_wrapper::Str );\r\n'
# Classes
cls = mb.class_('Vector')
cls.include()
cls.mem_opers('=').exclude() # Breaks debug mode and don't really need it
cls.add_wrapper_code( getitem_wrapper % {'cls_name' : 'Vector', 'nitems' : '2' } )
cls.add_registration_code( getitem_reg % {'cls_name':'Vector'}, False)
cls.add_wrapper_code( setitem_wrapper % {'cls_name' : 'Vector', 'nitems' : '2' } )
cls.add_registration_code( setitem_reg % {'cls_name':'Vector'}, False)
cls = mb.class_('Vector2D')
cls.include()
cls.mem_opers('=').exclude() # Breaks debug mode and don't really need it
cls.add_wrapper_code( getitem_wrapper % {'cls_name' : 'Vector2D', 'nitems' : '1' } )
cls.add_registration_code( getitem_reg % {'cls_name':'Vector2D'}, False)
cls.add_wrapper_code( setitem_wrapper % {'cls_name' : 'Vector2D', 'nitems' : '1' } )
cls.add_registration_code( setitem_reg % {'cls_name':'Vector2D'}, False)
cls = mb.class_('QAngle')
cls.include()
cls.mem_opers('=').exclude() # Breaks debug mode and don't really need it
cls.add_wrapper_code( getitem_wrapper % {'cls_name' : 'QAngle', 'nitems' : '2' } )
cls.add_registration_code( getitem_reg % {'cls_name':'QAngle'}, False)
cls.add_wrapper_code( setitem_wrapper % {'cls_name' : 'QAngle', 'nitems' : '2' } )
cls.add_registration_code( setitem_reg % {'cls_name':'QAngle'}, False)
cls = mb.class_('Quaternion')
cls.include()
cls.mem_opers('=').exclude() # Breaks debug mode and don't really need it
mb.free_function('QAngleToAngularImpulse').include()
mb.free_function('AngularImpulseToQAngle').include()
# Call policies
mb.mem_funs('AsVector2D').call_policies = call_policies.return_internal_reference()
# Transform functions that take pointers as arguments
mb.free_functions('SolveInverseQuadraticMonotonic').add_transformation( FT.output('a'), FT.output('b'), FT.output('c') )
mb.free_functions('ComputeTrianglePlane').add_transformation( FT.output('intercept') )
mb.free_functions('CalcSqrDistAndClosestPointOnAABB').add_transformation( FT.output('distSqrOut') )
mb.free_functions('SolveInverseReciprocalQuadratic').add_transformation( FT.output('a'), FT.output('b'), FT.output('c') )
mb.free_functions('SolveQuadratic').add_transformation( FT.output('root1'), FT.output('root2') )
mb.free_functions('SolveInverseQuadratic').add_transformation( FT.output('a'), FT.output('b'), FT.output('c') )
mb.free_functions('QuaternionAxisAngle').add_transformation( FT.output('axis'), FT.output('angle') )
mb.free_functions('RotationDeltaAxisAngle').add_transformation( FT.output('deltaAxis'), FT.output('deltaAngle') )
# Compressed color
mb.class_('ColorRGBExp32').include()
# cplane_t
mb.class_('cplane_t').include()
mb.class_('cplane_t').var('pad').exclude()
# matrix3x4_t
mb.class_('matrix3x4_t').include()
mb.class_('matrix3x4_t').mem_opers().exclude()
# -----
# Add custom item access functions to the Vector class
mb.global_ns.mem_opers('[]').exclude()
mb.class_('Vector').add_registration_code( 'def( bp::init< const Vector & >(( bp::arg("vOther") )) )')
mb.class_('QAngle').add_registration_code( 'def( bp::init< const QAngle & >(( bp::arg("vOther") )) )')
# Vars
mb.vars('vec3_origin').include()
mb.vars('vec3_angle').include()
mb.vars('vec3_invalid').include()
mb.vars('nanmask').include()
# Mathlib.h functions
mb.free_function('RandomAngularImpulse').include()
mb.free_functions('VectorMaximum').include()
mb.free_functions('VectorMAInline').include()
mb.free_functions('VectorMA').include()
mb.free_functions('RoundInt').include()
mb.free_functions('Q_log2').include()
mb.free_functions('SinCos').include()
mb.free_functions('TableCos').include()
mb.free_functions('TableSin').include()
if self.settings.branch == 'swarm':
mb.free_functions('IsPowerOfTwo').include()
mb.free_functions('SmallestPowerOfTwoGreaterOrEqual').include()
mb.free_functions('LargestPowerOfTwoLessThanOrEqual').include()
mb.free_functions('FloorDivMod').include()
mb.free_functions('GreatestCommonDivisor').include()
mb.free_functions('IsDenormal').include()
mb.free_functions('MatrixVectors').include()
mb.free_functions('VectorRotate').include()
mb.free_functions('TransformAnglesToLocalSpace').include()
mb.free_functions('MatrixInitialize').include()
mb.free_functions('MatrixCopy').include()
mb.free_functions('MatrixInvert').include()
mb.free_functions('MatricesAreEqual').include()
mb.free_functions('MatrixGetColumn').include()
mb.free_functions('MatrixSetColumn').include()
mb.free_functions('ConcatRotations').include()
mb.free_functions('ConcatTransforms').include()
mb.free_functions('MatrixMultiply').include()
mb.free_function('QuaternionSlerp').include()
mb.free_function('QuaternionSlerpNoAlign').include()
mb.free_function('QuaternionBlend').include()
mb.free_function('QuaternionBlendNoAlign').include()
mb.free_function('QuaternionIdentityBlend').include()
mb.free_function('QuaternionAngleDiff').include()
mb.free_function('QuaternionScale').include()
mb.free_function('QuaternionDotProduct').include()
mb.free_function('QuaternionConjugate').include()
mb.free_function('QuaternionInvert').include()
mb.free_function('QuaternionNormalize').include()
mb.free_function('QuaternionAdd').include()
mb.free_function('QuaternionMult').include()
mb.free_functions('QuaternionMatrix').include()
mb.free_functions('QuaternionAngles').include()
mb.free_functions('AngleQuaternion').include()
mb.free_function('QuaternionAxisAngle').include()
mb.free_function('AxisAngleQuaternion').include()
mb.free_function('BasisToQuaternion').include()
mb.free_function('MatrixQuaternion').include()
mb.free_functions('MatrixRowDotProduct').include()
mb.free_functions('MatrixColumnDotProduct').include()
mb.free_functions('anglemod').include()
mb.free_functions('RemapVal').include()
mb.free_functions('RemapValClamped').include()
mb.free_functions('Lerp').include()
mb.free_functions('Sqr').include()
mb.free_functions('FLerp').include()
mb.free_functions('Sign').include()
mb.free_functions('ClampArrayBounds').include()
mb.free_functions('AngleVectors').include()
mb.free_functions('AngleVectors').include()
mb.free_functions('AngleVectorsTranspose').include()
mb.free_functions('AngleMatrix').include()
mb.free_functions('AngleMatrix').include()
mb.free_functions('AngleIMatrix').include()
mb.free_functions('VectorAngles').include()
mb.free_functions('VectorMatrix').include()
mb.free_functions('VectorVectors').include()
mb.free_functions('SetIdentityMatrix').include()
mb.free_functions('SetScaleMatrix').include()
mb.free_functions('MatrixBuildRotationAboutAxis').include()
mb.free_functions('MatrixTranspose').include()
mb.free_functions('MatrixInverseTranspose').include()
mb.free_functions('PositionMatrix').include()
mb.free_functions('MatrixPosition').include()
mb.free_functions('VectorRotate').include()
mb.free_functions('VectorIRotate').include()
mb.free_functions('MatrixAngles').include()
mb.free_functions('VectorCompare').include()
mb.free_functions('VectorTransform').include()
mb.free_functions('VectorITransform').include()
mb.free_functions('BoxOnPlaneSide').include()
mb.free_functions('VectorFill').include()
mb.free_functions('VectorNegate').include()
mb.free_functions('VectorAvg').include()
mb.free_functions('BoxOnPlaneSide2').include()
mb.free_functions('ClearBounds').include()
mb.free_functions('AddPointToBounds').include()
mb.free_functions('BuildGammaTable').include()
mb.free_functions('TexLightToLinear').include()
mb.free_functions('LinearToTexture').include()
mb.free_functions('LinearToScreenGamma').include()
mb.free_functions('TextureToLinear').include()
mb.free_functions('SolveQuadratic').include()
mb.free_functions('SolveInverseQuadratic').include()
mb.free_functions('SolveInverseQuadraticMonotonic').include()
mb.free_functions('SolveInverseReciprocalQuadratic').include()
mb.free_functions('VectorYawRotate').include()
mb.free_functions('Bias').include()
mb.free_functions('Gain').include()
mb.free_functions('SmoothCurve').include()
mb.free_functions('SmoothCurve_Tweak').include()
mb.free_functions('ExponentialDecay').include()
mb.free_functions('ExponentialDecay').include()
mb.free_functions('ExponentialDecayIntegral').include()
mb.free_functions('SimpleSpline').include()
mb.free_functions('SimpleSplineRemapVal').include()
mb.free_functions('SimpleSplineRemapValClamped').include()
mb.free_functions('RoundFloatToInt').include()
mb.free_functions('RoundFloatToByte').include()
mb.free_functions('RoundFloatToUnsignedLong').include()
mb.free_functions('IsIntegralValue').include()
mb.free_functions('Float2Int').include()
mb.free_functions('Floor2Int').include()
mb.free_functions('FastFToC').include()
mb.free_functions('ClampToMsec').include()
mb.free_functions('Ceil2Int').include()
mb.free_functions('GetBarycentricCoords2D').include()
mb.free_functions('QuickBoxSphereTest').include()
mb.free_functions('QuickBoxIntersectTest').include()
mb.free_functions('GammaToLinearFullRange').include()
mb.free_functions('LinearToGammaFullRange').include()
mb.free_functions('GammaToLinear').include()
mb.free_functions('LinearToGamma').include()
mb.free_functions('SrgbGammaToLinear').include()
mb.free_functions('SrgbLinearToGamma').include()
mb.free_functions('X360GammaToLinear').include()
mb.free_functions('X360LinearToGamma').include()
mb.free_functions('SrgbGammaTo360Gamma').include()
mb.free_functions('LinearToVertexLight').include()
mb.free_functions('LinearToLightmap').include()
mb.free_functions('ColorClamp').include()
mb.free_functions('ColorClampTruncate').include()
mb.free_functions('Catmull_Rom_Spline').include()
mb.free_functions('Catmull_Rom_Spline_Tangent').include()
mb.free_functions('Catmull_Rom_Spline_Integral').include()
mb.free_functions('Catmull_Rom_Spline_Integral').include()
mb.free_functions('Catmull_Rom_Spline_Normalize').include()
mb.free_functions('Catmull_Rom_Spline_Integral_Normalize').include()
mb.free_functions('Catmull_Rom_Spline_NormalizeX').include()
mb.free_functions('Catmull_Rom_Spline_NormalizeX').include()
mb.free_functions('Hermite_Spline').include()
#mb.free_functions('Hermite_SplineBasis').include()
mb.free_functions('Kochanek_Bartels_Spline').include()
mb.free_functions('Kochanek_Bartels_Spline_NormalizeX').include()
mb.free_functions('Cubic_Spline').include()
mb.free_functions('Cubic_Spline_NormalizeX').include()
mb.free_functions('BSpline').include()
mb.free_functions('BSpline_NormalizeX').include()
mb.free_functions('Parabolic_Spline').include()
mb.free_functions('Parabolic_Spline_NormalizeX').include()
mb.free_functions('QuinticInterpolatingPolynomial').include()
#mb.free_functions('GetInterpolationData').include()
mb.free_functions('RangeCompressor').include()
mb.free_functions('CalcSqrDistanceToAABB').include()
mb.free_functions('CalcClosestPointOnAABB').include()
mb.free_functions('CalcSqrDistAndClosestPointOnAABB').include()
mb.free_functions('CalcDistanceToAABB').include()
#mb.free_functions('CalcLineToLineIntersectionSegment').include() # TODO
mb.free_functions('Approach').include()
mb.free_functions('ApproachAngle').include()
mb.free_functions('AngleDiff').include()
mb.free_functions('AngleDistance').include()
mb.free_functions('AngleNormalize').include()
mb.free_functions('AngleNormalizePositive').include()
mb.free_functions('AnglesAreEqual').include()
mb.free_functions('RotationDeltaAxisAngle').include()
mb.free_functions('RotationDelta').include()
mb.free_functions('ComputeTrianglePlane').include()
mb.free_functions('PolyFromPlane').include()
mb.free_functions('ClipPolyToPlane').include()
mb.free_functions('ClipPolyToPlane_Precise').include()
mb.free_functions('CalcTriangleTangentSpace').include()
mb.free_functions('TransformAABB').include()
mb.free_functions('ITransformAABB').include()
mb.free_functions('RotateAABB').include()
mb.free_functions('IRotateAABB').include()
mb.free_functions('MatrixTransformPlane').include()
mb.free_functions('MatrixITransformPlane').include()
mb.free_functions('CeilPow2').include()
mb.free_functions('FloorPow2').include()
mb.free_functions('RGBtoHSV').include()
mb.free_functions('HSVtoRGB').include()
# Vector.h functions
mb.free_functions('VectorClear').include()
mb.free_functions('VectorCopy').include()
mb.free_functions('VectorAdd').include()
mb.free_functions('VectorSubtract').include()
mb.free_functions('VectorMultiply').include()
mb.free_functions('VectorDivide').include()
mb.free_functions('VectorScale').include()
mb.free_functions('VectorMA').include()
mb.free_functions('VectorsAreEqual').include()
mb.free_functions('ComputeClosestPoint').include()
mb.free_functions('VectorAbs').include()
mb.free_functions('VectorLength').include()
mb.free_functions('DotProduct').include()
mb.free_functions('CrossProduct').include()
mb.free_functions('VectorMin').include()
mb.free_functions('VectorMax').include()
mb.free_functions('VectorLerp').include()
mb.free_functions('RandomVector').include()
mb.free_functions('QAnglesAreEqual').include()
#mb.free_functions('QAngleToAngularImpulse').include()
#mb.free_functions('AngularImpulseToQAngle').include()
mb.free_functions('VectorNormalize').include()
mb.free_functions('VectorNormalizeFast').include()
# Vector2d.h functions
mb.free_functions('Vector2DClear').include()
mb.free_functions('Vector2DCopy').include()
mb.free_functions('Vector2DAdd').include()
mb.free_functions('Vector2DSubtract').include()
mb.free_functions('Vector2DMultiply').include()
mb.free_functions('Vector2DDivide').include()
mb.free_functions('Vector2DMA').include()
mb.free_functions('Vector2DMin').include()
mb.free_functions('Vector2DMax').include()
mb.free_functions('Vector2DLength').include()
mb.free_functions('DotProduct2D').include()
mb.free_functions('Vector2DLerp').include()
mb.free_functions('Vector2DNormalize').include()
mb.free_functions('ComputeClosestPoint2D').include()
# QAngle functions
mb.free_function('RandomAngle').include()
# VMatrix
cls = mb.class_('VMatrix')
cls.include()
cls.mem_opers('=').exclude() # Breaks debug mode and don't really need it
cls.mem_opers('[]').exclude()
cls.mem_funs('Base').exclude()
cls.vars('m').exclude()
cls.mem_fun('As3x4', matchers.calldef_matcher_t(return_type=reference_t(declarated_t(mb.class_('matrix3x4_t'))))).exclude()
cls.mem_fun('GetTranslation', matchers.calldef_matcher_t(return_type=reference_t(declarated_t(mb.class_('Vector'))))).exclude()
cls.add_wrapper_code( str_vmatrix_wrapper % {'cls_name':'VMatrix'} )
cls.add_registration_code( str_reg % {'cls_name':'VMatrix'}, False)
mb.free_functions('MatrixSetIdentity').include()
mb.free_functions('MatrixTranspose').include()
mb.free_functions('MatrixCopy').include()
mb.free_functions('MatrixMultiply').include()
mb.free_functions('MatrixGetColumn').include()
mb.free_functions('MatrixSetColumn').include()
mb.free_functions('MatrixGetRow').include()
mb.free_functions('MatrixSetRow').include()
mb.free_functions('MatrixTranslate').include()
mb.free_functions('MatrixBuildRotationAboutAxis').include()
mb.free_functions('MatrixBuildRotateZ').include()
mb.free_functions('MatrixRotate').include()
mb.free_functions('MatrixFromAngles').include()
mb.free_functions('MatrixToAngles').include()
# Exclude
if self.settings.branch not in ['swarm', 'source2013']:
mb.vars('pfVectorNormalizeFast').exclude()
mb.vars('pfVectorNormalize').exclude()
mb.vars('pfInvRSquared').exclude()
mb.vars('m_flMatVal').exclude()
mb.vars('quat_identity').exclude() # <- Does not even exist except for a declaration?
# Exclude some functions
mb.mem_funs('Base').exclude() # Base gives a pointer to the address of the data. Not very python like.
mb.free_functions( 'AllocTempVector' ).exclude()
mb.class_('Vector2D').mem_funs('Cross').exclude() # Declaration only?
mb.free_function('ConcatRotations').exclude() # Declaration only?
# Remove any protected function
mb.calldefs( matchers.access_type_matcher_t( 'protected' ) ).exclude()
# Remove any function with "float *" values
# A lot of functions have two versions (or more), of which one takes "float *" arguments
vec_t = mb.typedef('vec_t')
excludetypes = [
pointer_t(float_t()),
pointer_t(const_t(float_t())),
pointer_t(declarated_t(vec_t)),
pointer_t(const_t(declarated_t(vec_t))),
]
mb.calldefs( calldef_withtypes( excludetypes ) ).exclude()
# Silent warnings of generating class wrappers
mb.classes().disable_warnings( messages.W1027 )
# Include functions with "float *" parameter. For these functions we should transform the "float *" parameter
mb.free_functions('CalcClosestPointOnLine2D').include()
mb.free_functions('CalcClosestPointOnLine2D').add_transformation( FT.output('t') )
mb.free_functions('CalcDistanceToLine2D').include()
mb.free_functions('CalcDistanceToLine2D').add_transformation( FT.output('t') )
mb.free_functions('CalcDistanceSqrToLine2D').include()
mb.free_functions('CalcDistanceSqrToLine2D').add_transformation( FT.output('t') )
mb.free_functions('CalcClosestPointOnLineSegment2D').include()
mb.free_functions('CalcClosestPointOnLineSegment2D').add_transformation( FT.output('t') )
mb.free_functions('CalcDistanceToLineSegment2D').include()
mb.free_functions('CalcDistanceToLineSegment2D').add_transformation( FT.output('t') )
mb.free_functions('CalcDistanceSqrToLineSegment2D').include()
mb.free_functions('CalcDistanceSqrToLineSegment2D').add_transformation( FT.output('t') )
mb.free_functions('CalcClosestPointOnLine').include()
mb.free_functions('CalcClosestPointOnLine').add_transformation( FT.output('t') )
mb.free_functions('CalcDistanceToLine').include()
mb.free_functions('CalcDistanceToLine').add_transformation( FT.output('t') )
mb.free_functions('CalcDistanceSqrToLine').include()
mb.free_functions('CalcDistanceSqrToLine').add_transformation( FT.output('t') )
mb.free_functions('CalcClosestPointOnLineSegment').include()
mb.free_functions('CalcClosestPointOnLineSegment').add_transformation( FT.output('t') )
mb.free_functions('CalcDistanceToLineSegment').include()
mb.free_functions('CalcDistanceToLineSegment').add_transformation( FT.output('t') )
mb.free_functions('CalcDistanceSqrToLineSegment').include()
mb.free_functions('CalcDistanceSqrToLineSegment').add_transformation( FT.output('t') )
"push_draw_2d_sprite")
mb.class_("DrawTools").member_functions("PushDraw2DText").rename(
"push_draw_2d_text")
mb.class_("DrawTools").member_functions("PushDraw3DSprite").rename(
"push_draw_3d_sprite")
mb.class_("DrawTools").member_functions("PushDraw3DText").rename(
"push_draw_3d_text")
mb.member_functions(
"Instance").call_policies = call_policies.return_value_policy(
call_policies.reference_existing_object)
mb.free_function(
"gGetApplication").call_policies = call_policies.return_value_policy(
call_policies.reference_existing_object)
mb.class_("BooksManager").member_function(
"GetBook").call_policies = call_policies.return_internal_reference()
mb.class_("Shader").member_function(
"GetTextureInfoOnStage"
).call_policies = call_policies.return_internal_reference()
mb.class_("Pack").member_function(
"FindFile").call_policies = call_policies.return_internal_reference()
mb.class_("Pack").member_function(
"GetFirstFile").call_policies = call_policies.return_internal_reference()
mb.class_("Pack").member_function(
"GetLastFile").call_policies = call_policies.return_internal_reference()
mb.class_("ParticleSystem").member_functions(
"GetSubSystem").call_policies = call_policies.return_internal_reference()
mb.class_("ParticleSystem").member_functions(
"GetParticle").call_policies = call_policies.return_internal_reference()
mb.class_("BaseParticleSystem").member_function(
"EmitterTransformation", return_type='::xfx::Mat4 &'
