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