//-----------------------------------------------------------------------------
// Exports mstudiobbox_t.
//-----------------------------------------------------------------------------
void export_hitbox(scope _studio)
{
class_<mstudiobbox_t, mstudiobbox_t *, boost::noncopyable> Hitbox("Hitbox");
// Properties...
Hitbox.add_property("name", &mstudiobbox_t::pszHitboxName);
Hitbox.def_readwrite("bone", &mstudiobbox_t::bone);
Hitbox.def_readwrite("group", &mstudiobbox_t::group);
Hitbox.add_property("min", make_getter(&mstudiobbox_t::bbmin, reference_existing_object_policy()));
Hitbox.add_property("max", make_getter(&mstudiobbox_t::bbmax, reference_existing_object_policy()));
// Add memory tools...
Hitbox ADD_MEM_TOOLS(mstudiobbox_t);
}
//-----------------------------------------------------------------------------
// Exports mstudioanimdesc_t.
//-----------------------------------------------------------------------------
void export_movement(scope _studio)
{
class_<mstudiomovement_t, mstudiomovement_t *, boost::noncopyable> Movement("Movement");
// Properties...
Movement.def_readwrite("end_frame", &mstudiomovement_t::endframe);
Movement.def_readwrite("motion_flags", &mstudiomovement_t::motionflags);
Movement.def_readwrite("velocity_start", &mstudiomovement_t::v0);
Movement.def_readwrite("velocity_end", &mstudiomovement_t::v1);
Movement.def_readwrite("angle", &mstudiomovement_t::angle);
Movement.add_property("vector", make_getter(&mstudiomovement_t::vector, reference_existing_object_policy()));
Movement.add_property("position", make_getter(&mstudiomovement_t::position, reference_existing_object_policy()));
// Add memory tools...
Movement ADD_MEM_TOOLS(mstudiomovement_t);
}
//-----------------------------------------------------------------------------
// Exports mstudiobone_t.
//-----------------------------------------------------------------------------
void export_bone(scope _studio)
{
class_<mstudiobone_t, mstudiobone_t *, boost::noncopyable> ModelBone("ModelBone");
// Properties...
ModelBone.add_property("name", &ModelBoneExt::get_name);
ModelBone.def_readwrite("parent", &mstudiobone_t::parent);
ModelBone.add_property("position", make_getter(&mstudiobone_t::pos, reference_existing_object_policy()));
ModelBone.add_property("quaternion", make_getter(&mstudiobone_t::quat, reference_existing_object_policy()));
ModelBone.add_property("radiant_euler", make_getter(&mstudiobone_t::rot, reference_existing_object_policy()));
ModelBone.add_property("position_scale", make_getter(&mstudiobone_t::posscale, reference_existing_object_policy()));
ModelBone.add_property("radiant_euler_scale", make_getter(&mstudiobone_t::rotscale, reference_existing_object_policy()));
ModelBone.add_property("position_to_bone", make_getter(&mstudiobone_t::poseToBone, reference_existing_object_policy())); // TODO: Export matrix3x4_t...
ModelBone.add_property("alignment", make_getter(&mstudiobone_t::qAlignment, reference_existing_object_policy()));
ModelBone.add_property("surface_name", &ModelBoneExt::get_surface_name);
ModelBone.def_readwrite("flags", &mstudiobone_t::flags);
ModelBone.def_readwrite("procedural_type", &mstudiobone_t::proctype);
ModelBone.def_readwrite("physics_bone", &mstudiobone_t::physicsbone);
ModelBone.def_readwrite("flags", &mstudiobone_t::flags);
ModelBone.def_readwrite("contents", &mstudiobone_t::contents);
// Methods...
ModelBone.def("get_procedure", &ModelBoneExt::get_procedure, manage_new_object_policy());
// Add memory tools...
ModelBone ADD_MEM_TOOLS(mstudiobone_t);
}
void compilability_test()
{
class_<trivial>("trivial")
.add_property("property", make_getter(&trivial::value, return_value_policy<return_by_value>()))
.def_readonly("readonly", &trivial::value)
;
class_< Color3 >("Color3", init< const Color3 & >())
.def_readonly("BLACK", &Color3::black) // line 17
;
}
// Class
void class_WorldObject()
{
// WorldObject
// WorldObject_class
class_<WorldObject, bases<Component> > WorldObject_class("WorldObject",
init< optional<std::string> >());
WorldObject_class
.add_property("geom", &WorldObject::getGeom, &WorldObject::setGeom)
// .add_property("material", &WorldObject::getMaterial, &WorldObject::setMaterial)
.add_property("parent", make_getter(&WorldObject::parent, return_internal_reference<>()))
// .def("getParent", &WorldObject::getParent, return_internal_reference<>())
.add_property("transform", &getTransform, &setTransform)
.add_property("worldtransform", &getWorldTransform)
.add_property("pos", &getPos, &setPos)
.add_property("rot", &getRot, &setRot)
.add_property("scale", &getScale, &setScale)
.add_property("pivot", &getPivot, &setPivot)
.add_property("cog", &getCog)
.add_property("inertiatensor", &getInertiaTensor)
.add_property("mass", &getMass, &setMass)
.add_property("totalmass", &getTotalMass)
.add_property("visible", &getVisible, &setVisible)
.add_property("linearvel", &getLinearVel, &setLinearVel)
.add_property("angularvel", &getAngularVel, &setAngularVel)
.def_readonly("transform_slot", &WorldObject::transform)
.def_readonly("pos_slot", &WorldObject::pos)
.def_readonly("rot_slot", &WorldObject::rot)
.def_readonly("scale_slot", &WorldObject::scale)
.def_readonly("cog_slot", &WorldObject::cog)
.def_readonly("inertiatensor_slot", &WorldObject::inertiatensor)
.def_readonly("mass_slot", &WorldObject::mass)
.def_readonly("totalmass_slot", &WorldObject::totalmass)
.def_readonly("worldtransform_slot", &WorldObject::worldtransform)
.def_readonly("visible_slot", &WorldObject::visible)
.def_readonly("linearvel_slot", &WorldObject::linearvel)
.def_readonly("angularvel_slot", &WorldObject::angularvel)
.def("__eq__", WorldObject__eq__)
.def("__ne__", WorldObject__ne__)
.def("localTransform", &WorldObject::localTransform,
return_value_policy<copy_const_reference>(),
"localTransform() -> mat4\n\n"
"Return the local transformation that has to be used for rendering.\n"
"The returned transformation L is calculated as follows: L = T*P^-1\n"
"where T is the current transform (taken from the transform slot)\n"
"and P is the offset transform.")
;
class_WorldObject2(WorldObject_class);
}
//-----------------------------------------------------------------------------
// Exports mstudioseqdesc_t.
//-----------------------------------------------------------------------------
void export_sequence(scope _studio)
{
class_<mstudioseqdesc_t, mstudioseqdesc_t *, boost::noncopyable> Sequence("Sequence");
// Properties...
Sequence.add_property("model_header", make_function(&mstudioseqdesc_t::pStudiohdr, reference_existing_object_policy()));
Sequence.def_readwrite("label_offset", &mstudioseqdesc_t::szlabelindex);
Sequence.add_property("label", &SequenceExt::get_label);
Sequence.def_readwrite("activity_offset", &mstudioseqdesc_t::szactivitynameindex);
Sequence.add_property("activity", &SequenceExt::get_activity);
Sequence.def_readwrite("flags", &mstudioseqdesc_t::flags);
Sequence.def_readwrite("activity_index", &mstudioseqdesc_t::activity);
Sequence.def_readwrite("act_weight", &mstudioseqdesc_t::actweight);
Sequence.def_readwrite("events_count", &mstudioseqdesc_t::numevents);
Sequence.def_readwrite("events_offset", &mstudioseqdesc_t::eventindex);
Sequence.add_property("min", make_getter(&mstudioseqdesc_t::bbmin, reference_existing_object_policy()));
Sequence.add_property("max", make_getter(&mstudioseqdesc_t::bbmax, reference_existing_object_policy()));
Sequence.def_readwrite("blends_count", &mstudioseqdesc_t::numblends);
Sequence.def_readwrite("animation_offset", &mstudioseqdesc_t::animindexindex);
Sequence.def_readwrite("movement_index", &mstudioseqdesc_t::movementindex);
Sequence.def_readwrite("fade_in_time", &mstudioseqdesc_t::fadeintime);
Sequence.def_readwrite("fade_out_time", &mstudioseqdesc_t::fadeouttime);
Sequence.def_readwrite("local_entry_node", &mstudioseqdesc_t::localentrynode);
Sequence.def_readwrite("local_exit_node", &mstudioseqdesc_t::localexitnode);
Sequence.def_readwrite("node_flags", &mstudioseqdesc_t::nodeflags);
Sequence.def_readwrite("entry_phase", &mstudioseqdesc_t::entryphase);
Sequence.def_readwrite("exit_phase", &mstudioseqdesc_t::exitphase);
Sequence.def_readwrite("lastframe", &mstudioseqdesc_t::lastframe);
Sequence.def_readwrite("next_sequence", &mstudioseqdesc_t::nextseq);
Sequence.def_readwrite("pose", &mstudioseqdesc_t::pose);
// Methods...
Sequence.def("get_animation_index", &mstudioseqdesc_t::anim);
Sequence.def("get_weight", &mstudioseqdesc_t::weight);
// Add memory tools...
Sequence ADD_MEM_TOOLS(mstudioseqdesc_t);
}
//-----------------------------------------------------------------------------
// Exports studiohdr_t.
//-----------------------------------------------------------------------------
void export_model_header(scope _studio)
{
class_<studiohdr_t, boost::shared_ptr<studiohdr_t>, boost::noncopyable> ModelHeader("ModelHeader", no_init);
// Initializer...
ModelHeader.def("__init__", make_constructor(&ModelHeaderExt::__init__,
default_call_policies(),
args("model_name")
)
);
// Properties...
ModelHeader.def_readwrite("id", &studiohdr_t::id); // Looks like a pointer?
ModelHeader.def_readwrite("version", &studiohdr_t::version);
ModelHeader.def_readwrite("checksum", &studiohdr_t::checksum);
ModelHeader.add_property("name", &studiohdr_t::pszName);
ModelHeader.add_property("eye_position", make_getter(&studiohdr_t::eyeposition, reference_existing_object_policy()));
ModelHeader.add_property("illumination_center", make_getter(&studiohdr_t::illumposition, reference_existing_object_policy()));
ModelHeader.add_property("hull_min", make_getter(&studiohdr_t::hull_min, reference_existing_object_policy()));
ModelHeader.add_property("hull_max", make_getter(&studiohdr_t::hull_max, reference_existing_object_policy()));
ModelHeader.add_property("view_min", make_getter(&studiohdr_t::view_bbmin, reference_existing_object_policy()));
ModelHeader.add_property("view_max", make_getter(&studiohdr_t::view_bbmax, reference_existing_object_policy()));
ModelHeader.def_readwrite("flags", &studiohdr_t::flags);
ModelHeader.def_readwrite("bones_count", &studiohdr_t::numbones);
ModelHeader.def_readwrite("bones_offset", &studiohdr_t::boneindex);
ModelHeader.def_readwrite("bone_controllers_count", &studiohdr_t::numbonecontrollers);
ModelHeader.def_readwrite("bone_controllers_offset", &studiohdr_t::bonecontrollerindex);
ModelHeader.def_readwrite("hitbox_sets_count", &studiohdr_t::numhitboxsets);
ModelHeader.def_readwrite("hitbox_sets_offset", &studiohdr_t::hitboxsetindex);
ModelHeader.def_readwrite("local_animations_count", &studiohdr_t::numlocalanim);
ModelHeader.def_readwrite("animations_offset", &studiohdr_t::localanimindex);
ModelHeader.def_readwrite("attachments_count", &studiohdr_t::numlocalattachments);
ModelHeader.def_readwrite("local_sequences_count", &studiohdr_t::numlocalseq);
ModelHeader.def_readwrite("local_sequence_offset", &studiohdr_t::localseqindex);
ModelHeader.def_readwrite("mass", &studiohdr_t::mass);
ModelHeader.def_readwrite("contents", &studiohdr_t::contents);
// Methods...
ModelHeader.def("get_bone", &studiohdr_t::pBone, reference_existing_object_policy());
// ModelHeader.def("remap_sequence_bone", &studiohdr_t::RemapSeqBone);
// ModelHeader.def("remap_animation_bone", &studiohdr_t::RemapAnimBone);
ModelHeader.def("get_bone_controller", &studiohdr_t::pBonecontroller, reference_existing_object_policy());
ModelHeader.def("get_hitbox_set", &studiohdr_t::pHitboxSet, reference_existing_object_policy());
ModelHeader.def("get_local_animation", &studiohdr_t::pLocalAnimdesc, reference_existing_object_policy());
// ModelHeader.def("has_sequences_available", &studiohdr_t::SequencesAvailable);
// ModelHeader.def("get_animation", &studiohdr_t::pAnimdesc, reference_existing_object_policy());
// ModelHeader.def("get_sequences_count", &studiohdr_t::GetNumSeq);
// ModelHeader.def("get_sequence", &studiohdr_t::pSeqdesc, reference_existing_object_policy());
// ModelHeader.def("get_activity_list_version", &studiohdr_t::GetActivityListVersion);
// ModelHeader.def("set_activity_list_version", &studiohdr_t::SetActivityListVersion);
ModelHeader.def("get_attachment", &studiohdr_t::pLocalAttachment, reference_existing_object_policy());
// Special methods...
ModelHeader.def("__len__", make_getter(&studiohdr_t::length));
// Add memory tools...
ModelHeader ADD_MEM_TOOLS(studiohdr_t);
}
//-----------------------------------------------------------------------------
// Exports CGlobalVarsBase.
//-----------------------------------------------------------------------------
void export_globals(scope _globals)
{
GlobalsBase_Visitor(
class_<CGlobalVarsBase>("_GlobalVarsBase", init<bool>())
.def("is_client",
&CGlobalVarsBase::IsClient,
"Returns True if the game is a client."
)
.def("get_network_base",
&CGlobalVarsBase::GetNetworkBase,
"for encoding m_flSimulationTime, m_flAnimTime",
args("tick", "entity")
)
.def_readwrite("real_time",
&CGlobalVarsBase::realtime,
"Absolute time."
)
.def_readwrite("frame_count",
&CGlobalVarsBase::framecount,
"Absolute frame counter."
)
.def_readwrite("absolute_frame_time",
&CGlobalVarsBase::absoluteframetime,
"Non-paused frame time."
)
.def_readwrite("current_time",
&CGlobalVarsBase::curtime,
"Current time."
)
.def_readwrite("frame_time",
&CGlobalVarsBase::frametime,
"Time spent on last server or client frame (has nothing to do with think intervals)."
)
.def_readwrite("max_clients",
&CGlobalVarsBase::maxClients,
"Current maxplayers setting."
)
.def_readwrite("tick_count",
&CGlobalVarsBase::tickcount,
"Simulation ticks - does not increase when game is paused."
)
.def_readwrite("interval_per_tick",
&CGlobalVarsBase::interval_per_tick,
"Simulation tick interval."
)
.def_readwrite("interpolation_amount",
&CGlobalVarsBase::interpolation_amount,
"interpolation amount ( client-only ) based on fraction of next tick which has elapsed."
)
.def_readwrite("simulated_ticks_this_frame",
&CGlobalVarsBase::simTicksThisFrame,
"Simulation ticks of this frame."
)
.def_readwrite("network_protocol",
&CGlobalVarsBase::network_protocol,
"Network protocol."
)
.NOT_IMPLEMENTED("is_remote_client")
) ADD_MEM_TOOLS(CGlobalVarsBase); // GlobalsBase_Visitor
Globals_Visitor(
class_< CGlobalVars, bases< CGlobalVarsBase> >("_GlobalVars", init<bool>())
.add_property("map_name",
make_getter(&CGlobalVars::mapname, return_value_policy<return_by_value>()),
"Current map name."
)
.def_readwrite("map_version",
&CGlobalVars::mapversion,
"Current map version."
)
.add_property("start_spot",
make_getter(&CGlobalVars::startspot, return_value_policy<return_by_value>()),
"Start spot name."
)
.def_readwrite("load_type",
&CGlobalVars::eLoadType,
"How the current map was loaded."
)
.def_readwrite("map_load_failed",
&CGlobalVars::bMapLoadFailed,
"Failed to load map?"
)
.def_readwrite("is_deathmatch",
&CGlobalVars::deathmatch,
"Deathmatch enabled?"
)
.def_readwrite("is_coop",
&CGlobalVars::coop,
"Coop enabled?"
)
.def_readwrite("is_teamplay",
&CGlobalVars::teamplay,
"Teamplay enabled?"
)
.def_readwrite("max_entities",
&CGlobalVars::maxEntities,
"Maximum number of entities."
)
.NOT_IMPLEMENTED_ATTR("map_group_name")
.NOT_IMPLEMENTED_ATTR("server_count")
) ADD_MEM_TOOLS(CGlobalVars); // Globals_Visitor
_globals.attr("global_vars") = object(ptr(gpGlobals));
}
class_<AbsCoord>("AbsCoord").
def(init<float, float, float>()).
add_property("x" , abs_get_v_const_type(&AbsCoord::x )).
add_property("y" , abs_get_v_const_type(&AbsCoord::y )).
add_property("theta" , abs_get_v_const_type(&AbsCoord::theta )).
def_readonly("weight" , &AbsCoord::weight ).
add_property("var" , make_getter(&AbsCoord::var, return_value_policy<return_by_value>()));
class_<BallInfo>("BallInfo")
.def_readonly("rr", &BallInfo::rr)
.def_readonly("radius", &BallInfo::radius)
.add_property("imageCoords", make_getter(&BallInfo::imageCoords, return_value_policy<return_by_value>()))
.add_property("neckRelative", &BallInfo::neckRelative)
.def_readonly("visionVar", &BallInfo::visionVar)
.def_readonly("topCamera", &BallInfo::topCamera);
class_<BallHint>("BallHint")
.def_readonly("type" , &BallHint::type );
enum_<BallHint::Type>("BallHintType")
.value("bLeft" , BallHint::bLeft )
.value("bRight" , BallHint::bRight )
.value("bHidden" , BallHint::bHidden )
.value("bNone" , BallHint::bNone );
