19 #include <core/exception.h> 29 TOLUA_API
int tolua_fawkestf_open (lua_State* tolua_S);
31 #include <tf/types_lua.h> 32 #include <tf/transformer.h> 39 static int tolua_collect_fawkes__tf__StampedTransform (lua_State* tolua_S)
46 static int tolua_collect_fawkes__tf__Quaternion (lua_State* tolua_S)
48 fawkes::tf::Quaternion*
self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
53 static int tolua_collect_fawkes__tf__Stamped_fawkes__tf__Quaternion_ (lua_State* tolua_S)
60 static int tolua_collect_fawkes__tf__Point (lua_State* tolua_S)
62 fawkes::tf::Point*
self = (fawkes::tf::Point*) tolua_tousertype(tolua_S,1,0);
67 static int tolua_collect_fawkes__tf__Pose (lua_State* tolua_S)
69 fawkes::tf::Pose*
self = (fawkes::tf::Pose*) tolua_tousertype(tolua_S,1,0);
74 static int tolua_collect_fawkes__tf__Stamped_fawkes__tf__Pose_ (lua_State* tolua_S)
81 static int tolua_collect_fawkes__tf__Vector3 (lua_State* tolua_S)
83 fawkes::tf::Vector3*
self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
88 static int tolua_collect_fawkes__tf__StampedPose (lua_State* tolua_S)
90 fawkes::tf::StampedPose*
self = (fawkes::tf::StampedPose*) tolua_tousertype(tolua_S,1,0);
95 static int tolua_collect_fawkes__tf__StampedVector3 (lua_State* tolua_S)
97 fawkes::tf::StampedVector3*
self = (fawkes::tf::StampedVector3*) tolua_tousertype(tolua_S,1,0);
102 static int tolua_collect_fawkes__tf__Stamped_fawkes__tf__Point_ (lua_State* tolua_S)
109 static int tolua_collect_fawkes__tf__StampedPoint (lua_State* tolua_S)
111 fawkes::tf::StampedPoint*
self = (fawkes::tf::StampedPoint*) tolua_tousertype(tolua_S,1,0);
116 static int tolua_collect_fawkes__tf__Transform (lua_State* tolua_S)
118 fawkes::tf::Transform*
self = (fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
123 static int tolua_collect_fawkes__tf__StampedQuaternion (lua_State* tolua_S)
125 fawkes::tf::StampedQuaternion*
self = (fawkes::tf::StampedQuaternion*) tolua_tousertype(tolua_S,1,0);
130 static int tolua_collect_fawkes__tf__Stamped_fawkes__tf__Vector3_ (lua_State* tolua_S)
140 static void tolua_reg_types (lua_State* tolua_S)
142 tolua_usertype(tolua_S,
"fawkes::tf::StampedTransform");
143 tolua_usertype(tolua_S,
"fawkes::tf::Quaternion");
144 tolua_usertype(tolua_S,
"fawkes::tf::Stamped<fawkes::tf::Quaternion>");
145 tolua_usertype(tolua_S,
"fawkes::tf::Point");
146 tolua_usertype(tolua_S,
"fawkes::tf::Transformer");
147 tolua_usertype(tolua_S,
"fawkes::tf::Pose");
148 tolua_usertype(tolua_S,
"fawkes::tf::Stamped<fawkes::tf::Pose>");
149 tolua_usertype(tolua_S,
"fawkes::tf::Vector3");
150 tolua_usertype(tolua_S,
"fawkes::tf::StampedPose");
151 tolua_usertype(tolua_S,
"fawkes::tf::StampedQuaternion");
152 tolua_usertype(tolua_S,
"fawkes::tf::StampedVector3");
153 tolua_usertype(tolua_S,
"fawkes::tf::Stamped<fawkes::tf::Point>");
154 tolua_usertype(tolua_S,
"fawkes::tf::StampedPoint");
155 tolua_usertype(tolua_S,
"fawkes::tf::Transform");
156 tolua_usertype(tolua_S,
"fawkes::Time");
157 tolua_usertype(tolua_S,
"fawkes::tf::Stamped<fawkes::tf::Vector3>");
161 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_get_yaw00 162 static int tolua_fawkestf_fawkes_tf_get_yaw00(lua_State* tolua_S)
164 #ifndef TOLUA_RELEASE 165 tolua_Error tolua_err;
167 (tolua_isvaluenil(tolua_S,1,&tolua_err) || !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
168 !tolua_isnoobj(tolua_S,2,&tolua_err)
174 const fawkes::tf::Quaternion* bt_q = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0));
175 bool exc_caught =
false;
178 double tolua_ret = (double) fawkes::tf::get_yaw(*bt_q);
179 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
185 catch (std::exception &e) {
187 lua_pushstring(tolua_S, e.what());
189 if (exc_caught) lua_error(tolua_S);
193 #ifndef TOLUA_RELEASE 195 tolua_error(tolua_S,
"#ferror in function 'get_yaw'.",&tolua_err);
199 #endif //#ifndef TOLUA_DISABLE 202 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_create_quaternion_from_rpy00 203 static int tolua_fawkestf_fawkes_tf_create_quaternion_from_rpy00(lua_State* tolua_S)
205 #ifndef TOLUA_RELEASE 206 tolua_Error tolua_err;
208 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
209 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
210 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
211 !tolua_isnoobj(tolua_S,4,&tolua_err)
217 double roll = ((double) tolua_tonumber(tolua_S,1,0));
218 double pitch = ((double) tolua_tonumber(tolua_S,2,0));
219 double yaw = ((double) tolua_tonumber(tolua_S,3,0));
220 bool exc_caught =
false;
223 fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) fawkes::tf::create_quaternion_from_rpy(roll,pitch,yaw);
226 void* tolua_obj = Mtolua_new((fawkes::tf::Quaternion)(tolua_ret));
227 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Quaternion");
228 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
230 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(fawkes::tf::Quaternion));
231 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Quaternion");
232 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
240 catch (std::exception &e) {
242 lua_pushstring(tolua_S, e.what());
244 if (exc_caught) lua_error(tolua_S);
248 #ifndef TOLUA_RELEASE 250 tolua_error(tolua_S,
"#ferror in function 'create_quaternion_from_rpy'.",&tolua_err);
254 #endif //#ifndef TOLUA_DISABLE 257 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_create_quaternion_from_yaw00 258 static int tolua_fawkestf_fawkes_tf_create_quaternion_from_yaw00(lua_State* tolua_S)
260 #ifndef TOLUA_RELEASE 261 tolua_Error tolua_err;
263 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
264 !tolua_isnoobj(tolua_S,2,&tolua_err)
270 double yaw = ((double) tolua_tonumber(tolua_S,1,0));
271 bool exc_caught =
false;
274 fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) fawkes::tf::create_quaternion_from_yaw(yaw);
277 void* tolua_obj = Mtolua_new((fawkes::tf::Quaternion)(tolua_ret));
278 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Quaternion");
279 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
281 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(fawkes::tf::Quaternion));
282 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Quaternion");
283 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
291 catch (std::exception &e) {
293 lua_pushstring(tolua_S, e.what());
295 if (exc_caught) lua_error(tolua_S);
299 #ifndef TOLUA_RELEASE 301 tolua_error(tolua_S,
"#ferror in function 'create_quaternion_from_yaw'.",&tolua_err);
305 #endif //#ifndef TOLUA_DISABLE 308 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_resize_vector00 309 static int tolua_fawkestf_fawkes_tf_resize_vector00(lua_State* tolua_S)
311 #ifndef TOLUA_RELEASE 312 tolua_Error tolua_err;
314 (tolua_isvaluenil(tolua_S,1,&tolua_err) || !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
315 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
316 !tolua_isnoobj(tolua_S,3,&tolua_err)
322 const fawkes::tf::Vector3* v = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0));
323 double s = ((double) tolua_tonumber(tolua_S,2,0));
324 bool exc_caught =
false;
327 fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) fawkes::tf::resize_vector(*v,s);
330 void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
331 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Vector3");
332 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
334 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(fawkes::tf::Vector3));
335 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Vector3");
336 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
344 catch (std::exception &e) {
346 lua_pushstring(tolua_S, e.what());
348 if (exc_caught) lua_error(tolua_S);
352 #ifndef TOLUA_RELEASE 354 tolua_error(tolua_S,
"#ferror in function 'resize_vector'.",&tolua_err);
358 #endif //#ifndef TOLUA_DISABLE 361 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_new00 362 static int tolua_fawkestf_fawkes_tf_Vector3_new00(lua_State* tolua_S)
364 #ifndef TOLUA_RELEASE 365 tolua_Error tolua_err;
367 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Vector3",0,&tolua_err) ||
368 !tolua_isnoobj(tolua_S,2,&tolua_err)
374 bool exc_caught =
false;
377 fawkes::tf::Vector3* tolua_ret = (fawkes::tf::Vector3*) Mtolua_new((fawkes::tf::Vector3)());
378 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Vector3");
384 catch (std::exception &e) {
386 lua_pushstring(tolua_S, e.what());
388 if (exc_caught) lua_error(tolua_S);
392 #ifndef TOLUA_RELEASE 394 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
398 #endif //#ifndef TOLUA_DISABLE 401 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_new00_local 402 static int tolua_fawkestf_fawkes_tf_Vector3_new00_local(lua_State* tolua_S)
404 #ifndef TOLUA_RELEASE 405 tolua_Error tolua_err;
407 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Vector3",0,&tolua_err) ||
408 !tolua_isnoobj(tolua_S,2,&tolua_err)
414 bool exc_caught =
false;
417 fawkes::tf::Vector3* tolua_ret = (fawkes::tf::Vector3*) Mtolua_new((fawkes::tf::Vector3)());
418 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Vector3");
419 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
425 catch (std::exception &e) {
427 lua_pushstring(tolua_S, e.what());
429 if (exc_caught) lua_error(tolua_S);
433 #ifndef TOLUA_RELEASE 435 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
439 #endif //#ifndef TOLUA_DISABLE 442 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_new01 443 static int tolua_fawkestf_fawkes_tf_Vector3_new01(lua_State* tolua_S)
445 tolua_Error tolua_err;
447 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Vector3",0,&tolua_err) ||
448 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
449 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
450 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
451 !tolua_isnoobj(tolua_S,5,&tolua_err)
456 double x = ((double) tolua_tonumber(tolua_S,2,0));
457 double y = ((double) tolua_tonumber(tolua_S,3,0));
458 double z = ((double) tolua_tonumber(tolua_S,4,0));
459 bool exc_caught =
false;
462 fawkes::tf::Vector3* tolua_ret = (fawkes::tf::Vector3*) Mtolua_new((fawkes::tf::Vector3)(x,y,z));
463 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Vector3");
469 catch (std::exception &e) {
471 lua_pushstring(tolua_S, e.what());
473 if (exc_caught) lua_error(tolua_S);
478 return tolua_fawkestf_fawkes_tf_Vector3_new00(tolua_S);
480 #endif //#ifndef TOLUA_DISABLE 483 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_new01_local 484 static int tolua_fawkestf_fawkes_tf_Vector3_new01_local(lua_State* tolua_S)
486 tolua_Error tolua_err;
488 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Vector3",0,&tolua_err) ||
489 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
490 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
491 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
492 !tolua_isnoobj(tolua_S,5,&tolua_err)
497 double x = ((double) tolua_tonumber(tolua_S,2,0));
498 double y = ((double) tolua_tonumber(tolua_S,3,0));
499 double z = ((double) tolua_tonumber(tolua_S,4,0));
500 bool exc_caught =
false;
503 fawkes::tf::Vector3* tolua_ret = (fawkes::tf::Vector3*) Mtolua_new((fawkes::tf::Vector3)(x,y,z));
504 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Vector3");
505 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
511 catch (std::exception &e) {
513 lua_pushstring(tolua_S, e.what());
515 if (exc_caught) lua_error(tolua_S);
520 return tolua_fawkestf_fawkes_tf_Vector3_new00_local(tolua_S);
522 #endif //#ifndef TOLUA_DISABLE 525 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_dot00 526 static int tolua_fawkestf_fawkes_tf_Vector3_dot00(lua_State* tolua_S)
528 #ifndef TOLUA_RELEASE 529 tolua_Error tolua_err;
531 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Vector3",0,&tolua_err) ||
532 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
533 !tolua_isnoobj(tolua_S,3,&tolua_err)
539 const fawkes::tf::Vector3*
self = (
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
540 const fawkes::tf::Vector3* q = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
541 #ifndef TOLUA_RELEASE 542 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'dot'", NULL);
544 bool exc_caught =
false;
547 double tolua_ret = (double) self->dot(*q);
548 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
554 catch (std::exception &e) {
556 lua_pushstring(tolua_S, e.what());
558 if (exc_caught) lua_error(tolua_S);
562 #ifndef TOLUA_RELEASE 564 tolua_error(tolua_S,
"#ferror in function 'dot'.",&tolua_err);
568 #endif //#ifndef TOLUA_DISABLE 571 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_length200 572 static int tolua_fawkestf_fawkes_tf_Vector3_length200(lua_State* tolua_S)
574 #ifndef TOLUA_RELEASE 575 tolua_Error tolua_err;
577 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Vector3",0,&tolua_err) ||
578 !tolua_isnoobj(tolua_S,2,&tolua_err)
584 const fawkes::tf::Vector3*
self = (
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
585 #ifndef TOLUA_RELEASE 586 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'length2'", NULL);
588 bool exc_caught =
false;
591 double tolua_ret = (double) self->length2();
592 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
598 catch (std::exception &e) {
600 lua_pushstring(tolua_S, e.what());
602 if (exc_caught) lua_error(tolua_S);
606 #ifndef TOLUA_RELEASE 608 tolua_error(tolua_S,
"#ferror in function 'length2'.",&tolua_err);
612 #endif //#ifndef TOLUA_DISABLE 615 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_length00 616 static int tolua_fawkestf_fawkes_tf_Vector3_length00(lua_State* tolua_S)
618 #ifndef TOLUA_RELEASE 619 tolua_Error tolua_err;
621 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Vector3",0,&tolua_err) ||
622 !tolua_isnoobj(tolua_S,2,&tolua_err)
628 const fawkes::tf::Vector3*
self = (
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
629 #ifndef TOLUA_RELEASE 630 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'length'", NULL);
632 bool exc_caught =
false;
635 double tolua_ret = (double) self->length();
636 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
642 catch (std::exception &e) {
644 lua_pushstring(tolua_S, e.what());
646 if (exc_caught) lua_error(tolua_S);
650 #ifndef TOLUA_RELEASE 652 tolua_error(tolua_S,
"#ferror in function 'length'.",&tolua_err);
656 #endif //#ifndef TOLUA_DISABLE 659 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_distance200 660 static int tolua_fawkestf_fawkes_tf_Vector3_distance200(lua_State* tolua_S)
662 #ifndef TOLUA_RELEASE 663 tolua_Error tolua_err;
665 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Vector3",0,&tolua_err) ||
666 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
667 !tolua_isnoobj(tolua_S,3,&tolua_err)
673 const fawkes::tf::Vector3*
self = (
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
674 const fawkes::tf::Vector3* v = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
675 #ifndef TOLUA_RELEASE 676 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'distance2'", NULL);
678 bool exc_caught =
false;
681 double tolua_ret = (double) self->distance2(*v);
682 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
688 catch (std::exception &e) {
690 lua_pushstring(tolua_S, e.what());
692 if (exc_caught) lua_error(tolua_S);
696 #ifndef TOLUA_RELEASE 698 tolua_error(tolua_S,
"#ferror in function 'distance2'.",&tolua_err);
702 #endif //#ifndef TOLUA_DISABLE 705 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_distance00 706 static int tolua_fawkestf_fawkes_tf_Vector3_distance00(lua_State* tolua_S)
708 #ifndef TOLUA_RELEASE 709 tolua_Error tolua_err;
711 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Vector3",0,&tolua_err) ||
712 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
713 !tolua_isnoobj(tolua_S,3,&tolua_err)
719 const fawkes::tf::Vector3*
self = (
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
720 const fawkes::tf::Vector3* v = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
721 #ifndef TOLUA_RELEASE 722 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'distance'", NULL);
724 bool exc_caught =
false;
727 double tolua_ret = (double) self->distance(*v);
728 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
734 catch (std::exception &e) {
736 lua_pushstring(tolua_S, e.what());
738 if (exc_caught) lua_error(tolua_S);
742 #ifndef TOLUA_RELEASE 744 tolua_error(tolua_S,
"#ferror in function 'distance'.",&tolua_err);
748 #endif //#ifndef TOLUA_DISABLE 751 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_normalize00 752 static int tolua_fawkestf_fawkes_tf_Vector3_normalize00(lua_State* tolua_S)
754 #ifndef TOLUA_RELEASE 755 tolua_Error tolua_err;
757 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Vector3",0,&tolua_err) ||
758 !tolua_isnoobj(tolua_S,2,&tolua_err)
764 fawkes::tf::Vector3*
self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
765 #ifndef TOLUA_RELEASE 766 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'normalize'", NULL);
768 bool exc_caught =
false;
771 fawkes::tf::Vector3& tolua_ret = (fawkes::tf::Vector3&) self->normalize();
772 tolua_pushusertype(tolua_S,(
void*)&tolua_ret,
"fawkes::tf::Vector3");
778 catch (std::exception &e) {
780 lua_pushstring(tolua_S, e.what());
782 if (exc_caught) lua_error(tolua_S);
786 #ifndef TOLUA_RELEASE 788 tolua_error(tolua_S,
"#ferror in function 'normalize'.",&tolua_err);
792 #endif //#ifndef TOLUA_DISABLE 795 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_normalized00 796 static int tolua_fawkestf_fawkes_tf_Vector3_normalized00(lua_State* tolua_S)
798 #ifndef TOLUA_RELEASE 799 tolua_Error tolua_err;
801 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Vector3",0,&tolua_err) ||
802 !tolua_isnoobj(tolua_S,2,&tolua_err)
808 fawkes::tf::Vector3*
self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
809 #ifndef TOLUA_RELEASE 810 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'normalized'", NULL);
812 bool exc_caught =
false;
815 fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->normalized();
818 void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
819 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Vector3");
820 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
822 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(fawkes::tf::Vector3));
823 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Vector3");
824 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
832 catch (std::exception &e) {
834 lua_pushstring(tolua_S, e.what());
836 if (exc_caught) lua_error(tolua_S);
840 #ifndef TOLUA_RELEASE 842 tolua_error(tolua_S,
"#ferror in function 'normalized'.",&tolua_err);
846 #endif //#ifndef TOLUA_DISABLE 849 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_rotate00 850 static int tolua_fawkestf_fawkes_tf_Vector3_rotate00(lua_State* tolua_S)
852 #ifndef TOLUA_RELEASE 853 tolua_Error tolua_err;
855 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Vector3",0,&tolua_err) ||
856 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
857 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
858 !tolua_isnoobj(tolua_S,4,&tolua_err)
864 fawkes::tf::Vector3*
self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
865 const fawkes::tf::Vector3* wAxis = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
866 double angle = ((double) tolua_tonumber(tolua_S,3,0));
867 #ifndef TOLUA_RELEASE 868 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'rotate'", NULL);
870 bool exc_caught =
false;
873 fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->rotate(*wAxis,angle);
876 void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
877 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Vector3");
878 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
880 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(fawkes::tf::Vector3));
881 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Vector3");
882 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
890 catch (std::exception &e) {
892 lua_pushstring(tolua_S, e.what());
894 if (exc_caught) lua_error(tolua_S);
898 #ifndef TOLUA_RELEASE 900 tolua_error(tolua_S,
"#ferror in function 'rotate'.",&tolua_err);
904 #endif //#ifndef TOLUA_DISABLE 907 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_angle00 908 static int tolua_fawkestf_fawkes_tf_Vector3_angle00(lua_State* tolua_S)
910 #ifndef TOLUA_RELEASE 911 tolua_Error tolua_err;
913 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Vector3",0,&tolua_err) ||
914 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
915 !tolua_isnoobj(tolua_S,3,&tolua_err)
921 const fawkes::tf::Vector3*
self = (
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
922 const fawkes::tf::Vector3* v = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
923 #ifndef TOLUA_RELEASE 924 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'angle'", NULL);
926 bool exc_caught =
false;
929 double tolua_ret = (double) self->angle(*v);
930 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
936 catch (std::exception &e) {
938 lua_pushstring(tolua_S, e.what());
940 if (exc_caught) lua_error(tolua_S);
944 #ifndef TOLUA_RELEASE 946 tolua_error(tolua_S,
"#ferror in function 'angle'.",&tolua_err);
950 #endif //#ifndef TOLUA_DISABLE 953 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_absolute00 954 static int tolua_fawkestf_fawkes_tf_Vector3_absolute00(lua_State* tolua_S)
956 #ifndef TOLUA_RELEASE 957 tolua_Error tolua_err;
959 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Vector3",0,&tolua_err) ||
960 !tolua_isnoobj(tolua_S,2,&tolua_err)
966 const fawkes::tf::Vector3*
self = (
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
967 #ifndef TOLUA_RELEASE 968 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'absolute'", NULL);
970 bool exc_caught =
false;
973 fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->absolute();
976 void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
977 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Vector3");
978 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
980 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(fawkes::tf::Vector3));
981 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Vector3");
982 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
990 catch (std::exception &e) {
992 lua_pushstring(tolua_S, e.what());
994 if (exc_caught) lua_error(tolua_S);
998 #ifndef TOLUA_RELEASE 1000 tolua_error(tolua_S,
"#ferror in function 'absolute'.",&tolua_err);
1004 #endif //#ifndef TOLUA_DISABLE 1007 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_cross00 1008 static int tolua_fawkestf_fawkes_tf_Vector3_cross00(lua_State* tolua_S)
1010 #ifndef TOLUA_RELEASE 1011 tolua_Error tolua_err;
1013 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Vector3",0,&tolua_err) ||
1014 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
1015 !tolua_isnoobj(tolua_S,3,&tolua_err)
1021 const fawkes::tf::Vector3*
self = (
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1022 const fawkes::tf::Vector3* v = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
1023 #ifndef TOLUA_RELEASE 1024 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'cross'", NULL);
1026 bool exc_caught =
false;
1029 fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->cross(*v);
1032 void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
1033 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Vector3");
1034 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1036 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(fawkes::tf::Vector3));
1037 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Vector3");
1038 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1046 catch (std::exception &e) {
1048 lua_pushstring(tolua_S, e.what());
1050 if (exc_caught) lua_error(tolua_S);
1054 #ifndef TOLUA_RELEASE 1056 tolua_error(tolua_S,
"#ferror in function 'cross'.",&tolua_err);
1060 #endif //#ifndef TOLUA_DISABLE 1063 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_triple00 1064 static int tolua_fawkestf_fawkes_tf_Vector3_triple00(lua_State* tolua_S)
1066 #ifndef TOLUA_RELEASE 1067 tolua_Error tolua_err;
1069 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Vector3",0,&tolua_err) ||
1070 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
1071 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"fawkes::tf::Vector3",0,&tolua_err)) ||
1072 !tolua_isnoobj(tolua_S,4,&tolua_err)
1078 const fawkes::tf::Vector3*
self = (
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1079 const fawkes::tf::Vector3* v1 = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
1080 fawkes::tf::Vector3* v2 = ((fawkes::tf::Vector3*) tolua_tousertype(tolua_S,3,0));
1081 #ifndef TOLUA_RELEASE 1082 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'triple'", NULL);
1084 bool exc_caught =
false;
1087 double tolua_ret = (double) self->triple(*v1,*v2);
1088 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1094 catch (std::exception &e) {
1096 lua_pushstring(tolua_S, e.what());
1098 if (exc_caught) lua_error(tolua_S);
1102 #ifndef TOLUA_RELEASE 1104 tolua_error(tolua_S,
"#ferror in function 'triple'.",&tolua_err);
1108 #endif //#ifndef TOLUA_DISABLE 1111 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_minAxis00 1112 static int tolua_fawkestf_fawkes_tf_Vector3_minAxis00(lua_State* tolua_S)
1114 #ifndef TOLUA_RELEASE 1115 tolua_Error tolua_err;
1117 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Vector3",0,&tolua_err) ||
1118 !tolua_isnoobj(tolua_S,2,&tolua_err)
1124 const fawkes::tf::Vector3*
self = (
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1125 #ifndef TOLUA_RELEASE 1126 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'minAxis'", NULL);
1128 bool exc_caught =
false;
1131 int tolua_ret = (int) self->minAxis();
1132 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1138 catch (std::exception &e) {
1140 lua_pushstring(tolua_S, e.what());
1142 if (exc_caught) lua_error(tolua_S);
1146 #ifndef TOLUA_RELEASE 1148 tolua_error(tolua_S,
"#ferror in function 'minAxis'.",&tolua_err);
1152 #endif //#ifndef TOLUA_DISABLE 1155 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_maxAxis00 1156 static int tolua_fawkestf_fawkes_tf_Vector3_maxAxis00(lua_State* tolua_S)
1158 #ifndef TOLUA_RELEASE 1159 tolua_Error tolua_err;
1161 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Vector3",0,&tolua_err) ||
1162 !tolua_isnoobj(tolua_S,2,&tolua_err)
1168 const fawkes::tf::Vector3*
self = (
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1169 #ifndef TOLUA_RELEASE 1170 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'maxAxis'", NULL);
1172 bool exc_caught =
false;
1175 int tolua_ret = (int) self->maxAxis();
1176 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1182 catch (std::exception &e) {
1184 lua_pushstring(tolua_S, e.what());
1186 if (exc_caught) lua_error(tolua_S);
1190 #ifndef TOLUA_RELEASE 1192 tolua_error(tolua_S,
"#ferror in function 'maxAxis'.",&tolua_err);
1196 #endif //#ifndef TOLUA_DISABLE 1199 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_furthestAxis00 1200 static int tolua_fawkestf_fawkes_tf_Vector3_furthestAxis00(lua_State* tolua_S)
1202 #ifndef TOLUA_RELEASE 1203 tolua_Error tolua_err;
1205 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Vector3",0,&tolua_err) ||
1206 !tolua_isnoobj(tolua_S,2,&tolua_err)
1212 const fawkes::tf::Vector3*
self = (
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1213 #ifndef TOLUA_RELEASE 1214 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'furthestAxis'", NULL);
1216 bool exc_caught =
false;
1219 int tolua_ret = (int) self->furthestAxis();
1220 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1226 catch (std::exception &e) {
1228 lua_pushstring(tolua_S, e.what());
1230 if (exc_caught) lua_error(tolua_S);
1234 #ifndef TOLUA_RELEASE 1236 tolua_error(tolua_S,
"#ferror in function 'furthestAxis'.",&tolua_err);
1240 #endif //#ifndef TOLUA_DISABLE 1243 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_closestAxis00 1244 static int tolua_fawkestf_fawkes_tf_Vector3_closestAxis00(lua_State* tolua_S)
1246 #ifndef TOLUA_RELEASE 1247 tolua_Error tolua_err;
1249 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Vector3",0,&tolua_err) ||
1250 !tolua_isnoobj(tolua_S,2,&tolua_err)
1256 const fawkes::tf::Vector3*
self = (
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1257 #ifndef TOLUA_RELEASE 1258 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'closestAxis'", NULL);
1260 bool exc_caught =
false;
1263 int tolua_ret = (int) self->closestAxis();
1264 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1270 catch (std::exception &e) {
1272 lua_pushstring(tolua_S, e.what());
1274 if (exc_caught) lua_error(tolua_S);
1278 #ifndef TOLUA_RELEASE 1280 tolua_error(tolua_S,
"#ferror in function 'closestAxis'.",&tolua_err);
1284 #endif //#ifndef TOLUA_DISABLE 1287 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setInterpolate300 1288 static int tolua_fawkestf_fawkes_tf_Vector3_setInterpolate300(lua_State* tolua_S)
1290 #ifndef TOLUA_RELEASE 1291 tolua_Error tolua_err;
1293 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Vector3",0,&tolua_err) ||
1294 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
1295 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
1296 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
1297 !tolua_isnoobj(tolua_S,5,&tolua_err)
1303 fawkes::tf::Vector3*
self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1304 const fawkes::tf::Vector3* v0 = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
1305 const fawkes::tf::Vector3* v1 = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,3,0));
1306 double rt = ((double) tolua_tonumber(tolua_S,4,0));
1307 #ifndef TOLUA_RELEASE 1308 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'setInterpolate3'", NULL);
1310 bool exc_caught =
false;
1313 self->setInterpolate3(*v0,*v1,rt);
1319 catch (std::exception &e) {
1321 lua_pushstring(tolua_S, e.what());
1323 if (exc_caught) lua_error(tolua_S);
1327 #ifndef TOLUA_RELEASE 1329 tolua_error(tolua_S,
"#ferror in function 'setInterpolate3'.",&tolua_err);
1333 #endif //#ifndef TOLUA_DISABLE 1336 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_lerp00 1337 static int tolua_fawkestf_fawkes_tf_Vector3_lerp00(lua_State* tolua_S)
1339 #ifndef TOLUA_RELEASE 1340 tolua_Error tolua_err;
1342 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Vector3",0,&tolua_err) ||
1343 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
1344 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1345 !tolua_isnoobj(tolua_S,4,&tolua_err)
1351 const fawkes::tf::Vector3*
self = (
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1352 const fawkes::tf::Vector3* v = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
1353 const double t = ((
const double) tolua_tonumber(tolua_S,3,0));
1354 #ifndef TOLUA_RELEASE 1355 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'lerp'", NULL);
1357 bool exc_caught =
false;
1360 fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->lerp(*v,t);
1363 void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
1364 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Vector3");
1365 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1367 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(fawkes::tf::Vector3));
1368 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Vector3");
1369 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1372 tolua_pushnumber(tolua_S,(lua_Number)t);
1378 catch (std::exception &e) {
1380 lua_pushstring(tolua_S, e.what());
1382 if (exc_caught) lua_error(tolua_S);
1386 #ifndef TOLUA_RELEASE 1388 tolua_error(tolua_S,
"#ferror in function 'lerp'.",&tolua_err);
1392 #endif //#ifndef TOLUA_DISABLE 1395 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_x00 1396 static int tolua_fawkestf_fawkes_tf_Vector3_x00(lua_State* tolua_S)
1398 #ifndef TOLUA_RELEASE 1399 tolua_Error tolua_err;
1401 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Vector3",0,&tolua_err) ||
1402 !tolua_isnoobj(tolua_S,2,&tolua_err)
1408 fawkes::tf::Vector3*
self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1409 #ifndef TOLUA_RELEASE 1410 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'x'", NULL);
1412 bool exc_caught =
false;
1415 const double tolua_ret = (
const double) self->x();
1416 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1422 catch (std::exception &e) {
1424 lua_pushstring(tolua_S, e.what());
1426 if (exc_caught) lua_error(tolua_S);
1430 #ifndef TOLUA_RELEASE 1432 tolua_error(tolua_S,
"#ferror in function 'x'.",&tolua_err);
1436 #endif //#ifndef TOLUA_DISABLE 1439 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_y00 1440 static int tolua_fawkestf_fawkes_tf_Vector3_y00(lua_State* tolua_S)
1442 #ifndef TOLUA_RELEASE 1443 tolua_Error tolua_err;
1445 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Vector3",0,&tolua_err) ||
1446 !tolua_isnoobj(tolua_S,2,&tolua_err)
1452 fawkes::tf::Vector3*
self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1453 #ifndef TOLUA_RELEASE 1454 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'y'", NULL);
1456 bool exc_caught =
false;
1459 const double tolua_ret = (
const double) self->y();
1460 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1466 catch (std::exception &e) {
1468 lua_pushstring(tolua_S, e.what());
1470 if (exc_caught) lua_error(tolua_S);
1474 #ifndef TOLUA_RELEASE 1476 tolua_error(tolua_S,
"#ferror in function 'y'.",&tolua_err);
1480 #endif //#ifndef TOLUA_DISABLE 1483 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_z00 1484 static int tolua_fawkestf_fawkes_tf_Vector3_z00(lua_State* tolua_S)
1486 #ifndef TOLUA_RELEASE 1487 tolua_Error tolua_err;
1489 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Vector3",0,&tolua_err) ||
1490 !tolua_isnoobj(tolua_S,2,&tolua_err)
1496 fawkes::tf::Vector3*
self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1497 #ifndef TOLUA_RELEASE 1498 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'z'", NULL);
1500 bool exc_caught =
false;
1503 const double tolua_ret = (
const double) self->z();
1504 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1510 catch (std::exception &e) {
1512 lua_pushstring(tolua_S, e.what());
1514 if (exc_caught) lua_error(tolua_S);
1518 #ifndef TOLUA_RELEASE 1520 tolua_error(tolua_S,
"#ferror in function 'z'.",&tolua_err);
1524 #endif //#ifndef TOLUA_DISABLE 1527 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setX00 1528 static int tolua_fawkestf_fawkes_tf_Vector3_setX00(lua_State* tolua_S)
1530 #ifndef TOLUA_RELEASE 1531 tolua_Error tolua_err;
1533 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Vector3",0,&tolua_err) ||
1534 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1535 !tolua_isnoobj(tolua_S,3,&tolua_err)
1541 fawkes::tf::Vector3*
self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1542 double x = ((double) tolua_tonumber(tolua_S,2,0));
1543 #ifndef TOLUA_RELEASE 1544 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'setX'", NULL);
1546 bool exc_caught =
false;
1555 catch (std::exception &e) {
1557 lua_pushstring(tolua_S, e.what());
1559 if (exc_caught) lua_error(tolua_S);
1563 #ifndef TOLUA_RELEASE 1565 tolua_error(tolua_S,
"#ferror in function 'setX'.",&tolua_err);
1569 #endif //#ifndef TOLUA_DISABLE 1572 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setY00 1573 static int tolua_fawkestf_fawkes_tf_Vector3_setY00(lua_State* tolua_S)
1575 #ifndef TOLUA_RELEASE 1576 tolua_Error tolua_err;
1578 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Vector3",0,&tolua_err) ||
1579 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1580 !tolua_isnoobj(tolua_S,3,&tolua_err)
1586 fawkes::tf::Vector3*
self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1587 double x = ((double) tolua_tonumber(tolua_S,2,0));
1588 #ifndef TOLUA_RELEASE 1589 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'setY'", NULL);
1591 bool exc_caught =
false;
1600 catch (std::exception &e) {
1602 lua_pushstring(tolua_S, e.what());
1604 if (exc_caught) lua_error(tolua_S);
1608 #ifndef TOLUA_RELEASE 1610 tolua_error(tolua_S,
"#ferror in function 'setY'.",&tolua_err);
1614 #endif //#ifndef TOLUA_DISABLE 1617 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setZ00 1618 static int tolua_fawkestf_fawkes_tf_Vector3_setZ00(lua_State* tolua_S)
1620 #ifndef TOLUA_RELEASE 1621 tolua_Error tolua_err;
1623 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Vector3",0,&tolua_err) ||
1624 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1625 !tolua_isnoobj(tolua_S,3,&tolua_err)
1631 fawkes::tf::Vector3*
self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1632 double x = ((double) tolua_tonumber(tolua_S,2,0));
1633 #ifndef TOLUA_RELEASE 1634 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'setZ'", NULL);
1636 bool exc_caught =
false;
1645 catch (std::exception &e) {
1647 lua_pushstring(tolua_S, e.what());
1649 if (exc_caught) lua_error(tolua_S);
1653 #ifndef TOLUA_RELEASE 1655 tolua_error(tolua_S,
"#ferror in function 'setZ'.",&tolua_err);
1659 #endif //#ifndef TOLUA_DISABLE 1662 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setValue00 1663 static int tolua_fawkestf_fawkes_tf_Vector3_setValue00(lua_State* tolua_S)
1665 #ifndef TOLUA_RELEASE 1666 tolua_Error tolua_err;
1668 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Vector3",0,&tolua_err) ||
1669 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1670 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1671 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
1672 !tolua_isnoobj(tolua_S,5,&tolua_err)
1678 fawkes::tf::Vector3*
self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1679 double x = ((double) tolua_tonumber(tolua_S,2,0));
1680 double y = ((double) tolua_tonumber(tolua_S,3,0));
1681 double z = ((double) tolua_tonumber(tolua_S,4,0));
1682 #ifndef TOLUA_RELEASE 1683 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'setValue'", NULL);
1685 bool exc_caught =
false;
1688 self->setValue(x,y,z);
1694 catch (std::exception &e) {
1696 lua_pushstring(tolua_S, e.what());
1698 if (exc_caught) lua_error(tolua_S);
1702 #ifndef TOLUA_RELEASE 1704 tolua_error(tolua_S,
"#ferror in function 'setValue'.",&tolua_err);
1708 #endif //#ifndef TOLUA_DISABLE 1711 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setZero00 1712 static int tolua_fawkestf_fawkes_tf_Vector3_setZero00(lua_State* tolua_S)
1714 #ifndef TOLUA_RELEASE 1715 tolua_Error tolua_err;
1717 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Vector3",0,&tolua_err) ||
1718 !tolua_isnoobj(tolua_S,2,&tolua_err)
1724 fawkes::tf::Vector3*
self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1725 #ifndef TOLUA_RELEASE 1726 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'setZero'", NULL);
1728 bool exc_caught =
false;
1737 catch (std::exception &e) {
1739 lua_pushstring(tolua_S, e.what());
1741 if (exc_caught) lua_error(tolua_S);
1745 #ifndef TOLUA_RELEASE 1747 tolua_error(tolua_S,
"#ferror in function 'setZero'.",&tolua_err);
1751 #endif //#ifndef TOLUA_DISABLE 1754 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_isZero00 1755 static int tolua_fawkestf_fawkes_tf_Vector3_isZero00(lua_State* tolua_S)
1757 #ifndef TOLUA_RELEASE 1758 tolua_Error tolua_err;
1760 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Vector3",0,&tolua_err) ||
1761 !tolua_isnoobj(tolua_S,2,&tolua_err)
1767 const fawkes::tf::Vector3*
self = (
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1768 #ifndef TOLUA_RELEASE 1769 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'isZero'", NULL);
1771 bool exc_caught =
false;
1774 bool tolua_ret = (bool) self->isZero();
1775 tolua_pushboolean(tolua_S,(
bool)tolua_ret);
1781 catch (std::exception &e) {
1783 lua_pushstring(tolua_S, e.what());
1785 if (exc_caught) lua_error(tolua_S);
1789 #ifndef TOLUA_RELEASE 1791 tolua_error(tolua_S,
"#ferror in function 'isZero'.",&tolua_err);
1795 #endif //#ifndef TOLUA_DISABLE 1798 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_fuzzyZero00 1799 static int tolua_fawkestf_fawkes_tf_Vector3_fuzzyZero00(lua_State* tolua_S)
1801 #ifndef TOLUA_RELEASE 1802 tolua_Error tolua_err;
1804 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Vector3",0,&tolua_err) ||
1805 !tolua_isnoobj(tolua_S,2,&tolua_err)
1811 const fawkes::tf::Vector3*
self = (
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
1812 #ifndef TOLUA_RELEASE 1813 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'fuzzyZero'", NULL);
1815 bool exc_caught =
false;
1818 bool tolua_ret = (bool) self->fuzzyZero();
1819 tolua_pushboolean(tolua_S,(
bool)tolua_ret);
1825 catch (std::exception &e) {
1827 lua_pushstring(tolua_S, e.what());
1829 if (exc_caught) lua_error(tolua_S);
1833 #ifndef TOLUA_RELEASE 1835 tolua_error(tolua_S,
"#ferror in function 'fuzzyZero'.",&tolua_err);
1839 #endif //#ifndef TOLUA_DISABLE 1842 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new00 1843 static int tolua_fawkestf_fawkes_tf_Quaternion_new00(lua_State* tolua_S)
1845 #ifndef TOLUA_RELEASE 1846 tolua_Error tolua_err;
1848 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
1849 !tolua_isnoobj(tolua_S,2,&tolua_err)
1855 bool exc_caught =
false;
1858 fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*) Mtolua_new((fawkes::tf::Quaternion)());
1859 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Quaternion");
1865 catch (std::exception &e) {
1867 lua_pushstring(tolua_S, e.what());
1869 if (exc_caught) lua_error(tolua_S);
1873 #ifndef TOLUA_RELEASE 1875 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
1879 #endif //#ifndef TOLUA_DISABLE 1882 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new00_local 1883 static int tolua_fawkestf_fawkes_tf_Quaternion_new00_local(lua_State* tolua_S)
1885 #ifndef TOLUA_RELEASE 1886 tolua_Error tolua_err;
1888 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
1889 !tolua_isnoobj(tolua_S,2,&tolua_err)
1895 bool exc_caught =
false;
1898 fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*) Mtolua_new((fawkes::tf::Quaternion)());
1899 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Quaternion");
1900 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1906 catch (std::exception &e) {
1908 lua_pushstring(tolua_S, e.what());
1910 if (exc_caught) lua_error(tolua_S);
1914 #ifndef TOLUA_RELEASE 1916 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
1920 #endif //#ifndef TOLUA_DISABLE 1923 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new01 1924 static int tolua_fawkestf_fawkes_tf_Quaternion_new01(lua_State* tolua_S)
1926 tolua_Error tolua_err;
1928 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
1929 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1930 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1931 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
1932 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
1933 !tolua_isnoobj(tolua_S,6,&tolua_err)
1938 double x = ((double) tolua_tonumber(tolua_S,2,0));
1939 double y = ((double) tolua_tonumber(tolua_S,3,0));
1940 double z = ((double) tolua_tonumber(tolua_S,4,0));
1941 double w = ((double) tolua_tonumber(tolua_S,5,0));
1942 bool exc_caught =
false;
1945 fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*) Mtolua_new((fawkes::tf::Quaternion)(x,y,z,w));
1946 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Quaternion");
1952 catch (std::exception &e) {
1954 lua_pushstring(tolua_S, e.what());
1956 if (exc_caught) lua_error(tolua_S);
1961 return tolua_fawkestf_fawkes_tf_Quaternion_new00(tolua_S);
1963 #endif //#ifndef TOLUA_DISABLE 1966 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new01_local 1967 static int tolua_fawkestf_fawkes_tf_Quaternion_new01_local(lua_State* tolua_S)
1969 tolua_Error tolua_err;
1971 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
1972 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1973 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1974 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
1975 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
1976 !tolua_isnoobj(tolua_S,6,&tolua_err)
1981 double x = ((double) tolua_tonumber(tolua_S,2,0));
1982 double y = ((double) tolua_tonumber(tolua_S,3,0));
1983 double z = ((double) tolua_tonumber(tolua_S,4,0));
1984 double w = ((double) tolua_tonumber(tolua_S,5,0));
1985 bool exc_caught =
false;
1988 fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*) Mtolua_new((fawkes::tf::Quaternion)(x,y,z,w));
1989 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Quaternion");
1990 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1996 catch (std::exception &e) {
1998 lua_pushstring(tolua_S, e.what());
2000 if (exc_caught) lua_error(tolua_S);
2005 return tolua_fawkestf_fawkes_tf_Quaternion_new00_local(tolua_S);
2007 #endif //#ifndef TOLUA_DISABLE 2010 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new02 2011 static int tolua_fawkestf_fawkes_tf_Quaternion_new02(lua_State* tolua_S)
2013 tolua_Error tolua_err;
2015 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
2016 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"fawkes::tf::Vector3",0,&tolua_err)) ||
2017 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2018 !tolua_isnoobj(tolua_S,4,&tolua_err)
2023 fawkes::tf::Vector3 axis = *((fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
2024 const double angle = ((
const double) tolua_tonumber(tolua_S,3,0));
2025 bool exc_caught =
false;
2028 fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*) Mtolua_new((fawkes::tf::Quaternion)(axis,angle));
2029 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Quaternion");
2035 catch (std::exception &e) {
2037 lua_pushstring(tolua_S, e.what());
2039 if (exc_caught) lua_error(tolua_S);
2044 return tolua_fawkestf_fawkes_tf_Quaternion_new01(tolua_S);
2046 #endif //#ifndef TOLUA_DISABLE 2049 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new02_local 2050 static int tolua_fawkestf_fawkes_tf_Quaternion_new02_local(lua_State* tolua_S)
2052 tolua_Error tolua_err;
2054 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
2055 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"fawkes::tf::Vector3",0,&tolua_err)) ||
2056 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2057 !tolua_isnoobj(tolua_S,4,&tolua_err)
2062 fawkes::tf::Vector3 axis = *((fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
2063 const double angle = ((
const double) tolua_tonumber(tolua_S,3,0));
2064 bool exc_caught =
false;
2067 fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*) Mtolua_new((fawkes::tf::Quaternion)(axis,angle));
2068 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Quaternion");
2069 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2075 catch (std::exception &e) {
2077 lua_pushstring(tolua_S, e.what());
2079 if (exc_caught) lua_error(tolua_S);
2084 return tolua_fawkestf_fawkes_tf_Quaternion_new01_local(tolua_S);
2086 #endif //#ifndef TOLUA_DISABLE 2089 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new03 2090 static int tolua_fawkestf_fawkes_tf_Quaternion_new03(lua_State* tolua_S)
2092 tolua_Error tolua_err;
2094 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
2095 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2096 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2097 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
2098 !tolua_isnoobj(tolua_S,5,&tolua_err)
2103 const double yaw = ((
const double) tolua_tonumber(tolua_S,2,0));
2104 const double pitch = ((
const double) tolua_tonumber(tolua_S,3,0));
2105 const double roll = ((
const double) tolua_tonumber(tolua_S,4,0));
2106 bool exc_caught =
false;
2109 fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*) Mtolua_new((fawkes::tf::Quaternion)(yaw,pitch,roll));
2110 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Quaternion");
2116 catch (std::exception &e) {
2118 lua_pushstring(tolua_S, e.what());
2120 if (exc_caught) lua_error(tolua_S);
2125 return tolua_fawkestf_fawkes_tf_Quaternion_new02(tolua_S);
2127 #endif //#ifndef TOLUA_DISABLE 2130 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new03_local 2131 static int tolua_fawkestf_fawkes_tf_Quaternion_new03_local(lua_State* tolua_S)
2133 tolua_Error tolua_err;
2135 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
2136 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2137 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2138 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
2139 !tolua_isnoobj(tolua_S,5,&tolua_err)
2144 const double yaw = ((
const double) tolua_tonumber(tolua_S,2,0));
2145 const double pitch = ((
const double) tolua_tonumber(tolua_S,3,0));
2146 const double roll = ((
const double) tolua_tonumber(tolua_S,4,0));
2147 bool exc_caught =
false;
2150 fawkes::tf::Quaternion* tolua_ret = (fawkes::tf::Quaternion*) Mtolua_new((fawkes::tf::Quaternion)(yaw,pitch,roll));
2151 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Quaternion");
2152 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2158 catch (std::exception &e) {
2160 lua_pushstring(tolua_S, e.what());
2162 if (exc_caught) lua_error(tolua_S);
2167 return tolua_fawkestf_fawkes_tf_Quaternion_new02_local(tolua_S);
2169 #endif //#ifndef TOLUA_DISABLE 2172 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_getIdentity00 2173 static int tolua_fawkestf_fawkes_tf_Quaternion_getIdentity00(lua_State* tolua_S)
2175 #ifndef TOLUA_RELEASE 2176 tolua_Error tolua_err;
2178 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
2179 !tolua_isnoobj(tolua_S,2,&tolua_err)
2185 bool exc_caught =
false;
2188 const fawkes::tf::Quaternion& tolua_ret = (
const fawkes::tf::Quaternion&) fawkes::tf::Quaternion::getIdentity();
2189 tolua_pushusertype(tolua_S,(
void*)&tolua_ret,
"const fawkes::tf::Quaternion");
2195 catch (std::exception &e) {
2197 lua_pushstring(tolua_S, e.what());
2199 if (exc_caught) lua_error(tolua_S);
2203 #ifndef TOLUA_RELEASE 2205 tolua_error(tolua_S,
"#ferror in function 'getIdentity'.",&tolua_err);
2209 #endif //#ifndef TOLUA_DISABLE 2212 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setRotation00 2213 static int tolua_fawkestf_fawkes_tf_Quaternion_setRotation00(lua_State* tolua_S)
2215 #ifndef TOLUA_RELEASE 2216 tolua_Error tolua_err;
2218 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
2219 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"fawkes::tf::Vector3",0,&tolua_err)) ||
2220 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2221 !tolua_isnoobj(tolua_S,4,&tolua_err)
2227 fawkes::tf::Quaternion*
self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2228 fawkes::tf::Vector3 axis = *((fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
2229 const double angle = ((
const double) tolua_tonumber(tolua_S,3,0));
2230 #ifndef TOLUA_RELEASE 2231 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'setRotation'", NULL);
2233 bool exc_caught =
false;
2236 self->setRotation(axis,angle);
2242 catch (std::exception &e) {
2244 lua_pushstring(tolua_S, e.what());
2246 if (exc_caught) lua_error(tolua_S);
2250 #ifndef TOLUA_RELEASE 2252 tolua_error(tolua_S,
"#ferror in function 'setRotation'.",&tolua_err);
2256 #endif //#ifndef TOLUA_DISABLE 2259 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setEuler00 2260 static int tolua_fawkestf_fawkes_tf_Quaternion_setEuler00(lua_State* tolua_S)
2262 #ifndef TOLUA_RELEASE 2263 tolua_Error tolua_err;
2265 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
2266 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2267 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2268 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
2269 !tolua_isnoobj(tolua_S,5,&tolua_err)
2275 fawkes::tf::Quaternion*
self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2276 const double yaw = ((
const double) tolua_tonumber(tolua_S,2,0));
2277 const double pitch = ((
const double) tolua_tonumber(tolua_S,3,0));
2278 const double roll = ((
const double) tolua_tonumber(tolua_S,4,0));
2279 #ifndef TOLUA_RELEASE 2280 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'setEuler'", NULL);
2282 bool exc_caught =
false;
2285 self->setEuler(yaw,pitch,roll);
2291 catch (std::exception &e) {
2293 lua_pushstring(tolua_S, e.what());
2295 if (exc_caught) lua_error(tolua_S);
2299 #ifndef TOLUA_RELEASE 2301 tolua_error(tolua_S,
"#ferror in function 'setEuler'.",&tolua_err);
2305 #endif //#ifndef TOLUA_DISABLE 2308 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion__eq00 2309 static int tolua_fawkestf_fawkes_tf_Quaternion__eq00(lua_State* tolua_S)
2311 #ifndef TOLUA_RELEASE 2312 tolua_Error tolua_err;
2314 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Quaternion",0,&tolua_err) ||
2315 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
2316 !tolua_isnoobj(tolua_S,3,&tolua_err)
2322 const fawkes::tf::Quaternion*
self = (
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2323 const fawkes::tf::Quaternion* q = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
2324 #ifndef TOLUA_RELEASE 2325 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'operator=='", NULL);
2327 bool exc_caught =
false;
2330 bool tolua_ret = (bool) self->operator==(*q);
2331 tolua_pushboolean(tolua_S,(
bool)tolua_ret);
2337 catch (std::exception &e) {
2339 lua_pushstring(tolua_S, e.what());
2341 if (exc_caught) lua_error(tolua_S);
2345 #ifndef TOLUA_RELEASE 2347 tolua_error(tolua_S,
"#ferror in function '.eq'.",&tolua_err);
2351 #endif //#ifndef TOLUA_DISABLE 2354 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_dot00 2355 static int tolua_fawkestf_fawkes_tf_Quaternion_dot00(lua_State* tolua_S)
2357 #ifndef TOLUA_RELEASE 2358 tolua_Error tolua_err;
2360 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Quaternion",0,&tolua_err) ||
2361 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
2362 !tolua_isnoobj(tolua_S,3,&tolua_err)
2368 const fawkes::tf::Quaternion*
self = (
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2369 const fawkes::tf::Quaternion* q = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
2370 #ifndef TOLUA_RELEASE 2371 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'dot'", NULL);
2373 bool exc_caught =
false;
2376 double tolua_ret = (double) self->dot(*q);
2377 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2383 catch (std::exception &e) {
2385 lua_pushstring(tolua_S, e.what());
2387 if (exc_caught) lua_error(tolua_S);
2391 #ifndef TOLUA_RELEASE 2393 tolua_error(tolua_S,
"#ferror in function 'dot'.",&tolua_err);
2397 #endif //#ifndef TOLUA_DISABLE 2400 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_length200 2401 static int tolua_fawkestf_fawkes_tf_Quaternion_length200(lua_State* tolua_S)
2403 #ifndef TOLUA_RELEASE 2404 tolua_Error tolua_err;
2406 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Quaternion",0,&tolua_err) ||
2407 !tolua_isnoobj(tolua_S,2,&tolua_err)
2413 const fawkes::tf::Quaternion*
self = (
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2414 #ifndef TOLUA_RELEASE 2415 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'length2'", NULL);
2417 bool exc_caught =
false;
2420 double tolua_ret = (double) self->length2();
2421 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2427 catch (std::exception &e) {
2429 lua_pushstring(tolua_S, e.what());
2431 if (exc_caught) lua_error(tolua_S);
2435 #ifndef TOLUA_RELEASE 2437 tolua_error(tolua_S,
"#ferror in function 'length2'.",&tolua_err);
2441 #endif //#ifndef TOLUA_DISABLE 2444 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_length00 2445 static int tolua_fawkestf_fawkes_tf_Quaternion_length00(lua_State* tolua_S)
2447 #ifndef TOLUA_RELEASE 2448 tolua_Error tolua_err;
2450 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Quaternion",0,&tolua_err) ||
2451 !tolua_isnoobj(tolua_S,2,&tolua_err)
2457 const fawkes::tf::Quaternion*
self = (
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2458 #ifndef TOLUA_RELEASE 2459 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'length'", NULL);
2461 bool exc_caught =
false;
2464 double tolua_ret = (double) self->length();
2465 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2471 catch (std::exception &e) {
2473 lua_pushstring(tolua_S, e.what());
2475 if (exc_caught) lua_error(tolua_S);
2479 #ifndef TOLUA_RELEASE 2481 tolua_error(tolua_S,
"#ferror in function 'length'.",&tolua_err);
2485 #endif //#ifndef TOLUA_DISABLE 2488 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_normalize00 2489 static int tolua_fawkestf_fawkes_tf_Quaternion_normalize00(lua_State* tolua_S)
2491 #ifndef TOLUA_RELEASE 2492 tolua_Error tolua_err;
2494 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
2495 !tolua_isnoobj(tolua_S,2,&tolua_err)
2501 fawkes::tf::Quaternion*
self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2502 #ifndef TOLUA_RELEASE 2503 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'normalize'", NULL);
2505 bool exc_caught =
false;
2508 fawkes::tf::Quaternion& tolua_ret = (fawkes::tf::Quaternion&) self->normalize();
2509 tolua_pushusertype(tolua_S,(
void*)&tolua_ret,
"fawkes::tf::Quaternion");
2515 catch (std::exception &e) {
2517 lua_pushstring(tolua_S, e.what());
2519 if (exc_caught) lua_error(tolua_S);
2523 #ifndef TOLUA_RELEASE 2525 tolua_error(tolua_S,
"#ferror in function 'normalize'.",&tolua_err);
2529 #endif //#ifndef TOLUA_DISABLE 2532 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_normalized00 2533 static int tolua_fawkestf_fawkes_tf_Quaternion_normalized00(lua_State* tolua_S)
2535 #ifndef TOLUA_RELEASE 2536 tolua_Error tolua_err;
2538 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
2539 !tolua_isnoobj(tolua_S,2,&tolua_err)
2545 fawkes::tf::Quaternion*
self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2546 #ifndef TOLUA_RELEASE 2547 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'normalized'", NULL);
2549 bool exc_caught =
false;
2552 fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) self->normalized();
2555 void* tolua_obj = Mtolua_new((fawkes::tf::Quaternion)(tolua_ret));
2556 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Quaternion");
2557 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2559 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(fawkes::tf::Quaternion));
2560 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Quaternion");
2561 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2569 catch (std::exception &e) {
2571 lua_pushstring(tolua_S, e.what());
2573 if (exc_caught) lua_error(tolua_S);
2577 #ifndef TOLUA_RELEASE 2579 tolua_error(tolua_S,
"#ferror in function 'normalized'.",&tolua_err);
2583 #endif //#ifndef TOLUA_DISABLE 2586 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_angle00 2587 static int tolua_fawkestf_fawkes_tf_Quaternion_angle00(lua_State* tolua_S)
2589 #ifndef TOLUA_RELEASE 2590 tolua_Error tolua_err;
2592 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Quaternion",0,&tolua_err) ||
2593 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
2594 !tolua_isnoobj(tolua_S,3,&tolua_err)
2600 const fawkes::tf::Quaternion*
self = (
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2601 const fawkes::tf::Quaternion* q = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
2602 #ifndef TOLUA_RELEASE 2603 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'angle'", NULL);
2605 bool exc_caught =
false;
2608 double tolua_ret = (double) self->angle(*q);
2609 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2615 catch (std::exception &e) {
2617 lua_pushstring(tolua_S, e.what());
2619 if (exc_caught) lua_error(tolua_S);
2623 #ifndef TOLUA_RELEASE 2625 tolua_error(tolua_S,
"#ferror in function 'angle'.",&tolua_err);
2629 #endif //#ifndef TOLUA_DISABLE 2632 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_getAngle00 2633 static int tolua_fawkestf_fawkes_tf_Quaternion_getAngle00(lua_State* tolua_S)
2635 #ifndef TOLUA_RELEASE 2636 tolua_Error tolua_err;
2638 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Quaternion",0,&tolua_err) ||
2639 !tolua_isnoobj(tolua_S,2,&tolua_err)
2645 const fawkes::tf::Quaternion*
self = (
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2646 #ifndef TOLUA_RELEASE 2647 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'getAngle'", NULL);
2649 bool exc_caught =
false;
2652 double tolua_ret = (double) self->getAngle();
2653 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2659 catch (std::exception &e) {
2661 lua_pushstring(tolua_S, e.what());
2663 if (exc_caught) lua_error(tolua_S);
2667 #ifndef TOLUA_RELEASE 2669 tolua_error(tolua_S,
"#ferror in function 'getAngle'.",&tolua_err);
2673 #endif //#ifndef TOLUA_DISABLE 2676 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_getAxis00 2677 static int tolua_fawkestf_fawkes_tf_Quaternion_getAxis00(lua_State* tolua_S)
2679 #ifndef TOLUA_RELEASE 2680 tolua_Error tolua_err;
2682 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Quaternion",0,&tolua_err) ||
2683 !tolua_isnoobj(tolua_S,2,&tolua_err)
2689 const fawkes::tf::Quaternion*
self = (
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2690 #ifndef TOLUA_RELEASE 2691 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'getAxis'", NULL);
2693 bool exc_caught =
false;
2696 fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->getAxis();
2699 void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
2700 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Vector3");
2701 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2703 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(fawkes::tf::Vector3));
2704 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Vector3");
2705 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2713 catch (std::exception &e) {
2715 lua_pushstring(tolua_S, e.what());
2717 if (exc_caught) lua_error(tolua_S);
2721 #ifndef TOLUA_RELEASE 2723 tolua_error(tolua_S,
"#ferror in function 'getAxis'.",&tolua_err);
2727 #endif //#ifndef TOLUA_DISABLE 2730 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_inverse00 2731 static int tolua_fawkestf_fawkes_tf_Quaternion_inverse00(lua_State* tolua_S)
2733 #ifndef TOLUA_RELEASE 2734 tolua_Error tolua_err;
2736 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Quaternion",0,&tolua_err) ||
2737 !tolua_isnoobj(tolua_S,2,&tolua_err)
2743 const fawkes::tf::Quaternion*
self = (
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2744 #ifndef TOLUA_RELEASE 2745 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'inverse'", NULL);
2747 bool exc_caught =
false;
2750 fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) self->inverse();
2753 void* tolua_obj = Mtolua_new((fawkes::tf::Quaternion)(tolua_ret));
2754 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Quaternion");
2755 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2757 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(fawkes::tf::Quaternion));
2758 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Quaternion");
2759 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2767 catch (std::exception &e) {
2769 lua_pushstring(tolua_S, e.what());
2771 if (exc_caught) lua_error(tolua_S);
2775 #ifndef TOLUA_RELEASE 2777 tolua_error(tolua_S,
"#ferror in function 'inverse'.",&tolua_err);
2781 #endif //#ifndef TOLUA_DISABLE 2784 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_slerp00 2785 static int tolua_fawkestf_fawkes_tf_Quaternion_slerp00(lua_State* tolua_S)
2787 #ifndef TOLUA_RELEASE 2788 tolua_Error tolua_err;
2790 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Quaternion",0,&tolua_err) ||
2791 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
2792 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2793 !tolua_isnoobj(tolua_S,4,&tolua_err)
2799 const fawkes::tf::Quaternion*
self = (
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2800 const fawkes::tf::Quaternion* q = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
2801 const double t = ((
const double) tolua_tonumber(tolua_S,3,0));
2802 #ifndef TOLUA_RELEASE 2803 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'slerp'", NULL);
2805 bool exc_caught =
false;
2808 fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) self->slerp(*q,t);
2811 void* tolua_obj = Mtolua_new((fawkes::tf::Quaternion)(tolua_ret));
2812 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Quaternion");
2813 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2815 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(fawkes::tf::Quaternion));
2816 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Quaternion");
2817 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2825 catch (std::exception &e) {
2827 lua_pushstring(tolua_S, e.what());
2829 if (exc_caught) lua_error(tolua_S);
2833 #ifndef TOLUA_RELEASE 2835 tolua_error(tolua_S,
"#ferror in function 'slerp'.",&tolua_err);
2839 #endif //#ifndef TOLUA_DISABLE 2842 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_x00 2843 static int tolua_fawkestf_fawkes_tf_Quaternion_x00(lua_State* tolua_S)
2845 #ifndef TOLUA_RELEASE 2846 tolua_Error tolua_err;
2848 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
2849 !tolua_isnoobj(tolua_S,2,&tolua_err)
2855 fawkes::tf::Quaternion*
self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2856 #ifndef TOLUA_RELEASE 2857 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'x'", NULL);
2859 bool exc_caught =
false;
2862 const double tolua_ret = (
const double) self->x();
2863 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2869 catch (std::exception &e) {
2871 lua_pushstring(tolua_S, e.what());
2873 if (exc_caught) lua_error(tolua_S);
2877 #ifndef TOLUA_RELEASE 2879 tolua_error(tolua_S,
"#ferror in function 'x'.",&tolua_err);
2883 #endif //#ifndef TOLUA_DISABLE 2886 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_y00 2887 static int tolua_fawkestf_fawkes_tf_Quaternion_y00(lua_State* tolua_S)
2889 #ifndef TOLUA_RELEASE 2890 tolua_Error tolua_err;
2892 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
2893 !tolua_isnoobj(tolua_S,2,&tolua_err)
2899 fawkes::tf::Quaternion*
self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2900 #ifndef TOLUA_RELEASE 2901 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'y'", NULL);
2903 bool exc_caught =
false;
2906 const double tolua_ret = (
const double) self->y();
2907 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2913 catch (std::exception &e) {
2915 lua_pushstring(tolua_S, e.what());
2917 if (exc_caught) lua_error(tolua_S);
2921 #ifndef TOLUA_RELEASE 2923 tolua_error(tolua_S,
"#ferror in function 'y'.",&tolua_err);
2927 #endif //#ifndef TOLUA_DISABLE 2930 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_z00 2931 static int tolua_fawkestf_fawkes_tf_Quaternion_z00(lua_State* tolua_S)
2933 #ifndef TOLUA_RELEASE 2934 tolua_Error tolua_err;
2936 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
2937 !tolua_isnoobj(tolua_S,2,&tolua_err)
2943 fawkes::tf::Quaternion*
self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2944 #ifndef TOLUA_RELEASE 2945 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'z'", NULL);
2947 bool exc_caught =
false;
2950 const double tolua_ret = (
const double) self->z();
2951 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2957 catch (std::exception &e) {
2959 lua_pushstring(tolua_S, e.what());
2961 if (exc_caught) lua_error(tolua_S);
2965 #ifndef TOLUA_RELEASE 2967 tolua_error(tolua_S,
"#ferror in function 'z'.",&tolua_err);
2971 #endif //#ifndef TOLUA_DISABLE 2974 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_w00 2975 static int tolua_fawkestf_fawkes_tf_Quaternion_w00(lua_State* tolua_S)
2977 #ifndef TOLUA_RELEASE 2978 tolua_Error tolua_err;
2980 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
2981 !tolua_isnoobj(tolua_S,2,&tolua_err)
2987 fawkes::tf::Quaternion*
self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
2988 #ifndef TOLUA_RELEASE 2989 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'w'", NULL);
2991 bool exc_caught =
false;
2994 const double tolua_ret = (
const double) self->w();
2995 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
3001 catch (std::exception &e) {
3003 lua_pushstring(tolua_S, e.what());
3005 if (exc_caught) lua_error(tolua_S);
3009 #ifndef TOLUA_RELEASE 3011 tolua_error(tolua_S,
"#ferror in function 'w'.",&tolua_err);
3015 #endif //#ifndef TOLUA_DISABLE 3018 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setX00 3019 static int tolua_fawkestf_fawkes_tf_Quaternion_setX00(lua_State* tolua_S)
3021 #ifndef TOLUA_RELEASE 3022 tolua_Error tolua_err;
3024 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
3025 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
3026 !tolua_isnoobj(tolua_S,3,&tolua_err)
3032 fawkes::tf::Quaternion*
self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
3033 double x = ((double) tolua_tonumber(tolua_S,2,0));
3034 #ifndef TOLUA_RELEASE 3035 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'setX'", NULL);
3037 bool exc_caught =
false;
3046 catch (std::exception &e) {
3048 lua_pushstring(tolua_S, e.what());
3050 if (exc_caught) lua_error(tolua_S);
3054 #ifndef TOLUA_RELEASE 3056 tolua_error(tolua_S,
"#ferror in function 'setX'.",&tolua_err);
3060 #endif //#ifndef TOLUA_DISABLE 3063 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setY00 3064 static int tolua_fawkestf_fawkes_tf_Quaternion_setY00(lua_State* tolua_S)
3066 #ifndef TOLUA_RELEASE 3067 tolua_Error tolua_err;
3069 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
3070 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
3071 !tolua_isnoobj(tolua_S,3,&tolua_err)
3077 fawkes::tf::Quaternion*
self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
3078 double x = ((double) tolua_tonumber(tolua_S,2,0));
3079 #ifndef TOLUA_RELEASE 3080 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'setY'", NULL);
3082 bool exc_caught =
false;
3091 catch (std::exception &e) {
3093 lua_pushstring(tolua_S, e.what());
3095 if (exc_caught) lua_error(tolua_S);
3099 #ifndef TOLUA_RELEASE 3101 tolua_error(tolua_S,
"#ferror in function 'setY'.",&tolua_err);
3105 #endif //#ifndef TOLUA_DISABLE 3108 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setZ00 3109 static int tolua_fawkestf_fawkes_tf_Quaternion_setZ00(lua_State* tolua_S)
3111 #ifndef TOLUA_RELEASE 3112 tolua_Error tolua_err;
3114 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
3115 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
3116 !tolua_isnoobj(tolua_S,3,&tolua_err)
3122 fawkes::tf::Quaternion*
self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
3123 double x = ((double) tolua_tonumber(tolua_S,2,0));
3124 #ifndef TOLUA_RELEASE 3125 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'setZ'", NULL);
3127 bool exc_caught =
false;
3136 catch (std::exception &e) {
3138 lua_pushstring(tolua_S, e.what());
3140 if (exc_caught) lua_error(tolua_S);
3144 #ifndef TOLUA_RELEASE 3146 tolua_error(tolua_S,
"#ferror in function 'setZ'.",&tolua_err);
3150 #endif //#ifndef TOLUA_DISABLE 3153 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setW00 3154 static int tolua_fawkestf_fawkes_tf_Quaternion_setW00(lua_State* tolua_S)
3156 #ifndef TOLUA_RELEASE 3157 tolua_Error tolua_err;
3159 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
3160 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
3161 !tolua_isnoobj(tolua_S,3,&tolua_err)
3167 fawkes::tf::Quaternion*
self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
3168 double x = ((double) tolua_tonumber(tolua_S,2,0));
3169 #ifndef TOLUA_RELEASE 3170 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'setW'", NULL);
3172 bool exc_caught =
false;
3181 catch (std::exception &e) {
3183 lua_pushstring(tolua_S, e.what());
3185 if (exc_caught) lua_error(tolua_S);
3189 #ifndef TOLUA_RELEASE 3191 tolua_error(tolua_S,
"#ferror in function 'setW'.",&tolua_err);
3195 #endif //#ifndef TOLUA_DISABLE 3198 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setValue00 3199 static int tolua_fawkestf_fawkes_tf_Quaternion_setValue00(lua_State* tolua_S)
3201 #ifndef TOLUA_RELEASE 3202 tolua_Error tolua_err;
3204 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Quaternion",0,&tolua_err) ||
3205 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
3206 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
3207 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
3208 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
3209 !tolua_isnoobj(tolua_S,6,&tolua_err)
3215 fawkes::tf::Quaternion*
self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
3216 double x = ((double) tolua_tonumber(tolua_S,2,0));
3217 double y = ((double) tolua_tonumber(tolua_S,3,0));
3218 double z = ((double) tolua_tonumber(tolua_S,4,0));
3219 double w = ((double) tolua_tonumber(tolua_S,5,0));
3220 #ifndef TOLUA_RELEASE 3221 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'setValue'", NULL);
3223 bool exc_caught =
false;
3226 self->setValue(x,y,z,w);
3232 catch (std::exception &e) {
3234 lua_pushstring(tolua_S, e.what());
3236 if (exc_caught) lua_error(tolua_S);
3240 #ifndef TOLUA_RELEASE 3242 tolua_error(tolua_S,
"#ferror in function 'setValue'.",&tolua_err);
3246 #endif //#ifndef TOLUA_DISABLE 3249 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new00 3250 static int tolua_fawkestf_fawkes_tf_Transform_new00(lua_State* tolua_S)
3252 #ifndef TOLUA_RELEASE 3253 tolua_Error tolua_err;
3255 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Transform",0,&tolua_err) ||
3256 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
3257 !tolua_isnoobj(tolua_S,3,&tolua_err)
3263 const fawkes::tf::Quaternion* q = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
3264 bool exc_caught =
false;
3267 fawkes::tf::Transform* tolua_ret = (fawkes::tf::Transform*) Mtolua_new((fawkes::tf::Transform)(*q));
3268 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Transform");
3274 catch (std::exception &e) {
3276 lua_pushstring(tolua_S, e.what());
3278 if (exc_caught) lua_error(tolua_S);
3282 #ifndef TOLUA_RELEASE 3284 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
3288 #endif //#ifndef TOLUA_DISABLE 3291 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new00_local 3292 static int tolua_fawkestf_fawkes_tf_Transform_new00_local(lua_State* tolua_S)
3294 #ifndef TOLUA_RELEASE 3295 tolua_Error tolua_err;
3297 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Transform",0,&tolua_err) ||
3298 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
3299 !tolua_isnoobj(tolua_S,3,&tolua_err)
3305 const fawkes::tf::Quaternion* q = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
3306 bool exc_caught =
false;
3309 fawkes::tf::Transform* tolua_ret = (fawkes::tf::Transform*) Mtolua_new((fawkes::tf::Transform)(*q));
3310 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Transform");
3311 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3317 catch (std::exception &e) {
3319 lua_pushstring(tolua_S, e.what());
3321 if (exc_caught) lua_error(tolua_S);
3325 #ifndef TOLUA_RELEASE 3327 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
3331 #endif //#ifndef TOLUA_DISABLE 3334 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new01 3335 static int tolua_fawkestf_fawkes_tf_Transform_new01(lua_State* tolua_S)
3337 tolua_Error tolua_err;
3339 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Transform",0,&tolua_err) ||
3340 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
3341 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
3342 !tolua_isnoobj(tolua_S,4,&tolua_err)
3347 const fawkes::tf::Quaternion* q = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
3348 const fawkes::tf::Vector3* c = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,3,0));
3349 bool exc_caught =
false;
3352 fawkes::tf::Transform* tolua_ret = (fawkes::tf::Transform*) Mtolua_new((fawkes::tf::Transform)(*q,*c));
3353 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Transform");
3359 catch (std::exception &e) {
3361 lua_pushstring(tolua_S, e.what());
3363 if (exc_caught) lua_error(tolua_S);
3368 return tolua_fawkestf_fawkes_tf_Transform_new00(tolua_S);
3370 #endif //#ifndef TOLUA_DISABLE 3373 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new01_local 3374 static int tolua_fawkestf_fawkes_tf_Transform_new01_local(lua_State* tolua_S)
3376 tolua_Error tolua_err;
3378 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Transform",0,&tolua_err) ||
3379 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
3380 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
3381 !tolua_isnoobj(tolua_S,4,&tolua_err)
3386 const fawkes::tf::Quaternion* q = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
3387 const fawkes::tf::Vector3* c = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,3,0));
3388 bool exc_caught =
false;
3391 fawkes::tf::Transform* tolua_ret = (fawkes::tf::Transform*) Mtolua_new((fawkes::tf::Transform)(*q,*c));
3392 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Transform");
3393 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3399 catch (std::exception &e) {
3401 lua_pushstring(tolua_S, e.what());
3403 if (exc_caught) lua_error(tolua_S);
3408 return tolua_fawkestf_fawkes_tf_Transform_new00_local(tolua_S);
3410 #endif //#ifndef TOLUA_DISABLE 3413 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new02 3414 static int tolua_fawkestf_fawkes_tf_Transform_new02(lua_State* tolua_S)
3416 tolua_Error tolua_err;
3418 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Transform",0,&tolua_err) ||
3419 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Transform",0,&tolua_err)) ||
3420 !tolua_isnoobj(tolua_S,3,&tolua_err)
3425 const fawkes::tf::Transform* other = ((
const fawkes::tf::Transform*) tolua_tousertype(tolua_S,2,0));
3426 bool exc_caught =
false;
3429 fawkes::tf::Transform* tolua_ret = (fawkes::tf::Transform*) Mtolua_new((fawkes::tf::Transform)(*other));
3430 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Transform");
3436 catch (std::exception &e) {
3438 lua_pushstring(tolua_S, e.what());
3440 if (exc_caught) lua_error(tolua_S);
3445 return tolua_fawkestf_fawkes_tf_Transform_new01(tolua_S);
3447 #endif //#ifndef TOLUA_DISABLE 3450 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new02_local 3451 static int tolua_fawkestf_fawkes_tf_Transform_new02_local(lua_State* tolua_S)
3453 tolua_Error tolua_err;
3455 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Transform",0,&tolua_err) ||
3456 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Transform",0,&tolua_err)) ||
3457 !tolua_isnoobj(tolua_S,3,&tolua_err)
3462 const fawkes::tf::Transform* other = ((
const fawkes::tf::Transform*) tolua_tousertype(tolua_S,2,0));
3463 bool exc_caught =
false;
3466 fawkes::tf::Transform* tolua_ret = (fawkes::tf::Transform*) Mtolua_new((fawkes::tf::Transform)(*other));
3467 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Transform");
3468 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3474 catch (std::exception &e) {
3476 lua_pushstring(tolua_S, e.what());
3478 if (exc_caught) lua_error(tolua_S);
3483 return tolua_fawkestf_fawkes_tf_Transform_new01_local(tolua_S);
3485 #endif //#ifndef TOLUA_DISABLE 3488 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_getIdentity00 3489 static int tolua_fawkestf_fawkes_tf_Transform_getIdentity00(lua_State* tolua_S)
3491 #ifndef TOLUA_RELEASE 3492 tolua_Error tolua_err;
3494 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Transform",0,&tolua_err) ||
3495 !tolua_isnoobj(tolua_S,2,&tolua_err)
3501 bool exc_caught =
false;
3504 const fawkes::tf::Transform& tolua_ret = (
const fawkes::tf::Transform&) fawkes::tf::Transform::getIdentity();
3505 tolua_pushusertype(tolua_S,(
void*)&tolua_ret,
"const fawkes::tf::Transform");
3511 catch (std::exception &e) {
3513 lua_pushstring(tolua_S, e.what());
3515 if (exc_caught) lua_error(tolua_S);
3519 #ifndef TOLUA_RELEASE 3521 tolua_error(tolua_S,
"#ferror in function 'getIdentity'.",&tolua_err);
3525 #endif //#ifndef TOLUA_DISABLE 3528 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_mult00 3529 static int tolua_fawkestf_fawkes_tf_Transform_mult00(lua_State* tolua_S)
3531 #ifndef TOLUA_RELEASE 3532 tolua_Error tolua_err;
3534 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Transform",0,&tolua_err) ||
3535 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Transform",0,&tolua_err)) ||
3536 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::tf::Transform",0,&tolua_err)) ||
3537 !tolua_isnoobj(tolua_S,4,&tolua_err)
3543 fawkes::tf::Transform*
self = (fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3544 const fawkes::tf::Transform* t1 = ((
const fawkes::tf::Transform*) tolua_tousertype(tolua_S,2,0));
3545 const fawkes::tf::Transform* t2 = ((
const fawkes::tf::Transform*) tolua_tousertype(tolua_S,3,0));
3546 #ifndef TOLUA_RELEASE 3547 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'mult'", NULL);
3549 bool exc_caught =
false;
3552 self->mult(*t1,*t2);
3558 catch (std::exception &e) {
3560 lua_pushstring(tolua_S, e.what());
3562 if (exc_caught) lua_error(tolua_S);
3566 #ifndef TOLUA_RELEASE 3568 tolua_error(tolua_S,
"#ferror in function 'mult'.",&tolua_err);
3572 #endif //#ifndef TOLUA_DISABLE 3575 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform__mul00 3576 static int tolua_fawkestf_fawkes_tf_Transform__mul00(lua_State* tolua_S)
3578 #ifndef TOLUA_RELEASE 3579 tolua_Error tolua_err;
3581 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Transform",0,&tolua_err) ||
3582 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
3583 !tolua_isnoobj(tolua_S,3,&tolua_err)
3589 const fawkes::tf::Transform*
self = (
const fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3590 const fawkes::tf::Vector3* x = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
3591 #ifndef TOLUA_RELEASE 3592 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'operator*'", NULL);
3594 bool exc_caught =
false;
3597 fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->operator*(*x);
3600 void* tolua_obj = Mtolua_new((fawkes::tf::Vector3)(tolua_ret));
3601 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Vector3");
3602 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3604 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(fawkes::tf::Vector3));
3605 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Vector3");
3606 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3614 catch (std::exception &e) {
3616 lua_pushstring(tolua_S, e.what());
3618 if (exc_caught) lua_error(tolua_S);
3622 #ifndef TOLUA_RELEASE 3624 tolua_error(tolua_S,
"#ferror in function '.mul'.",&tolua_err);
3628 #endif //#ifndef TOLUA_DISABLE 3631 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform__mul01 3632 static int tolua_fawkestf_fawkes_tf_Transform__mul01(lua_State* tolua_S)
3634 tolua_Error tolua_err;
3636 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Transform",0,&tolua_err) ||
3637 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
3638 !tolua_isnoobj(tolua_S,3,&tolua_err)
3643 const fawkes::tf::Transform*
self = (
const fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3644 const fawkes::tf::Quaternion* q = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
3645 #ifndef TOLUA_RELEASE 3646 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'operator*'", NULL);
3648 bool exc_caught =
false;
3651 fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) self->operator*(*q);
3654 void* tolua_obj = Mtolua_new((fawkes::tf::Quaternion)(tolua_ret));
3655 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Quaternion");
3656 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3658 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(fawkes::tf::Quaternion));
3659 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Quaternion");
3660 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3668 catch (std::exception &e) {
3670 lua_pushstring(tolua_S, e.what());
3672 if (exc_caught) lua_error(tolua_S);
3677 return tolua_fawkestf_fawkes_tf_Transform__mul00(tolua_S);
3679 #endif //#ifndef TOLUA_DISABLE 3682 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_getOrigin00 3683 static int tolua_fawkestf_fawkes_tf_Transform_getOrigin00(lua_State* tolua_S)
3685 #ifndef TOLUA_RELEASE 3686 tolua_Error tolua_err;
3688 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Transform",0,&tolua_err) ||
3689 !tolua_isnoobj(tolua_S,2,&tolua_err)
3695 fawkes::tf::Transform*
self = (fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3696 #ifndef TOLUA_RELEASE 3697 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'getOrigin'", NULL);
3699 bool exc_caught =
false;
3702 fawkes::tf::Vector3& tolua_ret = (fawkes::tf::Vector3&) self->getOrigin();
3703 tolua_pushusertype(tolua_S,(
void*)&tolua_ret,
"fawkes::tf::Vector3");
3709 catch (std::exception &e) {
3711 lua_pushstring(tolua_S, e.what());
3713 if (exc_caught) lua_error(tolua_S);
3717 #ifndef TOLUA_RELEASE 3719 tolua_error(tolua_S,
"#ferror in function 'getOrigin'.",&tolua_err);
3723 #endif //#ifndef TOLUA_DISABLE 3726 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_getRotation00 3727 static int tolua_fawkestf_fawkes_tf_Transform_getRotation00(lua_State* tolua_S)
3729 #ifndef TOLUA_RELEASE 3730 tolua_Error tolua_err;
3732 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Transform",0,&tolua_err) ||
3733 !tolua_isnoobj(tolua_S,2,&tolua_err)
3739 const fawkes::tf::Transform*
self = (
const fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3740 #ifndef TOLUA_RELEASE 3741 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'getRotation'", NULL);
3743 bool exc_caught =
false;
3746 fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) self->getRotation();
3749 void* tolua_obj = Mtolua_new((fawkes::tf::Quaternion)(tolua_ret));
3750 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Quaternion");
3751 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3753 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(fawkes::tf::Quaternion));
3754 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Quaternion");
3755 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3763 catch (std::exception &e) {
3765 lua_pushstring(tolua_S, e.what());
3767 if (exc_caught) lua_error(tolua_S);
3771 #ifndef TOLUA_RELEASE 3773 tolua_error(tolua_S,
"#ferror in function 'getRotation'.",&tolua_err);
3777 #endif //#ifndef TOLUA_DISABLE 3780 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_setOrigin00 3781 static int tolua_fawkestf_fawkes_tf_Transform_setOrigin00(lua_State* tolua_S)
3783 #ifndef TOLUA_RELEASE 3784 tolua_Error tolua_err;
3786 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Transform",0,&tolua_err) ||
3787 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
3788 !tolua_isnoobj(tolua_S,3,&tolua_err)
3794 fawkes::tf::Transform*
self = (fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3795 const fawkes::tf::Vector3* origin = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
3796 #ifndef TOLUA_RELEASE 3797 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'setOrigin'", NULL);
3799 bool exc_caught =
false;
3802 self->setOrigin(*origin);
3808 catch (std::exception &e) {
3810 lua_pushstring(tolua_S, e.what());
3812 if (exc_caught) lua_error(tolua_S);
3816 #ifndef TOLUA_RELEASE 3818 tolua_error(tolua_S,
"#ferror in function 'setOrigin'.",&tolua_err);
3822 #endif //#ifndef TOLUA_DISABLE 3825 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_setRotation00 3826 static int tolua_fawkestf_fawkes_tf_Transform_setRotation00(lua_State* tolua_S)
3828 #ifndef TOLUA_RELEASE 3829 tolua_Error tolua_err;
3831 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Transform",0,&tolua_err) ||
3832 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
3833 !tolua_isnoobj(tolua_S,3,&tolua_err)
3839 fawkes::tf::Transform*
self = (fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3840 const fawkes::tf::Quaternion* q = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
3841 #ifndef TOLUA_RELEASE 3842 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'setRotation'", NULL);
3844 bool exc_caught =
false;
3847 self->setRotation(*q);
3853 catch (std::exception &e) {
3855 lua_pushstring(tolua_S, e.what());
3857 if (exc_caught) lua_error(tolua_S);
3861 #ifndef TOLUA_RELEASE 3863 tolua_error(tolua_S,
"#ferror in function 'setRotation'.",&tolua_err);
3867 #endif //#ifndef TOLUA_DISABLE 3870 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_setIdentity00 3871 static int tolua_fawkestf_fawkes_tf_Transform_setIdentity00(lua_State* tolua_S)
3873 #ifndef TOLUA_RELEASE 3874 tolua_Error tolua_err;
3876 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Transform",0,&tolua_err) ||
3877 !tolua_isnoobj(tolua_S,2,&tolua_err)
3883 fawkes::tf::Transform*
self = (fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3884 #ifndef TOLUA_RELEASE 3885 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'setIdentity'", NULL);
3887 bool exc_caught =
false;
3890 self->setIdentity();
3896 catch (std::exception &e) {
3898 lua_pushstring(tolua_S, e.what());
3900 if (exc_caught) lua_error(tolua_S);
3904 #ifndef TOLUA_RELEASE 3906 tolua_error(tolua_S,
"#ferror in function 'setIdentity'.",&tolua_err);
3910 #endif //#ifndef TOLUA_DISABLE 3913 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_inverse00 3914 static int tolua_fawkestf_fawkes_tf_Transform_inverse00(lua_State* tolua_S)
3916 #ifndef TOLUA_RELEASE 3917 tolua_Error tolua_err;
3919 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Transform",0,&tolua_err) ||
3920 !tolua_isnoobj(tolua_S,2,&tolua_err)
3926 const fawkes::tf::Transform*
self = (
const fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3927 #ifndef TOLUA_RELEASE 3928 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'inverse'", NULL);
3930 bool exc_caught =
false;
3933 fawkes::tf::Transform tolua_ret = (fawkes::tf::Transform) self->inverse();
3936 void* tolua_obj = Mtolua_new((fawkes::tf::Transform)(tolua_ret));
3937 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Transform");
3938 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3940 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(fawkes::tf::Transform));
3941 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Transform");
3942 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3950 catch (std::exception &e) {
3952 lua_pushstring(tolua_S, e.what());
3954 if (exc_caught) lua_error(tolua_S);
3958 #ifndef TOLUA_RELEASE 3960 tolua_error(tolua_S,
"#ferror in function 'inverse'.",&tolua_err);
3964 #endif //#ifndef TOLUA_DISABLE 3967 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_inverseTimes00 3968 static int tolua_fawkestf_fawkes_tf_Transform_inverseTimes00(lua_State* tolua_S)
3970 #ifndef TOLUA_RELEASE 3971 tolua_Error tolua_err;
3973 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Transform",0,&tolua_err) ||
3974 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Transform",0,&tolua_err)) ||
3975 !tolua_isnoobj(tolua_S,3,&tolua_err)
3981 const fawkes::tf::Transform*
self = (
const fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
3982 const fawkes::tf::Transform* t = ((
const fawkes::tf::Transform*) tolua_tousertype(tolua_S,2,0));
3983 #ifndef TOLUA_RELEASE 3984 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'inverseTimes'", NULL);
3986 bool exc_caught =
false;
3989 fawkes::tf::Transform tolua_ret = (fawkes::tf::Transform) self->inverseTimes(*t);
3992 void* tolua_obj = Mtolua_new((fawkes::tf::Transform)(tolua_ret));
3993 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Transform");
3994 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
3996 void* tolua_obj = tolua_copy(tolua_S,(
void*)&tolua_ret,
sizeof(fawkes::tf::Transform));
3997 tolua_pushusertype(tolua_S,tolua_obj,
"fawkes::tf::Transform");
3998 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4006 catch (std::exception &e) {
4008 lua_pushstring(tolua_S, e.what());
4010 if (exc_caught) lua_error(tolua_S);
4014 #ifndef TOLUA_RELEASE 4016 tolua_error(tolua_S,
"#ferror in function 'inverseTimes'.",&tolua_err);
4020 #endif //#ifndef TOLUA_DISABLE 4023 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Point_new00 4024 static int tolua_fawkestf_fawkes_tf_Point_new00(lua_State* tolua_S)
4026 #ifndef TOLUA_RELEASE 4027 tolua_Error tolua_err;
4029 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Point",0,&tolua_err) ||
4030 !tolua_isnoobj(tolua_S,2,&tolua_err)
4036 bool exc_caught =
false;
4039 fawkes::tf::Point* tolua_ret = (fawkes::tf::Point*) Mtolua_new((fawkes::tf::Point)());
4040 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Point");
4046 catch (std::exception &e) {
4048 lua_pushstring(tolua_S, e.what());
4050 if (exc_caught) lua_error(tolua_S);
4054 #ifndef TOLUA_RELEASE 4056 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
4060 #endif //#ifndef TOLUA_DISABLE 4063 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Point_new00_local 4064 static int tolua_fawkestf_fawkes_tf_Point_new00_local(lua_State* tolua_S)
4066 #ifndef TOLUA_RELEASE 4067 tolua_Error tolua_err;
4069 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Point",0,&tolua_err) ||
4070 !tolua_isnoobj(tolua_S,2,&tolua_err)
4076 bool exc_caught =
false;
4079 fawkes::tf::Point* tolua_ret = (fawkes::tf::Point*) Mtolua_new((fawkes::tf::Point)());
4080 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Point");
4081 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4087 catch (std::exception &e) {
4089 lua_pushstring(tolua_S, e.what());
4091 if (exc_caught) lua_error(tolua_S);
4095 #ifndef TOLUA_RELEASE 4097 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
4101 #endif //#ifndef TOLUA_DISABLE 4104 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Point_new01 4105 static int tolua_fawkestf_fawkes_tf_Point_new01(lua_State* tolua_S)
4107 tolua_Error tolua_err;
4109 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Point",0,&tolua_err) ||
4110 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
4111 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
4112 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
4113 !tolua_isnoobj(tolua_S,5,&tolua_err)
4118 double x = ((double) tolua_tonumber(tolua_S,2,0));
4119 double y = ((double) tolua_tonumber(tolua_S,3,0));
4120 double z = ((double) tolua_tonumber(tolua_S,4,0));
4121 bool exc_caught =
false;
4124 fawkes::tf::Point* tolua_ret = (fawkes::tf::Point*) Mtolua_new((fawkes::tf::Point)(x,y,z));
4125 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Point");
4131 catch (std::exception &e) {
4133 lua_pushstring(tolua_S, e.what());
4135 if (exc_caught) lua_error(tolua_S);
4140 return tolua_fawkestf_fawkes_tf_Point_new00(tolua_S);
4142 #endif //#ifndef TOLUA_DISABLE 4145 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Point_new01_local 4146 static int tolua_fawkestf_fawkes_tf_Point_new01_local(lua_State* tolua_S)
4148 tolua_Error tolua_err;
4150 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Point",0,&tolua_err) ||
4151 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
4152 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
4153 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
4154 !tolua_isnoobj(tolua_S,5,&tolua_err)
4159 double x = ((double) tolua_tonumber(tolua_S,2,0));
4160 double y = ((double) tolua_tonumber(tolua_S,3,0));
4161 double z = ((double) tolua_tonumber(tolua_S,4,0));
4162 bool exc_caught =
false;
4165 fawkes::tf::Point* tolua_ret = (fawkes::tf::Point*) Mtolua_new((fawkes::tf::Point)(x,y,z));
4166 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Point");
4167 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4173 catch (std::exception &e) {
4175 lua_pushstring(tolua_S, e.what());
4177 if (exc_caught) lua_error(tolua_S);
4182 return tolua_fawkestf_fawkes_tf_Point_new00_local(tolua_S);
4184 #endif //#ifndef TOLUA_DISABLE 4187 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new00 4188 static int tolua_fawkestf_fawkes_tf_Pose_new00(lua_State* tolua_S)
4190 #ifndef TOLUA_RELEASE 4191 tolua_Error tolua_err;
4193 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Pose",0,&tolua_err) ||
4194 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
4195 !tolua_isnoobj(tolua_S,3,&tolua_err)
4201 const fawkes::tf::Quaternion* q = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
4202 bool exc_caught =
false;
4205 fawkes::tf::Pose* tolua_ret = (fawkes::tf::Pose*) Mtolua_new((fawkes::tf::Pose)(*q));
4206 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Pose");
4212 catch (std::exception &e) {
4214 lua_pushstring(tolua_S, e.what());
4216 if (exc_caught) lua_error(tolua_S);
4220 #ifndef TOLUA_RELEASE 4222 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
4226 #endif //#ifndef TOLUA_DISABLE 4229 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new00_local 4230 static int tolua_fawkestf_fawkes_tf_Pose_new00_local(lua_State* tolua_S)
4232 #ifndef TOLUA_RELEASE 4233 tolua_Error tolua_err;
4235 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Pose",0,&tolua_err) ||
4236 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
4237 !tolua_isnoobj(tolua_S,3,&tolua_err)
4243 const fawkes::tf::Quaternion* q = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
4244 bool exc_caught =
false;
4247 fawkes::tf::Pose* tolua_ret = (fawkes::tf::Pose*) Mtolua_new((fawkes::tf::Pose)(*q));
4248 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Pose");
4249 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4255 catch (std::exception &e) {
4257 lua_pushstring(tolua_S, e.what());
4259 if (exc_caught) lua_error(tolua_S);
4263 #ifndef TOLUA_RELEASE 4265 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
4269 #endif //#ifndef TOLUA_DISABLE 4272 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new01 4273 static int tolua_fawkestf_fawkes_tf_Pose_new01(lua_State* tolua_S)
4275 tolua_Error tolua_err;
4277 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Pose",0,&tolua_err) ||
4278 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
4279 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
4280 !tolua_isnoobj(tolua_S,4,&tolua_err)
4285 const fawkes::tf::Quaternion* q = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
4286 const fawkes::tf::Vector3* c = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,3,0));
4287 bool exc_caught =
false;
4290 fawkes::tf::Pose* tolua_ret = (fawkes::tf::Pose*) Mtolua_new((fawkes::tf::Pose)(*q,*c));
4291 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Pose");
4297 catch (std::exception &e) {
4299 lua_pushstring(tolua_S, e.what());
4301 if (exc_caught) lua_error(tolua_S);
4306 return tolua_fawkestf_fawkes_tf_Pose_new00(tolua_S);
4308 #endif //#ifndef TOLUA_DISABLE 4311 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new01_local 4312 static int tolua_fawkestf_fawkes_tf_Pose_new01_local(lua_State* tolua_S)
4314 tolua_Error tolua_err;
4316 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Pose",0,&tolua_err) ||
4317 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
4318 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
4319 !tolua_isnoobj(tolua_S,4,&tolua_err)
4324 const fawkes::tf::Quaternion* q = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
4325 const fawkes::tf::Vector3* c = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,3,0));
4326 bool exc_caught =
false;
4329 fawkes::tf::Pose* tolua_ret = (fawkes::tf::Pose*) Mtolua_new((fawkes::tf::Pose)(*q,*c));
4330 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Pose");
4331 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4337 catch (std::exception &e) {
4339 lua_pushstring(tolua_S, e.what());
4341 if (exc_caught) lua_error(tolua_S);
4346 return tolua_fawkestf_fawkes_tf_Pose_new00_local(tolua_S);
4348 #endif //#ifndef TOLUA_DISABLE 4351 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new02 4352 static int tolua_fawkestf_fawkes_tf_Pose_new02(lua_State* tolua_S)
4354 tolua_Error tolua_err;
4356 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Pose",0,&tolua_err) ||
4357 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Pose",0,&tolua_err)) ||
4358 !tolua_isnoobj(tolua_S,3,&tolua_err)
4363 const fawkes::tf::Pose* other = ((
const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
4364 bool exc_caught =
false;
4367 fawkes::tf::Pose* tolua_ret = (fawkes::tf::Pose*) Mtolua_new((fawkes::tf::Pose)(*other));
4368 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Pose");
4374 catch (std::exception &e) {
4376 lua_pushstring(tolua_S, e.what());
4378 if (exc_caught) lua_error(tolua_S);
4383 return tolua_fawkestf_fawkes_tf_Pose_new01(tolua_S);
4385 #endif //#ifndef TOLUA_DISABLE 4388 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new02_local 4389 static int tolua_fawkestf_fawkes_tf_Pose_new02_local(lua_State* tolua_S)
4391 tolua_Error tolua_err;
4393 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Pose",0,&tolua_err) ||
4394 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Pose",0,&tolua_err)) ||
4395 !tolua_isnoobj(tolua_S,3,&tolua_err)
4400 const fawkes::tf::Pose* other = ((
const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
4401 bool exc_caught =
false;
4404 fawkes::tf::Pose* tolua_ret = (fawkes::tf::Pose*) Mtolua_new((fawkes::tf::Pose)(*other));
4405 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Pose");
4406 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4412 catch (std::exception &e) {
4414 lua_pushstring(tolua_S, e.what());
4416 if (exc_caught) lua_error(tolua_S);
4421 return tolua_fawkestf_fawkes_tf_Pose_new01_local(tolua_S);
4423 #endif //#ifndef TOLUA_DISABLE 4426 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_getIdentity00 4427 static int tolua_fawkestf_fawkes_tf_Pose_getIdentity00(lua_State* tolua_S)
4429 #ifndef TOLUA_RELEASE 4430 tolua_Error tolua_err;
4432 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Pose",0,&tolua_err) ||
4433 !tolua_isnoobj(tolua_S,2,&tolua_err)
4439 bool exc_caught =
false;
4442 const fawkes::tf::Pose& tolua_ret = (
const fawkes::tf::Pose&) fawkes::tf::Pose::getIdentity();
4443 tolua_pushusertype(tolua_S,(
void*)&tolua_ret,
"const fawkes::tf::Pose");
4449 catch (std::exception &e) {
4451 lua_pushstring(tolua_S, e.what());
4453 if (exc_caught) lua_error(tolua_S);
4457 #ifndef TOLUA_RELEASE 4459 tolua_error(tolua_S,
"#ferror in function 'getIdentity'.",&tolua_err);
4463 #endif //#ifndef TOLUA_DISABLE 4466 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__StampedTransform_stamp 4467 static int tolua_get_fawkes__tf__StampedTransform_stamp(lua_State* tolua_S)
4470 #ifndef TOLUA_RELEASE 4471 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'stamp'",NULL);
4473 tolua_pushusertype(tolua_S,(
void*)&self->stamp,
"fawkes::Time");
4476 #endif //#ifndef TOLUA_DISABLE 4479 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__StampedTransform_stamp 4480 static int tolua_set_fawkes__tf__StampedTransform_stamp(lua_State* tolua_S)
4483 #ifndef TOLUA_RELEASE 4484 tolua_Error tolua_err;
4485 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'stamp'",NULL);
4486 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"fawkes::Time",0,&tolua_err)))
4487 tolua_error(tolua_S,
"#vinvalid type in variable assignment.",&tolua_err);
4489 self->stamp = *((
fawkes::Time*) tolua_tousertype(tolua_S,2,0))
4493 #endif //#ifndef TOLUA_DISABLE 4496 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__StampedTransform_frame_id 4497 static int tolua_get_fawkes__tf__StampedTransform_frame_id(lua_State* tolua_S)
4500 #ifndef TOLUA_RELEASE 4501 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'frame_id'",NULL);
4503 tolua_pushcppstring(tolua_S,(
const char*)self->frame_id);
4506 #endif //#ifndef TOLUA_DISABLE 4509 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__StampedTransform_frame_id 4510 static int tolua_set_fawkes__tf__StampedTransform_frame_id(lua_State* tolua_S)
4513 #ifndef TOLUA_RELEASE 4514 tolua_Error tolua_err;
4515 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'frame_id'",NULL);
4516 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
4517 tolua_error(tolua_S,
"#vinvalid type in variable assignment.",&tolua_err);
4519 self->frame_id = ((std::string) tolua_tocppstring(tolua_S,2,0))
4523 #endif //#ifndef TOLUA_DISABLE 4526 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__StampedTransform_child_frame_id 4527 static int tolua_get_fawkes__tf__StampedTransform_child_frame_id(lua_State* tolua_S)
4530 #ifndef TOLUA_RELEASE 4531 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'child_frame_id'",NULL);
4533 tolua_pushcppstring(tolua_S,(
const char*)self->child_frame_id);
4536 #endif //#ifndef TOLUA_DISABLE 4539 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__StampedTransform_child_frame_id 4540 static int tolua_set_fawkes__tf__StampedTransform_child_frame_id(lua_State* tolua_S)
4543 #ifndef TOLUA_RELEASE 4544 tolua_Error tolua_err;
4545 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'child_frame_id'",NULL);
4546 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
4547 tolua_error(tolua_S,
"#vinvalid type in variable assignment.",&tolua_err);
4549 self->child_frame_id = ((std::string) tolua_tocppstring(tolua_S,2,0))
4553 #endif //#ifndef TOLUA_DISABLE 4556 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_new00 4557 static int tolua_fawkestf_fawkes_tf_StampedTransform_new00(lua_State* tolua_S)
4559 #ifndef TOLUA_RELEASE 4560 tolua_Error tolua_err;
4562 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedTransform",0,&tolua_err) ||
4563 !tolua_isnoobj(tolua_S,2,&tolua_err)
4569 bool exc_caught =
false;
4573 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedTransform");
4579 catch (std::exception &e) {
4581 lua_pushstring(tolua_S, e.what());
4583 if (exc_caught) lua_error(tolua_S);
4587 #ifndef TOLUA_RELEASE 4589 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
4593 #endif //#ifndef TOLUA_DISABLE 4596 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_new00_local 4597 static int tolua_fawkestf_fawkes_tf_StampedTransform_new00_local(lua_State* tolua_S)
4599 #ifndef TOLUA_RELEASE 4600 tolua_Error tolua_err;
4602 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedTransform",0,&tolua_err) ||
4603 !tolua_isnoobj(tolua_S,2,&tolua_err)
4609 bool exc_caught =
false;
4613 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedTransform");
4614 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4620 catch (std::exception &e) {
4622 lua_pushstring(tolua_S, e.what());
4624 if (exc_caught) lua_error(tolua_S);
4628 #ifndef TOLUA_RELEASE 4630 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
4634 #endif //#ifndef TOLUA_DISABLE 4637 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_new01 4638 static int tolua_fawkestf_fawkes_tf_StampedTransform_new01(lua_State* tolua_S)
4640 tolua_Error tolua_err;
4642 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedTransform",0,&tolua_err) ||
4643 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Transform",0,&tolua_err)) ||
4644 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
4645 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
4646 !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
4647 !tolua_isnoobj(tolua_S,6,&tolua_err)
4652 const fawkes::tf::Transform* input = ((
const fawkes::tf::Transform*) tolua_tousertype(tolua_S,2,0));
4654 const std::string frame_id = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
4655 const std::string child_frame_id = ((
const std::string) tolua_tocppstring(tolua_S,5,0));
4656 bool exc_caught =
false;
4660 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedTransform");
4661 tolua_pushcppstring(tolua_S,(
const char*)frame_id);
4662 tolua_pushcppstring(tolua_S,(
const char*)child_frame_id);
4668 catch (std::exception &e) {
4670 lua_pushstring(tolua_S, e.what());
4672 if (exc_caught) lua_error(tolua_S);
4677 return tolua_fawkestf_fawkes_tf_StampedTransform_new00(tolua_S);
4679 #endif //#ifndef TOLUA_DISABLE 4682 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_new01_local 4683 static int tolua_fawkestf_fawkes_tf_StampedTransform_new01_local(lua_State* tolua_S)
4685 tolua_Error tolua_err;
4687 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedTransform",0,&tolua_err) ||
4688 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Transform",0,&tolua_err)) ||
4689 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
4690 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
4691 !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
4692 !tolua_isnoobj(tolua_S,6,&tolua_err)
4697 const fawkes::tf::Transform* input = ((
const fawkes::tf::Transform*) tolua_tousertype(tolua_S,2,0));
4699 const std::string frame_id = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
4700 const std::string child_frame_id = ((
const std::string) tolua_tocppstring(tolua_S,5,0));
4701 bool exc_caught =
false;
4705 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedTransform");
4706 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4707 tolua_pushcppstring(tolua_S,(
const char*)frame_id);
4708 tolua_pushcppstring(tolua_S,(
const char*)child_frame_id);
4714 catch (std::exception &e) {
4716 lua_pushstring(tolua_S, e.what());
4718 if (exc_caught) lua_error(tolua_S);
4723 return tolua_fawkestf_fawkes_tf_StampedTransform_new00_local(tolua_S);
4725 #endif //#ifndef TOLUA_DISABLE 4728 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_set_data00 4729 static int tolua_fawkestf_fawkes_tf_StampedTransform_set_data00(lua_State* tolua_S)
4731 #ifndef TOLUA_RELEASE 4732 tolua_Error tolua_err;
4734 !tolua_isusertype(tolua_S,1,
"fawkes::tf::StampedTransform",0,&tolua_err) ||
4735 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Transform",0,&tolua_err)) ||
4736 !tolua_isnoobj(tolua_S,3,&tolua_err)
4743 const fawkes::tf::Transform* input = ((
const fawkes::tf::Transform*) tolua_tousertype(tolua_S,2,0));
4744 #ifndef TOLUA_RELEASE 4745 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'set_data'", NULL);
4747 bool exc_caught =
false;
4750 self->set_data(*input);
4756 catch (std::exception &e) {
4758 lua_pushstring(tolua_S, e.what());
4760 if (exc_caught) lua_error(tolua_S);
4764 #ifndef TOLUA_RELEASE 4766 tolua_error(tolua_S,
"#ferror in function 'set_data'.",&tolua_err);
4770 #endif //#ifndef TOLUA_DISABLE 4773 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp 4774 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp(lua_State* tolua_S)
4777 #ifndef TOLUA_RELEASE 4778 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'stamp'",NULL);
4780 tolua_pushusertype(tolua_S,(
void*)&self->stamp,
"fawkes::Time");
4783 #endif //#ifndef TOLUA_DISABLE 4786 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp 4787 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp(lua_State* tolua_S)
4790 #ifndef TOLUA_RELEASE 4791 tolua_Error tolua_err;
4792 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'stamp'",NULL);
4793 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"fawkes::Time",0,&tolua_err)))
4794 tolua_error(tolua_S,
"#vinvalid type in variable assignment.",&tolua_err);
4796 self->stamp = *((
fawkes::Time*) tolua_tousertype(tolua_S,2,0))
4800 #endif //#ifndef TOLUA_DISABLE 4803 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id 4804 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id(lua_State* tolua_S)
4807 #ifndef TOLUA_RELEASE 4808 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'frame_id'",NULL);
4810 tolua_pushcppstring(tolua_S,(
const char*)self->frame_id);
4813 #endif //#ifndef TOLUA_DISABLE 4816 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id 4817 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id(lua_State* tolua_S)
4820 #ifndef TOLUA_RELEASE 4821 tolua_Error tolua_err;
4822 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'frame_id'",NULL);
4823 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
4824 tolua_error(tolua_S,
"#vinvalid type in variable assignment.",&tolua_err);
4826 self->frame_id = ((std::string) tolua_tocppstring(tolua_S,2,0))
4830 #endif //#ifndef TOLUA_DISABLE 4833 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00 4834 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00(lua_State* tolua_S)
4836 #ifndef TOLUA_RELEASE 4837 tolua_Error tolua_err;
4839 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Quaternion>",0,&tolua_err) ||
4840 !tolua_isnoobj(tolua_S,2,&tolua_err)
4846 bool exc_caught =
false;
4850 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Stamped<fawkes::tf::Quaternion>");
4856 catch (std::exception &e) {
4858 lua_pushstring(tolua_S, e.what());
4860 if (exc_caught) lua_error(tolua_S);
4864 #ifndef TOLUA_RELEASE 4866 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
4870 #endif //#ifndef TOLUA_DISABLE 4873 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00_local 4874 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00_local(lua_State* tolua_S)
4876 #ifndef TOLUA_RELEASE 4877 tolua_Error tolua_err;
4879 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Quaternion>",0,&tolua_err) ||
4880 !tolua_isnoobj(tolua_S,2,&tolua_err)
4886 bool exc_caught =
false;
4890 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Stamped<fawkes::tf::Quaternion>");
4891 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4897 catch (std::exception &e) {
4899 lua_pushstring(tolua_S, e.what());
4901 if (exc_caught) lua_error(tolua_S);
4905 #ifndef TOLUA_RELEASE 4907 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
4911 #endif //#ifndef TOLUA_DISABLE 4914 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01 4915 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01(lua_State* tolua_S)
4917 tolua_Error tolua_err;
4919 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Quaternion>",0,&tolua_err) ||
4920 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
4921 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
4922 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
4923 !tolua_isnoobj(tolua_S,5,&tolua_err)
4928 const fawkes::tf::Quaternion* input = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
4930 const std::string frame_id = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
4931 bool exc_caught =
false;
4935 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Stamped<fawkes::tf::Quaternion>");
4936 tolua_pushcppstring(tolua_S,(
const char*)frame_id);
4942 catch (std::exception &e) {
4944 lua_pushstring(tolua_S, e.what());
4946 if (exc_caught) lua_error(tolua_S);
4951 return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00(tolua_S);
4953 #endif //#ifndef TOLUA_DISABLE 4956 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01_local 4957 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01_local(lua_State* tolua_S)
4959 tolua_Error tolua_err;
4961 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Quaternion>",0,&tolua_err) ||
4962 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
4963 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
4964 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
4965 !tolua_isnoobj(tolua_S,5,&tolua_err)
4970 const fawkes::tf::Quaternion* input = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
4972 const std::string frame_id = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
4973 bool exc_caught =
false;
4977 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Stamped<fawkes::tf::Quaternion>");
4978 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4979 tolua_pushcppstring(tolua_S,(
const char*)frame_id);
4985 catch (std::exception &e) {
4987 lua_pushstring(tolua_S, e.what());
4989 if (exc_caught) lua_error(tolua_S);
4994 return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00_local(tolua_S);
4996 #endif //#ifndef TOLUA_DISABLE 4999 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__set_data00 5000 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__set_data00(lua_State* tolua_S)
5002 #ifndef TOLUA_RELEASE 5003 tolua_Error tolua_err;
5005 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Quaternion>",0,&tolua_err) ||
5006 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
5007 !tolua_isnoobj(tolua_S,3,&tolua_err)
5014 const fawkes::tf::Quaternion* input = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
5015 #ifndef TOLUA_RELEASE 5016 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'set_data'", NULL);
5018 bool exc_caught =
false;
5021 self->set_data(*input);
5027 catch (std::exception &e) {
5029 lua_pushstring(tolua_S, e.what());
5031 if (exc_caught) lua_error(tolua_S);
5035 #ifndef TOLUA_RELEASE 5037 tolua_error(tolua_S,
"#ferror in function 'set_data'.",&tolua_err);
5041 #endif //#ifndef TOLUA_DISABLE 5044 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp 5045 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp(lua_State* tolua_S)
5048 #ifndef TOLUA_RELEASE 5049 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'stamp'",NULL);
5051 tolua_pushusertype(tolua_S,(
void*)&self->stamp,
"fawkes::Time");
5054 #endif //#ifndef TOLUA_DISABLE 5057 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp 5058 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp(lua_State* tolua_S)
5061 #ifndef TOLUA_RELEASE 5062 tolua_Error tolua_err;
5063 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'stamp'",NULL);
5064 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"fawkes::Time",0,&tolua_err)))
5065 tolua_error(tolua_S,
"#vinvalid type in variable assignment.",&tolua_err);
5067 self->stamp = *((
fawkes::Time*) tolua_tousertype(tolua_S,2,0))
5071 #endif //#ifndef TOLUA_DISABLE 5074 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id 5075 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id(lua_State* tolua_S)
5078 #ifndef TOLUA_RELEASE 5079 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'frame_id'",NULL);
5081 tolua_pushcppstring(tolua_S,(
const char*)self->frame_id);
5084 #endif //#ifndef TOLUA_DISABLE 5087 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id 5088 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id(lua_State* tolua_S)
5091 #ifndef TOLUA_RELEASE 5092 tolua_Error tolua_err;
5093 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'frame_id'",NULL);
5094 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
5095 tolua_error(tolua_S,
"#vinvalid type in variable assignment.",&tolua_err);
5097 self->frame_id = ((std::string) tolua_tocppstring(tolua_S,2,0))
5101 #endif //#ifndef TOLUA_DISABLE 5104 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00 5105 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00(lua_State* tolua_S)
5107 #ifndef TOLUA_RELEASE 5108 tolua_Error tolua_err;
5110 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Vector3>",0,&tolua_err) ||
5111 !tolua_isnoobj(tolua_S,2,&tolua_err)
5117 bool exc_caught =
false;
5121 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Stamped<fawkes::tf::Vector3>");
5127 catch (std::exception &e) {
5129 lua_pushstring(tolua_S, e.what());
5131 if (exc_caught) lua_error(tolua_S);
5135 #ifndef TOLUA_RELEASE 5137 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
5141 #endif //#ifndef TOLUA_DISABLE 5144 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00_local 5145 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00_local(lua_State* tolua_S)
5147 #ifndef TOLUA_RELEASE 5148 tolua_Error tolua_err;
5150 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Vector3>",0,&tolua_err) ||
5151 !tolua_isnoobj(tolua_S,2,&tolua_err)
5157 bool exc_caught =
false;
5161 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Stamped<fawkes::tf::Vector3>");
5162 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5168 catch (std::exception &e) {
5170 lua_pushstring(tolua_S, e.what());
5172 if (exc_caught) lua_error(tolua_S);
5176 #ifndef TOLUA_RELEASE 5178 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
5182 #endif //#ifndef TOLUA_DISABLE 5185 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01 5186 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01(lua_State* tolua_S)
5188 tolua_Error tolua_err;
5190 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Vector3>",0,&tolua_err) ||
5191 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
5192 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
5193 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
5194 !tolua_isnoobj(tolua_S,5,&tolua_err)
5199 const fawkes::tf::Vector3* input = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
5201 const std::string frame_id = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
5202 bool exc_caught =
false;
5206 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Stamped<fawkes::tf::Vector3>");
5207 tolua_pushcppstring(tolua_S,(
const char*)frame_id);
5213 catch (std::exception &e) {
5215 lua_pushstring(tolua_S, e.what());
5217 if (exc_caught) lua_error(tolua_S);
5222 return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00(tolua_S);
5224 #endif //#ifndef TOLUA_DISABLE 5227 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01_local 5228 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01_local(lua_State* tolua_S)
5230 tolua_Error tolua_err;
5232 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Vector3>",0,&tolua_err) ||
5233 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
5234 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
5235 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
5236 !tolua_isnoobj(tolua_S,5,&tolua_err)
5241 const fawkes::tf::Vector3* input = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
5243 const std::string frame_id = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
5244 bool exc_caught =
false;
5248 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Stamped<fawkes::tf::Vector3>");
5249 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5250 tolua_pushcppstring(tolua_S,(
const char*)frame_id);
5256 catch (std::exception &e) {
5258 lua_pushstring(tolua_S, e.what());
5260 if (exc_caught) lua_error(tolua_S);
5265 return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00_local(tolua_S);
5267 #endif //#ifndef TOLUA_DISABLE 5270 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__set_data00 5271 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__set_data00(lua_State* tolua_S)
5273 #ifndef TOLUA_RELEASE 5274 tolua_Error tolua_err;
5276 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Vector3>",0,&tolua_err) ||
5277 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
5278 !tolua_isnoobj(tolua_S,3,&tolua_err)
5285 const fawkes::tf::Vector3* input = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
5286 #ifndef TOLUA_RELEASE 5287 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'set_data'", NULL);
5289 bool exc_caught =
false;
5292 self->set_data(*input);
5298 catch (std::exception &e) {
5300 lua_pushstring(tolua_S, e.what());
5302 if (exc_caught) lua_error(tolua_S);
5306 #ifndef TOLUA_RELEASE 5308 tolua_error(tolua_S,
"#ferror in function 'set_data'.",&tolua_err);
5312 #endif //#ifndef TOLUA_DISABLE 5315 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__stamp 5316 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__stamp(lua_State* tolua_S)
5319 #ifndef TOLUA_RELEASE 5320 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'stamp'",NULL);
5322 tolua_pushusertype(tolua_S,(
void*)&self->stamp,
"fawkes::Time");
5325 #endif //#ifndef TOLUA_DISABLE 5328 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__stamp 5329 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__stamp(lua_State* tolua_S)
5332 #ifndef TOLUA_RELEASE 5333 tolua_Error tolua_err;
5334 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'stamp'",NULL);
5335 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"fawkes::Time",0,&tolua_err)))
5336 tolua_error(tolua_S,
"#vinvalid type in variable assignment.",&tolua_err);
5338 self->stamp = *((
fawkes::Time*) tolua_tousertype(tolua_S,2,0))
5342 #endif //#ifndef TOLUA_DISABLE 5345 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__frame_id 5346 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__frame_id(lua_State* tolua_S)
5349 #ifndef TOLUA_RELEASE 5350 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'frame_id'",NULL);
5352 tolua_pushcppstring(tolua_S,(
const char*)self->frame_id);
5355 #endif //#ifndef TOLUA_DISABLE 5358 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__frame_id 5359 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__frame_id(lua_State* tolua_S)
5362 #ifndef TOLUA_RELEASE 5363 tolua_Error tolua_err;
5364 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'frame_id'",NULL);
5365 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
5366 tolua_error(tolua_S,
"#vinvalid type in variable assignment.",&tolua_err);
5368 self->frame_id = ((std::string) tolua_tocppstring(tolua_S,2,0))
5372 #endif //#ifndef TOLUA_DISABLE 5375 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00 5376 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00(lua_State* tolua_S)
5378 #ifndef TOLUA_RELEASE 5379 tolua_Error tolua_err;
5381 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Point>",0,&tolua_err) ||
5382 !tolua_isnoobj(tolua_S,2,&tolua_err)
5388 bool exc_caught =
false;
5392 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Stamped<fawkes::tf::Point>");
5398 catch (std::exception &e) {
5400 lua_pushstring(tolua_S, e.what());
5402 if (exc_caught) lua_error(tolua_S);
5406 #ifndef TOLUA_RELEASE 5408 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
5412 #endif //#ifndef TOLUA_DISABLE 5415 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00_local 5416 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00_local(lua_State* tolua_S)
5418 #ifndef TOLUA_RELEASE 5419 tolua_Error tolua_err;
5421 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Point>",0,&tolua_err) ||
5422 !tolua_isnoobj(tolua_S,2,&tolua_err)
5428 bool exc_caught =
false;
5432 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Stamped<fawkes::tf::Point>");
5433 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5439 catch (std::exception &e) {
5441 lua_pushstring(tolua_S, e.what());
5443 if (exc_caught) lua_error(tolua_S);
5447 #ifndef TOLUA_RELEASE 5449 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
5453 #endif //#ifndef TOLUA_DISABLE 5456 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01 5457 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01(lua_State* tolua_S)
5459 tolua_Error tolua_err;
5461 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Point>",0,&tolua_err) ||
5462 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Point",0,&tolua_err)) ||
5463 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
5464 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
5465 !tolua_isnoobj(tolua_S,5,&tolua_err)
5470 const fawkes::tf::Point* input = ((
const fawkes::tf::Point*) tolua_tousertype(tolua_S,2,0));
5472 const std::string frame_id = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
5473 bool exc_caught =
false;
5477 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Stamped<fawkes::tf::Point>");
5478 tolua_pushcppstring(tolua_S,(
const char*)frame_id);
5484 catch (std::exception &e) {
5486 lua_pushstring(tolua_S, e.what());
5488 if (exc_caught) lua_error(tolua_S);
5493 return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00(tolua_S);
5495 #endif //#ifndef TOLUA_DISABLE 5498 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01_local 5499 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01_local(lua_State* tolua_S)
5501 tolua_Error tolua_err;
5503 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Point>",0,&tolua_err) ||
5504 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Point",0,&tolua_err)) ||
5505 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
5506 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
5507 !tolua_isnoobj(tolua_S,5,&tolua_err)
5512 const fawkes::tf::Point* input = ((
const fawkes::tf::Point*) tolua_tousertype(tolua_S,2,0));
5514 const std::string frame_id = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
5515 bool exc_caught =
false;
5519 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Stamped<fawkes::tf::Point>");
5520 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5521 tolua_pushcppstring(tolua_S,(
const char*)frame_id);
5527 catch (std::exception &e) {
5529 lua_pushstring(tolua_S, e.what());
5531 if (exc_caught) lua_error(tolua_S);
5536 return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00_local(tolua_S);
5538 #endif //#ifndef TOLUA_DISABLE 5541 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__set_data00 5542 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__set_data00(lua_State* tolua_S)
5544 #ifndef TOLUA_RELEASE 5545 tolua_Error tolua_err;
5547 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Point>",0,&tolua_err) ||
5548 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Point",0,&tolua_err)) ||
5549 !tolua_isnoobj(tolua_S,3,&tolua_err)
5556 const fawkes::tf::Point* input = ((
const fawkes::tf::Point*) tolua_tousertype(tolua_S,2,0));
5557 #ifndef TOLUA_RELEASE 5558 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'set_data'", NULL);
5560 bool exc_caught =
false;
5563 self->set_data(*input);
5569 catch (std::exception &e) {
5571 lua_pushstring(tolua_S, e.what());
5573 if (exc_caught) lua_error(tolua_S);
5577 #ifndef TOLUA_RELEASE 5579 tolua_error(tolua_S,
"#ferror in function 'set_data'.",&tolua_err);
5583 #endif //#ifndef TOLUA_DISABLE 5586 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__stamp 5587 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__stamp(lua_State* tolua_S)
5590 #ifndef TOLUA_RELEASE 5591 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'stamp'",NULL);
5593 tolua_pushusertype(tolua_S,(
void*)&self->stamp,
"fawkes::Time");
5596 #endif //#ifndef TOLUA_DISABLE 5599 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__stamp 5600 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__stamp(lua_State* tolua_S)
5603 #ifndef TOLUA_RELEASE 5604 tolua_Error tolua_err;
5605 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'stamp'",NULL);
5606 if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"fawkes::Time",0,&tolua_err)))
5607 tolua_error(tolua_S,
"#vinvalid type in variable assignment.",&tolua_err);
5609 self->stamp = *((
fawkes::Time*) tolua_tousertype(tolua_S,2,0))
5613 #endif //#ifndef TOLUA_DISABLE 5616 #ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id 5617 static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id(lua_State* tolua_S)
5620 #ifndef TOLUA_RELEASE 5621 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'frame_id'",NULL);
5623 tolua_pushcppstring(tolua_S,(
const char*)self->frame_id);
5626 #endif //#ifndef TOLUA_DISABLE 5629 #ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id 5630 static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id(lua_State* tolua_S)
5633 #ifndef TOLUA_RELEASE 5634 tolua_Error tolua_err;
5635 if (!
self) tolua_error(tolua_S,
"invalid 'self' in accessing variable 'frame_id'",NULL);
5636 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
5637 tolua_error(tolua_S,
"#vinvalid type in variable assignment.",&tolua_err);
5639 self->frame_id = ((std::string) tolua_tocppstring(tolua_S,2,0))
5643 #endif //#ifndef TOLUA_DISABLE 5646 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00 5647 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00(lua_State* tolua_S)
5649 #ifndef TOLUA_RELEASE 5650 tolua_Error tolua_err;
5652 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Pose>",0,&tolua_err) ||
5653 !tolua_isnoobj(tolua_S,2,&tolua_err)
5659 bool exc_caught =
false;
5663 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Stamped<fawkes::tf::Pose>");
5669 catch (std::exception &e) {
5671 lua_pushstring(tolua_S, e.what());
5673 if (exc_caught) lua_error(tolua_S);
5677 #ifndef TOLUA_RELEASE 5679 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
5683 #endif //#ifndef TOLUA_DISABLE 5686 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00_local 5687 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00_local(lua_State* tolua_S)
5689 #ifndef TOLUA_RELEASE 5690 tolua_Error tolua_err;
5692 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Pose>",0,&tolua_err) ||
5693 !tolua_isnoobj(tolua_S,2,&tolua_err)
5699 bool exc_caught =
false;
5703 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Stamped<fawkes::tf::Pose>");
5704 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5710 catch (std::exception &e) {
5712 lua_pushstring(tolua_S, e.what());
5714 if (exc_caught) lua_error(tolua_S);
5718 #ifndef TOLUA_RELEASE 5720 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
5724 #endif //#ifndef TOLUA_DISABLE 5727 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01 5728 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01(lua_State* tolua_S)
5730 tolua_Error tolua_err;
5732 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Pose>",0,&tolua_err) ||
5733 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Pose",0,&tolua_err)) ||
5734 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
5735 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
5736 !tolua_isnoobj(tolua_S,5,&tolua_err)
5741 const fawkes::tf::Pose* input = ((
const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
5743 const std::string frame_id = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
5744 bool exc_caught =
false;
5748 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Stamped<fawkes::tf::Pose>");
5749 tolua_pushcppstring(tolua_S,(
const char*)frame_id);
5755 catch (std::exception &e) {
5757 lua_pushstring(tolua_S, e.what());
5759 if (exc_caught) lua_error(tolua_S);
5764 return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00(tolua_S);
5766 #endif //#ifndef TOLUA_DISABLE 5769 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01_local 5770 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01_local(lua_State* tolua_S)
5772 tolua_Error tolua_err;
5774 !tolua_isusertable(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Pose>",0,&tolua_err) ||
5775 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Pose",0,&tolua_err)) ||
5776 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
5777 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
5778 !tolua_isnoobj(tolua_S,5,&tolua_err)
5783 const fawkes::tf::Pose* input = ((
const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
5785 const std::string frame_id = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
5786 bool exc_caught =
false;
5790 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::Stamped<fawkes::tf::Pose>");
5791 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5792 tolua_pushcppstring(tolua_S,(
const char*)frame_id);
5798 catch (std::exception &e) {
5800 lua_pushstring(tolua_S, e.what());
5802 if (exc_caught) lua_error(tolua_S);
5807 return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00_local(tolua_S);
5809 #endif //#ifndef TOLUA_DISABLE 5812 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__set_data00 5813 static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__set_data00(lua_State* tolua_S)
5815 #ifndef TOLUA_RELEASE 5816 tolua_Error tolua_err;
5818 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Stamped<fawkes::tf::Pose>",0,&tolua_err) ||
5819 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Pose",0,&tolua_err)) ||
5820 !tolua_isnoobj(tolua_S,3,&tolua_err)
5827 const fawkes::tf::Pose* input = ((
const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
5828 #ifndef TOLUA_RELEASE 5829 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'set_data'", NULL);
5831 bool exc_caught =
false;
5834 self->set_data(*input);
5840 catch (std::exception &e) {
5842 lua_pushstring(tolua_S, e.what());
5844 if (exc_caught) lua_error(tolua_S);
5848 #ifndef TOLUA_RELEASE 5850 tolua_error(tolua_S,
"#ferror in function 'set_data'.",&tolua_err);
5854 #endif //#ifndef TOLUA_DISABLE 5857 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedQuaternion_new00 5858 static int tolua_fawkestf_fawkes_tf_StampedQuaternion_new00(lua_State* tolua_S)
5860 #ifndef TOLUA_RELEASE 5861 tolua_Error tolua_err;
5863 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedQuaternion",0,&tolua_err) ||
5864 !tolua_isnoobj(tolua_S,2,&tolua_err)
5870 bool exc_caught =
false;
5873 fawkes::tf::StampedQuaternion* tolua_ret = (fawkes::tf::StampedQuaternion*) Mtolua_new((fawkes::tf::StampedQuaternion)());
5874 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedQuaternion");
5880 catch (std::exception &e) {
5882 lua_pushstring(tolua_S, e.what());
5884 if (exc_caught) lua_error(tolua_S);
5888 #ifndef TOLUA_RELEASE 5890 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
5894 #endif //#ifndef TOLUA_DISABLE 5897 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedQuaternion_new00_local 5898 static int tolua_fawkestf_fawkes_tf_StampedQuaternion_new00_local(lua_State* tolua_S)
5900 #ifndef TOLUA_RELEASE 5901 tolua_Error tolua_err;
5903 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedQuaternion",0,&tolua_err) ||
5904 !tolua_isnoobj(tolua_S,2,&tolua_err)
5910 bool exc_caught =
false;
5913 fawkes::tf::StampedQuaternion* tolua_ret = (fawkes::tf::StampedQuaternion*) Mtolua_new((fawkes::tf::StampedQuaternion)());
5914 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedQuaternion");
5915 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5921 catch (std::exception &e) {
5923 lua_pushstring(tolua_S, e.what());
5925 if (exc_caught) lua_error(tolua_S);
5929 #ifndef TOLUA_RELEASE 5931 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
5935 #endif //#ifndef TOLUA_DISABLE 5938 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedQuaternion_new01 5939 static int tolua_fawkestf_fawkes_tf_StampedQuaternion_new01(lua_State* tolua_S)
5941 tolua_Error tolua_err;
5943 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedQuaternion",0,&tolua_err) ||
5944 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
5945 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
5946 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
5947 !tolua_isnoobj(tolua_S,5,&tolua_err)
5952 const fawkes::tf::Quaternion* input = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
5954 const std::string frame_id = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
5955 bool exc_caught =
false;
5958 fawkes::tf::StampedQuaternion* tolua_ret = (fawkes::tf::StampedQuaternion*) Mtolua_new((fawkes::tf::StampedQuaternion)(*input,*timestamp,frame_id));
5959 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedQuaternion");
5960 tolua_pushcppstring(tolua_S,(
const char*)frame_id);
5966 catch (std::exception &e) {
5968 lua_pushstring(tolua_S, e.what());
5970 if (exc_caught) lua_error(tolua_S);
5975 return tolua_fawkestf_fawkes_tf_StampedQuaternion_new00(tolua_S);
5977 #endif //#ifndef TOLUA_DISABLE 5980 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedQuaternion_new01_local 5981 static int tolua_fawkestf_fawkes_tf_StampedQuaternion_new01_local(lua_State* tolua_S)
5983 tolua_Error tolua_err;
5985 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedQuaternion",0,&tolua_err) ||
5986 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Quaternion",0,&tolua_err)) ||
5987 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
5988 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
5989 !tolua_isnoobj(tolua_S,5,&tolua_err)
5994 const fawkes::tf::Quaternion* input = ((
const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
5996 const std::string frame_id = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
5997 bool exc_caught =
false;
6000 fawkes::tf::StampedQuaternion* tolua_ret = (fawkes::tf::StampedQuaternion*) Mtolua_new((fawkes::tf::StampedQuaternion)(*input,*timestamp,frame_id));
6001 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedQuaternion");
6002 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6003 tolua_pushcppstring(tolua_S,(
const char*)frame_id);
6009 catch (std::exception &e) {
6011 lua_pushstring(tolua_S, e.what());
6013 if (exc_caught) lua_error(tolua_S);
6018 return tolua_fawkestf_fawkes_tf_StampedQuaternion_new00_local(tolua_S);
6020 #endif //#ifndef TOLUA_DISABLE 6023 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedVector3_new00 6024 static int tolua_fawkestf_fawkes_tf_StampedVector3_new00(lua_State* tolua_S)
6026 #ifndef TOLUA_RELEASE 6027 tolua_Error tolua_err;
6029 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedVector3",0,&tolua_err) ||
6030 !tolua_isnoobj(tolua_S,2,&tolua_err)
6036 bool exc_caught =
false;
6039 fawkes::tf::StampedVector3* tolua_ret = (fawkes::tf::StampedVector3*) Mtolua_new((fawkes::tf::StampedVector3)());
6040 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedVector3");
6046 catch (std::exception &e) {
6048 lua_pushstring(tolua_S, e.what());
6050 if (exc_caught) lua_error(tolua_S);
6054 #ifndef TOLUA_RELEASE 6056 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
6060 #endif //#ifndef TOLUA_DISABLE 6063 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedVector3_new00_local 6064 static int tolua_fawkestf_fawkes_tf_StampedVector3_new00_local(lua_State* tolua_S)
6066 #ifndef TOLUA_RELEASE 6067 tolua_Error tolua_err;
6069 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedVector3",0,&tolua_err) ||
6070 !tolua_isnoobj(tolua_S,2,&tolua_err)
6076 bool exc_caught =
false;
6079 fawkes::tf::StampedVector3* tolua_ret = (fawkes::tf::StampedVector3*) Mtolua_new((fawkes::tf::StampedVector3)());
6080 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedVector3");
6081 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6087 catch (std::exception &e) {
6089 lua_pushstring(tolua_S, e.what());
6091 if (exc_caught) lua_error(tolua_S);
6095 #ifndef TOLUA_RELEASE 6097 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
6101 #endif //#ifndef TOLUA_DISABLE 6104 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedVector3_new01 6105 static int tolua_fawkestf_fawkes_tf_StampedVector3_new01(lua_State* tolua_S)
6107 tolua_Error tolua_err;
6109 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedVector3",0,&tolua_err) ||
6110 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
6111 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
6112 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
6113 !tolua_isnoobj(tolua_S,5,&tolua_err)
6118 const fawkes::tf::Vector3* input = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
6120 const std::string frame_id = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
6121 bool exc_caught =
false;
6124 fawkes::tf::StampedVector3* tolua_ret = (fawkes::tf::StampedVector3*) Mtolua_new((fawkes::tf::StampedVector3)(*input,*timestamp,frame_id));
6125 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedVector3");
6126 tolua_pushcppstring(tolua_S,(
const char*)frame_id);
6132 catch (std::exception &e) {
6134 lua_pushstring(tolua_S, e.what());
6136 if (exc_caught) lua_error(tolua_S);
6141 return tolua_fawkestf_fawkes_tf_StampedVector3_new00(tolua_S);
6143 #endif //#ifndef TOLUA_DISABLE 6146 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedVector3_new01_local 6147 static int tolua_fawkestf_fawkes_tf_StampedVector3_new01_local(lua_State* tolua_S)
6149 tolua_Error tolua_err;
6151 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedVector3",0,&tolua_err) ||
6152 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Vector3",0,&tolua_err)) ||
6153 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
6154 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
6155 !tolua_isnoobj(tolua_S,5,&tolua_err)
6160 const fawkes::tf::Vector3* input = ((
const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
6162 const std::string frame_id = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
6163 bool exc_caught =
false;
6166 fawkes::tf::StampedVector3* tolua_ret = (fawkes::tf::StampedVector3*) Mtolua_new((fawkes::tf::StampedVector3)(*input,*timestamp,frame_id));
6167 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedVector3");
6168 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6169 tolua_pushcppstring(tolua_S,(
const char*)frame_id);
6175 catch (std::exception &e) {
6177 lua_pushstring(tolua_S, e.what());
6179 if (exc_caught) lua_error(tolua_S);
6184 return tolua_fawkestf_fawkes_tf_StampedVector3_new00_local(tolua_S);
6186 #endif //#ifndef TOLUA_DISABLE 6189 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPoint_new00 6190 static int tolua_fawkestf_fawkes_tf_StampedPoint_new00(lua_State* tolua_S)
6192 #ifndef TOLUA_RELEASE 6193 tolua_Error tolua_err;
6195 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedPoint",0,&tolua_err) ||
6196 !tolua_isnoobj(tolua_S,2,&tolua_err)
6202 bool exc_caught =
false;
6205 fawkes::tf::StampedPoint* tolua_ret = (fawkes::tf::StampedPoint*) Mtolua_new((fawkes::tf::StampedPoint)());
6206 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedPoint");
6212 catch (std::exception &e) {
6214 lua_pushstring(tolua_S, e.what());
6216 if (exc_caught) lua_error(tolua_S);
6220 #ifndef TOLUA_RELEASE 6222 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
6226 #endif //#ifndef TOLUA_DISABLE 6229 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPoint_new00_local 6230 static int tolua_fawkestf_fawkes_tf_StampedPoint_new00_local(lua_State* tolua_S)
6232 #ifndef TOLUA_RELEASE 6233 tolua_Error tolua_err;
6235 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedPoint",0,&tolua_err) ||
6236 !tolua_isnoobj(tolua_S,2,&tolua_err)
6242 bool exc_caught =
false;
6245 fawkes::tf::StampedPoint* tolua_ret = (fawkes::tf::StampedPoint*) Mtolua_new((fawkes::tf::StampedPoint)());
6246 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedPoint");
6247 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6253 catch (std::exception &e) {
6255 lua_pushstring(tolua_S, e.what());
6257 if (exc_caught) lua_error(tolua_S);
6261 #ifndef TOLUA_RELEASE 6263 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
6267 #endif //#ifndef TOLUA_DISABLE 6270 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPoint_new01 6271 static int tolua_fawkestf_fawkes_tf_StampedPoint_new01(lua_State* tolua_S)
6273 tolua_Error tolua_err;
6275 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedPoint",0,&tolua_err) ||
6276 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Point",0,&tolua_err)) ||
6277 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
6278 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
6279 !tolua_isnoobj(tolua_S,5,&tolua_err)
6284 const fawkes::tf::Point* input = ((
const fawkes::tf::Point*) tolua_tousertype(tolua_S,2,0));
6286 const std::string frame_id = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
6287 bool exc_caught =
false;
6290 fawkes::tf::StampedPoint* tolua_ret = (fawkes::tf::StampedPoint*) Mtolua_new((fawkes::tf::StampedPoint)(*input,*timestamp,frame_id));
6291 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedPoint");
6292 tolua_pushcppstring(tolua_S,(
const char*)frame_id);
6298 catch (std::exception &e) {
6300 lua_pushstring(tolua_S, e.what());
6302 if (exc_caught) lua_error(tolua_S);
6307 return tolua_fawkestf_fawkes_tf_StampedPoint_new00(tolua_S);
6309 #endif //#ifndef TOLUA_DISABLE 6312 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPoint_new01_local 6313 static int tolua_fawkestf_fawkes_tf_StampedPoint_new01_local(lua_State* tolua_S)
6315 tolua_Error tolua_err;
6317 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedPoint",0,&tolua_err) ||
6318 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Point",0,&tolua_err)) ||
6319 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
6320 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
6321 !tolua_isnoobj(tolua_S,5,&tolua_err)
6326 const fawkes::tf::Point* input = ((
const fawkes::tf::Point*) tolua_tousertype(tolua_S,2,0));
6328 const std::string frame_id = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
6329 bool exc_caught =
false;
6332 fawkes::tf::StampedPoint* tolua_ret = (fawkes::tf::StampedPoint*) Mtolua_new((fawkes::tf::StampedPoint)(*input,*timestamp,frame_id));
6333 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedPoint");
6334 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6335 tolua_pushcppstring(tolua_S,(
const char*)frame_id);
6341 catch (std::exception &e) {
6343 lua_pushstring(tolua_S, e.what());
6345 if (exc_caught) lua_error(tolua_S);
6350 return tolua_fawkestf_fawkes_tf_StampedPoint_new00_local(tolua_S);
6352 #endif //#ifndef TOLUA_DISABLE 6355 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPose_new00 6356 static int tolua_fawkestf_fawkes_tf_StampedPose_new00(lua_State* tolua_S)
6358 #ifndef TOLUA_RELEASE 6359 tolua_Error tolua_err;
6361 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedPose",0,&tolua_err) ||
6362 !tolua_isnoobj(tolua_S,2,&tolua_err)
6368 bool exc_caught =
false;
6371 fawkes::tf::StampedPose* tolua_ret = (fawkes::tf::StampedPose*) Mtolua_new((fawkes::tf::StampedPose)());
6372 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedPose");
6378 catch (std::exception &e) {
6380 lua_pushstring(tolua_S, e.what());
6382 if (exc_caught) lua_error(tolua_S);
6386 #ifndef TOLUA_RELEASE 6388 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
6392 #endif //#ifndef TOLUA_DISABLE 6395 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPose_new00_local 6396 static int tolua_fawkestf_fawkes_tf_StampedPose_new00_local(lua_State* tolua_S)
6398 #ifndef TOLUA_RELEASE 6399 tolua_Error tolua_err;
6401 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedPose",0,&tolua_err) ||
6402 !tolua_isnoobj(tolua_S,2,&tolua_err)
6408 bool exc_caught =
false;
6411 fawkes::tf::StampedPose* tolua_ret = (fawkes::tf::StampedPose*) Mtolua_new((fawkes::tf::StampedPose)());
6412 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedPose");
6413 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6419 catch (std::exception &e) {
6421 lua_pushstring(tolua_S, e.what());
6423 if (exc_caught) lua_error(tolua_S);
6427 #ifndef TOLUA_RELEASE 6429 tolua_error(tolua_S,
"#ferror in function 'new'.",&tolua_err);
6433 #endif //#ifndef TOLUA_DISABLE 6436 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPose_new01 6437 static int tolua_fawkestf_fawkes_tf_StampedPose_new01(lua_State* tolua_S)
6439 tolua_Error tolua_err;
6441 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedPose",0,&tolua_err) ||
6442 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Pose",0,&tolua_err)) ||
6443 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
6444 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
6445 !tolua_isnoobj(tolua_S,5,&tolua_err)
6450 const fawkes::tf::Pose* input = ((
const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
6452 const std::string frame_id = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
6453 bool exc_caught =
false;
6456 fawkes::tf::StampedPose* tolua_ret = (fawkes::tf::StampedPose*) Mtolua_new((fawkes::tf::StampedPose)(*input,*timestamp,frame_id));
6457 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedPose");
6458 tolua_pushcppstring(tolua_S,(
const char*)frame_id);
6464 catch (std::exception &e) {
6466 lua_pushstring(tolua_S, e.what());
6468 if (exc_caught) lua_error(tolua_S);
6473 return tolua_fawkestf_fawkes_tf_StampedPose_new00(tolua_S);
6475 #endif //#ifndef TOLUA_DISABLE 6478 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPose_new01_local 6479 static int tolua_fawkestf_fawkes_tf_StampedPose_new01_local(lua_State* tolua_S)
6481 tolua_Error tolua_err;
6483 !tolua_isusertable(tolua_S,1,
"fawkes::tf::StampedPose",0,&tolua_err) ||
6484 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,
"const fawkes::tf::Pose",0,&tolua_err)) ||
6485 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
6486 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
6487 !tolua_isnoobj(tolua_S,5,&tolua_err)
6492 const fawkes::tf::Pose* input = ((
const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
6494 const std::string frame_id = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
6495 bool exc_caught =
false;
6498 fawkes::tf::StampedPose* tolua_ret = (fawkes::tf::StampedPose*) Mtolua_new((fawkes::tf::StampedPose)(*input,*timestamp,frame_id));
6499 tolua_pushusertype(tolua_S,(
void*)tolua_ret,
"fawkes::tf::StampedPose");
6500 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6501 tolua_pushcppstring(tolua_S,(
const char*)frame_id);
6507 catch (std::exception &e) {
6509 lua_pushstring(tolua_S, e.what());
6511 if (exc_caught) lua_error(tolua_S);
6516 return tolua_fawkestf_fawkes_tf_StampedPose_new00_local(tolua_S);
6518 #endif //#ifndef TOLUA_DISABLE 6521 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_clear00 6522 static int tolua_fawkestf_fawkes_tf_Transformer_clear00(lua_State* tolua_S)
6524 #ifndef TOLUA_RELEASE 6525 tolua_Error tolua_err;
6527 !tolua_isusertype(tolua_S,1,
"fawkes::tf::Transformer",0,&tolua_err) ||
6528 !tolua_isnoobj(tolua_S,2,&tolua_err)
6535 #ifndef TOLUA_RELEASE 6536 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'clear'", NULL);
6538 bool exc_caught =
false;
6547 catch (std::exception &e) {
6549 lua_pushstring(tolua_S, e.what());
6551 if (exc_caught) lua_error(tolua_S);
6555 #ifndef TOLUA_RELEASE 6557 tolua_error(tolua_S,
"#ferror in function 'clear'.",&tolua_err);
6561 #endif //#ifndef TOLUA_DISABLE 6564 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_frame_exists00 6565 static int tolua_fawkestf_fawkes_tf_Transformer_frame_exists00(lua_State* tolua_S)
6567 #ifndef TOLUA_RELEASE 6568 tolua_Error tolua_err;
6570 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Transformer",0,&tolua_err) ||
6571 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6572 !tolua_isnoobj(tolua_S,3,&tolua_err)
6579 const std::string frame_id_str = ((
const std::string) tolua_tocppstring(tolua_S,2,0));
6580 #ifndef TOLUA_RELEASE 6581 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'frame_exists'", NULL);
6583 bool exc_caught =
false;
6586 bool tolua_ret = (bool) self->frame_exists(frame_id_str);
6587 tolua_pushboolean(tolua_S,(
bool)tolua_ret);
6588 tolua_pushcppstring(tolua_S,(
const char*)frame_id_str);
6594 catch (std::exception &e) {
6596 lua_pushstring(tolua_S, e.what());
6598 if (exc_caught) lua_error(tolua_S);
6602 #ifndef TOLUA_RELEASE 6604 tolua_error(tolua_S,
"#ferror in function 'frame_exists'.",&tolua_err);
6608 #endif //#ifndef TOLUA_DISABLE 6611 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_lookup_transform00 6612 static int tolua_fawkestf_fawkes_tf_Transformer_lookup_transform00(lua_State* tolua_S)
6614 #ifndef TOLUA_RELEASE 6615 tolua_Error tolua_err;
6617 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Transformer",0,&tolua_err) ||
6618 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6619 !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
6620 (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,
"const fawkes::Time",0,&tolua_err)) ||
6621 (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,
"fawkes::tf::StampedTransform",0,&tolua_err)) ||
6622 !tolua_isnoobj(tolua_S,6,&tolua_err)
6629 const std::string target_frame = ((
const std::string) tolua_tocppstring(tolua_S,2,0));
6630 const std::string source_frame = ((
const std::string) tolua_tocppstring(tolua_S,3,0));
6633 #ifndef TOLUA_RELEASE 6634 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'lookup_transform'", NULL);
6636 bool exc_caught =
false;
6639 self->lookup_transform(target_frame,source_frame,*time,*transform);
6640 tolua_pushcppstring(tolua_S,(
const char*)target_frame);
6641 tolua_pushcppstring(tolua_S,(
const char*)source_frame);
6647 catch (std::exception &e) {
6649 lua_pushstring(tolua_S, e.what());
6651 if (exc_caught) lua_error(tolua_S);
6655 #ifndef TOLUA_RELEASE 6657 tolua_error(tolua_S,
"#ferror in function 'lookup_transform'.",&tolua_err);
6661 #endif //#ifndef TOLUA_DISABLE 6664 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_lookup_transform01 6665 static int tolua_fawkestf_fawkes_tf_Transformer_lookup_transform01(lua_State* tolua_S)
6667 tolua_Error tolua_err;
6669 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Transformer",0,&tolua_err) ||
6670 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6671 !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
6672 (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,
"fawkes::tf::StampedTransform",0,&tolua_err)) ||
6673 !tolua_isnoobj(tolua_S,5,&tolua_err)
6679 const std::string target_frame = ((
const std::string) tolua_tocppstring(tolua_S,2,0));
6680 const std::string source_frame = ((
const std::string) tolua_tocppstring(tolua_S,3,0));
6682 #ifndef TOLUA_RELEASE 6683 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'lookup_transform'", NULL);
6685 bool exc_caught =
false;
6688 self->lookup_transform(target_frame,source_frame,*transform);
6689 tolua_pushcppstring(tolua_S,(
const char*)target_frame);
6690 tolua_pushcppstring(tolua_S,(
const char*)source_frame);
6696 catch (std::exception &e) {
6698 lua_pushstring(tolua_S, e.what());
6700 if (exc_caught) lua_error(tolua_S);
6705 return tolua_fawkestf_fawkes_tf_Transformer_lookup_transform00(tolua_S);
6707 #endif //#ifndef TOLUA_DISABLE 6710 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_lookup_transform02 6711 static int tolua_fawkestf_fawkes_tf_Transformer_lookup_transform02(lua_State* tolua_S)
6713 tolua_Error tolua_err;
6715 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Transformer",0,&tolua_err) ||
6716 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6717 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
6718 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
6719 (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,
"const fawkes::Time",0,&tolua_err)) ||
6720 !tolua_iscppstring(tolua_S,6,0,&tolua_err) ||
6721 (tolua_isvaluenil(tolua_S,7,&tolua_err) || !tolua_isusertype(tolua_S,7,
"fawkes::tf::StampedTransform",0,&tolua_err)) ||
6722 !tolua_isnoobj(tolua_S,8,&tolua_err)
6728 const std::string target_frame = ((
const std::string) tolua_tocppstring(tolua_S,2,0));
6730 const std::string source_frame = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
6732 const std::string fixed_frame = ((
const std::string) tolua_tocppstring(tolua_S,6,0));
6734 #ifndef TOLUA_RELEASE 6735 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'lookup_transform'", NULL);
6737 bool exc_caught =
false;
6740 self->lookup_transform(target_frame,*target_time,source_frame,*source_time,fixed_frame,*transform);
6741 tolua_pushcppstring(tolua_S,(
const char*)target_frame);
6742 tolua_pushcppstring(tolua_S,(
const char*)source_frame);
6743 tolua_pushcppstring(tolua_S,(
const char*)fixed_frame);
6749 catch (std::exception &e) {
6751 lua_pushstring(tolua_S, e.what());
6753 if (exc_caught) lua_error(tolua_S);
6758 return tolua_fawkestf_fawkes_tf_Transformer_lookup_transform01(tolua_S);
6760 #endif //#ifndef TOLUA_DISABLE 6763 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_can_transform00 6764 static int tolua_fawkestf_fawkes_tf_Transformer_can_transform00(lua_State* tolua_S)
6766 #ifndef TOLUA_RELEASE 6767 tolua_Error tolua_err;
6769 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Transformer",0,&tolua_err) ||
6770 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6771 !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
6772 (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,
"const fawkes::Time",0,&tolua_err)) ||
6773 !tolua_isnoobj(tolua_S,5,&tolua_err)
6780 const std::string target_frame = ((
const std::string) tolua_tocppstring(tolua_S,2,0));
6781 const std::string source_frame = ((
const std::string) tolua_tocppstring(tolua_S,3,0));
6783 #ifndef TOLUA_RELEASE 6784 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'can_transform'", NULL);
6786 bool exc_caught =
false;
6789 bool tolua_ret = (bool) self->can_transform(target_frame,source_frame,*time);
6790 tolua_pushboolean(tolua_S,(
bool)tolua_ret);
6791 tolua_pushcppstring(tolua_S,(
const char*)target_frame);
6792 tolua_pushcppstring(tolua_S,(
const char*)source_frame);
6798 catch (std::exception &e) {
6800 lua_pushstring(tolua_S, e.what());
6802 if (exc_caught) lua_error(tolua_S);
6806 #ifndef TOLUA_RELEASE 6808 tolua_error(tolua_S,
"#ferror in function 'can_transform'.",&tolua_err);
6812 #endif //#ifndef TOLUA_DISABLE 6815 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_can_transform01 6816 static int tolua_fawkestf_fawkes_tf_Transformer_can_transform01(lua_State* tolua_S)
6818 tolua_Error tolua_err;
6820 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Transformer",0,&tolua_err) ||
6821 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6822 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
6823 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
6824 (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,
"const fawkes::Time",0,&tolua_err)) ||
6825 !tolua_iscppstring(tolua_S,6,0,&tolua_err) ||
6826 !tolua_isnoobj(tolua_S,7,&tolua_err)
6832 const std::string target_frame = ((
const std::string) tolua_tocppstring(tolua_S,2,0));
6834 const std::string source_frame = ((
const std::string) tolua_tocppstring(tolua_S,4,0));
6836 const std::string fixed_frame = ((
const std::string) tolua_tocppstring(tolua_S,6,0));
6837 #ifndef TOLUA_RELEASE 6838 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'can_transform'", NULL);
6840 bool exc_caught =
false;
6843 bool tolua_ret = (bool) self->can_transform(target_frame,*target_time,source_frame,*source_time,fixed_frame);
6844 tolua_pushboolean(tolua_S,(
bool)tolua_ret);
6845 tolua_pushcppstring(tolua_S,(
const char*)target_frame);
6846 tolua_pushcppstring(tolua_S,(
const char*)source_frame);
6847 tolua_pushcppstring(tolua_S,(
const char*)fixed_frame);
6853 catch (std::exception &e) {
6855 lua_pushstring(tolua_S, e.what());
6857 if (exc_caught) lua_error(tolua_S);
6862 return tolua_fawkestf_fawkes_tf_Transformer_can_transform00(tolua_S);
6864 #endif //#ifndef TOLUA_DISABLE 6867 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion00 6868 static int tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion00(lua_State* tolua_S)
6870 #ifndef TOLUA_RELEASE 6871 tolua_Error tolua_err;
6873 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Transformer",0,&tolua_err) ||
6874 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6875 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::tf::StampedQuaternion",0,&tolua_err)) ||
6876 (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,
"fawkes::tf::StampedQuaternion",0,&tolua_err)) ||
6877 !tolua_isnoobj(tolua_S,5,&tolua_err)
6884 const std::string target_frame = ((
const std::string) tolua_tocppstring(tolua_S,2,0));
6885 const fawkes::tf::StampedQuaternion* stamped_in = ((
const fawkes::tf::StampedQuaternion*) tolua_tousertype(tolua_S,3,0));
6886 fawkes::tf::StampedQuaternion* stamped_out = ((fawkes::tf::StampedQuaternion*) tolua_tousertype(tolua_S,4,0));
6887 #ifndef TOLUA_RELEASE 6888 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'transform_quaternion'", NULL);
6890 bool exc_caught =
false;
6893 self->transform_quaternion(target_frame,*stamped_in,*stamped_out);
6894 tolua_pushcppstring(tolua_S,(
const char*)target_frame);
6900 catch (std::exception &e) {
6902 lua_pushstring(tolua_S, e.what());
6904 if (exc_caught) lua_error(tolua_S);
6908 #ifndef TOLUA_RELEASE 6910 tolua_error(tolua_S,
"#ferror in function 'transform_quaternion'.",&tolua_err);
6914 #endif //#ifndef TOLUA_DISABLE 6917 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_vector00 6918 static int tolua_fawkestf_fawkes_tf_Transformer_transform_vector00(lua_State* tolua_S)
6920 #ifndef TOLUA_RELEASE 6921 tolua_Error tolua_err;
6923 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Transformer",0,&tolua_err) ||
6924 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6925 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::tf::StampedVector3",0,&tolua_err)) ||
6926 (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,
"fawkes::tf::StampedVector3",0,&tolua_err)) ||
6927 !tolua_isnoobj(tolua_S,5,&tolua_err)
6934 const std::string target_frame = ((
const std::string) tolua_tocppstring(tolua_S,2,0));
6935 const fawkes::tf::StampedVector3* stamped_in = ((
const fawkes::tf::StampedVector3*) tolua_tousertype(tolua_S,3,0));
6936 fawkes::tf::StampedVector3* stamped_out = ((fawkes::tf::StampedVector3*) tolua_tousertype(tolua_S,4,0));
6937 #ifndef TOLUA_RELEASE 6938 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'transform_vector'", NULL);
6940 bool exc_caught =
false;
6943 self->transform_vector(target_frame,*stamped_in,*stamped_out);
6944 tolua_pushcppstring(tolua_S,(
const char*)target_frame);
6950 catch (std::exception &e) {
6952 lua_pushstring(tolua_S, e.what());
6954 if (exc_caught) lua_error(tolua_S);
6958 #ifndef TOLUA_RELEASE 6960 tolua_error(tolua_S,
"#ferror in function 'transform_vector'.",&tolua_err);
6964 #endif //#ifndef TOLUA_DISABLE 6967 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_point00 6968 static int tolua_fawkestf_fawkes_tf_Transformer_transform_point00(lua_State* tolua_S)
6970 #ifndef TOLUA_RELEASE 6971 tolua_Error tolua_err;
6973 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Transformer",0,&tolua_err) ||
6974 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
6975 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::tf::StampedPoint",0,&tolua_err)) ||
6976 (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,
"fawkes::tf::StampedPoint",0,&tolua_err)) ||
6977 !tolua_isnoobj(tolua_S,5,&tolua_err)
6984 const std::string target_frame = ((
const std::string) tolua_tocppstring(tolua_S,2,0));
6985 const fawkes::tf::StampedPoint* stamped_in = ((
const fawkes::tf::StampedPoint*) tolua_tousertype(tolua_S,3,0));
6986 fawkes::tf::StampedPoint* stamped_out = ((fawkes::tf::StampedPoint*) tolua_tousertype(tolua_S,4,0));
6987 #ifndef TOLUA_RELEASE 6988 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'transform_point'", NULL);
6990 bool exc_caught =
false;
6993 self->transform_point(target_frame,*stamped_in,*stamped_out);
6994 tolua_pushcppstring(tolua_S,(
const char*)target_frame);
7000 catch (std::exception &e) {
7002 lua_pushstring(tolua_S, e.what());
7004 if (exc_caught) lua_error(tolua_S);
7008 #ifndef TOLUA_RELEASE 7010 tolua_error(tolua_S,
"#ferror in function 'transform_point'.",&tolua_err);
7014 #endif //#ifndef TOLUA_DISABLE 7017 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_pose00 7018 static int tolua_fawkestf_fawkes_tf_Transformer_transform_pose00(lua_State* tolua_S)
7020 #ifndef TOLUA_RELEASE 7021 tolua_Error tolua_err;
7023 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Transformer",0,&tolua_err) ||
7024 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7025 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::tf::StampedPose",0,&tolua_err)) ||
7026 (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,
"fawkes::tf::StampedPose",0,&tolua_err)) ||
7027 !tolua_isnoobj(tolua_S,5,&tolua_err)
7034 const std::string target_frame = ((
const std::string) tolua_tocppstring(tolua_S,2,0));
7035 const fawkes::tf::StampedPose* stamped_in = ((
const fawkes::tf::StampedPose*) tolua_tousertype(tolua_S,3,0));
7036 fawkes::tf::StampedPose* stamped_out = ((fawkes::tf::StampedPose*) tolua_tousertype(tolua_S,4,0));
7037 #ifndef TOLUA_RELEASE 7038 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'transform_pose'", NULL);
7040 bool exc_caught =
false;
7043 self->transform_pose(target_frame,*stamped_in,*stamped_out);
7044 tolua_pushcppstring(tolua_S,(
const char*)target_frame);
7050 catch (std::exception &e) {
7052 lua_pushstring(tolua_S, e.what());
7054 if (exc_caught) lua_error(tolua_S);
7058 #ifndef TOLUA_RELEASE 7060 tolua_error(tolua_S,
"#ferror in function 'transform_pose'.",&tolua_err);
7064 #endif //#ifndef TOLUA_DISABLE 7067 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion01 7068 static int tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion01(lua_State* tolua_S)
7070 tolua_Error tolua_err;
7072 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Transformer",0,&tolua_err) ||
7073 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7074 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
7075 (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,
"const fawkes::tf::StampedQuaternion",0,&tolua_err)) ||
7076 !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
7077 (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,
"fawkes::tf::StampedQuaternion",0,&tolua_err)) ||
7078 !tolua_isnoobj(tolua_S,7,&tolua_err)
7084 const std::string target_frame = ((
const std::string) tolua_tocppstring(tolua_S,2,0));
7086 const fawkes::tf::StampedQuaternion* stamped_in = ((
const fawkes::tf::StampedQuaternion*) tolua_tousertype(tolua_S,4,0));
7087 const std::string fixed_frame = ((
const std::string) tolua_tocppstring(tolua_S,5,0));
7088 fawkes::tf::StampedQuaternion* stamped_out = ((fawkes::tf::StampedQuaternion*) tolua_tousertype(tolua_S,6,0));
7089 #ifndef TOLUA_RELEASE 7090 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'transform_quaternion'", NULL);
7092 bool exc_caught =
false;
7095 self->transform_quaternion(target_frame,*target_time,*stamped_in,fixed_frame,*stamped_out);
7096 tolua_pushcppstring(tolua_S,(
const char*)target_frame);
7097 tolua_pushcppstring(tolua_S,(
const char*)fixed_frame);
7103 catch (std::exception &e) {
7105 lua_pushstring(tolua_S, e.what());
7107 if (exc_caught) lua_error(tolua_S);
7112 return tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion00(tolua_S);
7114 #endif //#ifndef TOLUA_DISABLE 7117 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_vector01 7118 static int tolua_fawkestf_fawkes_tf_Transformer_transform_vector01(lua_State* tolua_S)
7120 tolua_Error tolua_err;
7122 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Transformer",0,&tolua_err) ||
7123 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7124 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
7125 (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,
"const fawkes::tf::StampedVector3",0,&tolua_err)) ||
7126 !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
7127 (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,
"fawkes::tf::StampedVector3",0,&tolua_err)) ||
7128 !tolua_isnoobj(tolua_S,7,&tolua_err)
7134 const std::string target_frame = ((
const std::string) tolua_tocppstring(tolua_S,2,0));
7136 const fawkes::tf::StampedVector3* stamped_in = ((
const fawkes::tf::StampedVector3*) tolua_tousertype(tolua_S,4,0));
7137 const std::string fixed_frame = ((
const std::string) tolua_tocppstring(tolua_S,5,0));
7138 fawkes::tf::StampedVector3* stamped_out = ((fawkes::tf::StampedVector3*) tolua_tousertype(tolua_S,6,0));
7139 #ifndef TOLUA_RELEASE 7140 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'transform_vector'", NULL);
7142 bool exc_caught =
false;
7145 self->transform_vector(target_frame,*target_time,*stamped_in,fixed_frame,*stamped_out);
7146 tolua_pushcppstring(tolua_S,(
const char*)target_frame);
7147 tolua_pushcppstring(tolua_S,(
const char*)fixed_frame);
7153 catch (std::exception &e) {
7155 lua_pushstring(tolua_S, e.what());
7157 if (exc_caught) lua_error(tolua_S);
7162 return tolua_fawkestf_fawkes_tf_Transformer_transform_vector00(tolua_S);
7164 #endif //#ifndef TOLUA_DISABLE 7167 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_point01 7168 static int tolua_fawkestf_fawkes_tf_Transformer_transform_point01(lua_State* tolua_S)
7170 tolua_Error tolua_err;
7172 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Transformer",0,&tolua_err) ||
7173 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7174 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
7175 (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,
"const fawkes::tf::StampedPoint",0,&tolua_err)) ||
7176 !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
7177 (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,
"fawkes::tf::StampedPoint",0,&tolua_err)) ||
7178 !tolua_isnoobj(tolua_S,7,&tolua_err)
7184 const std::string target_frame = ((
const std::string) tolua_tocppstring(tolua_S,2,0));
7186 const fawkes::tf::StampedPoint* stamped_in = ((
const fawkes::tf::StampedPoint*) tolua_tousertype(tolua_S,4,0));
7187 const std::string fixed_frame = ((
const std::string) tolua_tocppstring(tolua_S,5,0));
7188 fawkes::tf::StampedPoint* stamped_out = ((fawkes::tf::StampedPoint*) tolua_tousertype(tolua_S,6,0));
7189 #ifndef TOLUA_RELEASE 7190 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'transform_point'", NULL);
7192 bool exc_caught =
false;
7195 self->transform_point(target_frame,*target_time,*stamped_in,fixed_frame,*stamped_out);
7196 tolua_pushcppstring(tolua_S,(
const char*)target_frame);
7197 tolua_pushcppstring(tolua_S,(
const char*)fixed_frame);
7203 catch (std::exception &e) {
7205 lua_pushstring(tolua_S, e.what());
7207 if (exc_caught) lua_error(tolua_S);
7212 return tolua_fawkestf_fawkes_tf_Transformer_transform_point00(tolua_S);
7214 #endif //#ifndef TOLUA_DISABLE 7217 #ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_pose01 7218 static int tolua_fawkestf_fawkes_tf_Transformer_transform_pose01(lua_State* tolua_S)
7220 tolua_Error tolua_err;
7222 !tolua_isusertype(tolua_S,1,
"const fawkes::tf::Transformer",0,&tolua_err) ||
7223 !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
7224 (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,
"const fawkes::Time",0,&tolua_err)) ||
7225 (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,
"const fawkes::tf::StampedPose",0,&tolua_err)) ||
7226 !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
7227 (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,
"fawkes::tf::StampedPose",0,&tolua_err)) ||
7228 !tolua_isnoobj(tolua_S,7,&tolua_err)
7234 const std::string target_frame = ((
const std::string) tolua_tocppstring(tolua_S,2,0));
7236 const fawkes::tf::StampedPose* stamped_in = ((
const fawkes::tf::StampedPose*) tolua_tousertype(tolua_S,4,0));
7237 const std::string fixed_frame = ((
const std::string) tolua_tocppstring(tolua_S,5,0));
7238 fawkes::tf::StampedPose* stamped_out = ((fawkes::tf::StampedPose*) tolua_tousertype(tolua_S,6,0));
7239 #ifndef TOLUA_RELEASE 7240 if (!
self) tolua_error(tolua_S,
"invalid 'self' in function 'transform_pose'", NULL);
7242 bool exc_caught =
false;
7245 self->transform_pose(target_frame,*target_time,*stamped_in,fixed_frame,*stamped_out);
7246 tolua_pushcppstring(tolua_S,(
const char*)target_frame);
7247 tolua_pushcppstring(tolua_S,(
const char*)fixed_frame);
7253 catch (std::exception &e) {
7255 lua_pushstring(tolua_S, e.what());
7257 if (exc_caught) lua_error(tolua_S);
7262 return tolua_fawkestf_fawkes_tf_Transformer_transform_pose00(tolua_S);
7264 #endif //#ifndef TOLUA_DISABLE 7267 TOLUA_API
int tolua_fawkestf_open (lua_State* tolua_S)
7269 tolua_open(tolua_S);
7270 tolua_reg_types(tolua_S);
7271 tolua_module(tolua_S,NULL,0);
7272 tolua_beginmodule(tolua_S,NULL);
7273 tolua_module(tolua_S,
"fawkes",0);
7274 tolua_beginmodule(tolua_S,
"fawkes");
7275 tolua_module(tolua_S,
"tf",0);
7276 tolua_beginmodule(tolua_S,
"tf");
7277 tolua_function(tolua_S,
"get_yaw",tolua_fawkestf_fawkes_tf_get_yaw00);
7278 tolua_function(tolua_S,
"create_quaternion_from_rpy",tolua_fawkestf_fawkes_tf_create_quaternion_from_rpy00);
7279 tolua_function(tolua_S,
"create_quaternion_from_yaw",tolua_fawkestf_fawkes_tf_create_quaternion_from_yaw00);
7280 tolua_function(tolua_S,
"resize_vector",tolua_fawkestf_fawkes_tf_resize_vector00);
7282 tolua_cclass(tolua_S,
"Vector3",
"fawkes::tf::Vector3",
"",tolua_collect_fawkes__tf__Vector3);
7284 tolua_cclass(tolua_S,
"Vector3",
"fawkes::tf::Vector3",
"",NULL);
7286 tolua_beginmodule(tolua_S,
"Vector3");
7287 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Vector3_new00);
7288 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Vector3_new00_local);
7289 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Vector3_new00_local);
7290 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Vector3_new01);
7291 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Vector3_new01_local);
7292 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Vector3_new01_local);
7293 tolua_function(tolua_S,
"dot",tolua_fawkestf_fawkes_tf_Vector3_dot00);
7294 tolua_function(tolua_S,
"length2",tolua_fawkestf_fawkes_tf_Vector3_length200);
7295 tolua_function(tolua_S,
"length",tolua_fawkestf_fawkes_tf_Vector3_length00);
7296 tolua_function(tolua_S,
"distance2",tolua_fawkestf_fawkes_tf_Vector3_distance200);
7297 tolua_function(tolua_S,
"distance",tolua_fawkestf_fawkes_tf_Vector3_distance00);
7298 tolua_function(tolua_S,
"normalize",tolua_fawkestf_fawkes_tf_Vector3_normalize00);
7299 tolua_function(tolua_S,
"normalized",tolua_fawkestf_fawkes_tf_Vector3_normalized00);
7300 tolua_function(tolua_S,
"rotate",tolua_fawkestf_fawkes_tf_Vector3_rotate00);
7301 tolua_function(tolua_S,
"angle",tolua_fawkestf_fawkes_tf_Vector3_angle00);
7302 tolua_function(tolua_S,
"absolute",tolua_fawkestf_fawkes_tf_Vector3_absolute00);
7303 tolua_function(tolua_S,
"cross",tolua_fawkestf_fawkes_tf_Vector3_cross00);
7304 tolua_function(tolua_S,
"triple",tolua_fawkestf_fawkes_tf_Vector3_triple00);
7305 tolua_function(tolua_S,
"minAxis",tolua_fawkestf_fawkes_tf_Vector3_minAxis00);
7306 tolua_function(tolua_S,
"maxAxis",tolua_fawkestf_fawkes_tf_Vector3_maxAxis00);
7307 tolua_function(tolua_S,
"furthestAxis",tolua_fawkestf_fawkes_tf_Vector3_furthestAxis00);
7308 tolua_function(tolua_S,
"closestAxis",tolua_fawkestf_fawkes_tf_Vector3_closestAxis00);
7309 tolua_function(tolua_S,
"setInterpolate3",tolua_fawkestf_fawkes_tf_Vector3_setInterpolate300);
7310 tolua_function(tolua_S,
"lerp",tolua_fawkestf_fawkes_tf_Vector3_lerp00);
7311 tolua_function(tolua_S,
"x",tolua_fawkestf_fawkes_tf_Vector3_x00);
7312 tolua_function(tolua_S,
"y",tolua_fawkestf_fawkes_tf_Vector3_y00);
7313 tolua_function(tolua_S,
"z",tolua_fawkestf_fawkes_tf_Vector3_z00);
7314 tolua_function(tolua_S,
"setX",tolua_fawkestf_fawkes_tf_Vector3_setX00);
7315 tolua_function(tolua_S,
"setY",tolua_fawkestf_fawkes_tf_Vector3_setY00);
7316 tolua_function(tolua_S,
"setZ",tolua_fawkestf_fawkes_tf_Vector3_setZ00);
7317 tolua_function(tolua_S,
"setValue",tolua_fawkestf_fawkes_tf_Vector3_setValue00);
7318 tolua_function(tolua_S,
"setZero",tolua_fawkestf_fawkes_tf_Vector3_setZero00);
7319 tolua_function(tolua_S,
"isZero",tolua_fawkestf_fawkes_tf_Vector3_isZero00);
7320 tolua_function(tolua_S,
"fuzzyZero",tolua_fawkestf_fawkes_tf_Vector3_fuzzyZero00);
7321 tolua_endmodule(tolua_S);
7323 tolua_cclass(tolua_S,
"Quaternion",
"fawkes::tf::Quaternion",
"",tolua_collect_fawkes__tf__Quaternion);
7325 tolua_cclass(tolua_S,
"Quaternion",
"fawkes::tf::Quaternion",
"",NULL);
7327 tolua_beginmodule(tolua_S,
"Quaternion");
7328 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Quaternion_new00);
7329 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Quaternion_new00_local);
7330 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Quaternion_new00_local);
7331 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Quaternion_new01);
7332 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Quaternion_new01_local);
7333 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Quaternion_new01_local);
7334 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Quaternion_new02);
7335 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Quaternion_new02_local);
7336 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Quaternion_new02_local);
7337 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Quaternion_new03);
7338 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Quaternion_new03_local);
7339 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Quaternion_new03_local);
7340 tolua_function(tolua_S,
"getIdentity",tolua_fawkestf_fawkes_tf_Quaternion_getIdentity00);
7341 tolua_function(tolua_S,
"setRotation",tolua_fawkestf_fawkes_tf_Quaternion_setRotation00);
7342 tolua_function(tolua_S,
"setEuler",tolua_fawkestf_fawkes_tf_Quaternion_setEuler00);
7343 tolua_function(tolua_S,
".eq",tolua_fawkestf_fawkes_tf_Quaternion__eq00);
7344 tolua_function(tolua_S,
"dot",tolua_fawkestf_fawkes_tf_Quaternion_dot00);
7345 tolua_function(tolua_S,
"length2",tolua_fawkestf_fawkes_tf_Quaternion_length200);
7346 tolua_function(tolua_S,
"length",tolua_fawkestf_fawkes_tf_Quaternion_length00);
7347 tolua_function(tolua_S,
"normalize",tolua_fawkestf_fawkes_tf_Quaternion_normalize00);
7348 tolua_function(tolua_S,
"normalized",tolua_fawkestf_fawkes_tf_Quaternion_normalized00);
7349 tolua_function(tolua_S,
"angle",tolua_fawkestf_fawkes_tf_Quaternion_angle00);
7350 tolua_function(tolua_S,
"getAngle",tolua_fawkestf_fawkes_tf_Quaternion_getAngle00);
7351 tolua_function(tolua_S,
"getAxis",tolua_fawkestf_fawkes_tf_Quaternion_getAxis00);
7352 tolua_function(tolua_S,
"inverse",tolua_fawkestf_fawkes_tf_Quaternion_inverse00);
7353 tolua_function(tolua_S,
"slerp",tolua_fawkestf_fawkes_tf_Quaternion_slerp00);
7354 tolua_function(tolua_S,
"x",tolua_fawkestf_fawkes_tf_Quaternion_x00);
7355 tolua_function(tolua_S,
"y",tolua_fawkestf_fawkes_tf_Quaternion_y00);
7356 tolua_function(tolua_S,
"z",tolua_fawkestf_fawkes_tf_Quaternion_z00);
7357 tolua_function(tolua_S,
"w",tolua_fawkestf_fawkes_tf_Quaternion_w00);
7358 tolua_function(tolua_S,
"setX",tolua_fawkestf_fawkes_tf_Quaternion_setX00);
7359 tolua_function(tolua_S,
"setY",tolua_fawkestf_fawkes_tf_Quaternion_setY00);
7360 tolua_function(tolua_S,
"setZ",tolua_fawkestf_fawkes_tf_Quaternion_setZ00);
7361 tolua_function(tolua_S,
"setW",tolua_fawkestf_fawkes_tf_Quaternion_setW00);
7362 tolua_function(tolua_S,
"setValue",tolua_fawkestf_fawkes_tf_Quaternion_setValue00);
7363 tolua_endmodule(tolua_S);
7365 tolua_cclass(tolua_S,
"Transform",
"fawkes::tf::Transform",
"",tolua_collect_fawkes__tf__Transform);
7367 tolua_cclass(tolua_S,
"Transform",
"fawkes::tf::Transform",
"",NULL);
7369 tolua_beginmodule(tolua_S,
"Transform");
7370 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Transform_new00);
7371 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Transform_new00_local);
7372 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Transform_new00_local);
7373 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Transform_new01);
7374 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Transform_new01_local);
7375 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Transform_new01_local);
7376 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Transform_new02);
7377 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Transform_new02_local);
7378 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Transform_new02_local);
7379 tolua_function(tolua_S,
"getIdentity",tolua_fawkestf_fawkes_tf_Transform_getIdentity00);
7380 tolua_function(tolua_S,
"mult",tolua_fawkestf_fawkes_tf_Transform_mult00);
7381 tolua_function(tolua_S,
".mul",tolua_fawkestf_fawkes_tf_Transform__mul00);
7382 tolua_function(tolua_S,
".mul",tolua_fawkestf_fawkes_tf_Transform__mul01);
7383 tolua_function(tolua_S,
"getOrigin",tolua_fawkestf_fawkes_tf_Transform_getOrigin00);
7384 tolua_function(tolua_S,
"getRotation",tolua_fawkestf_fawkes_tf_Transform_getRotation00);
7385 tolua_function(tolua_S,
"setOrigin",tolua_fawkestf_fawkes_tf_Transform_setOrigin00);
7386 tolua_function(tolua_S,
"setRotation",tolua_fawkestf_fawkes_tf_Transform_setRotation00);
7387 tolua_function(tolua_S,
"setIdentity",tolua_fawkestf_fawkes_tf_Transform_setIdentity00);
7388 tolua_function(tolua_S,
"inverse",tolua_fawkestf_fawkes_tf_Transform_inverse00);
7389 tolua_function(tolua_S,
"inverseTimes",tolua_fawkestf_fawkes_tf_Transform_inverseTimes00);
7390 tolua_endmodule(tolua_S);
7392 tolua_cclass(tolua_S,
"Point",
"fawkes::tf::Point",
"fawkes::tf::Vector3",tolua_collect_fawkes__tf__Point);
7394 tolua_cclass(tolua_S,
"Point",
"fawkes::tf::Point",
"fawkes::tf::Vector3",NULL);
7396 tolua_beginmodule(tolua_S,
"Point");
7397 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Point_new00);
7398 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Point_new00_local);
7399 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Point_new00_local);
7400 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Point_new01);
7401 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Point_new01_local);
7402 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Point_new01_local);
7403 tolua_endmodule(tolua_S);
7405 tolua_cclass(tolua_S,
"Pose",
"fawkes::tf::Pose",
"fawkes::tf::Transform",tolua_collect_fawkes__tf__Pose);
7407 tolua_cclass(tolua_S,
"Pose",
"fawkes::tf::Pose",
"fawkes::tf::Transform",NULL);
7409 tolua_beginmodule(tolua_S,
"Pose");
7410 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Pose_new00);
7411 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Pose_new00_local);
7412 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Pose_new00_local);
7413 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Pose_new01);
7414 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Pose_new01_local);
7415 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Pose_new01_local);
7416 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Pose_new02);
7417 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Pose_new02_local);
7418 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Pose_new02_local);
7419 tolua_function(tolua_S,
"getIdentity",tolua_fawkestf_fawkes_tf_Pose_getIdentity00);
7420 tolua_endmodule(tolua_S);
7422 tolua_cclass(tolua_S,
"StampedTransform",
"fawkes::tf::StampedTransform",
"fawkes::tf::Transform",tolua_collect_fawkes__tf__StampedTransform);
7424 tolua_cclass(tolua_S,
"StampedTransform",
"fawkes::tf::StampedTransform",
"fawkes::tf::Transform",NULL);
7426 tolua_beginmodule(tolua_S,
"StampedTransform");
7427 tolua_variable(tolua_S,
"stamp",tolua_get_fawkes__tf__StampedTransform_stamp,tolua_set_fawkes__tf__StampedTransform_stamp);
7428 tolua_variable(tolua_S,
"frame_id",tolua_get_fawkes__tf__StampedTransform_frame_id,tolua_set_fawkes__tf__StampedTransform_frame_id);
7429 tolua_variable(tolua_S,
"child_frame_id",tolua_get_fawkes__tf__StampedTransform_child_frame_id,tolua_set_fawkes__tf__StampedTransform_child_frame_id);
7430 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_StampedTransform_new00);
7431 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_StampedTransform_new00_local);
7432 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_StampedTransform_new00_local);
7433 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_StampedTransform_new01);
7434 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_StampedTransform_new01_local);
7435 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_StampedTransform_new01_local);
7436 tolua_function(tolua_S,
"set_data",tolua_fawkestf_fawkes_tf_StampedTransform_set_data00);
7437 tolua_endmodule(tolua_S);
7439 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_);
7441 tolua_cclass(tolua_S,
"Stamped_fawkes__tf__Quaternion_",
"fawkes::tf::Stamped<fawkes::tf::Quaternion>",
"fawkes::tf::Quaternion",NULL);
7443 tolua_beginmodule(tolua_S,
"Stamped_fawkes__tf__Quaternion_");
7444 tolua_variable(tolua_S,
"stamp",tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp,tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp);
7445 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);
7446 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00);
7447 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00_local);
7448 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00_local);
7449 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01);
7450 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01_local);
7451 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01_local);
7452 tolua_function(tolua_S,
"set_data",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__set_data00);
7453 tolua_endmodule(tolua_S);
7455 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_);
7457 tolua_cclass(tolua_S,
"Stamped_fawkes__tf__Vector3_",
"fawkes::tf::Stamped<fawkes::tf::Vector3>",
"fawkes::tf::Vector3",NULL);
7459 tolua_beginmodule(tolua_S,
"Stamped_fawkes__tf__Vector3_");
7460 tolua_variable(tolua_S,
"stamp",tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp,tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp);
7461 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);
7462 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00);
7463 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00_local);
7464 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00_local);
7465 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01);
7466 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01_local);
7467 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01_local);
7468 tolua_function(tolua_S,
"set_data",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__set_data00);
7469 tolua_endmodule(tolua_S);
7471 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_);
7473 tolua_cclass(tolua_S,
"Stamped_fawkes__tf__Point_",
"fawkes::tf::Stamped<fawkes::tf::Point>",
"fawkes::tf::Point",NULL);
7475 tolua_beginmodule(tolua_S,
"Stamped_fawkes__tf__Point_");
7476 tolua_variable(tolua_S,
"stamp",tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__stamp,tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__stamp);
7477 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);
7478 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00);
7479 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00_local);
7480 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00_local);
7481 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01);
7482 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01_local);
7483 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01_local);
7484 tolua_function(tolua_S,
"set_data",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__set_data00);
7485 tolua_endmodule(tolua_S);
7487 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_);
7489 tolua_cclass(tolua_S,
"Stamped_fawkes__tf__Pose_",
"fawkes::tf::Stamped<fawkes::tf::Pose>",
"fawkes::tf::Pose",NULL);
7491 tolua_beginmodule(tolua_S,
"Stamped_fawkes__tf__Pose_");
7492 tolua_variable(tolua_S,
"stamp",tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__stamp,tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__stamp);
7493 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);
7494 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00);
7495 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00_local);
7496 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00_local);
7497 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01);
7498 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01_local);
7499 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01_local);
7500 tolua_function(tolua_S,
"set_data",tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__set_data00);
7501 tolua_endmodule(tolua_S);
7503 tolua_cclass(tolua_S,
"StampedQuaternion",
"fawkes::tf::StampedQuaternion",
"fawkes::tf::Stamped<fawkes::tf::Quaternion>",tolua_collect_fawkes__tf__StampedQuaternion);
7505 tolua_cclass(tolua_S,
"StampedQuaternion",
"fawkes::tf::StampedQuaternion",
"fawkes::tf::Stamped<fawkes::tf::Quaternion>",NULL);
7507 tolua_beginmodule(tolua_S,
"StampedQuaternion");
7508 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_StampedQuaternion_new00);
7509 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_StampedQuaternion_new00_local);
7510 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_StampedQuaternion_new00_local);
7511 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_StampedQuaternion_new01);
7512 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_StampedQuaternion_new01_local);
7513 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_StampedQuaternion_new01_local);
7514 tolua_endmodule(tolua_S);
7516 tolua_cclass(tolua_S,
"StampedVector3",
"fawkes::tf::StampedVector3",
"fawkes::tf::Stamped<fawkes::tf::Vector3>",tolua_collect_fawkes__tf__StampedVector3);
7518 tolua_cclass(tolua_S,
"StampedVector3",
"fawkes::tf::StampedVector3",
"fawkes::tf::Stamped<fawkes::tf::Vector3>",NULL);
7520 tolua_beginmodule(tolua_S,
"StampedVector3");
7521 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_StampedVector3_new00);
7522 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_StampedVector3_new00_local);
7523 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_StampedVector3_new00_local);
7524 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_StampedVector3_new01);
7525 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_StampedVector3_new01_local);
7526 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_StampedVector3_new01_local);
7527 tolua_endmodule(tolua_S);
7529 tolua_cclass(tolua_S,
"StampedPoint",
"fawkes::tf::StampedPoint",
"fawkes::tf::Stamped<fawkes::tf::Point>",tolua_collect_fawkes__tf__StampedPoint);
7531 tolua_cclass(tolua_S,
"StampedPoint",
"fawkes::tf::StampedPoint",
"fawkes::tf::Stamped<fawkes::tf::Point>",NULL);
7533 tolua_beginmodule(tolua_S,
"StampedPoint");
7534 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_StampedPoint_new00);
7535 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_StampedPoint_new00_local);
7536 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_StampedPoint_new00_local);
7537 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_StampedPoint_new01);
7538 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_StampedPoint_new01_local);
7539 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_StampedPoint_new01_local);
7540 tolua_endmodule(tolua_S);
7542 tolua_cclass(tolua_S,
"StampedPose",
"fawkes::tf::StampedPose",
"fawkes::tf::Stamped<fawkes::tf::Pose>",tolua_collect_fawkes__tf__StampedPose);
7544 tolua_cclass(tolua_S,
"StampedPose",
"fawkes::tf::StampedPose",
"fawkes::tf::Stamped<fawkes::tf::Pose>",NULL);
7546 tolua_beginmodule(tolua_S,
"StampedPose");
7547 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_StampedPose_new00);
7548 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_StampedPose_new00_local);
7549 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_StampedPose_new00_local);
7550 tolua_function(tolua_S,
"new",tolua_fawkestf_fawkes_tf_StampedPose_new01);
7551 tolua_function(tolua_S,
"new_local",tolua_fawkestf_fawkes_tf_StampedPose_new01_local);
7552 tolua_function(tolua_S,
".call",tolua_fawkestf_fawkes_tf_StampedPose_new01_local);
7553 tolua_endmodule(tolua_S);
7554 tolua_cclass(tolua_S,
"Transformer",
"fawkes::tf::Transformer",
"",NULL);
7555 tolua_beginmodule(tolua_S,
"Transformer");
7556 tolua_function(tolua_S,
"clear",tolua_fawkestf_fawkes_tf_Transformer_clear00);
7557 tolua_function(tolua_S,
"frame_exists",tolua_fawkestf_fawkes_tf_Transformer_frame_exists00);
7558 tolua_function(tolua_S,
"lookup_transform",tolua_fawkestf_fawkes_tf_Transformer_lookup_transform00);
7559 tolua_function(tolua_S,
"lookup_transform",tolua_fawkestf_fawkes_tf_Transformer_lookup_transform01);
7560 tolua_function(tolua_S,
"lookup_transform",tolua_fawkestf_fawkes_tf_Transformer_lookup_transform02);
7561 tolua_function(tolua_S,
"can_transform",tolua_fawkestf_fawkes_tf_Transformer_can_transform00);
7562 tolua_function(tolua_S,
"can_transform",tolua_fawkestf_fawkes_tf_Transformer_can_transform01);
7563 tolua_function(tolua_S,
"transform_quaternion",tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion00);
7564 tolua_function(tolua_S,
"transform_vector",tolua_fawkestf_fawkes_tf_Transformer_transform_vector00);
7565 tolua_function(tolua_S,
"transform_point",tolua_fawkestf_fawkes_tf_Transformer_transform_point00);
7566 tolua_function(tolua_S,
"transform_pose",tolua_fawkestf_fawkes_tf_Transformer_transform_pose00);
7567 tolua_function(tolua_S,
"transform_quaternion",tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion01);
7568 tolua_function(tolua_S,
"transform_vector",tolua_fawkestf_fawkes_tf_Transformer_transform_vector01);
7569 tolua_function(tolua_S,
"transform_point",tolua_fawkestf_fawkes_tf_Transformer_transform_point01);
7570 tolua_function(tolua_S,
"transform_pose",tolua_fawkestf_fawkes_tf_Transformer_transform_pose01);
7571 tolua_endmodule(tolua_S);
7572 tolua_endmodule(tolua_S);
7573 tolua_endmodule(tolua_S);
7574 tolua_endmodule(tolua_S);
7580 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501 7581 TOLUA_API
int luaopen_fawkestf (lua_State* tolua_S) {
7582 return tolua_fawkestf_open(tolua_S);
A class for handling time.
Base class for exceptions in Fawkes.
virtual const char * what_no_backtrace() const
Get primary string (does not implicitly print the back trace).
Wrapper class to add time stamp and frame ID to base types.