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/hom_coord.h>
00031 #include <geometry/hom_vector.h>
00032 #include <geometry/transformable.h>
00033 #include <geometry/hom_vector.h>
00034 #include <geometry/hom_point.h>
00035 #include <geometry/hom_transform.h>
00036 #include <geometry/matrix.h>
00037 #include <geometry/hom_vector.h>
00038 #include <geometry/hom_point.h>
00039 #include <geometry/hom_pose_2d.h>
00040 #include <geometry/hom_coord.h>
00041 
00042 /* function to release collected object via destructor */
00043 #ifdef __cplusplus
00044 
00045 static int tolua_collect_fawkes__HomPose2d (lua_State* tolua_S)
00046 {
00047  fawkes::HomPose2d* self = (fawkes::HomPose2d*) 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__HomTransform (lua_State* tolua_S)
00074 {
00075  fawkes::HomTransform* self = (fawkes::HomTransform*) 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::HomPoint */
00869 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_new00
00870 static int tolua_fawkesgeometry_fawkes_HomPoint_new00(lua_State* tolua_S)
00871 {
00872 #ifndef TOLUA_RELEASE
00873  tolua_Error tolua_err;
00874  if (
00875      !tolua_isusertable(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
00876      !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
00877      !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
00878      !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
00879      !tolua_isnoobj(tolua_S,5,&tolua_err)
00880  )
00881   goto tolua_lerror;
00882  else
00883 #endif
00884  {
00885   float x = ((float)  tolua_tonumber(tolua_S,2,0.0));
00886   float y = ((float)  tolua_tonumber(tolua_S,3,0.0));
00887   float z = ((float)  tolua_tonumber(tolua_S,4,0.0));
00888   {
00889    fawkes::HomPoint* tolua_ret = (fawkes::HomPoint*)  Mtolua_new((fawkes::HomPoint)(x,y,z));
00890     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPoint");
00891   }
00892  }
00893  return 1;
00894 #ifndef TOLUA_RELEASE
00895  tolua_lerror:
00896  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00897  return 0;
00898 #endif
00899 }
00900 #endif //#ifndef TOLUA_DISABLE
00901 
00902 /* method: new_local of class  fawkes::HomPoint */
00903 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_new00_local
00904 static int tolua_fawkesgeometry_fawkes_HomPoint_new00_local(lua_State* tolua_S)
00905 {
00906 #ifndef TOLUA_RELEASE
00907  tolua_Error tolua_err;
00908  if (
00909      !tolua_isusertable(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
00910      !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
00911      !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
00912      !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
00913      !tolua_isnoobj(tolua_S,5,&tolua_err)
00914  )
00915   goto tolua_lerror;
00916  else
00917 #endif
00918  {
00919   float x = ((float)  tolua_tonumber(tolua_S,2,0.0));
00920   float y = ((float)  tolua_tonumber(tolua_S,3,0.0));
00921   float z = ((float)  tolua_tonumber(tolua_S,4,0.0));
00922   {
00923    fawkes::HomPoint* tolua_ret = (fawkes::HomPoint*)  Mtolua_new((fawkes::HomPoint)(x,y,z));
00924     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPoint");
00925     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00926   }
00927  }
00928  return 1;
00929 #ifndef TOLUA_RELEASE
00930  tolua_lerror:
00931  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00932  return 0;
00933 #endif
00934 }
00935 #endif //#ifndef TOLUA_DISABLE
00936 
00937 /* method: new of class  fawkes::HomPoint */
00938 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_new01
00939 static int tolua_fawkesgeometry_fawkes_HomPoint_new01(lua_State* tolua_S)
00940 {
00941  tolua_Error tolua_err;
00942  if (
00943      !tolua_isusertable(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
00944      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
00945      !tolua_isnoobj(tolua_S,3,&tolua_err)
00946  )
00947   goto tolua_lerror;
00948  else
00949  {
00950   const fawkes::HomCoord* h = ((const fawkes::HomCoord*)  tolua_tousertype(tolua_S,2,0));
00951   {
00952    fawkes::HomPoint* tolua_ret = (fawkes::HomPoint*)  Mtolua_new((fawkes::HomPoint)(*h));
00953     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPoint");
00954   }
00955  }
00956  return 1;
00957 tolua_lerror:
00958  return tolua_fawkesgeometry_fawkes_HomPoint_new00(tolua_S);
00959 }
00960 #endif //#ifndef TOLUA_DISABLE
00961 
00962 /* method: new_local of class  fawkes::HomPoint */
00963 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_new01_local
00964 static int tolua_fawkesgeometry_fawkes_HomPoint_new01_local(lua_State* tolua_S)
00965 {
00966  tolua_Error tolua_err;
00967  if (
00968      !tolua_isusertable(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
00969      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
00970      !tolua_isnoobj(tolua_S,3,&tolua_err)
00971  )
00972   goto tolua_lerror;
00973  else
00974  {
00975   const fawkes::HomCoord* h = ((const fawkes::HomCoord*)  tolua_tousertype(tolua_S,2,0));
00976   {
00977    fawkes::HomPoint* tolua_ret = (fawkes::HomPoint*)  Mtolua_new((fawkes::HomPoint)(*h));
00978     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPoint");
00979     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00980   }
00981  }
00982  return 1;
00983 tolua_lerror:
00984  return tolua_fawkesgeometry_fawkes_HomPoint_new00_local(tolua_S);
00985 }
00986 #endif //#ifndef TOLUA_DISABLE
00987 
00988 /* method: delete of class  fawkes::HomPoint */
00989 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_delete00
00990 static int tolua_fawkesgeometry_fawkes_HomPoint_delete00(lua_State* tolua_S)
00991 {
00992 #ifndef TOLUA_RELEASE
00993  tolua_Error tolua_err;
00994  if (
00995      !tolua_isusertype(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
00996      !tolua_isnoobj(tolua_S,2,&tolua_err)
00997  )
00998   goto tolua_lerror;
00999  else
01000 #endif
01001  {
01002   fawkes::HomPoint* self = (fawkes::HomPoint*)  tolua_tousertype(tolua_S,1,0);
01003 #ifndef TOLUA_RELEASE
01004   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01005 #endif
01006   Mtolua_delete(self);
01007  }
01008  return 0;
01009 #ifndef TOLUA_RELEASE
01010  tolua_lerror:
01011  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01012  return 0;
01013 #endif
01014 }
01015 #endif //#ifndef TOLUA_DISABLE
01016 
01017 /* method: distance of class  fawkes::HomPoint */
01018 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_distance00
01019 static int tolua_fawkesgeometry_fawkes_HomPoint_distance00(lua_State* tolua_S)
01020 {
01021 #ifndef TOLUA_RELEASE
01022  tolua_Error tolua_err;
01023  if (
01024      !tolua_isusertype(tolua_S,1,"const fawkes::HomPoint",0,&tolua_err) ||
01025      !tolua_isnoobj(tolua_S,2,&tolua_err)
01026  )
01027   goto tolua_lerror;
01028  else
01029 #endif
01030  {
01031   const fawkes::HomPoint* self = (const fawkes::HomPoint*)  tolua_tousertype(tolua_S,1,0);
01032 #ifndef TOLUA_RELEASE
01033   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'distance'", NULL);
01034 #endif
01035   {
01036    float tolua_ret = (float)  self->distance();
01037    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01038   }
01039  }
01040  return 1;
01041 #ifndef TOLUA_RELEASE
01042  tolua_lerror:
01043  tolua_error(tolua_S,"#ferror in function 'distance'.",&tolua_err);
01044  return 0;
01045 #endif
01046 }
01047 #endif //#ifndef TOLUA_DISABLE
01048 
01049 /* method: move of class  fawkes::HomPoint */
01050 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_move00
01051 static int tolua_fawkesgeometry_fawkes_HomPoint_move00(lua_State* tolua_S)
01052 {
01053 #ifndef TOLUA_RELEASE
01054  tolua_Error tolua_err;
01055  if (
01056      !tolua_isusertype(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
01057      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01058      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01059      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01060      !tolua_isnoobj(tolua_S,5,&tolua_err)
01061  )
01062   goto tolua_lerror;
01063  else
01064 #endif
01065  {
01066   fawkes::HomPoint* self = (fawkes::HomPoint*)  tolua_tousertype(tolua_S,1,0);
01067   float dx = ((float)  tolua_tonumber(tolua_S,2,0));
01068   float dy = ((float)  tolua_tonumber(tolua_S,3,0));
01069   float dz = ((float)  tolua_tonumber(tolua_S,4,0));
01070 #ifndef TOLUA_RELEASE
01071   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'move'", NULL);
01072 #endif
01073   {
01074    fawkes::HomPoint& tolua_ret = (fawkes::HomPoint&)  self->move(dx,dy,dz);
01075     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomPoint");
01076   }
01077  }
01078  return 1;
01079 #ifndef TOLUA_RELEASE
01080  tolua_lerror:
01081  tolua_error(tolua_S,"#ferror in function 'move'.",&tolua_err);
01082  return 0;
01083 #endif
01084 }
01085 #endif //#ifndef TOLUA_DISABLE
01086 
01087 /* method: move_to of class  fawkes::HomPoint */
01088 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_move_to00
01089 static int tolua_fawkesgeometry_fawkes_HomPoint_move_to00(lua_State* tolua_S)
01090 {
01091 #ifndef TOLUA_RELEASE
01092  tolua_Error tolua_err;
01093  if (
01094      !tolua_isusertype(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
01095      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01096      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
01097      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
01098      !tolua_isnoobj(tolua_S,5,&tolua_err)
01099  )
01100   goto tolua_lerror;
01101  else
01102 #endif
01103  {
01104   fawkes::HomPoint* self = (fawkes::HomPoint*)  tolua_tousertype(tolua_S,1,0);
01105   float x = ((float)  tolua_tonumber(tolua_S,2,0));
01106   float y = ((float)  tolua_tonumber(tolua_S,3,0));
01107   float z = ((float)  tolua_tonumber(tolua_S,4,0));
01108 #ifndef TOLUA_RELEASE
01109   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'move_to'", NULL);
01110 #endif
01111   {
01112    fawkes::HomPoint& tolua_ret = (fawkes::HomPoint&)  self->move_to(x,y,z);
01113     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomPoint");
01114   }
01115  }
01116  return 1;
01117 #ifndef TOLUA_RELEASE
01118  tolua_lerror:
01119  tolua_error(tolua_S,"#ferror in function 'move_to'.",&tolua_err);
01120  return 0;
01121 #endif
01122 }
01123 #endif //#ifndef TOLUA_DISABLE
01124 
01125 /* method: operator- of class  fawkes::HomPoint */
01126 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint__sub00
01127 static int tolua_fawkesgeometry_fawkes_HomPoint__sub00(lua_State* tolua_S)
01128 {
01129 #ifndef TOLUA_RELEASE
01130  tolua_Error tolua_err;
01131  if (
01132      !tolua_isusertype(tolua_S,1,"const fawkes::HomPoint",0,&tolua_err) ||
01133      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPoint",0,&tolua_err)) ||
01134      !tolua_isnoobj(tolua_S,3,&tolua_err)
01135  )
01136   goto tolua_lerror;
01137  else
01138 #endif
01139  {
01140   const fawkes::HomPoint* self = (const fawkes::HomPoint*)  tolua_tousertype(tolua_S,1,0);
01141   const fawkes::HomPoint* p = ((const fawkes::HomPoint*)  tolua_tousertype(tolua_S,2,0));
01142 #ifndef TOLUA_RELEASE
01143   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'", NULL);
01144 #endif
01145   {
01146    fawkes::HomVector tolua_ret = (fawkes::HomVector)  self->operator-(*p);
01147    {
01148 #ifdef __cplusplus
01149     void* tolua_obj = Mtolua_new((fawkes::HomVector)(tolua_ret));
01150      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomVector");
01151     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01152 #else
01153     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomVector));
01154      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomVector");
01155     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01156 #endif
01157    }
01158   }
01159  }
01160  return 1;
01161 #ifndef TOLUA_RELEASE
01162  tolua_lerror:
01163  tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
01164  return 0;
01165 #endif
01166 }
01167 #endif //#ifndef TOLUA_DISABLE
01168 
01169 /* method: new of class  fawkes::HomPose2d */
01170 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_new00
01171 static int tolua_fawkesgeometry_fawkes_HomPose2d_new00(lua_State* tolua_S)
01172 {
01173 #ifndef TOLUA_RELEASE
01174  tolua_Error tolua_err;
01175  if (
01176      !tolua_isusertable(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
01177      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPoint",0,&tolua_err)) ||
01178      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::HomVector",0,&tolua_err)) ||
01179      !tolua_isnoobj(tolua_S,4,&tolua_err)
01180  )
01181   goto tolua_lerror;
01182  else
01183 #endif
01184  {
01185   const fawkes::HomPoint* pos = ((const fawkes::HomPoint*)  tolua_tousertype(tolua_S,2,0));
01186   const fawkes::HomVector* orientation = ((const fawkes::HomVector*)  tolua_tousertype(tolua_S,3,0));
01187   {
01188    fawkes::HomPose2d* tolua_ret = (fawkes::HomPose2d*)  Mtolua_new((fawkes::HomPose2d)(*pos,*orientation));
01189     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPose2d");
01190   }
01191  }
01192  return 1;
01193 #ifndef TOLUA_RELEASE
01194  tolua_lerror:
01195  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01196  return 0;
01197 #endif
01198 }
01199 #endif //#ifndef TOLUA_DISABLE
01200 
01201 /* method: new_local of class  fawkes::HomPose2d */
01202 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_new00_local
01203 static int tolua_fawkesgeometry_fawkes_HomPose2d_new00_local(lua_State* tolua_S)
01204 {
01205 #ifndef TOLUA_RELEASE
01206  tolua_Error tolua_err;
01207  if (
01208      !tolua_isusertable(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
01209      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPoint",0,&tolua_err)) ||
01210      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::HomVector",0,&tolua_err)) ||
01211      !tolua_isnoobj(tolua_S,4,&tolua_err)
01212  )
01213   goto tolua_lerror;
01214  else
01215 #endif
01216  {
01217   const fawkes::HomPoint* pos = ((const fawkes::HomPoint*)  tolua_tousertype(tolua_S,2,0));
01218   const fawkes::HomVector* orientation = ((const fawkes::HomVector*)  tolua_tousertype(tolua_S,3,0));
01219   {
01220    fawkes::HomPose2d* tolua_ret = (fawkes::HomPose2d*)  Mtolua_new((fawkes::HomPose2d)(*pos,*orientation));
01221     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPose2d");
01222     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01223   }
01224  }
01225  return 1;
01226 #ifndef TOLUA_RELEASE
01227  tolua_lerror:
01228  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01229  return 0;
01230 #endif
01231 }
01232 #endif //#ifndef TOLUA_DISABLE
01233 
01234 /* method: new of class  fawkes::HomPose2d */
01235 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_new01
01236 static int tolua_fawkesgeometry_fawkes_HomPose2d_new01(lua_State* tolua_S)
01237 {
01238  tolua_Error tolua_err;
01239  if (
01240      !tolua_isusertable(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
01241      !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
01242      !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
01243      !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
01244      !tolua_isnoobj(tolua_S,5,&tolua_err)
01245  )
01246   goto tolua_lerror;
01247  else
01248  {
01249   float x = ((float)  tolua_tonumber(tolua_S,2,0.0));
01250   float y = ((float)  tolua_tonumber(tolua_S,3,0.0));
01251   float yaw = ((float)  tolua_tonumber(tolua_S,4,0.0));
01252   {
01253    fawkes::HomPose2d* tolua_ret = (fawkes::HomPose2d*)  Mtolua_new((fawkes::HomPose2d)(x,y,yaw));
01254     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPose2d");
01255   }
01256  }
01257  return 1;
01258 tolua_lerror:
01259  return tolua_fawkesgeometry_fawkes_HomPose2d_new00(tolua_S);
01260 }
01261 #endif //#ifndef TOLUA_DISABLE
01262 
01263 /* method: new_local of class  fawkes::HomPose2d */
01264 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_new01_local
01265 static int tolua_fawkesgeometry_fawkes_HomPose2d_new01_local(lua_State* tolua_S)
01266 {
01267  tolua_Error tolua_err;
01268  if (
01269      !tolua_isusertable(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
01270      !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
01271      !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
01272      !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
01273      !tolua_isnoobj(tolua_S,5,&tolua_err)
01274  )
01275   goto tolua_lerror;
01276  else
01277  {
01278   float x = ((float)  tolua_tonumber(tolua_S,2,0.0));
01279   float y = ((float)  tolua_tonumber(tolua_S,3,0.0));
01280   float yaw = ((float)  tolua_tonumber(tolua_S,4,0.0));
01281   {
01282    fawkes::HomPose2d* tolua_ret = (fawkes::HomPose2d*)  Mtolua_new((fawkes::HomPose2d)(x,y,yaw));
01283     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPose2d");
01284     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01285   }
01286  }
01287  return 1;
01288 tolua_lerror:
01289  return tolua_fawkesgeometry_fawkes_HomPose2d_new00_local(tolua_S);
01290 }
01291 #endif //#ifndef TOLUA_DISABLE
01292 
01293 /* method: new of class  fawkes::HomPose2d */
01294 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_new02
01295 static int tolua_fawkesgeometry_fawkes_HomPose2d_new02(lua_State* tolua_S)
01296 {
01297  tolua_Error tolua_err;
01298  if (
01299      !tolua_isusertable(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
01300      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPose2d",0,&tolua_err)) ||
01301      !tolua_isnoobj(tolua_S,3,&tolua_err)
01302  )
01303   goto tolua_lerror;
01304  else
01305  {
01306   const fawkes::HomPose2d* p = ((const fawkes::HomPose2d*)  tolua_tousertype(tolua_S,2,0));
01307   {
01308    fawkes::HomPose2d* tolua_ret = (fawkes::HomPose2d*)  Mtolua_new((fawkes::HomPose2d)(*p));
01309     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPose2d");
01310   }
01311  }
01312  return 1;
01313 tolua_lerror:
01314  return tolua_fawkesgeometry_fawkes_HomPose2d_new01(tolua_S);
01315 }
01316 #endif //#ifndef TOLUA_DISABLE
01317 
01318 /* method: new_local of class  fawkes::HomPose2d */
01319 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_new02_local
01320 static int tolua_fawkesgeometry_fawkes_HomPose2d_new02_local(lua_State* tolua_S)
01321 {
01322  tolua_Error tolua_err;
01323  if (
01324      !tolua_isusertable(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
01325      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPose2d",0,&tolua_err)) ||
01326      !tolua_isnoobj(tolua_S,3,&tolua_err)
01327  )
01328   goto tolua_lerror;
01329  else
01330  {
01331   const fawkes::HomPose2d* p = ((const fawkes::HomPose2d*)  tolua_tousertype(tolua_S,2,0));
01332   {
01333    fawkes::HomPose2d* tolua_ret = (fawkes::HomPose2d*)  Mtolua_new((fawkes::HomPose2d)(*p));
01334     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPose2d");
01335     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01336   }
01337  }
01338  return 1;
01339 tolua_lerror:
01340  return tolua_fawkesgeometry_fawkes_HomPose2d_new01_local(tolua_S);
01341 }
01342 #endif //#ifndef TOLUA_DISABLE
01343 
01344 /* method: delete of class  fawkes::HomPose2d */
01345 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_delete00
01346 static int tolua_fawkesgeometry_fawkes_HomPose2d_delete00(lua_State* tolua_S)
01347 {
01348 #ifndef TOLUA_RELEASE
01349  tolua_Error tolua_err;
01350  if (
01351      !tolua_isusertype(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
01352      !tolua_isnoobj(tolua_S,2,&tolua_err)
01353  )
01354   goto tolua_lerror;
01355  else
01356 #endif
01357  {
01358   fawkes::HomPose2d* self = (fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01359 #ifndef TOLUA_RELEASE
01360   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01361 #endif
01362   Mtolua_delete(self);
01363  }
01364  return 0;
01365 #ifndef TOLUA_RELEASE
01366  tolua_lerror:
01367  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01368  return 0;
01369 #endif
01370 }
01371 #endif //#ifndef TOLUA_DISABLE
01372 
01373 /* method: x of class  fawkes::HomPose2d */
01374 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_x00
01375 static int tolua_fawkesgeometry_fawkes_HomPose2d_x00(lua_State* tolua_S)
01376 {
01377 #ifndef TOLUA_RELEASE
01378  tolua_Error tolua_err;
01379  if (
01380      !tolua_isusertype(tolua_S,1,"const fawkes::HomPose2d",0,&tolua_err) ||
01381      !tolua_isnoobj(tolua_S,2,&tolua_err)
01382  )
01383   goto tolua_lerror;
01384  else
01385 #endif
01386  {
01387   const fawkes::HomPose2d* self = (const fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01388 #ifndef TOLUA_RELEASE
01389   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
01390 #endif
01391   {
01392    float tolua_ret = (float)  self->x();
01393    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01394   }
01395  }
01396  return 1;
01397 #ifndef TOLUA_RELEASE
01398  tolua_lerror:
01399  tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
01400  return 0;
01401 #endif
01402 }
01403 #endif //#ifndef TOLUA_DISABLE
01404 
01405 /* method: x of class  fawkes::HomPose2d */
01406 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_x01
01407 static int tolua_fawkesgeometry_fawkes_HomPose2d_x01(lua_State* tolua_S)
01408 {
01409  tolua_Error tolua_err;
01410  if (
01411      !tolua_isusertype(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
01412      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01413      !tolua_isnoobj(tolua_S,3,&tolua_err)
01414  )
01415   goto tolua_lerror;
01416  else
01417  {
01418   fawkes::HomPose2d* self = (fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01419   float x = ((float)  tolua_tonumber(tolua_S,2,0));
01420 #ifndef TOLUA_RELEASE
01421   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'", NULL);
01422 #endif
01423   {
01424    self->x(x);
01425   }
01426  }
01427  return 0;
01428 tolua_lerror:
01429  return tolua_fawkesgeometry_fawkes_HomPose2d_x00(tolua_S);
01430 }
01431 #endif //#ifndef TOLUA_DISABLE
01432 
01433 /* method: y of class  fawkes::HomPose2d */
01434 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_y00
01435 static int tolua_fawkesgeometry_fawkes_HomPose2d_y00(lua_State* tolua_S)
01436 {
01437 #ifndef TOLUA_RELEASE
01438  tolua_Error tolua_err;
01439  if (
01440      !tolua_isusertype(tolua_S,1,"const fawkes::HomPose2d",0,&tolua_err) ||
01441      !tolua_isnoobj(tolua_S,2,&tolua_err)
01442  )
01443   goto tolua_lerror;
01444  else
01445 #endif
01446  {
01447   const fawkes::HomPose2d* self = (const fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01448 #ifndef TOLUA_RELEASE
01449   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
01450 #endif
01451   {
01452    float tolua_ret = (float)  self->y();
01453    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01454   }
01455  }
01456  return 1;
01457 #ifndef TOLUA_RELEASE
01458  tolua_lerror:
01459  tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
01460  return 0;
01461 #endif
01462 }
01463 #endif //#ifndef TOLUA_DISABLE
01464 
01465 /* method: y of class  fawkes::HomPose2d */
01466 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_y01
01467 static int tolua_fawkesgeometry_fawkes_HomPose2d_y01(lua_State* tolua_S)
01468 {
01469  tolua_Error tolua_err;
01470  if (
01471      !tolua_isusertype(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
01472      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01473      !tolua_isnoobj(tolua_S,3,&tolua_err)
01474  )
01475   goto tolua_lerror;
01476  else
01477  {
01478   fawkes::HomPose2d* self = (fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01479   float y = ((float)  tolua_tonumber(tolua_S,2,0));
01480 #ifndef TOLUA_RELEASE
01481   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'", NULL);
01482 #endif
01483   {
01484    self->y(y);
01485   }
01486  }
01487  return 0;
01488 tolua_lerror:
01489  return tolua_fawkesgeometry_fawkes_HomPose2d_y00(tolua_S);
01490 }
01491 #endif //#ifndef TOLUA_DISABLE
01492 
01493 /* method: yaw of class  fawkes::HomPose2d */
01494 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_yaw00
01495 static int tolua_fawkesgeometry_fawkes_HomPose2d_yaw00(lua_State* tolua_S)
01496 {
01497 #ifndef TOLUA_RELEASE
01498  tolua_Error tolua_err;
01499  if (
01500      !tolua_isusertype(tolua_S,1,"const fawkes::HomPose2d",0,&tolua_err) ||
01501      !tolua_isnoobj(tolua_S,2,&tolua_err)
01502  )
01503   goto tolua_lerror;
01504  else
01505 #endif
01506  {
01507   const fawkes::HomPose2d* self = (const fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01508 #ifndef TOLUA_RELEASE
01509   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'yaw'", NULL);
01510 #endif
01511   {
01512    float tolua_ret = (float)  self->yaw();
01513    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01514   }
01515  }
01516  return 1;
01517 #ifndef TOLUA_RELEASE
01518  tolua_lerror:
01519  tolua_error(tolua_S,"#ferror in function 'yaw'.",&tolua_err);
01520  return 0;
01521 #endif
01522 }
01523 #endif //#ifndef TOLUA_DISABLE
01524 
01525 /* method: yaw of class  fawkes::HomPose2d */
01526 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_yaw01
01527 static int tolua_fawkesgeometry_fawkes_HomPose2d_yaw01(lua_State* tolua_S)
01528 {
01529  tolua_Error tolua_err;
01530  if (
01531      !tolua_isusertype(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
01532      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01533      !tolua_isnoobj(tolua_S,3,&tolua_err)
01534  )
01535   goto tolua_lerror;
01536  else
01537  {
01538   fawkes::HomPose2d* self = (fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01539   float yaw = ((float)  tolua_tonumber(tolua_S,2,0));
01540 #ifndef TOLUA_RELEASE
01541   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'yaw'", NULL);
01542 #endif
01543   {
01544    self->yaw(yaw);
01545   }
01546  }
01547  return 0;
01548 tolua_lerror:
01549  return tolua_fawkesgeometry_fawkes_HomPose2d_yaw00(tolua_S);
01550 }
01551 #endif //#ifndef TOLUA_DISABLE
01552 
01553 /* method: position of class  fawkes::HomPose2d */
01554 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_position00
01555 static int tolua_fawkesgeometry_fawkes_HomPose2d_position00(lua_State* tolua_S)
01556 {
01557 #ifndef TOLUA_RELEASE
01558  tolua_Error tolua_err;
01559  if (
01560      !tolua_isusertype(tolua_S,1,"const fawkes::HomPose2d",0,&tolua_err) ||
01561      !tolua_isnoobj(tolua_S,2,&tolua_err)
01562  )
01563   goto tolua_lerror;
01564  else
01565 #endif
01566  {
01567   const fawkes::HomPose2d* self = (const fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01568 #ifndef TOLUA_RELEASE
01569   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'position'", NULL);
01570 #endif
01571   {
01572    const fawkes::HomPoint& tolua_ret = (const fawkes::HomPoint&)  self->position();
01573     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const fawkes::HomPoint");
01574   }
01575  }
01576  return 1;
01577 #ifndef TOLUA_RELEASE
01578  tolua_lerror:
01579  tolua_error(tolua_S,"#ferror in function 'position'.",&tolua_err);
01580  return 0;
01581 #endif
01582 }
01583 #endif //#ifndef TOLUA_DISABLE
01584 
01585 /* method: orientation of class  fawkes::HomPose2d */
01586 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_orientation00
01587 static int tolua_fawkesgeometry_fawkes_HomPose2d_orientation00(lua_State* tolua_S)
01588 {
01589 #ifndef TOLUA_RELEASE
01590  tolua_Error tolua_err;
01591  if (
01592      !tolua_isusertype(tolua_S,1,"const fawkes::HomPose2d",0,&tolua_err) ||
01593      !tolua_isnoobj(tolua_S,2,&tolua_err)
01594  )
01595   goto tolua_lerror;
01596  else
01597 #endif
01598  {
01599   const fawkes::HomPose2d* self = (const fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01600 #ifndef TOLUA_RELEASE
01601   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'orientation'", NULL);
01602 #endif
01603   {
01604    const fawkes::HomVector& tolua_ret = (const fawkes::HomVector&)  self->orientation();
01605     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const fawkes::HomVector");
01606   }
01607  }
01608  return 1;
01609 #ifndef TOLUA_RELEASE
01610  tolua_lerror:
01611  tolua_error(tolua_S,"#ferror in function 'orientation'.",&tolua_err);
01612  return 0;
01613 #endif
01614 }
01615 #endif //#ifndef TOLUA_DISABLE
01616 
01617 /* method: set_position of class  fawkes::HomPose2d */
01618 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_set_position00
01619 static int tolua_fawkesgeometry_fawkes_HomPose2d_set_position00(lua_State* tolua_S)
01620 {
01621 #ifndef TOLUA_RELEASE
01622  tolua_Error tolua_err;
01623  if (
01624      !tolua_isusertype(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
01625      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPoint",0,&tolua_err)) ||
01626      !tolua_isnoobj(tolua_S,3,&tolua_err)
01627  )
01628   goto tolua_lerror;
01629  else
01630 #endif
01631  {
01632   fawkes::HomPose2d* self = (fawkes::HomPose2d*)  tolua_tousertype(tolua_S,1,0);
01633   const fawkes::HomPoint* p = ((const fawkes::HomPoint*)  tolua_tousertype(tolua_S,2,0));
01634 #ifndef TOLUA_RELEASE
01635   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_position'", NULL);
01636 #endif
01637   {
01638    self->set_position(*p);
01639   }
01640  }
01641  return 0;
01642 #ifndef TOLUA_RELEASE
01643  tolua_lerror:
01644  tolua_error(tolua_S,"#ferror in function 'set_position'.",&tolua_err);
01645  return 0;
01646 #endif
01647 }
01648 #endif //#ifndef TOLUA_DISABLE
01649 
01650 /* method: new of class  fawkes::HomTransform */
01651 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_new00
01652 static int tolua_fawkesgeometry_fawkes_HomTransform_new00(lua_State* tolua_S)
01653 {
01654 #ifndef TOLUA_RELEASE
01655  tolua_Error tolua_err;
01656  if (
01657      !tolua_isusertable(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01658      !tolua_isnoobj(tolua_S,2,&tolua_err)
01659  )
01660   goto tolua_lerror;
01661  else
01662 #endif
01663  {
01664   {
01665    fawkes::HomTransform* tolua_ret = (fawkes::HomTransform*)  Mtolua_new((fawkes::HomTransform)());
01666     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomTransform");
01667   }
01668  }
01669  return 1;
01670 #ifndef TOLUA_RELEASE
01671  tolua_lerror:
01672  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01673  return 0;
01674 #endif
01675 }
01676 #endif //#ifndef TOLUA_DISABLE
01677 
01678 /* method: new_local of class  fawkes::HomTransform */
01679 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_new00_local
01680 static int tolua_fawkesgeometry_fawkes_HomTransform_new00_local(lua_State* tolua_S)
01681 {
01682 #ifndef TOLUA_RELEASE
01683  tolua_Error tolua_err;
01684  if (
01685      !tolua_isusertable(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01686      !tolua_isnoobj(tolua_S,2,&tolua_err)
01687  )
01688   goto tolua_lerror;
01689  else
01690 #endif
01691  {
01692   {
01693    fawkes::HomTransform* tolua_ret = (fawkes::HomTransform*)  Mtolua_new((fawkes::HomTransform)());
01694     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomTransform");
01695     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01696   }
01697  }
01698  return 1;
01699 #ifndef TOLUA_RELEASE
01700  tolua_lerror:
01701  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
01702  return 0;
01703 #endif
01704 }
01705 #endif //#ifndef TOLUA_DISABLE
01706 
01707 /* method: new of class  fawkes::HomTransform */
01708 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_new01
01709 static int tolua_fawkesgeometry_fawkes_HomTransform_new01(lua_State* tolua_S)
01710 {
01711  tolua_Error tolua_err;
01712  if (
01713      !tolua_isusertable(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01714      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomTransform",0,&tolua_err)) ||
01715      !tolua_isnoobj(tolua_S,3,&tolua_err)
01716  )
01717   goto tolua_lerror;
01718  else
01719  {
01720   const fawkes::HomTransform* ht = ((const fawkes::HomTransform*)  tolua_tousertype(tolua_S,2,0));
01721   {
01722    fawkes::HomTransform* tolua_ret = (fawkes::HomTransform*)  Mtolua_new((fawkes::HomTransform)(*ht));
01723     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomTransform");
01724   }
01725  }
01726  return 1;
01727 tolua_lerror:
01728  return tolua_fawkesgeometry_fawkes_HomTransform_new00(tolua_S);
01729 }
01730 #endif //#ifndef TOLUA_DISABLE
01731 
01732 /* method: new_local of class  fawkes::HomTransform */
01733 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_new01_local
01734 static int tolua_fawkesgeometry_fawkes_HomTransform_new01_local(lua_State* tolua_S)
01735 {
01736  tolua_Error tolua_err;
01737  if (
01738      !tolua_isusertable(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01739      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomTransform",0,&tolua_err)) ||
01740      !tolua_isnoobj(tolua_S,3,&tolua_err)
01741  )
01742   goto tolua_lerror;
01743  else
01744  {
01745   const fawkes::HomTransform* ht = ((const fawkes::HomTransform*)  tolua_tousertype(tolua_S,2,0));
01746   {
01747    fawkes::HomTransform* tolua_ret = (fawkes::HomTransform*)  Mtolua_new((fawkes::HomTransform)(*ht));
01748     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomTransform");
01749     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01750   }
01751  }
01752  return 1;
01753 tolua_lerror:
01754  return tolua_fawkesgeometry_fawkes_HomTransform_new00_local(tolua_S);
01755 }
01756 #endif //#ifndef TOLUA_DISABLE
01757 
01758 /* method: new of class  fawkes::HomTransform */
01759 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_new02
01760 static int tolua_fawkesgeometry_fawkes_HomTransform_new02(lua_State* tolua_S)
01761 {
01762  tolua_Error tolua_err;
01763  if (
01764      !tolua_isusertable(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01765      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Matrix",0,&tolua_err)) ||
01766      !tolua_isnoobj(tolua_S,3,&tolua_err)
01767  )
01768   goto tolua_lerror;
01769  else
01770  {
01771   const fawkes::Matrix* m = ((const fawkes::Matrix*)  tolua_tousertype(tolua_S,2,0));
01772   {
01773    fawkes::HomTransform* tolua_ret = (fawkes::HomTransform*)  Mtolua_new((fawkes::HomTransform)(*m));
01774     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomTransform");
01775   }
01776  }
01777  return 1;
01778 tolua_lerror:
01779  return tolua_fawkesgeometry_fawkes_HomTransform_new01(tolua_S);
01780 }
01781 #endif //#ifndef TOLUA_DISABLE
01782 
01783 /* method: new_local of class  fawkes::HomTransform */
01784 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_new02_local
01785 static int tolua_fawkesgeometry_fawkes_HomTransform_new02_local(lua_State* tolua_S)
01786 {
01787  tolua_Error tolua_err;
01788  if (
01789      !tolua_isusertable(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01790      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Matrix",0,&tolua_err)) ||
01791      !tolua_isnoobj(tolua_S,3,&tolua_err)
01792  )
01793   goto tolua_lerror;
01794  else
01795  {
01796   const fawkes::Matrix* m = ((const fawkes::Matrix*)  tolua_tousertype(tolua_S,2,0));
01797   {
01798    fawkes::HomTransform* tolua_ret = (fawkes::HomTransform*)  Mtolua_new((fawkes::HomTransform)(*m));
01799     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomTransform");
01800     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01801   }
01802  }
01803  return 1;
01804 tolua_lerror:
01805  return tolua_fawkesgeometry_fawkes_HomTransform_new01_local(tolua_S);
01806 }
01807 #endif //#ifndef TOLUA_DISABLE
01808 
01809 /* method: delete of class  fawkes::HomTransform */
01810 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_delete00
01811 static int tolua_fawkesgeometry_fawkes_HomTransform_delete00(lua_State* tolua_S)
01812 {
01813 #ifndef TOLUA_RELEASE
01814  tolua_Error tolua_err;
01815  if (
01816      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01817      !tolua_isnoobj(tolua_S,2,&tolua_err)
01818  )
01819   goto tolua_lerror;
01820  else
01821 #endif
01822  {
01823   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01824 #ifndef TOLUA_RELEASE
01825   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
01826 #endif
01827   Mtolua_delete(self);
01828  }
01829  return 0;
01830 #ifndef TOLUA_RELEASE
01831  tolua_lerror:
01832  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
01833  return 0;
01834 #endif
01835 }
01836 #endif //#ifndef TOLUA_DISABLE
01837 
01838 /* method: reset of class  fawkes::HomTransform */
01839 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_reset00
01840 static int tolua_fawkesgeometry_fawkes_HomTransform_reset00(lua_State* tolua_S)
01841 {
01842 #ifndef TOLUA_RELEASE
01843  tolua_Error tolua_err;
01844  if (
01845      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01846      !tolua_isnoobj(tolua_S,2,&tolua_err)
01847  )
01848   goto tolua_lerror;
01849  else
01850 #endif
01851  {
01852   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01853 #ifndef TOLUA_RELEASE
01854   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reset'", NULL);
01855 #endif
01856   {
01857    fawkes::HomTransform& tolua_ret = (fawkes::HomTransform&)  self->reset();
01858     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomTransform");
01859   }
01860  }
01861  return 1;
01862 #ifndef TOLUA_RELEASE
01863  tolua_lerror:
01864  tolua_error(tolua_S,"#ferror in function 'reset'.",&tolua_err);
01865  return 0;
01866 #endif
01867 }
01868 #endif //#ifndef TOLUA_DISABLE
01869 
01870 /* method: invert of class  fawkes::HomTransform */
01871 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_invert00
01872 static int tolua_fawkesgeometry_fawkes_HomTransform_invert00(lua_State* tolua_S)
01873 {
01874 #ifndef TOLUA_RELEASE
01875  tolua_Error tolua_err;
01876  if (
01877      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01878      !tolua_isnoobj(tolua_S,2,&tolua_err)
01879  )
01880   goto tolua_lerror;
01881  else
01882 #endif
01883  {
01884   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01885 #ifndef TOLUA_RELEASE
01886   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'invert'", NULL);
01887 #endif
01888   {
01889    fawkes::HomTransform& tolua_ret = (fawkes::HomTransform&)  self->invert();
01890     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomTransform");
01891   }
01892  }
01893  return 1;
01894 #ifndef TOLUA_RELEASE
01895  tolua_lerror:
01896  tolua_error(tolua_S,"#ferror in function 'invert'.",&tolua_err);
01897  return 0;
01898 #endif
01899 }
01900 #endif //#ifndef TOLUA_DISABLE
01901 
01902 /* method: get_inverse of class  fawkes::HomTransform */
01903 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_get_inverse00
01904 static int tolua_fawkesgeometry_fawkes_HomTransform_get_inverse00(lua_State* tolua_S)
01905 {
01906 #ifndef TOLUA_RELEASE
01907  tolua_Error tolua_err;
01908  if (
01909      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01910      !tolua_isnoobj(tolua_S,2,&tolua_err)
01911  )
01912   goto tolua_lerror;
01913  else
01914 #endif
01915  {
01916   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01917 #ifndef TOLUA_RELEASE
01918   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_inverse'", NULL);
01919 #endif
01920   {
01921    fawkes::HomTransform tolua_ret = (fawkes::HomTransform)  self->get_inverse();
01922    {
01923 #ifdef __cplusplus
01924     void* tolua_obj = Mtolua_new((fawkes::HomTransform)(tolua_ret));
01925      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomTransform");
01926     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01927 #else
01928     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomTransform));
01929      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomTransform");
01930     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
01931 #endif
01932    }
01933   }
01934  }
01935  return 1;
01936 #ifndef TOLUA_RELEASE
01937  tolua_lerror:
01938  tolua_error(tolua_S,"#ferror in function 'get_inverse'.",&tolua_err);
01939  return 0;
01940 #endif
01941 }
01942 #endif //#ifndef TOLUA_DISABLE
01943 
01944 /* method: rotate_x of class  fawkes::HomTransform */
01945 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_rotate_x00
01946 static int tolua_fawkesgeometry_fawkes_HomTransform_rotate_x00(lua_State* tolua_S)
01947 {
01948 #ifndef TOLUA_RELEASE
01949  tolua_Error tolua_err;
01950  if (
01951      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01952      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01953      !tolua_isnoobj(tolua_S,3,&tolua_err)
01954  )
01955   goto tolua_lerror;
01956  else
01957 #endif
01958  {
01959   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01960   float rad = ((float)  tolua_tonumber(tolua_S,2,0));
01961 #ifndef TOLUA_RELEASE
01962   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotate_x'", NULL);
01963 #endif
01964   {
01965    self->rotate_x(rad);
01966   }
01967  }
01968  return 0;
01969 #ifndef TOLUA_RELEASE
01970  tolua_lerror:
01971  tolua_error(tolua_S,"#ferror in function 'rotate_x'.",&tolua_err);
01972  return 0;
01973 #endif
01974 }
01975 #endif //#ifndef TOLUA_DISABLE
01976 
01977 /* method: rotate_y of class  fawkes::HomTransform */
01978 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_rotate_y00
01979 static int tolua_fawkesgeometry_fawkes_HomTransform_rotate_y00(lua_State* tolua_S)
01980 {
01981 #ifndef TOLUA_RELEASE
01982  tolua_Error tolua_err;
01983  if (
01984      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
01985      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01986      !tolua_isnoobj(tolua_S,3,&tolua_err)
01987  )
01988   goto tolua_lerror;
01989  else
01990 #endif
01991  {
01992   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
01993   float rad = ((float)  tolua_tonumber(tolua_S,2,0));
01994 #ifndef TOLUA_RELEASE
01995   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotate_y'", NULL);
01996 #endif
01997   {
01998    self->rotate_y(rad);
01999   }
02000  }
02001  return 0;
02002 #ifndef TOLUA_RELEASE
02003  tolua_lerror:
02004  tolua_error(tolua_S,"#ferror in function 'rotate_y'.",&tolua_err);
02005  return 0;
02006 #endif
02007 }
02008 #endif //#ifndef TOLUA_DISABLE
02009 
02010 /* method: rotate_z of class  fawkes::HomTransform */
02011 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_rotate_z00
02012 static int tolua_fawkesgeometry_fawkes_HomTransform_rotate_z00(lua_State* tolua_S)
02013 {
02014 #ifndef TOLUA_RELEASE
02015  tolua_Error tolua_err;
02016  if (
02017      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
02018      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02019      !tolua_isnoobj(tolua_S,3,&tolua_err)
02020  )
02021   goto tolua_lerror;
02022  else
02023 #endif
02024  {
02025   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
02026   float rad = ((float)  tolua_tonumber(tolua_S,2,0));
02027 #ifndef TOLUA_RELEASE
02028   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotate_z'", NULL);
02029 #endif
02030   {
02031    self->rotate_z(rad);
02032   }
02033  }
02034  return 0;
02035 #ifndef TOLUA_RELEASE
02036  tolua_lerror:
02037  tolua_error(tolua_S,"#ferror in function 'rotate_z'.",&tolua_err);
02038  return 0;
02039 #endif
02040 }
02041 #endif //#ifndef TOLUA_DISABLE
02042 
02043 /* method: trans of class  fawkes::HomTransform */
02044 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_trans00
02045 static int tolua_fawkesgeometry_fawkes_HomTransform_trans00(lua_State* tolua_S)
02046 {
02047 #ifndef TOLUA_RELEASE
02048  tolua_Error tolua_err;
02049  if (
02050      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
02051      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02052      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02053      !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
02054      !tolua_isnoobj(tolua_S,5,&tolua_err)
02055  )
02056   goto tolua_lerror;
02057  else
02058 #endif
02059  {
02060   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
02061   float dx = ((float)  tolua_tonumber(tolua_S,2,0));
02062   float dy = ((float)  tolua_tonumber(tolua_S,3,0));
02063   float dz = ((float)  tolua_tonumber(tolua_S,4,0.0));
02064 #ifndef TOLUA_RELEASE
02065   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'trans'", NULL);
02066 #endif
02067   {
02068    self->trans(dx,dy,dz);
02069   }
02070  }
02071  return 0;
02072 #ifndef TOLUA_RELEASE
02073  tolua_lerror:
02074  tolua_error(tolua_S,"#ferror in function 'trans'.",&tolua_err);
02075  return 0;
02076 #endif
02077 }
02078 #endif //#ifndef TOLUA_DISABLE
02079 
02080 /* method: set_trans of class  fawkes::HomTransform */
02081 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_set_trans00
02082 static int tolua_fawkesgeometry_fawkes_HomTransform_set_trans00(lua_State* tolua_S)
02083 {
02084 #ifndef TOLUA_RELEASE
02085  tolua_Error tolua_err;
02086  if (
02087      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
02088      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02089      !tolua_isnumber(tolua_S,3,0,&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   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
02098   float x = ((float)  tolua_tonumber(tolua_S,2,0));
02099   float y = ((float)  tolua_tonumber(tolua_S,3,0));
02100   float z = ((float)  tolua_tonumber(tolua_S,4,0.0));
02101 #ifndef TOLUA_RELEASE
02102   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_trans'", NULL);
02103 #endif
02104   {
02105    self->set_trans(x,y,z);
02106   }
02107  }
02108  return 0;
02109 #ifndef TOLUA_RELEASE
02110  tolua_lerror:
02111  tolua_error(tolua_S,"#ferror in function 'set_trans'.",&tolua_err);
02112  return 0;
02113 #endif
02114 }
02115 #endif //#ifndef TOLUA_DISABLE
02116 
02117 /* method: mDH of class  fawkes::HomTransform */
02118 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_mDH00
02119 static int tolua_fawkesgeometry_fawkes_HomTransform_mDH00(lua_State* tolua_S)
02120 {
02121 #ifndef TOLUA_RELEASE
02122  tolua_Error tolua_err;
02123  if (
02124      !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
02125      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02126      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
02127      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
02128      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
02129      !tolua_isnoobj(tolua_S,6,&tolua_err)
02130  )
02131   goto tolua_lerror;
02132  else
02133 #endif
02134  {
02135   fawkes::HomTransform* self = (fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
02136   const float alpha = ((const float)  tolua_tonumber(tolua_S,2,0));
02137   const float a = ((const float)  tolua_tonumber(tolua_S,3,0));
02138   const float theta = ((const float)  tolua_tonumber(tolua_S,4,0));
02139   const float d = ((const float)  tolua_tonumber(tolua_S,5,0));
02140 #ifndef TOLUA_RELEASE
02141   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mDH'", NULL);
02142 #endif
02143   {
02144    self->mDH(alpha,a,theta,d);
02145   }
02146  }
02147  return 0;
02148 #ifndef TOLUA_RELEASE
02149  tolua_lerror:
02150  tolua_error(tolua_S,"#ferror in function 'mDH'.",&tolua_err);
02151  return 0;
02152 #endif
02153 }
02154 #endif //#ifndef TOLUA_DISABLE
02155 
02156 /* method: operator* of class  fawkes::HomTransform */
02157 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform__mul00
02158 static int tolua_fawkesgeometry_fawkes_HomTransform__mul00(lua_State* tolua_S)
02159 {
02160 #ifndef TOLUA_RELEASE
02161  tolua_Error tolua_err;
02162  if (
02163      !tolua_isusertype(tolua_S,1,"const fawkes::HomTransform",0,&tolua_err) ||
02164      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomVector",0,&tolua_err)) ||
02165      !tolua_isnoobj(tolua_S,3,&tolua_err)
02166  )
02167   goto tolua_lerror;
02168  else
02169 #endif
02170  {
02171   const fawkes::HomTransform* self = (const fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
02172   const fawkes::HomVector* v = ((const fawkes::HomVector*)  tolua_tousertype(tolua_S,2,0));
02173 #ifndef TOLUA_RELEASE
02174   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", NULL);
02175 #endif
02176   {
02177    fawkes::HomVector tolua_ret = (fawkes::HomVector)  self->operator*(*v);
02178    {
02179 #ifdef __cplusplus
02180     void* tolua_obj = Mtolua_new((fawkes::HomVector)(tolua_ret));
02181      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomVector");
02182     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02183 #else
02184     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomVector));
02185      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomVector");
02186     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02187 #endif
02188    }
02189   }
02190  }
02191  return 1;
02192 #ifndef TOLUA_RELEASE
02193  tolua_lerror:
02194  tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err);
02195  return 0;
02196 #endif
02197 }
02198 #endif //#ifndef TOLUA_DISABLE
02199 
02200 /* method: operator* of class  fawkes::HomTransform */
02201 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform__mul01
02202 static int tolua_fawkesgeometry_fawkes_HomTransform__mul01(lua_State* tolua_S)
02203 {
02204  tolua_Error tolua_err;
02205  if (
02206      !tolua_isusertype(tolua_S,1,"const fawkes::HomTransform",0,&tolua_err) ||
02207      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPoint",0,&tolua_err)) ||
02208      !tolua_isnoobj(tolua_S,3,&tolua_err)
02209  )
02210   goto tolua_lerror;
02211  else
02212  {
02213   const fawkes::HomTransform* self = (const fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
02214   const fawkes::HomPoint* p = ((const fawkes::HomPoint*)  tolua_tousertype(tolua_S,2,0));
02215 #ifndef TOLUA_RELEASE
02216   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", NULL);
02217 #endif
02218   {
02219    fawkes::HomPoint tolua_ret = (fawkes::HomPoint)  self->operator*(*p);
02220    {
02221 #ifdef __cplusplus
02222     void* tolua_obj = Mtolua_new((fawkes::HomPoint)(tolua_ret));
02223      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomPoint");
02224     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02225 #else
02226     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomPoint));
02227      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomPoint");
02228     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02229 #endif
02230    }
02231   }
02232  }
02233  return 1;
02234 tolua_lerror:
02235  return tolua_fawkesgeometry_fawkes_HomTransform__mul00(tolua_S);
02236 }
02237 #endif //#ifndef TOLUA_DISABLE
02238 
02239 /* method: operator* of class  fawkes::HomTransform */
02240 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform__mul02
02241 static int tolua_fawkesgeometry_fawkes_HomTransform__mul02(lua_State* tolua_S)
02242 {
02243  tolua_Error tolua_err;
02244  if (
02245      !tolua_isusertype(tolua_S,1,"const fawkes::HomTransform",0,&tolua_err) ||
02246      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPose2d",0,&tolua_err)) ||
02247      !tolua_isnoobj(tolua_S,3,&tolua_err)
02248  )
02249   goto tolua_lerror;
02250  else
02251  {
02252   const fawkes::HomTransform* self = (const fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
02253   const fawkes::HomPose2d* p = ((const fawkes::HomPose2d*)  tolua_tousertype(tolua_S,2,0));
02254 #ifndef TOLUA_RELEASE
02255   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", NULL);
02256 #endif
02257   {
02258    fawkes::HomPose2d tolua_ret = (fawkes::HomPose2d)  self->operator*(*p);
02259    {
02260 #ifdef __cplusplus
02261     void* tolua_obj = Mtolua_new((fawkes::HomPose2d)(tolua_ret));
02262      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomPose2d");
02263     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02264 #else
02265     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomPose2d));
02266      tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomPose2d");
02267     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02268 #endif
02269    }
02270   }
02271  }
02272  return 1;
02273 tolua_lerror:
02274  return tolua_fawkesgeometry_fawkes_HomTransform__mul01(tolua_S);
02275 }
02276 #endif //#ifndef TOLUA_DISABLE
02277 
02278 /* method: operator== of class  fawkes::HomTransform */
02279 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform__eq00
02280 static int tolua_fawkesgeometry_fawkes_HomTransform__eq00(lua_State* tolua_S)
02281 {
02282 #ifndef TOLUA_RELEASE
02283  tolua_Error tolua_err;
02284  if (
02285      !tolua_isusertype(tolua_S,1,"const fawkes::HomTransform",0,&tolua_err) ||
02286      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomTransform",0,&tolua_err)) ||
02287      !tolua_isnoobj(tolua_S,3,&tolua_err)
02288  )
02289   goto tolua_lerror;
02290  else
02291 #endif
02292  {
02293   const fawkes::HomTransform* self = (const fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
02294   const fawkes::HomTransform* t = ((const fawkes::HomTransform*)  tolua_tousertype(tolua_S,2,0));
02295 #ifndef TOLUA_RELEASE
02296   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
02297 #endif
02298   {
02299    bool tolua_ret = (bool)  self->operator==(*t);
02300    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02301   }
02302  }
02303  return 1;
02304 #ifndef TOLUA_RELEASE
02305  tolua_lerror:
02306  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
02307  return 0;
02308 #endif
02309 }
02310 #endif //#ifndef TOLUA_DISABLE
02311 
02312 /* method: print_info of class  fawkes::HomTransform */
02313 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_print_info00
02314 static int tolua_fawkesgeometry_fawkes_HomTransform_print_info00(lua_State* tolua_S)
02315 {
02316 #ifndef TOLUA_RELEASE
02317  tolua_Error tolua_err;
02318  if (
02319      !tolua_isusertype(tolua_S,1,"const fawkes::HomTransform",0,&tolua_err) ||
02320      !tolua_isstring(tolua_S,2,1,&tolua_err) ||
02321      !tolua_isstring(tolua_S,3,1,&tolua_err) ||
02322      !tolua_isstring(tolua_S,4,1,&tolua_err) ||
02323      !tolua_isnoobj(tolua_S,5,&tolua_err)
02324  )
02325   goto tolua_lerror;
02326  else
02327 #endif
02328  {
02329   const fawkes::HomTransform* self = (const fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
02330   const char* name = ((const char*)  tolua_tostring(tolua_S,2,0));
02331   const char* col_sep = ((const char*)  tolua_tostring(tolua_S,3,0));
02332   const char* row_sep = ((const char*)  tolua_tostring(tolua_S,4,0));
02333 #ifndef TOLUA_RELEASE
02334   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'print_info'", NULL);
02335 #endif
02336   {
02337    self->print_info(name,col_sep,row_sep);
02338   }
02339  }
02340  return 0;
02341 #ifndef TOLUA_RELEASE
02342  tolua_lerror:
02343  tolua_error(tolua_S,"#ferror in function 'print_info'.",&tolua_err);
02344  return 0;
02345 #endif
02346 }
02347 #endif //#ifndef TOLUA_DISABLE
02348 
02349 /* method: get_matrix of class  fawkes::HomTransform */
02350 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_get_matrix00
02351 static int tolua_fawkesgeometry_fawkes_HomTransform_get_matrix00(lua_State* tolua_S)
02352 {
02353 #ifndef TOLUA_RELEASE
02354  tolua_Error tolua_err;
02355  if (
02356      !tolua_isusertype(tolua_S,1,"const fawkes::HomTransform",0,&tolua_err) ||
02357      !tolua_isnoobj(tolua_S,2,&tolua_err)
02358  )
02359   goto tolua_lerror;
02360  else
02361 #endif
02362  {
02363   const fawkes::HomTransform* self = (const fawkes::HomTransform*)  tolua_tousertype(tolua_S,1,0);
02364 #ifndef TOLUA_RELEASE
02365   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_matrix'", NULL);
02366 #endif
02367   {
02368    const fawkes::Matrix& tolua_ret = (const fawkes::Matrix&)  self->get_matrix();
02369     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const fawkes::Matrix");
02370   }
02371  }
02372  return 1;
02373 #ifndef TOLUA_RELEASE
02374  tolua_lerror:
02375  tolua_error(tolua_S,"#ferror in function 'get_matrix'.",&tolua_err);
02376  return 0;
02377 #endif
02378 }
02379 #endif //#ifndef TOLUA_DISABLE
02380 
02381 /* method: new of class  fawkes::HomVector */
02382 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_new00
02383 static int tolua_fawkesgeometry_fawkes_HomVector_new00(lua_State* tolua_S)
02384 {
02385 #ifndef TOLUA_RELEASE
02386  tolua_Error tolua_err;
02387  if (
02388      !tolua_isusertable(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
02389      !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
02390      !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
02391      !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
02392      !tolua_isnoobj(tolua_S,5,&tolua_err)
02393  )
02394   goto tolua_lerror;
02395  else
02396 #endif
02397  {
02398   float x = ((float)  tolua_tonumber(tolua_S,2,0));
02399   float y = ((float)  tolua_tonumber(tolua_S,3,0));
02400   float z = ((float)  tolua_tonumber(tolua_S,4,0));
02401   {
02402    fawkes::HomVector* tolua_ret = (fawkes::HomVector*)  Mtolua_new((fawkes::HomVector)(x,y,z));
02403     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomVector");
02404   }
02405  }
02406  return 1;
02407 #ifndef TOLUA_RELEASE
02408  tolua_lerror:
02409  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02410  return 0;
02411 #endif
02412 }
02413 #endif //#ifndef TOLUA_DISABLE
02414 
02415 /* method: new_local of class  fawkes::HomVector */
02416 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_new00_local
02417 static int tolua_fawkesgeometry_fawkes_HomVector_new00_local(lua_State* tolua_S)
02418 {
02419 #ifndef TOLUA_RELEASE
02420  tolua_Error tolua_err;
02421  if (
02422      !tolua_isusertable(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
02423      !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
02424      !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
02425      !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
02426      !tolua_isnoobj(tolua_S,5,&tolua_err)
02427  )
02428   goto tolua_lerror;
02429  else
02430 #endif
02431  {
02432   float x = ((float)  tolua_tonumber(tolua_S,2,0));
02433   float y = ((float)  tolua_tonumber(tolua_S,3,0));
02434   float z = ((float)  tolua_tonumber(tolua_S,4,0));
02435   {
02436    fawkes::HomVector* tolua_ret = (fawkes::HomVector*)  Mtolua_new((fawkes::HomVector)(x,y,z));
02437     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomVector");
02438     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02439   }
02440  }
02441  return 1;
02442 #ifndef TOLUA_RELEASE
02443  tolua_lerror:
02444  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
02445  return 0;
02446 #endif
02447 }
02448 #endif //#ifndef TOLUA_DISABLE
02449 
02450 /* method: new of class  fawkes::HomVector */
02451 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_new01
02452 static int tolua_fawkesgeometry_fawkes_HomVector_new01(lua_State* tolua_S)
02453 {
02454  tolua_Error tolua_err;
02455  if (
02456      !tolua_isusertable(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
02457      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
02458      !tolua_isnoobj(tolua_S,3,&tolua_err)
02459  )
02460   goto tolua_lerror;
02461  else
02462  {
02463   const fawkes::HomCoord* h = ((const fawkes::HomCoord*)  tolua_tousertype(tolua_S,2,0));
02464   {
02465    fawkes::HomVector* tolua_ret = (fawkes::HomVector*)  Mtolua_new((fawkes::HomVector)(*h));
02466     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomVector");
02467   }
02468  }
02469  return 1;
02470 tolua_lerror:
02471  return tolua_fawkesgeometry_fawkes_HomVector_new00(tolua_S);
02472 }
02473 #endif //#ifndef TOLUA_DISABLE
02474 
02475 /* method: new_local of class  fawkes::HomVector */
02476 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_new01_local
02477 static int tolua_fawkesgeometry_fawkes_HomVector_new01_local(lua_State* tolua_S)
02478 {
02479  tolua_Error tolua_err;
02480  if (
02481      !tolua_isusertable(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
02482      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
02483      !tolua_isnoobj(tolua_S,3,&tolua_err)
02484  )
02485   goto tolua_lerror;
02486  else
02487  {
02488   const fawkes::HomCoord* h = ((const fawkes::HomCoord*)  tolua_tousertype(tolua_S,2,0));
02489   {
02490    fawkes::HomVector* tolua_ret = (fawkes::HomVector*)  Mtolua_new((fawkes::HomVector)(*h));
02491     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomVector");
02492     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
02493   }
02494  }
02495  return 1;
02496 tolua_lerror:
02497  return tolua_fawkesgeometry_fawkes_HomVector_new00_local(tolua_S);
02498 }
02499 #endif //#ifndef TOLUA_DISABLE
02500 
02501 /* method: delete of class  fawkes::HomVector */
02502 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_delete00
02503 static int tolua_fawkesgeometry_fawkes_HomVector_delete00(lua_State* tolua_S)
02504 {
02505 #ifndef TOLUA_RELEASE
02506  tolua_Error tolua_err;
02507  if (
02508      !tolua_isusertype(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
02509      !tolua_isnoobj(tolua_S,2,&tolua_err)
02510  )
02511   goto tolua_lerror;
02512  else
02513 #endif
02514  {
02515   fawkes::HomVector* self = (fawkes::HomVector*)  tolua_tousertype(tolua_S,1,0);
02516 #ifndef TOLUA_RELEASE
02517   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
02518 #endif
02519   Mtolua_delete(self);
02520  }
02521  return 0;
02522 #ifndef TOLUA_RELEASE
02523  tolua_lerror:
02524  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
02525  return 0;
02526 #endif
02527 }
02528 #endif //#ifndef TOLUA_DISABLE
02529 
02530 /* method: length of class  fawkes::HomVector */
02531 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_length00
02532 static int tolua_fawkesgeometry_fawkes_HomVector_length00(lua_State* tolua_S)
02533 {
02534 #ifndef TOLUA_RELEASE
02535  tolua_Error tolua_err;
02536  if (
02537      !tolua_isusertype(tolua_S,1,"const fawkes::HomVector",0,&tolua_err) ||
02538      !tolua_isnoobj(tolua_S,2,&tolua_err)
02539  )
02540   goto tolua_lerror;
02541  else
02542 #endif
02543  {
02544   const fawkes::HomVector* self = (const fawkes::HomVector*)  tolua_tousertype(tolua_S,1,0);
02545 #ifndef TOLUA_RELEASE
02546   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'length'", NULL);
02547 #endif
02548   {
02549    float tolua_ret = (float)  self->length();
02550    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02551   }
02552  }
02553  return 1;
02554 #ifndef TOLUA_RELEASE
02555  tolua_lerror:
02556  tolua_error(tolua_S,"#ferror in function 'length'.",&tolua_err);
02557  return 0;
02558 #endif
02559 }
02560 #endif //#ifndef TOLUA_DISABLE
02561 
02562 /* method: set_length of class  fawkes::HomVector */
02563 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_set_length00
02564 static int tolua_fawkesgeometry_fawkes_HomVector_set_length00(lua_State* tolua_S)
02565 {
02566 #ifndef TOLUA_RELEASE
02567  tolua_Error tolua_err;
02568  if (
02569      !tolua_isusertype(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
02570      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
02571      !tolua_isnoobj(tolua_S,3,&tolua_err)
02572  )
02573   goto tolua_lerror;
02574  else
02575 #endif
02576  {
02577   fawkes::HomVector* self = (fawkes::HomVector*)  tolua_tousertype(tolua_S,1,0);
02578   float length = ((float)  tolua_tonumber(tolua_S,2,0));
02579 #ifndef TOLUA_RELEASE
02580   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_length'", NULL);
02581 #endif
02582   {
02583    fawkes::HomVector& tolua_ret = (fawkes::HomVector&)  self->set_length(length);
02584     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomVector");
02585   }
02586  }
02587  return 1;
02588 #ifndef TOLUA_RELEASE
02589  tolua_lerror:
02590  tolua_error(tolua_S,"#ferror in function 'set_length'.",&tolua_err);
02591  return 0;
02592 #endif
02593 }
02594 #endif //#ifndef TOLUA_DISABLE
02595 
02596 /* method: unit of class  fawkes::HomVector */
02597 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_unit00
02598 static int tolua_fawkesgeometry_fawkes_HomVector_unit00(lua_State* tolua_S)
02599 {
02600 #ifndef TOLUA_RELEASE
02601  tolua_Error tolua_err;
02602  if (
02603      !tolua_isusertype(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
02604      !tolua_isnoobj(tolua_S,2,&tolua_err)
02605  )
02606   goto tolua_lerror;
02607  else
02608 #endif
02609  {
02610   fawkes::HomVector* self = (fawkes::HomVector*)  tolua_tousertype(tolua_S,1,0);
02611 #ifndef TOLUA_RELEASE
02612   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unit'", NULL);
02613 #endif
02614   {
02615    fawkes::HomVector& tolua_ret = (fawkes::HomVector&)  self->unit();
02616     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomVector");
02617   }
02618  }
02619  return 1;
02620 #ifndef TOLUA_RELEASE
02621  tolua_lerror:
02622  tolua_error(tolua_S,"#ferror in function 'unit'.",&tolua_err);
02623  return 0;
02624 #endif
02625 }
02626 #endif //#ifndef TOLUA_DISABLE
02627 
02628 /* method: angle_xy of class  fawkes::HomVector */
02629 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_angle_xy00
02630 static int tolua_fawkesgeometry_fawkes_HomVector_angle_xy00(lua_State* tolua_S)
02631 {
02632 #ifndef TOLUA_RELEASE
02633  tolua_Error tolua_err;
02634  if (
02635      !tolua_isusertype(tolua_S,1,"const fawkes::HomVector",0,&tolua_err) ||
02636      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomVector",0,&tolua_err)) ||
02637      !tolua_isnoobj(tolua_S,3,&tolua_err)
02638  )
02639   goto tolua_lerror;
02640  else
02641 #endif
02642  {
02643   const fawkes::HomVector* self = (const fawkes::HomVector*)  tolua_tousertype(tolua_S,1,0);
02644   const fawkes::HomVector* h = ((const fawkes::HomVector*)  tolua_tousertype(tolua_S,2,0));
02645 #ifndef TOLUA_RELEASE
02646   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'angle_xy'", NULL);
02647 #endif
02648   {
02649    float tolua_ret = (float)  self->angle_xy(*h);
02650    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
02651   }
02652  }
02653  return 1;
02654 #ifndef TOLUA_RELEASE
02655  tolua_lerror:
02656  tolua_error(tolua_S,"#ferror in function 'angle_xy'.",&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,"HomPoint","fawkes::HomPoint","fawkes::HomCoord",tolua_collect_fawkes__HomPoint);
02708    #else
02709    tolua_cclass(tolua_S,"HomPoint","fawkes::HomPoint","fawkes::HomCoord",NULL);
02710    #endif
02711    tolua_beginmodule(tolua_S,"HomPoint");
02712     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomPoint_new00);
02713     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomPoint_new00_local);
02714     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomPoint_new00_local);
02715     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomPoint_new01);
02716     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomPoint_new01_local);
02717     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomPoint_new01_local);
02718     tolua_function(tolua_S,"delete",tolua_fawkesgeometry_fawkes_HomPoint_delete00);
02719     tolua_function(tolua_S,"distance",tolua_fawkesgeometry_fawkes_HomPoint_distance00);
02720     tolua_function(tolua_S,"move",tolua_fawkesgeometry_fawkes_HomPoint_move00);
02721     tolua_function(tolua_S,"move_to",tolua_fawkesgeometry_fawkes_HomPoint_move_to00);
02722     tolua_function(tolua_S,".sub",tolua_fawkesgeometry_fawkes_HomPoint__sub00);
02723    tolua_endmodule(tolua_S);
02724   tolua_endmodule(tolua_S);
02725   tolua_module(tolua_S,"fawkes",0);
02726   tolua_beginmodule(tolua_S,"fawkes");
02727    #ifdef __cplusplus
02728    tolua_cclass(tolua_S,"HomPose2d","fawkes::HomPose2d","Transformable",tolua_collect_fawkes__HomPose2d);
02729    #else
02730    tolua_cclass(tolua_S,"HomPose2d","fawkes::HomPose2d","Transformable",NULL);
02731    #endif
02732    tolua_beginmodule(tolua_S,"HomPose2d");
02733     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomPose2d_new00);
02734     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomPose2d_new00_local);
02735     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomPose2d_new00_local);
02736     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomPose2d_new01);
02737     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomPose2d_new01_local);
02738     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomPose2d_new01_local);
02739     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomPose2d_new02);
02740     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomPose2d_new02_local);
02741     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomPose2d_new02_local);
02742     tolua_function(tolua_S,"delete",tolua_fawkesgeometry_fawkes_HomPose2d_delete00);
02743     tolua_function(tolua_S,"x",tolua_fawkesgeometry_fawkes_HomPose2d_x00);
02744     tolua_function(tolua_S,"x",tolua_fawkesgeometry_fawkes_HomPose2d_x01);
02745     tolua_function(tolua_S,"y",tolua_fawkesgeometry_fawkes_HomPose2d_y00);
02746     tolua_function(tolua_S,"y",tolua_fawkesgeometry_fawkes_HomPose2d_y01);
02747     tolua_function(tolua_S,"yaw",tolua_fawkesgeometry_fawkes_HomPose2d_yaw00);
02748     tolua_function(tolua_S,"yaw",tolua_fawkesgeometry_fawkes_HomPose2d_yaw01);
02749     tolua_function(tolua_S,"position",tolua_fawkesgeometry_fawkes_HomPose2d_position00);
02750     tolua_function(tolua_S,"orientation",tolua_fawkesgeometry_fawkes_HomPose2d_orientation00);
02751     tolua_function(tolua_S,"set_position",tolua_fawkesgeometry_fawkes_HomPose2d_set_position00);
02752    tolua_endmodule(tolua_S);
02753   tolua_endmodule(tolua_S);
02754   tolua_module(tolua_S,"fawkes",0);
02755   tolua_beginmodule(tolua_S,"fawkes");
02756    #ifdef __cplusplus
02757    tolua_cclass(tolua_S,"HomTransform","fawkes::HomTransform","",tolua_collect_fawkes__HomTransform);
02758    #else
02759    tolua_cclass(tolua_S,"HomTransform","fawkes::HomTransform","",NULL);
02760    #endif
02761    tolua_beginmodule(tolua_S,"HomTransform");
02762     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomTransform_new00);
02763     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomTransform_new00_local);
02764     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomTransform_new00_local);
02765     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomTransform_new01);
02766     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomTransform_new01_local);
02767     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomTransform_new01_local);
02768     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomTransform_new02);
02769     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomTransform_new02_local);
02770     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomTransform_new02_local);
02771     tolua_function(tolua_S,"delete",tolua_fawkesgeometry_fawkes_HomTransform_delete00);
02772     tolua_function(tolua_S,"reset",tolua_fawkesgeometry_fawkes_HomTransform_reset00);
02773     tolua_function(tolua_S,"invert",tolua_fawkesgeometry_fawkes_HomTransform_invert00);
02774     tolua_function(tolua_S,"get_inverse",tolua_fawkesgeometry_fawkes_HomTransform_get_inverse00);
02775     tolua_function(tolua_S,"rotate_x",tolua_fawkesgeometry_fawkes_HomTransform_rotate_x00);
02776     tolua_function(tolua_S,"rotate_y",tolua_fawkesgeometry_fawkes_HomTransform_rotate_y00);
02777     tolua_function(tolua_S,"rotate_z",tolua_fawkesgeometry_fawkes_HomTransform_rotate_z00);
02778     tolua_function(tolua_S,"trans",tolua_fawkesgeometry_fawkes_HomTransform_trans00);
02779     tolua_function(tolua_S,"set_trans",tolua_fawkesgeometry_fawkes_HomTransform_set_trans00);
02780     tolua_function(tolua_S,"mDH",tolua_fawkesgeometry_fawkes_HomTransform_mDH00);
02781     tolua_function(tolua_S,".mul",tolua_fawkesgeometry_fawkes_HomTransform__mul00);
02782     tolua_function(tolua_S,".mul",tolua_fawkesgeometry_fawkes_HomTransform__mul01);
02783     tolua_function(tolua_S,".mul",tolua_fawkesgeometry_fawkes_HomTransform__mul02);
02784     tolua_function(tolua_S,".eq",tolua_fawkesgeometry_fawkes_HomTransform__eq00);
02785     tolua_function(tolua_S,"print_info",tolua_fawkesgeometry_fawkes_HomTransform_print_info00);
02786     tolua_function(tolua_S,"get_matrix",tolua_fawkesgeometry_fawkes_HomTransform_get_matrix00);
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,"HomVector","fawkes::HomVector","fawkes::HomCoord",tolua_collect_fawkes__HomVector);
02793    #else
02794    tolua_cclass(tolua_S,"HomVector","fawkes::HomVector","fawkes::HomCoord",NULL);
02795    #endif
02796    tolua_beginmodule(tolua_S,"HomVector");
02797     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomVector_new00);
02798     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomVector_new00_local);
02799     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomVector_new00_local);
02800     tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomVector_new01);
02801     tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomVector_new01_local);
02802     tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomVector_new01_local);
02803     tolua_function(tolua_S,"delete",tolua_fawkesgeometry_fawkes_HomVector_delete00);
02804     tolua_function(tolua_S,"length",tolua_fawkesgeometry_fawkes_HomVector_length00);
02805     tolua_function(tolua_S,"set_length",tolua_fawkesgeometry_fawkes_HomVector_set_length00);
02806     tolua_function(tolua_S,"unit",tolua_fawkesgeometry_fawkes_HomVector_unit00);
02807     tolua_function(tolua_S,"angle_xy",tolua_fawkesgeometry_fawkes_HomVector_angle_xy00);
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