Fawkes API Fawkes Development Version

fawkesgeometry_tolua.cpp

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