fawkesgeometry_tolua.cpp

00001 /*
00002 ** Lua binding: fawkesgeometry
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_fawkesgeometry_open (lua_State* tolua_S);
00028 
00029 #include <geometry/hom_coord.h>
00030 #include <geometry/transformable.h>
00031 #include <geometry/hom_vector.h>
00032 #include <geometry/hom_point.h>
00033 #include <geometry/hom_transform.h>
00034 #include <geometry/matrix.h>
00035 #include <geometry/hom_vector.h>
00036 #include <geometry/hom_point.h>
00037 #include <geometry/hom_pose_2d.h>
00038 #include <geometry/hom_coord.h>
00039 #include <geometry/hom_coord.h>
00040 #include <geometry/hom_vector.h>
00041 
00042 /* function to release collected object via destructor */
00043 #ifdef __cplusplus
00044 
00045 static int tolua_collect_fawkes__HomTransform (lua_State* tolua_S)
00046 {
00047  fawkes::HomTransform* self = (fawkes::HomTransform*) tolua_tousertype(tolua_S,1,0);
00048         Mtolua_delete(self);
00049         return 0;
00050 }
00051 
00052 static int tolua_collect_fawkes__HomPoint (lua_State* tolua_S)
00053 {
00054  fawkes::HomPoint* self = (fawkes::HomPoint*) tolua_tousertype(tolua_S,1,0);
00055         Mtolua_delete(self);
00056         return 0;
00057 }
00058 
00059 static int tolua_collect_fawkes__HomCoord (lua_State* tolua_S)
00060 {
00061  fawkes::HomCoord* self = (fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
00062         Mtolua_delete(self);
00063         return 0;
00064 }
00065 
00066 static int tolua_collect_fawkes__HomVector (lua_State* tolua_S)
00067 {
00068  fawkes::HomVector* self = (fawkes::HomVector*) tolua_tousertype(tolua_S,1,0);
00069         Mtolua_delete(self);
00070         return 0;
00071 }
00072 
00073 static int tolua_collect_fawkes__HomPose2d (lua_State* tolua_S)
00074 {
00075  fawkes::HomPose2d* self = (fawkes::HomPose2d*) tolua_tousertype(tolua_S,1,0);
00076         Mtolua_delete(self);
00077         return 0;
00078 }
00079 #endif
00080 
00081 
00082 /* function to register type */
00083 static void tolua_reg_types (lua_State* tolua_S)
00084 {
00085  tolua_usertype(tolua_S,"fawkes::HomPose2d");
00086  tolua_usertype(tolua_S,"fawkes::HomPoint");
00087  tolua_usertype(tolua_S,"fawkes::Matrix");
00088  tolua_usertype(tolua_S,"Printable");
00089  tolua_usertype(tolua_S,"fawkes::HomCoord");
00090  tolua_usertype(tolua_S,"fawkes::HomVector");
00091  tolua_usertype(tolua_S,"fawkes::HomTransform");
00092  tolua_usertype(tolua_S,"Transformable");
00093 }
00094 
00095 /* method: new of class  fawkes::HomCoord */
00096 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_new00
00097 static int tolua_fawkesgeometry_fawkes_HomCoord_new00(lua_State* tolua_S)
00098 {
00099 #ifndef TOLUA_RELEASE
00100  tolua_Error tolua_err;
00101  if (
00102      !tolua_isusertable(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
00103      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
00104      !tolua_isnoobj(tolua_S,3,&tolua_err)
00105  )
00106   goto tolua_lerror;
00107  else
00108 #endif
00109  {
00110   const fawkes::HomCoord* c = ((const fawkes::HomCoord*)  tolua_tousertype(tolua_S,2,0));
00111   {
00112    fawkes::HomCoord* tolua_ret = (fawkes::HomCoord*)  Mtolua_new((fawkes::HomCoord)(*c));
00113     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomCoord");
00114   }
00115  }
00116  return 1;
00117 #ifndef TOLUA_RELEASE
00118  tolua_lerror:
00119  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00120  return 0;
00121 #endif
00122 }
00123 #endif //#ifndef TOLUA_DISABLE
00124 
00125 /* method: new_local of class  fawkes::HomCoord */
00126 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_new00_local
00127 static int tolua_fawkesgeometry_fawkes_HomCoord_new00_local(lua_State* tolua_S)
00128 {
00129 #ifndef TOLUA_RELEASE
00130  tolua_Error tolua_err;
00131  if (
00132      !tolua_isusertable(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
00133      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
00134      !tolua_isnoobj(tolua_S,3,&tolua_err)
00135  )
00136   goto tolua_lerror;
00137  else
00138 #endif
00139  {
00140   const fawkes::HomCoord* c = ((const fawkes::HomCoord*)  tolua_tousertype(tolua_S,2,0));
00141   {
00142    fawkes::HomCoord* tolua_ret = (fawkes::HomCoord*)  Mtolua_new((fawkes::HomCoord)(*c));
00143     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomCoord");
00144     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00145   }
00146  }
00147  return 1;
00148 #ifndef TOLUA_RELEASE
00149  tolua_lerror:
00150  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00151  return 0;
00152 #endif
00153 }
00154 #endif //#ifndef TOLUA_DISABLE
00155 
00156 /* method: delete of class  fawkes::HomCoord */
00157 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_delete00
00158 static int tolua_fawkesgeometry_fawkes_HomCoord_delete00(lua_State* tolua_S)
00159 {
00160 #ifndef TOLUA_RELEASE
00161  tolua_Error tolua_err;
00162  if (
00163      !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
00164      !tolua_isnoobj(tolua_S,2,&tolua_err)
00165  )
00166   goto tolua_lerror;
00167  else
00168 #endif
00169  {
00170   fawkes::HomCoord* self = (fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00171 #ifndef TOLUA_RELEASE
00172   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00173 #endif
00174   Mtolua_delete(self);
00175  }
00176  return 0;
00177 #ifndef TOLUA_RELEASE
00178  tolua_lerror:
00179  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00180  return 0;
00181 #endif
00182 }
00183 #endif //#ifndef TOLUA_DISABLE
00184 
00185 /* method: x of class  fawkes::HomCoord */
00186 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_x00
00187 static int tolua_fawkesgeometry_fawkes_HomCoord_x00(lua_State* tolua_S)
00188 {
00189 #ifndef TOLUA_RELEASE
00190  tolua_Error tolua_err;
00191  if (
00192      !tolua_isusertype(tolua_S,1,"const fawkes::HomCoord",0,&tolua_err) ||
00193      !tolua_isnoobj(tolua_S,2,&tolua_err)
00194  )
00195   goto tolua_lerror;
00196  else
00197 #endif
00198  {
00199   const fawkes::HomCoord* self = (const fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00200 #ifndef TOLUA_RELEASE
00201   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
00202 #endif
00203   {
00204    float tolua_ret = (float)  self->x();
00205    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00206   }
00207  }
00208  return 1;
00209 #ifndef TOLUA_RELEASE
00210  tolua_lerror:
00211  tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
00212  return 0;
00213 #endif
00214 }
00215 #endif //#ifndef TOLUA_DISABLE
00216 
00217 /* method: x of class  fawkes::HomCoord */
00218 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_x01
00219 static int tolua_fawkesgeometry_fawkes_HomCoord_x01(lua_State* tolua_S)
00220 {
00221  tolua_Error tolua_err;
00222  if (
00223      !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
00224      !tolua_isnoobj(tolua_S,2,&tolua_err)
00225  )
00226   goto tolua_lerror;
00227  else
00228  {
00229   fawkes::HomCoord* self = (fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00230 #ifndef TOLUA_RELEASE
00231   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
00232 #endif
00233   {
00234    float tolua_ret = (float)  self->x();
00235    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00236   }
00237  }
00238  return 1;
00239 tolua_lerror:
00240  return tolua_fawkesgeometry_fawkes_HomCoord_x00(tolua_S);
00241 }
00242 #endif //#ifndef TOLUA_DISABLE
00243 
00244 /* method: x of class  fawkes::HomCoord */
00245 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_x02
00246 static int tolua_fawkesgeometry_fawkes_HomCoord_x02(lua_State* tolua_S)
00247 {
00248  tolua_Error tolua_err;
00249  if (
00250      !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
00251      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00252      !tolua_isnoobj(tolua_S,3,&tolua_err)
00253  )
00254   goto tolua_lerror;
00255  else
00256  {
00257   fawkes::HomCoord* self = (fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00258   float x = ((float)  tolua_tonumber(tolua_S,2,0));
00259 #ifndef TOLUA_RELEASE
00260   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
00261 #endif
00262   {
00263    fawkes::HomCoord& tolua_ret = (fawkes::HomCoord&)  self->x(x);
00264     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomCoord");
00265   }
00266  }
00267  return 1;
00268 tolua_lerror:
00269  return tolua_fawkesgeometry_fawkes_HomCoord_x01(tolua_S);
00270 }
00271 #endif //#ifndef TOLUA_DISABLE
00272 
00273 /* method: y of class  fawkes::HomCoord */
00274 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_y00
00275 static int tolua_fawkesgeometry_fawkes_HomCoord_y00(lua_State* tolua_S)
00276 {
00277 #ifndef TOLUA_RELEASE
00278  tolua_Error tolua_err;
00279  if (
00280      !tolua_isusertype(tolua_S,1,"const fawkes::HomCoord",0,&tolua_err) ||
00281      !tolua_isnoobj(tolua_S,2,&tolua_err)
00282  )
00283   goto tolua_lerror;
00284  else
00285 #endif
00286  {
00287   const fawkes::HomCoord* self = (const fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00288 #ifndef TOLUA_RELEASE
00289   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
00290 #endif
00291   {
00292    float tolua_ret = (float)  self->y();
00293    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00294   }
00295  }
00296  return 1;
00297 #ifndef TOLUA_RELEASE
00298  tolua_lerror:
00299  tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
00300  return 0;
00301 #endif
00302 }
00303 #endif //#ifndef TOLUA_DISABLE
00304 
00305 /* method: y of class  fawkes::HomCoord */
00306 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_y01
00307 static int tolua_fawkesgeometry_fawkes_HomCoord_y01(lua_State* tolua_S)
00308 {
00309  tolua_Error tolua_err;
00310  if (
00311      !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
00312      !tolua_isnoobj(tolua_S,2,&tolua_err)
00313  )
00314   goto tolua_lerror;
00315  else
00316  {
00317   fawkes::HomCoord* self = (fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00318 #ifndef TOLUA_RELEASE
00319   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
00320 #endif
00321   {
00322    float tolua_ret = (float)  self->y();
00323    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00324   }
00325  }
00326  return 1;
00327 tolua_lerror:
00328  return tolua_fawkesgeometry_fawkes_HomCoord_y00(tolua_S);
00329 }
00330 #endif //#ifndef TOLUA_DISABLE
00331 
00332 /* method: y of class  fawkes::HomCoord */
00333 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_y02
00334 static int tolua_fawkesgeometry_fawkes_HomCoord_y02(lua_State* tolua_S)
00335 {
00336  tolua_Error tolua_err;
00337  if (
00338      !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
00339      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00340      !tolua_isnoobj(tolua_S,3,&tolua_err)
00341  )
00342   goto tolua_lerror;
00343  else
00344  {
00345   fawkes::HomCoord* self = (fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00346   float y = ((float)  tolua_tonumber(tolua_S,2,0));
00347 #ifndef TOLUA_RELEASE
00348   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
00349 #endif
00350   {
00351    fawkes::HomCoord& tolua_ret = (fawkes::HomCoord&)  self->y(y);
00352     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomCoord");
00353   }
00354  }
00355  return 1;
00356 tolua_lerror:
00357  return tolua_fawkesgeometry_fawkes_HomCoord_y01(tolua_S);
00358 }
00359 #endif //#ifndef TOLUA_DISABLE
00360 
00361 /* method: z of class  fawkes::HomCoord */
00362 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_z00
00363 static int tolua_fawkesgeometry_fawkes_HomCoord_z00(lua_State* tolua_S)
00364 {
00365 #ifndef TOLUA_RELEASE
00366  tolua_Error tolua_err;
00367  if (
00368      !tolua_isusertype(tolua_S,1,"const fawkes::HomCoord",0,&tolua_err) ||
00369      !tolua_isnoobj(tolua_S,2,&tolua_err)
00370  )
00371   goto tolua_lerror;
00372  else
00373 #endif
00374  {
00375   const fawkes::HomCoord* self = (const fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00376 #ifndef TOLUA_RELEASE
00377   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'z'", NULL);
00378 #endif
00379   {
00380    float tolua_ret = (float)  self->z();
00381    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00382   }
00383  }
00384  return 1;
00385 #ifndef TOLUA_RELEASE
00386  tolua_lerror:
00387  tolua_error(tolua_S,"#ferror in function 'z'.",&tolua_err);
00388  return 0;
00389 #endif
00390 }
00391 #endif //#ifndef TOLUA_DISABLE
00392 
00393 /* method: z of class  fawkes::HomCoord */
00394 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_z01
00395 static int tolua_fawkesgeometry_fawkes_HomCoord_z01(lua_State* tolua_S)
00396 {
00397  tolua_Error tolua_err;
00398  if (
00399      !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
00400      !tolua_isnoobj(tolua_S,2,&tolua_err)
00401  )
00402   goto tolua_lerror;
00403  else
00404  {
00405   fawkes::HomCoord* self = (fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00406 #ifndef TOLUA_RELEASE
00407   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'z'", NULL);
00408 #endif
00409   {
00410    float tolua_ret = (float)  self->z();
00411    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00412   }
00413  }
00414  return 1;
00415 tolua_lerror:
00416  return tolua_fawkesgeometry_fawkes_HomCoord_z00(tolua_S);
00417 }
00418 #endif //#ifndef TOLUA_DISABLE
00419 
00420 /* method: z of class  fawkes::HomCoord */
00421 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_z02
00422 static int tolua_fawkesgeometry_fawkes_HomCoord_z02(lua_State* tolua_S)
00423 {
00424  tolua_Error tolua_err;
00425  if (
00426      !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
00427      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00428      !tolua_isnoobj(tolua_S,3,&tolua_err)
00429  )
00430   goto tolua_lerror;
00431  else
00432  {
00433   fawkes::HomCoord* self = (fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00434   float z = ((float)  tolua_tonumber(tolua_S,2,0));
00435 #ifndef TOLUA_RELEASE
00436   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'z'", NULL);
00437 #endif
00438   {
00439    fawkes::HomCoord& tolua_ret = (fawkes::HomCoord&)  self->z(z);
00440     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomCoord");
00441   }
00442  }
00443  return 1;
00444 tolua_lerror:
00445  return tolua_fawkesgeometry_fawkes_HomCoord_z01(tolua_S);
00446 }
00447 #endif //#ifndef TOLUA_DISABLE
00448 
00449 /* method: w of class  fawkes::HomCoord */
00450 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_w00
00451 static int tolua_fawkesgeometry_fawkes_HomCoord_w00(lua_State* tolua_S)
00452 {
00453 #ifndef TOLUA_RELEASE
00454  tolua_Error tolua_err;
00455  if (
00456      !tolua_isusertype(tolua_S,1,"const fawkes::HomCoord",0,&tolua_err) ||
00457      !tolua_isnoobj(tolua_S,2,&tolua_err)
00458  )
00459   goto tolua_lerror;
00460  else
00461 #endif
00462  {
00463   const fawkes::HomCoord* self = (const fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00464 #ifndef TOLUA_RELEASE
00465   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'w'", NULL);
00466 #endif
00467   {
00468    float tolua_ret = (float)  self->w();
00469    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00470   }
00471  }
00472  return 1;
00473 #ifndef TOLUA_RELEASE
00474  tolua_lerror:
00475  tolua_error(tolua_S,"#ferror in function 'w'.",&tolua_err);
00476  return 0;
00477 #endif
00478 }
00479 #endif //#ifndef TOLUA_DISABLE
00480 
00481 /* method: w of class  fawkes::HomCoord */
00482 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_w01
00483 static int tolua_fawkesgeometry_fawkes_HomCoord_w01(lua_State* tolua_S)
00484 {
00485  tolua_Error tolua_err;
00486  if (
00487      !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
00488      !tolua_isnoobj(tolua_S,2,&tolua_err)
00489  )
00490   goto tolua_lerror;
00491  else
00492  {
00493   fawkes::HomCoord* self = (fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00494 #ifndef TOLUA_RELEASE
00495   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'w'", NULL);
00496 #endif
00497   {
00498    float tolua_ret = (float)  self->w();
00499    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00500   }
00501  }
00502  return 1;
00503 tolua_lerror:
00504  return tolua_fawkesgeometry_fawkes_HomCoord_w00(tolua_S);
00505 }
00506 #endif //#ifndef TOLUA_DISABLE
00507 
00508 /* method: w of class  fawkes::HomCoord */
00509 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_w02
00510 static int tolua_fawkesgeometry_fawkes_HomCoord_w02(lua_State* tolua_S)
00511 {
00512  tolua_Error tolua_err;
00513  if (
00514      !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
00515      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00516      !tolua_isnoobj(tolua_S,3,&tolua_err)
00517  )
00518   goto tolua_lerror;
00519  else
00520  {
00521   fawkes::HomCoord* self = (fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00522   float w = ((float)  tolua_tonumber(tolua_S,2,0));
00523 #ifndef TOLUA_RELEASE
00524   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'w'", NULL);
00525 #endif
00526   {
00527    fawkes::HomCoord& tolua_ret = (fawkes::HomCoord&)  self->w(w);
00528     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomCoord");
00529   }
00530  }
00531  return 1;
00532 tolua_lerror:
00533  return tolua_fawkesgeometry_fawkes_HomCoord_w01(tolua_S);
00534 }
00535 #endif //#ifndef TOLUA_DISABLE
00536 
00537 /* method: rotate_x of class  fawkes::HomCoord */
00538 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_rotate_x00
00539 static int tolua_fawkesgeometry_fawkes_HomCoord_rotate_x00(lua_State* tolua_S)
00540 {
00541 #ifndef TOLUA_RELEASE
00542  tolua_Error tolua_err;
00543  if (
00544      !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
00545      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00546      !tolua_isnoobj(tolua_S,3,&tolua_err)
00547  )
00548   goto tolua_lerror;
00549  else
00550 #endif
00551  {
00552   fawkes::HomCoord* self = (fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00553   float rad = ((float)  tolua_tonumber(tolua_S,2,0));
00554 #ifndef TOLUA_RELEASE
00555   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotate_x'", NULL);
00556 #endif
00557   {
00558    fawkes::HomCoord& tolua_ret = (fawkes::HomCoord&)  self->rotate_x(rad);
00559     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomCoord");
00560   }
00561  }
00562  return 1;
00563 #ifndef TOLUA_RELEASE
00564  tolua_lerror:
00565  tolua_error(tolua_S,"#ferror in function 'rotate_x'.",&tolua_err);
00566  return 0;
00567 #endif
00568 }
00569 #endif //#ifndef TOLUA_DISABLE
00570 
00571 /* method: rotate_y of class  fawkes::HomCoord */
00572 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_rotate_y00
00573 static int tolua_fawkesgeometry_fawkes_HomCoord_rotate_y00(lua_State* tolua_S)
00574 {
00575 #ifndef TOLUA_RELEASE
00576  tolua_Error tolua_err;
00577  if (
00578      !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
00579      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00580      !tolua_isnoobj(tolua_S,3,&tolua_err)
00581  )
00582   goto tolua_lerror;
00583  else
00584 #endif
00585  {
00586   fawkes::HomCoord* self = (fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00587   float rad = ((float)  tolua_tonumber(tolua_S,2,0));
00588 #ifndef TOLUA_RELEASE
00589   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotate_y'", NULL);
00590 #endif
00591   {
00592    fawkes::HomCoord& tolua_ret = (fawkes::HomCoord&)  self->rotate_y(rad);
00593     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomCoord");
00594   }
00595  }
00596  return 1;
00597 #ifndef TOLUA_RELEASE
00598  tolua_lerror:
00599  tolua_error(tolua_S,"#ferror in function 'rotate_y'.",&tolua_err);
00600  return 0;
00601 #endif
00602 }
00603 #endif //#ifndef TOLUA_DISABLE
00604 
00605 /* method: rotate_z of class  fawkes::HomCoord */
00606 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_rotate_z00
00607 static int tolua_fawkesgeometry_fawkes_HomCoord_rotate_z00(lua_State* tolua_S)
00608 {
00609 #ifndef TOLUA_RELEASE
00610  tolua_Error tolua_err;
00611  if (
00612      !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
00613      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00614      !tolua_isnoobj(tolua_S,3,&tolua_err)
00615  )
00616   goto tolua_lerror;
00617  else
00618 #endif
00619  {
00620   fawkes::HomCoord* self = (fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00621   float rad = ((float)  tolua_tonumber(tolua_S,2,0));
00622 #ifndef TOLUA_RELEASE
00623   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotate_z'", NULL);
00624 #endif
00625   {
00626    fawkes::HomCoord& tolua_ret = (fawkes::HomCoord&)  self->rotate_z(rad);
00627     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomCoord");
00628   }
00629  }
00630  return 1;
00631 #ifndef TOLUA_RELEASE
00632  tolua_lerror:
00633  tolua_error(tolua_S,"#ferror in function 'rotate_z'.",&tolua_err);
00634  return 0;
00635 #endif
00636 }
00637 #endif //#ifndef TOLUA_DISABLE
00638 
00639 /* method: transform of class  fawkes::HomCoord */
00640 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_transform00
00641 static int tolua_fawkesgeometry_fawkes_HomCoord_transform00(lua_State* tolua_S)
00642 {
00643 #ifndef TOLUA_RELEASE
00644  tolua_Error tolua_err;
00645  if (
00646      !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
00647      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomTransform",0,&tolua_err)) ||
00648      !tolua_isnoobj(tolua_S,3,&tolua_err)
00649  )
00650   goto tolua_lerror;
00651  else
00652 #endif
00653  {
00654   fawkes::HomCoord* self = (fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00655   const fawkes::HomTransform* t = ((const fawkes::HomTransform*)  tolua_tousertype(tolua_S,2,0));
00656 #ifndef TOLUA_RELEASE
00657   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'transform'", NULL);
00658 #endif
00659   {
00660    fawkes::HomCoord& tolua_ret = (fawkes::HomCoord&)  self->transform(*t);
00661     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomCoord");
00662   }
00663  }
00664  return 1;
00665 #ifndef TOLUA_RELEASE
00666  tolua_lerror:
00667  tolua_error(tolua_S,"#ferror in function 'transform'.",&tolua_err);
00668  return 0;
00669 #endif
00670 }
00671 #endif //#ifndef TOLUA_DISABLE
00672 
00673 /* method: operator- of class  fawkes::HomCoord */
00674 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord__sub00
00675 static int tolua_fawkesgeometry_fawkes_HomCoord__sub00(lua_State* tolua_S)
00676 {
00677 #ifndef TOLUA_RELEASE
00678  tolua_Error tolua_err;
00679  if (
00680      !tolua_isusertype(tolua_S,1,"const fawkes::HomCoord",0,&tolua_err) ||
00681      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
00682      !tolua_isnoobj(tolua_S,3,&tolua_err)
00683  )
00684   goto tolua_lerror;
00685  else
00686 #endif
00687  {
00688   const fawkes::HomCoord* self = (const fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00689   const fawkes::HomCoord* h = ((const fawkes::HomCoord*)  tolua_tousertype(tolua_S,2,0));
00690 #ifndef TOLUA_RELEASE
00691   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'", NULL);
00692 #endif
00693   {
00694    fawkes::HomCoord tolua_ret = (fawkes::HomCoord)  self->operator-(*h);
00695    {
00696 #ifdef __cplusplus
00697     void* tolua_obj = Mtolua_new((fawkes::HomCoord)(tolua_ret));
00698      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomCoord");
00699     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00700 #else
00701     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomCoord));
00702      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomCoord");
00703     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00704 #endif
00705    }
00706   }
00707  }
00708  return 1;
00709 #ifndef TOLUA_RELEASE
00710  tolua_lerror:
00711  tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
00712  return 0;
00713 #endif
00714 }
00715 #endif //#ifndef TOLUA_DISABLE
00716 
00717 /* method: operator+ of class  fawkes::HomCoord */
00718 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord__add00
00719 static int tolua_fawkesgeometry_fawkes_HomCoord__add00(lua_State* tolua_S)
00720 {
00721 #ifndef TOLUA_RELEASE
00722  tolua_Error tolua_err;
00723  if (
00724      !tolua_isusertype(tolua_S,1,"const fawkes::HomCoord",0,&tolua_err) ||
00725      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
00726      !tolua_isnoobj(tolua_S,3,&tolua_err)
00727  )
00728   goto tolua_lerror;
00729  else
00730 #endif
00731  {
00732   const fawkes::HomCoord* self = (const fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00733   const fawkes::HomCoord* h = ((const fawkes::HomCoord*)  tolua_tousertype(tolua_S,2,0));
00734 #ifndef TOLUA_RELEASE
00735   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'", NULL);
00736 #endif
00737   {
00738    fawkes::HomCoord tolua_ret = (fawkes::HomCoord)  self->operator+(*h);
00739    {
00740 #ifdef __cplusplus
00741     void* tolua_obj = Mtolua_new((fawkes::HomCoord)(tolua_ret));
00742      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomCoord");
00743     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00744 #else
00745     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomCoord));
00746      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomCoord");
00747     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00748 #endif
00749    }
00750   }
00751  }
00752  return 1;
00753 #ifndef TOLUA_RELEASE
00754  tolua_lerror:
00755  tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err);
00756  return 0;
00757 #endif
00758 }
00759 #endif //#ifndef TOLUA_DISABLE
00760 
00761 /* method: operator* of class  fawkes::HomCoord */
00762 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord__mul00
00763 static int tolua_fawkesgeometry_fawkes_HomCoord__mul00(lua_State* tolua_S)
00764 {
00765 #ifndef TOLUA_RELEASE
00766  tolua_Error tolua_err;
00767  if (
00768      !tolua_isusertype(tolua_S,1,"const fawkes::HomCoord",0,&tolua_err) ||
00769      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
00770      !tolua_isnoobj(tolua_S,3,&tolua_err)
00771  )
00772   goto tolua_lerror;
00773  else
00774 #endif
00775  {
00776   const fawkes::HomCoord* self = (const fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00777   const fawkes::HomCoord* h = ((const fawkes::HomCoord*)  tolua_tousertype(tolua_S,2,0));
00778 #ifndef TOLUA_RELEASE
00779   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", NULL);
00780 #endif
00781   {
00782    float tolua_ret = (float)  self->operator*(*h);
00783    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00784   }
00785  }
00786  return 1;
00787 #ifndef TOLUA_RELEASE
00788  tolua_lerror:
00789  tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err);
00790  return 0;
00791 #endif
00792 }
00793 #endif //#ifndef TOLUA_DISABLE
00794 
00795 /* method: operator* of class  fawkes::HomCoord */
00796 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord__mul01
00797 static int tolua_fawkesgeometry_fawkes_HomCoord__mul01(lua_State* tolua_S)
00798 {
00799  tolua_Error tolua_err;
00800  if (
00801      !tolua_isusertype(tolua_S,1,"const fawkes::HomCoord",0,&tolua_err) ||
00802      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00803      !tolua_isnoobj(tolua_S,3,&tolua_err)
00804  )
00805   goto tolua_lerror;
00806  else
00807  {
00808   const fawkes::HomCoord* self = (const fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00809   const float s = ((const float)  tolua_tonumber(tolua_S,2,0));
00810 #ifndef TOLUA_RELEASE
00811   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", NULL);
00812 #endif
00813   {
00814    fawkes::HomCoord tolua_ret = (fawkes::HomCoord)  self->operator*(s);
00815    {
00816 #ifdef __cplusplus
00817     void* tolua_obj = Mtolua_new((fawkes::HomCoord)(tolua_ret));
00818      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomCoord");
00819     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00820 #else
00821     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomCoord));
00822      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomCoord");
00823     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00824 #endif
00825    }
00826   }
00827  }
00828  return 1;
00829 tolua_lerror:
00830  return tolua_fawkesgeometry_fawkes_HomCoord__mul00(tolua_S);
00831 }
00832 #endif //#ifndef TOLUA_DISABLE
00833 
00834 /* method: operator== of class  fawkes::HomCoord */
00835 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord__eq00
00836 static int tolua_fawkesgeometry_fawkes_HomCoord__eq00(lua_State* tolua_S)
00837 {
00838 #ifndef TOLUA_RELEASE
00839  tolua_Error tolua_err;
00840  if (
00841      !tolua_isusertype(tolua_S,1,"const fawkes::HomCoord",0,&tolua_err) ||
00842      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
00843      !tolua_isnoobj(tolua_S,3,&tolua_err)
00844  )
00845   goto tolua_lerror;
00846  else
00847 #endif
00848  {
00849   const fawkes::HomCoord* self = (const fawkes::HomCoord*)  tolua_tousertype(tolua_S,1,0);
00850   const fawkes::HomCoord* h = ((const fawkes::HomCoord*)  tolua_tousertype(tolua_S,2,0));
00851 #ifndef TOLUA_RELEASE
00852   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
00853 #endif
00854   {
00855    bool tolua_ret = (bool)  self->operator==(*h);
00856    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00857   }
00858  }
00859  return 1;
00860 #ifndef TOLUA_RELEASE
00861  tolua_lerror:
00862  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
00863  return 0;
00864 #endif
00865 }
00866 #endif //#ifndef TOLUA_DISABLE
00867 
00868 /* method: new of class  fawkes::HomPose2d */
00869 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_new00
00870 static int tolua_fawkesgeometry_fawkes_HomPose2d_new00(lua_State* tolua_S)
00871 {
00872 #ifndef TOLUA_RELEASE
00873  tolua_Error tolua_err;
00874  if (
00875      !tolua_isusertable(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
00876      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPoint",0,&tolua_err)) ||
00877      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::HomVector",0,&tolua_err)) ||
00878      !tolua_isnoobj(tolua_S,4,&tolua_err)
00879  )
00880   goto tolua_lerror;
00881  else
00882 #endif
00883  {
00884   const fawkes::HomPoint* pos = ((const fawkes::HomPoint*)  tolua_tousertype(tolua_S,2,0));
00885   const fawkes::HomVector* orientation = ((const fawkes::HomVector*)  tolua_tousertype(tolua_S,3,0));
00886   {
00887    fawkes::HomPose2d* tolua_ret = (fawkes::HomPose2d*)  Mtolua_new((fawkes::HomPose2d)(*pos,*orientation));
00888     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPose2d");
00889   }
00890  }
00891  return 1;
00892 #ifndef TOLUA_RELEASE
00893  tolua_lerror:
00894  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00895  return 0;
00896 #endif
00897 }
00898 #endif //#ifndef TOLUA_DISABLE
00899 
00900 /* method: new_local of class  fawkes::HomPose2d */
00901 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_new00_local
00902 static int tolua_fawkesgeometry_fawkes_HomPose2d_new00_local(lua_State* tolua_S)
00903 {
00904 #ifndef TOLUA_RELEASE
00905  tolua_Error tolua_err;
00906  if (
00907      !tolua_isusertable(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
00908      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPoint",0,&tolua_err)) ||
00909      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::HomVector",0,&tolua_err)) ||
00910      !tolua_isnoobj(tolua_S,4,&tolua_err)
00911  )
00912   goto tolua_lerror;
00913  else
00914 #endif
00915  {
00916   const fawkes::HomPoint* pos = ((const fawkes::HomPoint*)  tolua_tousertype(tolua_S,2,0));
00917   const fawkes::HomVector* orientation = ((const fawkes::HomVector*)  tolua_tousertype(tolua_S,3,0));
00918   {
00919    fawkes::HomPose2d* tolua_ret = (fawkes::HomPose2d*)  Mtolua_new((fawkes::HomPose2d)(*pos,*orientation));
00920     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPose2d");
00921     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00922   }
00923  }
00924  return 1;
00925 #ifndef TOLUA_RELEASE
00926  tolua_lerror:
00927  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00928  return 0;
00929 #endif
00930 }
00931 #endif //#ifndef TOLUA_DISABLE
00932 
00933 /* method: new of class  fawkes::HomPose2d */
00934 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_new01
00935 static int tolua_fawkesgeometry_fawkes_HomPose2d_new01(lua_State* tolua_S)
00936 {
00937  tolua_Error tolua_err;
00938  if (
00939      !tolua_isusertable(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
00940      !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
00941      !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
00942      !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
00943      !tolua_isnoobj(tolua_S,5,&tolua_err)
00944  )
00945   goto tolua_lerror;
00946  else
00947  {
00948   float x = ((float)  tolua_tonumber(tolua_S,2,0.0));
00949   float y = ((float)  tolua_tonumber(tolua_S,3,0.0));
00950   float yaw = ((float)  tolua_tonumber(tolua_S,4,0.0));
00951   {
00952    fawkes::HomPose2d* tolua_ret = (fawkes::HomPose2d*)  Mtolua_new((fawkes::HomPose2d)(x,y,yaw));
00953     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPose2d");
00954   }
00955  }
00956  return 1;
00957 tolua_lerror:
00958  return tolua_fawkesgeometry_fawkes_HomPose2d_new00(tolua_S);
00959 }
00960 #endif //#ifndef TOLUA_DISABLE
00961 
00962 /* method: new_local of class  fawkes::HomPose2d */
00963 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_new01_local
00964 static int tolua_fawkesgeometry_fawkes_HomPose2d_new01_local(lua_State* tolua_S)
00965 {
00966  tolua_Error tolua_err;
00967  if (
00968      !tolua_isusertable(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
00969      !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
00970      !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
00971      !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
00972      !tolua_isnoobj(tolua_S,5,&tolua_err)
00973  )
00974   goto tolua_lerror;
00975  else
00976  {
00977   float x = ((float)  tolua_tonumber(tolua_S,2,0.0));
00978   float y = ((float)  tolua_tonumber(tolua_S,3,0.0));
00979   float yaw = ((float)  tolua_tonumber(tolua_S,4,0.0));
00980   {
00981    fawkes::HomPose2d* tolua_ret = (fawkes::HomPose2d*)  Mtolua_new((fawkes::HomPose2d)(x,y,yaw));
00982     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPose2d");
00983     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00984   }
00985  }
00986  return 1;
00987 tolua_lerror:
00988  return tolua_fawkesgeometry_fawkes_HomPose2d_new00_local(tolua_S);
00989 }
00990 #endif //#ifndef TOLUA_DISABLE
00991 
00992 /* method: new of class  fawkes::HomPose2d */
00993 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_new02
00994 static int tolua_fawkesgeometry_fawkes_HomPose2d_new02(lua_State* tolua_S)
00995 {
00996  tolua_Error tolua_err;
00997  if (
00998      !tolua_isusertable(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
00999      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPose2d",0,&tolua_err)) ||
01000      !tolua_isnoobj(tolua_S,3,&tolua_err)
01001  )
01002   goto tolua_lerror;
01003  else
01004  {
01005   const fawkes::HomPose2d* p = ((const fawkes::HomPose2d*)  tolua_tousertype(tolua_S,2,0));
01006   {
01007    fawkes::HomPose2d* tolua_ret = (fawkes::HomPose2d*)  Mtolua_new((fawkes::HomPose2d)(*p));
01008     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPose2d");
01009   }
01010  }
01011  return 1;
01012 tolua_lerror:
01013  return tolua_fawkesgeometry_fawkes_HomPose2d_new01(tolua_S);
01014 }
01015 #endif //#ifndef TOLUA_DISABLE
01016 
01017 /* method: new_local of class  fawkes::HomPose2d */
01018 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_new02_local
01019 static int tolua_fawkesgeometry_fawkes_HomPose2d_new02_local(lua_State* tolua_S)
01020 {
01021  tolua_Error tolua_err;
01022  if (
01023      !tolua_isusertable(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
01024      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPose2d",0,&tolua_err)) ||
01025      !tolua_isnoobj(tolua_S,3,&tolua_err)
01026  )
01027   goto tolua_lerror;
01028  else
01029  {
01030   const fawkes::HomPose2d* p = ((const fawkes::HomPose2d*)  tolua_tousertype(tolua_S,2,0));
01031   {
01032    fawkes::HomPose2d* tolua_ret = (fawkes::HomPose2d*)  Mtolua_new((fawkes::HomPose2d)(*p));
01033     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPose2d");
01034     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01035   }
01036  }
01037  return 1;
01038 tolua_lerror:
01039  return tolua_fawkesgeometry_fawkes_HomPose2d_new01_local(tolua_S);
01040 }
01041 #endif //#ifndef TOLUA_DISABLE
01042 
01043 /* method: delete of class  fawkes::HomPose2d */
01044 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_delete00
01045 static int tolua_fawkesgeometry_fawkes_HomPose2d_delete00(lua_State* tolua_S)
01046 {
01047 #ifndef TOLUA_RELEASE
01048  tolua_Error tolua_err;
01049  if (
01050      !tolua_isusertype(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
01051      !tolua_isnoobj(tolua_S,2,&tolua_err)
01052  )
01053   goto tolua_lerror;
01054  else
01055 #endif
01056  {
01057   fawkes::HomPose2d* self = (fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01058 #ifndef TOLUA_RELEASE
01059   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01060 #endif
01061   Mtolua_delete(self);
01062  }
01063  return 0;
01064 #ifndef TOLUA_RELEASE
01065  tolua_lerror:
01066  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01067  return 0;
01068 #endif
01069 }
01070 #endif //#ifndef TOLUA_DISABLE
01071 
01072 /* method: x of class  fawkes::HomPose2d */
01073 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_x00
01074 static int tolua_fawkesgeometry_fawkes_HomPose2d_x00(lua_State* tolua_S)
01075 {
01076 #ifndef TOLUA_RELEASE
01077  tolua_Error tolua_err;
01078  if (
01079      !tolua_isusertype(tolua_S,1,"const fawkes::HomPose2d",0,&tolua_err) ||
01080      !tolua_isnoobj(tolua_S,2,&tolua_err)
01081  )
01082   goto tolua_lerror;
01083  else
01084 #endif
01085  {
01086   const fawkes::HomPose2d* self = (const fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01087 #ifndef TOLUA_RELEASE
01088   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
01089 #endif
01090   {
01091    float tolua_ret = (float)  self->x();
01092    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01093   }
01094  }
01095  return 1;
01096 #ifndef TOLUA_RELEASE
01097  tolua_lerror:
01098  tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
01099  return 0;
01100 #endif
01101 }
01102 #endif //#ifndef TOLUA_DISABLE
01103 
01104 /* method: x of class  fawkes::HomPose2d */
01105 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_x01
01106 static int tolua_fawkesgeometry_fawkes_HomPose2d_x01(lua_State* tolua_S)
01107 {
01108  tolua_Error tolua_err;
01109  if (
01110      !tolua_isusertype(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
01111      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01112      !tolua_isnoobj(tolua_S,3,&tolua_err)
01113  )
01114   goto tolua_lerror;
01115  else
01116  {
01117   fawkes::HomPose2d* self = (fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01118   float x = ((float)  tolua_tonumber(tolua_S,2,0));
01119 #ifndef TOLUA_RELEASE
01120   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
01121 #endif
01122   {
01123    self->x(x);
01124   }
01125  }
01126  return 0;
01127 tolua_lerror:
01128  return tolua_fawkesgeometry_fawkes_HomPose2d_x00(tolua_S);
01129 }
01130 #endif //#ifndef TOLUA_DISABLE
01131 
01132 /* method: y of class  fawkes::HomPose2d */
01133 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_y00
01134 static int tolua_fawkesgeometry_fawkes_HomPose2d_y00(lua_State* tolua_S)
01135 {
01136 #ifndef TOLUA_RELEASE
01137  tolua_Error tolua_err;
01138  if (
01139      !tolua_isusertype(tolua_S,1,"const fawkes::HomPose2d",0,&tolua_err) ||
01140      !tolua_isnoobj(tolua_S,2,&tolua_err)
01141  )
01142   goto tolua_lerror;
01143  else
01144 #endif
01145  {
01146   const fawkes::HomPose2d* self = (const fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01147 #ifndef TOLUA_RELEASE
01148   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
01149 #endif
01150   {
01151    float tolua_ret = (float)  self->y();
01152    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01153   }
01154  }
01155  return 1;
01156 #ifndef TOLUA_RELEASE
01157  tolua_lerror:
01158  tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
01159  return 0;
01160 #endif
01161 }
01162 #endif //#ifndef TOLUA_DISABLE
01163 
01164 /* method: y of class  fawkes::HomPose2d */
01165 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_y01
01166 static int tolua_fawkesgeometry_fawkes_HomPose2d_y01(lua_State* tolua_S)
01167 {
01168  tolua_Error tolua_err;
01169  if (
01170      !tolua_isusertype(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
01171      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01172      !tolua_isnoobj(tolua_S,3,&tolua_err)
01173  )
01174   goto tolua_lerror;
01175  else
01176  {
01177   fawkes::HomPose2d* self = (fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01178   float y = ((float)  tolua_tonumber(tolua_S,2,0));
01179 #ifndef TOLUA_RELEASE
01180   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
01181 #endif
01182   {
01183    self->y(y);
01184   }
01185  }
01186  return 0;
01187 tolua_lerror:
01188  return tolua_fawkesgeometry_fawkes_HomPose2d_y00(tolua_S);
01189 }
01190 #endif //#ifndef TOLUA_DISABLE
01191 
01192 /* method: yaw of class  fawkes::HomPose2d */
01193 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_yaw00
01194 static int tolua_fawkesgeometry_fawkes_HomPose2d_yaw00(lua_State* tolua_S)
01195 {
01196 #ifndef TOLUA_RELEASE
01197  tolua_Error tolua_err;
01198  if (
01199      !tolua_isusertype(tolua_S,1,"const fawkes::HomPose2d",0,&tolua_err) ||
01200      !tolua_isnoobj(tolua_S,2,&tolua_err)
01201  )
01202   goto tolua_lerror;
01203  else
01204 #endif
01205  {
01206   const fawkes::HomPose2d* self = (const fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01207 #ifndef TOLUA_RELEASE
01208   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'yaw'", NULL);
01209 #endif
01210   {
01211    float tolua_ret = (float)  self->yaw();
01212    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01213   }
01214  }
01215  return 1;
01216 #ifndef TOLUA_RELEASE
01217  tolua_lerror:
01218  tolua_error(tolua_S,"#ferror in function 'yaw'.",&tolua_err);
01219  return 0;
01220 #endif
01221 }
01222 #endif //#ifndef TOLUA_DISABLE
01223 
01224 /* method: yaw of class  fawkes::HomPose2d */
01225 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_yaw01
01226 static int tolua_fawkesgeometry_fawkes_HomPose2d_yaw01(lua_State* tolua_S)
01227 {
01228  tolua_Error tolua_err;
01229  if (
01230      !tolua_isusertype(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
01231      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01232      !tolua_isnoobj(tolua_S,3,&tolua_err)
01233  )
01234   goto tolua_lerror;
01235  else
01236  {
01237   fawkes::HomPose2d* self = (fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01238   float yaw = ((float)  tolua_tonumber(tolua_S,2,0));
01239 #ifndef TOLUA_RELEASE
01240   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'yaw'", NULL);
01241 #endif
01242   {
01243    self->yaw(yaw);
01244   }
01245  }
01246  return 0;
01247 tolua_lerror:
01248  return tolua_fawkesgeometry_fawkes_HomPose2d_yaw00(tolua_S);
01249 }
01250 #endif //#ifndef TOLUA_DISABLE
01251 
01252 /* method: position of class  fawkes::HomPose2d */
01253 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_position00
01254 static int tolua_fawkesgeometry_fawkes_HomPose2d_position00(lua_State* tolua_S)
01255 {
01256 #ifndef TOLUA_RELEASE
01257  tolua_Error tolua_err;
01258  if (
01259      !tolua_isusertype(tolua_S,1,"const fawkes::HomPose2d",0,&tolua_err) ||
01260      !tolua_isnoobj(tolua_S,2,&tolua_err)
01261  )
01262   goto tolua_lerror;
01263  else
01264 #endif
01265  {
01266   const fawkes::HomPose2d* self = (const fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01267 #ifndef TOLUA_RELEASE
01268   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'position'", NULL);
01269 #endif
01270   {
01271    const fawkes::HomPoint& tolua_ret = (const fawkes::HomPoint&)  self->position();
01272     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const fawkes::HomPoint");
01273   }
01274  }
01275  return 1;
01276 #ifndef TOLUA_RELEASE
01277  tolua_lerror:
01278  tolua_error(tolua_S,"#ferror in function 'position'.",&tolua_err);
01279  return 0;
01280 #endif
01281 }
01282 #endif //#ifndef TOLUA_DISABLE
01283 
01284 /* method: orientation of class  fawkes::HomPose2d */
01285 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_orientation00
01286 static int tolua_fawkesgeometry_fawkes_HomPose2d_orientation00(lua_State* tolua_S)
01287 {
01288 #ifndef TOLUA_RELEASE
01289  tolua_Error tolua_err;
01290  if (
01291      !tolua_isusertype(tolua_S,1,"const fawkes::HomPose2d",0,&tolua_err) ||
01292      !tolua_isnoobj(tolua_S,2,&tolua_err)
01293  )
01294   goto tolua_lerror;
01295  else
01296 #endif
01297  {
01298   const fawkes::HomPose2d* self = (const fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01299 #ifndef TOLUA_RELEASE
01300   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'orientation'", NULL);
01301 #endif
01302   {
01303    const fawkes::HomVector& tolua_ret = (const fawkes::HomVector&)  self->orientation();
01304     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const fawkes::HomVector");
01305   }
01306  }
01307  return 1;
01308 #ifndef TOLUA_RELEASE
01309  tolua_lerror:
01310  tolua_error(tolua_S,"#ferror in function 'orientation'.",&tolua_err);
01311  return 0;
01312 #endif
01313 }
01314 #endif //#ifndef TOLUA_DISABLE
01315 
01316 /* method: set_position of class  fawkes::HomPose2d */
01317 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_set_position00
01318 static int tolua_fawkesgeometry_fawkes_HomPose2d_set_position00(lua_State* tolua_S)
01319 {
01320 #ifndef TOLUA_RELEASE
01321  tolua_Error tolua_err;
01322  if (
01323      !tolua_isusertype(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
01324      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPoint",0,&tolua_err)) ||
01325      !tolua_isnoobj(tolua_S,3,&tolua_err)
01326  )
01327   goto tolua_lerror;
01328  else
01329 #endif
01330  {
01331   fawkes::HomPose2d* self = (fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01332   const fawkes::HomPoint* p = ((const fawkes::HomPoint*)  tolua_tousertype(tolua_S,2,0));
01333 #ifndef TOLUA_RELEASE
01334   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_position'", NULL);
01335 #endif
01336   {
01337    self->set_position(*p);
01338   }
01339  }
01340  return 0;
01341 #ifndef TOLUA_RELEASE
01342  tolua_lerror:
01343  tolua_error(tolua_S,"#ferror in function 'set_position'.",&tolua_err);
01344  return 0;
01345 #endif
01346 }
01347 #endif //#ifndef TOLUA_DISABLE
01348 
01349 /* method: new of class  fawkes::HomTransform */
01350 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_new00
01351 static int tolua_fawkesgeometry_fawkes_HomTransform_new00(lua_State* tolua_S)
01352 {
01353 #ifndef TOLUA_RELEASE
01354  tolua_Error tolua_err;
01355  if (
01356      !tolua_isusertable(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01357      !tolua_isnoobj(tolua_S,2,&tolua_err)
01358  )
01359   goto tolua_lerror;
01360  else
01361 #endif
01362  {
01363   {
01364    fawkes::HomTransform* tolua_ret = (fawkes::HomTransform*)  Mtolua_new((fawkes::HomTransform)());
01365     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomTransform");
01366   }
01367  }
01368  return 1;
01369 #ifndef TOLUA_RELEASE
01370  tolua_lerror:
01371  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01372  return 0;
01373 #endif
01374 }
01375 #endif //#ifndef TOLUA_DISABLE
01376 
01377 /* method: new_local of class  fawkes::HomTransform */
01378 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_new00_local
01379 static int tolua_fawkesgeometry_fawkes_HomTransform_new00_local(lua_State* tolua_S)
01380 {
01381 #ifndef TOLUA_RELEASE
01382  tolua_Error tolua_err;
01383  if (
01384      !tolua_isusertable(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01385      !tolua_isnoobj(tolua_S,2,&tolua_err)
01386  )
01387   goto tolua_lerror;
01388  else
01389 #endif
01390  {
01391   {
01392    fawkes::HomTransform* tolua_ret = (fawkes::HomTransform*)  Mtolua_new((fawkes::HomTransform)());
01393     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomTransform");
01394     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01395   }
01396  }
01397  return 1;
01398 #ifndef TOLUA_RELEASE
01399  tolua_lerror:
01400  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01401  return 0;
01402 #endif
01403 }
01404 #endif //#ifndef TOLUA_DISABLE
01405 
01406 /* method: new of class  fawkes::HomTransform */
01407 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_new01
01408 static int tolua_fawkesgeometry_fawkes_HomTransform_new01(lua_State* tolua_S)
01409 {
01410  tolua_Error tolua_err;
01411  if (
01412      !tolua_isusertable(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01413      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomTransform",0,&tolua_err)) ||
01414      !tolua_isnoobj(tolua_S,3,&tolua_err)
01415  )
01416   goto tolua_lerror;
01417  else
01418  {
01419   const fawkes::HomTransform* ht = ((const fawkes::HomTransform*)  tolua_tousertype(tolua_S,2,0));
01420   {
01421    fawkes::HomTransform* tolua_ret = (fawkes::HomTransform*)  Mtolua_new((fawkes::HomTransform)(*ht));
01422     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomTransform");
01423   }
01424  }
01425  return 1;
01426 tolua_lerror:
01427  return tolua_fawkesgeometry_fawkes_HomTransform_new00(tolua_S);
01428 }
01429 #endif //#ifndef TOLUA_DISABLE
01430 
01431 /* method: new_local of class  fawkes::HomTransform */
01432 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_new01_local
01433 static int tolua_fawkesgeometry_fawkes_HomTransform_new01_local(lua_State* tolua_S)
01434 {
01435  tolua_Error tolua_err;
01436  if (
01437      !tolua_isusertable(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01438      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomTransform",0,&tolua_err)) ||
01439      !tolua_isnoobj(tolua_S,3,&tolua_err)
01440  )
01441   goto tolua_lerror;
01442  else
01443  {
01444   const fawkes::HomTransform* ht = ((const fawkes::HomTransform*)  tolua_tousertype(tolua_S,2,0));
01445   {
01446    fawkes::HomTransform* tolua_ret = (fawkes::HomTransform*)  Mtolua_new((fawkes::HomTransform)(*ht));
01447     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomTransform");
01448     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01449   }
01450  }
01451  return 1;
01452 tolua_lerror:
01453  return tolua_fawkesgeometry_fawkes_HomTransform_new00_local(tolua_S);
01454 }
01455 #endif //#ifndef TOLUA_DISABLE
01456 
01457 /* method: new of class  fawkes::HomTransform */
01458 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_new02
01459 static int tolua_fawkesgeometry_fawkes_HomTransform_new02(lua_State* tolua_S)
01460 {
01461  tolua_Error tolua_err;
01462  if (
01463      !tolua_isusertable(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01464      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Matrix",0,&tolua_err)) ||
01465      !tolua_isnoobj(tolua_S,3,&tolua_err)
01466  )
01467   goto tolua_lerror;
01468  else
01469  {
01470   const fawkes::Matrix* m = ((const fawkes::Matrix*)  tolua_tousertype(tolua_S,2,0));
01471   {
01472    fawkes::HomTransform* tolua_ret = (fawkes::HomTransform*)  Mtolua_new((fawkes::HomTransform)(*m));
01473     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomTransform");
01474   }
01475  }
01476  return 1;
01477 tolua_lerror:
01478  return tolua_fawkesgeometry_fawkes_HomTransform_new01(tolua_S);
01479 }
01480 #endif //#ifndef TOLUA_DISABLE
01481 
01482 /* method: new_local of class  fawkes::HomTransform */
01483 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_new02_local
01484 static int tolua_fawkesgeometry_fawkes_HomTransform_new02_local(lua_State* tolua_S)
01485 {
01486  tolua_Error tolua_err;
01487  if (
01488      !tolua_isusertable(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01489      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Matrix",0,&tolua_err)) ||
01490      !tolua_isnoobj(tolua_S,3,&tolua_err)
01491  )
01492   goto tolua_lerror;
01493  else
01494  {
01495   const fawkes::Matrix* m = ((const fawkes::Matrix*)  tolua_tousertype(tolua_S,2,0));
01496   {
01497    fawkes::HomTransform* tolua_ret = (fawkes::HomTransform*)  Mtolua_new((fawkes::HomTransform)(*m));
01498     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomTransform");
01499     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01500   }
01501  }
01502  return 1;
01503 tolua_lerror:
01504  return tolua_fawkesgeometry_fawkes_HomTransform_new01_local(tolua_S);
01505 }
01506 #endif //#ifndef TOLUA_DISABLE
01507 
01508 /* method: delete of class  fawkes::HomTransform */
01509 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_delete00
01510 static int tolua_fawkesgeometry_fawkes_HomTransform_delete00(lua_State* tolua_S)
01511 {
01512 #ifndef TOLUA_RELEASE
01513  tolua_Error tolua_err;
01514  if (
01515      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01516      !tolua_isnoobj(tolua_S,2,&tolua_err)
01517  )
01518   goto tolua_lerror;
01519  else
01520 #endif
01521  {
01522   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01523 #ifndef TOLUA_RELEASE
01524   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01525 #endif
01526   Mtolua_delete(self);
01527  }
01528  return 0;
01529 #ifndef TOLUA_RELEASE
01530  tolua_lerror:
01531  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01532  return 0;
01533 #endif
01534 }
01535 #endif //#ifndef TOLUA_DISABLE
01536 
01537 /* method: reset of class  fawkes::HomTransform */
01538 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_reset00
01539 static int tolua_fawkesgeometry_fawkes_HomTransform_reset00(lua_State* tolua_S)
01540 {
01541 #ifndef TOLUA_RELEASE
01542  tolua_Error tolua_err;
01543  if (
01544      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01545      !tolua_isnoobj(tolua_S,2,&tolua_err)
01546  )
01547   goto tolua_lerror;
01548  else
01549 #endif
01550  {
01551   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01552 #ifndef TOLUA_RELEASE
01553   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reset'", NULL);
01554 #endif
01555   {
01556    fawkes::HomTransform& tolua_ret = (fawkes::HomTransform&)  self->reset();
01557     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomTransform");
01558   }
01559  }
01560  return 1;
01561 #ifndef TOLUA_RELEASE
01562  tolua_lerror:
01563  tolua_error(tolua_S,"#ferror in function 'reset'.",&tolua_err);
01564  return 0;
01565 #endif
01566 }
01567 #endif //#ifndef TOLUA_DISABLE
01568 
01569 /* method: invert of class  fawkes::HomTransform */
01570 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_invert00
01571 static int tolua_fawkesgeometry_fawkes_HomTransform_invert00(lua_State* tolua_S)
01572 {
01573 #ifndef TOLUA_RELEASE
01574  tolua_Error tolua_err;
01575  if (
01576      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01577      !tolua_isnoobj(tolua_S,2,&tolua_err)
01578  )
01579   goto tolua_lerror;
01580  else
01581 #endif
01582  {
01583   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01584 #ifndef TOLUA_RELEASE
01585   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'invert'", NULL);
01586 #endif
01587   {
01588    fawkes::HomTransform& tolua_ret = (fawkes::HomTransform&)  self->invert();
01589     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomTransform");
01590   }
01591  }
01592  return 1;
01593 #ifndef TOLUA_RELEASE
01594  tolua_lerror:
01595  tolua_error(tolua_S,"#ferror in function 'invert'.",&tolua_err);
01596  return 0;
01597 #endif
01598 }
01599 #endif //#ifndef TOLUA_DISABLE
01600 
01601 /* method: get_inverse of class  fawkes::HomTransform */
01602 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_get_inverse00
01603 static int tolua_fawkesgeometry_fawkes_HomTransform_get_inverse00(lua_State* tolua_S)
01604 {
01605 #ifndef TOLUA_RELEASE
01606  tolua_Error tolua_err;
01607  if (
01608      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01609      !tolua_isnoobj(tolua_S,2,&tolua_err)
01610  )
01611   goto tolua_lerror;
01612  else
01613 #endif
01614  {
01615   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01616 #ifndef TOLUA_RELEASE
01617   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_inverse'", NULL);
01618 #endif
01619   {
01620    fawkes::HomTransform tolua_ret = (fawkes::HomTransform)  self->get_inverse();
01621    {
01622 #ifdef __cplusplus
01623     void* tolua_obj = Mtolua_new((fawkes::HomTransform)(tolua_ret));
01624      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomTransform");
01625     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01626 #else
01627     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomTransform));
01628      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomTransform");
01629     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01630 #endif
01631    }
01632   }
01633  }
01634  return 1;
01635 #ifndef TOLUA_RELEASE
01636  tolua_lerror:
01637  tolua_error(tolua_S,"#ferror in function 'get_inverse'.",&tolua_err);
01638  return 0;
01639 #endif
01640 }
01641 #endif //#ifndef TOLUA_DISABLE
01642 
01643 /* method: rotate_x of class  fawkes::HomTransform */
01644 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_rotate_x00
01645 static int tolua_fawkesgeometry_fawkes_HomTransform_rotate_x00(lua_State* tolua_S)
01646 {
01647 #ifndef TOLUA_RELEASE
01648  tolua_Error tolua_err;
01649  if (
01650      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01651      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01652      !tolua_isnoobj(tolua_S,3,&tolua_err)
01653  )
01654   goto tolua_lerror;
01655  else
01656 #endif
01657  {
01658   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01659   float rad = ((float)  tolua_tonumber(tolua_S,2,0));
01660 #ifndef TOLUA_RELEASE
01661   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotate_x'", NULL);
01662 #endif
01663   {
01664    self->rotate_x(rad);
01665   }
01666  }
01667  return 0;
01668 #ifndef TOLUA_RELEASE
01669  tolua_lerror:
01670  tolua_error(tolua_S,"#ferror in function 'rotate_x'.",&tolua_err);
01671  return 0;
01672 #endif
01673 }
01674 #endif //#ifndef TOLUA_DISABLE
01675 
01676 /* method: rotate_y of class  fawkes::HomTransform */
01677 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_rotate_y00
01678 static int tolua_fawkesgeometry_fawkes_HomTransform_rotate_y00(lua_State* tolua_S)
01679 {
01680 #ifndef TOLUA_RELEASE
01681  tolua_Error tolua_err;
01682  if (
01683      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01684      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01685      !tolua_isnoobj(tolua_S,3,&tolua_err)
01686  )
01687   goto tolua_lerror;
01688  else
01689 #endif
01690  {
01691   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01692   float rad = ((float)  tolua_tonumber(tolua_S,2,0));
01693 #ifndef TOLUA_RELEASE
01694   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotate_y'", NULL);
01695 #endif
01696   {
01697    self->rotate_y(rad);
01698   }
01699  }
01700  return 0;
01701 #ifndef TOLUA_RELEASE
01702  tolua_lerror:
01703  tolua_error(tolua_S,"#ferror in function 'rotate_y'.",&tolua_err);
01704  return 0;
01705 #endif
01706 }
01707 #endif //#ifndef TOLUA_DISABLE
01708 
01709 /* method: rotate_z of class  fawkes::HomTransform */
01710 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_rotate_z00
01711 static int tolua_fawkesgeometry_fawkes_HomTransform_rotate_z00(lua_State* tolua_S)
01712 {
01713 #ifndef TOLUA_RELEASE
01714  tolua_Error tolua_err;
01715  if (
01716      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01717      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01718      !tolua_isnoobj(tolua_S,3,&tolua_err)
01719  )
01720   goto tolua_lerror;
01721  else
01722 #endif
01723  {
01724   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01725   float rad = ((float)  tolua_tonumber(tolua_S,2,0));
01726 #ifndef TOLUA_RELEASE
01727   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotate_z'", NULL);
01728 #endif
01729   {
01730    self->rotate_z(rad);
01731   }
01732  }
01733  return 0;
01734 #ifndef TOLUA_RELEASE
01735  tolua_lerror:
01736  tolua_error(tolua_S,"#ferror in function 'rotate_z'.",&tolua_err);
01737  return 0;
01738 #endif
01739 }
01740 #endif //#ifndef TOLUA_DISABLE
01741 
01742 /* method: trans of class  fawkes::HomTransform */
01743 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_trans00
01744 static int tolua_fawkesgeometry_fawkes_HomTransform_trans00(lua_State* tolua_S)
01745 {
01746 #ifndef TOLUA_RELEASE
01747  tolua_Error tolua_err;
01748  if (
01749      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01750      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01751      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01752      !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
01753      !tolua_isnoobj(tolua_S,5,&tolua_err)
01754  )
01755   goto tolua_lerror;
01756  else
01757 #endif
01758  {
01759   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01760   float dx = ((float)  tolua_tonumber(tolua_S,2,0));
01761   float dy = ((float)  tolua_tonumber(tolua_S,3,0));
01762   float dz = ((float)  tolua_tonumber(tolua_S,4,0.0));
01763 #ifndef TOLUA_RELEASE
01764   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'trans'", NULL);
01765 #endif
01766   {
01767    self->trans(dx,dy,dz);
01768   }
01769  }
01770  return 0;
01771 #ifndef TOLUA_RELEASE
01772  tolua_lerror:
01773  tolua_error(tolua_S,"#ferror in function 'trans'.",&tolua_err);
01774  return 0;
01775 #endif
01776 }
01777 #endif //#ifndef TOLUA_DISABLE
01778 
01779 /* method: set_trans of class  fawkes::HomTransform */
01780 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_set_trans00
01781 static int tolua_fawkesgeometry_fawkes_HomTransform_set_trans00(lua_State* tolua_S)
01782 {
01783 #ifndef TOLUA_RELEASE
01784  tolua_Error tolua_err;
01785  if (
01786      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01787      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01788      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01789      !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
01790      !tolua_isnoobj(tolua_S,5,&tolua_err)
01791  )
01792   goto tolua_lerror;
01793  else
01794 #endif
01795  {
01796   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01797   float x = ((float)  tolua_tonumber(tolua_S,2,0));
01798   float y = ((float)  tolua_tonumber(tolua_S,3,0));
01799   float z = ((float)  tolua_tonumber(tolua_S,4,0.0));
01800 #ifndef TOLUA_RELEASE
01801   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_trans'", NULL);
01802 #endif
01803   {
01804    self->set_trans(x,y,z);
01805   }
01806  }
01807  return 0;
01808 #ifndef TOLUA_RELEASE
01809  tolua_lerror:
01810  tolua_error(tolua_S,"#ferror in function 'set_trans'.",&tolua_err);
01811  return 0;
01812 #endif
01813 }
01814 #endif //#ifndef TOLUA_DISABLE
01815 
01816 /* method: mDH of class  fawkes::HomTransform */
01817 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_mDH00
01818 static int tolua_fawkesgeometry_fawkes_HomTransform_mDH00(lua_State* tolua_S)
01819 {
01820 #ifndef TOLUA_RELEASE
01821  tolua_Error tolua_err;
01822  if (
01823      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01824      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01825      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01826      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01827      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
01828      !tolua_isnoobj(tolua_S,6,&tolua_err)
01829  )
01830   goto tolua_lerror;
01831  else
01832 #endif
01833  {
01834   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01835   const float alpha = ((const float)  tolua_tonumber(tolua_S,2,0));
01836   const float a = ((const float)  tolua_tonumber(tolua_S,3,0));
01837   const float theta = ((const float)  tolua_tonumber(tolua_S,4,0));
01838   const float d = ((const float)  tolua_tonumber(tolua_S,5,0));
01839 #ifndef TOLUA_RELEASE
01840   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mDH'", NULL);
01841 #endif
01842   {
01843    self->mDH(alpha,a,theta,d);
01844   }
01845  }
01846  return 0;
01847 #ifndef TOLUA_RELEASE
01848  tolua_lerror:
01849  tolua_error(tolua_S,"#ferror in function 'mDH'.",&tolua_err);
01850  return 0;
01851 #endif
01852 }
01853 #endif //#ifndef TOLUA_DISABLE
01854 
01855 /* method: operator* of class  fawkes::HomTransform */
01856 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform__mul00
01857 static int tolua_fawkesgeometry_fawkes_HomTransform__mul00(lua_State* tolua_S)
01858 {
01859 #ifndef TOLUA_RELEASE
01860  tolua_Error tolua_err;
01861  if (
01862      !tolua_isusertype(tolua_S,1,"const fawkes::HomTransform",0,&tolua_err) ||
01863      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomVector",0,&tolua_err)) ||
01864      !tolua_isnoobj(tolua_S,3,&tolua_err)
01865  )
01866   goto tolua_lerror;
01867  else
01868 #endif
01869  {
01870   const fawkes::HomTransform* self = (const fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01871   const fawkes::HomVector* v = ((const fawkes::HomVector*)  tolua_tousertype(tolua_S,2,0));
01872 #ifndef TOLUA_RELEASE
01873   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", NULL);
01874 #endif
01875   {
01876    fawkes::HomVector tolua_ret = (fawkes::HomVector)  self->operator*(*v);
01877    {
01878 #ifdef __cplusplus
01879     void* tolua_obj = Mtolua_new((fawkes::HomVector)(tolua_ret));
01880      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomVector");
01881     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01882 #else
01883     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomVector));
01884      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomVector");
01885     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01886 #endif
01887    }
01888   }
01889  }
01890  return 1;
01891 #ifndef TOLUA_RELEASE
01892  tolua_lerror:
01893  tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err);
01894  return 0;
01895 #endif
01896 }
01897 #endif //#ifndef TOLUA_DISABLE
01898 
01899 /* method: operator* of class  fawkes::HomTransform */
01900 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform__mul01
01901 static int tolua_fawkesgeometry_fawkes_HomTransform__mul01(lua_State* tolua_S)
01902 {
01903  tolua_Error tolua_err;
01904  if (
01905      !tolua_isusertype(tolua_S,1,"const fawkes::HomTransform",0,&tolua_err) ||
01906      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPoint",0,&tolua_err)) ||
01907      !tolua_isnoobj(tolua_S,3,&tolua_err)
01908  )
01909   goto tolua_lerror;
01910  else
01911  {
01912   const fawkes::HomTransform* self = (const fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01913   const fawkes::HomPoint* p = ((const fawkes::HomPoint*)  tolua_tousertype(tolua_S,2,0));
01914 #ifndef TOLUA_RELEASE
01915   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", NULL);
01916 #endif
01917   {
01918    fawkes::HomPoint tolua_ret = (fawkes::HomPoint)  self->operator*(*p);
01919    {
01920 #ifdef __cplusplus
01921     void* tolua_obj = Mtolua_new((fawkes::HomPoint)(tolua_ret));
01922      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomPoint");
01923     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01924 #else
01925     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomPoint));
01926      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomPoint");
01927     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01928 #endif
01929    }
01930   }
01931  }
01932  return 1;
01933 tolua_lerror:
01934  return tolua_fawkesgeometry_fawkes_HomTransform__mul00(tolua_S);
01935 }
01936 #endif //#ifndef TOLUA_DISABLE
01937 
01938 /* method: operator* of class  fawkes::HomTransform */
01939 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform__mul02
01940 static int tolua_fawkesgeometry_fawkes_HomTransform__mul02(lua_State* tolua_S)
01941 {
01942  tolua_Error tolua_err;
01943  if (
01944      !tolua_isusertype(tolua_S,1,"const fawkes::HomTransform",0,&tolua_err) ||
01945      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPose2d",0,&tolua_err)) ||
01946      !tolua_isnoobj(tolua_S,3,&tolua_err)
01947  )
01948   goto tolua_lerror;
01949  else
01950  {
01951   const fawkes::HomTransform* self = (const fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01952   const fawkes::HomPose2d* p = ((const fawkes::HomPose2d*)  tolua_tousertype(tolua_S,2,0));
01953 #ifndef TOLUA_RELEASE
01954   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", NULL);
01955 #endif
01956   {
01957    fawkes::HomPose2d tolua_ret = (fawkes::HomPose2d)  self->operator*(*p);
01958    {
01959 #ifdef __cplusplus
01960     void* tolua_obj = Mtolua_new((fawkes::HomPose2d)(tolua_ret));
01961      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomPose2d");
01962     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01963 #else
01964     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomPose2d));
01965      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomPose2d");
01966     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01967 #endif
01968    }
01969   }
01970  }
01971  return 1;
01972 tolua_lerror:
01973  return tolua_fawkesgeometry_fawkes_HomTransform__mul01(tolua_S);
01974 }
01975 #endif //#ifndef TOLUA_DISABLE
01976 
01977 /* method: operator== of class  fawkes::HomTransform */
01978 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform__eq00
01979 static int tolua_fawkesgeometry_fawkes_HomTransform__eq00(lua_State* tolua_S)
01980 {
01981 #ifndef TOLUA_RELEASE
01982  tolua_Error tolua_err;
01983  if (
01984      !tolua_isusertype(tolua_S,1,"const fawkes::HomTransform",0,&tolua_err) ||
01985      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomTransform",0,&tolua_err)) ||
01986      !tolua_isnoobj(tolua_S,3,&tolua_err)
01987  )
01988   goto tolua_lerror;
01989  else
01990 #endif
01991  {
01992   const fawkes::HomTransform* self = (const fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01993   const fawkes::HomTransform* t = ((const fawkes::HomTransform*)  tolua_tousertype(tolua_S,2,0));
01994 #ifndef TOLUA_RELEASE
01995   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
01996 #endif
01997   {
01998    bool tolua_ret = (bool)  self->operator==(*t);
01999    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02000   }
02001  }
02002  return 1;
02003 #ifndef TOLUA_RELEASE
02004  tolua_lerror:
02005  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
02006  return 0;
02007 #endif
02008 }
02009 #endif //#ifndef TOLUA_DISABLE
02010 
02011 /* method: print_info of class  fawkes::HomTransform */
02012 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_print_info00
02013 static int tolua_fawkesgeometry_fawkes_HomTransform_print_info00(lua_State* tolua_S)
02014 {
02015 #ifndef TOLUA_RELEASE
02016  tolua_Error tolua_err;
02017  if (
02018      !tolua_isusertype(tolua_S,1,"const fawkes::HomTransform",0,&tolua_err) ||
02019      !tolua_isstring(tolua_S,2,1,&tolua_err) ||
02020      !tolua_isstring(tolua_S,3,1,&tolua_err) ||
02021      !tolua_isstring(tolua_S,4,1,&tolua_err) ||
02022      !tolua_isnoobj(tolua_S,5,&tolua_err)
02023  )
02024   goto tolua_lerror;
02025  else
02026 #endif
02027  {
02028   const fawkes::HomTransform* self = (const fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
02029   const char* name = ((const char*)  tolua_tostring(tolua_S,2,0));
02030   const char* col_sep = ((const char*)  tolua_tostring(tolua_S,3,0));
02031   const char* row_sep = ((const char*)  tolua_tostring(tolua_S,4,0));
02032 #ifndef TOLUA_RELEASE
02033   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'print_info'", NULL);
02034 #endif
02035   {
02036    self->print_info(name,col_sep,row_sep);
02037   }
02038  }
02039  return 0;
02040 #ifndef TOLUA_RELEASE
02041  tolua_lerror:
02042  tolua_error(tolua_S,"#ferror in function 'print_info'.",&tolua_err);
02043  return 0;
02044 #endif
02045 }
02046 #endif //#ifndef TOLUA_DISABLE
02047 
02048 /* method: get_matrix of class  fawkes::HomTransform */
02049 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_get_matrix00
02050 static int tolua_fawkesgeometry_fawkes_HomTransform_get_matrix00(lua_State* tolua_S)
02051 {
02052 #ifndef TOLUA_RELEASE
02053  tolua_Error tolua_err;
02054  if (
02055      !tolua_isusertype(tolua_S,1,"const fawkes::HomTransform",0,&tolua_err) ||
02056      !tolua_isnoobj(tolua_S,2,&tolua_err)
02057  )
02058   goto tolua_lerror;
02059  else
02060 #endif
02061  {
02062   const fawkes::HomTransform* self = (const fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
02063 #ifndef TOLUA_RELEASE
02064   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_matrix'", NULL);
02065 #endif
02066   {
02067    const fawkes::Matrix& tolua_ret = (const fawkes::Matrix&)  self->get_matrix();
02068     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const fawkes::Matrix");
02069   }
02070  }
02071  return 1;
02072 #ifndef TOLUA_RELEASE
02073  tolua_lerror:
02074  tolua_error(tolua_S,"#ferror in function 'get_matrix'.",&tolua_err);
02075  return 0;
02076 #endif
02077 }
02078 #endif //#ifndef TOLUA_DISABLE
02079 
02080 /* method: new of class  fawkes::HomVector */
02081 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_new00
02082 static int tolua_fawkesgeometry_fawkes_HomVector_new00(lua_State* tolua_S)
02083 {
02084 #ifndef TOLUA_RELEASE
02085  tolua_Error tolua_err;
02086  if (
02087      !tolua_isusertable(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
02088      !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
02089      !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
02090      !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
02091      !tolua_isnoobj(tolua_S,5,&tolua_err)
02092  )
02093   goto tolua_lerror;
02094  else
02095 #endif
02096  {
02097   float x = ((float)  tolua_tonumber(tolua_S,2,0));
02098   float y = ((float)  tolua_tonumber(tolua_S,3,0));
02099   float z = ((float)  tolua_tonumber(tolua_S,4,0));
02100   {
02101    fawkes::HomVector* tolua_ret = (fawkes::HomVector*)  Mtolua_new((fawkes::HomVector)(x,y,z));
02102     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomVector");
02103   }
02104  }
02105  return 1;
02106 #ifndef TOLUA_RELEASE
02107  tolua_lerror:
02108  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02109  return 0;
02110 #endif
02111 }
02112 #endif //#ifndef TOLUA_DISABLE
02113 
02114 /* method: new_local of class  fawkes::HomVector */
02115 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_new00_local
02116 static int tolua_fawkesgeometry_fawkes_HomVector_new00_local(lua_State* tolua_S)
02117 {
02118 #ifndef TOLUA_RELEASE
02119  tolua_Error tolua_err;
02120  if (
02121      !tolua_isusertable(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
02122      !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
02123      !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
02124      !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
02125      !tolua_isnoobj(tolua_S,5,&tolua_err)
02126  )
02127   goto tolua_lerror;
02128  else
02129 #endif
02130  {
02131   float x = ((float)  tolua_tonumber(tolua_S,2,0));
02132   float y = ((float)  tolua_tonumber(tolua_S,3,0));
02133   float z = ((float)  tolua_tonumber(tolua_S,4,0));
02134   {
02135    fawkes::HomVector* tolua_ret = (fawkes::HomVector*)  Mtolua_new((fawkes::HomVector)(x,y,z));
02136     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomVector");
02137     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02138   }
02139  }
02140  return 1;
02141 #ifndef TOLUA_RELEASE
02142  tolua_lerror:
02143  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02144  return 0;
02145 #endif
02146 }
02147 #endif //#ifndef TOLUA_DISABLE
02148 
02149 /* method: new of class  fawkes::HomVector */
02150 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_new01
02151 static int tolua_fawkesgeometry_fawkes_HomVector_new01(lua_State* tolua_S)
02152 {
02153  tolua_Error tolua_err;
02154  if (
02155      !tolua_isusertable(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
02156      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
02157      !tolua_isnoobj(tolua_S,3,&tolua_err)
02158  )
02159   goto tolua_lerror;
02160  else
02161  {
02162   const fawkes::HomCoord* h = ((const fawkes::HomCoord*)  tolua_tousertype(tolua_S,2,0));
02163   {
02164    fawkes::HomVector* tolua_ret = (fawkes::HomVector*)  Mtolua_new((fawkes::HomVector)(*h));
02165     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomVector");
02166   }
02167  }
02168  return 1;
02169 tolua_lerror:
02170  return tolua_fawkesgeometry_fawkes_HomVector_new00(tolua_S);
02171 }
02172 #endif //#ifndef TOLUA_DISABLE
02173 
02174 /* method: new_local of class  fawkes::HomVector */
02175 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_new01_local
02176 static int tolua_fawkesgeometry_fawkes_HomVector_new01_local(lua_State* tolua_S)
02177 {
02178  tolua_Error tolua_err;
02179  if (
02180      !tolua_isusertable(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
02181      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
02182      !tolua_isnoobj(tolua_S,3,&tolua_err)
02183  )
02184   goto tolua_lerror;
02185  else
02186  {
02187   const fawkes::HomCoord* h = ((const fawkes::HomCoord*)  tolua_tousertype(tolua_S,2,0));
02188   {
02189    fawkes::HomVector* tolua_ret = (fawkes::HomVector*)  Mtolua_new((fawkes::HomVector)(*h));
02190     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomVector");
02191     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02192   }
02193  }
02194  return 1;
02195 tolua_lerror:
02196  return tolua_fawkesgeometry_fawkes_HomVector_new00_local(tolua_S);
02197 }
02198 #endif //#ifndef TOLUA_DISABLE
02199 
02200 /* method: delete of class  fawkes::HomVector */
02201 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_delete00
02202 static int tolua_fawkesgeometry_fawkes_HomVector_delete00(lua_State* tolua_S)
02203 {
02204 #ifndef TOLUA_RELEASE
02205  tolua_Error tolua_err;
02206  if (
02207      !tolua_isusertype(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
02208      !tolua_isnoobj(tolua_S,2,&tolua_err)
02209  )
02210   goto tolua_lerror;
02211  else
02212 #endif
02213  {
02214   fawkes::HomVector* self = (fawkes::HomVector*)  tolua_tousertype(tolua_S,1,0);
02215 #ifndef TOLUA_RELEASE
02216   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
02217 #endif
02218   Mtolua_delete(self);
02219  }
02220  return 0;
02221 #ifndef TOLUA_RELEASE
02222  tolua_lerror:
02223  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02224  return 0;
02225 #endif
02226 }
02227 #endif //#ifndef TOLUA_DISABLE
02228 
02229 /* method: length of class  fawkes::HomVector */
02230 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_length00
02231 static int tolua_fawkesgeometry_fawkes_HomVector_length00(lua_State* tolua_S)
02232 {
02233 #ifndef TOLUA_RELEASE
02234  tolua_Error tolua_err;
02235  if (
02236      !tolua_isusertype(tolua_S,1,"const fawkes::HomVector",0,&tolua_err) ||
02237      !tolua_isnoobj(tolua_S,2,&tolua_err)
02238  )
02239   goto tolua_lerror;
02240  else
02241 #endif
02242  {
02243   const fawkes::HomVector* self = (const fawkes::HomVector*)  tolua_tousertype(tolua_S,1,0);
02244 #ifndef TOLUA_RELEASE
02245   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'length'", NULL);
02246 #endif
02247   {
02248    float tolua_ret = (float)  self->length();
02249    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02250   }
02251  }
02252  return 1;
02253 #ifndef TOLUA_RELEASE
02254  tolua_lerror:
02255  tolua_error(tolua_S,"#ferror in function 'length'.",&tolua_err);
02256  return 0;
02257 #endif
02258 }
02259 #endif //#ifndef TOLUA_DISABLE
02260 
02261 /* method: set_length of class  fawkes::HomVector */
02262 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_set_length00
02263 static int tolua_fawkesgeometry_fawkes_HomVector_set_length00(lua_State* tolua_S)
02264 {
02265 #ifndef TOLUA_RELEASE
02266  tolua_Error tolua_err;
02267  if (
02268      !tolua_isusertype(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
02269      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02270      !tolua_isnoobj(tolua_S,3,&tolua_err)
02271  )
02272   goto tolua_lerror;
02273  else
02274 #endif
02275  {
02276   fawkes::HomVector* self = (fawkes::HomVector*)  tolua_tousertype(tolua_S,1,0);
02277   float length = ((float)  tolua_tonumber(tolua_S,2,0));
02278 #ifndef TOLUA_RELEASE
02279   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_length'", NULL);
02280 #endif
02281   {
02282    fawkes::HomVector& tolua_ret = (fawkes::HomVector&)  self->set_length(length);
02283     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomVector");
02284   }
02285  }
02286  return 1;
02287 #ifndef TOLUA_RELEASE
02288  tolua_lerror:
02289  tolua_error(tolua_S,"#ferror in function 'set_length'.",&tolua_err);
02290  return 0;
02291 #endif
02292 }
02293 #endif //#ifndef TOLUA_DISABLE
02294 
02295 /* method: unit of class  fawkes::HomVector */
02296 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_unit00
02297 static int tolua_fawkesgeometry_fawkes_HomVector_unit00(lua_State* tolua_S)
02298 {
02299 #ifndef TOLUA_RELEASE
02300  tolua_Error tolua_err;
02301  if (
02302      !tolua_isusertype(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
02303      !tolua_isnoobj(tolua_S,2,&tolua_err)
02304  )
02305   goto tolua_lerror;
02306  else
02307 #endif
02308  {
02309   fawkes::HomVector* self = (fawkes::HomVector*)  tolua_tousertype(tolua_S,1,0);
02310 #ifndef TOLUA_RELEASE
02311   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unit'", NULL);
02312 #endif
02313   {
02314    fawkes::HomVector& tolua_ret = (fawkes::HomVector&)  self->unit();
02315     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomVector");
02316   }
02317  }
02318  return 1;
02319 #ifndef TOLUA_RELEASE
02320  tolua_lerror:
02321  tolua_error(tolua_S,"#ferror in function 'unit'.",&tolua_err);
02322  return 0;
02323 #endif
02324 }
02325 #endif //#ifndef TOLUA_DISABLE
02326 
02327 /* method: angle_xy of class  fawkes::HomVector */
02328 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_angle_xy00
02329 static int tolua_fawkesgeometry_fawkes_HomVector_angle_xy00(lua_State* tolua_S)
02330 {
02331 #ifndef TOLUA_RELEASE
02332  tolua_Error tolua_err;
02333  if (
02334      !tolua_isusertype(tolua_S,1,"const fawkes::HomVector",0,&tolua_err) ||
02335      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomVector",0,&tolua_err)) ||
02336      !tolua_isnoobj(tolua_S,3,&tolua_err)
02337  )
02338   goto tolua_lerror;
02339  else
02340 #endif
02341  {
02342   const fawkes::HomVector* self = (const fawkes::HomVector*)  tolua_tousertype(tolua_S,1,0);
02343   const fawkes::HomVector* h = ((const fawkes::HomVector*)  tolua_tousertype(tolua_S,2,0));
02344 #ifndef TOLUA_RELEASE
02345   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'angle_xy'", NULL);
02346 #endif
02347   {
02348    float tolua_ret = (float)  self->angle_xy(*h);
02349    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02350   }
02351  }
02352  return 1;
02353 #ifndef TOLUA_RELEASE
02354  tolua_lerror:
02355  tolua_error(tolua_S,"#ferror in function 'angle_xy'.",&tolua_err);
02356  return 0;
02357 #endif
02358 }
02359 #endif //#ifndef TOLUA_DISABLE
02360 
02361 /* method: new of class  fawkes::HomPoint */
02362 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_new00
02363 static int tolua_fawkesgeometry_fawkes_HomPoint_new00(lua_State* tolua_S)
02364 {
02365 #ifndef TOLUA_RELEASE
02366  tolua_Error tolua_err;
02367  if (
02368      !tolua_isusertable(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
02369      !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
02370      !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
02371      !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
02372      !tolua_isnoobj(tolua_S,5,&tolua_err)
02373  )
02374   goto tolua_lerror;
02375  else
02376 #endif
02377  {
02378   float x = ((float)  tolua_tonumber(tolua_S,2,0.0));
02379   float y = ((float)  tolua_tonumber(tolua_S,3,0.0));
02380   float z = ((float)  tolua_tonumber(tolua_S,4,0.0));
02381   {
02382    fawkes::HomPoint* tolua_ret = (fawkes::HomPoint*)  Mtolua_new((fawkes::HomPoint)(x,y,z));
02383     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPoint");
02384   }
02385  }
02386  return 1;
02387 #ifndef TOLUA_RELEASE
02388  tolua_lerror:
02389  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02390  return 0;
02391 #endif
02392 }
02393 #endif //#ifndef TOLUA_DISABLE
02394 
02395 /* method: new_local of class  fawkes::HomPoint */
02396 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_new00_local
02397 static int tolua_fawkesgeometry_fawkes_HomPoint_new00_local(lua_State* tolua_S)
02398 {
02399 #ifndef TOLUA_RELEASE
02400  tolua_Error tolua_err;
02401  if (
02402      !tolua_isusertable(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
02403      !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
02404      !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
02405      !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
02406      !tolua_isnoobj(tolua_S,5,&tolua_err)
02407  )
02408   goto tolua_lerror;
02409  else
02410 #endif
02411  {
02412   float x = ((float)  tolua_tonumber(tolua_S,2,0.0));
02413   float y = ((float)  tolua_tonumber(tolua_S,3,0.0));
02414   float z = ((float)  tolua_tonumber(tolua_S,4,0.0));
02415   {
02416    fawkes::HomPoint* tolua_ret = (fawkes::HomPoint*)  Mtolua_new((fawkes::HomPoint)(x,y,z));
02417     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPoint");
02418     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02419   }
02420  }
02421  return 1;
02422 #ifndef TOLUA_RELEASE
02423  tolua_lerror:
02424  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02425  return 0;
02426 #endif
02427 }
02428 #endif //#ifndef TOLUA_DISABLE
02429 
02430 /* method: new of class  fawkes::HomPoint */
02431 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_new01
02432 static int tolua_fawkesgeometry_fawkes_HomPoint_new01(lua_State* tolua_S)
02433 {
02434  tolua_Error tolua_err;
02435  if (
02436      !tolua_isusertable(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
02437      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
02438      !tolua_isnoobj(tolua_S,3,&tolua_err)
02439  )
02440   goto tolua_lerror;
02441  else
02442  {
02443   const fawkes::HomCoord* h = ((const fawkes::HomCoord*)  tolua_tousertype(tolua_S,2,0));
02444   {
02445    fawkes::HomPoint* tolua_ret = (fawkes::HomPoint*)  Mtolua_new((fawkes::HomPoint)(*h));
02446     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPoint");
02447   }
02448  }
02449  return 1;
02450 tolua_lerror:
02451  return tolua_fawkesgeometry_fawkes_HomPoint_new00(tolua_S);
02452 }
02453 #endif //#ifndef TOLUA_DISABLE
02454 
02455 /* method: new_local of class  fawkes::HomPoint */
02456 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_new01_local
02457 static int tolua_fawkesgeometry_fawkes_HomPoint_new01_local(lua_State* tolua_S)
02458 {
02459  tolua_Error tolua_err;
02460  if (
02461      !tolua_isusertable(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
02462      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
02463      !tolua_isnoobj(tolua_S,3,&tolua_err)
02464  )
02465   goto tolua_lerror;
02466  else
02467  {
02468   const fawkes::HomCoord* h = ((const fawkes::HomCoord*)  tolua_tousertype(tolua_S,2,0));
02469   {
02470    fawkes::HomPoint* tolua_ret = (fawkes::HomPoint*)  Mtolua_new((fawkes::HomPoint)(*h));
02471     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPoint");
02472     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02473   }
02474  }
02475  return 1;
02476 tolua_lerror:
02477  return tolua_fawkesgeometry_fawkes_HomPoint_new00_local(tolua_S);
02478 }
02479 #endif //#ifndef TOLUA_DISABLE
02480 
02481 /* method: delete of class  fawkes::HomPoint */
02482 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_delete00
02483 static int tolua_fawkesgeometry_fawkes_HomPoint_delete00(lua_State* tolua_S)
02484 {
02485 #ifndef TOLUA_RELEASE
02486  tolua_Error tolua_err;
02487  if (
02488      !tolua_isusertype(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
02489      !tolua_isnoobj(tolua_S,2,&tolua_err)
02490  )
02491   goto tolua_lerror;
02492  else
02493 #endif
02494  {
02495   fawkes::HomPoint* self = (fawkes::HomPoint*)  tolua_tousertype(tolua_S,1,0);
02496 #ifndef TOLUA_RELEASE
02497   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
02498 #endif
02499   Mtolua_delete(self);
02500  }
02501  return 0;
02502 #ifndef TOLUA_RELEASE
02503  tolua_lerror:
02504  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02505  return 0;
02506 #endif
02507 }
02508 #endif //#ifndef TOLUA_DISABLE
02509 
02510 /* method: distance of class  fawkes::HomPoint */
02511 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_distance00
02512 static int tolua_fawkesgeometry_fawkes_HomPoint_distance00(lua_State* tolua_S)
02513 {
02514 #ifndef TOLUA_RELEASE
02515  tolua_Error tolua_err;
02516  if (
02517      !tolua_isusertype(tolua_S,1,"const fawkes::HomPoint",0,&tolua_err) ||
02518      !tolua_isnoobj(tolua_S,2,&tolua_err)
02519  )
02520   goto tolua_lerror;
02521  else
02522 #endif
02523  {
02524   const fawkes::HomPoint* self = (const fawkes::HomPoint*)  tolua_tousertype(tolua_S,1,0);
02525 #ifndef TOLUA_RELEASE
02526   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'distance'", NULL);
02527 #endif
02528   {
02529    float tolua_ret = (float)  self->distance();
02530    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02531   }
02532  }
02533  return 1;
02534 #ifndef TOLUA_RELEASE
02535  tolua_lerror:
02536  tolua_error(tolua_S,"#ferror in function 'distance'.",&tolua_err);
02537  return 0;
02538 #endif
02539 }
02540 #endif //#ifndef TOLUA_DISABLE
02541 
02542 /* method: move of class  fawkes::HomPoint */
02543 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_move00
02544 static int tolua_fawkesgeometry_fawkes_HomPoint_move00(lua_State* tolua_S)
02545 {
02546 #ifndef TOLUA_RELEASE
02547  tolua_Error tolua_err;
02548  if (
02549      !tolua_isusertype(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
02550      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02551      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02552      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
02553      !tolua_isnoobj(tolua_S,5,&tolua_err)
02554  )
02555   goto tolua_lerror;
02556  else
02557 #endif
02558  {
02559   fawkes::HomPoint* self = (fawkes::HomPoint*)  tolua_tousertype(tolua_S,1,0);
02560   float dx = ((float)  tolua_tonumber(tolua_S,2,0));
02561   float dy = ((float)  tolua_tonumber(tolua_S,3,0));
02562   float dz = ((float)  tolua_tonumber(tolua_S,4,0));
02563 #ifndef TOLUA_RELEASE
02564   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'move'", NULL);
02565 #endif
02566   {
02567    fawkes::HomPoint& tolua_ret = (fawkes::HomPoint&)  self->move(dx,dy,dz);
02568     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomPoint");
02569   }
02570  }
02571  return 1;
02572 #ifndef TOLUA_RELEASE
02573  tolua_lerror:
02574  tolua_error(tolua_S,"#ferror in function 'move'.",&tolua_err);
02575  return 0;
02576 #endif
02577 }
02578 #endif //#ifndef TOLUA_DISABLE
02579 
02580 /* method: move_to of class  fawkes::HomPoint */
02581 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_move_to00
02582 static int tolua_fawkesgeometry_fawkes_HomPoint_move_to00(lua_State* tolua_S)
02583 {
02584 #ifndef TOLUA_RELEASE
02585  tolua_Error tolua_err;
02586  if (
02587      !tolua_isusertype(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
02588      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02589      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02590      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
02591      !tolua_isnoobj(tolua_S,5,&tolua_err)
02592  )
02593   goto tolua_lerror;
02594  else
02595 #endif
02596  {
02597   fawkes::HomPoint* self = (fawkes::HomPoint*)  tolua_tousertype(tolua_S,1,0);
02598   float x = ((float)  tolua_tonumber(tolua_S,2,0));
02599   float y = ((float)  tolua_tonumber(tolua_S,3,0));
02600   float z = ((float)  tolua_tonumber(tolua_S,4,0));
02601 #ifndef TOLUA_RELEASE
02602   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'move_to'", NULL);
02603 #endif
02604   {
02605    fawkes::HomPoint& tolua_ret = (fawkes::HomPoint&)  self->move_to(x,y,z);
02606     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomPoint");
02607   }
02608  }
02609  return 1;
02610 #ifndef TOLUA_RELEASE
02611  tolua_lerror:
02612  tolua_error(tolua_S,"#ferror in function 'move_to'.",&tolua_err);
02613  return 0;
02614 #endif
02615 }
02616 #endif //#ifndef TOLUA_DISABLE
02617 
02618 /* method: operator- of class  fawkes::HomPoint */
02619 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint__sub00
02620 static int tolua_fawkesgeometry_fawkes_HomPoint__sub00(lua_State* tolua_S)
02621 {
02622 #ifndef TOLUA_RELEASE
02623  tolua_Error tolua_err;
02624  if (
02625      !tolua_isusertype(tolua_S,1,"const fawkes::HomPoint",0,&tolua_err) ||
02626      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPoint",0,&tolua_err)) ||
02627      !tolua_isnoobj(tolua_S,3,&tolua_err)
02628  )
02629   goto tolua_lerror;
02630  else
02631 #endif
02632  {
02633   const fawkes::HomPoint* self = (const fawkes::HomPoint*)  tolua_tousertype(tolua_S,1,0);
02634   const fawkes::HomPoint* p = ((const fawkes::HomPoint*)  tolua_tousertype(tolua_S,2,0));
02635 #ifndef TOLUA_RELEASE
02636   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'", NULL);
02637 #endif
02638   {
02639    fawkes::HomVector tolua_ret = (fawkes::HomVector)  self->operator-(*p);
02640    {
02641 #ifdef __cplusplus
02642     void* tolua_obj = Mtolua_new((fawkes::HomVector)(tolua_ret));
02643      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomVector");
02644     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02645 #else
02646     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomVector));
02647      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomVector");
02648     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02649 #endif
02650    }
02651   }
02652  }
02653  return 1;
02654 #ifndef TOLUA_RELEASE
02655  tolua_lerror:
02656  tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
02657  return 0;
02658 #endif
02659 }
02660 #endif //#ifndef TOLUA_DISABLE
02661 
02662 /* Open function */
02663 TOLUA_API int tolua_fawkesgeometry_open (lua_State* tolua_S)
02664 {
02665  tolua_open(tolua_S);
02666  tolua_reg_types(tolua_S);
02667  tolua_module(tolua_S,NULL,0);
02668  tolua_beginmodule(tolua_S,NULL);
02669   tolua_module(tolua_S,"fawkes",0);
02670   tolua_beginmodule(tolua_S,"fawkes");
02671    #ifdef __cplusplus
02672    tolua_cclass(tolua_S,"HomCoord","fawkes::HomCoord","Printable",tolua_collect_fawkes__HomCoord);
02673    #else
02674    tolua_cclass(tolua_S,"HomCoord","fawkes::HomCoord","Printable",NULL);
02675    #endif
02676    tolua_beginmodule(tolua_S,"HomCoord");
02677     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomCoord_new00);
02678     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomCoord_new00_local);
02679     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomCoord_new00_local);
02680     tolua_function(tolua_S,"delete",tolua_fawkesgeometry_fawkes_HomCoord_delete00);
02681     tolua_function(tolua_S,"x",tolua_fawkesgeometry_fawkes_HomCoord_x00);
02682     tolua_function(tolua_S,"x",tolua_fawkesgeometry_fawkes_HomCoord_x01);
02683     tolua_function(tolua_S,"x",tolua_fawkesgeometry_fawkes_HomCoord_x02);
02684     tolua_function(tolua_S,"y",tolua_fawkesgeometry_fawkes_HomCoord_y00);
02685     tolua_function(tolua_S,"y",tolua_fawkesgeometry_fawkes_HomCoord_y01);
02686     tolua_function(tolua_S,"y",tolua_fawkesgeometry_fawkes_HomCoord_y02);
02687     tolua_function(tolua_S,"z",tolua_fawkesgeometry_fawkes_HomCoord_z00);
02688     tolua_function(tolua_S,"z",tolua_fawkesgeometry_fawkes_HomCoord_z01);
02689     tolua_function(tolua_S,"z",tolua_fawkesgeometry_fawkes_HomCoord_z02);
02690     tolua_function(tolua_S,"w",tolua_fawkesgeometry_fawkes_HomCoord_w00);
02691     tolua_function(tolua_S,"w",tolua_fawkesgeometry_fawkes_HomCoord_w01);
02692     tolua_function(tolua_S,"w",tolua_fawkesgeometry_fawkes_HomCoord_w02);
02693     tolua_function(tolua_S,"rotate_x",tolua_fawkesgeometry_fawkes_HomCoord_rotate_x00);
02694     tolua_function(tolua_S,"rotate_y",tolua_fawkesgeometry_fawkes_HomCoord_rotate_y00);
02695     tolua_function(tolua_S,"rotate_z",tolua_fawkesgeometry_fawkes_HomCoord_rotate_z00);
02696     tolua_function(tolua_S,"transform",tolua_fawkesgeometry_fawkes_HomCoord_transform00);
02697     tolua_function(tolua_S,".sub",tolua_fawkesgeometry_fawkes_HomCoord__sub00);
02698     tolua_function(tolua_S,".add",tolua_fawkesgeometry_fawkes_HomCoord__add00);
02699     tolua_function(tolua_S,".mul",tolua_fawkesgeometry_fawkes_HomCoord__mul00);
02700     tolua_function(tolua_S,".mul",tolua_fawkesgeometry_fawkes_HomCoord__mul01);
02701     tolua_function(tolua_S,".eq",tolua_fawkesgeometry_fawkes_HomCoord__eq00);
02702    tolua_endmodule(tolua_S);
02703   tolua_endmodule(tolua_S);
02704   tolua_module(tolua_S,"fawkes",0);
02705   tolua_beginmodule(tolua_S,"fawkes");
02706    #ifdef __cplusplus
02707    tolua_cclass(tolua_S,"HomPose2d","fawkes::HomPose2d","Transformable",tolua_collect_fawkes__HomPose2d);
02708    #else
02709    tolua_cclass(tolua_S,"HomPose2d","fawkes::HomPose2d","Transformable",NULL);
02710    #endif
02711    tolua_beginmodule(tolua_S,"HomPose2d");
02712     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomPose2d_new00);
02713     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomPose2d_new00_local);
02714     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomPose2d_new00_local);
02715     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomPose2d_new01);
02716     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomPose2d_new01_local);
02717     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomPose2d_new01_local);
02718     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomPose2d_new02);
02719     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomPose2d_new02_local);
02720     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomPose2d_new02_local);
02721     tolua_function(tolua_S,"delete",tolua_fawkesgeometry_fawkes_HomPose2d_delete00);
02722     tolua_function(tolua_S,"x",tolua_fawkesgeometry_fawkes_HomPose2d_x00);
02723     tolua_function(tolua_S,"x",tolua_fawkesgeometry_fawkes_HomPose2d_x01);
02724     tolua_function(tolua_S,"y",tolua_fawkesgeometry_fawkes_HomPose2d_y00);
02725     tolua_function(tolua_S,"y",tolua_fawkesgeometry_fawkes_HomPose2d_y01);
02726     tolua_function(tolua_S,"yaw",tolua_fawkesgeometry_fawkes_HomPose2d_yaw00);
02727     tolua_function(tolua_S,"yaw",tolua_fawkesgeometry_fawkes_HomPose2d_yaw01);
02728     tolua_function(tolua_S,"position",tolua_fawkesgeometry_fawkes_HomPose2d_position00);
02729     tolua_function(tolua_S,"orientation",tolua_fawkesgeometry_fawkes_HomPose2d_orientation00);
02730     tolua_function(tolua_S,"set_position",tolua_fawkesgeometry_fawkes_HomPose2d_set_position00);
02731    tolua_endmodule(tolua_S);
02732   tolua_endmodule(tolua_S);
02733   tolua_module(tolua_S,"fawkes",0);
02734   tolua_beginmodule(tolua_S,"fawkes");
02735    #ifdef __cplusplus
02736    tolua_cclass(tolua_S,"HomTransform","fawkes::HomTransform","",tolua_collect_fawkes__HomTransform);
02737    #else
02738    tolua_cclass(tolua_S,"HomTransform","fawkes::HomTransform","",NULL);
02739    #endif
02740    tolua_beginmodule(tolua_S,"HomTransform");
02741     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomTransform_new00);
02742     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomTransform_new00_local);
02743     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomTransform_new00_local);
02744     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomTransform_new01);
02745     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomTransform_new01_local);
02746     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomTransform_new01_local);
02747     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomTransform_new02);
02748     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomTransform_new02_local);
02749     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomTransform_new02_local);
02750     tolua_function(tolua_S,"delete",tolua_fawkesgeometry_fawkes_HomTransform_delete00);
02751     tolua_function(tolua_S,"reset",tolua_fawkesgeometry_fawkes_HomTransform_reset00);
02752     tolua_function(tolua_S,"invert",tolua_fawkesgeometry_fawkes_HomTransform_invert00);
02753     tolua_function(tolua_S,"get_inverse",tolua_fawkesgeometry_fawkes_HomTransform_get_inverse00);
02754     tolua_function(tolua_S,"rotate_x",tolua_fawkesgeometry_fawkes_HomTransform_rotate_x00);
02755     tolua_function(tolua_S,"rotate_y",tolua_fawkesgeometry_fawkes_HomTransform_rotate_y00);
02756     tolua_function(tolua_S,"rotate_z",tolua_fawkesgeometry_fawkes_HomTransform_rotate_z00);
02757     tolua_function(tolua_S,"trans",tolua_fawkesgeometry_fawkes_HomTransform_trans00);
02758     tolua_function(tolua_S,"set_trans",tolua_fawkesgeometry_fawkes_HomTransform_set_trans00);
02759     tolua_function(tolua_S,"mDH",tolua_fawkesgeometry_fawkes_HomTransform_mDH00);
02760     tolua_function(tolua_S,".mul",tolua_fawkesgeometry_fawkes_HomTransform__mul00);
02761     tolua_function(tolua_S,".mul",tolua_fawkesgeometry_fawkes_HomTransform__mul01);
02762     tolua_function(tolua_S,".mul",tolua_fawkesgeometry_fawkes_HomTransform__mul02);
02763     tolua_function(tolua_S,".eq",tolua_fawkesgeometry_fawkes_HomTransform__eq00);
02764     tolua_function(tolua_S,"print_info",tolua_fawkesgeometry_fawkes_HomTransform_print_info00);
02765     tolua_function(tolua_S,"get_matrix",tolua_fawkesgeometry_fawkes_HomTransform_get_matrix00);
02766    tolua_endmodule(tolua_S);
02767   tolua_endmodule(tolua_S);
02768   tolua_module(tolua_S,"fawkes",0);
02769   tolua_beginmodule(tolua_S,"fawkes");
02770    #ifdef __cplusplus
02771    tolua_cclass(tolua_S,"HomVector","fawkes::HomVector","fawkes::HomCoord",tolua_collect_fawkes__HomVector);
02772    #else
02773    tolua_cclass(tolua_S,"HomVector","fawkes::HomVector","fawkes::HomCoord",NULL);
02774    #endif
02775    tolua_beginmodule(tolua_S,"HomVector");
02776     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomVector_new00);
02777     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomVector_new00_local);
02778     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomVector_new00_local);
02779     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomVector_new01);
02780     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomVector_new01_local);
02781     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomVector_new01_local);
02782     tolua_function(tolua_S,"delete",tolua_fawkesgeometry_fawkes_HomVector_delete00);
02783     tolua_function(tolua_S,"length",tolua_fawkesgeometry_fawkes_HomVector_length00);
02784     tolua_function(tolua_S,"set_length",tolua_fawkesgeometry_fawkes_HomVector_set_length00);
02785     tolua_function(tolua_S,"unit",tolua_fawkesgeometry_fawkes_HomVector_unit00);
02786     tolua_function(tolua_S,"angle_xy",tolua_fawkesgeometry_fawkes_HomVector_angle_xy00);
02787    tolua_endmodule(tolua_S);
02788   tolua_endmodule(tolua_S);
02789   tolua_module(tolua_S,"fawkes",0);
02790   tolua_beginmodule(tolua_S,"fawkes");
02791    #ifdef __cplusplus
02792    tolua_cclass(tolua_S,"HomPoint","fawkes::HomPoint","fawkes::HomCoord",tolua_collect_fawkes__HomPoint);
02793    #else
02794    tolua_cclass(tolua_S,"HomPoint","fawkes::HomPoint","fawkes::HomCoord",NULL);
02795    #endif
02796    tolua_beginmodule(tolua_S,"HomPoint");
02797     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomPoint_new00);
02798     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomPoint_new00_local);
02799     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomPoint_new00_local);
02800     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomPoint_new01);
02801     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomPoint_new01_local);
02802     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomPoint_new01_local);
02803     tolua_function(tolua_S,"delete",tolua_fawkesgeometry_fawkes_HomPoint_delete00);
02804     tolua_function(tolua_S,"distance",tolua_fawkesgeometry_fawkes_HomPoint_distance00);
02805     tolua_function(tolua_S,"move",tolua_fawkesgeometry_fawkes_HomPoint_move00);
02806     tolua_function(tolua_S,"move_to",tolua_fawkesgeometry_fawkes_HomPoint_move_to00);
02807     tolua_function(tolua_S,".sub",tolua_fawkesgeometry_fawkes_HomPoint__sub00);
02808    tolua_endmodule(tolua_S);
02809   tolua_endmodule(tolua_S);
02810  tolua_endmodule(tolua_S);
02811  return 1;
02812 }
02813 
02814 
02815 extern "C" {
02816 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
02817  TOLUA_API int luaopen_fawkesgeometry (lua_State* tolua_S) {
02818  return tolua_fawkesgeometry_open(tolua_S);
02819 };
02820 #endif
02821 }
02822 
02823