oasislua_export_wrap_luabind.cpp

使用stl技术,(还没看,是听说的)

/*
** Lua binding:
**   disentangled from the main distribution for ease
**   adding different languages. Exportation only.
*/ 
#ifdef HAS_LUA

#include "oasisCommon.h"
#include "oasisVector3.h"
#include "oasisQuaternion.h"
#include "oasisColour.h"
#include "oasisFrameListener.h"
#include "oasisResource.h"
#include "oasisResourceManager.h"
#include "oasisSystem.h"
#include "oasisMovable.h"
#include "oasisSingleton.h"
#include "oasisPool.h"
#include "oasisPoolable.h"
#include "oasisAudible.h"
#include "oasisPhysical.h"
#include "oasisVisible.h"
#include "oasisCameraSystem.h"
#include "oasisFrameListenerSystem.h"
#include "oasisGraphicsSystem.h"
#include "oasisObjectResource.h"
#include "oasisObjectSystem.h"
#include "oasisPhysics.h"
#include "oasisJoint.h"
#include "oasisJoints.h"
#include "oasisProxy.h"
#include "oasisProxies.h"
#include "oasisPhysicsResource.h"
#include "oasisMass.h"
#include "oasisPhysicsSystem.h"
#include "oasisSound.h"
#include "oasisSoundResource.h"
#include "oasisSoundSystem.h"
#include "oasisScriptSystem.h"
#include "oasisObject.h"
#include "oasisEntity.h"

#include "lua.h"
#include "luabind.hpp"
#include "oasisLua_export_wrap.h"
using namespace Oasis;

int errorHandler( lua_State *L ) {
  string error = lua_tostring( L, 1 );
  scriptSystem::get( ).scriptLog( error );
  return 1;
}

/* Exported function */
int lua_engine_open( lua_State* L ) {
  lua_State *engine = L;
  luabind::open( L );
  
 // Redirect errors
 lua_register( engine, 
   "_ALERT",
 ( lua_CFunction )&errorHandler );
    scriptSystem::get( ).scriptLog( 
            "Registering custom types..." );

  luabind::module( engine ) [
    luabind::class_< vector3 >( "vector3" )
    .def( luabind::constructor< >( ) )
    .def( luabind::constructor< real, real, real >( ) )
    .def( luabind::self * int( ) )
    .def_readwrite( "x", &vector3::x )
    .def_readwrite( "y", &vector3::y )
    .def_readwrite( "z", &vector3::z )
  ];
   scriptSystem::get( ).scriptLog( "Vector3 registered" );
   
   
   luabind::module( engine ) [
    luabind::class_< quaternion >( "quaternion" )
    .def( luabind::constructor< >( ) )
    .def( luabind::constructor< real, real, real, real >( ) )
    .def( "fromAxisAndAngle", &quaternion::fromAxisAndAngle )
    .def_readwrite( "w", &quaternion::w )
    .def_readwrite( "x", &quaternion::x )
    .def_readwrite( "y", &quaternion::y )
    .def_readwrite( "z", &quaternion::z )
  ];
   scriptSystem::get( ).scriptLog( "Quaternion registered" );
   
   luabind::module( engine ) [
    luabind::class_< colour >( "colour" )
    .def( luabind::constructor< >( ) )
    .def( luabind::constructor< real, real, real, real >( ) )
    .def_readwrite( "red", &colour::red )
    .def_readwrite( "green", &colour::green )
    .def_readwrite( "blue", &colour::blue )
    .def_readwrite( "alpha", &colour::alpha )
  ];
   scriptSystem::get( ).scriptLog( "Colour registered" );
   
   luabind::module( engine ) [
    luabind::class_< audible >( "audible" )
   .def( "addSound", ( sound*( audible::* )( const string&, const string& ) )
    &audible::addSound )
    .def( "addSound", ( void( audible::* )( const string&, sound* ) )
    &audible::addSound )
    .def( "getSound", &audible::getSound )
    .def( "playSound", &audible::playSound )
    .def( "stopSound", &audible::stopSound )
    .def( "stopAllSounds", &audible::stopAllSounds )
    .def( "removeAllSounds", &audible::removeAllSounds )
    .def( "removeAndDestroyAllSounds", &audible::removeAndDestroyAllSounds )
    .def( "removeSound", &audible::removeSound )
    .def( "removeAndDestroySound", &audible::removeAndDestroySound )
  ];
  scriptSystem::get( ).scriptLog( "Audible registered" );
  /* 
   luabind::module( engine ) [
    luabind::class_< movable >( "movable" )
    .def( "setPosition", ( void( movable::* )( real, real, real ) )
   &movable::setPosition )
    .def( "setPosition", ( void( movable::* )( const vector3& ) )
   &movable::setPosition )
    .def( "getPosition", &movable::getPosition )
    .def( "move", ( void( movable::* )( real, real, real ) )
   &movable::move )
    .def( "move", ( void( movable::* )( const vector3& ) )
   &movable::move )
    .def( "moveRelative", ( void( movable::* )( real, real, real ) )
   &movable::moveRelative )
    .def( "moveRelative", ( void( movable::* )( const vector3& ) )
   &movable::moveRelative )
    .def( "rotate", ( void( movable::* )( real, real, real, real ) )
   &movable::rotate )
    .def( "rotate", ( void( movable::* )( const vector3&, real ) )
   &movable::rotate )
    .def( "rotate", ( void( movable::* )( const quaternion& ) )
   &movable::rotate )
    .def( "setOrientation", &movable::setOrientation )
    .def( "getOrientation", &movable::getOrientation )
    .def( "getDirection", &movable::getDirection )
  ];
   scriptSystem::get( ).scriptLog( "Movable registered" );
   
   luabind::module( engine ) [
    luabind::class_< physical, movable >( "physical" )
    .def( "enablePhysics", &physical::enablePhysics )
    .def( "setPhysics", ( void( physical::* )( physics* ) )
   &physical::setPhysics )
    .def( "setPhysics", ( physics*( physical::* )( const string& ) )
   &physical::setPhysics )
    .def( "getPhysics", &physical::getPhysics )
    .def( "removePhysics", &physical::removePhysics )
    .def( "removeAndDestroyPhysics", &physical::removeAndDestroyPhysics )
  ];
   scriptSystem::get( ).scriptLog( "Physical registered" );
   
   luabind::module( engine ) [
    luabind::class_< visible >( "visible" )
    .def( "scale", ( void( visible::* )( real, real, real ) )
   &visible::scale )
    .def( "scale", ( void( visible::* )( const vector3& ) )
   &visible::scale )      
    .def( "setScale", ( void( visible::* )( real, real, real ) )
   &visible::setScale )
    .def( "setScale", ( void( visible::* )( const vector3& ) )
   &visible::setScale )
    .def( "getScale", &visible::getScale )
    .def( "setEntity", ( entity*( visible::* )( const string& ) )
          &visible::setEntity )
    .def( "setEntity", ( void( visible::* )( entity* ) )
          &visible::setEntity )
    .def( "getEntity", &visible::getEntity )
    .def( "removeEntity", &visible::removeEntity )
    .def( "removeAndDestroyEntity", &visible::removeAndDestroyEntity )
  ];
   scriptSystem::get( ).scriptLog( "Visible registered" );
   
   luabind::module( engine ) [
    luabind::class_< pool >( "pool" )
    .def( "clearPool", &pool::clearPool )
    .def( "getPoolName", &pool::getPoolName )
    .def( "setPoolSize", &pool::setPoolSize )
    .def( "getPoolSize", &pool::getPoolSize )
    .def( "getNextUniqueName", &pool::getNextUniqueName )
  ];
   scriptSystem::get( ).scriptLog( "Pool registered" );

   /// More
  luabind::module( engine ) [
    luabind::class_< cameraSystem, movable >( "cameraSystem" )
    .def( "reset", &cameraSystem::reset )
    .def( "setSoundListener", &cameraSystem::setSoundListener )     
    .def( "setDirection", ( void( cameraSystem::* )( real, real, real ) )
    &cameraSystem::setDirection )
    .def( "setDirection", ( void( cameraSystem::* )( const vector3& ) )
    &cameraSystem::setDirection )    
    .def( "lookAt", ( void( cameraSystem::* )( const object* ) )
    &cameraSystem::lookAt )
    .def( "lookAt", ( void( cameraSystem::* )( real, real, real ) )
    &cameraSystem::lookAt )
    .def( "lookAt", ( void( cameraSystem::* )( const vector3& ) )
    &cameraSystem::lookAt )
  ];
   luabind::module( engine ) [
    luabind::def( "getCameraSystem", &cameraSystem::get )
  ];

  luabind::module( engine ) [
    luabind::class_< frameListenerSystem >( "frameListenerSystem" )
    .def( "reset", &frameListenerSystem::reset )
    .def( "setTimeScale", &frameListenerSystem::setTimeScale )
    .def( "getTimeScale", &frameListenerSystem::getTimeScale )
  ];
   luabind::module( engine ) [
    luabind::def( "getFrameListenerSystem", &frameListenerSystem::get )
  ];

  luabind::module( engine ) [
    luabind::class_< graphicsSystem >( "graphicsSystem" )
    .enum_( "DetailLevel" ) [
      luabind::value( "DL_POINTS", 0 ),
  luabind::value( "DL_WIREFRAME", 1 ),
  luabind::value( "DL_SOLID", 2 )
    ]
    .enum_( "FogMode" ) [
      luabind::value( "FM_NONE", 0 ),
  luabind::value( "FM_EXP", 1 ),
  luabind::value( "FM_EXP2", 2 ),
  luabind::value( "FM_LINEAR", 3 )
    ]
    .def( "reset", &graphicsSystem::reset )
    .def( "setSkyBox", &graphicsSystem::setSkyBox )
    .def( "setFog", &graphicsSystem::setFog )
    .def( "setBackgroundColour", ( void( graphicsSystem::* )( real, real, real ) )
    &graphicsSystem::setBackgroundColour )
    .def( "setBackgroundColour", ( void( graphicsSystem::* )( const colour& ) )
    &graphicsSystem::setBackgroundColour )
    .def( "setAmbientLight", ( void( graphicsSystem::* )( real, real, real ) )
    &graphicsSystem::setAmbientLight )
    .def( "setAmbientLight", ( void( graphicsSystem::* )( const colour& ) )
    &graphicsSystem::setAmbientLight )
    .def( "takeShot", ( void( graphicsSystem::* )( const string& ) )
    &graphicsSystem::takeShot )
    .def( "takeShot", ( void( graphicsSystem::* )( void ) )
    &graphicsSystem::takeShot )
    .def( "setDetailLevel", &graphicsSystem::setDetailLevel )
    .def( "createEntity", &graphicsSystem::createEntity )
    .def( "removeEntity", ( void( graphicsSystem::* )( entity* ) )
    &graphicsSystem::removeEntity )
    .def( "removeEntity", ( void( graphicsSystem::* )( const string& ) )
    &graphicsSystem::removeEntity )
    .def( "getEntity", &graphicsSystem::getEntity )
  ];
  luabind::module( engine ) [
   luabind::class_< entity >( "entity" )     
   .def( "setAllMaterials", &entity::setAllMaterials )
  ];
  luabind::module( engine ) [
    luabind::def( "getGraphicSystem", &graphicsSystem::get )
  ];

  luabind::module( engine ) [
    luabind::class_< objectSystem, pool >( "objectSystem" )
    .def( "reset", &objectSystem::reset )
    .def( "getObjectTemplate", &objectSystem::getObjectTemplate )
    .def( "createObjectTemplate", &objectSystem::createObjectTemplate )
    .def( "createObject", &objectSystem::createObject )
    .def( "removeObject", ( void( objectSystem::* )( object* ) )
    &objectSystem::removeObject )      
    .def( "removeObject", ( void( objectSystem::* )( const string& ) )
    &objectSystem::removeObject )
    .def( "getObject", &objectSystem::getObject )
  ];

  luabind::module( engine ) [
    luabind::class_< objectResource >( "objectResource" )
    .def( "setScale", ( void( objectResource::* )( real, real, real ) )