Fawkes API  Fawkes Development Version
fawkestf_tolua.cpp
00001 /*
00002 ** Lua binding: fawkestf
00003 ** Generated automatically by tolua++-1.0.92
00004 */
00005 /*  This program is free software; you can redistribute it and/or modify
00006  *  it under the terms of the GNU General Public License as published by
00007  *  the Free Software Foundation; either version 2 of the License, or
00008  *  (at your option) any later version. A runtime exception applies to
00009  *  this software (see LICENSE.GPL_WRE file mentioned below for details).
00010  *
00011  *  This program is distributed in the hope that it will be useful,
00012  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  *  GNU Library General Public License for more details.
00015  *
00016  *  Read the full text in the LICENSE.GPL_WRE file in the doc directory.
00017  */
00018 
00019 #ifndef __cplusplus
00020 #include "stdlib.h"
00021 #endif
00022 #include "string.h"
00023 
00024 #include "tolua++.h"
00025 
00026 /* Exported function */
00027 TOLUA_API int  tolua_fawkestf_open (lua_State* tolua_S);
00028 
00029 #include <tf/types_lua.h>
00030 #include <tf/transformer.h>
00031 
00032 /* function to release collected object via destructor */
00033 #ifdef __cplusplus
00034 
00035 static int tolua_collect_fawkes__tf__StampedTransform (lua_State* tolua_S)
00036 {
00037  fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,1,0);
00038         Mtolua_delete(self);
00039         return 0;
00040 }
00041 
00042 static int tolua_collect_fawkes__tf__Quaternion (lua_State* tolua_S)
00043 {
00044  fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
00045         Mtolua_delete(self);
00046         return 0;
00047 }
00048 
00049 static int tolua_collect_fawkes__tf__Stamped_fawkes__tf__Quaternion_ (lua_State* tolua_S)
00050 {
00051  fawkes::tf::Stamped<fawkes::tf::Quaternion>* self = (fawkes::tf::Stamped<fawkes::tf::Quaternion>*) tolua_tousertype(tolua_S,1,0);
00052         Mtolua_delete(self);
00053         return 0;
00054 }
00055 
00056 static int tolua_collect_fawkes__tf__Point (lua_State* tolua_S)
00057 {
00058  fawkes::tf::Point* self = (fawkes::tf::Point*) tolua_tousertype(tolua_S,1,0);
00059         Mtolua_delete(self);
00060         return 0;
00061 }
00062 
00063 static int tolua_collect_fawkes__tf__Pose (lua_State* tolua_S)
00064 {
00065  fawkes::tf::Pose* self = (fawkes::tf::Pose*) tolua_tousertype(tolua_S,1,0);
00066         Mtolua_delete(self);
00067         return 0;
00068 }
00069 
00070 static int tolua_collect_fawkes__tf__Stamped_fawkes__tf__Pose_ (lua_State* tolua_S)
00071 {
00072  fawkes::tf::Stamped<fawkes::tf::Pose>* self = (fawkes::tf::Stamped<fawkes::tf::Pose>*) tolua_tousertype(tolua_S,1,0);
00073         Mtolua_delete(self);
00074         return 0;
00075 }
00076 
00077 static int tolua_collect_fawkes__tf__Vector3 (lua_State* tolua_S)
00078 {
00079  fawkes::tf::Vector3* self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
00080         Mtolua_delete(self);
00081         return 0;
00082 }
00083 
00084 static int tolua_collect_fawkes__tf__StampedPose (lua_State* tolua_S)
00085 {
00086  fawkes::tf::StampedPose* self = (fawkes::tf::StampedPose*) tolua_tousertype(tolua_S,1,0);
00087         Mtolua_delete(self);
00088         return 0;
00089 }
00090 
00091 static int tolua_collect_fawkes__tf__StampedVector3 (lua_State* tolua_S)
00092 {
00093  fawkes::tf::StampedVector3* self = (fawkes::tf::StampedVector3*) tolua_tousertype(tolua_S,1,0);
00094         Mtolua_delete(self);
00095         return 0;
00096 }
00097 
00098 static int tolua_collect_fawkes__tf__Stamped_fawkes__tf__Point_ (lua_State* tolua_S)
00099 {
00100  fawkes::tf::Stamped<fawkes::tf::Point>* self = (fawkes::tf::Stamped<fawkes::tf::Point>*) tolua_tousertype(tolua_S,1,0);
00101         Mtolua_delete(self);
00102         return 0;
00103 }
00104 
00105 static int tolua_collect_fawkes__tf__StampedPoint (lua_State* tolua_S)
00106 {
00107  fawkes::tf::StampedPoint* self = (fawkes::tf::StampedPoint*) tolua_tousertype(tolua_S,1,0);
00108         Mtolua_delete(self);
00109         return 0;
00110 }
00111 
00112 static int tolua_collect_fawkes__tf__Transform (lua_State* tolua_S)
00113 {
00114  fawkes::tf::Transform* self = (fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
00115         Mtolua_delete(self);
00116         return 0;
00117 }
00118 
00119 static int tolua_collect_fawkes__tf__StampedQuaternion (lua_State* tolua_S)
00120 {
00121  fawkes::tf::StampedQuaternion* self = (fawkes::tf::StampedQuaternion*) tolua_tousertype(tolua_S,1,0);
00122         Mtolua_delete(self);
00123         return 0;
00124 }
00125 
00126 static int tolua_collect_fawkes__tf__Stamped_fawkes__tf__Vector3_ (lua_State* tolua_S)
00127 {
00128  fawkes::tf::Stamped<fawkes::tf::Vector3>* self = (fawkes::tf::Stamped<fawkes::tf::Vector3>*) tolua_tousertype(tolua_S,1,0);
00129         Mtolua_delete(self);
00130         return 0;
00131 }
00132 #endif
00133 
00134 
00135 /* function to register type */
00136 static void tolua_reg_types (lua_State* tolua_S)
00137 {
00138  tolua_usertype(tolua_S,"fawkes::tf::StampedTransform");
00139  tolua_usertype(tolua_S,"fawkes::tf::Quaternion");
00140  tolua_usertype(tolua_S,"fawkes::tf::Stamped<fawkes::tf::Quaternion>");
00141  tolua_usertype(tolua_S,"fawkes::tf::Point");
00142  tolua_usertype(tolua_S,"fawkes::tf::Transformer");
00143  tolua_usertype(tolua_S,"fawkes::tf::Pose");
00144  tolua_usertype(tolua_S,"fawkes::tf::Stamped<fawkes::tf::Pose>");
00145  tolua_usertype(tolua_S,"fawkes::tf::Vector3");
00146  tolua_usertype(tolua_S,"fawkes::tf::StampedPose");
00147  tolua_usertype(tolua_S,"fawkes::tf::StampedQuaternion");
00148  tolua_usertype(tolua_S,"fawkes::tf::StampedVector3");
00149  tolua_usertype(tolua_S,"fawkes::tf::Stamped<fawkes::tf::Point>");
00150  tolua_usertype(tolua_S,"fawkes::tf::StampedPoint");
00151  tolua_usertype(tolua_S,"fawkes::tf::Transform");
00152  tolua_usertype(tolua_S,"fawkes::Time");
00153  tolua_usertype(tolua_S,"fawkes::tf::Stamped<fawkes::tf::Vector3>");
00154 }
00155 
00156 /* method: new of class  fawkes::tf::Vector3 */
00157 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_new00
00158 static int tolua_fawkestf_fawkes_tf_Vector3_new00(lua_State* tolua_S)
00159 {
00160 #ifndef TOLUA_RELEASE
00161  tolua_Error tolua_err;
00162  if (
00163      !tolua_isusertable(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
00164      !tolua_isnoobj(tolua_S,2,&tolua_err)
00165  )
00166   goto tolua_lerror;
00167  else
00168 #endif
00169  {
00170   {
00171    fawkes::tf::Vector3* tolua_ret = (fawkes::tf::Vector3*)  Mtolua_new((fawkes::tf::Vector3)());
00172     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Vector3");
00173   }
00174  }
00175  return 1;
00176 #ifndef TOLUA_RELEASE
00177  tolua_lerror:
00178  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00179  return 0;
00180 #endif
00181 }
00182 #endif //#ifndef TOLUA_DISABLE
00183 
00184 /* method: new_local of class  fawkes::tf::Vector3 */
00185 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_new00_local
00186 static int tolua_fawkestf_fawkes_tf_Vector3_new00_local(lua_State* tolua_S)
00187 {
00188 #ifndef TOLUA_RELEASE
00189  tolua_Error tolua_err;
00190  if (
00191      !tolua_isusertable(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
00192      !tolua_isnoobj(tolua_S,2,&tolua_err)
00193  )
00194   goto tolua_lerror;
00195  else
00196 #endif
00197  {
00198   {
00199    fawkes::tf::Vector3* tolua_ret = (fawkes::tf::Vector3*)  Mtolua_new((fawkes::tf::Vector3)());
00200     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Vector3");
00201     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00202   }
00203  }
00204  return 1;
00205 #ifndef TOLUA_RELEASE
00206  tolua_lerror:
00207  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00208  return 0;
00209 #endif
00210 }
00211 #endif //#ifndef TOLUA_DISABLE
00212 
00213 /* method: new of class  fawkes::tf::Vector3 */
00214 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_new01
00215 static int tolua_fawkestf_fawkes_tf_Vector3_new01(lua_State* tolua_S)
00216 {
00217  tolua_Error tolua_err;
00218  if (
00219      !tolua_isusertable(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
00220      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00221      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00222      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
00223      !tolua_isnoobj(tolua_S,5,&tolua_err)
00224  )
00225   goto tolua_lerror;
00226  else
00227  {
00228   double x = ((double)  tolua_tonumber(tolua_S,2,0));
00229   double y = ((double)  tolua_tonumber(tolua_S,3,0));
00230   double z = ((double)  tolua_tonumber(tolua_S,4,0));
00231   {
00232    fawkes::tf::Vector3* tolua_ret = (fawkes::tf::Vector3*)  Mtolua_new((fawkes::tf::Vector3)(x,y,z));
00233     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Vector3");
00234   }
00235  }
00236  return 1;
00237 tolua_lerror:
00238  return tolua_fawkestf_fawkes_tf_Vector3_new00(tolua_S);
00239 }
00240 #endif //#ifndef TOLUA_DISABLE
00241 
00242 /* method: new_local of class  fawkes::tf::Vector3 */
00243 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_new01_local
00244 static int tolua_fawkestf_fawkes_tf_Vector3_new01_local(lua_State* tolua_S)
00245 {
00246  tolua_Error tolua_err;
00247  if (
00248      !tolua_isusertable(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
00249      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00250      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00251      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
00252      !tolua_isnoobj(tolua_S,5,&tolua_err)
00253  )
00254   goto tolua_lerror;
00255  else
00256  {
00257   double x = ((double)  tolua_tonumber(tolua_S,2,0));
00258   double y = ((double)  tolua_tonumber(tolua_S,3,0));
00259   double z = ((double)  tolua_tonumber(tolua_S,4,0));
00260   {
00261    fawkes::tf::Vector3* tolua_ret = (fawkes::tf::Vector3*)  Mtolua_new((fawkes::tf::Vector3)(x,y,z));
00262     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Vector3");
00263     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00264   }
00265  }
00266  return 1;
00267 tolua_lerror:
00268  return tolua_fawkestf_fawkes_tf_Vector3_new00_local(tolua_S);
00269 }
00270 #endif //#ifndef TOLUA_DISABLE
00271 
00272 /* method: dot of class  fawkes::tf::Vector3 */
00273 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_dot00
00274 static int tolua_fawkestf_fawkes_tf_Vector3_dot00(lua_State* tolua_S)
00275 {
00276 #ifndef TOLUA_RELEASE
00277  tolua_Error tolua_err;
00278  if (
00279      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
00280      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
00281      !tolua_isnoobj(tolua_S,3,&tolua_err)
00282  )
00283   goto tolua_lerror;
00284  else
00285 #endif
00286  {
00287   const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00288   const fawkes::tf::Vector3* q = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,2,0));
00289 #ifndef TOLUA_RELEASE
00290   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'dot'", NULL);
00291 #endif
00292   {
00293    double tolua_ret = (double)  self->dot(*q);
00294    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00295   }
00296  }
00297  return 1;
00298 #ifndef TOLUA_RELEASE
00299  tolua_lerror:
00300  tolua_error(tolua_S,"#ferror in function 'dot'.",&tolua_err);
00301  return 0;
00302 #endif
00303 }
00304 #endif //#ifndef TOLUA_DISABLE
00305 
00306 /* method: length2 of class  fawkes::tf::Vector3 */
00307 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_length200
00308 static int tolua_fawkestf_fawkes_tf_Vector3_length200(lua_State* tolua_S)
00309 {
00310 #ifndef TOLUA_RELEASE
00311  tolua_Error tolua_err;
00312  if (
00313      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
00314      !tolua_isnoobj(tolua_S,2,&tolua_err)
00315  )
00316   goto tolua_lerror;
00317  else
00318 #endif
00319  {
00320   const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00321 #ifndef TOLUA_RELEASE
00322   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'length2'", NULL);
00323 #endif
00324   {
00325    double tolua_ret = (double)  self->length2();
00326    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00327   }
00328  }
00329  return 1;
00330 #ifndef TOLUA_RELEASE
00331  tolua_lerror:
00332  tolua_error(tolua_S,"#ferror in function 'length2'.",&tolua_err);
00333  return 0;
00334 #endif
00335 }
00336 #endif //#ifndef TOLUA_DISABLE
00337 
00338 /* method: length of class  fawkes::tf::Vector3 */
00339 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_length00
00340 static int tolua_fawkestf_fawkes_tf_Vector3_length00(lua_State* tolua_S)
00341 {
00342 #ifndef TOLUA_RELEASE
00343  tolua_Error tolua_err;
00344  if (
00345      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
00346      !tolua_isnoobj(tolua_S,2,&tolua_err)
00347  )
00348   goto tolua_lerror;
00349  else
00350 #endif
00351  {
00352   const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00353 #ifndef TOLUA_RELEASE
00354   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'length'", NULL);
00355 #endif
00356   {
00357    double tolua_ret = (double)  self->length();
00358    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00359   }
00360  }
00361  return 1;
00362 #ifndef TOLUA_RELEASE
00363  tolua_lerror:
00364  tolua_error(tolua_S,"#ferror in function 'length'.",&tolua_err);
00365  return 0;
00366 #endif
00367 }
00368 #endif //#ifndef TOLUA_DISABLE
00369 
00370 /* method: distance2 of class  fawkes::tf::Vector3 */
00371 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_distance200
00372 static int tolua_fawkestf_fawkes_tf_Vector3_distance200(lua_State* tolua_S)
00373 {
00374 #ifndef TOLUA_RELEASE
00375  tolua_Error tolua_err;
00376  if (
00377      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
00378      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
00379      !tolua_isnoobj(tolua_S,3,&tolua_err)
00380  )
00381   goto tolua_lerror;
00382  else
00383 #endif
00384  {
00385   const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00386   const fawkes::tf::Vector3* v = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,2,0));
00387 #ifndef TOLUA_RELEASE
00388   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'distance2'", NULL);
00389 #endif
00390   {
00391    double tolua_ret = (double)  self->distance2(*v);
00392    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00393   }
00394  }
00395  return 1;
00396 #ifndef TOLUA_RELEASE
00397  tolua_lerror:
00398  tolua_error(tolua_S,"#ferror in function 'distance2'.",&tolua_err);
00399  return 0;
00400 #endif
00401 }
00402 #endif //#ifndef TOLUA_DISABLE
00403 
00404 /* method: distance of class  fawkes::tf::Vector3 */
00405 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_distance00
00406 static int tolua_fawkestf_fawkes_tf_Vector3_distance00(lua_State* tolua_S)
00407 {
00408 #ifndef TOLUA_RELEASE
00409  tolua_Error tolua_err;
00410  if (
00411      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
00412      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
00413      !tolua_isnoobj(tolua_S,3,&tolua_err)
00414  )
00415   goto tolua_lerror;
00416  else
00417 #endif
00418  {
00419   const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00420   const fawkes::tf::Vector3* v = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,2,0));
00421 #ifndef TOLUA_RELEASE
00422   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'distance'", NULL);
00423 #endif
00424   {
00425    double tolua_ret = (double)  self->distance(*v);
00426    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00427   }
00428  }
00429  return 1;
00430 #ifndef TOLUA_RELEASE
00431  tolua_lerror:
00432  tolua_error(tolua_S,"#ferror in function 'distance'.",&tolua_err);
00433  return 0;
00434 #endif
00435 }
00436 #endif //#ifndef TOLUA_DISABLE
00437 
00438 /* method: normalize of class  fawkes::tf::Vector3 */
00439 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_normalize00
00440 static int tolua_fawkestf_fawkes_tf_Vector3_normalize00(lua_State* tolua_S)
00441 {
00442 #ifndef TOLUA_RELEASE
00443  tolua_Error tolua_err;
00444  if (
00445      !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
00446      !tolua_isnoobj(tolua_S,2,&tolua_err)
00447  )
00448   goto tolua_lerror;
00449  else
00450 #endif
00451  {
00452   fawkes::tf::Vector3* self = (fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00453 #ifndef TOLUA_RELEASE
00454   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'normalize'", NULL);
00455 #endif
00456   {
00457    fawkes::tf::Vector3& tolua_ret = (fawkes::tf::Vector3&)  self->normalize();
00458     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::tf::Vector3");
00459   }
00460  }
00461  return 1;
00462 #ifndef TOLUA_RELEASE
00463  tolua_lerror:
00464  tolua_error(tolua_S,"#ferror in function 'normalize'.",&tolua_err);
00465  return 0;
00466 #endif
00467 }
00468 #endif //#ifndef TOLUA_DISABLE
00469 
00470 /* method: normalized of class  fawkes::tf::Vector3 */
00471 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_normalized00
00472 static int tolua_fawkestf_fawkes_tf_Vector3_normalized00(lua_State* tolua_S)
00473 {
00474 #ifndef TOLUA_RELEASE
00475  tolua_Error tolua_err;
00476  if (
00477      !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
00478      !tolua_isnoobj(tolua_S,2,&tolua_err)
00479  )
00480   goto tolua_lerror;
00481  else
00482 #endif
00483  {
00484   fawkes::tf::Vector3* self = (fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00485 #ifndef TOLUA_RELEASE
00486   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'normalized'", NULL);
00487 #endif
00488   {
00489    fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3)  self->normalized();
00490    {
00491 #ifdef __cplusplus
00492     void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
00493      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
00494     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00495 #else
00496     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Vector3));
00497      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
00498     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00499 #endif
00500    }
00501   }
00502  }
00503  return 1;
00504 #ifndef TOLUA_RELEASE
00505  tolua_lerror:
00506  tolua_error(tolua_S,"#ferror in function 'normalized'.",&tolua_err);
00507  return 0;
00508 #endif
00509 }
00510 #endif //#ifndef TOLUA_DISABLE
00511 
00512 /* method: angle of class  fawkes::tf::Vector3 */
00513 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_angle00
00514 static int tolua_fawkestf_fawkes_tf_Vector3_angle00(lua_State* tolua_S)
00515 {
00516 #ifndef TOLUA_RELEASE
00517  tolua_Error tolua_err;
00518  if (
00519      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
00520      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
00521      !tolua_isnoobj(tolua_S,3,&tolua_err)
00522  )
00523   goto tolua_lerror;
00524  else
00525 #endif
00526  {
00527   const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00528   const fawkes::tf::Vector3* v = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,2,0));
00529 #ifndef TOLUA_RELEASE
00530   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'angle'", NULL);
00531 #endif
00532   {
00533    double tolua_ret = (double)  self->angle(*v);
00534    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00535   }
00536  }
00537  return 1;
00538 #ifndef TOLUA_RELEASE
00539  tolua_lerror:
00540  tolua_error(tolua_S,"#ferror in function 'angle'.",&tolua_err);
00541  return 0;
00542 #endif
00543 }
00544 #endif //#ifndef TOLUA_DISABLE
00545 
00546 /* method: absolute of class  fawkes::tf::Vector3 */
00547 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_absolute00
00548 static int tolua_fawkestf_fawkes_tf_Vector3_absolute00(lua_State* tolua_S)
00549 {
00550 #ifndef TOLUA_RELEASE
00551  tolua_Error tolua_err;
00552  if (
00553      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
00554      !tolua_isnoobj(tolua_S,2,&tolua_err)
00555  )
00556   goto tolua_lerror;
00557  else
00558 #endif
00559  {
00560   const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00561 #ifndef TOLUA_RELEASE
00562   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'absolute'", NULL);
00563 #endif
00564   {
00565    fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3)  self->absolute();
00566    {
00567 #ifdef __cplusplus
00568     void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
00569      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
00570     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00571 #else
00572     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Vector3));
00573      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
00574     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00575 #endif
00576    }
00577   }
00578  }
00579  return 1;
00580 #ifndef TOLUA_RELEASE
00581  tolua_lerror:
00582  tolua_error(tolua_S,"#ferror in function 'absolute'.",&tolua_err);
00583  return 0;
00584 #endif
00585 }
00586 #endif //#ifndef TOLUA_DISABLE
00587 
00588 /* method: cross of class  fawkes::tf::Vector3 */
00589 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_cross00
00590 static int tolua_fawkestf_fawkes_tf_Vector3_cross00(lua_State* tolua_S)
00591 {
00592 #ifndef TOLUA_RELEASE
00593  tolua_Error tolua_err;
00594  if (
00595      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
00596      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
00597      !tolua_isnoobj(tolua_S,3,&tolua_err)
00598  )
00599   goto tolua_lerror;
00600  else
00601 #endif
00602  {
00603   const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00604   const fawkes::tf::Vector3* v = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,2,0));
00605 #ifndef TOLUA_RELEASE
00606   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cross'", NULL);
00607 #endif
00608   {
00609    fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3)  self->cross(*v);
00610    {
00611 #ifdef __cplusplus
00612     void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
00613      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
00614     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00615 #else
00616     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Vector3));
00617      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
00618     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00619 #endif
00620    }
00621   }
00622  }
00623  return 1;
00624 #ifndef TOLUA_RELEASE
00625  tolua_lerror:
00626  tolua_error(tolua_S,"#ferror in function 'cross'.",&tolua_err);
00627  return 0;
00628 #endif
00629 }
00630 #endif //#ifndef TOLUA_DISABLE
00631 
00632 /* method: triple of class  fawkes::tf::Vector3 */
00633 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_triple00
00634 static int tolua_fawkestf_fawkes_tf_Vector3_triple00(lua_State* tolua_S)
00635 {
00636 #ifndef TOLUA_RELEASE
00637  tolua_Error tolua_err;
00638  if (
00639      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
00640      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
00641      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"fawkes::tf::Vector3",0,&tolua_err)) ||
00642      !tolua_isnoobj(tolua_S,4,&tolua_err)
00643  )
00644   goto tolua_lerror;
00645  else
00646 #endif
00647  {
00648   const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00649   const fawkes::tf::Vector3* v1 = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,2,0));
00650   fawkes::tf::Vector3* v2 = ((fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,3,0));
00651 #ifndef TOLUA_RELEASE
00652   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'triple'", NULL);
00653 #endif
00654   {
00655    double tolua_ret = (double)  self->triple(*v1,*v2);
00656    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00657   }
00658  }
00659  return 1;
00660 #ifndef TOLUA_RELEASE
00661  tolua_lerror:
00662  tolua_error(tolua_S,"#ferror in function 'triple'.",&tolua_err);
00663  return 0;
00664 #endif
00665 }
00666 #endif //#ifndef TOLUA_DISABLE
00667 
00668 /* method: minAxis of class  fawkes::tf::Vector3 */
00669 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_minAxis00
00670 static int tolua_fawkestf_fawkes_tf_Vector3_minAxis00(lua_State* tolua_S)
00671 {
00672 #ifndef TOLUA_RELEASE
00673  tolua_Error tolua_err;
00674  if (
00675      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
00676      !tolua_isnoobj(tolua_S,2,&tolua_err)
00677  )
00678   goto tolua_lerror;
00679  else
00680 #endif
00681  {
00682   const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00683 #ifndef TOLUA_RELEASE
00684   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'minAxis'", NULL);
00685 #endif
00686   {
00687    int tolua_ret = (int)  self->minAxis();
00688    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00689   }
00690  }
00691  return 1;
00692 #ifndef TOLUA_RELEASE
00693  tolua_lerror:
00694  tolua_error(tolua_S,"#ferror in function 'minAxis'.",&tolua_err);
00695  return 0;
00696 #endif
00697 }
00698 #endif //#ifndef TOLUA_DISABLE
00699 
00700 /* method: maxAxis of class  fawkes::tf::Vector3 */
00701 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_maxAxis00
00702 static int tolua_fawkestf_fawkes_tf_Vector3_maxAxis00(lua_State* tolua_S)
00703 {
00704 #ifndef TOLUA_RELEASE
00705  tolua_Error tolua_err;
00706  if (
00707      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
00708      !tolua_isnoobj(tolua_S,2,&tolua_err)
00709  )
00710   goto tolua_lerror;
00711  else
00712 #endif
00713  {
00714   const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00715 #ifndef TOLUA_RELEASE
00716   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxAxis'", NULL);
00717 #endif
00718   {
00719    int tolua_ret = (int)  self->maxAxis();
00720    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00721   }
00722  }
00723  return 1;
00724 #ifndef TOLUA_RELEASE
00725  tolua_lerror:
00726  tolua_error(tolua_S,"#ferror in function 'maxAxis'.",&tolua_err);
00727  return 0;
00728 #endif
00729 }
00730 #endif //#ifndef TOLUA_DISABLE
00731 
00732 /* method: furthestAxis of class  fawkes::tf::Vector3 */
00733 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_furthestAxis00
00734 static int tolua_fawkestf_fawkes_tf_Vector3_furthestAxis00(lua_State* tolua_S)
00735 {
00736 #ifndef TOLUA_RELEASE
00737  tolua_Error tolua_err;
00738  if (
00739      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
00740      !tolua_isnoobj(tolua_S,2,&tolua_err)
00741  )
00742   goto tolua_lerror;
00743  else
00744 #endif
00745  {
00746   const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00747 #ifndef TOLUA_RELEASE
00748   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'furthestAxis'", NULL);
00749 #endif
00750   {
00751    int tolua_ret = (int)  self->furthestAxis();
00752    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00753   }
00754  }
00755  return 1;
00756 #ifndef TOLUA_RELEASE
00757  tolua_lerror:
00758  tolua_error(tolua_S,"#ferror in function 'furthestAxis'.",&tolua_err);
00759  return 0;
00760 #endif
00761 }
00762 #endif //#ifndef TOLUA_DISABLE
00763 
00764 /* method: closestAxis of class  fawkes::tf::Vector3 */
00765 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_closestAxis00
00766 static int tolua_fawkestf_fawkes_tf_Vector3_closestAxis00(lua_State* tolua_S)
00767 {
00768 #ifndef TOLUA_RELEASE
00769  tolua_Error tolua_err;
00770  if (
00771      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
00772      !tolua_isnoobj(tolua_S,2,&tolua_err)
00773  )
00774   goto tolua_lerror;
00775  else
00776 #endif
00777  {
00778   const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00779 #ifndef TOLUA_RELEASE
00780   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'closestAxis'", NULL);
00781 #endif
00782   {
00783    int tolua_ret = (int)  self->closestAxis();
00784    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00785   }
00786  }
00787  return 1;
00788 #ifndef TOLUA_RELEASE
00789  tolua_lerror:
00790  tolua_error(tolua_S,"#ferror in function 'closestAxis'.",&tolua_err);
00791  return 0;
00792 #endif
00793 }
00794 #endif //#ifndef TOLUA_DISABLE
00795 
00796 /* method: setInterpolate3 of class  fawkes::tf::Vector3 */
00797 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setInterpolate300
00798 static int tolua_fawkestf_fawkes_tf_Vector3_setInterpolate300(lua_State* tolua_S)
00799 {
00800 #ifndef TOLUA_RELEASE
00801  tolua_Error tolua_err;
00802  if (
00803      !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
00804      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
00805      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::Vector3",0,&tolua_err)) ||
00806      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
00807      !tolua_isnoobj(tolua_S,5,&tolua_err)
00808  )
00809   goto tolua_lerror;
00810  else
00811 #endif
00812  {
00813   fawkes::tf::Vector3* self = (fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00814   const fawkes::tf::Vector3* v0 = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,2,0));
00815   const fawkes::tf::Vector3* v1 = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,3,0));
00816   double rt = ((double)  tolua_tonumber(tolua_S,4,0));
00817 #ifndef TOLUA_RELEASE
00818   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setInterpolate3'", NULL);
00819 #endif
00820   {
00821    self->setInterpolate3(*v0,*v1,rt);
00822   }
00823  }
00824  return 0;
00825 #ifndef TOLUA_RELEASE
00826  tolua_lerror:
00827  tolua_error(tolua_S,"#ferror in function 'setInterpolate3'.",&tolua_err);
00828  return 0;
00829 #endif
00830 }
00831 #endif //#ifndef TOLUA_DISABLE
00832 
00833 /* method: lerp of class  fawkes::tf::Vector3 */
00834 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_lerp00
00835 static int tolua_fawkestf_fawkes_tf_Vector3_lerp00(lua_State* tolua_S)
00836 {
00837 #ifndef TOLUA_RELEASE
00838  tolua_Error tolua_err;
00839  if (
00840      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
00841      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
00842      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
00843      !tolua_isnoobj(tolua_S,4,&tolua_err)
00844  )
00845   goto tolua_lerror;
00846  else
00847 #endif
00848  {
00849   const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00850   const fawkes::tf::Vector3* v = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,2,0));
00851   const double t = ((const double)  tolua_tonumber(tolua_S,3,0));
00852 #ifndef TOLUA_RELEASE
00853   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lerp'", NULL);
00854 #endif
00855   {
00856    fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3)  self->lerp(*v,t);
00857    {
00858 #ifdef __cplusplus
00859     void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
00860      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
00861     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00862 #else
00863     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Vector3));
00864      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
00865     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00866 #endif
00867    }
00868    tolua_pushnumber(tolua_S,(lua_Number)t);
00869   }
00870  }
00871  return 2;
00872 #ifndef TOLUA_RELEASE
00873  tolua_lerror:
00874  tolua_error(tolua_S,"#ferror in function 'lerp'.",&tolua_err);
00875  return 0;
00876 #endif
00877 }
00878 #endif //#ifndef TOLUA_DISABLE
00879 
00880 /* method: x of class  fawkes::tf::Vector3 */
00881 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_x00
00882 static int tolua_fawkestf_fawkes_tf_Vector3_x00(lua_State* tolua_S)
00883 {
00884 #ifndef TOLUA_RELEASE
00885  tolua_Error tolua_err;
00886  if (
00887      !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
00888      !tolua_isnoobj(tolua_S,2,&tolua_err)
00889  )
00890   goto tolua_lerror;
00891  else
00892 #endif
00893  {
00894   fawkes::tf::Vector3* self = (fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00895 #ifndef TOLUA_RELEASE
00896   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
00897 #endif
00898   {
00899    const double tolua_ret = (const double)  self->x();
00900    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00901   }
00902  }
00903  return 1;
00904 #ifndef TOLUA_RELEASE
00905  tolua_lerror:
00906  tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
00907  return 0;
00908 #endif
00909 }
00910 #endif //#ifndef TOLUA_DISABLE
00911 
00912 /* method: y of class  fawkes::tf::Vector3 */
00913 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_y00
00914 static int tolua_fawkestf_fawkes_tf_Vector3_y00(lua_State* tolua_S)
00915 {
00916 #ifndef TOLUA_RELEASE
00917  tolua_Error tolua_err;
00918  if (
00919      !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
00920      !tolua_isnoobj(tolua_S,2,&tolua_err)
00921  )
00922   goto tolua_lerror;
00923  else
00924 #endif
00925  {
00926   fawkes::tf::Vector3* self = (fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00927 #ifndef TOLUA_RELEASE
00928   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
00929 #endif
00930   {
00931    const double tolua_ret = (const double)  self->y();
00932    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00933   }
00934  }
00935  return 1;
00936 #ifndef TOLUA_RELEASE
00937  tolua_lerror:
00938  tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
00939  return 0;
00940 #endif
00941 }
00942 #endif //#ifndef TOLUA_DISABLE
00943 
00944 /* method: z of class  fawkes::tf::Vector3 */
00945 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_z00
00946 static int tolua_fawkestf_fawkes_tf_Vector3_z00(lua_State* tolua_S)
00947 {
00948 #ifndef TOLUA_RELEASE
00949  tolua_Error tolua_err;
00950  if (
00951      !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
00952      !tolua_isnoobj(tolua_S,2,&tolua_err)
00953  )
00954   goto tolua_lerror;
00955  else
00956 #endif
00957  {
00958   fawkes::tf::Vector3* self = (fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00959 #ifndef TOLUA_RELEASE
00960   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'z'", NULL);
00961 #endif
00962   {
00963    const double tolua_ret = (const double)  self->z();
00964    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00965   }
00966  }
00967  return 1;
00968 #ifndef TOLUA_RELEASE
00969  tolua_lerror:
00970  tolua_error(tolua_S,"#ferror in function 'z'.",&tolua_err);
00971  return 0;
00972 #endif
00973 }
00974 #endif //#ifndef TOLUA_DISABLE
00975 
00976 /* method: setX of class  fawkes::tf::Vector3 */
00977 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setX00
00978 static int tolua_fawkestf_fawkes_tf_Vector3_setX00(lua_State* tolua_S)
00979 {
00980 #ifndef TOLUA_RELEASE
00981  tolua_Error tolua_err;
00982  if (
00983      !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
00984      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00985      !tolua_isnoobj(tolua_S,3,&tolua_err)
00986  )
00987   goto tolua_lerror;
00988  else
00989 #endif
00990  {
00991   fawkes::tf::Vector3* self = (fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
00992   double x = ((double)  tolua_tonumber(tolua_S,2,0));
00993 #ifndef TOLUA_RELEASE
00994   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setX'", NULL);
00995 #endif
00996   {
00997    self->setX(x);
00998   }
00999  }
01000  return 0;
01001 #ifndef TOLUA_RELEASE
01002  tolua_lerror:
01003  tolua_error(tolua_S,"#ferror in function 'setX'.",&tolua_err);
01004  return 0;
01005 #endif
01006 }
01007 #endif //#ifndef TOLUA_DISABLE
01008 
01009 /* method: setY of class  fawkes::tf::Vector3 */
01010 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setY00
01011 static int tolua_fawkestf_fawkes_tf_Vector3_setY00(lua_State* tolua_S)
01012 {
01013 #ifndef TOLUA_RELEASE
01014  tolua_Error tolua_err;
01015  if (
01016      !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
01017      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01018      !tolua_isnoobj(tolua_S,3,&tolua_err)
01019  )
01020   goto tolua_lerror;
01021  else
01022 #endif
01023  {
01024   fawkes::tf::Vector3* self = (fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
01025   double x = ((double)  tolua_tonumber(tolua_S,2,0));
01026 #ifndef TOLUA_RELEASE
01027   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setY'", NULL);
01028 #endif
01029   {
01030    self->setY(x);
01031   }
01032  }
01033  return 0;
01034 #ifndef TOLUA_RELEASE
01035  tolua_lerror:
01036  tolua_error(tolua_S,"#ferror in function 'setY'.",&tolua_err);
01037  return 0;
01038 #endif
01039 }
01040 #endif //#ifndef TOLUA_DISABLE
01041 
01042 /* method: setZ of class  fawkes::tf::Vector3 */
01043 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setZ00
01044 static int tolua_fawkestf_fawkes_tf_Vector3_setZ00(lua_State* tolua_S)
01045 {
01046 #ifndef TOLUA_RELEASE
01047  tolua_Error tolua_err;
01048  if (
01049      !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
01050      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01051      !tolua_isnoobj(tolua_S,3,&tolua_err)
01052  )
01053   goto tolua_lerror;
01054  else
01055 #endif
01056  {
01057   fawkes::tf::Vector3* self = (fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
01058   double x = ((double)  tolua_tonumber(tolua_S,2,0));
01059 #ifndef TOLUA_RELEASE
01060   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setZ'", NULL);
01061 #endif
01062   {
01063    self->setZ(x);
01064   }
01065  }
01066  return 0;
01067 #ifndef TOLUA_RELEASE
01068  tolua_lerror:
01069  tolua_error(tolua_S,"#ferror in function 'setZ'.",&tolua_err);
01070  return 0;
01071 #endif
01072 }
01073 #endif //#ifndef TOLUA_DISABLE
01074 
01075 /* method: setValue of class  fawkes::tf::Vector3 */
01076 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setValue00
01077 static int tolua_fawkestf_fawkes_tf_Vector3_setValue00(lua_State* tolua_S)
01078 {
01079 #ifndef TOLUA_RELEASE
01080  tolua_Error tolua_err;
01081  if (
01082      !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
01083      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01084      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01085      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01086      !tolua_isnoobj(tolua_S,5,&tolua_err)
01087  )
01088   goto tolua_lerror;
01089  else
01090 #endif
01091  {
01092   fawkes::tf::Vector3* self = (fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
01093   double x = ((double)  tolua_tonumber(tolua_S,2,0));
01094   double y = ((double)  tolua_tonumber(tolua_S,3,0));
01095   double z = ((double)  tolua_tonumber(tolua_S,4,0));
01096 #ifndef TOLUA_RELEASE
01097   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setValue'", NULL);
01098 #endif
01099   {
01100    self->setValue(x,y,z);
01101   }
01102  }
01103  return 0;
01104 #ifndef TOLUA_RELEASE
01105  tolua_lerror:
01106  tolua_error(tolua_S,"#ferror in function 'setValue'.",&tolua_err);
01107  return 0;
01108 #endif
01109 }
01110 #endif //#ifndef TOLUA_DISABLE
01111 
01112 /* method: setZero of class  fawkes::tf::Vector3 */
01113 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setZero00
01114 static int tolua_fawkestf_fawkes_tf_Vector3_setZero00(lua_State* tolua_S)
01115 {
01116 #ifndef TOLUA_RELEASE
01117  tolua_Error tolua_err;
01118  if (
01119      !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
01120      !tolua_isnoobj(tolua_S,2,&tolua_err)
01121  )
01122   goto tolua_lerror;
01123  else
01124 #endif
01125  {
01126   fawkes::tf::Vector3* self = (fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
01127 #ifndef TOLUA_RELEASE
01128   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setZero'", NULL);
01129 #endif
01130   {
01131    self->setZero();
01132   }
01133  }
01134  return 0;
01135 #ifndef TOLUA_RELEASE
01136  tolua_lerror:
01137  tolua_error(tolua_S,"#ferror in function 'setZero'.",&tolua_err);
01138  return 0;
01139 #endif
01140 }
01141 #endif //#ifndef TOLUA_DISABLE
01142 
01143 /* method: isZero of class  fawkes::tf::Vector3 */
01144 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_isZero00
01145 static int tolua_fawkestf_fawkes_tf_Vector3_isZero00(lua_State* tolua_S)
01146 {
01147 #ifndef TOLUA_RELEASE
01148  tolua_Error tolua_err;
01149  if (
01150      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
01151      !tolua_isnoobj(tolua_S,2,&tolua_err)
01152  )
01153   goto tolua_lerror;
01154  else
01155 #endif
01156  {
01157   const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
01158 #ifndef TOLUA_RELEASE
01159   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isZero'", NULL);
01160 #endif
01161   {
01162    bool tolua_ret = (bool)  self->isZero();
01163    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01164   }
01165  }
01166  return 1;
01167 #ifndef TOLUA_RELEASE
01168  tolua_lerror:
01169  tolua_error(tolua_S,"#ferror in function 'isZero'.",&tolua_err);
01170  return 0;
01171 #endif
01172 }
01173 #endif //#ifndef TOLUA_DISABLE
01174 
01175 /* method: fuzzyZero of class  fawkes::tf::Vector3 */
01176 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_fuzzyZero00
01177 static int tolua_fawkestf_fawkes_tf_Vector3_fuzzyZero00(lua_State* tolua_S)
01178 {
01179 #ifndef TOLUA_RELEASE
01180  tolua_Error tolua_err;
01181  if (
01182      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
01183      !tolua_isnoobj(tolua_S,2,&tolua_err)
01184  )
01185   goto tolua_lerror;
01186  else
01187 #endif
01188  {
01189   const fawkes::tf::Vector3* self = (const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,1,0);
01190 #ifndef TOLUA_RELEASE
01191   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'fuzzyZero'", NULL);
01192 #endif
01193   {
01194    bool tolua_ret = (bool)  self->fuzzyZero();
01195    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01196   }
01197  }
01198  return 1;
01199 #ifndef TOLUA_RELEASE
01200  tolua_lerror:
01201  tolua_error(tolua_S,"#ferror in function 'fuzzyZero'.",&tolua_err);
01202  return 0;
01203 #endif
01204 }
01205 #endif //#ifndef TOLUA_DISABLE
01206 
01207 /* method: new of class  fawkes::tf::Quaternion */
01208 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new00
01209 static int tolua_fawkestf_fawkes_tf_Quaternion_new00(lua_State* tolua_S)
01210 {
01211 #ifndef TOLUA_RELEASE
01212  tolua_Error tolua_err;
01213  if (
01214      !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
01215      !tolua_isnoobj(tolua_S,2,&tolua_err)
01216  )
01217   goto tolua_lerror;
01218  else
01219 #endif
01220  {
01221   {
01222    fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*)  Mtolua_new((fawkes::tf::Quaternion)());
01223     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Quaternion");
01224   }
01225  }
01226  return 1;
01227 #ifndef TOLUA_RELEASE
01228  tolua_lerror:
01229  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01230  return 0;
01231 #endif
01232 }
01233 #endif //#ifndef TOLUA_DISABLE
01234 
01235 /* method: new_local of class  fawkes::tf::Quaternion */
01236 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new00_local
01237 static int tolua_fawkestf_fawkes_tf_Quaternion_new00_local(lua_State* tolua_S)
01238 {
01239 #ifndef TOLUA_RELEASE
01240  tolua_Error tolua_err;
01241  if (
01242      !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
01243      !tolua_isnoobj(tolua_S,2,&tolua_err)
01244  )
01245   goto tolua_lerror;
01246  else
01247 #endif
01248  {
01249   {
01250    fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*)  Mtolua_new((fawkes::tf::Quaternion)());
01251     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Quaternion");
01252     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01253   }
01254  }
01255  return 1;
01256 #ifndef TOLUA_RELEASE
01257  tolua_lerror:
01258  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01259  return 0;
01260 #endif
01261 }
01262 #endif //#ifndef TOLUA_DISABLE
01263 
01264 /* method: new of class  fawkes::tf::Quaternion */
01265 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new01
01266 static int tolua_fawkestf_fawkes_tf_Quaternion_new01(lua_State* tolua_S)
01267 {
01268  tolua_Error tolua_err;
01269  if (
01270      !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
01271      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01272      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01273      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01274      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
01275      !tolua_isnoobj(tolua_S,6,&tolua_err)
01276  )
01277   goto tolua_lerror;
01278  else
01279  {
01280   double x = ((double)  tolua_tonumber(tolua_S,2,0));
01281   double y = ((double)  tolua_tonumber(tolua_S,3,0));
01282   double z = ((double)  tolua_tonumber(tolua_S,4,0));
01283   double w = ((double)  tolua_tonumber(tolua_S,5,0));
01284   {
01285    fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*)  Mtolua_new((fawkes::tf::Quaternion)(x,y,z,w));
01286     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Quaternion");
01287   }
01288  }
01289  return 1;
01290 tolua_lerror:
01291  return tolua_fawkestf_fawkes_tf_Quaternion_new00(tolua_S);
01292 }
01293 #endif //#ifndef TOLUA_DISABLE
01294 
01295 /* method: new_local of class  fawkes::tf::Quaternion */
01296 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new01_local
01297 static int tolua_fawkestf_fawkes_tf_Quaternion_new01_local(lua_State* tolua_S)
01298 {
01299  tolua_Error tolua_err;
01300  if (
01301      !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
01302      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01303      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01304      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01305      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
01306      !tolua_isnoobj(tolua_S,6,&tolua_err)
01307  )
01308   goto tolua_lerror;
01309  else
01310  {
01311   double x = ((double)  tolua_tonumber(tolua_S,2,0));
01312   double y = ((double)  tolua_tonumber(tolua_S,3,0));
01313   double z = ((double)  tolua_tonumber(tolua_S,4,0));
01314   double w = ((double)  tolua_tonumber(tolua_S,5,0));
01315   {
01316    fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*)  Mtolua_new((fawkes::tf::Quaternion)(x,y,z,w));
01317     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Quaternion");
01318     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01319   }
01320  }
01321  return 1;
01322 tolua_lerror:
01323  return tolua_fawkestf_fawkes_tf_Quaternion_new00_local(tolua_S);
01324 }
01325 #endif //#ifndef TOLUA_DISABLE
01326 
01327 /* method: new of class  fawkes::tf::Quaternion */
01328 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new02
01329 static int tolua_fawkestf_fawkes_tf_Quaternion_new02(lua_State* tolua_S)
01330 {
01331  tolua_Error tolua_err;
01332  if (
01333      !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
01334      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::tf::Vector3",0,&tolua_err)) ||
01335      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01336      !tolua_isnoobj(tolua_S,4,&tolua_err)
01337  )
01338   goto tolua_lerror;
01339  else
01340  {
01341   fawkes::tf::Vector3 axis = *((fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,2,0));
01342   const double angle = ((const double)  tolua_tonumber(tolua_S,3,0));
01343   {
01344    fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*)  Mtolua_new((fawkes::tf::Quaternion)(axis,angle));
01345     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Quaternion");
01346   }
01347  }
01348  return 1;
01349 tolua_lerror:
01350  return tolua_fawkestf_fawkes_tf_Quaternion_new01(tolua_S);
01351 }
01352 #endif //#ifndef TOLUA_DISABLE
01353 
01354 /* method: new_local of class  fawkes::tf::Quaternion */
01355 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new02_local
01356 static int tolua_fawkestf_fawkes_tf_Quaternion_new02_local(lua_State* tolua_S)
01357 {
01358  tolua_Error tolua_err;
01359  if (
01360      !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
01361      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::tf::Vector3",0,&tolua_err)) ||
01362      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01363      !tolua_isnoobj(tolua_S,4,&tolua_err)
01364  )
01365   goto tolua_lerror;
01366  else
01367  {
01368   fawkes::tf::Vector3 axis = *((fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,2,0));
01369   const double angle = ((const double)  tolua_tonumber(tolua_S,3,0));
01370   {
01371    fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*)  Mtolua_new((fawkes::tf::Quaternion)(axis,angle));
01372     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Quaternion");
01373     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01374   }
01375  }
01376  return 1;
01377 tolua_lerror:
01378  return tolua_fawkestf_fawkes_tf_Quaternion_new01_local(tolua_S);
01379 }
01380 #endif //#ifndef TOLUA_DISABLE
01381 
01382 /* method: new of class  fawkes::tf::Quaternion */
01383 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new03
01384 static int tolua_fawkestf_fawkes_tf_Quaternion_new03(lua_State* tolua_S)
01385 {
01386  tolua_Error tolua_err;
01387  if (
01388      !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
01389      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01390      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01391      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01392      !tolua_isnoobj(tolua_S,5,&tolua_err)
01393  )
01394   goto tolua_lerror;
01395  else
01396  {
01397   const double yaw = ((const double)  tolua_tonumber(tolua_S,2,0));
01398   const double pitch = ((const double)  tolua_tonumber(tolua_S,3,0));
01399   const double roll = ((const double)  tolua_tonumber(tolua_S,4,0));
01400   {
01401    fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*)  Mtolua_new((fawkes::tf::Quaternion)(yaw,pitch,roll));
01402     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Quaternion");
01403   }
01404  }
01405  return 1;
01406 tolua_lerror:
01407  return tolua_fawkestf_fawkes_tf_Quaternion_new02(tolua_S);
01408 }
01409 #endif //#ifndef TOLUA_DISABLE
01410 
01411 /* method: new_local of class  fawkes::tf::Quaternion */
01412 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new03_local
01413 static int tolua_fawkestf_fawkes_tf_Quaternion_new03_local(lua_State* tolua_S)
01414 {
01415  tolua_Error tolua_err;
01416  if (
01417      !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
01418      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01419      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01420      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01421      !tolua_isnoobj(tolua_S,5,&tolua_err)
01422  )
01423   goto tolua_lerror;
01424  else
01425  {
01426   const double yaw = ((const double)  tolua_tonumber(tolua_S,2,0));
01427   const double pitch = ((const double)  tolua_tonumber(tolua_S,3,0));
01428   const double roll = ((const double)  tolua_tonumber(tolua_S,4,0));
01429   {
01430    fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*)  Mtolua_new((fawkes::tf::Quaternion)(yaw,pitch,roll));
01431     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Quaternion");
01432     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01433   }
01434  }
01435  return 1;
01436 tolua_lerror:
01437  return tolua_fawkestf_fawkes_tf_Quaternion_new02_local(tolua_S);
01438 }
01439 #endif //#ifndef TOLUA_DISABLE
01440 
01441 /* method: getIdentity of class  fawkes::tf::Quaternion */
01442 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_getIdentity00
01443 static int tolua_fawkestf_fawkes_tf_Quaternion_getIdentity00(lua_State* tolua_S)
01444 {
01445 #ifndef TOLUA_RELEASE
01446  tolua_Error tolua_err;
01447  if (
01448      !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
01449      !tolua_isnoobj(tolua_S,2,&tolua_err)
01450  )
01451   goto tolua_lerror;
01452  else
01453 #endif
01454  {
01455   {
01456    const fawkes::tf::Quaternion& tolua_ret = (const fawkes::tf::Quaternion&)  fawkes::tf::Quaternion::getIdentity();
01457     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const fawkes::tf::Quaternion");
01458   }
01459  }
01460  return 1;
01461 #ifndef TOLUA_RELEASE
01462  tolua_lerror:
01463  tolua_error(tolua_S,"#ferror in function 'getIdentity'.",&tolua_err);
01464  return 0;
01465 #endif
01466 }
01467 #endif //#ifndef TOLUA_DISABLE
01468 
01469 /* method: setRotation of class  fawkes::tf::Quaternion */
01470 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setRotation00
01471 static int tolua_fawkestf_fawkes_tf_Quaternion_setRotation00(lua_State* tolua_S)
01472 {
01473 #ifndef TOLUA_RELEASE
01474  tolua_Error tolua_err;
01475  if (
01476      !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
01477      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::tf::Vector3",0,&tolua_err)) ||
01478      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01479      !tolua_isnoobj(tolua_S,4,&tolua_err)
01480  )
01481   goto tolua_lerror;
01482  else
01483 #endif
01484  {
01485   fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
01486   fawkes::tf::Vector3 axis = *((fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,2,0));
01487   const double angle = ((const double)  tolua_tonumber(tolua_S,3,0));
01488 #ifndef TOLUA_RELEASE
01489   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRotation'", NULL);
01490 #endif
01491   {
01492    self->setRotation(axis,angle);
01493   }
01494  }
01495  return 0;
01496 #ifndef TOLUA_RELEASE
01497  tolua_lerror:
01498  tolua_error(tolua_S,"#ferror in function 'setRotation'.",&tolua_err);
01499  return 0;
01500 #endif
01501 }
01502 #endif //#ifndef TOLUA_DISABLE
01503 
01504 /* method: setEuler of class  fawkes::tf::Quaternion */
01505 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setEuler00
01506 static int tolua_fawkestf_fawkes_tf_Quaternion_setEuler00(lua_State* tolua_S)
01507 {
01508 #ifndef TOLUA_RELEASE
01509  tolua_Error tolua_err;
01510  if (
01511      !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
01512      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01513      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01514      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01515      !tolua_isnoobj(tolua_S,5,&tolua_err)
01516  )
01517   goto tolua_lerror;
01518  else
01519 #endif
01520  {
01521   fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
01522   const double yaw = ((const double)  tolua_tonumber(tolua_S,2,0));
01523   const double pitch = ((const double)  tolua_tonumber(tolua_S,3,0));
01524   const double roll = ((const double)  tolua_tonumber(tolua_S,4,0));
01525 #ifndef TOLUA_RELEASE
01526   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setEuler'", NULL);
01527 #endif
01528   {
01529    self->setEuler(yaw,pitch,roll);
01530   }
01531  }
01532  return 0;
01533 #ifndef TOLUA_RELEASE
01534  tolua_lerror:
01535  tolua_error(tolua_S,"#ferror in function 'setEuler'.",&tolua_err);
01536  return 0;
01537 #endif
01538 }
01539 #endif //#ifndef TOLUA_DISABLE
01540 
01541 /* method: operator== of class  fawkes::tf::Quaternion */
01542 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion__eq00
01543 static int tolua_fawkestf_fawkes_tf_Quaternion__eq00(lua_State* tolua_S)
01544 {
01545 #ifndef TOLUA_RELEASE
01546  tolua_Error tolua_err;
01547  if (
01548      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
01549      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
01550      !tolua_isnoobj(tolua_S,3,&tolua_err)
01551  )
01552   goto tolua_lerror;
01553  else
01554 #endif
01555  {
01556   const fawkes::tf::Quaternion* self = (const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
01557   const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,2,0));
01558 #ifndef TOLUA_RELEASE
01559   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
01560 #endif
01561   {
01562    bool tolua_ret = (bool)  self->operator==(*q);
01563    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01564   }
01565  }
01566  return 1;
01567 #ifndef TOLUA_RELEASE
01568  tolua_lerror:
01569  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
01570  return 0;
01571 #endif
01572 }
01573 #endif //#ifndef TOLUA_DISABLE
01574 
01575 /* method: dot of class  fawkes::tf::Quaternion */
01576 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_dot00
01577 static int tolua_fawkestf_fawkes_tf_Quaternion_dot00(lua_State* tolua_S)
01578 {
01579 #ifndef TOLUA_RELEASE
01580  tolua_Error tolua_err;
01581  if (
01582      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
01583      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
01584      !tolua_isnoobj(tolua_S,3,&tolua_err)
01585  )
01586   goto tolua_lerror;
01587  else
01588 #endif
01589  {
01590   const fawkes::tf::Quaternion* self = (const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
01591   const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,2,0));
01592 #ifndef TOLUA_RELEASE
01593   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'dot'", NULL);
01594 #endif
01595   {
01596    double tolua_ret = (double)  self->dot(*q);
01597    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01598   }
01599  }
01600  return 1;
01601 #ifndef TOLUA_RELEASE
01602  tolua_lerror:
01603  tolua_error(tolua_S,"#ferror in function 'dot'.",&tolua_err);
01604  return 0;
01605 #endif
01606 }
01607 #endif //#ifndef TOLUA_DISABLE
01608 
01609 /* method: length2 of class  fawkes::tf::Quaternion */
01610 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_length200
01611 static int tolua_fawkestf_fawkes_tf_Quaternion_length200(lua_State* tolua_S)
01612 {
01613 #ifndef TOLUA_RELEASE
01614  tolua_Error tolua_err;
01615  if (
01616      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
01617      !tolua_isnoobj(tolua_S,2,&tolua_err)
01618  )
01619   goto tolua_lerror;
01620  else
01621 #endif
01622  {
01623   const fawkes::tf::Quaternion* self = (const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
01624 #ifndef TOLUA_RELEASE
01625   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'length2'", NULL);
01626 #endif
01627   {
01628    double tolua_ret = (double)  self->length2();
01629    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01630   }
01631  }
01632  return 1;
01633 #ifndef TOLUA_RELEASE
01634  tolua_lerror:
01635  tolua_error(tolua_S,"#ferror in function 'length2'.",&tolua_err);
01636  return 0;
01637 #endif
01638 }
01639 #endif //#ifndef TOLUA_DISABLE
01640 
01641 /* method: length of class  fawkes::tf::Quaternion */
01642 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_length00
01643 static int tolua_fawkestf_fawkes_tf_Quaternion_length00(lua_State* tolua_S)
01644 {
01645 #ifndef TOLUA_RELEASE
01646  tolua_Error tolua_err;
01647  if (
01648      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
01649      !tolua_isnoobj(tolua_S,2,&tolua_err)
01650  )
01651   goto tolua_lerror;
01652  else
01653 #endif
01654  {
01655   const fawkes::tf::Quaternion* self = (const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
01656 #ifndef TOLUA_RELEASE
01657   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'length'", NULL);
01658 #endif
01659   {
01660    double tolua_ret = (double)  self->length();
01661    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01662   }
01663  }
01664  return 1;
01665 #ifndef TOLUA_RELEASE
01666  tolua_lerror:
01667  tolua_error(tolua_S,"#ferror in function 'length'.",&tolua_err);
01668  return 0;
01669 #endif
01670 }
01671 #endif //#ifndef TOLUA_DISABLE
01672 
01673 /* method: normalize of class  fawkes::tf::Quaternion */
01674 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_normalize00
01675 static int tolua_fawkestf_fawkes_tf_Quaternion_normalize00(lua_State* tolua_S)
01676 {
01677 #ifndef TOLUA_RELEASE
01678  tolua_Error tolua_err;
01679  if (
01680      !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
01681      !tolua_isnoobj(tolua_S,2,&tolua_err)
01682  )
01683   goto tolua_lerror;
01684  else
01685 #endif
01686  {
01687   fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
01688 #ifndef TOLUA_RELEASE
01689   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'normalize'", NULL);
01690 #endif
01691   {
01692    fawkes::tf::Quaternion& tolua_ret = (fawkes::tf::Quaternion&)  self->normalize();
01693     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::tf::Quaternion");
01694   }
01695  }
01696  return 1;
01697 #ifndef TOLUA_RELEASE
01698  tolua_lerror:
01699  tolua_error(tolua_S,"#ferror in function 'normalize'.",&tolua_err);
01700  return 0;
01701 #endif
01702 }
01703 #endif //#ifndef TOLUA_DISABLE
01704 
01705 /* method: normalized of class  fawkes::tf::Quaternion */
01706 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_normalized00
01707 static int tolua_fawkestf_fawkes_tf_Quaternion_normalized00(lua_State* tolua_S)
01708 {
01709 #ifndef TOLUA_RELEASE
01710  tolua_Error tolua_err;
01711  if (
01712      !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
01713      !tolua_isnoobj(tolua_S,2,&tolua_err)
01714  )
01715   goto tolua_lerror;
01716  else
01717 #endif
01718  {
01719   fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
01720 #ifndef TOLUA_RELEASE
01721   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'normalized'", NULL);
01722 #endif
01723   {
01724    fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion)  self->normalized();
01725    {
01726 #ifdef __cplusplus
01727     void* tolua_obj = Mtolua_new((fawkes::tf::Quaternion)(tolua_ret));
01728      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
01729     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01730 #else
01731     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Quaternion));
01732      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
01733     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01734 #endif
01735    }
01736   }
01737  }
01738  return 1;
01739 #ifndef TOLUA_RELEASE
01740  tolua_lerror:
01741  tolua_error(tolua_S,"#ferror in function 'normalized'.",&tolua_err);
01742  return 0;
01743 #endif
01744 }
01745 #endif //#ifndef TOLUA_DISABLE
01746 
01747 /* method: angle of class  fawkes::tf::Quaternion */
01748 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_angle00
01749 static int tolua_fawkestf_fawkes_tf_Quaternion_angle00(lua_State* tolua_S)
01750 {
01751 #ifndef TOLUA_RELEASE
01752  tolua_Error tolua_err;
01753  if (
01754      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
01755      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
01756      !tolua_isnoobj(tolua_S,3,&tolua_err)
01757  )
01758   goto tolua_lerror;
01759  else
01760 #endif
01761  {
01762   const fawkes::tf::Quaternion* self = (const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
01763   const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,2,0));
01764 #ifndef TOLUA_RELEASE
01765   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'angle'", NULL);
01766 #endif
01767   {
01768    double tolua_ret = (double)  self->angle(*q);
01769    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01770   }
01771  }
01772  return 1;
01773 #ifndef TOLUA_RELEASE
01774  tolua_lerror:
01775  tolua_error(tolua_S,"#ferror in function 'angle'.",&tolua_err);
01776  return 0;
01777 #endif
01778 }
01779 #endif //#ifndef TOLUA_DISABLE
01780 
01781 /* method: getAngle of class  fawkes::tf::Quaternion */
01782 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_getAngle00
01783 static int tolua_fawkestf_fawkes_tf_Quaternion_getAngle00(lua_State* tolua_S)
01784 {
01785 #ifndef TOLUA_RELEASE
01786  tolua_Error tolua_err;
01787  if (
01788      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
01789      !tolua_isnoobj(tolua_S,2,&tolua_err)
01790  )
01791   goto tolua_lerror;
01792  else
01793 #endif
01794  {
01795   const fawkes::tf::Quaternion* self = (const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
01796 #ifndef TOLUA_RELEASE
01797   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAngle'", NULL);
01798 #endif
01799   {
01800    double tolua_ret = (double)  self->getAngle();
01801    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01802   }
01803  }
01804  return 1;
01805 #ifndef TOLUA_RELEASE
01806  tolua_lerror:
01807  tolua_error(tolua_S,"#ferror in function 'getAngle'.",&tolua_err);
01808  return 0;
01809 #endif
01810 }
01811 #endif //#ifndef TOLUA_DISABLE
01812 
01813 /* method: getAxis of class  fawkes::tf::Quaternion */
01814 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_getAxis00
01815 static int tolua_fawkestf_fawkes_tf_Quaternion_getAxis00(lua_State* tolua_S)
01816 {
01817 #ifndef TOLUA_RELEASE
01818  tolua_Error tolua_err;
01819  if (
01820      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
01821      !tolua_isnoobj(tolua_S,2,&tolua_err)
01822  )
01823   goto tolua_lerror;
01824  else
01825 #endif
01826  {
01827   const fawkes::tf::Quaternion* self = (const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
01828 #ifndef TOLUA_RELEASE
01829   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAxis'", NULL);
01830 #endif
01831   {
01832    fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3)  self->getAxis();
01833    {
01834 #ifdef __cplusplus
01835     void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
01836      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
01837     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01838 #else
01839     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Vector3));
01840      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
01841     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01842 #endif
01843    }
01844   }
01845  }
01846  return 1;
01847 #ifndef TOLUA_RELEASE
01848  tolua_lerror:
01849  tolua_error(tolua_S,"#ferror in function 'getAxis'.",&tolua_err);
01850  return 0;
01851 #endif
01852 }
01853 #endif //#ifndef TOLUA_DISABLE
01854 
01855 /* method: inverse of class  fawkes::tf::Quaternion */
01856 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_inverse00
01857 static int tolua_fawkestf_fawkes_tf_Quaternion_inverse00(lua_State* tolua_S)
01858 {
01859 #ifndef TOLUA_RELEASE
01860  tolua_Error tolua_err;
01861  if (
01862      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
01863      !tolua_isnoobj(tolua_S,2,&tolua_err)
01864  )
01865   goto tolua_lerror;
01866  else
01867 #endif
01868  {
01869   const fawkes::tf::Quaternion* self = (const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
01870 #ifndef TOLUA_RELEASE
01871   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'inverse'", NULL);
01872 #endif
01873   {
01874    fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion)  self->inverse();
01875    {
01876 #ifdef __cplusplus
01877     void* tolua_obj = Mtolua_new((fawkes::tf::Quaternion)(tolua_ret));
01878      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
01879     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01880 #else
01881     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Quaternion));
01882      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
01883     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01884 #endif
01885    }
01886   }
01887  }
01888  return 1;
01889 #ifndef TOLUA_RELEASE
01890  tolua_lerror:
01891  tolua_error(tolua_S,"#ferror in function 'inverse'.",&tolua_err);
01892  return 0;
01893 #endif
01894 }
01895 #endif //#ifndef TOLUA_DISABLE
01896 
01897 /* method: slerp of class  fawkes::tf::Quaternion */
01898 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_slerp00
01899 static int tolua_fawkestf_fawkes_tf_Quaternion_slerp00(lua_State* tolua_S)
01900 {
01901 #ifndef TOLUA_RELEASE
01902  tolua_Error tolua_err;
01903  if (
01904      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
01905      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
01906      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01907      !tolua_isnoobj(tolua_S,4,&tolua_err)
01908  )
01909   goto tolua_lerror;
01910  else
01911 #endif
01912  {
01913   const fawkes::tf::Quaternion* self = (const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
01914   const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,2,0));
01915   const double t = ((const double)  tolua_tonumber(tolua_S,3,0));
01916 #ifndef TOLUA_RELEASE
01917   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'slerp'", NULL);
01918 #endif
01919   {
01920    fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion)  self->slerp(*q,t);
01921    {
01922 #ifdef __cplusplus
01923     void* tolua_obj = Mtolua_new((fawkes::tf::Quaternion)(tolua_ret));
01924      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
01925     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01926 #else
01927     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Quaternion));
01928      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
01929     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01930 #endif
01931    }
01932   }
01933  }
01934  return 1;
01935 #ifndef TOLUA_RELEASE
01936  tolua_lerror:
01937  tolua_error(tolua_S,"#ferror in function 'slerp'.",&tolua_err);
01938  return 0;
01939 #endif
01940 }
01941 #endif //#ifndef TOLUA_DISABLE
01942 
01943 /* method: x of class  fawkes::tf::Quaternion */
01944 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_x00
01945 static int tolua_fawkestf_fawkes_tf_Quaternion_x00(lua_State* tolua_S)
01946 {
01947 #ifndef TOLUA_RELEASE
01948  tolua_Error tolua_err;
01949  if (
01950      !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
01951      !tolua_isnoobj(tolua_S,2,&tolua_err)
01952  )
01953   goto tolua_lerror;
01954  else
01955 #endif
01956  {
01957   fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
01958 #ifndef TOLUA_RELEASE
01959   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
01960 #endif
01961   {
01962    const double tolua_ret = (const double)  self->x();
01963    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01964   }
01965  }
01966  return 1;
01967 #ifndef TOLUA_RELEASE
01968  tolua_lerror:
01969  tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
01970  return 0;
01971 #endif
01972 }
01973 #endif //#ifndef TOLUA_DISABLE
01974 
01975 /* method: y of class  fawkes::tf::Quaternion */
01976 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_y00
01977 static int tolua_fawkestf_fawkes_tf_Quaternion_y00(lua_State* tolua_S)
01978 {
01979 #ifndef TOLUA_RELEASE
01980  tolua_Error tolua_err;
01981  if (
01982      !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
01983      !tolua_isnoobj(tolua_S,2,&tolua_err)
01984  )
01985   goto tolua_lerror;
01986  else
01987 #endif
01988  {
01989   fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
01990 #ifndef TOLUA_RELEASE
01991   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
01992 #endif
01993   {
01994    const double tolua_ret = (const double)  self->y();
01995    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01996   }
01997  }
01998  return 1;
01999 #ifndef TOLUA_RELEASE
02000  tolua_lerror:
02001  tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
02002  return 0;
02003 #endif
02004 }
02005 #endif //#ifndef TOLUA_DISABLE
02006 
02007 /* method: z of class  fawkes::tf::Quaternion */
02008 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_z00
02009 static int tolua_fawkestf_fawkes_tf_Quaternion_z00(lua_State* tolua_S)
02010 {
02011 #ifndef TOLUA_RELEASE
02012  tolua_Error tolua_err;
02013  if (
02014      !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
02015      !tolua_isnoobj(tolua_S,2,&tolua_err)
02016  )
02017   goto tolua_lerror;
02018  else
02019 #endif
02020  {
02021   fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
02022 #ifndef TOLUA_RELEASE
02023   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'z'", NULL);
02024 #endif
02025   {
02026    const double tolua_ret = (const double)  self->z();
02027    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02028   }
02029  }
02030  return 1;
02031 #ifndef TOLUA_RELEASE
02032  tolua_lerror:
02033  tolua_error(tolua_S,"#ferror in function 'z'.",&tolua_err);
02034  return 0;
02035 #endif
02036 }
02037 #endif //#ifndef TOLUA_DISABLE
02038 
02039 /* method: w of class  fawkes::tf::Quaternion */
02040 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_w00
02041 static int tolua_fawkestf_fawkes_tf_Quaternion_w00(lua_State* tolua_S)
02042 {
02043 #ifndef TOLUA_RELEASE
02044  tolua_Error tolua_err;
02045  if (
02046      !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
02047      !tolua_isnoobj(tolua_S,2,&tolua_err)
02048  )
02049   goto tolua_lerror;
02050  else
02051 #endif
02052  {
02053   fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
02054 #ifndef TOLUA_RELEASE
02055   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'w'", NULL);
02056 #endif
02057   {
02058    const double tolua_ret = (const double)  self->w();
02059    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02060   }
02061  }
02062  return 1;
02063 #ifndef TOLUA_RELEASE
02064  tolua_lerror:
02065  tolua_error(tolua_S,"#ferror in function 'w'.",&tolua_err);
02066  return 0;
02067 #endif
02068 }
02069 #endif //#ifndef TOLUA_DISABLE
02070 
02071 /* method: setX of class  fawkes::tf::Quaternion */
02072 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setX00
02073 static int tolua_fawkestf_fawkes_tf_Quaternion_setX00(lua_State* tolua_S)
02074 {
02075 #ifndef TOLUA_RELEASE
02076  tolua_Error tolua_err;
02077  if (
02078      !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
02079      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02080      !tolua_isnoobj(tolua_S,3,&tolua_err)
02081  )
02082   goto tolua_lerror;
02083  else
02084 #endif
02085  {
02086   fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
02087   double x = ((double)  tolua_tonumber(tolua_S,2,0));
02088 #ifndef TOLUA_RELEASE
02089   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setX'", NULL);
02090 #endif
02091   {
02092    self->setX(x);
02093   }
02094  }
02095  return 0;
02096 #ifndef TOLUA_RELEASE
02097  tolua_lerror:
02098  tolua_error(tolua_S,"#ferror in function 'setX'.",&tolua_err);
02099  return 0;
02100 #endif
02101 }
02102 #endif //#ifndef TOLUA_DISABLE
02103 
02104 /* method: setY of class  fawkes::tf::Quaternion */
02105 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setY00
02106 static int tolua_fawkestf_fawkes_tf_Quaternion_setY00(lua_State* tolua_S)
02107 {
02108 #ifndef TOLUA_RELEASE
02109  tolua_Error tolua_err;
02110  if (
02111      !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
02112      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02113      !tolua_isnoobj(tolua_S,3,&tolua_err)
02114  )
02115   goto tolua_lerror;
02116  else
02117 #endif
02118  {
02119   fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
02120   double x = ((double)  tolua_tonumber(tolua_S,2,0));
02121 #ifndef TOLUA_RELEASE
02122   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setY'", NULL);
02123 #endif
02124   {
02125    self->setY(x);
02126   }
02127  }
02128  return 0;
02129 #ifndef TOLUA_RELEASE
02130  tolua_lerror:
02131  tolua_error(tolua_S,"#ferror in function 'setY'.",&tolua_err);
02132  return 0;
02133 #endif
02134 }
02135 #endif //#ifndef TOLUA_DISABLE
02136 
02137 /* method: setZ of class  fawkes::tf::Quaternion */
02138 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setZ00
02139 static int tolua_fawkestf_fawkes_tf_Quaternion_setZ00(lua_State* tolua_S)
02140 {
02141 #ifndef TOLUA_RELEASE
02142  tolua_Error tolua_err;
02143  if (
02144      !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
02145      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02146      !tolua_isnoobj(tolua_S,3,&tolua_err)
02147  )
02148   goto tolua_lerror;
02149  else
02150 #endif
02151  {
02152   fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
02153   double x = ((double)  tolua_tonumber(tolua_S,2,0));
02154 #ifndef TOLUA_RELEASE
02155   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setZ'", NULL);
02156 #endif
02157   {
02158    self->setZ(x);
02159   }
02160  }
02161  return 0;
02162 #ifndef TOLUA_RELEASE
02163  tolua_lerror:
02164  tolua_error(tolua_S,"#ferror in function 'setZ'.",&tolua_err);
02165  return 0;
02166 #endif
02167 }
02168 #endif //#ifndef TOLUA_DISABLE
02169 
02170 /* method: setW of class  fawkes::tf::Quaternion */
02171 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setW00
02172 static int tolua_fawkestf_fawkes_tf_Quaternion_setW00(lua_State* tolua_S)
02173 {
02174 #ifndef TOLUA_RELEASE
02175  tolua_Error tolua_err;
02176  if (
02177      !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
02178      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02179      !tolua_isnoobj(tolua_S,3,&tolua_err)
02180  )
02181   goto tolua_lerror;
02182  else
02183 #endif
02184  {
02185   fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
02186   double x = ((double)  tolua_tonumber(tolua_S,2,0));
02187 #ifndef TOLUA_RELEASE
02188   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setW'", NULL);
02189 #endif
02190   {
02191    self->setW(x);
02192   }
02193  }
02194  return 0;
02195 #ifndef TOLUA_RELEASE
02196  tolua_lerror:
02197  tolua_error(tolua_S,"#ferror in function 'setW'.",&tolua_err);
02198  return 0;
02199 #endif
02200 }
02201 #endif //#ifndef TOLUA_DISABLE
02202 
02203 /* method: setValue of class  fawkes::tf::Quaternion */
02204 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setValue00
02205 static int tolua_fawkestf_fawkes_tf_Quaternion_setValue00(lua_State* tolua_S)
02206 {
02207 #ifndef TOLUA_RELEASE
02208  tolua_Error tolua_err;
02209  if (
02210      !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
02211      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02212      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02213      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
02214      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
02215      !tolua_isnoobj(tolua_S,6,&tolua_err)
02216  )
02217   goto tolua_lerror;
02218  else
02219 #endif
02220  {
02221   fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,1,0);
02222   double x = ((double)  tolua_tonumber(tolua_S,2,0));
02223   double y = ((double)  tolua_tonumber(tolua_S,3,0));
02224   double z = ((double)  tolua_tonumber(tolua_S,4,0));
02225   double w = ((double)  tolua_tonumber(tolua_S,5,0));
02226 #ifndef TOLUA_RELEASE
02227   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setValue'", NULL);
02228 #endif
02229   {
02230    self->setValue(x,y,z,w);
02231   }
02232  }
02233  return 0;
02234 #ifndef TOLUA_RELEASE
02235  tolua_lerror:
02236  tolua_error(tolua_S,"#ferror in function 'setValue'.",&tolua_err);
02237  return 0;
02238 #endif
02239 }
02240 #endif //#ifndef TOLUA_DISABLE
02241 
02242 /* method: new of class  fawkes::tf::Transform */
02243 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new00
02244 static int tolua_fawkestf_fawkes_tf_Transform_new00(lua_State* tolua_S)
02245 {
02246 #ifndef TOLUA_RELEASE
02247  tolua_Error tolua_err;
02248  if (
02249      !tolua_isusertable(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
02250      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
02251      !tolua_isnoobj(tolua_S,3,&tolua_err)
02252  )
02253   goto tolua_lerror;
02254  else
02255 #endif
02256  {
02257   const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,2,0));
02258   {
02259    fawkes::tf::Transform* tolua_ret = (fawkes::tf::Transform*)  Mtolua_new((fawkes::tf::Transform)(*q));
02260     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Transform");
02261   }
02262  }
02263  return 1;
02264 #ifndef TOLUA_RELEASE
02265  tolua_lerror:
02266  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02267  return 0;
02268 #endif
02269 }
02270 #endif //#ifndef TOLUA_DISABLE
02271 
02272 /* method: new_local of class  fawkes::tf::Transform */
02273 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new00_local
02274 static int tolua_fawkestf_fawkes_tf_Transform_new00_local(lua_State* tolua_S)
02275 {
02276 #ifndef TOLUA_RELEASE
02277  tolua_Error tolua_err;
02278  if (
02279      !tolua_isusertable(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
02280      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
02281      !tolua_isnoobj(tolua_S,3,&tolua_err)
02282  )
02283   goto tolua_lerror;
02284  else
02285 #endif
02286  {
02287   const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,2,0));
02288   {
02289    fawkes::tf::Transform* tolua_ret = (fawkes::tf::Transform*)  Mtolua_new((fawkes::tf::Transform)(*q));
02290     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Transform");
02291     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02292   }
02293  }
02294  return 1;
02295 #ifndef TOLUA_RELEASE
02296  tolua_lerror:
02297  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02298  return 0;
02299 #endif
02300 }
02301 #endif //#ifndef TOLUA_DISABLE
02302 
02303 /* method: new of class  fawkes::tf::Transform */
02304 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new01
02305 static int tolua_fawkestf_fawkes_tf_Transform_new01(lua_State* tolua_S)
02306 {
02307  tolua_Error tolua_err;
02308  if (
02309      !tolua_isusertable(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
02310      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
02311      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::Vector3",0,&tolua_err)) ||
02312      !tolua_isnoobj(tolua_S,4,&tolua_err)
02313  )
02314   goto tolua_lerror;
02315  else
02316  {
02317   const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,2,0));
02318   const fawkes::tf::Vector3* c = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,3,0));
02319   {
02320    fawkes::tf::Transform* tolua_ret = (fawkes::tf::Transform*)  Mtolua_new((fawkes::tf::Transform)(*q,*c));
02321     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Transform");
02322   }
02323  }
02324  return 1;
02325 tolua_lerror:
02326  return tolua_fawkestf_fawkes_tf_Transform_new00(tolua_S);
02327 }
02328 #endif //#ifndef TOLUA_DISABLE
02329 
02330 /* method: new_local of class  fawkes::tf::Transform */
02331 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new01_local
02332 static int tolua_fawkestf_fawkes_tf_Transform_new01_local(lua_State* tolua_S)
02333 {
02334  tolua_Error tolua_err;
02335  if (
02336      !tolua_isusertable(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
02337      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
02338      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::Vector3",0,&tolua_err)) ||
02339      !tolua_isnoobj(tolua_S,4,&tolua_err)
02340  )
02341   goto tolua_lerror;
02342  else
02343  {
02344   const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,2,0));
02345   const fawkes::tf::Vector3* c = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,3,0));
02346   {
02347    fawkes::tf::Transform* tolua_ret = (fawkes::tf::Transform*)  Mtolua_new((fawkes::tf::Transform)(*q,*c));
02348     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Transform");
02349     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02350   }
02351  }
02352  return 1;
02353 tolua_lerror:
02354  return tolua_fawkestf_fawkes_tf_Transform_new00_local(tolua_S);
02355 }
02356 #endif //#ifndef TOLUA_DISABLE
02357 
02358 /* method: new of class  fawkes::tf::Transform */
02359 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new02
02360 static int tolua_fawkestf_fawkes_tf_Transform_new02(lua_State* tolua_S)
02361 {
02362  tolua_Error tolua_err;
02363  if (
02364      !tolua_isusertable(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
02365      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Transform",0,&tolua_err)) ||
02366      !tolua_isnoobj(tolua_S,3,&tolua_err)
02367  )
02368   goto tolua_lerror;
02369  else
02370  {
02371   const fawkes::tf::Transform* other = ((const fawkes::tf::Transform*)  tolua_tousertype(tolua_S,2,0));
02372   {
02373    fawkes::tf::Transform* tolua_ret = (fawkes::tf::Transform*)  Mtolua_new((fawkes::tf::Transform)(*other));
02374     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Transform");
02375   }
02376  }
02377  return 1;
02378 tolua_lerror:
02379  return tolua_fawkestf_fawkes_tf_Transform_new01(tolua_S);
02380 }
02381 #endif //#ifndef TOLUA_DISABLE
02382 
02383 /* method: new_local of class  fawkes::tf::Transform */
02384 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new02_local
02385 static int tolua_fawkestf_fawkes_tf_Transform_new02_local(lua_State* tolua_S)
02386 {
02387  tolua_Error tolua_err;
02388  if (
02389      !tolua_isusertable(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
02390      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Transform",0,&tolua_err)) ||
02391      !tolua_isnoobj(tolua_S,3,&tolua_err)
02392  )
02393   goto tolua_lerror;
02394  else
02395  {
02396   const fawkes::tf::Transform* other = ((const fawkes::tf::Transform*)  tolua_tousertype(tolua_S,2,0));
02397   {
02398    fawkes::tf::Transform* tolua_ret = (fawkes::tf::Transform*)  Mtolua_new((fawkes::tf::Transform)(*other));
02399     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Transform");
02400     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02401   }
02402  }
02403  return 1;
02404 tolua_lerror:
02405  return tolua_fawkestf_fawkes_tf_Transform_new01_local(tolua_S);
02406 }
02407 #endif //#ifndef TOLUA_DISABLE
02408 
02409 /* method: getIdentity of class  fawkes::tf::Transform */
02410 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_getIdentity00
02411 static int tolua_fawkestf_fawkes_tf_Transform_getIdentity00(lua_State* tolua_S)
02412 {
02413 #ifndef TOLUA_RELEASE
02414  tolua_Error tolua_err;
02415  if (
02416      !tolua_isusertable(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
02417      !tolua_isnoobj(tolua_S,2,&tolua_err)
02418  )
02419   goto tolua_lerror;
02420  else
02421 #endif
02422  {
02423   {
02424    const fawkes::tf::Transform& tolua_ret = (const fawkes::tf::Transform&)  fawkes::tf::Transform::getIdentity();
02425     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const fawkes::tf::Transform");
02426   }
02427  }
02428  return 1;
02429 #ifndef TOLUA_RELEASE
02430  tolua_lerror:
02431  tolua_error(tolua_S,"#ferror in function 'getIdentity'.",&tolua_err);
02432  return 0;
02433 #endif
02434 }
02435 #endif //#ifndef TOLUA_DISABLE
02436 
02437 /* method: mult of class  fawkes::tf::Transform */
02438 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_mult00
02439 static int tolua_fawkestf_fawkes_tf_Transform_mult00(lua_State* tolua_S)
02440 {
02441 #ifndef TOLUA_RELEASE
02442  tolua_Error tolua_err;
02443  if (
02444      !tolua_isusertype(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
02445      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Transform",0,&tolua_err)) ||
02446      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::Transform",0,&tolua_err)) ||
02447      !tolua_isnoobj(tolua_S,4,&tolua_err)
02448  )
02449   goto tolua_lerror;
02450  else
02451 #endif
02452  {
02453   fawkes::tf::Transform* self = (fawkes::tf::Transform*)  tolua_tousertype(tolua_S,1,0);
02454   const fawkes::tf::Transform* t1 = ((const fawkes::tf::Transform*)  tolua_tousertype(tolua_S,2,0));
02455   const fawkes::tf::Transform* t2 = ((const fawkes::tf::Transform*)  tolua_tousertype(tolua_S,3,0));
02456 #ifndef TOLUA_RELEASE
02457   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mult'", NULL);
02458 #endif
02459   {
02460    self->mult(*t1,*t2);
02461   }
02462  }
02463  return 0;
02464 #ifndef TOLUA_RELEASE
02465  tolua_lerror:
02466  tolua_error(tolua_S,"#ferror in function 'mult'.",&tolua_err);
02467  return 0;
02468 #endif
02469 }
02470 #endif //#ifndef TOLUA_DISABLE
02471 
02472 /* method: operator* of class  fawkes::tf::Transform */
02473 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform__mul00
02474 static int tolua_fawkestf_fawkes_tf_Transform__mul00(lua_State* tolua_S)
02475 {
02476 #ifndef TOLUA_RELEASE
02477  tolua_Error tolua_err;
02478  if (
02479      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transform",0,&tolua_err) ||
02480      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
02481      !tolua_isnoobj(tolua_S,3,&tolua_err)
02482  )
02483   goto tolua_lerror;
02484  else
02485 #endif
02486  {
02487   const fawkes::tf::Transform* self = (const fawkes::tf::Transform*)  tolua_tousertype(tolua_S,1,0);
02488   const fawkes::tf::Vector3* x = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,2,0));
02489 #ifndef TOLUA_RELEASE
02490   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", NULL);
02491 #endif
02492   {
02493    fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3)  self->operator*(*x);
02494    {
02495 #ifdef __cplusplus
02496     void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
02497      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
02498     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02499 #else
02500     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Vector3));
02501      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Vector3");
02502     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02503 #endif
02504    }
02505   }
02506  }
02507  return 1;
02508 #ifndef TOLUA_RELEASE
02509  tolua_lerror:
02510  tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err);
02511  return 0;
02512 #endif
02513 }
02514 #endif //#ifndef TOLUA_DISABLE
02515 
02516 /* method: operator* of class  fawkes::tf::Transform */
02517 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform__mul01
02518 static int tolua_fawkestf_fawkes_tf_Transform__mul01(lua_State* tolua_S)
02519 {
02520  tolua_Error tolua_err;
02521  if (
02522      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transform",0,&tolua_err) ||
02523      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
02524      !tolua_isnoobj(tolua_S,3,&tolua_err)
02525  )
02526   goto tolua_lerror;
02527  else
02528  {
02529   const fawkes::tf::Transform* self = (const fawkes::tf::Transform*)  tolua_tousertype(tolua_S,1,0);
02530   const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,2,0));
02531 #ifndef TOLUA_RELEASE
02532   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", NULL);
02533 #endif
02534   {
02535    fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion)  self->operator*(*q);
02536    {
02537 #ifdef __cplusplus
02538     void* tolua_obj = Mtolua_new((fawkes::tf::Quaternion)(tolua_ret));
02539      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
02540     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02541 #else
02542     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Quaternion));
02543      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
02544     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02545 #endif
02546    }
02547   }
02548  }
02549  return 1;
02550 tolua_lerror:
02551  return tolua_fawkestf_fawkes_tf_Transform__mul00(tolua_S);
02552 }
02553 #endif //#ifndef TOLUA_DISABLE
02554 
02555 /* method: getOrigin of class  fawkes::tf::Transform */
02556 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_getOrigin00
02557 static int tolua_fawkestf_fawkes_tf_Transform_getOrigin00(lua_State* tolua_S)
02558 {
02559 #ifndef TOLUA_RELEASE
02560  tolua_Error tolua_err;
02561  if (
02562      !tolua_isusertype(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
02563      !tolua_isnoobj(tolua_S,2,&tolua_err)
02564  )
02565   goto tolua_lerror;
02566  else
02567 #endif
02568  {
02569   fawkes::tf::Transform* self = (fawkes::tf::Transform*)  tolua_tousertype(tolua_S,1,0);
02570 #ifndef TOLUA_RELEASE
02571   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOrigin'", NULL);
02572 #endif
02573   {
02574    fawkes::tf::Vector3& tolua_ret = (fawkes::tf::Vector3&)  self->getOrigin();
02575     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::tf::Vector3");
02576   }
02577  }
02578  return 1;
02579 #ifndef TOLUA_RELEASE
02580  tolua_lerror:
02581  tolua_error(tolua_S,"#ferror in function 'getOrigin'.",&tolua_err);
02582  return 0;
02583 #endif
02584 }
02585 #endif //#ifndef TOLUA_DISABLE
02586 
02587 /* method: getRotation of class  fawkes::tf::Transform */
02588 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_getRotation00
02589 static int tolua_fawkestf_fawkes_tf_Transform_getRotation00(lua_State* tolua_S)
02590 {
02591 #ifndef TOLUA_RELEASE
02592  tolua_Error tolua_err;
02593  if (
02594      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transform",0,&tolua_err) ||
02595      !tolua_isnoobj(tolua_S,2,&tolua_err)
02596  )
02597   goto tolua_lerror;
02598  else
02599 #endif
02600  {
02601   const fawkes::tf::Transform* self = (const fawkes::tf::Transform*)  tolua_tousertype(tolua_S,1,0);
02602 #ifndef TOLUA_RELEASE
02603   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRotation'", NULL);
02604 #endif
02605   {
02606    fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion)  self->getRotation();
02607    {
02608 #ifdef __cplusplus
02609     void* tolua_obj = Mtolua_new((fawkes::tf::Quaternion)(tolua_ret));
02610      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
02611     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02612 #else
02613     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Quaternion));
02614      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Quaternion");
02615     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02616 #endif
02617    }
02618   }
02619  }
02620  return 1;
02621 #ifndef TOLUA_RELEASE
02622  tolua_lerror:
02623  tolua_error(tolua_S,"#ferror in function 'getRotation'.",&tolua_err);
02624  return 0;
02625 #endif
02626 }
02627 #endif //#ifndef TOLUA_DISABLE
02628 
02629 /* method: setOrigin of class  fawkes::tf::Transform */
02630 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_setOrigin00
02631 static int tolua_fawkestf_fawkes_tf_Transform_setOrigin00(lua_State* tolua_S)
02632 {
02633 #ifndef TOLUA_RELEASE
02634  tolua_Error tolua_err;
02635  if (
02636      !tolua_isusertype(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
02637      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
02638      !tolua_isnoobj(tolua_S,3,&tolua_err)
02639  )
02640   goto tolua_lerror;
02641  else
02642 #endif
02643  {
02644   fawkes::tf::Transform* self = (fawkes::tf::Transform*)  tolua_tousertype(tolua_S,1,0);
02645   const fawkes::tf::Vector3* origin = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,2,0));
02646 #ifndef TOLUA_RELEASE
02647   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setOrigin'", NULL);
02648 #endif
02649   {
02650    self->setOrigin(*origin);
02651   }
02652  }
02653  return 0;
02654 #ifndef TOLUA_RELEASE
02655  tolua_lerror:
02656  tolua_error(tolua_S,"#ferror in function 'setOrigin'.",&tolua_err);
02657  return 0;
02658 #endif
02659 }
02660 #endif //#ifndef TOLUA_DISABLE
02661 
02662 /* method: setRotation of class  fawkes::tf::Transform */
02663 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_setRotation00
02664 static int tolua_fawkestf_fawkes_tf_Transform_setRotation00(lua_State* tolua_S)
02665 {
02666 #ifndef TOLUA_RELEASE
02667  tolua_Error tolua_err;
02668  if (
02669      !tolua_isusertype(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
02670      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
02671      !tolua_isnoobj(tolua_S,3,&tolua_err)
02672  )
02673   goto tolua_lerror;
02674  else
02675 #endif
02676  {
02677   fawkes::tf::Transform* self = (fawkes::tf::Transform*)  tolua_tousertype(tolua_S,1,0);
02678   const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,2,0));
02679 #ifndef TOLUA_RELEASE
02680   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRotation'", NULL);
02681 #endif
02682   {
02683    self->setRotation(*q);
02684   }
02685  }
02686  return 0;
02687 #ifndef TOLUA_RELEASE
02688  tolua_lerror:
02689  tolua_error(tolua_S,"#ferror in function 'setRotation'.",&tolua_err);
02690  return 0;
02691 #endif
02692 }
02693 #endif //#ifndef TOLUA_DISABLE
02694 
02695 /* method: setIdentity of class  fawkes::tf::Transform */
02696 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_setIdentity00
02697 static int tolua_fawkestf_fawkes_tf_Transform_setIdentity00(lua_State* tolua_S)
02698 {
02699 #ifndef TOLUA_RELEASE
02700  tolua_Error tolua_err;
02701  if (
02702      !tolua_isusertype(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
02703      !tolua_isnoobj(tolua_S,2,&tolua_err)
02704  )
02705   goto tolua_lerror;
02706  else
02707 #endif
02708  {
02709   fawkes::tf::Transform* self = (fawkes::tf::Transform*)  tolua_tousertype(tolua_S,1,0);
02710 #ifndef TOLUA_RELEASE
02711   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setIdentity'", NULL);
02712 #endif
02713   {
02714    self->setIdentity();
02715   }
02716  }
02717  return 0;
02718 #ifndef TOLUA_RELEASE
02719  tolua_lerror:
02720  tolua_error(tolua_S,"#ferror in function 'setIdentity'.",&tolua_err);
02721  return 0;
02722 #endif
02723 }
02724 #endif //#ifndef TOLUA_DISABLE
02725 
02726 /* method: inverse of class  fawkes::tf::Transform */
02727 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_inverse00
02728 static int tolua_fawkestf_fawkes_tf_Transform_inverse00(lua_State* tolua_S)
02729 {
02730 #ifndef TOLUA_RELEASE
02731  tolua_Error tolua_err;
02732  if (
02733      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transform",0,&tolua_err) ||
02734      !tolua_isnoobj(tolua_S,2,&tolua_err)
02735  )
02736   goto tolua_lerror;
02737  else
02738 #endif
02739  {
02740   const fawkes::tf::Transform* self = (const fawkes::tf::Transform*)  tolua_tousertype(tolua_S,1,0);
02741 #ifndef TOLUA_RELEASE
02742   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'inverse'", NULL);
02743 #endif
02744   {
02745    fawkes::tf::Transform tolua_ret = (fawkes::tf::Transform)  self->inverse();
02746    {
02747 #ifdef __cplusplus
02748     void* tolua_obj = Mtolua_new((fawkes::tf::Transform)(tolua_ret));
02749      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Transform");
02750     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02751 #else
02752     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Transform));
02753      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Transform");
02754     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02755 #endif
02756    }
02757   }
02758  }
02759  return 1;
02760 #ifndef TOLUA_RELEASE
02761  tolua_lerror:
02762  tolua_error(tolua_S,"#ferror in function 'inverse'.",&tolua_err);
02763  return 0;
02764 #endif
02765 }
02766 #endif //#ifndef TOLUA_DISABLE
02767 
02768 /* method: inverseTimes of class  fawkes::tf::Transform */
02769 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_inverseTimes00
02770 static int tolua_fawkestf_fawkes_tf_Transform_inverseTimes00(lua_State* tolua_S)
02771 {
02772 #ifndef TOLUA_RELEASE
02773  tolua_Error tolua_err;
02774  if (
02775      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transform",0,&tolua_err) ||
02776      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Transform",0,&tolua_err)) ||
02777      !tolua_isnoobj(tolua_S,3,&tolua_err)
02778  )
02779   goto tolua_lerror;
02780  else
02781 #endif
02782  {
02783   const fawkes::tf::Transform* self = (const fawkes::tf::Transform*)  tolua_tousertype(tolua_S,1,0);
02784   const fawkes::tf::Transform* t = ((const fawkes::tf::Transform*)  tolua_tousertype(tolua_S,2,0));
02785 #ifndef TOLUA_RELEASE
02786   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'inverseTimes'", NULL);
02787 #endif
02788   {
02789    fawkes::tf::Transform tolua_ret = (fawkes::tf::Transform)  self->inverseTimes(*t);
02790    {
02791 #ifdef __cplusplus
02792     void* tolua_obj = Mtolua_new((fawkes::tf::Transform)(tolua_ret));
02793      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Transform");
02794     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02795 #else
02796     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::tf::Transform));
02797      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::tf::Transform");
02798     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02799 #endif
02800    }
02801   }
02802  }
02803  return 1;
02804 #ifndef TOLUA_RELEASE
02805  tolua_lerror:
02806  tolua_error(tolua_S,"#ferror in function 'inverseTimes'.",&tolua_err);
02807  return 0;
02808 #endif
02809 }
02810 #endif //#ifndef TOLUA_DISABLE
02811 
02812 /* method: new of class  fawkes::tf::Point */
02813 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Point_new00
02814 static int tolua_fawkestf_fawkes_tf_Point_new00(lua_State* tolua_S)
02815 {
02816 #ifndef TOLUA_RELEASE
02817  tolua_Error tolua_err;
02818  if (
02819      !tolua_isusertable(tolua_S,1,"fawkes::tf::Point",0,&tolua_err) ||
02820      !tolua_isnoobj(tolua_S,2,&tolua_err)
02821  )
02822   goto tolua_lerror;
02823  else
02824 #endif
02825  {
02826   {
02827    fawkes::tf::Point* tolua_ret = (fawkes::tf::Point*)  Mtolua_new((fawkes::tf::Point)());
02828     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Point");
02829   }
02830  }
02831  return 1;
02832 #ifndef TOLUA_RELEASE
02833  tolua_lerror:
02834  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02835  return 0;
02836 #endif
02837 }
02838 #endif //#ifndef TOLUA_DISABLE
02839 
02840 /* method: new_local of class  fawkes::tf::Point */
02841 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Point_new00_local
02842 static int tolua_fawkestf_fawkes_tf_Point_new00_local(lua_State* tolua_S)
02843 {
02844 #ifndef TOLUA_RELEASE
02845  tolua_Error tolua_err;
02846  if (
02847      !tolua_isusertable(tolua_S,1,"fawkes::tf::Point",0,&tolua_err) ||
02848      !tolua_isnoobj(tolua_S,2,&tolua_err)
02849  )
02850   goto tolua_lerror;
02851  else
02852 #endif
02853  {
02854   {
02855    fawkes::tf::Point* tolua_ret = (fawkes::tf::Point*)  Mtolua_new((fawkes::tf::Point)());
02856     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Point");
02857     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02858   }
02859  }
02860  return 1;
02861 #ifndef TOLUA_RELEASE
02862  tolua_lerror:
02863  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02864  return 0;
02865 #endif
02866 }
02867 #endif //#ifndef TOLUA_DISABLE
02868 
02869 /* method: new of class  fawkes::tf::Point */
02870 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Point_new01
02871 static int tolua_fawkestf_fawkes_tf_Point_new01(lua_State* tolua_S)
02872 {
02873  tolua_Error tolua_err;
02874  if (
02875      !tolua_isusertable(tolua_S,1,"fawkes::tf::Point",0,&tolua_err) ||
02876      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02877      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02878      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
02879      !tolua_isnoobj(tolua_S,5,&tolua_err)
02880  )
02881   goto tolua_lerror;
02882  else
02883  {
02884   double x = ((double)  tolua_tonumber(tolua_S,2,0));
02885   double y = ((double)  tolua_tonumber(tolua_S,3,0));
02886   double z = ((double)  tolua_tonumber(tolua_S,4,0));
02887   {
02888    fawkes::tf::Point* tolua_ret = (fawkes::tf::Point*)  Mtolua_new((fawkes::tf::Point)(x,y,z));
02889     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Point");
02890   }
02891  }
02892  return 1;
02893 tolua_lerror:
02894  return tolua_fawkestf_fawkes_tf_Point_new00(tolua_S);
02895 }
02896 #endif //#ifndef TOLUA_DISABLE
02897 
02898 /* method: new_local of class  fawkes::tf::Point */
02899 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Point_new01_local
02900 static int tolua_fawkestf_fawkes_tf_Point_new01_local(lua_State* tolua_S)
02901 {
02902  tolua_Error tolua_err;
02903  if (
02904      !tolua_isusertable(tolua_S,1,"fawkes::tf::Point",0,&tolua_err) ||
02905      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02906      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02907      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
02908      !tolua_isnoobj(tolua_S,5,&tolua_err)
02909  )
02910   goto tolua_lerror;
02911  else
02912  {
02913   double x = ((double)  tolua_tonumber(tolua_S,2,0));
02914   double y = ((double)  tolua_tonumber(tolua_S,3,0));
02915   double z = ((double)  tolua_tonumber(tolua_S,4,0));
02916   {
02917    fawkes::tf::Point* tolua_ret = (fawkes::tf::Point*)  Mtolua_new((fawkes::tf::Point)(x,y,z));
02918     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Point");
02919     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02920   }
02921  }
02922  return 1;
02923 tolua_lerror:
02924  return tolua_fawkestf_fawkes_tf_Point_new00_local(tolua_S);
02925 }
02926 #endif //#ifndef TOLUA_DISABLE
02927 
02928 /* method: new of class  fawkes::tf::Pose */
02929 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new00
02930 static int tolua_fawkestf_fawkes_tf_Pose_new00(lua_State* tolua_S)
02931 {
02932 #ifndef TOLUA_RELEASE
02933  tolua_Error tolua_err;
02934  if (
02935      !tolua_isusertable(tolua_S,1,"fawkes::tf::Pose",0,&tolua_err) ||
02936      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
02937      !tolua_isnoobj(tolua_S,3,&tolua_err)
02938  )
02939   goto tolua_lerror;
02940  else
02941 #endif
02942  {
02943   const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,2,0));
02944   {
02945    fawkes::tf::Pose* tolua_ret = (fawkes::tf::Pose*)  Mtolua_new((fawkes::tf::Pose)(*q));
02946     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Pose");
02947   }
02948  }
02949  return 1;
02950 #ifndef TOLUA_RELEASE
02951  tolua_lerror:
02952  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02953  return 0;
02954 #endif
02955 }
02956 #endif //#ifndef TOLUA_DISABLE
02957 
02958 /* method: new_local of class  fawkes::tf::Pose */
02959 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new00_local
02960 static int tolua_fawkestf_fawkes_tf_Pose_new00_local(lua_State* tolua_S)
02961 {
02962 #ifndef TOLUA_RELEASE
02963  tolua_Error tolua_err;
02964  if (
02965      !tolua_isusertable(tolua_S,1,"fawkes::tf::Pose",0,&tolua_err) ||
02966      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
02967      !tolua_isnoobj(tolua_S,3,&tolua_err)
02968  )
02969   goto tolua_lerror;
02970  else
02971 #endif
02972  {
02973   const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,2,0));
02974   {
02975    fawkes::tf::Pose* tolua_ret = (fawkes::tf::Pose*)  Mtolua_new((fawkes::tf::Pose)(*q));
02976     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Pose");
02977     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02978   }
02979  }
02980  return 1;
02981 #ifndef TOLUA_RELEASE
02982  tolua_lerror:
02983  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02984  return 0;
02985 #endif
02986 }
02987 #endif //#ifndef TOLUA_DISABLE
02988 
02989 /* method: new of class  fawkes::tf::Pose */
02990 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new01
02991 static int tolua_fawkestf_fawkes_tf_Pose_new01(lua_State* tolua_S)
02992 {
02993  tolua_Error tolua_err;
02994  if (
02995      !tolua_isusertable(tolua_S,1,"fawkes::tf::Pose",0,&tolua_err) ||
02996      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
02997      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::Vector3",0,&tolua_err)) ||
02998      !tolua_isnoobj(tolua_S,4,&tolua_err)
02999  )
03000   goto tolua_lerror;
03001  else
03002  {
03003   const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,2,0));
03004   const fawkes::tf::Vector3* c = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,3,0));
03005   {
03006    fawkes::tf::Pose* tolua_ret = (fawkes::tf::Pose*)  Mtolua_new((fawkes::tf::Pose)(*q,*c));
03007     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Pose");
03008   }
03009  }
03010  return 1;
03011 tolua_lerror:
03012  return tolua_fawkestf_fawkes_tf_Pose_new00(tolua_S);
03013 }
03014 #endif //#ifndef TOLUA_DISABLE
03015 
03016 /* method: new_local of class  fawkes::tf::Pose */
03017 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new01_local
03018 static int tolua_fawkestf_fawkes_tf_Pose_new01_local(lua_State* tolua_S)
03019 {
03020  tolua_Error tolua_err;
03021  if (
03022      !tolua_isusertable(tolua_S,1,"fawkes::tf::Pose",0,&tolua_err) ||
03023      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
03024      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::Vector3",0,&tolua_err)) ||
03025      !tolua_isnoobj(tolua_S,4,&tolua_err)
03026  )
03027   goto tolua_lerror;
03028  else
03029  {
03030   const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,2,0));
03031   const fawkes::tf::Vector3* c = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,3,0));
03032   {
03033    fawkes::tf::Pose* tolua_ret = (fawkes::tf::Pose*)  Mtolua_new((fawkes::tf::Pose)(*q,*c));
03034     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Pose");
03035     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03036   }
03037  }
03038  return 1;
03039 tolua_lerror:
03040  return tolua_fawkestf_fawkes_tf_Pose_new00_local(tolua_S);
03041 }
03042 #endif //#ifndef TOLUA_DISABLE
03043 
03044 /* method: new of class  fawkes::tf::Pose */
03045 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new02
03046 static int tolua_fawkestf_fawkes_tf_Pose_new02(lua_State* tolua_S)
03047 {
03048  tolua_Error tolua_err;
03049  if (
03050      !tolua_isusertable(tolua_S,1,"fawkes::tf::Pose",0,&tolua_err) ||
03051      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Pose",0,&tolua_err)) ||
03052      !tolua_isnoobj(tolua_S,3,&tolua_err)
03053  )
03054   goto tolua_lerror;
03055  else
03056  {
03057   const fawkes::tf::Pose* other = ((const fawkes::tf::Pose*)  tolua_tousertype(tolua_S,2,0));
03058   {
03059    fawkes::tf::Pose* tolua_ret = (fawkes::tf::Pose*)  Mtolua_new((fawkes::tf::Pose)(*other));
03060     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Pose");
03061   }
03062  }
03063  return 1;
03064 tolua_lerror:
03065  return tolua_fawkestf_fawkes_tf_Pose_new01(tolua_S);
03066 }
03067 #endif //#ifndef TOLUA_DISABLE
03068 
03069 /* method: new_local of class  fawkes::tf::Pose */
03070 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new02_local
03071 static int tolua_fawkestf_fawkes_tf_Pose_new02_local(lua_State* tolua_S)
03072 {
03073  tolua_Error tolua_err;
03074  if (
03075      !tolua_isusertable(tolua_S,1,"fawkes::tf::Pose",0,&tolua_err) ||
03076      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Pose",0,&tolua_err)) ||
03077      !tolua_isnoobj(tolua_S,3,&tolua_err)
03078  )
03079   goto tolua_lerror;
03080  else
03081  {
03082   const fawkes::tf::Pose* other = ((const fawkes::tf::Pose*)  tolua_tousertype(tolua_S,2,0));
03083   {
03084    fawkes::tf::Pose* tolua_ret = (fawkes::tf::Pose*)  Mtolua_new((fawkes::tf::Pose)(*other));
03085     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Pose");
03086     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03087   }
03088  }
03089  return 1;
03090 tolua_lerror:
03091  return tolua_fawkestf_fawkes_tf_Pose_new01_local(tolua_S);
03092 }
03093 #endif //#ifndef TOLUA_DISABLE
03094 
03095 /* method: getIdentity of class  fawkes::tf::Pose */
03096 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_getIdentity00
03097 static int tolua_fawkestf_fawkes_tf_Pose_getIdentity00(lua_State* tolua_S)
03098 {
03099 #ifndef TOLUA_RELEASE
03100  tolua_Error tolua_err;
03101  if (
03102      !tolua_isusertable(tolua_S,1,"fawkes::tf::Pose",0,&tolua_err) ||
03103      !tolua_isnoobj(tolua_S,2,&tolua_err)
03104  )
03105   goto tolua_lerror;
03106  else
03107 #endif
03108  {
03109   {
03110    const fawkes::tf::Pose& tolua_ret = (const fawkes::tf::Pose&)  fawkes::tf::Pose::getIdentity();
03111     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const fawkes::tf::Pose");
03112   }
03113  }
03114  return 1;
03115 #ifndef TOLUA_RELEASE
03116  tolua_lerror:
03117  tolua_error(tolua_S,"#ferror in function 'getIdentity'.",&tolua_err);
03118  return 0;
03119 #endif
03120 }
03121 #endif //#ifndef TOLUA_DISABLE
03122 
03123 /* get function: stamp of class  fawkes::tf::StampedTransform */
03124 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__StampedTransform_stamp
03125 static int tolua_get_fawkes__tf__StampedTransform_stamp(lua_State* tolua_S)
03126 {
03127   fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*)  tolua_tousertype(tolua_S,1,0);
03128 #ifndef TOLUA_RELEASE
03129   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
03130 #endif
03131    tolua_pushusertype(tolua_S,(void*)&self->stamp,"fawkes::Time");
03132  return 1;
03133 }
03134 #endif //#ifndef TOLUA_DISABLE
03135 
03136 /* set function: stamp of class  fawkes::tf::StampedTransform */
03137 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__StampedTransform_stamp
03138 static int tolua_set_fawkes__tf__StampedTransform_stamp(lua_State* tolua_S)
03139 {
03140   fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*)  tolua_tousertype(tolua_S,1,0);
03141 #ifndef TOLUA_RELEASE
03142   tolua_Error tolua_err;
03143   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
03144   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)))
03145    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
03146 #endif
03147   self->stamp = *((fawkes::Time*)  tolua_tousertype(tolua_S,2,0))
03148 ;
03149  return 0;
03150 }
03151 #endif //#ifndef TOLUA_DISABLE
03152 
03153 /* get function: frame_id of class  fawkes::tf::StampedTransform */
03154 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__StampedTransform_frame_id
03155 static int tolua_get_fawkes__tf__StampedTransform_frame_id(lua_State* tolua_S)
03156 {
03157   fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*)  tolua_tousertype(tolua_S,1,0);
03158 #ifndef TOLUA_RELEASE
03159   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
03160 #endif
03161   tolua_pushcppstring(tolua_S,(const char*)self->frame_id);
03162  return 1;
03163 }
03164 #endif //#ifndef TOLUA_DISABLE
03165 
03166 /* set function: frame_id of class  fawkes::tf::StampedTransform */
03167 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__StampedTransform_frame_id
03168 static int tolua_set_fawkes__tf__StampedTransform_frame_id(lua_State* tolua_S)
03169 {
03170   fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*)  tolua_tousertype(tolua_S,1,0);
03171 #ifndef TOLUA_RELEASE
03172   tolua_Error tolua_err;
03173   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
03174   if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
03175    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
03176 #endif
03177   self->frame_id = ((std::string)  tolua_tocppstring(tolua_S,2,0))
03178 ;
03179  return 0;
03180 }
03181 #endif //#ifndef TOLUA_DISABLE
03182 
03183 /* get function: child_frame_id of class  fawkes::tf::StampedTransform */
03184 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__StampedTransform_child_frame_id
03185 static int tolua_get_fawkes__tf__StampedTransform_child_frame_id(lua_State* tolua_S)
03186 {
03187   fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*)  tolua_tousertype(tolua_S,1,0);
03188 #ifndef TOLUA_RELEASE
03189   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'child_frame_id'",NULL);
03190 #endif
03191   tolua_pushcppstring(tolua_S,(const char*)self->child_frame_id);
03192  return 1;
03193 }
03194 #endif //#ifndef TOLUA_DISABLE
03195 
03196 /* set function: child_frame_id of class  fawkes::tf::StampedTransform */
03197 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__StampedTransform_child_frame_id
03198 static int tolua_set_fawkes__tf__StampedTransform_child_frame_id(lua_State* tolua_S)
03199 {
03200   fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*)  tolua_tousertype(tolua_S,1,0);
03201 #ifndef TOLUA_RELEASE
03202   tolua_Error tolua_err;
03203   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'child_frame_id'",NULL);
03204   if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
03205    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
03206 #endif
03207   self->child_frame_id = ((std::string)  tolua_tocppstring(tolua_S,2,0))
03208 ;
03209  return 0;
03210 }
03211 #endif //#ifndef TOLUA_DISABLE
03212 
03213 /* method: new of class  fawkes::tf::StampedTransform */
03214 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_new00
03215 static int tolua_fawkestf_fawkes_tf_StampedTransform_new00(lua_State* tolua_S)
03216 {
03217 #ifndef TOLUA_RELEASE
03218  tolua_Error tolua_err;
03219  if (
03220      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedTransform",0,&tolua_err) ||
03221      !tolua_isnoobj(tolua_S,2,&tolua_err)
03222  )
03223   goto tolua_lerror;
03224  else
03225 #endif
03226  {
03227   {
03228    fawkes::tf::StampedTransform* tolua_ret = (fawkes::tf::StampedTransform*)  Mtolua_new((fawkes::tf::StampedTransform)());
03229     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedTransform");
03230   }
03231  }
03232  return 1;
03233 #ifndef TOLUA_RELEASE
03234  tolua_lerror:
03235  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
03236  return 0;
03237 #endif
03238 }
03239 #endif //#ifndef TOLUA_DISABLE
03240 
03241 /* method: new_local of class  fawkes::tf::StampedTransform */
03242 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_new00_local
03243 static int tolua_fawkestf_fawkes_tf_StampedTransform_new00_local(lua_State* tolua_S)
03244 {
03245 #ifndef TOLUA_RELEASE
03246  tolua_Error tolua_err;
03247  if (
03248      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedTransform",0,&tolua_err) ||
03249      !tolua_isnoobj(tolua_S,2,&tolua_err)
03250  )
03251   goto tolua_lerror;
03252  else
03253 #endif
03254  {
03255   {
03256    fawkes::tf::StampedTransform* tolua_ret = (fawkes::tf::StampedTransform*)  Mtolua_new((fawkes::tf::StampedTransform)());
03257     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedTransform");
03258     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03259   }
03260  }
03261  return 1;
03262 #ifndef TOLUA_RELEASE
03263  tolua_lerror:
03264  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
03265  return 0;
03266 #endif
03267 }
03268 #endif //#ifndef TOLUA_DISABLE
03269 
03270 /* method: new of class  fawkes::tf::StampedTransform */
03271 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_new01
03272 static int tolua_fawkestf_fawkes_tf_StampedTransform_new01(lua_State* tolua_S)
03273 {
03274  tolua_Error tolua_err;
03275  if (
03276      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedTransform",0,&tolua_err) ||
03277      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Transform",0,&tolua_err)) ||
03278      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
03279      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
03280      !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
03281      !tolua_isnoobj(tolua_S,6,&tolua_err)
03282  )
03283   goto tolua_lerror;
03284  else
03285  {
03286   const fawkes::tf::Transform* input = ((const fawkes::tf::Transform*)  tolua_tousertype(tolua_S,2,0));
03287   const fawkes::Time* timestamp = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
03288   const std::string frame_id = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
03289   const std::string child_frame_id = ((const std::string)  tolua_tocppstring(tolua_S,5,0));
03290   {
03291    fawkes::tf::StampedTransform* tolua_ret = (fawkes::tf::StampedTransform*)  Mtolua_new((fawkes::tf::StampedTransform)(*input,*timestamp,frame_id,child_frame_id));
03292     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedTransform");
03293    tolua_pushcppstring(tolua_S,(const char*)frame_id);
03294    tolua_pushcppstring(tolua_S,(const char*)child_frame_id);
03295   }
03296  }
03297  return 3;
03298 tolua_lerror:
03299  return tolua_fawkestf_fawkes_tf_StampedTransform_new00(tolua_S);
03300 }
03301 #endif //#ifndef TOLUA_DISABLE
03302 
03303 /* method: new_local of class  fawkes::tf::StampedTransform */
03304 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_new01_local
03305 static int tolua_fawkestf_fawkes_tf_StampedTransform_new01_local(lua_State* tolua_S)
03306 {
03307  tolua_Error tolua_err;
03308  if (
03309      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedTransform",0,&tolua_err) ||
03310      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Transform",0,&tolua_err)) ||
03311      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
03312      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
03313      !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
03314      !tolua_isnoobj(tolua_S,6,&tolua_err)
03315  )
03316   goto tolua_lerror;
03317  else
03318  {
03319   const fawkes::tf::Transform* input = ((const fawkes::tf::Transform*)  tolua_tousertype(tolua_S,2,0));
03320   const fawkes::Time* timestamp = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
03321   const std::string frame_id = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
03322   const std::string child_frame_id = ((const std::string)  tolua_tocppstring(tolua_S,5,0));
03323   {
03324    fawkes::tf::StampedTransform* tolua_ret = (fawkes::tf::StampedTransform*)  Mtolua_new((fawkes::tf::StampedTransform)(*input,*timestamp,frame_id,child_frame_id));
03325     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedTransform");
03326     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03327    tolua_pushcppstring(tolua_S,(const char*)frame_id);
03328    tolua_pushcppstring(tolua_S,(const char*)child_frame_id);
03329   }
03330  }
03331  return 3;
03332 tolua_lerror:
03333  return tolua_fawkestf_fawkes_tf_StampedTransform_new00_local(tolua_S);
03334 }
03335 #endif //#ifndef TOLUA_DISABLE
03336 
03337 /* method: set_data of class  fawkes::tf::StampedTransform */
03338 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_set_data00
03339 static int tolua_fawkestf_fawkes_tf_StampedTransform_set_data00(lua_State* tolua_S)
03340 {
03341 #ifndef TOLUA_RELEASE
03342  tolua_Error tolua_err;
03343  if (
03344      !tolua_isusertype(tolua_S,1,"fawkes::tf::StampedTransform",0,&tolua_err) ||
03345      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Transform",0,&tolua_err)) ||
03346      !tolua_isnoobj(tolua_S,3,&tolua_err)
03347  )
03348   goto tolua_lerror;
03349  else
03350 #endif
03351  {
03352   fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*)  tolua_tousertype(tolua_S,1,0);
03353   const fawkes::tf::Transform* input = ((const fawkes::tf::Transform*)  tolua_tousertype(tolua_S,2,0));
03354 #ifndef TOLUA_RELEASE
03355   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_data'", NULL);
03356 #endif
03357   {
03358    self->set_data(*input);
03359   }
03360  }
03361  return 0;
03362 #ifndef TOLUA_RELEASE
03363  tolua_lerror:
03364  tolua_error(tolua_S,"#ferror in function 'set_data'.",&tolua_err);
03365  return 0;
03366 #endif
03367 }
03368 #endif //#ifndef TOLUA_DISABLE
03369 
03370 /* get function: stamp of class  fawkes::tf::Stamped<fawkes::tf::Quaternion> */
03371 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp
03372 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp(lua_State* tolua_S)
03373 {
03374   fawkes::tf::Stamped<fawkes::tf::Quaternion>* self = (fawkes::tf::Stamped<fawkes::tf::Quaternion>*)  tolua_tousertype(tolua_S,1,0);
03375 #ifndef TOLUA_RELEASE
03376   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
03377 #endif
03378    tolua_pushusertype(tolua_S,(void*)&self->stamp,"fawkes::Time");
03379  return 1;
03380 }
03381 #endif //#ifndef TOLUA_DISABLE
03382 
03383 /* set function: stamp of class  fawkes::tf::Stamped<fawkes::tf::Quaternion> */
03384 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp
03385 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp(lua_State* tolua_S)
03386 {
03387   fawkes::tf::Stamped<fawkes::tf::Quaternion>* self = (fawkes::tf::Stamped<fawkes::tf::Quaternion>*)  tolua_tousertype(tolua_S,1,0);
03388 #ifndef TOLUA_RELEASE
03389   tolua_Error tolua_err;
03390   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
03391   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)))
03392    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
03393 #endif
03394   self->stamp = *((fawkes::Time*)  tolua_tousertype(tolua_S,2,0))
03395 ;
03396  return 0;
03397 }
03398 #endif //#ifndef TOLUA_DISABLE
03399 
03400 /* get function: frame_id of class  fawkes::tf::Stamped<fawkes::tf::Quaternion> */
03401 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id
03402 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id(lua_State* tolua_S)
03403 {
03404   fawkes::tf::Stamped<fawkes::tf::Quaternion>* self = (fawkes::tf::Stamped<fawkes::tf::Quaternion>*)  tolua_tousertype(tolua_S,1,0);
03405 #ifndef TOLUA_RELEASE
03406   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
03407 #endif
03408   tolua_pushcppstring(tolua_S,(const char*)self->frame_id);
03409  return 1;
03410 }
03411 #endif //#ifndef TOLUA_DISABLE
03412 
03413 /* set function: frame_id of class  fawkes::tf::Stamped<fawkes::tf::Quaternion> */
03414 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id
03415 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id(lua_State* tolua_S)
03416 {
03417   fawkes::tf::Stamped<fawkes::tf::Quaternion>* self = (fawkes::tf::Stamped<fawkes::tf::Quaternion>*)  tolua_tousertype(tolua_S,1,0);
03418 #ifndef TOLUA_RELEASE
03419   tolua_Error tolua_err;
03420   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
03421   if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
03422    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
03423 #endif
03424   self->frame_id = ((std::string)  tolua_tocppstring(tolua_S,2,0))
03425 ;
03426  return 0;
03427 }
03428 #endif //#ifndef TOLUA_DISABLE
03429 
03430 /* method: new of class  fawkes::tf::Stamped<fawkes::tf::Quaternion> */
03431 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00
03432 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00(lua_State* tolua_S)
03433 {
03434 #ifndef TOLUA_RELEASE
03435  tolua_Error tolua_err;
03436  if (
03437      !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Quaternion>",0,&tolua_err) ||
03438      !tolua_isnoobj(tolua_S,2,&tolua_err)
03439  )
03440   goto tolua_lerror;
03441  else
03442 #endif
03443  {
03444   {
03445    fawkes::tf::Stamped<fawkes::tf::Quaternion>* tolua_ret = (fawkes::tf::Stamped<fawkes::tf::Quaternion>*)  Mtolua_new((fawkes::tf::Stamped<fawkes::tf::Quaternion>)());
03446     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Quaternion>");
03447   }
03448  }
03449  return 1;
03450 #ifndef TOLUA_RELEASE
03451  tolua_lerror:
03452  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
03453  return 0;
03454 #endif
03455 }
03456 #endif //#ifndef TOLUA_DISABLE
03457 
03458 /* method: new_local of class  fawkes::tf::Stamped<fawkes::tf::Quaternion> */
03459 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00_local
03460 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00_local(lua_State* tolua_S)
03461 {
03462 #ifndef TOLUA_RELEASE
03463  tolua_Error tolua_err;
03464  if (
03465      !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Quaternion>",0,&tolua_err) ||
03466      !tolua_isnoobj(tolua_S,2,&tolua_err)
03467  )
03468   goto tolua_lerror;
03469  else
03470 #endif
03471  {
03472   {
03473    fawkes::tf::Stamped<fawkes::tf::Quaternion>* tolua_ret = (fawkes::tf::Stamped<fawkes::tf::Quaternion>*)  Mtolua_new((fawkes::tf::Stamped<fawkes::tf::Quaternion>)());
03474     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Quaternion>");
03475     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03476   }
03477  }
03478  return 1;
03479 #ifndef TOLUA_RELEASE
03480  tolua_lerror:
03481  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
03482  return 0;
03483 #endif
03484 }
03485 #endif //#ifndef TOLUA_DISABLE
03486 
03487 /* method: new of class  fawkes::tf::Stamped<fawkes::tf::Quaternion> */
03488 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01
03489 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01(lua_State* tolua_S)
03490 {
03491  tolua_Error tolua_err;
03492  if (
03493      !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Quaternion>",0,&tolua_err) ||
03494      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
03495      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
03496      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
03497      !tolua_isnoobj(tolua_S,5,&tolua_err)
03498  )
03499   goto tolua_lerror;
03500  else
03501  {
03502   const fawkes::tf::Quaternion* input = ((const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,2,0));
03503   const fawkes::Time* timestamp = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
03504   const std::string frame_id = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
03505   {
03506    fawkes::tf::Stamped<fawkes::tf::Quaternion>* tolua_ret = (fawkes::tf::Stamped<fawkes::tf::Quaternion>*)  Mtolua_new((fawkes::tf::Stamped<fawkes::tf::Quaternion>)(*input,*timestamp,frame_id));
03507     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Quaternion>");
03508    tolua_pushcppstring(tolua_S,(const char*)frame_id);
03509   }
03510  }
03511  return 2;
03512 tolua_lerror:
03513  return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00(tolua_S);
03514 }
03515 #endif //#ifndef TOLUA_DISABLE
03516 
03517 /* method: new_local of class  fawkes::tf::Stamped<fawkes::tf::Quaternion> */
03518 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01_local
03519 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01_local(lua_State* tolua_S)
03520 {
03521  tolua_Error tolua_err;
03522  if (
03523      !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Quaternion>",0,&tolua_err) ||
03524      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
03525      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
03526      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
03527      !tolua_isnoobj(tolua_S,5,&tolua_err)
03528  )
03529   goto tolua_lerror;
03530  else
03531  {
03532   const fawkes::tf::Quaternion* input = ((const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,2,0));
03533   const fawkes::Time* timestamp = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
03534   const std::string frame_id = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
03535   {
03536    fawkes::tf::Stamped<fawkes::tf::Quaternion>* tolua_ret = (fawkes::tf::Stamped<fawkes::tf::Quaternion>*)  Mtolua_new((fawkes::tf::Stamped<fawkes::tf::Quaternion>)(*input,*timestamp,frame_id));
03537     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Quaternion>");
03538     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03539    tolua_pushcppstring(tolua_S,(const char*)frame_id);
03540   }
03541  }
03542  return 2;
03543 tolua_lerror:
03544  return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00_local(tolua_S);
03545 }
03546 #endif //#ifndef TOLUA_DISABLE
03547 
03548 /* method: set_data of class  fawkes::tf::Stamped<fawkes::tf::Quaternion> */
03549 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__set_data00
03550 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__set_data00(lua_State* tolua_S)
03551 {
03552 #ifndef TOLUA_RELEASE
03553  tolua_Error tolua_err;
03554  if (
03555      !tolua_isusertype(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Quaternion>",0,&tolua_err) ||
03556      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
03557      !tolua_isnoobj(tolua_S,3,&tolua_err)
03558  )
03559   goto tolua_lerror;
03560  else
03561 #endif
03562  {
03563   fawkes::tf::Stamped<fawkes::tf::Quaternion>* self = (fawkes::tf::Stamped<fawkes::tf::Quaternion>*)  tolua_tousertype(tolua_S,1,0);
03564   const fawkes::tf::Quaternion* input = ((const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,2,0));
03565 #ifndef TOLUA_RELEASE
03566   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_data'", NULL);
03567 #endif
03568   {
03569    self->set_data(*input);
03570   }
03571  }
03572  return 0;
03573 #ifndef TOLUA_RELEASE
03574  tolua_lerror:
03575  tolua_error(tolua_S,"#ferror in function 'set_data'.",&tolua_err);
03576  return 0;
03577 #endif
03578 }
03579 #endif //#ifndef TOLUA_DISABLE
03580 
03581 /* get function: stamp of class  fawkes::tf::Stamped<fawkes::tf::Vector3> */
03582 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp
03583 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp(lua_State* tolua_S)
03584 {
03585   fawkes::tf::Stamped<fawkes::tf::Vector3>* self = (fawkes::tf::Stamped<fawkes::tf::Vector3>*)  tolua_tousertype(tolua_S,1,0);
03586 #ifndef TOLUA_RELEASE
03587   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
03588 #endif
03589    tolua_pushusertype(tolua_S,(void*)&self->stamp,"fawkes::Time");
03590  return 1;
03591 }
03592 #endif //#ifndef TOLUA_DISABLE
03593 
03594 /* set function: stamp of class  fawkes::tf::Stamped<fawkes::tf::Vector3> */
03595 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp
03596 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp(lua_State* tolua_S)
03597 {
03598   fawkes::tf::Stamped<fawkes::tf::Vector3>* self = (fawkes::tf::Stamped<fawkes::tf::Vector3>*)  tolua_tousertype(tolua_S,1,0);
03599 #ifndef TOLUA_RELEASE
03600   tolua_Error tolua_err;
03601   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
03602   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)))
03603    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
03604 #endif
03605   self->stamp = *((fawkes::Time*)  tolua_tousertype(tolua_S,2,0))
03606 ;
03607  return 0;
03608 }
03609 #endif //#ifndef TOLUA_DISABLE
03610 
03611 /* get function: frame_id of class  fawkes::tf::Stamped<fawkes::tf::Vector3> */
03612 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id
03613 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id(lua_State* tolua_S)
03614 {
03615   fawkes::tf::Stamped<fawkes::tf::Vector3>* self = (fawkes::tf::Stamped<fawkes::tf::Vector3>*)  tolua_tousertype(tolua_S,1,0);
03616 #ifndef TOLUA_RELEASE
03617   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
03618 #endif
03619   tolua_pushcppstring(tolua_S,(const char*)self->frame_id);
03620  return 1;
03621 }
03622 #endif //#ifndef TOLUA_DISABLE
03623 
03624 /* set function: frame_id of class  fawkes::tf::Stamped<fawkes::tf::Vector3> */
03625 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id
03626 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id(lua_State* tolua_S)
03627 {
03628   fawkes::tf::Stamped<fawkes::tf::Vector3>* self = (fawkes::tf::Stamped<fawkes::tf::Vector3>*)  tolua_tousertype(tolua_S,1,0);
03629 #ifndef TOLUA_RELEASE
03630   tolua_Error tolua_err;
03631   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
03632   if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
03633    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
03634 #endif
03635   self->frame_id = ((std::string)  tolua_tocppstring(tolua_S,2,0))
03636 ;
03637  return 0;
03638 }
03639 #endif //#ifndef TOLUA_DISABLE
03640 
03641 /* method: new of class  fawkes::tf::Stamped<fawkes::tf::Vector3> */
03642 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00
03643 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00(lua_State* tolua_S)
03644 {
03645 #ifndef TOLUA_RELEASE
03646  tolua_Error tolua_err;
03647  if (
03648      !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Vector3>",0,&tolua_err) ||
03649      !tolua_isnoobj(tolua_S,2,&tolua_err)
03650  )
03651   goto tolua_lerror;
03652  else
03653 #endif
03654  {
03655   {
03656    fawkes::tf::Stamped<fawkes::tf::Vector3>* tolua_ret = (fawkes::tf::Stamped<fawkes::tf::Vector3>*)  Mtolua_new((fawkes::tf::Stamped<fawkes::tf::Vector3>)());
03657     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Vector3>");
03658   }
03659  }
03660  return 1;
03661 #ifndef TOLUA_RELEASE
03662  tolua_lerror:
03663  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
03664  return 0;
03665 #endif
03666 }
03667 #endif //#ifndef TOLUA_DISABLE
03668 
03669 /* method: new_local of class  fawkes::tf::Stamped<fawkes::tf::Vector3> */
03670 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00_local
03671 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00_local(lua_State* tolua_S)
03672 {
03673 #ifndef TOLUA_RELEASE
03674  tolua_Error tolua_err;
03675  if (
03676      !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Vector3>",0,&tolua_err) ||
03677      !tolua_isnoobj(tolua_S,2,&tolua_err)
03678  )
03679   goto tolua_lerror;
03680  else
03681 #endif
03682  {
03683   {
03684    fawkes::tf::Stamped<fawkes::tf::Vector3>* tolua_ret = (fawkes::tf::Stamped<fawkes::tf::Vector3>*)  Mtolua_new((fawkes::tf::Stamped<fawkes::tf::Vector3>)());
03685     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Vector3>");
03686     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03687   }
03688  }
03689  return 1;
03690 #ifndef TOLUA_RELEASE
03691  tolua_lerror:
03692  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
03693  return 0;
03694 #endif
03695 }
03696 #endif //#ifndef TOLUA_DISABLE
03697 
03698 /* method: new of class  fawkes::tf::Stamped<fawkes::tf::Vector3> */
03699 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01
03700 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01(lua_State* tolua_S)
03701 {
03702  tolua_Error tolua_err;
03703  if (
03704      !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Vector3>",0,&tolua_err) ||
03705      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
03706      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
03707      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
03708      !tolua_isnoobj(tolua_S,5,&tolua_err)
03709  )
03710   goto tolua_lerror;
03711  else
03712  {
03713   const fawkes::tf::Vector3* input = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,2,0));
03714   const fawkes::Time* timestamp = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
03715   const std::string frame_id = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
03716   {
03717    fawkes::tf::Stamped<fawkes::tf::Vector3>* tolua_ret = (fawkes::tf::Stamped<fawkes::tf::Vector3>*)  Mtolua_new((fawkes::tf::Stamped<fawkes::tf::Vector3>)(*input,*timestamp,frame_id));
03718     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Vector3>");
03719    tolua_pushcppstring(tolua_S,(const char*)frame_id);
03720   }
03721  }
03722  return 2;
03723 tolua_lerror:
03724  return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00(tolua_S);
03725 }
03726 #endif //#ifndef TOLUA_DISABLE
03727 
03728 /* method: new_local of class  fawkes::tf::Stamped<fawkes::tf::Vector3> */
03729 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01_local
03730 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01_local(lua_State* tolua_S)
03731 {
03732  tolua_Error tolua_err;
03733  if (
03734      !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Vector3>",0,&tolua_err) ||
03735      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
03736      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
03737      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
03738      !tolua_isnoobj(tolua_S,5,&tolua_err)
03739  )
03740   goto tolua_lerror;
03741  else
03742  {
03743   const fawkes::tf::Vector3* input = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,2,0));
03744   const fawkes::Time* timestamp = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
03745   const std::string frame_id = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
03746   {
03747    fawkes::tf::Stamped<fawkes::tf::Vector3>* tolua_ret = (fawkes::tf::Stamped<fawkes::tf::Vector3>*)  Mtolua_new((fawkes::tf::Stamped<fawkes::tf::Vector3>)(*input,*timestamp,frame_id));
03748     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Vector3>");
03749     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03750    tolua_pushcppstring(tolua_S,(const char*)frame_id);
03751   }
03752  }
03753  return 2;
03754 tolua_lerror:
03755  return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00_local(tolua_S);
03756 }
03757 #endif //#ifndef TOLUA_DISABLE
03758 
03759 /* method: set_data of class  fawkes::tf::Stamped<fawkes::tf::Vector3> */
03760 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__set_data00
03761 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__set_data00(lua_State* tolua_S)
03762 {
03763 #ifndef TOLUA_RELEASE
03764  tolua_Error tolua_err;
03765  if (
03766      !tolua_isusertype(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Vector3>",0,&tolua_err) ||
03767      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
03768      !tolua_isnoobj(tolua_S,3,&tolua_err)
03769  )
03770   goto tolua_lerror;
03771  else
03772 #endif
03773  {
03774   fawkes::tf::Stamped<fawkes::tf::Vector3>* self = (fawkes::tf::Stamped<fawkes::tf::Vector3>*)  tolua_tousertype(tolua_S,1,0);
03775   const fawkes::tf::Vector3* input = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,2,0));
03776 #ifndef TOLUA_RELEASE
03777   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_data'", NULL);
03778 #endif
03779   {
03780    self->set_data(*input);
03781   }
03782  }
03783  return 0;
03784 #ifndef TOLUA_RELEASE
03785  tolua_lerror:
03786  tolua_error(tolua_S,"#ferror in function 'set_data'.",&tolua_err);
03787  return 0;
03788 #endif
03789 }
03790 #endif //#ifndef TOLUA_DISABLE
03791 
03792 /* get function: stamp of class  fawkes::tf::Stamped<fawkes::tf::Point> */
03793 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__stamp
03794 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__stamp(lua_State* tolua_S)
03795 {
03796   fawkes::tf::Stamped<fawkes::tf::Point>* self = (fawkes::tf::Stamped<fawkes::tf::Point>*)  tolua_tousertype(tolua_S,1,0);
03797 #ifndef TOLUA_RELEASE
03798   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
03799 #endif
03800    tolua_pushusertype(tolua_S,(void*)&self->stamp,"fawkes::Time");
03801  return 1;
03802 }
03803 #endif //#ifndef TOLUA_DISABLE
03804 
03805 /* set function: stamp of class  fawkes::tf::Stamped<fawkes::tf::Point> */
03806 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__stamp
03807 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__stamp(lua_State* tolua_S)
03808 {
03809   fawkes::tf::Stamped<fawkes::tf::Point>* self = (fawkes::tf::Stamped<fawkes::tf::Point>*)  tolua_tousertype(tolua_S,1,0);
03810 #ifndef TOLUA_RELEASE
03811   tolua_Error tolua_err;
03812   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
03813   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)))
03814    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
03815 #endif
03816   self->stamp = *((fawkes::Time*)  tolua_tousertype(tolua_S,2,0))
03817 ;
03818  return 0;
03819 }
03820 #endif //#ifndef TOLUA_DISABLE
03821 
03822 /* get function: frame_id of class  fawkes::tf::Stamped<fawkes::tf::Point> */
03823 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__frame_id
03824 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__frame_id(lua_State* tolua_S)
03825 {
03826   fawkes::tf::Stamped<fawkes::tf::Point>* self = (fawkes::tf::Stamped<fawkes::tf::Point>*)  tolua_tousertype(tolua_S,1,0);
03827 #ifndef TOLUA_RELEASE
03828   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
03829 #endif
03830   tolua_pushcppstring(tolua_S,(const char*)self->frame_id);
03831  return 1;
03832 }
03833 #endif //#ifndef TOLUA_DISABLE
03834 
03835 /* set function: frame_id of class  fawkes::tf::Stamped<fawkes::tf::Point> */
03836 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__frame_id
03837 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__frame_id(lua_State* tolua_S)
03838 {
03839   fawkes::tf::Stamped<fawkes::tf::Point>* self = (fawkes::tf::Stamped<fawkes::tf::Point>*)  tolua_tousertype(tolua_S,1,0);
03840 #ifndef TOLUA_RELEASE
03841   tolua_Error tolua_err;
03842   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
03843   if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
03844    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
03845 #endif
03846   self->frame_id = ((std::string)  tolua_tocppstring(tolua_S,2,0))
03847 ;
03848  return 0;
03849 }
03850 #endif //#ifndef TOLUA_DISABLE
03851 
03852 /* method: new of class  fawkes::tf::Stamped<fawkes::tf::Point> */
03853 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00
03854 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00(lua_State* tolua_S)
03855 {
03856 #ifndef TOLUA_RELEASE
03857  tolua_Error tolua_err;
03858  if (
03859      !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Point>",0,&tolua_err) ||
03860      !tolua_isnoobj(tolua_S,2,&tolua_err)
03861  )
03862   goto tolua_lerror;
03863  else
03864 #endif
03865  {
03866   {
03867    fawkes::tf::Stamped<fawkes::tf::Point>* tolua_ret = (fawkes::tf::Stamped<fawkes::tf::Point>*)  Mtolua_new((fawkes::tf::Stamped<fawkes::tf::Point>)());
03868     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Point>");
03869   }
03870  }
03871  return 1;
03872 #ifndef TOLUA_RELEASE
03873  tolua_lerror:
03874  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
03875  return 0;
03876 #endif
03877 }
03878 #endif //#ifndef TOLUA_DISABLE
03879 
03880 /* method: new_local of class  fawkes::tf::Stamped<fawkes::tf::Point> */
03881 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00_local
03882 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00_local(lua_State* tolua_S)
03883 {
03884 #ifndef TOLUA_RELEASE
03885  tolua_Error tolua_err;
03886  if (
03887      !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Point>",0,&tolua_err) ||
03888      !tolua_isnoobj(tolua_S,2,&tolua_err)
03889  )
03890   goto tolua_lerror;
03891  else
03892 #endif
03893  {
03894   {
03895    fawkes::tf::Stamped<fawkes::tf::Point>* tolua_ret = (fawkes::tf::Stamped<fawkes::tf::Point>*)  Mtolua_new((fawkes::tf::Stamped<fawkes::tf::Point>)());
03896     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Point>");
03897     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03898   }
03899  }
03900  return 1;
03901 #ifndef TOLUA_RELEASE
03902  tolua_lerror:
03903  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
03904  return 0;
03905 #endif
03906 }
03907 #endif //#ifndef TOLUA_DISABLE
03908 
03909 /* method: new of class  fawkes::tf::Stamped<fawkes::tf::Point> */
03910 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01
03911 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01(lua_State* tolua_S)
03912 {
03913  tolua_Error tolua_err;
03914  if (
03915      !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Point>",0,&tolua_err) ||
03916      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Point",0,&tolua_err)) ||
03917      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
03918      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
03919      !tolua_isnoobj(tolua_S,5,&tolua_err)
03920  )
03921   goto tolua_lerror;
03922  else
03923  {
03924   const fawkes::tf::Point* input = ((const fawkes::tf::Point*)  tolua_tousertype(tolua_S,2,0));
03925   const fawkes::Time* timestamp = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
03926   const std::string frame_id = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
03927   {
03928    fawkes::tf::Stamped<fawkes::tf::Point>* tolua_ret = (fawkes::tf::Stamped<fawkes::tf::Point>*)  Mtolua_new((fawkes::tf::Stamped<fawkes::tf::Point>)(*input,*timestamp,frame_id));
03929     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Point>");
03930    tolua_pushcppstring(tolua_S,(const char*)frame_id);
03931   }
03932  }
03933  return 2;
03934 tolua_lerror:
03935  return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00(tolua_S);
03936 }
03937 #endif //#ifndef TOLUA_DISABLE
03938 
03939 /* method: new_local of class  fawkes::tf::Stamped<fawkes::tf::Point> */
03940 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01_local
03941 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01_local(lua_State* tolua_S)
03942 {
03943  tolua_Error tolua_err;
03944  if (
03945      !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Point>",0,&tolua_err) ||
03946      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Point",0,&tolua_err)) ||
03947      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
03948      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
03949      !tolua_isnoobj(tolua_S,5,&tolua_err)
03950  )
03951   goto tolua_lerror;
03952  else
03953  {
03954   const fawkes::tf::Point* input = ((const fawkes::tf::Point*)  tolua_tousertype(tolua_S,2,0));
03955   const fawkes::Time* timestamp = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
03956   const std::string frame_id = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
03957   {
03958    fawkes::tf::Stamped<fawkes::tf::Point>* tolua_ret = (fawkes::tf::Stamped<fawkes::tf::Point>*)  Mtolua_new((fawkes::tf::Stamped<fawkes::tf::Point>)(*input,*timestamp,frame_id));
03959     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Point>");
03960     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
03961    tolua_pushcppstring(tolua_S,(const char*)frame_id);
03962   }
03963  }
03964  return 2;
03965 tolua_lerror:
03966  return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00_local(tolua_S);
03967 }
03968 #endif //#ifndef TOLUA_DISABLE
03969 
03970 /* method: set_data of class  fawkes::tf::Stamped<fawkes::tf::Point> */
03971 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__set_data00
03972 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__set_data00(lua_State* tolua_S)
03973 {
03974 #ifndef TOLUA_RELEASE
03975  tolua_Error tolua_err;
03976  if (
03977      !tolua_isusertype(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Point>",0,&tolua_err) ||
03978      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Point",0,&tolua_err)) ||
03979      !tolua_isnoobj(tolua_S,3,&tolua_err)
03980  )
03981   goto tolua_lerror;
03982  else
03983 #endif
03984  {
03985   fawkes::tf::Stamped<fawkes::tf::Point>* self = (fawkes::tf::Stamped<fawkes::tf::Point>*)  tolua_tousertype(tolua_S,1,0);
03986   const fawkes::tf::Point* input = ((const fawkes::tf::Point*)  tolua_tousertype(tolua_S,2,0));
03987 #ifndef TOLUA_RELEASE
03988   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_data'", NULL);
03989 #endif
03990   {
03991    self->set_data(*input);
03992   }
03993  }
03994  return 0;
03995 #ifndef TOLUA_RELEASE
03996  tolua_lerror:
03997  tolua_error(tolua_S,"#ferror in function 'set_data'.",&tolua_err);
03998  return 0;
03999 #endif
04000 }
04001 #endif //#ifndef TOLUA_DISABLE
04002 
04003 /* get function: stamp of class  fawkes::tf::Stamped<fawkes::tf::Pose> */
04004 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__stamp
04005 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__stamp(lua_State* tolua_S)
04006 {
04007   fawkes::tf::Stamped<fawkes::tf::Pose>* self = (fawkes::tf::Stamped<fawkes::tf::Pose>*)  tolua_tousertype(tolua_S,1,0);
04008 #ifndef TOLUA_RELEASE
04009   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
04010 #endif
04011    tolua_pushusertype(tolua_S,(void*)&self->stamp,"fawkes::Time");
04012  return 1;
04013 }
04014 #endif //#ifndef TOLUA_DISABLE
04015 
04016 /* set function: stamp of class  fawkes::tf::Stamped<fawkes::tf::Pose> */
04017 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__stamp
04018 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__stamp(lua_State* tolua_S)
04019 {
04020   fawkes::tf::Stamped<fawkes::tf::Pose>* self = (fawkes::tf::Stamped<fawkes::tf::Pose>*)  tolua_tousertype(tolua_S,1,0);
04021 #ifndef TOLUA_RELEASE
04022   tolua_Error tolua_err;
04023   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
04024   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fawkes::Time",0,&tolua_err)))
04025    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
04026 #endif
04027   self->stamp = *((fawkes::Time*)  tolua_tousertype(tolua_S,2,0))
04028 ;
04029  return 0;
04030 }
04031 #endif //#ifndef TOLUA_DISABLE
04032 
04033 /* get function: frame_id of class  fawkes::tf::Stamped<fawkes::tf::Pose> */
04034 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id
04035 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id(lua_State* tolua_S)
04036 {
04037   fawkes::tf::Stamped<fawkes::tf::Pose>* self = (fawkes::tf::Stamped<fawkes::tf::Pose>*)  tolua_tousertype(tolua_S,1,0);
04038 #ifndef TOLUA_RELEASE
04039   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
04040 #endif
04041   tolua_pushcppstring(tolua_S,(const char*)self->frame_id);
04042  return 1;
04043 }
04044 #endif //#ifndef TOLUA_DISABLE
04045 
04046 /* set function: frame_id of class  fawkes::tf::Stamped<fawkes::tf::Pose> */
04047 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id
04048 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id(lua_State* tolua_S)
04049 {
04050   fawkes::tf::Stamped<fawkes::tf::Pose>* self = (fawkes::tf::Stamped<fawkes::tf::Pose>*)  tolua_tousertype(tolua_S,1,0);
04051 #ifndef TOLUA_RELEASE
04052   tolua_Error tolua_err;
04053   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
04054   if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
04055    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
04056 #endif
04057   self->frame_id = ((std::string)  tolua_tocppstring(tolua_S,2,0))
04058 ;
04059  return 0;
04060 }
04061 #endif //#ifndef TOLUA_DISABLE
04062 
04063 /* method: new of class  fawkes::tf::Stamped<fawkes::tf::Pose> */
04064 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00
04065 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00(lua_State* tolua_S)
04066 {
04067 #ifndef TOLUA_RELEASE
04068  tolua_Error tolua_err;
04069  if (
04070      !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Pose>",0,&tolua_err) ||
04071      !tolua_isnoobj(tolua_S,2,&tolua_err)
04072  )
04073   goto tolua_lerror;
04074  else
04075 #endif
04076  {
04077   {
04078    fawkes::tf::Stamped<fawkes::tf::Pose>* tolua_ret = (fawkes::tf::Stamped<fawkes::tf::Pose>*)  Mtolua_new((fawkes::tf::Stamped<fawkes::tf::Pose>)());
04079     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Pose>");
04080   }
04081  }
04082  return 1;
04083 #ifndef TOLUA_RELEASE
04084  tolua_lerror:
04085  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
04086  return 0;
04087 #endif
04088 }
04089 #endif //#ifndef TOLUA_DISABLE
04090 
04091 /* method: new_local of class  fawkes::tf::Stamped<fawkes::tf::Pose> */
04092 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00_local
04093 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00_local(lua_State* tolua_S)
04094 {
04095 #ifndef TOLUA_RELEASE
04096  tolua_Error tolua_err;
04097  if (
04098      !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Pose>",0,&tolua_err) ||
04099      !tolua_isnoobj(tolua_S,2,&tolua_err)
04100  )
04101   goto tolua_lerror;
04102  else
04103 #endif
04104  {
04105   {
04106    fawkes::tf::Stamped<fawkes::tf::Pose>* tolua_ret = (fawkes::tf::Stamped<fawkes::tf::Pose>*)  Mtolua_new((fawkes::tf::Stamped<fawkes::tf::Pose>)());
04107     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Pose>");
04108     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
04109   }
04110  }
04111  return 1;
04112 #ifndef TOLUA_RELEASE
04113  tolua_lerror:
04114  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
04115  return 0;
04116 #endif
04117 }
04118 #endif //#ifndef TOLUA_DISABLE
04119 
04120 /* method: new of class  fawkes::tf::Stamped<fawkes::tf::Pose> */
04121 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01
04122 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01(lua_State* tolua_S)
04123 {
04124  tolua_Error tolua_err;
04125  if (
04126      !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Pose>",0,&tolua_err) ||
04127      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Pose",0,&tolua_err)) ||
04128      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
04129      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
04130      !tolua_isnoobj(tolua_S,5,&tolua_err)
04131  )
04132   goto tolua_lerror;
04133  else
04134  {
04135   const fawkes::tf::Pose* input = ((const fawkes::tf::Pose*)  tolua_tousertype(tolua_S,2,0));
04136   const fawkes::Time* timestamp = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
04137   const std::string frame_id = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
04138   {
04139    fawkes::tf::Stamped<fawkes::tf::Pose>* tolua_ret = (fawkes::tf::Stamped<fawkes::tf::Pose>*)  Mtolua_new((fawkes::tf::Stamped<fawkes::tf::Pose>)(*input,*timestamp,frame_id));
04140     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Pose>");
04141    tolua_pushcppstring(tolua_S,(const char*)frame_id);
04142   }
04143  }
04144  return 2;
04145 tolua_lerror:
04146  return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00(tolua_S);
04147 }
04148 #endif //#ifndef TOLUA_DISABLE
04149 
04150 /* method: new_local of class  fawkes::tf::Stamped<fawkes::tf::Pose> */
04151 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01_local
04152 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01_local(lua_State* tolua_S)
04153 {
04154  tolua_Error tolua_err;
04155  if (
04156      !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Pose>",0,&tolua_err) ||
04157      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Pose",0,&tolua_err)) ||
04158      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
04159      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
04160      !tolua_isnoobj(tolua_S,5,&tolua_err)
04161  )
04162   goto tolua_lerror;
04163  else
04164  {
04165   const fawkes::tf::Pose* input = ((const fawkes::tf::Pose*)  tolua_tousertype(tolua_S,2,0));
04166   const fawkes::Time* timestamp = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
04167   const std::string frame_id = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
04168   {
04169    fawkes::tf::Stamped<fawkes::tf::Pose>* tolua_ret = (fawkes::tf::Stamped<fawkes::tf::Pose>*)  Mtolua_new((fawkes::tf::Stamped<fawkes::tf::Pose>)(*input,*timestamp,frame_id));
04170     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Pose>");
04171     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
04172    tolua_pushcppstring(tolua_S,(const char*)frame_id);
04173   }
04174  }
04175  return 2;
04176 tolua_lerror:
04177  return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00_local(tolua_S);
04178 }
04179 #endif //#ifndef TOLUA_DISABLE
04180 
04181 /* method: set_data of class  fawkes::tf::Stamped<fawkes::tf::Pose> */
04182 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__set_data00
04183 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__set_data00(lua_State* tolua_S)
04184 {
04185 #ifndef TOLUA_RELEASE
04186  tolua_Error tolua_err;
04187  if (
04188      !tolua_isusertype(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Pose>",0,&tolua_err) ||
04189      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Pose",0,&tolua_err)) ||
04190      !tolua_isnoobj(tolua_S,3,&tolua_err)
04191  )
04192   goto tolua_lerror;
04193  else
04194 #endif
04195  {
04196   fawkes::tf::Stamped<fawkes::tf::Pose>* self = (fawkes::tf::Stamped<fawkes::tf::Pose>*)  tolua_tousertype(tolua_S,1,0);
04197   const fawkes::tf::Pose* input = ((const fawkes::tf::Pose*)  tolua_tousertype(tolua_S,2,0));
04198 #ifndef TOLUA_RELEASE
04199   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_data'", NULL);
04200 #endif
04201   {
04202    self->set_data(*input);
04203   }
04204  }
04205  return 0;
04206 #ifndef TOLUA_RELEASE
04207  tolua_lerror:
04208  tolua_error(tolua_S,"#ferror in function 'set_data'.",&tolua_err);
04209  return 0;
04210 #endif
04211 }
04212 #endif //#ifndef TOLUA_DISABLE
04213 
04214 /* method: new of class  fawkes::tf::StampedQuaternion */
04215 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedQuaternion_new00
04216 static int tolua_fawkestf_fawkes_tf_StampedQuaternion_new00(lua_State* tolua_S)
04217 {
04218 #ifndef TOLUA_RELEASE
04219  tolua_Error tolua_err;
04220  if (
04221      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedQuaternion",0,&tolua_err) ||
04222      !tolua_isnoobj(tolua_S,2,&tolua_err)
04223  )
04224   goto tolua_lerror;
04225  else
04226 #endif
04227  {
04228   {
04229    fawkes::tf::StampedQuaternion* tolua_ret = (fawkes::tf::StampedQuaternion*)  Mtolua_new((fawkes::tf::StampedQuaternion)());
04230     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedQuaternion");
04231   }
04232  }
04233  return 1;
04234 #ifndef TOLUA_RELEASE
04235  tolua_lerror:
04236  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
04237  return 0;
04238 #endif
04239 }
04240 #endif //#ifndef TOLUA_DISABLE
04241 
04242 /* method: new_local of class  fawkes::tf::StampedQuaternion */
04243 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedQuaternion_new00_local
04244 static int tolua_fawkestf_fawkes_tf_StampedQuaternion_new00_local(lua_State* tolua_S)
04245 {
04246 #ifndef TOLUA_RELEASE
04247  tolua_Error tolua_err;
04248  if (
04249      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedQuaternion",0,&tolua_err) ||
04250      !tolua_isnoobj(tolua_S,2,&tolua_err)
04251  )
04252   goto tolua_lerror;
04253  else
04254 #endif
04255  {
04256   {
04257    fawkes::tf::StampedQuaternion* tolua_ret = (fawkes::tf::StampedQuaternion*)  Mtolua_new((fawkes::tf::StampedQuaternion)());
04258     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedQuaternion");
04259     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
04260   }
04261  }
04262  return 1;
04263 #ifndef TOLUA_RELEASE
04264  tolua_lerror:
04265  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
04266  return 0;
04267 #endif
04268 }
04269 #endif //#ifndef TOLUA_DISABLE
04270 
04271 /* method: new of class  fawkes::tf::StampedQuaternion */
04272 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedQuaternion_new01
04273 static int tolua_fawkestf_fawkes_tf_StampedQuaternion_new01(lua_State* tolua_S)
04274 {
04275  tolua_Error tolua_err;
04276  if (
04277      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedQuaternion",0,&tolua_err) ||
04278      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
04279      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
04280      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
04281      !tolua_isnoobj(tolua_S,5,&tolua_err)
04282  )
04283   goto tolua_lerror;
04284  else
04285  {
04286   const fawkes::tf::Quaternion* input = ((const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,2,0));
04287   const fawkes::Time* timestamp = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
04288   const std::string frame_id = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
04289   {
04290    fawkes::tf::StampedQuaternion* tolua_ret = (fawkes::tf::StampedQuaternion*)  Mtolua_new((fawkes::tf::StampedQuaternion)(*input,*timestamp,frame_id));
04291     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedQuaternion");
04292    tolua_pushcppstring(tolua_S,(const char*)frame_id);
04293   }
04294  }
04295  return 2;
04296 tolua_lerror:
04297  return tolua_fawkestf_fawkes_tf_StampedQuaternion_new00(tolua_S);
04298 }
04299 #endif //#ifndef TOLUA_DISABLE
04300 
04301 /* method: new_local of class  fawkes::tf::StampedQuaternion */
04302 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedQuaternion_new01_local
04303 static int tolua_fawkestf_fawkes_tf_StampedQuaternion_new01_local(lua_State* tolua_S)
04304 {
04305  tolua_Error tolua_err;
04306  if (
04307      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedQuaternion",0,&tolua_err) ||
04308      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Quaternion",0,&tolua_err)) ||
04309      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
04310      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
04311      !tolua_isnoobj(tolua_S,5,&tolua_err)
04312  )
04313   goto tolua_lerror;
04314  else
04315  {
04316   const fawkes::tf::Quaternion* input = ((const fawkes::tf::Quaternion*)  tolua_tousertype(tolua_S,2,0));
04317   const fawkes::Time* timestamp = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
04318   const std::string frame_id = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
04319   {
04320    fawkes::tf::StampedQuaternion* tolua_ret = (fawkes::tf::StampedQuaternion*)  Mtolua_new((fawkes::tf::StampedQuaternion)(*input,*timestamp,frame_id));
04321     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedQuaternion");
04322     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
04323    tolua_pushcppstring(tolua_S,(const char*)frame_id);
04324   }
04325  }
04326  return 2;
04327 tolua_lerror:
04328  return tolua_fawkestf_fawkes_tf_StampedQuaternion_new00_local(tolua_S);
04329 }
04330 #endif //#ifndef TOLUA_DISABLE
04331 
04332 /* method: new of class  fawkes::tf::StampedVector3 */
04333 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedVector3_new00
04334 static int tolua_fawkestf_fawkes_tf_StampedVector3_new00(lua_State* tolua_S)
04335 {
04336 #ifndef TOLUA_RELEASE
04337  tolua_Error tolua_err;
04338  if (
04339      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedVector3",0,&tolua_err) ||
04340      !tolua_isnoobj(tolua_S,2,&tolua_err)
04341  )
04342   goto tolua_lerror;
04343  else
04344 #endif
04345  {
04346   {
04347    fawkes::tf::StampedVector3* tolua_ret = (fawkes::tf::StampedVector3*)  Mtolua_new((fawkes::tf::StampedVector3)());
04348     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedVector3");
04349   }
04350  }
04351  return 1;
04352 #ifndef TOLUA_RELEASE
04353  tolua_lerror:
04354  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
04355  return 0;
04356 #endif
04357 }
04358 #endif //#ifndef TOLUA_DISABLE
04359 
04360 /* method: new_local of class  fawkes::tf::StampedVector3 */
04361 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedVector3_new00_local
04362 static int tolua_fawkestf_fawkes_tf_StampedVector3_new00_local(lua_State* tolua_S)
04363 {
04364 #ifndef TOLUA_RELEASE
04365  tolua_Error tolua_err;
04366  if (
04367      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedVector3",0,&tolua_err) ||
04368      !tolua_isnoobj(tolua_S,2,&tolua_err)
04369  )
04370   goto tolua_lerror;
04371  else
04372 #endif
04373  {
04374   {
04375    fawkes::tf::StampedVector3* tolua_ret = (fawkes::tf::StampedVector3*)  Mtolua_new((fawkes::tf::StampedVector3)());
04376     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedVector3");
04377     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
04378   }
04379  }
04380  return 1;
04381 #ifndef TOLUA_RELEASE
04382  tolua_lerror:
04383  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
04384  return 0;
04385 #endif
04386 }
04387 #endif //#ifndef TOLUA_DISABLE
04388 
04389 /* method: new of class  fawkes::tf::StampedVector3 */
04390 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedVector3_new01
04391 static int tolua_fawkestf_fawkes_tf_StampedVector3_new01(lua_State* tolua_S)
04392 {
04393  tolua_Error tolua_err;
04394  if (
04395      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedVector3",0,&tolua_err) ||
04396      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
04397      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
04398      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
04399      !tolua_isnoobj(tolua_S,5,&tolua_err)
04400  )
04401   goto tolua_lerror;
04402  else
04403  {
04404   const fawkes::tf::Vector3* input = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,2,0));
04405   const fawkes::Time* timestamp = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
04406   const std::string frame_id = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
04407   {
04408    fawkes::tf::StampedVector3* tolua_ret = (fawkes::tf::StampedVector3*)  Mtolua_new((fawkes::tf::StampedVector3)(*input,*timestamp,frame_id));
04409     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedVector3");
04410    tolua_pushcppstring(tolua_S,(const char*)frame_id);
04411   }
04412  }
04413  return 2;
04414 tolua_lerror:
04415  return tolua_fawkestf_fawkes_tf_StampedVector3_new00(tolua_S);
04416 }
04417 #endif //#ifndef TOLUA_DISABLE
04418 
04419 /* method: new_local of class  fawkes::tf::StampedVector3 */
04420 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedVector3_new01_local
04421 static int tolua_fawkestf_fawkes_tf_StampedVector3_new01_local(lua_State* tolua_S)
04422 {
04423  tolua_Error tolua_err;
04424  if (
04425      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedVector3",0,&tolua_err) ||
04426      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Vector3",0,&tolua_err)) ||
04427      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
04428      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
04429      !tolua_isnoobj(tolua_S,5,&tolua_err)
04430  )
04431   goto tolua_lerror;
04432  else
04433  {
04434   const fawkes::tf::Vector3* input = ((const fawkes::tf::Vector3*)  tolua_tousertype(tolua_S,2,0));
04435   const fawkes::Time* timestamp = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
04436   const std::string frame_id = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
04437   {
04438    fawkes::tf::StampedVector3* tolua_ret = (fawkes::tf::StampedVector3*)  Mtolua_new((fawkes::tf::StampedVector3)(*input,*timestamp,frame_id));
04439     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedVector3");
04440     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
04441    tolua_pushcppstring(tolua_S,(const char*)frame_id);
04442   }
04443  }
04444  return 2;
04445 tolua_lerror:
04446  return tolua_fawkestf_fawkes_tf_StampedVector3_new00_local(tolua_S);
04447 }
04448 #endif //#ifndef TOLUA_DISABLE
04449 
04450 /* method: new of class  fawkes::tf::StampedPoint */
04451 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPoint_new00
04452 static int tolua_fawkestf_fawkes_tf_StampedPoint_new00(lua_State* tolua_S)
04453 {
04454 #ifndef TOLUA_RELEASE
04455  tolua_Error tolua_err;
04456  if (
04457      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPoint",0,&tolua_err) ||
04458      !tolua_isnoobj(tolua_S,2,&tolua_err)
04459  )
04460   goto tolua_lerror;
04461  else
04462 #endif
04463  {
04464   {
04465    fawkes::tf::StampedPoint* tolua_ret = (fawkes::tf::StampedPoint*)  Mtolua_new((fawkes::tf::StampedPoint)());
04466     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedPoint");
04467   }
04468  }
04469  return 1;
04470 #ifndef TOLUA_RELEASE
04471  tolua_lerror:
04472  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
04473  return 0;
04474 #endif
04475 }
04476 #endif //#ifndef TOLUA_DISABLE
04477 
04478 /* method: new_local of class  fawkes::tf::StampedPoint */
04479 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPoint_new00_local
04480 static int tolua_fawkestf_fawkes_tf_StampedPoint_new00_local(lua_State* tolua_S)
04481 {
04482 #ifndef TOLUA_RELEASE
04483  tolua_Error tolua_err;
04484  if (
04485      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPoint",0,&tolua_err) ||
04486      !tolua_isnoobj(tolua_S,2,&tolua_err)
04487  )
04488   goto tolua_lerror;
04489  else
04490 #endif
04491  {
04492   {
04493    fawkes::tf::StampedPoint* tolua_ret = (fawkes::tf::StampedPoint*)  Mtolua_new((fawkes::tf::StampedPoint)());
04494     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedPoint");
04495     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
04496   }
04497  }
04498  return 1;
04499 #ifndef TOLUA_RELEASE
04500  tolua_lerror:
04501  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
04502  return 0;
04503 #endif
04504 }
04505 #endif //#ifndef TOLUA_DISABLE
04506 
04507 /* method: new of class  fawkes::tf::StampedPoint */
04508 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPoint_new01
04509 static int tolua_fawkestf_fawkes_tf_StampedPoint_new01(lua_State* tolua_S)
04510 {
04511  tolua_Error tolua_err;
04512  if (
04513      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPoint",0,&tolua_err) ||
04514      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Point",0,&tolua_err)) ||
04515      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
04516      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
04517      !tolua_isnoobj(tolua_S,5,&tolua_err)
04518  )
04519   goto tolua_lerror;
04520  else
04521  {
04522   const fawkes::tf::Point* input = ((const fawkes::tf::Point*)  tolua_tousertype(tolua_S,2,0));
04523   const fawkes::Time* timestamp = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
04524   const std::string frame_id = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
04525   {
04526    fawkes::tf::StampedPoint* tolua_ret = (fawkes::tf::StampedPoint*)  Mtolua_new((fawkes::tf::StampedPoint)(*input,*timestamp,frame_id));
04527     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedPoint");
04528    tolua_pushcppstring(tolua_S,(const char*)frame_id);
04529   }
04530  }
04531  return 2;
04532 tolua_lerror:
04533  return tolua_fawkestf_fawkes_tf_StampedPoint_new00(tolua_S);
04534 }
04535 #endif //#ifndef TOLUA_DISABLE
04536 
04537 /* method: new_local of class  fawkes::tf::StampedPoint */
04538 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPoint_new01_local
04539 static int tolua_fawkestf_fawkes_tf_StampedPoint_new01_local(lua_State* tolua_S)
04540 {
04541  tolua_Error tolua_err;
04542  if (
04543      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPoint",0,&tolua_err) ||
04544      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Point",0,&tolua_err)) ||
04545      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
04546      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
04547      !tolua_isnoobj(tolua_S,5,&tolua_err)
04548  )
04549   goto tolua_lerror;
04550  else
04551  {
04552   const fawkes::tf::Point* input = ((const fawkes::tf::Point*)  tolua_tousertype(tolua_S,2,0));
04553   const fawkes::Time* timestamp = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
04554   const std::string frame_id = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
04555   {
04556    fawkes::tf::StampedPoint* tolua_ret = (fawkes::tf::StampedPoint*)  Mtolua_new((fawkes::tf::StampedPoint)(*input,*timestamp,frame_id));
04557     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedPoint");
04558     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
04559    tolua_pushcppstring(tolua_S,(const char*)frame_id);
04560   }
04561  }
04562  return 2;
04563 tolua_lerror:
04564  return tolua_fawkestf_fawkes_tf_StampedPoint_new00_local(tolua_S);
04565 }
04566 #endif //#ifndef TOLUA_DISABLE
04567 
04568 /* method: new of class  fawkes::tf::StampedPose */
04569 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPose_new00
04570 static int tolua_fawkestf_fawkes_tf_StampedPose_new00(lua_State* tolua_S)
04571 {
04572 #ifndef TOLUA_RELEASE
04573  tolua_Error tolua_err;
04574  if (
04575      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPose",0,&tolua_err) ||
04576      !tolua_isnoobj(tolua_S,2,&tolua_err)
04577  )
04578   goto tolua_lerror;
04579  else
04580 #endif
04581  {
04582   {
04583    fawkes::tf::StampedPose* tolua_ret = (fawkes::tf::StampedPose*)  Mtolua_new((fawkes::tf::StampedPose)());
04584     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedPose");
04585   }
04586  }
04587  return 1;
04588 #ifndef TOLUA_RELEASE
04589  tolua_lerror:
04590  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
04591  return 0;
04592 #endif
04593 }
04594 #endif //#ifndef TOLUA_DISABLE
04595 
04596 /* method: new_local of class  fawkes::tf::StampedPose */
04597 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPose_new00_local
04598 static int tolua_fawkestf_fawkes_tf_StampedPose_new00_local(lua_State* tolua_S)
04599 {
04600 #ifndef TOLUA_RELEASE
04601  tolua_Error tolua_err;
04602  if (
04603      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPose",0,&tolua_err) ||
04604      !tolua_isnoobj(tolua_S,2,&tolua_err)
04605  )
04606   goto tolua_lerror;
04607  else
04608 #endif
04609  {
04610   {
04611    fawkes::tf::StampedPose* tolua_ret = (fawkes::tf::StampedPose*)  Mtolua_new((fawkes::tf::StampedPose)());
04612     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedPose");
04613     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
04614   }
04615  }
04616  return 1;
04617 #ifndef TOLUA_RELEASE
04618  tolua_lerror:
04619  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
04620  return 0;
04621 #endif
04622 }
04623 #endif //#ifndef TOLUA_DISABLE
04624 
04625 /* method: new of class  fawkes::tf::StampedPose */
04626 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPose_new01
04627 static int tolua_fawkestf_fawkes_tf_StampedPose_new01(lua_State* tolua_S)
04628 {
04629  tolua_Error tolua_err;
04630  if (
04631      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPose",0,&tolua_err) ||
04632      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Pose",0,&tolua_err)) ||
04633      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
04634      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
04635      !tolua_isnoobj(tolua_S,5,&tolua_err)
04636  )
04637   goto tolua_lerror;
04638  else
04639  {
04640   const fawkes::tf::Pose* input = ((const fawkes::tf::Pose*)  tolua_tousertype(tolua_S,2,0));
04641   const fawkes::Time* timestamp = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
04642   const std::string frame_id = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
04643   {
04644    fawkes::tf::StampedPose* tolua_ret = (fawkes::tf::StampedPose*)  Mtolua_new((fawkes::tf::StampedPose)(*input,*timestamp,frame_id));
04645     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedPose");
04646    tolua_pushcppstring(tolua_S,(const char*)frame_id);
04647   }
04648  }
04649  return 2;
04650 tolua_lerror:
04651  return tolua_fawkestf_fawkes_tf_StampedPose_new00(tolua_S);
04652 }
04653 #endif //#ifndef TOLUA_DISABLE
04654 
04655 /* method: new_local of class  fawkes::tf::StampedPose */
04656 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPose_new01_local
04657 static int tolua_fawkestf_fawkes_tf_StampedPose_new01_local(lua_State* tolua_S)
04658 {
04659  tolua_Error tolua_err;
04660  if (
04661      !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPose",0,&tolua_err) ||
04662      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::tf::Pose",0,&tolua_err)) ||
04663      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
04664      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
04665      !tolua_isnoobj(tolua_S,5,&tolua_err)
04666  )
04667   goto tolua_lerror;
04668  else
04669  {
04670   const fawkes::tf::Pose* input = ((const fawkes::tf::Pose*)  tolua_tousertype(tolua_S,2,0));
04671   const fawkes::Time* timestamp = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
04672   const std::string frame_id = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
04673   {
04674    fawkes::tf::StampedPose* tolua_ret = (fawkes::tf::StampedPose*)  Mtolua_new((fawkes::tf::StampedPose)(*input,*timestamp,frame_id));
04675     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedPose");
04676     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
04677    tolua_pushcppstring(tolua_S,(const char*)frame_id);
04678   }
04679  }
04680  return 2;
04681 tolua_lerror:
04682  return tolua_fawkestf_fawkes_tf_StampedPose_new00_local(tolua_S);
04683 }
04684 #endif //#ifndef TOLUA_DISABLE
04685 
04686 /* method: clear of class  fawkes::tf::Transformer */
04687 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_clear00
04688 static int tolua_fawkestf_fawkes_tf_Transformer_clear00(lua_State* tolua_S)
04689 {
04690 #ifndef TOLUA_RELEASE
04691  tolua_Error tolua_err;
04692  if (
04693      !tolua_isusertype(tolua_S,1,"fawkes::tf::Transformer",0,&tolua_err) ||
04694      !tolua_isnoobj(tolua_S,2,&tolua_err)
04695  )
04696   goto tolua_lerror;
04697  else
04698 #endif
04699  {
04700   fawkes::tf::Transformer* self = (fawkes::tf::Transformer*)  tolua_tousertype(tolua_S,1,0);
04701 #ifndef TOLUA_RELEASE
04702   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
04703 #endif
04704   {
04705    self->clear();
04706   }
04707  }
04708  return 0;
04709 #ifndef TOLUA_RELEASE
04710  tolua_lerror:
04711  tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
04712  return 0;
04713 #endif
04714 }
04715 #endif //#ifndef TOLUA_DISABLE
04716 
04717 /* method: frame_exists of class  fawkes::tf::Transformer */
04718 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_frame_exists00
04719 static int tolua_fawkestf_fawkes_tf_Transformer_frame_exists00(lua_State* tolua_S)
04720 {
04721 #ifndef TOLUA_RELEASE
04722  tolua_Error tolua_err;
04723  if (
04724      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
04725      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
04726      !tolua_isnoobj(tolua_S,3,&tolua_err)
04727  )
04728   goto tolua_lerror;
04729  else
04730 #endif
04731  {
04732   const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*)  tolua_tousertype(tolua_S,1,0);
04733   const std::string frame_id_str = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
04734 #ifndef TOLUA_RELEASE
04735   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'frame_exists'", NULL);
04736 #endif
04737   {
04738    bool tolua_ret = (bool)  self->frame_exists(frame_id_str);
04739    tolua_pushboolean(tolua_S,(bool)tolua_ret);
04740    tolua_pushcppstring(tolua_S,(const char*)frame_id_str);
04741   }
04742  }
04743  return 2;
04744 #ifndef TOLUA_RELEASE
04745  tolua_lerror:
04746  tolua_error(tolua_S,"#ferror in function 'frame_exists'.",&tolua_err);
04747  return 0;
04748 #endif
04749 }
04750 #endif //#ifndef TOLUA_DISABLE
04751 
04752 /* method: lookup_transform of class  fawkes::tf::Transformer */
04753 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_lookup_transform00
04754 static int tolua_fawkestf_fawkes_tf_Transformer_lookup_transform00(lua_State* tolua_S)
04755 {
04756 #ifndef TOLUA_RELEASE
04757  tolua_Error tolua_err;
04758  if (
04759      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
04760      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
04761      !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
04762      (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const fawkes::Time",0,&tolua_err)) ||
04763      (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"fawkes::tf::StampedTransform",0,&tolua_err)) ||
04764      !tolua_isnoobj(tolua_S,6,&tolua_err)
04765  )
04766   goto tolua_lerror;
04767  else
04768 #endif
04769  {
04770   const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*)  tolua_tousertype(tolua_S,1,0);
04771   const std::string target_frame = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
04772   const std::string source_frame = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
04773   const fawkes::Time* time = ((const fawkes::Time*)  tolua_tousertype(tolua_S,4,0));
04774   fawkes::tf::StampedTransform* transform = ((fawkes::tf::StampedTransform*)  tolua_tousertype(tolua_S,5,0));
04775 #ifndef TOLUA_RELEASE
04776   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lookup_transform'", NULL);
04777 #endif
04778   {
04779    self->lookup_transform(target_frame,source_frame,*time,*transform);
04780    tolua_pushcppstring(tolua_S,(const char*)target_frame);
04781    tolua_pushcppstring(tolua_S,(const char*)source_frame);
04782   }
04783  }
04784  return 2;
04785 #ifndef TOLUA_RELEASE
04786  tolua_lerror:
04787  tolua_error(tolua_S,"#ferror in function 'lookup_transform'.",&tolua_err);
04788  return 0;
04789 #endif
04790 }
04791 #endif //#ifndef TOLUA_DISABLE
04792 
04793 /* method: lookup_transform of class  fawkes::tf::Transformer */
04794 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_lookup_transform01
04795 static int tolua_fawkestf_fawkes_tf_Transformer_lookup_transform01(lua_State* tolua_S)
04796 {
04797  tolua_Error tolua_err;
04798  if (
04799      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
04800      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
04801      !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
04802      (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"fawkes::tf::StampedTransform",0,&tolua_err)) ||
04803      !tolua_isnoobj(tolua_S,5,&tolua_err)
04804  )
04805   goto tolua_lerror;
04806  else
04807  {
04808   const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*)  tolua_tousertype(tolua_S,1,0);
04809   const std::string target_frame = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
04810   const std::string source_frame = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
04811   fawkes::tf::StampedTransform* transform = ((fawkes::tf::StampedTransform*)  tolua_tousertype(tolua_S,4,0));
04812 #ifndef TOLUA_RELEASE
04813   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lookup_transform'", NULL);
04814 #endif
04815   {
04816    self->lookup_transform(target_frame,source_frame,*transform);
04817    tolua_pushcppstring(tolua_S,(const char*)target_frame);
04818    tolua_pushcppstring(tolua_S,(const char*)source_frame);
04819   }
04820  }
04821  return 2;
04822 tolua_lerror:
04823  return tolua_fawkestf_fawkes_tf_Transformer_lookup_transform00(tolua_S);
04824 }
04825 #endif //#ifndef TOLUA_DISABLE
04826 
04827 /* method: lookup_transform of class  fawkes::tf::Transformer */
04828 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_lookup_transform02
04829 static int tolua_fawkestf_fawkes_tf_Transformer_lookup_transform02(lua_State* tolua_S)
04830 {
04831  tolua_Error tolua_err;
04832  if (
04833      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
04834      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
04835      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
04836      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
04837      (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const fawkes::Time",0,&tolua_err)) ||
04838      !tolua_iscppstring(tolua_S,6,0,&tolua_err) ||
04839      (tolua_isvaluenil(tolua_S,7,&tolua_err) || !tolua_isusertype(tolua_S,7,"fawkes::tf::StampedTransform",0,&tolua_err)) ||
04840      !tolua_isnoobj(tolua_S,8,&tolua_err)
04841  )
04842   goto tolua_lerror;
04843  else
04844  {
04845   const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*)  tolua_tousertype(tolua_S,1,0);
04846   const std::string target_frame = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
04847   const fawkes::Time* target_time = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
04848   const std::string source_frame = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
04849   const fawkes::Time* source_time = ((const fawkes::Time*)  tolua_tousertype(tolua_S,5,0));
04850   const std::string fixed_frame = ((const std::string)  tolua_tocppstring(tolua_S,6,0));
04851   fawkes::tf::StampedTransform* transform = ((fawkes::tf::StampedTransform*)  tolua_tousertype(tolua_S,7,0));
04852 #ifndef TOLUA_RELEASE
04853   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lookup_transform'", NULL);
04854 #endif
04855   {
04856    self->lookup_transform(target_frame,*target_time,source_frame,*source_time,fixed_frame,*transform);
04857    tolua_pushcppstring(tolua_S,(const char*)target_frame);
04858    tolua_pushcppstring(tolua_S,(const char*)source_frame);
04859    tolua_pushcppstring(tolua_S,(const char*)fixed_frame);
04860   }
04861  }
04862  return 3;
04863 tolua_lerror:
04864  return tolua_fawkestf_fawkes_tf_Transformer_lookup_transform01(tolua_S);
04865 }
04866 #endif //#ifndef TOLUA_DISABLE
04867 
04868 /* method: can_transform of class  fawkes::tf::Transformer */
04869 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_can_transform00
04870 static int tolua_fawkestf_fawkes_tf_Transformer_can_transform00(lua_State* tolua_S)
04871 {
04872 #ifndef TOLUA_RELEASE
04873  tolua_Error tolua_err;
04874  if (
04875      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
04876      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
04877      !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
04878      (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const fawkes::Time",0,&tolua_err)) ||
04879      !tolua_isnoobj(tolua_S,5,&tolua_err)
04880  )
04881   goto tolua_lerror;
04882  else
04883 #endif
04884  {
04885   const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*)  tolua_tousertype(tolua_S,1,0);
04886   const std::string target_frame = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
04887   const std::string source_frame = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
04888   const fawkes::Time* time = ((const fawkes::Time*)  tolua_tousertype(tolua_S,4,0));
04889 #ifndef TOLUA_RELEASE
04890   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'can_transform'", NULL);
04891 #endif
04892   {
04893    bool tolua_ret = (bool)  self->can_transform(target_frame,source_frame,*time);
04894    tolua_pushboolean(tolua_S,(bool)tolua_ret);
04895    tolua_pushcppstring(tolua_S,(const char*)target_frame);
04896    tolua_pushcppstring(tolua_S,(const char*)source_frame);
04897   }
04898  }
04899  return 3;
04900 #ifndef TOLUA_RELEASE
04901  tolua_lerror:
04902  tolua_error(tolua_S,"#ferror in function 'can_transform'.",&tolua_err);
04903  return 0;
04904 #endif
04905 }
04906 #endif //#ifndef TOLUA_DISABLE
04907 
04908 /* method: can_transform of class  fawkes::tf::Transformer */
04909 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_can_transform01
04910 static int tolua_fawkestf_fawkes_tf_Transformer_can_transform01(lua_State* tolua_S)
04911 {
04912  tolua_Error tolua_err;
04913  if (
04914      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
04915      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
04916      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
04917      !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
04918      (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const fawkes::Time",0,&tolua_err)) ||
04919      !tolua_iscppstring(tolua_S,6,0,&tolua_err) ||
04920      !tolua_isnoobj(tolua_S,7,&tolua_err)
04921  )
04922   goto tolua_lerror;
04923  else
04924  {
04925   const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*)  tolua_tousertype(tolua_S,1,0);
04926   const std::string target_frame = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
04927   const fawkes::Time* target_time = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
04928   const std::string source_frame = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
04929   const fawkes::Time* source_time = ((const fawkes::Time*)  tolua_tousertype(tolua_S,5,0));
04930   const std::string fixed_frame = ((const std::string)  tolua_tocppstring(tolua_S,6,0));
04931 #ifndef TOLUA_RELEASE
04932   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'can_transform'", NULL);
04933 #endif
04934   {
04935    bool tolua_ret = (bool)  self->can_transform(target_frame,*target_time,source_frame,*source_time,fixed_frame);
04936    tolua_pushboolean(tolua_S,(bool)tolua_ret);
04937    tolua_pushcppstring(tolua_S,(const char*)target_frame);
04938    tolua_pushcppstring(tolua_S,(const char*)source_frame);
04939    tolua_pushcppstring(tolua_S,(const char*)fixed_frame);
04940   }
04941  }
04942  return 4;
04943 tolua_lerror:
04944  return tolua_fawkestf_fawkes_tf_Transformer_can_transform00(tolua_S);
04945 }
04946 #endif //#ifndef TOLUA_DISABLE
04947 
04948 /* method: transform_quaternion of class  fawkes::tf::Transformer */
04949 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion00
04950 static int tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion00(lua_State* tolua_S)
04951 {
04952 #ifndef TOLUA_RELEASE
04953  tolua_Error tolua_err;
04954  if (
04955      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
04956      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
04957      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::StampedQuaternion",0,&tolua_err)) ||
04958      (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"fawkes::tf::StampedQuaternion",0,&tolua_err)) ||
04959      !tolua_isnoobj(tolua_S,5,&tolua_err)
04960  )
04961   goto tolua_lerror;
04962  else
04963 #endif
04964  {
04965   const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*)  tolua_tousertype(tolua_S,1,0);
04966   const std::string target_frame = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
04967   const fawkes::tf::StampedQuaternion* stamped_in = ((const fawkes::tf::StampedQuaternion*)  tolua_tousertype(tolua_S,3,0));
04968   fawkes::tf::StampedQuaternion* stamped_out = ((fawkes::tf::StampedQuaternion*)  tolua_tousertype(tolua_S,4,0));
04969 #ifndef TOLUA_RELEASE
04970   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'transform_quaternion'", NULL);
04971 #endif
04972   {
04973    self->transform_quaternion(target_frame,*stamped_in,*stamped_out);
04974    tolua_pushcppstring(tolua_S,(const char*)target_frame);
04975   }
04976  }
04977  return 1;
04978 #ifndef TOLUA_RELEASE
04979  tolua_lerror:
04980  tolua_error(tolua_S,"#ferror in function 'transform_quaternion'.",&tolua_err);
04981  return 0;
04982 #endif
04983 }
04984 #endif //#ifndef TOLUA_DISABLE
04985 
04986 /* method: transform_vector of class  fawkes::tf::Transformer */
04987 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_vector00
04988 static int tolua_fawkestf_fawkes_tf_Transformer_transform_vector00(lua_State* tolua_S)
04989 {
04990 #ifndef TOLUA_RELEASE
04991  tolua_Error tolua_err;
04992  if (
04993      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
04994      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
04995      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::StampedVector3",0,&tolua_err)) ||
04996      (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"fawkes::tf::StampedVector3",0,&tolua_err)) ||
04997      !tolua_isnoobj(tolua_S,5,&tolua_err)
04998  )
04999   goto tolua_lerror;
05000  else
05001 #endif
05002  {
05003   const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*)  tolua_tousertype(tolua_S,1,0);
05004   const std::string target_frame = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
05005   const fawkes::tf::StampedVector3* stamped_in = ((const fawkes::tf::StampedVector3*)  tolua_tousertype(tolua_S,3,0));
05006   fawkes::tf::StampedVector3* stamped_out = ((fawkes::tf::StampedVector3*)  tolua_tousertype(tolua_S,4,0));
05007 #ifndef TOLUA_RELEASE
05008   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'transform_vector'", NULL);
05009 #endif
05010   {
05011    self->transform_vector(target_frame,*stamped_in,*stamped_out);
05012    tolua_pushcppstring(tolua_S,(const char*)target_frame);
05013   }
05014  }
05015  return 1;
05016 #ifndef TOLUA_RELEASE
05017  tolua_lerror:
05018  tolua_error(tolua_S,"#ferror in function 'transform_vector'.",&tolua_err);
05019  return 0;
05020 #endif
05021 }
05022 #endif //#ifndef TOLUA_DISABLE
05023 
05024 /* method: transform_point of class  fawkes::tf::Transformer */
05025 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_point00
05026 static int tolua_fawkestf_fawkes_tf_Transformer_transform_point00(lua_State* tolua_S)
05027 {
05028 #ifndef TOLUA_RELEASE
05029  tolua_Error tolua_err;
05030  if (
05031      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
05032      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
05033      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::StampedPoint",0,&tolua_err)) ||
05034      (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"fawkes::tf::StampedPoint",0,&tolua_err)) ||
05035      !tolua_isnoobj(tolua_S,5,&tolua_err)
05036  )
05037   goto tolua_lerror;
05038  else
05039 #endif
05040  {
05041   const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*)  tolua_tousertype(tolua_S,1,0);
05042   const std::string target_frame = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
05043   const fawkes::tf::StampedPoint* stamped_in = ((const fawkes::tf::StampedPoint*)  tolua_tousertype(tolua_S,3,0));
05044   fawkes::tf::StampedPoint* stamped_out = ((fawkes::tf::StampedPoint*)  tolua_tousertype(tolua_S,4,0));
05045 #ifndef TOLUA_RELEASE
05046   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'transform_point'", NULL);
05047 #endif
05048   {
05049    self->transform_point(target_frame,*stamped_in,*stamped_out);
05050    tolua_pushcppstring(tolua_S,(const char*)target_frame);
05051   }
05052  }
05053  return 1;
05054 #ifndef TOLUA_RELEASE
05055  tolua_lerror:
05056  tolua_error(tolua_S,"#ferror in function 'transform_point'.",&tolua_err);
05057  return 0;
05058 #endif
05059 }
05060 #endif //#ifndef TOLUA_DISABLE
05061 
05062 /* method: transform_pose of class  fawkes::tf::Transformer */
05063 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_pose00
05064 static int tolua_fawkestf_fawkes_tf_Transformer_transform_pose00(lua_State* tolua_S)
05065 {
05066 #ifndef TOLUA_RELEASE
05067  tolua_Error tolua_err;
05068  if (
05069      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
05070      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
05071      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::tf::StampedPose",0,&tolua_err)) ||
05072      (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"fawkes::tf::StampedPose",0,&tolua_err)) ||
05073      !tolua_isnoobj(tolua_S,5,&tolua_err)
05074  )
05075   goto tolua_lerror;
05076  else
05077 #endif
05078  {
05079   const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*)  tolua_tousertype(tolua_S,1,0);
05080   const std::string target_frame = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
05081   const fawkes::tf::StampedPose* stamped_in = ((const fawkes::tf::StampedPose*)  tolua_tousertype(tolua_S,3,0));
05082   fawkes::tf::StampedPose* stamped_out = ((fawkes::tf::StampedPose*)  tolua_tousertype(tolua_S,4,0));
05083 #ifndef TOLUA_RELEASE
05084   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'transform_pose'", NULL);
05085 #endif
05086   {
05087    self->transform_pose(target_frame,*stamped_in,*stamped_out);
05088    tolua_pushcppstring(tolua_S,(const char*)target_frame);
05089   }
05090  }
05091  return 1;
05092 #ifndef TOLUA_RELEASE
05093  tolua_lerror:
05094  tolua_error(tolua_S,"#ferror in function 'transform_pose'.",&tolua_err);
05095  return 0;
05096 #endif
05097 }
05098 #endif //#ifndef TOLUA_DISABLE
05099 
05100 /* method: transform_quaternion of class  fawkes::tf::Transformer */
05101 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion01
05102 static int tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion01(lua_State* tolua_S)
05103 {
05104  tolua_Error tolua_err;
05105  if (
05106      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
05107      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
05108      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
05109      (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const fawkes::tf::StampedQuaternion",0,&tolua_err)) ||
05110      !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
05111      (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"fawkes::tf::StampedQuaternion",0,&tolua_err)) ||
05112      !tolua_isnoobj(tolua_S,7,&tolua_err)
05113  )
05114   goto tolua_lerror;
05115  else
05116  {
05117   const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*)  tolua_tousertype(tolua_S,1,0);
05118   const std::string target_frame = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
05119   const fawkes::Time* target_time = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
05120   const fawkes::tf::StampedQuaternion* stamped_in = ((const fawkes::tf::StampedQuaternion*)  tolua_tousertype(tolua_S,4,0));
05121   const std::string fixed_frame = ((const std::string)  tolua_tocppstring(tolua_S,5,0));
05122   fawkes::tf::StampedQuaternion* stamped_out = ((fawkes::tf::StampedQuaternion*)  tolua_tousertype(tolua_S,6,0));
05123 #ifndef TOLUA_RELEASE
05124   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'transform_quaternion'", NULL);
05125 #endif
05126   {
05127    self->transform_quaternion(target_frame,*target_time,*stamped_in,fixed_frame,*stamped_out);
05128    tolua_pushcppstring(tolua_S,(const char*)target_frame);
05129    tolua_pushcppstring(tolua_S,(const char*)fixed_frame);
05130   }
05131  }
05132  return 2;
05133 tolua_lerror:
05134  return tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion00(tolua_S);
05135 }
05136 #endif //#ifndef TOLUA_DISABLE
05137 
05138 /* method: transform_vector of class  fawkes::tf::Transformer */
05139 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_vector01
05140 static int tolua_fawkestf_fawkes_tf_Transformer_transform_vector01(lua_State* tolua_S)
05141 {
05142  tolua_Error tolua_err;
05143  if (
05144      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
05145      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
05146      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
05147      (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const fawkes::tf::StampedVector3",0,&tolua_err)) ||
05148      !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
05149      (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"fawkes::tf::StampedVector3",0,&tolua_err)) ||
05150      !tolua_isnoobj(tolua_S,7,&tolua_err)
05151  )
05152   goto tolua_lerror;
05153  else
05154  {
05155   const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*)  tolua_tousertype(tolua_S,1,0);
05156   const std::string target_frame = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
05157   const fawkes::Time* target_time = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
05158   const fawkes::tf::StampedVector3* stamped_in = ((const fawkes::tf::StampedVector3*)  tolua_tousertype(tolua_S,4,0));
05159   const std::string fixed_frame = ((const std::string)  tolua_tocppstring(tolua_S,5,0));
05160   fawkes::tf::StampedVector3* stamped_out = ((fawkes::tf::StampedVector3*)  tolua_tousertype(tolua_S,6,0));
05161 #ifndef TOLUA_RELEASE
05162   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'transform_vector'", NULL);
05163 #endif
05164   {
05165    self->transform_vector(target_frame,*target_time,*stamped_in,fixed_frame,*stamped_out);
05166    tolua_pushcppstring(tolua_S,(const char*)target_frame);
05167    tolua_pushcppstring(tolua_S,(const char*)fixed_frame);
05168   }
05169  }
05170  return 2;
05171 tolua_lerror:
05172  return tolua_fawkestf_fawkes_tf_Transformer_transform_vector00(tolua_S);
05173 }
05174 #endif //#ifndef TOLUA_DISABLE
05175 
05176 /* method: transform_point of class  fawkes::tf::Transformer */
05177 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_point01
05178 static int tolua_fawkestf_fawkes_tf_Transformer_transform_point01(lua_State* tolua_S)
05179 {
05180  tolua_Error tolua_err;
05181  if (
05182      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
05183      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
05184      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
05185      (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const fawkes::tf::StampedPoint",0,&tolua_err)) ||
05186      !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
05187      (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"fawkes::tf::StampedPoint",0,&tolua_err)) ||
05188      !tolua_isnoobj(tolua_S,7,&tolua_err)
05189  )
05190   goto tolua_lerror;
05191  else
05192  {
05193   const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*)  tolua_tousertype(tolua_S,1,0);
05194   const std::string target_frame = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
05195   const fawkes::Time* target_time = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
05196   const fawkes::tf::StampedPoint* stamped_in = ((const fawkes::tf::StampedPoint*)  tolua_tousertype(tolua_S,4,0));
05197   const std::string fixed_frame = ((const std::string)  tolua_tocppstring(tolua_S,5,0));
05198   fawkes::tf::StampedPoint* stamped_out = ((fawkes::tf::StampedPoint*)  tolua_tousertype(tolua_S,6,0));
05199 #ifndef TOLUA_RELEASE
05200   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'transform_point'", NULL);
05201 #endif
05202   {
05203    self->transform_point(target_frame,*target_time,*stamped_in,fixed_frame,*stamped_out);
05204    tolua_pushcppstring(tolua_S,(const char*)target_frame);
05205    tolua_pushcppstring(tolua_S,(const char*)fixed_frame);
05206   }
05207  }
05208  return 2;
05209 tolua_lerror:
05210  return tolua_fawkestf_fawkes_tf_Transformer_transform_point00(tolua_S);
05211 }
05212 #endif //#ifndef TOLUA_DISABLE
05213 
05214 /* method: transform_pose of class  fawkes::tf::Transformer */
05215 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_pose01
05216 static int tolua_fawkestf_fawkes_tf_Transformer_transform_pose01(lua_State* tolua_S)
05217 {
05218  tolua_Error tolua_err;
05219  if (
05220      !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transformer",0,&tolua_err) ||
05221      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
05222      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::Time",0,&tolua_err)) ||
05223      (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const fawkes::tf::StampedPose",0,&tolua_err)) ||
05224      !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
05225      (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"fawkes::tf::StampedPose",0,&tolua_err)) ||
05226      !tolua_isnoobj(tolua_S,7,&tolua_err)
05227  )
05228   goto tolua_lerror;
05229  else
05230  {
05231   const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*)  tolua_tousertype(tolua_S,1,0);
05232   const std::string target_frame = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
05233   const fawkes::Time* target_time = ((const fawkes::Time*)  tolua_tousertype(tolua_S,3,0));
05234   const fawkes::tf::StampedPose* stamped_in = ((const fawkes::tf::StampedPose*)  tolua_tousertype(tolua_S,4,0));
05235   const std::string fixed_frame = ((const std::string)  tolua_tocppstring(tolua_S,5,0));
05236   fawkes::tf::StampedPose* stamped_out = ((fawkes::tf::StampedPose*)  tolua_tousertype(tolua_S,6,0));
05237 #ifndef TOLUA_RELEASE
05238   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'transform_pose'", NULL);
05239 #endif
05240   {
05241    self->transform_pose(target_frame,*target_time,*stamped_in,fixed_frame,*stamped_out);
05242    tolua_pushcppstring(tolua_S,(const char*)target_frame);
05243    tolua_pushcppstring(tolua_S,(const char*)fixed_frame);
05244   }
05245  }
05246  return 2;
05247 tolua_lerror:
05248  return tolua_fawkestf_fawkes_tf_Transformer_transform_pose00(tolua_S);
05249 }
05250 #endif //#ifndef TOLUA_DISABLE
05251 
05252 /* Open function */
05253 TOLUA_API int tolua_fawkestf_open (lua_State* tolua_S)
05254 {
05255  tolua_open(tolua_S);
05256  tolua_reg_types(tolua_S);
05257  tolua_module(tolua_S,NULL,0);
05258  tolua_beginmodule(tolua_S,NULL);
05259   tolua_module(tolua_S,"fawkes",0);
05260   tolua_beginmodule(tolua_S,"fawkes");
05261    tolua_module(tolua_S,"tf",0);
05262    tolua_beginmodule(tolua_S,"tf");
05263     #ifdef __cplusplus
05264     tolua_cclass(tolua_S,"Vector3","fawkes::tf::Vector3","",tolua_collect_fawkes__tf__Vector3);
05265     #else
05266     tolua_cclass(tolua_S,"Vector3","fawkes::tf::Vector3","",NULL);
05267     #endif
05268     tolua_beginmodule(tolua_S,"Vector3");
05269      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Vector3_new00);
05270      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Vector3_new00_local);
05271      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Vector3_new00_local);
05272      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Vector3_new01);
05273      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Vector3_new01_local);
05274      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Vector3_new01_local);
05275      tolua_function(tolua_S,"dot",tolua_fawkestf_fawkes_tf_Vector3_dot00);
05276      tolua_function(tolua_S,"length2",tolua_fawkestf_fawkes_tf_Vector3_length200);
05277      tolua_function(tolua_S,"length",tolua_fawkestf_fawkes_tf_Vector3_length00);
05278      tolua_function(tolua_S,"distance2",tolua_fawkestf_fawkes_tf_Vector3_distance200);
05279      tolua_function(tolua_S,"distance",tolua_fawkestf_fawkes_tf_Vector3_distance00);
05280      tolua_function(tolua_S,"normalize",tolua_fawkestf_fawkes_tf_Vector3_normalize00);
05281      tolua_function(tolua_S,"normalized",tolua_fawkestf_fawkes_tf_Vector3_normalized00);
05282      tolua_function(tolua_S,"angle",tolua_fawkestf_fawkes_tf_Vector3_angle00);
05283      tolua_function(tolua_S,"absolute",tolua_fawkestf_fawkes_tf_Vector3_absolute00);
05284      tolua_function(tolua_S,"cross",tolua_fawkestf_fawkes_tf_Vector3_cross00);
05285      tolua_function(tolua_S,"triple",tolua_fawkestf_fawkes_tf_Vector3_triple00);
05286      tolua_function(tolua_S,"minAxis",tolua_fawkestf_fawkes_tf_Vector3_minAxis00);
05287      tolua_function(tolua_S,"maxAxis",tolua_fawkestf_fawkes_tf_Vector3_maxAxis00);
05288      tolua_function(tolua_S,"furthestAxis",tolua_fawkestf_fawkes_tf_Vector3_furthestAxis00);
05289      tolua_function(tolua_S,"closestAxis",tolua_fawkestf_fawkes_tf_Vector3_closestAxis00);
05290      tolua_function(tolua_S,"setInterpolate3",tolua_fawkestf_fawkes_tf_Vector3_setInterpolate300);
05291      tolua_function(tolua_S,"lerp",tolua_fawkestf_fawkes_tf_Vector3_lerp00);
05292      tolua_function(tolua_S,"x",tolua_fawkestf_fawkes_tf_Vector3_x00);
05293      tolua_function(tolua_S,"y",tolua_fawkestf_fawkes_tf_Vector3_y00);
05294      tolua_function(tolua_S,"z",tolua_fawkestf_fawkes_tf_Vector3_z00);
05295      tolua_function(tolua_S,"setX",tolua_fawkestf_fawkes_tf_Vector3_setX00);
05296      tolua_function(tolua_S,"setY",tolua_fawkestf_fawkes_tf_Vector3_setY00);
05297      tolua_function(tolua_S,"setZ",tolua_fawkestf_fawkes_tf_Vector3_setZ00);
05298      tolua_function(tolua_S,"setValue",tolua_fawkestf_fawkes_tf_Vector3_setValue00);
05299      tolua_function(tolua_S,"setZero",tolua_fawkestf_fawkes_tf_Vector3_setZero00);
05300      tolua_function(tolua_S,"isZero",tolua_fawkestf_fawkes_tf_Vector3_isZero00);
05301      tolua_function(tolua_S,"fuzzyZero",tolua_fawkestf_fawkes_tf_Vector3_fuzzyZero00);
05302     tolua_endmodule(tolua_S);
05303     #ifdef __cplusplus
05304     tolua_cclass(tolua_S,"Quaternion","fawkes::tf::Quaternion","",tolua_collect_fawkes__tf__Quaternion);
05305     #else
05306     tolua_cclass(tolua_S,"Quaternion","fawkes::tf::Quaternion","",NULL);
05307     #endif
05308     tolua_beginmodule(tolua_S,"Quaternion");
05309      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Quaternion_new00);
05310      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Quaternion_new00_local);
05311      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Quaternion_new00_local);
05312      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Quaternion_new01);
05313      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Quaternion_new01_local);
05314      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Quaternion_new01_local);
05315      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Quaternion_new02);
05316      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Quaternion_new02_local);
05317      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Quaternion_new02_local);
05318      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Quaternion_new03);
05319      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Quaternion_new03_local);
05320      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Quaternion_new03_local);
05321      tolua_function(tolua_S,"getIdentity",tolua_fawkestf_fawkes_tf_Quaternion_getIdentity00);
05322      tolua_function(tolua_S,"setRotation",tolua_fawkestf_fawkes_tf_Quaternion_setRotation00);
05323      tolua_function(tolua_S,"setEuler",tolua_fawkestf_fawkes_tf_Quaternion_setEuler00);
05324      tolua_function(tolua_S,".eq",tolua_fawkestf_fawkes_tf_Quaternion__eq00);
05325      tolua_function(tolua_S,"dot",tolua_fawkestf_fawkes_tf_Quaternion_dot00);
05326      tolua_function(tolua_S,"length2",tolua_fawkestf_fawkes_tf_Quaternion_length200);
05327      tolua_function(tolua_S,"length",tolua_fawkestf_fawkes_tf_Quaternion_length00);
05328      tolua_function(tolua_S,"normalize",tolua_fawkestf_fawkes_tf_Quaternion_normalize00);
05329      tolua_function(tolua_S,"normalized",tolua_fawkestf_fawkes_tf_Quaternion_normalized00);
05330      tolua_function(tolua_S,"angle",tolua_fawkestf_fawkes_tf_Quaternion_angle00);
05331      tolua_function(tolua_S,"getAngle",tolua_fawkestf_fawkes_tf_Quaternion_getAngle00);
05332      tolua_function(tolua_S,"getAxis",tolua_fawkestf_fawkes_tf_Quaternion_getAxis00);
05333      tolua_function(tolua_S,"inverse",tolua_fawkestf_fawkes_tf_Quaternion_inverse00);
05334      tolua_function(tolua_S,"slerp",tolua_fawkestf_fawkes_tf_Quaternion_slerp00);
05335      tolua_function(tolua_S,"x",tolua_fawkestf_fawkes_tf_Quaternion_x00);
05336      tolua_function(tolua_S,"y",tolua_fawkestf_fawkes_tf_Quaternion_y00);
05337      tolua_function(tolua_S,"z",tolua_fawkestf_fawkes_tf_Quaternion_z00);
05338      tolua_function(tolua_S,"w",tolua_fawkestf_fawkes_tf_Quaternion_w00);
05339      tolua_function(tolua_S,"setX",tolua_fawkestf_fawkes_tf_Quaternion_setX00);
05340      tolua_function(tolua_S,"setY",tolua_fawkestf_fawkes_tf_Quaternion_setY00);
05341      tolua_function(tolua_S,"setZ",tolua_fawkestf_fawkes_tf_Quaternion_setZ00);
05342      tolua_function(tolua_S,"setW",tolua_fawkestf_fawkes_tf_Quaternion_setW00);
05343      tolua_function(tolua_S,"setValue",tolua_fawkestf_fawkes_tf_Quaternion_setValue00);
05344     tolua_endmodule(tolua_S);
05345     #ifdef __cplusplus
05346     tolua_cclass(tolua_S,"Transform","fawkes::tf::Transform","",tolua_collect_fawkes__tf__Transform);
05347     #else
05348     tolua_cclass(tolua_S,"Transform","fawkes::tf::Transform","",NULL);
05349     #endif
05350     tolua_beginmodule(tolua_S,"Transform");
05351      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Transform_new00);
05352      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Transform_new00_local);
05353      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Transform_new00_local);
05354      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Transform_new01);
05355      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Transform_new01_local);
05356      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Transform_new01_local);
05357      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Transform_new02);
05358      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Transform_new02_local);
05359      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Transform_new02_local);
05360      tolua_function(tolua_S,"getIdentity",tolua_fawkestf_fawkes_tf_Transform_getIdentity00);
05361      tolua_function(tolua_S,"mult",tolua_fawkestf_fawkes_tf_Transform_mult00);
05362      tolua_function(tolua_S,".mul",tolua_fawkestf_fawkes_tf_Transform__mul00);
05363      tolua_function(tolua_S,".mul",tolua_fawkestf_fawkes_tf_Transform__mul01);
05364      tolua_function(tolua_S,"getOrigin",tolua_fawkestf_fawkes_tf_Transform_getOrigin00);
05365      tolua_function(tolua_S,"getRotation",tolua_fawkestf_fawkes_tf_Transform_getRotation00);
05366      tolua_function(tolua_S,"setOrigin",tolua_fawkestf_fawkes_tf_Transform_setOrigin00);
05367      tolua_function(tolua_S,"setRotation",tolua_fawkestf_fawkes_tf_Transform_setRotation00);
05368      tolua_function(tolua_S,"setIdentity",tolua_fawkestf_fawkes_tf_Transform_setIdentity00);
05369      tolua_function(tolua_S,"inverse",tolua_fawkestf_fawkes_tf_Transform_inverse00);
05370      tolua_function(tolua_S,"inverseTimes",tolua_fawkestf_fawkes_tf_Transform_inverseTimes00);
05371     tolua_endmodule(tolua_S);
05372     #ifdef __cplusplus
05373     tolua_cclass(tolua_S,"Point","fawkes::tf::Point","fawkes::tf::Vector3",tolua_collect_fawkes__tf__Point);
05374     #else
05375     tolua_cclass(tolua_S,"Point","fawkes::tf::Point","fawkes::tf::Vector3",NULL);
05376     #endif
05377     tolua_beginmodule(tolua_S,"Point");
05378      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Point_new00);
05379      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Point_new00_local);
05380      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Point_new00_local);
05381      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Point_new01);
05382      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Point_new01_local);
05383      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Point_new01_local);
05384     tolua_endmodule(tolua_S);
05385     #ifdef __cplusplus
05386     tolua_cclass(tolua_S,"Pose","fawkes::tf::Pose","fawkes::tf::Transform",tolua_collect_fawkes__tf__Pose);
05387     #else
05388     tolua_cclass(tolua_S,"Pose","fawkes::tf::Pose","fawkes::tf::Transform",NULL);
05389     #endif
05390     tolua_beginmodule(tolua_S,"Pose");
05391      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Pose_new00);
05392      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Pose_new00_local);
05393      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Pose_new00_local);
05394      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Pose_new01);
05395      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Pose_new01_local);
05396      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Pose_new01_local);
05397      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Pose_new02);
05398      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Pose_new02_local);
05399      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Pose_new02_local);
05400      tolua_function(tolua_S,"getIdentity",tolua_fawkestf_fawkes_tf_Pose_getIdentity00);
05401     tolua_endmodule(tolua_S);
05402     #ifdef __cplusplus
05403     tolua_cclass(tolua_S,"StampedTransform","fawkes::tf::StampedTransform","fawkes::tf::Transform",tolua_collect_fawkes__tf__StampedTransform);
05404     #else
05405     tolua_cclass(tolua_S,"StampedTransform","fawkes::tf::StampedTransform","fawkes::tf::Transform",NULL);
05406     #endif
05407     tolua_beginmodule(tolua_S,"StampedTransform");
05408      tolua_variable(tolua_S,"stamp",tolua_get_fawkes__tf__StampedTransform_stamp,tolua_set_fawkes__tf__StampedTransform_stamp);
05409      tolua_variable(tolua_S,"frame_id",tolua_get_fawkes__tf__StampedTransform_frame_id,tolua_set_fawkes__tf__StampedTransform_frame_id);
05410      tolua_variable(tolua_S,"child_frame_id",tolua_get_fawkes__tf__StampedTransform_child_frame_id,tolua_set_fawkes__tf__StampedTransform_child_frame_id);
05411      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedTransform_new00);
05412      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedTransform_new00_local);
05413      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedTransform_new00_local);
05414      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedTransform_new01);
05415      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedTransform_new01_local);
05416      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedTransform_new01_local);
05417      tolua_function(tolua_S,"set_data",tolua_fawkestf_fawkes_tf_StampedTransform_set_data00);
05418     tolua_endmodule(tolua_S);
05419     #ifdef __cplusplus
05420     tolua_cclass(tolua_S,"Stamped_fawkes__tf__Quaternion_","fawkes::tf::Stamped<fawkes::tf::Quaternion>","fawkes::tf::Quaternion",tolua_collect_fawkes__tf__Stamped_fawkes__tf__Quaternion_);
05421     #else
05422     tolua_cclass(tolua_S,"Stamped_fawkes__tf__Quaternion_","fawkes::tf::Stamped<fawkes::tf::Quaternion>","fawkes::tf::Quaternion",NULL);
05423     #endif
05424     tolua_beginmodule(tolua_S,"Stamped_fawkes__tf__Quaternion_");
05425      tolua_variable(tolua_S,"stamp",tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp,tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp);
05426      tolua_variable(tolua_S,"frame_id",tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id,tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id);
05427      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00);
05428      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00_local);
05429      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00_local);
05430      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01);
05431      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01_local);
05432      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01_local);
05433      tolua_function(tolua_S,"set_data",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__set_data00);
05434     tolua_endmodule(tolua_S);
05435     #ifdef __cplusplus
05436     tolua_cclass(tolua_S,"Stamped_fawkes__tf__Vector3_","fawkes::tf::Stamped<fawkes::tf::Vector3>","fawkes::tf::Vector3",tolua_collect_fawkes__tf__Stamped_fawkes__tf__Vector3_);
05437     #else
05438     tolua_cclass(tolua_S,"Stamped_fawkes__tf__Vector3_","fawkes::tf::Stamped<fawkes::tf::Vector3>","fawkes::tf::Vector3",NULL);
05439     #endif
05440     tolua_beginmodule(tolua_S,"Stamped_fawkes__tf__Vector3_");
05441      tolua_variable(tolua_S,"stamp",tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp,tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp);
05442      tolua_variable(tolua_S,"frame_id",tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id,tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id);
05443      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00);
05444      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00_local);
05445      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00_local);
05446      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01);
05447      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01_local);
05448      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01_local);
05449      tolua_function(tolua_S,"set_data",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__set_data00);
05450     tolua_endmodule(tolua_S);
05451     #ifdef __cplusplus
05452     tolua_cclass(tolua_S,"Stamped_fawkes__tf__Point_","fawkes::tf::Stamped<fawkes::tf::Point>","fawkes::tf::Point",tolua_collect_fawkes__tf__Stamped_fawkes__tf__Point_);
05453     #else
05454     tolua_cclass(tolua_S,"Stamped_fawkes__tf__Point_","fawkes::tf::Stamped<fawkes::tf::Point>","fawkes::tf::Point",NULL);
05455     #endif
05456     tolua_beginmodule(tolua_S,"Stamped_fawkes__tf__Point_");
05457      tolua_variable(tolua_S,"stamp",tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__stamp,tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__stamp);
05458      tolua_variable(tolua_S,"frame_id",tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__frame_id,tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__frame_id);
05459      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00);
05460      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00_local);
05461      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00_local);
05462      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01);
05463      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01_local);
05464      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01_local);
05465      tolua_function(tolua_S,"set_data",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__set_data00);
05466     tolua_endmodule(tolua_S);
05467     #ifdef __cplusplus
05468     tolua_cclass(tolua_S,"Stamped_fawkes__tf__Pose_","fawkes::tf::Stamped<fawkes::tf::Pose>","fawkes::tf::Pose",tolua_collect_fawkes__tf__Stamped_fawkes__tf__Pose_);
05469     #else
05470     tolua_cclass(tolua_S,"Stamped_fawkes__tf__Pose_","fawkes::tf::Stamped<fawkes::tf::Pose>","fawkes::tf::Pose",NULL);
05471     #endif
05472     tolua_beginmodule(tolua_S,"Stamped_fawkes__tf__Pose_");
05473      tolua_variable(tolua_S,"stamp",tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__stamp,tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__stamp);
05474      tolua_variable(tolua_S,"frame_id",tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id,tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id);
05475      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00);
05476      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00_local);
05477      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00_local);
05478      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01);
05479      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01_local);
05480      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01_local);
05481      tolua_function(tolua_S,"set_data",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__set_data00);
05482     tolua_endmodule(tolua_S);
05483     #ifdef __cplusplus
05484     tolua_cclass(tolua_S,"StampedQuaternion","fawkes::tf::StampedQuaternion","fawkes::tf::Stamped<fawkes::tf::Quaternion>",tolua_collect_fawkes__tf__StampedQuaternion);
05485     #else
05486     tolua_cclass(tolua_S,"StampedQuaternion","fawkes::tf::StampedQuaternion","fawkes::tf::Stamped<fawkes::tf::Quaternion>",NULL);
05487     #endif
05488     tolua_beginmodule(tolua_S,"StampedQuaternion");
05489      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedQuaternion_new00);
05490      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedQuaternion_new00_local);
05491      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedQuaternion_new00_local);
05492      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedQuaternion_new01);
05493      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedQuaternion_new01_local);
05494      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedQuaternion_new01_local);
05495     tolua_endmodule(tolua_S);
05496     #ifdef __cplusplus
05497     tolua_cclass(tolua_S,"StampedVector3","fawkes::tf::StampedVector3","fawkes::tf::Stamped<fawkes::tf::Vector3>",tolua_collect_fawkes__tf__StampedVector3);
05498     #else
05499     tolua_cclass(tolua_S,"StampedVector3","fawkes::tf::StampedVector3","fawkes::tf::Stamped<fawkes::tf::Vector3>",NULL);
05500     #endif
05501     tolua_beginmodule(tolua_S,"StampedVector3");
05502      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedVector3_new00);
05503      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedVector3_new00_local);
05504      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedVector3_new00_local);
05505      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedVector3_new01);
05506      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedVector3_new01_local);
05507      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedVector3_new01_local);
05508     tolua_endmodule(tolua_S);
05509     #ifdef __cplusplus
05510     tolua_cclass(tolua_S,"StampedPoint","fawkes::tf::StampedPoint","fawkes::tf::Stamped<fawkes::tf::Point>",tolua_collect_fawkes__tf__StampedPoint);
05511     #else
05512     tolua_cclass(tolua_S,"StampedPoint","fawkes::tf::StampedPoint","fawkes::tf::Stamped<fawkes::tf::Point>",NULL);
05513     #endif
05514     tolua_beginmodule(tolua_S,"StampedPoint");
05515      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedPoint_new00);
05516      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedPoint_new00_local);
05517      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedPoint_new00_local);
05518      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedPoint_new01);
05519      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedPoint_new01_local);
05520      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedPoint_new01_local);
05521     tolua_endmodule(tolua_S);
05522     #ifdef __cplusplus
05523     tolua_cclass(tolua_S,"StampedPose","fawkes::tf::StampedPose","fawkes::tf::Stamped<fawkes::tf::Pose>",tolua_collect_fawkes__tf__StampedPose);
05524     #else
05525     tolua_cclass(tolua_S,"StampedPose","fawkes::tf::StampedPose","fawkes::tf::Stamped<fawkes::tf::Pose>",NULL);
05526     #endif
05527     tolua_beginmodule(tolua_S,"StampedPose");
05528      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedPose_new00);
05529      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedPose_new00_local);
05530      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedPose_new00_local);
05531      tolua_function(tolua_S,"new",tolua_fawkestf_fawkes_tf_StampedPose_new01);
05532      tolua_function(tolua_S,"new_local",tolua_fawkestf_fawkes_tf_StampedPose_new01_local);
05533      tolua_function(tolua_S,".call",tolua_fawkestf_fawkes_tf_StampedPose_new01_local);
05534     tolua_endmodule(tolua_S);
05535     tolua_cclass(tolua_S,"Transformer","fawkes::tf::Transformer","",NULL);
05536     tolua_beginmodule(tolua_S,"Transformer");
05537      tolua_function(tolua_S,"clear",tolua_fawkestf_fawkes_tf_Transformer_clear00);
05538      tolua_function(tolua_S,"frame_exists",tolua_fawkestf_fawkes_tf_Transformer_frame_exists00);
05539      tolua_function(tolua_S,"lookup_transform",tolua_fawkestf_fawkes_tf_Transformer_lookup_transform00);
05540      tolua_function(tolua_S,"lookup_transform",tolua_fawkestf_fawkes_tf_Transformer_lookup_transform01);
05541      tolua_function(tolua_S,"lookup_transform",tolua_fawkestf_fawkes_tf_Transformer_lookup_transform02);
05542      tolua_function(tolua_S,"can_transform",tolua_fawkestf_fawkes_tf_Transformer_can_transform00);
05543      tolua_function(tolua_S,"can_transform",tolua_fawkestf_fawkes_tf_Transformer_can_transform01);
05544      tolua_function(tolua_S,"transform_quaternion",tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion00);
05545      tolua_function(tolua_S,"transform_vector",tolua_fawkestf_fawkes_tf_Transformer_transform_vector00);
05546      tolua_function(tolua_S,"transform_point",tolua_fawkestf_fawkes_tf_Transformer_transform_point00);
05547      tolua_function(tolua_S,"transform_pose",tolua_fawkestf_fawkes_tf_Transformer_transform_pose00);
05548      tolua_function(tolua_S,"transform_quaternion",tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion01);
05549      tolua_function(tolua_S,"transform_vector",tolua_fawkestf_fawkes_tf_Transformer_transform_vector01);
05550      tolua_function(tolua_S,"transform_point",tolua_fawkestf_fawkes_tf_Transformer_transform_point01);
05551      tolua_function(tolua_S,"transform_pose",tolua_fawkestf_fawkes_tf_Transformer_transform_pose01);
05552     tolua_endmodule(tolua_S);
05553    tolua_endmodule(tolua_S);
05554   tolua_endmodule(tolua_S);
05555  tolua_endmodule(tolua_S);
05556  return 1;
05557 }
05558 
05559 
05560 extern "C" {
05561 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
05562  TOLUA_API int luaopen_fawkestf (lua_State* tolua_S) {
05563  return tolua_fawkestf_open(tolua_S);
05564 };
05565 #endif
05566 }
05567 
05568