Fawkes API Fawkes Development Version
fawkestf_tolua.cpp
1/*
2** Lua binding: fawkestf
3** Generated automatically by tolua++-1.0.92
4*/
5/* This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version. A runtime exception applies to
9 * this software (see LICENSE.GPL_WRE file mentioned below for details).
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU Library General Public License for more details.
15 *
16 * Read the full text in the LICENSE.GPL_WRE file in the doc directory.
17 */
18
19#include <core/exception.h>
20
21#ifndef __cplusplus
22#include "stdlib.h"
23#endif
24#include "string.h"
25
26#include "tolua++.h"
27
28/* Exported function */
29TOLUA_API int tolua_fawkestf_open (lua_State* tolua_S);
30
31#include <tf/types_lua.h>
32#include <tf/transformer.h>
33#include <tf/types.h>
34#include <tf/utils.h>
35
36/* function to release collected object via destructor */
37#ifdef __cplusplus
38
39static int tolua_collect_fawkes__tf__StampedTransform (lua_State* tolua_S)
40{
41 fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,1,0);
42 Mtolua_delete(self);
43 return 0;
44}
45
46static int tolua_collect_fawkes__tf__Quaternion (lua_State* tolua_S)
47{
48 fawkes::tf::Quaternion* self = (fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0);
49 Mtolua_delete(self);
50 return 0;
51}
52
53static int tolua_collect_fawkes__tf__Stamped_fawkes__tf__Quaternion_ (lua_State* tolua_S)
54{
56 Mtolua_delete(self);
57 return 0;
58}
59
60static int tolua_collect_fawkes__tf__Point (lua_State* tolua_S)
61{
62 fawkes::tf::Point* self = (fawkes::tf::Point*) tolua_tousertype(tolua_S,1,0);
63 Mtolua_delete(self);
64 return 0;
65}
66
67static int tolua_collect_fawkes__tf__Pose (lua_State* tolua_S)
68{
69 fawkes::tf::Pose* self = (fawkes::tf::Pose*) tolua_tousertype(tolua_S,1,0);
70 Mtolua_delete(self);
71 return 0;
72}
73
74static int tolua_collect_fawkes__tf__Stamped_fawkes__tf__Pose_ (lua_State* tolua_S)
75{
77 Mtolua_delete(self);
78 return 0;
79}
80
81static int tolua_collect_fawkes__tf__Vector3 (lua_State* tolua_S)
82{
83 fawkes::tf::Vector3* self = (fawkes::tf::Vector3*) tolua_tousertype(tolua_S,1,0);
84 Mtolua_delete(self);
85 return 0;
86}
87
88static int tolua_collect_fawkes__tf__StampedPose (lua_State* tolua_S)
89{
90 fawkes::tf::StampedPose* self = (fawkes::tf::StampedPose*) tolua_tousertype(tolua_S,1,0);
91 Mtolua_delete(self);
92 return 0;
93}
94
95static int tolua_collect_fawkes__tf__StampedVector3 (lua_State* tolua_S)
96{
97 fawkes::tf::StampedVector3* self = (fawkes::tf::StampedVector3*) tolua_tousertype(tolua_S,1,0);
98 Mtolua_delete(self);
99 return 0;
100}
101
102static int tolua_collect_fawkes__tf__Stamped_fawkes__tf__Point_ (lua_State* tolua_S)
103{
105 Mtolua_delete(self);
106 return 0;
107}
108
109static int tolua_collect_fawkes__tf__StampedPoint (lua_State* tolua_S)
110{
111 fawkes::tf::StampedPoint* self = (fawkes::tf::StampedPoint*) tolua_tousertype(tolua_S,1,0);
112 Mtolua_delete(self);
113 return 0;
114}
115
116static int tolua_collect_fawkes__tf__Transform (lua_State* tolua_S)
117{
118 fawkes::tf::Transform* self = (fawkes::tf::Transform*) tolua_tousertype(tolua_S,1,0);
119 Mtolua_delete(self);
120 return 0;
121}
122
123static int tolua_collect_fawkes__tf__StampedQuaternion (lua_State* tolua_S)
124{
125 fawkes::tf::StampedQuaternion* self = (fawkes::tf::StampedQuaternion*) tolua_tousertype(tolua_S,1,0);
126 Mtolua_delete(self);
127 return 0;
128}
129
130static int tolua_collect_fawkes__tf__Stamped_fawkes__tf__Vector3_ (lua_State* tolua_S)
131{
133 Mtolua_delete(self);
134 return 0;
135}
136#endif
137
138
139/* function to register type */
140static void tolua_reg_types (lua_State* tolua_S)
141{
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>");
158}
159
160/* function: fawkes::tf::get_yaw */
161#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_get_yaw00
162static int tolua_fawkestf_fawkes_tf_get_yaw00(lua_State* tolua_S)
163{
164#ifndef TOLUA_RELEASE
165 tolua_Error tolua_err;
166 if (
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)
169 )
170 goto tolua_lerror;
171 else
172#endif
173 {
174 const fawkes::tf::Quaternion* bt_q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,1,0));
175 bool exc_caught = false;
176 try {
177 {
178 double tolua_ret = (double) fawkes::tf::get_yaw(*bt_q);
179 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
180 }
181 } catch (fawkes::Exception &e) {
182 exc_caught = true;
183 lua_pushstring(tolua_S, e.what_no_backtrace());
184 }
185 catch (std::exception &e) {
186 exc_caught = true;
187 lua_pushstring(tolua_S, e.what());
188 }
189 if (exc_caught) lua_error(tolua_S);
190
191 }
192 return 1;
193#ifndef TOLUA_RELEASE
194 tolua_lerror:
195 tolua_error(tolua_S,"#ferror in function 'get_yaw'.",&tolua_err);
196 return 0;
197#endif
198}
199#endif //#ifndef TOLUA_DISABLE
200
201/* function: fawkes::tf::create_quaternion_from_rpy */
202#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_create_quaternion_from_rpy00
203static int tolua_fawkestf_fawkes_tf_create_quaternion_from_rpy00(lua_State* tolua_S)
204{
205#ifndef TOLUA_RELEASE
206 tolua_Error tolua_err;
207 if (
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)
212 )
213 goto tolua_lerror;
214 else
215#endif
216 {
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;
221 try {
222 {
223 fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) fawkes::tf::create_quaternion_from_rpy(roll,pitch,yaw);
224 {
225#ifdef __cplusplus
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));
229#else
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));
233#endif
234 }
235 }
236 } catch (fawkes::Exception &e) {
237 exc_caught = true;
238 lua_pushstring(tolua_S, e.what_no_backtrace());
239 }
240 catch (std::exception &e) {
241 exc_caught = true;
242 lua_pushstring(tolua_S, e.what());
243 }
244 if (exc_caught) lua_error(tolua_S);
245
246 }
247 return 1;
248#ifndef TOLUA_RELEASE
249 tolua_lerror:
250 tolua_error(tolua_S,"#ferror in function 'create_quaternion_from_rpy'.",&tolua_err);
251 return 0;
252#endif
253}
254#endif //#ifndef TOLUA_DISABLE
255
256/* function: fawkes::tf::create_quaternion_from_yaw */
257#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_create_quaternion_from_yaw00
258static int tolua_fawkestf_fawkes_tf_create_quaternion_from_yaw00(lua_State* tolua_S)
259{
260#ifndef TOLUA_RELEASE
261 tolua_Error tolua_err;
262 if (
263 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
264 !tolua_isnoobj(tolua_S,2,&tolua_err)
265 )
266 goto tolua_lerror;
267 else
268#endif
269 {
270 double yaw = ((double) tolua_tonumber(tolua_S,1,0));
271 bool exc_caught = false;
272 try {
273 {
274 fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) fawkes::tf::create_quaternion_from_yaw(yaw);
275 {
276#ifdef __cplusplus
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));
280#else
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));
284#endif
285 }
286 }
287 } catch (fawkes::Exception &e) {
288 exc_caught = true;
289 lua_pushstring(tolua_S, e.what_no_backtrace());
290 }
291 catch (std::exception &e) {
292 exc_caught = true;
293 lua_pushstring(tolua_S, e.what());
294 }
295 if (exc_caught) lua_error(tolua_S);
296
297 }
298 return 1;
299#ifndef TOLUA_RELEASE
300 tolua_lerror:
301 tolua_error(tolua_S,"#ferror in function 'create_quaternion_from_yaw'.",&tolua_err);
302 return 0;
303#endif
304}
305#endif //#ifndef TOLUA_DISABLE
306
307/* function: fawkes::tf::resize_vector */
308#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_resize_vector00
309static int tolua_fawkestf_fawkes_tf_resize_vector00(lua_State* tolua_S)
310{
311#ifndef TOLUA_RELEASE
312 tolua_Error tolua_err;
313 if (
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)
317 )
318 goto tolua_lerror;
319 else
320#endif
321 {
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;
325 try {
326 {
327 fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) fawkes::tf::resize_vector(*v,s);
328 {
329#ifdef __cplusplus
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));
333#else
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));
337#endif
338 }
339 }
340 } catch (fawkes::Exception &e) {
341 exc_caught = true;
342 lua_pushstring(tolua_S, e.what_no_backtrace());
343 }
344 catch (std::exception &e) {
345 exc_caught = true;
346 lua_pushstring(tolua_S, e.what());
347 }
348 if (exc_caught) lua_error(tolua_S);
349
350 }
351 return 1;
352#ifndef TOLUA_RELEASE
353 tolua_lerror:
354 tolua_error(tolua_S,"#ferror in function 'resize_vector'.",&tolua_err);
355 return 0;
356#endif
357}
358#endif //#ifndef TOLUA_DISABLE
359
360/* method: new of class fawkes::tf::Vector3 */
361#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_new00
362static int tolua_fawkestf_fawkes_tf_Vector3_new00(lua_State* tolua_S)
363{
364#ifndef TOLUA_RELEASE
365 tolua_Error tolua_err;
366 if (
367 !tolua_isusertable(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
368 !tolua_isnoobj(tolua_S,2,&tolua_err)
369 )
370 goto tolua_lerror;
371 else
372#endif
373 {
374 bool exc_caught = false;
375 try {
376 {
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");
379 }
380 } catch (fawkes::Exception &e) {
381 exc_caught = true;
382 lua_pushstring(tolua_S, e.what_no_backtrace());
383 }
384 catch (std::exception &e) {
385 exc_caught = true;
386 lua_pushstring(tolua_S, e.what());
387 }
388 if (exc_caught) lua_error(tolua_S);
389
390 }
391 return 1;
392#ifndef TOLUA_RELEASE
393 tolua_lerror:
394 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
395 return 0;
396#endif
397}
398#endif //#ifndef TOLUA_DISABLE
399
400/* method: new_local of class fawkes::tf::Vector3 */
401#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_new00_local
402static int tolua_fawkestf_fawkes_tf_Vector3_new00_local(lua_State* tolua_S)
403{
404#ifndef TOLUA_RELEASE
405 tolua_Error tolua_err;
406 if (
407 !tolua_isusertable(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
408 !tolua_isnoobj(tolua_S,2,&tolua_err)
409 )
410 goto tolua_lerror;
411 else
412#endif
413 {
414 bool exc_caught = false;
415 try {
416 {
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));
420 }
421 } catch (fawkes::Exception &e) {
422 exc_caught = true;
423 lua_pushstring(tolua_S, e.what_no_backtrace());
424 }
425 catch (std::exception &e) {
426 exc_caught = true;
427 lua_pushstring(tolua_S, e.what());
428 }
429 if (exc_caught) lua_error(tolua_S);
430
431 }
432 return 1;
433#ifndef TOLUA_RELEASE
434 tolua_lerror:
435 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
436 return 0;
437#endif
438}
439#endif //#ifndef TOLUA_DISABLE
440
441/* method: new of class fawkes::tf::Vector3 */
442#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_new01
443static int tolua_fawkestf_fawkes_tf_Vector3_new01(lua_State* tolua_S)
444{
445 tolua_Error tolua_err;
446 if (
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)
452 )
453 goto tolua_lerror;
454 else
455 {
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;
460 try {
461 {
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");
464 }
465 } catch (fawkes::Exception &e) {
466 exc_caught = true;
467 lua_pushstring(tolua_S, e.what_no_backtrace());
468 }
469 catch (std::exception &e) {
470 exc_caught = true;
471 lua_pushstring(tolua_S, e.what());
472 }
473 if (exc_caught) lua_error(tolua_S);
474
475 }
476 return 1;
477tolua_lerror:
478 return tolua_fawkestf_fawkes_tf_Vector3_new00(tolua_S);
479}
480#endif //#ifndef TOLUA_DISABLE
481
482/* method: new_local of class fawkes::tf::Vector3 */
483#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_new01_local
484static int tolua_fawkestf_fawkes_tf_Vector3_new01_local(lua_State* tolua_S)
485{
486 tolua_Error tolua_err;
487 if (
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)
493 )
494 goto tolua_lerror;
495 else
496 {
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;
501 try {
502 {
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));
506 }
507 } catch (fawkes::Exception &e) {
508 exc_caught = true;
509 lua_pushstring(tolua_S, e.what_no_backtrace());
510 }
511 catch (std::exception &e) {
512 exc_caught = true;
513 lua_pushstring(tolua_S, e.what());
514 }
515 if (exc_caught) lua_error(tolua_S);
516
517 }
518 return 1;
519tolua_lerror:
520 return tolua_fawkestf_fawkes_tf_Vector3_new00_local(tolua_S);
521}
522#endif //#ifndef TOLUA_DISABLE
523
524/* method: dot of class fawkes::tf::Vector3 */
525#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_dot00
526static int tolua_fawkestf_fawkes_tf_Vector3_dot00(lua_State* tolua_S)
527{
528#ifndef TOLUA_RELEASE
529 tolua_Error tolua_err;
530 if (
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)
534 )
535 goto tolua_lerror;
536 else
537#endif
538 {
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);
543#endif
544 bool exc_caught = false;
545 try {
546 {
547 double tolua_ret = (double) self->dot(*q);
548 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
549 }
550 } catch (fawkes::Exception &e) {
551 exc_caught = true;
552 lua_pushstring(tolua_S, e.what_no_backtrace());
553 }
554 catch (std::exception &e) {
555 exc_caught = true;
556 lua_pushstring(tolua_S, e.what());
557 }
558 if (exc_caught) lua_error(tolua_S);
559
560 }
561 return 1;
562#ifndef TOLUA_RELEASE
563 tolua_lerror:
564 tolua_error(tolua_S,"#ferror in function 'dot'.",&tolua_err);
565 return 0;
566#endif
567}
568#endif //#ifndef TOLUA_DISABLE
569
570/* method: length2 of class fawkes::tf::Vector3 */
571#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_length200
572static int tolua_fawkestf_fawkes_tf_Vector3_length200(lua_State* tolua_S)
573{
574#ifndef TOLUA_RELEASE
575 tolua_Error tolua_err;
576 if (
577 !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
578 !tolua_isnoobj(tolua_S,2,&tolua_err)
579 )
580 goto tolua_lerror;
581 else
582#endif
583 {
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);
587#endif
588 bool exc_caught = false;
589 try {
590 {
591 double tolua_ret = (double) self->length2();
592 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
593 }
594 } catch (fawkes::Exception &e) {
595 exc_caught = true;
596 lua_pushstring(tolua_S, e.what_no_backtrace());
597 }
598 catch (std::exception &e) {
599 exc_caught = true;
600 lua_pushstring(tolua_S, e.what());
601 }
602 if (exc_caught) lua_error(tolua_S);
603
604 }
605 return 1;
606#ifndef TOLUA_RELEASE
607 tolua_lerror:
608 tolua_error(tolua_S,"#ferror in function 'length2'.",&tolua_err);
609 return 0;
610#endif
611}
612#endif //#ifndef TOLUA_DISABLE
613
614/* method: length of class fawkes::tf::Vector3 */
615#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_length00
616static int tolua_fawkestf_fawkes_tf_Vector3_length00(lua_State* tolua_S)
617{
618#ifndef TOLUA_RELEASE
619 tolua_Error tolua_err;
620 if (
621 !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
622 !tolua_isnoobj(tolua_S,2,&tolua_err)
623 )
624 goto tolua_lerror;
625 else
626#endif
627 {
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);
631#endif
632 bool exc_caught = false;
633 try {
634 {
635 double tolua_ret = (double) self->length();
636 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
637 }
638 } catch (fawkes::Exception &e) {
639 exc_caught = true;
640 lua_pushstring(tolua_S, e.what_no_backtrace());
641 }
642 catch (std::exception &e) {
643 exc_caught = true;
644 lua_pushstring(tolua_S, e.what());
645 }
646 if (exc_caught) lua_error(tolua_S);
647
648 }
649 return 1;
650#ifndef TOLUA_RELEASE
651 tolua_lerror:
652 tolua_error(tolua_S,"#ferror in function 'length'.",&tolua_err);
653 return 0;
654#endif
655}
656#endif //#ifndef TOLUA_DISABLE
657
658/* method: distance2 of class fawkes::tf::Vector3 */
659#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_distance200
660static int tolua_fawkestf_fawkes_tf_Vector3_distance200(lua_State* tolua_S)
661{
662#ifndef TOLUA_RELEASE
663 tolua_Error tolua_err;
664 if (
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)
668 )
669 goto tolua_lerror;
670 else
671#endif
672 {
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);
677#endif
678 bool exc_caught = false;
679 try {
680 {
681 double tolua_ret = (double) self->distance2(*v);
682 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
683 }
684 } catch (fawkes::Exception &e) {
685 exc_caught = true;
686 lua_pushstring(tolua_S, e.what_no_backtrace());
687 }
688 catch (std::exception &e) {
689 exc_caught = true;
690 lua_pushstring(tolua_S, e.what());
691 }
692 if (exc_caught) lua_error(tolua_S);
693
694 }
695 return 1;
696#ifndef TOLUA_RELEASE
697 tolua_lerror:
698 tolua_error(tolua_S,"#ferror in function 'distance2'.",&tolua_err);
699 return 0;
700#endif
701}
702#endif //#ifndef TOLUA_DISABLE
703
704/* method: distance of class fawkes::tf::Vector3 */
705#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_distance00
706static int tolua_fawkestf_fawkes_tf_Vector3_distance00(lua_State* tolua_S)
707{
708#ifndef TOLUA_RELEASE
709 tolua_Error tolua_err;
710 if (
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)
714 )
715 goto tolua_lerror;
716 else
717#endif
718 {
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);
723#endif
724 bool exc_caught = false;
725 try {
726 {
727 double tolua_ret = (double) self->distance(*v);
728 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
729 }
730 } catch (fawkes::Exception &e) {
731 exc_caught = true;
732 lua_pushstring(tolua_S, e.what_no_backtrace());
733 }
734 catch (std::exception &e) {
735 exc_caught = true;
736 lua_pushstring(tolua_S, e.what());
737 }
738 if (exc_caught) lua_error(tolua_S);
739
740 }
741 return 1;
742#ifndef TOLUA_RELEASE
743 tolua_lerror:
744 tolua_error(tolua_S,"#ferror in function 'distance'.",&tolua_err);
745 return 0;
746#endif
747}
748#endif //#ifndef TOLUA_DISABLE
749
750/* method: normalize of class fawkes::tf::Vector3 */
751#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_normalize00
752static int tolua_fawkestf_fawkes_tf_Vector3_normalize00(lua_State* tolua_S)
753{
754#ifndef TOLUA_RELEASE
755 tolua_Error tolua_err;
756 if (
757 !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
758 !tolua_isnoobj(tolua_S,2,&tolua_err)
759 )
760 goto tolua_lerror;
761 else
762#endif
763 {
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);
767#endif
768 bool exc_caught = false;
769 try {
770 {
771 fawkes::tf::Vector3& tolua_ret = (fawkes::tf::Vector3&) self->normalize();
772 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::tf::Vector3");
773 }
774 } catch (fawkes::Exception &e) {
775 exc_caught = true;
776 lua_pushstring(tolua_S, e.what_no_backtrace());
777 }
778 catch (std::exception &e) {
779 exc_caught = true;
780 lua_pushstring(tolua_S, e.what());
781 }
782 if (exc_caught) lua_error(tolua_S);
783
784 }
785 return 1;
786#ifndef TOLUA_RELEASE
787 tolua_lerror:
788 tolua_error(tolua_S,"#ferror in function 'normalize'.",&tolua_err);
789 return 0;
790#endif
791}
792#endif //#ifndef TOLUA_DISABLE
793
794/* method: normalized of class fawkes::tf::Vector3 */
795#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_normalized00
796static int tolua_fawkestf_fawkes_tf_Vector3_normalized00(lua_State* tolua_S)
797{
798#ifndef TOLUA_RELEASE
799 tolua_Error tolua_err;
800 if (
801 !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
802 !tolua_isnoobj(tolua_S,2,&tolua_err)
803 )
804 goto tolua_lerror;
805 else
806#endif
807 {
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);
811#endif
812 bool exc_caught = false;
813 try {
814 {
815 fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->normalized();
816 {
817#ifdef __cplusplus
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));
821#else
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));
825#endif
826 }
827 }
828 } catch (fawkes::Exception &e) {
829 exc_caught = true;
830 lua_pushstring(tolua_S, e.what_no_backtrace());
831 }
832 catch (std::exception &e) {
833 exc_caught = true;
834 lua_pushstring(tolua_S, e.what());
835 }
836 if (exc_caught) lua_error(tolua_S);
837
838 }
839 return 1;
840#ifndef TOLUA_RELEASE
841 tolua_lerror:
842 tolua_error(tolua_S,"#ferror in function 'normalized'.",&tolua_err);
843 return 0;
844#endif
845}
846#endif //#ifndef TOLUA_DISABLE
847
848/* method: rotate of class fawkes::tf::Vector3 */
849#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_rotate00
850static int tolua_fawkestf_fawkes_tf_Vector3_rotate00(lua_State* tolua_S)
851{
852#ifndef TOLUA_RELEASE
853 tolua_Error tolua_err;
854 if (
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)
859 )
860 goto tolua_lerror;
861 else
862#endif
863 {
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);
869#endif
870 bool exc_caught = false;
871 try {
872 {
873 fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->rotate(*wAxis,angle);
874 {
875#ifdef __cplusplus
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));
879#else
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));
883#endif
884 }
885 }
886 } catch (fawkes::Exception &e) {
887 exc_caught = true;
888 lua_pushstring(tolua_S, e.what_no_backtrace());
889 }
890 catch (std::exception &e) {
891 exc_caught = true;
892 lua_pushstring(tolua_S, e.what());
893 }
894 if (exc_caught) lua_error(tolua_S);
895
896 }
897 return 1;
898#ifndef TOLUA_RELEASE
899 tolua_lerror:
900 tolua_error(tolua_S,"#ferror in function 'rotate'.",&tolua_err);
901 return 0;
902#endif
903}
904#endif //#ifndef TOLUA_DISABLE
905
906/* method: angle of class fawkes::tf::Vector3 */
907#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_angle00
908static int tolua_fawkestf_fawkes_tf_Vector3_angle00(lua_State* tolua_S)
909{
910#ifndef TOLUA_RELEASE
911 tolua_Error tolua_err;
912 if (
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)
916 )
917 goto tolua_lerror;
918 else
919#endif
920 {
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);
925#endif
926 bool exc_caught = false;
927 try {
928 {
929 double tolua_ret = (double) self->angle(*v);
930 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
931 }
932 } catch (fawkes::Exception &e) {
933 exc_caught = true;
934 lua_pushstring(tolua_S, e.what_no_backtrace());
935 }
936 catch (std::exception &e) {
937 exc_caught = true;
938 lua_pushstring(tolua_S, e.what());
939 }
940 if (exc_caught) lua_error(tolua_S);
941
942 }
943 return 1;
944#ifndef TOLUA_RELEASE
945 tolua_lerror:
946 tolua_error(tolua_S,"#ferror in function 'angle'.",&tolua_err);
947 return 0;
948#endif
949}
950#endif //#ifndef TOLUA_DISABLE
951
952/* method: absolute of class fawkes::tf::Vector3 */
953#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_absolute00
954static int tolua_fawkestf_fawkes_tf_Vector3_absolute00(lua_State* tolua_S)
955{
956#ifndef TOLUA_RELEASE
957 tolua_Error tolua_err;
958 if (
959 !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
960 !tolua_isnoobj(tolua_S,2,&tolua_err)
961 )
962 goto tolua_lerror;
963 else
964#endif
965 {
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);
969#endif
970 bool exc_caught = false;
971 try {
972 {
973 fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->absolute();
974 {
975#ifdef __cplusplus
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));
979#else
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));
983#endif
984 }
985 }
986 } catch (fawkes::Exception &e) {
987 exc_caught = true;
988 lua_pushstring(tolua_S, e.what_no_backtrace());
989 }
990 catch (std::exception &e) {
991 exc_caught = true;
992 lua_pushstring(tolua_S, e.what());
993 }
994 if (exc_caught) lua_error(tolua_S);
995
996 }
997 return 1;
998#ifndef TOLUA_RELEASE
999 tolua_lerror:
1000 tolua_error(tolua_S,"#ferror in function 'absolute'.",&tolua_err);
1001 return 0;
1002#endif
1003}
1004#endif //#ifndef TOLUA_DISABLE
1005
1006/* method: cross of class fawkes::tf::Vector3 */
1007#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_cross00
1008static int tolua_fawkestf_fawkes_tf_Vector3_cross00(lua_State* tolua_S)
1009{
1010#ifndef TOLUA_RELEASE
1011 tolua_Error tolua_err;
1012 if (
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)
1016 )
1017 goto tolua_lerror;
1018 else
1019#endif
1020 {
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);
1025#endif
1026 bool exc_caught = false;
1027 try {
1028 {
1029 fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->cross(*v);
1030 {
1031#ifdef __cplusplus
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));
1035#else
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));
1039#endif
1040 }
1041 }
1042 } catch (fawkes::Exception &e) {
1043 exc_caught = true;
1044 lua_pushstring(tolua_S, e.what_no_backtrace());
1045 }
1046 catch (std::exception &e) {
1047 exc_caught = true;
1048 lua_pushstring(tolua_S, e.what());
1049 }
1050 if (exc_caught) lua_error(tolua_S);
1051
1052 }
1053 return 1;
1054#ifndef TOLUA_RELEASE
1055 tolua_lerror:
1056 tolua_error(tolua_S,"#ferror in function 'cross'.",&tolua_err);
1057 return 0;
1058#endif
1059}
1060#endif //#ifndef TOLUA_DISABLE
1061
1062/* method: triple of class fawkes::tf::Vector3 */
1063#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_triple00
1064static int tolua_fawkestf_fawkes_tf_Vector3_triple00(lua_State* tolua_S)
1065{
1066#ifndef TOLUA_RELEASE
1067 tolua_Error tolua_err;
1068 if (
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)
1073 )
1074 goto tolua_lerror;
1075 else
1076#endif
1077 {
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);
1083#endif
1084 bool exc_caught = false;
1085 try {
1086 {
1087 double tolua_ret = (double) self->triple(*v1,*v2);
1088 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1089 }
1090 } catch (fawkes::Exception &e) {
1091 exc_caught = true;
1092 lua_pushstring(tolua_S, e.what_no_backtrace());
1093 }
1094 catch (std::exception &e) {
1095 exc_caught = true;
1096 lua_pushstring(tolua_S, e.what());
1097 }
1098 if (exc_caught) lua_error(tolua_S);
1099
1100 }
1101 return 1;
1102#ifndef TOLUA_RELEASE
1103 tolua_lerror:
1104 tolua_error(tolua_S,"#ferror in function 'triple'.",&tolua_err);
1105 return 0;
1106#endif
1107}
1108#endif //#ifndef TOLUA_DISABLE
1109
1110/* method: minAxis of class fawkes::tf::Vector3 */
1111#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_minAxis00
1112static int tolua_fawkestf_fawkes_tf_Vector3_minAxis00(lua_State* tolua_S)
1113{
1114#ifndef TOLUA_RELEASE
1115 tolua_Error tolua_err;
1116 if (
1117 !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
1118 !tolua_isnoobj(tolua_S,2,&tolua_err)
1119 )
1120 goto tolua_lerror;
1121 else
1122#endif
1123 {
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);
1127#endif
1128 bool exc_caught = false;
1129 try {
1130 {
1131 int tolua_ret = (int) self->minAxis();
1132 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1133 }
1134 } catch (fawkes::Exception &e) {
1135 exc_caught = true;
1136 lua_pushstring(tolua_S, e.what_no_backtrace());
1137 }
1138 catch (std::exception &e) {
1139 exc_caught = true;
1140 lua_pushstring(tolua_S, e.what());
1141 }
1142 if (exc_caught) lua_error(tolua_S);
1143
1144 }
1145 return 1;
1146#ifndef TOLUA_RELEASE
1147 tolua_lerror:
1148 tolua_error(tolua_S,"#ferror in function 'minAxis'.",&tolua_err);
1149 return 0;
1150#endif
1151}
1152#endif //#ifndef TOLUA_DISABLE
1153
1154/* method: maxAxis of class fawkes::tf::Vector3 */
1155#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_maxAxis00
1156static int tolua_fawkestf_fawkes_tf_Vector3_maxAxis00(lua_State* tolua_S)
1157{
1158#ifndef TOLUA_RELEASE
1159 tolua_Error tolua_err;
1160 if (
1161 !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
1162 !tolua_isnoobj(tolua_S,2,&tolua_err)
1163 )
1164 goto tolua_lerror;
1165 else
1166#endif
1167 {
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);
1171#endif
1172 bool exc_caught = false;
1173 try {
1174 {
1175 int tolua_ret = (int) self->maxAxis();
1176 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1177 }
1178 } catch (fawkes::Exception &e) {
1179 exc_caught = true;
1180 lua_pushstring(tolua_S, e.what_no_backtrace());
1181 }
1182 catch (std::exception &e) {
1183 exc_caught = true;
1184 lua_pushstring(tolua_S, e.what());
1185 }
1186 if (exc_caught) lua_error(tolua_S);
1187
1188 }
1189 return 1;
1190#ifndef TOLUA_RELEASE
1191 tolua_lerror:
1192 tolua_error(tolua_S,"#ferror in function 'maxAxis'.",&tolua_err);
1193 return 0;
1194#endif
1195}
1196#endif //#ifndef TOLUA_DISABLE
1197
1198/* method: furthestAxis of class fawkes::tf::Vector3 */
1199#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_furthestAxis00
1200static int tolua_fawkestf_fawkes_tf_Vector3_furthestAxis00(lua_State* tolua_S)
1201{
1202#ifndef TOLUA_RELEASE
1203 tolua_Error tolua_err;
1204 if (
1205 !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
1206 !tolua_isnoobj(tolua_S,2,&tolua_err)
1207 )
1208 goto tolua_lerror;
1209 else
1210#endif
1211 {
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);
1215#endif
1216 bool exc_caught = false;
1217 try {
1218 {
1219 int tolua_ret = (int) self->furthestAxis();
1220 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1221 }
1222 } catch (fawkes::Exception &e) {
1223 exc_caught = true;
1224 lua_pushstring(tolua_S, e.what_no_backtrace());
1225 }
1226 catch (std::exception &e) {
1227 exc_caught = true;
1228 lua_pushstring(tolua_S, e.what());
1229 }
1230 if (exc_caught) lua_error(tolua_S);
1231
1232 }
1233 return 1;
1234#ifndef TOLUA_RELEASE
1235 tolua_lerror:
1236 tolua_error(tolua_S,"#ferror in function 'furthestAxis'.",&tolua_err);
1237 return 0;
1238#endif
1239}
1240#endif //#ifndef TOLUA_DISABLE
1241
1242/* method: closestAxis of class fawkes::tf::Vector3 */
1243#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_closestAxis00
1244static int tolua_fawkestf_fawkes_tf_Vector3_closestAxis00(lua_State* tolua_S)
1245{
1246#ifndef TOLUA_RELEASE
1247 tolua_Error tolua_err;
1248 if (
1249 !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
1250 !tolua_isnoobj(tolua_S,2,&tolua_err)
1251 )
1252 goto tolua_lerror;
1253 else
1254#endif
1255 {
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);
1259#endif
1260 bool exc_caught = false;
1261 try {
1262 {
1263 int tolua_ret = (int) self->closestAxis();
1264 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1265 }
1266 } catch (fawkes::Exception &e) {
1267 exc_caught = true;
1268 lua_pushstring(tolua_S, e.what_no_backtrace());
1269 }
1270 catch (std::exception &e) {
1271 exc_caught = true;
1272 lua_pushstring(tolua_S, e.what());
1273 }
1274 if (exc_caught) lua_error(tolua_S);
1275
1276 }
1277 return 1;
1278#ifndef TOLUA_RELEASE
1279 tolua_lerror:
1280 tolua_error(tolua_S,"#ferror in function 'closestAxis'.",&tolua_err);
1281 return 0;
1282#endif
1283}
1284#endif //#ifndef TOLUA_DISABLE
1285
1286/* method: setInterpolate3 of class fawkes::tf::Vector3 */
1287#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setInterpolate300
1288static int tolua_fawkestf_fawkes_tf_Vector3_setInterpolate300(lua_State* tolua_S)
1289{
1290#ifndef TOLUA_RELEASE
1291 tolua_Error tolua_err;
1292 if (
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)
1298 )
1299 goto tolua_lerror;
1300 else
1301#endif
1302 {
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);
1309#endif
1310 bool exc_caught = false;
1311 try {
1312 {
1313 self->setInterpolate3(*v0,*v1,rt);
1314 }
1315 } catch (fawkes::Exception &e) {
1316 exc_caught = true;
1317 lua_pushstring(tolua_S, e.what_no_backtrace());
1318 }
1319 catch (std::exception &e) {
1320 exc_caught = true;
1321 lua_pushstring(tolua_S, e.what());
1322 }
1323 if (exc_caught) lua_error(tolua_S);
1324
1325 }
1326 return 0;
1327#ifndef TOLUA_RELEASE
1328 tolua_lerror:
1329 tolua_error(tolua_S,"#ferror in function 'setInterpolate3'.",&tolua_err);
1330 return 0;
1331#endif
1332}
1333#endif //#ifndef TOLUA_DISABLE
1334
1335/* method: lerp of class fawkes::tf::Vector3 */
1336#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_lerp00
1337static int tolua_fawkestf_fawkes_tf_Vector3_lerp00(lua_State* tolua_S)
1338{
1339#ifndef TOLUA_RELEASE
1340 tolua_Error tolua_err;
1341 if (
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)
1346 )
1347 goto tolua_lerror;
1348 else
1349#endif
1350 {
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);
1356#endif
1357 bool exc_caught = false;
1358 try {
1359 {
1360 fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->lerp(*v,t);
1361 {
1362#ifdef __cplusplus
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));
1366#else
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));
1370#endif
1371 }
1372 tolua_pushnumber(tolua_S,(lua_Number)t);
1373 }
1374 } catch (fawkes::Exception &e) {
1375 exc_caught = true;
1376 lua_pushstring(tolua_S, e.what_no_backtrace());
1377 }
1378 catch (std::exception &e) {
1379 exc_caught = true;
1380 lua_pushstring(tolua_S, e.what());
1381 }
1382 if (exc_caught) lua_error(tolua_S);
1383
1384 }
1385 return 2;
1386#ifndef TOLUA_RELEASE
1387 tolua_lerror:
1388 tolua_error(tolua_S,"#ferror in function 'lerp'.",&tolua_err);
1389 return 0;
1390#endif
1391}
1392#endif //#ifndef TOLUA_DISABLE
1393
1394/* method: x of class fawkes::tf::Vector3 */
1395#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_x00
1396static int tolua_fawkestf_fawkes_tf_Vector3_x00(lua_State* tolua_S)
1397{
1398#ifndef TOLUA_RELEASE
1399 tolua_Error tolua_err;
1400 if (
1401 !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
1402 !tolua_isnoobj(tolua_S,2,&tolua_err)
1403 )
1404 goto tolua_lerror;
1405 else
1406#endif
1407 {
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);
1411#endif
1412 bool exc_caught = false;
1413 try {
1414 {
1415 const double tolua_ret = (const double) self->x();
1416 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1417 }
1418 } catch (fawkes::Exception &e) {
1419 exc_caught = true;
1420 lua_pushstring(tolua_S, e.what_no_backtrace());
1421 }
1422 catch (std::exception &e) {
1423 exc_caught = true;
1424 lua_pushstring(tolua_S, e.what());
1425 }
1426 if (exc_caught) lua_error(tolua_S);
1427
1428 }
1429 return 1;
1430#ifndef TOLUA_RELEASE
1431 tolua_lerror:
1432 tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
1433 return 0;
1434#endif
1435}
1436#endif //#ifndef TOLUA_DISABLE
1437
1438/* method: y of class fawkes::tf::Vector3 */
1439#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_y00
1440static int tolua_fawkestf_fawkes_tf_Vector3_y00(lua_State* tolua_S)
1441{
1442#ifndef TOLUA_RELEASE
1443 tolua_Error tolua_err;
1444 if (
1445 !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
1446 !tolua_isnoobj(tolua_S,2,&tolua_err)
1447 )
1448 goto tolua_lerror;
1449 else
1450#endif
1451 {
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);
1455#endif
1456 bool exc_caught = false;
1457 try {
1458 {
1459 const double tolua_ret = (const double) self->y();
1460 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1461 }
1462 } catch (fawkes::Exception &e) {
1463 exc_caught = true;
1464 lua_pushstring(tolua_S, e.what_no_backtrace());
1465 }
1466 catch (std::exception &e) {
1467 exc_caught = true;
1468 lua_pushstring(tolua_S, e.what());
1469 }
1470 if (exc_caught) lua_error(tolua_S);
1471
1472 }
1473 return 1;
1474#ifndef TOLUA_RELEASE
1475 tolua_lerror:
1476 tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
1477 return 0;
1478#endif
1479}
1480#endif //#ifndef TOLUA_DISABLE
1481
1482/* method: z of class fawkes::tf::Vector3 */
1483#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_z00
1484static int tolua_fawkestf_fawkes_tf_Vector3_z00(lua_State* tolua_S)
1485{
1486#ifndef TOLUA_RELEASE
1487 tolua_Error tolua_err;
1488 if (
1489 !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
1490 !tolua_isnoobj(tolua_S,2,&tolua_err)
1491 )
1492 goto tolua_lerror;
1493 else
1494#endif
1495 {
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);
1499#endif
1500 bool exc_caught = false;
1501 try {
1502 {
1503 const double tolua_ret = (const double) self->z();
1504 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1505 }
1506 } catch (fawkes::Exception &e) {
1507 exc_caught = true;
1508 lua_pushstring(tolua_S, e.what_no_backtrace());
1509 }
1510 catch (std::exception &e) {
1511 exc_caught = true;
1512 lua_pushstring(tolua_S, e.what());
1513 }
1514 if (exc_caught) lua_error(tolua_S);
1515
1516 }
1517 return 1;
1518#ifndef TOLUA_RELEASE
1519 tolua_lerror:
1520 tolua_error(tolua_S,"#ferror in function 'z'.",&tolua_err);
1521 return 0;
1522#endif
1523}
1524#endif //#ifndef TOLUA_DISABLE
1525
1526/* method: setX of class fawkes::tf::Vector3 */
1527#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setX00
1528static int tolua_fawkestf_fawkes_tf_Vector3_setX00(lua_State* tolua_S)
1529{
1530#ifndef TOLUA_RELEASE
1531 tolua_Error tolua_err;
1532 if (
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)
1536 )
1537 goto tolua_lerror;
1538 else
1539#endif
1540 {
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);
1545#endif
1546 bool exc_caught = false;
1547 try {
1548 {
1549 self->setX(x);
1550 }
1551 } catch (fawkes::Exception &e) {
1552 exc_caught = true;
1553 lua_pushstring(tolua_S, e.what_no_backtrace());
1554 }
1555 catch (std::exception &e) {
1556 exc_caught = true;
1557 lua_pushstring(tolua_S, e.what());
1558 }
1559 if (exc_caught) lua_error(tolua_S);
1560
1561 }
1562 return 0;
1563#ifndef TOLUA_RELEASE
1564 tolua_lerror:
1565 tolua_error(tolua_S,"#ferror in function 'setX'.",&tolua_err);
1566 return 0;
1567#endif
1568}
1569#endif //#ifndef TOLUA_DISABLE
1570
1571/* method: setY of class fawkes::tf::Vector3 */
1572#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setY00
1573static int tolua_fawkestf_fawkes_tf_Vector3_setY00(lua_State* tolua_S)
1574{
1575#ifndef TOLUA_RELEASE
1576 tolua_Error tolua_err;
1577 if (
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)
1581 )
1582 goto tolua_lerror;
1583 else
1584#endif
1585 {
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);
1590#endif
1591 bool exc_caught = false;
1592 try {
1593 {
1594 self->setY(x);
1595 }
1596 } catch (fawkes::Exception &e) {
1597 exc_caught = true;
1598 lua_pushstring(tolua_S, e.what_no_backtrace());
1599 }
1600 catch (std::exception &e) {
1601 exc_caught = true;
1602 lua_pushstring(tolua_S, e.what());
1603 }
1604 if (exc_caught) lua_error(tolua_S);
1605
1606 }
1607 return 0;
1608#ifndef TOLUA_RELEASE
1609 tolua_lerror:
1610 tolua_error(tolua_S,"#ferror in function 'setY'.",&tolua_err);
1611 return 0;
1612#endif
1613}
1614#endif //#ifndef TOLUA_DISABLE
1615
1616/* method: setZ of class fawkes::tf::Vector3 */
1617#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setZ00
1618static int tolua_fawkestf_fawkes_tf_Vector3_setZ00(lua_State* tolua_S)
1619{
1620#ifndef TOLUA_RELEASE
1621 tolua_Error tolua_err;
1622 if (
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)
1626 )
1627 goto tolua_lerror;
1628 else
1629#endif
1630 {
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);
1635#endif
1636 bool exc_caught = false;
1637 try {
1638 {
1639 self->setZ(x);
1640 }
1641 } catch (fawkes::Exception &e) {
1642 exc_caught = true;
1643 lua_pushstring(tolua_S, e.what_no_backtrace());
1644 }
1645 catch (std::exception &e) {
1646 exc_caught = true;
1647 lua_pushstring(tolua_S, e.what());
1648 }
1649 if (exc_caught) lua_error(tolua_S);
1650
1651 }
1652 return 0;
1653#ifndef TOLUA_RELEASE
1654 tolua_lerror:
1655 tolua_error(tolua_S,"#ferror in function 'setZ'.",&tolua_err);
1656 return 0;
1657#endif
1658}
1659#endif //#ifndef TOLUA_DISABLE
1660
1661/* method: setValue of class fawkes::tf::Vector3 */
1662#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setValue00
1663static int tolua_fawkestf_fawkes_tf_Vector3_setValue00(lua_State* tolua_S)
1664{
1665#ifndef TOLUA_RELEASE
1666 tolua_Error tolua_err;
1667 if (
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)
1673 )
1674 goto tolua_lerror;
1675 else
1676#endif
1677 {
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);
1684#endif
1685 bool exc_caught = false;
1686 try {
1687 {
1688 self->setValue(x,y,z);
1689 }
1690 } catch (fawkes::Exception &e) {
1691 exc_caught = true;
1692 lua_pushstring(tolua_S, e.what_no_backtrace());
1693 }
1694 catch (std::exception &e) {
1695 exc_caught = true;
1696 lua_pushstring(tolua_S, e.what());
1697 }
1698 if (exc_caught) lua_error(tolua_S);
1699
1700 }
1701 return 0;
1702#ifndef TOLUA_RELEASE
1703 tolua_lerror:
1704 tolua_error(tolua_S,"#ferror in function 'setValue'.",&tolua_err);
1705 return 0;
1706#endif
1707}
1708#endif //#ifndef TOLUA_DISABLE
1709
1710/* method: setZero of class fawkes::tf::Vector3 */
1711#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_setZero00
1712static int tolua_fawkestf_fawkes_tf_Vector3_setZero00(lua_State* tolua_S)
1713{
1714#ifndef TOLUA_RELEASE
1715 tolua_Error tolua_err;
1716 if (
1717 !tolua_isusertype(tolua_S,1,"fawkes::tf::Vector3",0,&tolua_err) ||
1718 !tolua_isnoobj(tolua_S,2,&tolua_err)
1719 )
1720 goto tolua_lerror;
1721 else
1722#endif
1723 {
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);
1727#endif
1728 bool exc_caught = false;
1729 try {
1730 {
1731 self->setZero();
1732 }
1733 } catch (fawkes::Exception &e) {
1734 exc_caught = true;
1735 lua_pushstring(tolua_S, e.what_no_backtrace());
1736 }
1737 catch (std::exception &e) {
1738 exc_caught = true;
1739 lua_pushstring(tolua_S, e.what());
1740 }
1741 if (exc_caught) lua_error(tolua_S);
1742
1743 }
1744 return 0;
1745#ifndef TOLUA_RELEASE
1746 tolua_lerror:
1747 tolua_error(tolua_S,"#ferror in function 'setZero'.",&tolua_err);
1748 return 0;
1749#endif
1750}
1751#endif //#ifndef TOLUA_DISABLE
1752
1753/* method: isZero of class fawkes::tf::Vector3 */
1754#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_isZero00
1755static int tolua_fawkestf_fawkes_tf_Vector3_isZero00(lua_State* tolua_S)
1756{
1757#ifndef TOLUA_RELEASE
1758 tolua_Error tolua_err;
1759 if (
1760 !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
1761 !tolua_isnoobj(tolua_S,2,&tolua_err)
1762 )
1763 goto tolua_lerror;
1764 else
1765#endif
1766 {
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);
1770#endif
1771 bool exc_caught = false;
1772 try {
1773 {
1774 bool tolua_ret = (bool) self->isZero();
1775 tolua_pushboolean(tolua_S,(bool)tolua_ret);
1776 }
1777 } catch (fawkes::Exception &e) {
1778 exc_caught = true;
1779 lua_pushstring(tolua_S, e.what_no_backtrace());
1780 }
1781 catch (std::exception &e) {
1782 exc_caught = true;
1783 lua_pushstring(tolua_S, e.what());
1784 }
1785 if (exc_caught) lua_error(tolua_S);
1786
1787 }
1788 return 1;
1789#ifndef TOLUA_RELEASE
1790 tolua_lerror:
1791 tolua_error(tolua_S,"#ferror in function 'isZero'.",&tolua_err);
1792 return 0;
1793#endif
1794}
1795#endif //#ifndef TOLUA_DISABLE
1796
1797/* method: fuzzyZero of class fawkes::tf::Vector3 */
1798#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Vector3_fuzzyZero00
1799static int tolua_fawkestf_fawkes_tf_Vector3_fuzzyZero00(lua_State* tolua_S)
1800{
1801#ifndef TOLUA_RELEASE
1802 tolua_Error tolua_err;
1803 if (
1804 !tolua_isusertype(tolua_S,1,"const fawkes::tf::Vector3",0,&tolua_err) ||
1805 !tolua_isnoobj(tolua_S,2,&tolua_err)
1806 )
1807 goto tolua_lerror;
1808 else
1809#endif
1810 {
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);
1814#endif
1815 bool exc_caught = false;
1816 try {
1817 {
1818 bool tolua_ret = (bool) self->fuzzyZero();
1819 tolua_pushboolean(tolua_S,(bool)tolua_ret);
1820 }
1821 } catch (fawkes::Exception &e) {
1822 exc_caught = true;
1823 lua_pushstring(tolua_S, e.what_no_backtrace());
1824 }
1825 catch (std::exception &e) {
1826 exc_caught = true;
1827 lua_pushstring(tolua_S, e.what());
1828 }
1829 if (exc_caught) lua_error(tolua_S);
1830
1831 }
1832 return 1;
1833#ifndef TOLUA_RELEASE
1834 tolua_lerror:
1835 tolua_error(tolua_S,"#ferror in function 'fuzzyZero'.",&tolua_err);
1836 return 0;
1837#endif
1838}
1839#endif //#ifndef TOLUA_DISABLE
1840
1841/* method: new of class fawkes::tf::Quaternion */
1842#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new00
1843static int tolua_fawkestf_fawkes_tf_Quaternion_new00(lua_State* tolua_S)
1844{
1845#ifndef TOLUA_RELEASE
1846 tolua_Error tolua_err;
1847 if (
1848 !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
1849 !tolua_isnoobj(tolua_S,2,&tolua_err)
1850 )
1851 goto tolua_lerror;
1852 else
1853#endif
1854 {
1855 bool exc_caught = false;
1856 try {
1857 {
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");
1860 }
1861 } catch (fawkes::Exception &e) {
1862 exc_caught = true;
1863 lua_pushstring(tolua_S, e.what_no_backtrace());
1864 }
1865 catch (std::exception &e) {
1866 exc_caught = true;
1867 lua_pushstring(tolua_S, e.what());
1868 }
1869 if (exc_caught) lua_error(tolua_S);
1870
1871 }
1872 return 1;
1873#ifndef TOLUA_RELEASE
1874 tolua_lerror:
1875 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1876 return 0;
1877#endif
1878}
1879#endif //#ifndef TOLUA_DISABLE
1880
1881/* method: new_local of class fawkes::tf::Quaternion */
1882#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new00_local
1883static int tolua_fawkestf_fawkes_tf_Quaternion_new00_local(lua_State* tolua_S)
1884{
1885#ifndef TOLUA_RELEASE
1886 tolua_Error tolua_err;
1887 if (
1888 !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
1889 !tolua_isnoobj(tolua_S,2,&tolua_err)
1890 )
1891 goto tolua_lerror;
1892 else
1893#endif
1894 {
1895 bool exc_caught = false;
1896 try {
1897 {
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));
1901 }
1902 } catch (fawkes::Exception &e) {
1903 exc_caught = true;
1904 lua_pushstring(tolua_S, e.what_no_backtrace());
1905 }
1906 catch (std::exception &e) {
1907 exc_caught = true;
1908 lua_pushstring(tolua_S, e.what());
1909 }
1910 if (exc_caught) lua_error(tolua_S);
1911
1912 }
1913 return 1;
1914#ifndef TOLUA_RELEASE
1915 tolua_lerror:
1916 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1917 return 0;
1918#endif
1919}
1920#endif //#ifndef TOLUA_DISABLE
1921
1922/* method: new of class fawkes::tf::Quaternion */
1923#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new01
1924static int tolua_fawkestf_fawkes_tf_Quaternion_new01(lua_State* tolua_S)
1925{
1926 tolua_Error tolua_err;
1927 if (
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)
1934 )
1935 goto tolua_lerror;
1936 else
1937 {
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;
1943 try {
1944 {
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");
1947 }
1948 } catch (fawkes::Exception &e) {
1949 exc_caught = true;
1950 lua_pushstring(tolua_S, e.what_no_backtrace());
1951 }
1952 catch (std::exception &e) {
1953 exc_caught = true;
1954 lua_pushstring(tolua_S, e.what());
1955 }
1956 if (exc_caught) lua_error(tolua_S);
1957
1958 }
1959 return 1;
1960tolua_lerror:
1961 return tolua_fawkestf_fawkes_tf_Quaternion_new00(tolua_S);
1962}
1963#endif //#ifndef TOLUA_DISABLE
1964
1965/* method: new_local of class fawkes::tf::Quaternion */
1966#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new01_local
1967static int tolua_fawkestf_fawkes_tf_Quaternion_new01_local(lua_State* tolua_S)
1968{
1969 tolua_Error tolua_err;
1970 if (
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)
1977 )
1978 goto tolua_lerror;
1979 else
1980 {
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;
1986 try {
1987 {
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));
1991 }
1992 } catch (fawkes::Exception &e) {
1993 exc_caught = true;
1994 lua_pushstring(tolua_S, e.what_no_backtrace());
1995 }
1996 catch (std::exception &e) {
1997 exc_caught = true;
1998 lua_pushstring(tolua_S, e.what());
1999 }
2000 if (exc_caught) lua_error(tolua_S);
2001
2002 }
2003 return 1;
2004tolua_lerror:
2005 return tolua_fawkestf_fawkes_tf_Quaternion_new00_local(tolua_S);
2006}
2007#endif //#ifndef TOLUA_DISABLE
2008
2009/* method: new of class fawkes::tf::Quaternion */
2010#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new02
2011static int tolua_fawkestf_fawkes_tf_Quaternion_new02(lua_State* tolua_S)
2012{
2013 tolua_Error tolua_err;
2014 if (
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)
2019 )
2020 goto tolua_lerror;
2021 else
2022 {
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;
2026 try {
2027 {
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");
2030 }
2031 } catch (fawkes::Exception &e) {
2032 exc_caught = true;
2033 lua_pushstring(tolua_S, e.what_no_backtrace());
2034 }
2035 catch (std::exception &e) {
2036 exc_caught = true;
2037 lua_pushstring(tolua_S, e.what());
2038 }
2039 if (exc_caught) lua_error(tolua_S);
2040
2041 }
2042 return 1;
2043tolua_lerror:
2044 return tolua_fawkestf_fawkes_tf_Quaternion_new01(tolua_S);
2045}
2046#endif //#ifndef TOLUA_DISABLE
2047
2048/* method: new_local of class fawkes::tf::Quaternion */
2049#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new02_local
2050static int tolua_fawkestf_fawkes_tf_Quaternion_new02_local(lua_State* tolua_S)
2051{
2052 tolua_Error tolua_err;
2053 if (
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)
2058 )
2059 goto tolua_lerror;
2060 else
2061 {
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;
2065 try {
2066 {
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));
2070 }
2071 } catch (fawkes::Exception &e) {
2072 exc_caught = true;
2073 lua_pushstring(tolua_S, e.what_no_backtrace());
2074 }
2075 catch (std::exception &e) {
2076 exc_caught = true;
2077 lua_pushstring(tolua_S, e.what());
2078 }
2079 if (exc_caught) lua_error(tolua_S);
2080
2081 }
2082 return 1;
2083tolua_lerror:
2084 return tolua_fawkestf_fawkes_tf_Quaternion_new01_local(tolua_S);
2085}
2086#endif //#ifndef TOLUA_DISABLE
2087
2088/* method: new of class fawkes::tf::Quaternion */
2089#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new03
2090static int tolua_fawkestf_fawkes_tf_Quaternion_new03(lua_State* tolua_S)
2091{
2092 tolua_Error tolua_err;
2093 if (
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)
2099 )
2100 goto tolua_lerror;
2101 else
2102 {
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;
2107 try {
2108 {
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");
2111 }
2112 } catch (fawkes::Exception &e) {
2113 exc_caught = true;
2114 lua_pushstring(tolua_S, e.what_no_backtrace());
2115 }
2116 catch (std::exception &e) {
2117 exc_caught = true;
2118 lua_pushstring(tolua_S, e.what());
2119 }
2120 if (exc_caught) lua_error(tolua_S);
2121
2122 }
2123 return 1;
2124tolua_lerror:
2125 return tolua_fawkestf_fawkes_tf_Quaternion_new02(tolua_S);
2126}
2127#endif //#ifndef TOLUA_DISABLE
2128
2129/* method: new_local of class fawkes::tf::Quaternion */
2130#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_new03_local
2131static int tolua_fawkestf_fawkes_tf_Quaternion_new03_local(lua_State* tolua_S)
2132{
2133 tolua_Error tolua_err;
2134 if (
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)
2140 )
2141 goto tolua_lerror;
2142 else
2143 {
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;
2148 try {
2149 {
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));
2153 }
2154 } catch (fawkes::Exception &e) {
2155 exc_caught = true;
2156 lua_pushstring(tolua_S, e.what_no_backtrace());
2157 }
2158 catch (std::exception &e) {
2159 exc_caught = true;
2160 lua_pushstring(tolua_S, e.what());
2161 }
2162 if (exc_caught) lua_error(tolua_S);
2163
2164 }
2165 return 1;
2166tolua_lerror:
2167 return tolua_fawkestf_fawkes_tf_Quaternion_new02_local(tolua_S);
2168}
2169#endif //#ifndef TOLUA_DISABLE
2170
2171/* method: getIdentity of class fawkes::tf::Quaternion */
2172#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_getIdentity00
2173static int tolua_fawkestf_fawkes_tf_Quaternion_getIdentity00(lua_State* tolua_S)
2174{
2175#ifndef TOLUA_RELEASE
2176 tolua_Error tolua_err;
2177 if (
2178 !tolua_isusertable(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2179 !tolua_isnoobj(tolua_S,2,&tolua_err)
2180 )
2181 goto tolua_lerror;
2182 else
2183#endif
2184 {
2185 bool exc_caught = false;
2186 try {
2187 {
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");
2190 }
2191 } catch (fawkes::Exception &e) {
2192 exc_caught = true;
2193 lua_pushstring(tolua_S, e.what_no_backtrace());
2194 }
2195 catch (std::exception &e) {
2196 exc_caught = true;
2197 lua_pushstring(tolua_S, e.what());
2198 }
2199 if (exc_caught) lua_error(tolua_S);
2200
2201 }
2202 return 1;
2203#ifndef TOLUA_RELEASE
2204 tolua_lerror:
2205 tolua_error(tolua_S,"#ferror in function 'getIdentity'.",&tolua_err);
2206 return 0;
2207#endif
2208}
2209#endif //#ifndef TOLUA_DISABLE
2210
2211/* method: setRotation of class fawkes::tf::Quaternion */
2212#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setRotation00
2213static int tolua_fawkestf_fawkes_tf_Quaternion_setRotation00(lua_State* tolua_S)
2214{
2215#ifndef TOLUA_RELEASE
2216 tolua_Error tolua_err;
2217 if (
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)
2222 )
2223 goto tolua_lerror;
2224 else
2225#endif
2226 {
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);
2232#endif
2233 bool exc_caught = false;
2234 try {
2235 {
2236 self->setRotation(axis,angle);
2237 }
2238 } catch (fawkes::Exception &e) {
2239 exc_caught = true;
2240 lua_pushstring(tolua_S, e.what_no_backtrace());
2241 }
2242 catch (std::exception &e) {
2243 exc_caught = true;
2244 lua_pushstring(tolua_S, e.what());
2245 }
2246 if (exc_caught) lua_error(tolua_S);
2247
2248 }
2249 return 0;
2250#ifndef TOLUA_RELEASE
2251 tolua_lerror:
2252 tolua_error(tolua_S,"#ferror in function 'setRotation'.",&tolua_err);
2253 return 0;
2254#endif
2255}
2256#endif //#ifndef TOLUA_DISABLE
2257
2258/* method: setEuler of class fawkes::tf::Quaternion */
2259#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setEuler00
2260static int tolua_fawkestf_fawkes_tf_Quaternion_setEuler00(lua_State* tolua_S)
2261{
2262#ifndef TOLUA_RELEASE
2263 tolua_Error tolua_err;
2264 if (
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)
2270 )
2271 goto tolua_lerror;
2272 else
2273#endif
2274 {
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);
2281#endif
2282 bool exc_caught = false;
2283 try {
2284 {
2285 self->setEuler(yaw,pitch,roll);
2286 }
2287 } catch (fawkes::Exception &e) {
2288 exc_caught = true;
2289 lua_pushstring(tolua_S, e.what_no_backtrace());
2290 }
2291 catch (std::exception &e) {
2292 exc_caught = true;
2293 lua_pushstring(tolua_S, e.what());
2294 }
2295 if (exc_caught) lua_error(tolua_S);
2296
2297 }
2298 return 0;
2299#ifndef TOLUA_RELEASE
2300 tolua_lerror:
2301 tolua_error(tolua_S,"#ferror in function 'setEuler'.",&tolua_err);
2302 return 0;
2303#endif
2304}
2305#endif //#ifndef TOLUA_DISABLE
2306
2307/* method: operator== of class fawkes::tf::Quaternion */
2308#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion__eq00
2309static int tolua_fawkestf_fawkes_tf_Quaternion__eq00(lua_State* tolua_S)
2310{
2311#ifndef TOLUA_RELEASE
2312 tolua_Error tolua_err;
2313 if (
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)
2317 )
2318 goto tolua_lerror;
2319 else
2320#endif
2321 {
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);
2326#endif
2327 bool exc_caught = false;
2328 try {
2329 {
2330 bool tolua_ret = (bool) self->operator==(*q);
2331 tolua_pushboolean(tolua_S,(bool)tolua_ret);
2332 }
2333 } catch (fawkes::Exception &e) {
2334 exc_caught = true;
2335 lua_pushstring(tolua_S, e.what_no_backtrace());
2336 }
2337 catch (std::exception &e) {
2338 exc_caught = true;
2339 lua_pushstring(tolua_S, e.what());
2340 }
2341 if (exc_caught) lua_error(tolua_S);
2342
2343 }
2344 return 1;
2345#ifndef TOLUA_RELEASE
2346 tolua_lerror:
2347 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
2348 return 0;
2349#endif
2350}
2351#endif //#ifndef TOLUA_DISABLE
2352
2353/* method: dot of class fawkes::tf::Quaternion */
2354#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_dot00
2355static int tolua_fawkestf_fawkes_tf_Quaternion_dot00(lua_State* tolua_S)
2356{
2357#ifndef TOLUA_RELEASE
2358 tolua_Error tolua_err;
2359 if (
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)
2363 )
2364 goto tolua_lerror;
2365 else
2366#endif
2367 {
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);
2372#endif
2373 bool exc_caught = false;
2374 try {
2375 {
2376 double tolua_ret = (double) self->dot(*q);
2377 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2378 }
2379 } catch (fawkes::Exception &e) {
2380 exc_caught = true;
2381 lua_pushstring(tolua_S, e.what_no_backtrace());
2382 }
2383 catch (std::exception &e) {
2384 exc_caught = true;
2385 lua_pushstring(tolua_S, e.what());
2386 }
2387 if (exc_caught) lua_error(tolua_S);
2388
2389 }
2390 return 1;
2391#ifndef TOLUA_RELEASE
2392 tolua_lerror:
2393 tolua_error(tolua_S,"#ferror in function 'dot'.",&tolua_err);
2394 return 0;
2395#endif
2396}
2397#endif //#ifndef TOLUA_DISABLE
2398
2399/* method: length2 of class fawkes::tf::Quaternion */
2400#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_length200
2401static int tolua_fawkestf_fawkes_tf_Quaternion_length200(lua_State* tolua_S)
2402{
2403#ifndef TOLUA_RELEASE
2404 tolua_Error tolua_err;
2405 if (
2406 !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
2407 !tolua_isnoobj(tolua_S,2,&tolua_err)
2408 )
2409 goto tolua_lerror;
2410 else
2411#endif
2412 {
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);
2416#endif
2417 bool exc_caught = false;
2418 try {
2419 {
2420 double tolua_ret = (double) self->length2();
2421 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2422 }
2423 } catch (fawkes::Exception &e) {
2424 exc_caught = true;
2425 lua_pushstring(tolua_S, e.what_no_backtrace());
2426 }
2427 catch (std::exception &e) {
2428 exc_caught = true;
2429 lua_pushstring(tolua_S, e.what());
2430 }
2431 if (exc_caught) lua_error(tolua_S);
2432
2433 }
2434 return 1;
2435#ifndef TOLUA_RELEASE
2436 tolua_lerror:
2437 tolua_error(tolua_S,"#ferror in function 'length2'.",&tolua_err);
2438 return 0;
2439#endif
2440}
2441#endif //#ifndef TOLUA_DISABLE
2442
2443/* method: length of class fawkes::tf::Quaternion */
2444#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_length00
2445static int tolua_fawkestf_fawkes_tf_Quaternion_length00(lua_State* tolua_S)
2446{
2447#ifndef TOLUA_RELEASE
2448 tolua_Error tolua_err;
2449 if (
2450 !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
2451 !tolua_isnoobj(tolua_S,2,&tolua_err)
2452 )
2453 goto tolua_lerror;
2454 else
2455#endif
2456 {
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);
2460#endif
2461 bool exc_caught = false;
2462 try {
2463 {
2464 double tolua_ret = (double) self->length();
2465 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2466 }
2467 } catch (fawkes::Exception &e) {
2468 exc_caught = true;
2469 lua_pushstring(tolua_S, e.what_no_backtrace());
2470 }
2471 catch (std::exception &e) {
2472 exc_caught = true;
2473 lua_pushstring(tolua_S, e.what());
2474 }
2475 if (exc_caught) lua_error(tolua_S);
2476
2477 }
2478 return 1;
2479#ifndef TOLUA_RELEASE
2480 tolua_lerror:
2481 tolua_error(tolua_S,"#ferror in function 'length'.",&tolua_err);
2482 return 0;
2483#endif
2484}
2485#endif //#ifndef TOLUA_DISABLE
2486
2487/* method: normalize of class fawkes::tf::Quaternion */
2488#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_normalize00
2489static int tolua_fawkestf_fawkes_tf_Quaternion_normalize00(lua_State* tolua_S)
2490{
2491#ifndef TOLUA_RELEASE
2492 tolua_Error tolua_err;
2493 if (
2494 !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2495 !tolua_isnoobj(tolua_S,2,&tolua_err)
2496 )
2497 goto tolua_lerror;
2498 else
2499#endif
2500 {
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);
2504#endif
2505 bool exc_caught = false;
2506 try {
2507 {
2508 fawkes::tf::Quaternion& tolua_ret = (fawkes::tf::Quaternion&) self->normalize();
2509 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::tf::Quaternion");
2510 }
2511 } catch (fawkes::Exception &e) {
2512 exc_caught = true;
2513 lua_pushstring(tolua_S, e.what_no_backtrace());
2514 }
2515 catch (std::exception &e) {
2516 exc_caught = true;
2517 lua_pushstring(tolua_S, e.what());
2518 }
2519 if (exc_caught) lua_error(tolua_S);
2520
2521 }
2522 return 1;
2523#ifndef TOLUA_RELEASE
2524 tolua_lerror:
2525 tolua_error(tolua_S,"#ferror in function 'normalize'.",&tolua_err);
2526 return 0;
2527#endif
2528}
2529#endif //#ifndef TOLUA_DISABLE
2530
2531/* method: normalized of class fawkes::tf::Quaternion */
2532#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_normalized00
2533static int tolua_fawkestf_fawkes_tf_Quaternion_normalized00(lua_State* tolua_S)
2534{
2535#ifndef TOLUA_RELEASE
2536 tolua_Error tolua_err;
2537 if (
2538 !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2539 !tolua_isnoobj(tolua_S,2,&tolua_err)
2540 )
2541 goto tolua_lerror;
2542 else
2543#endif
2544 {
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);
2548#endif
2549 bool exc_caught = false;
2550 try {
2551 {
2552 fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) self->normalized();
2553 {
2554#ifdef __cplusplus
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));
2558#else
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));
2562#endif
2563 }
2564 }
2565 } catch (fawkes::Exception &e) {
2566 exc_caught = true;
2567 lua_pushstring(tolua_S, e.what_no_backtrace());
2568 }
2569 catch (std::exception &e) {
2570 exc_caught = true;
2571 lua_pushstring(tolua_S, e.what());
2572 }
2573 if (exc_caught) lua_error(tolua_S);
2574
2575 }
2576 return 1;
2577#ifndef TOLUA_RELEASE
2578 tolua_lerror:
2579 tolua_error(tolua_S,"#ferror in function 'normalized'.",&tolua_err);
2580 return 0;
2581#endif
2582}
2583#endif //#ifndef TOLUA_DISABLE
2584
2585/* method: angle of class fawkes::tf::Quaternion */
2586#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_angle00
2587static int tolua_fawkestf_fawkes_tf_Quaternion_angle00(lua_State* tolua_S)
2588{
2589#ifndef TOLUA_RELEASE
2590 tolua_Error tolua_err;
2591 if (
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)
2595 )
2596 goto tolua_lerror;
2597 else
2598#endif
2599 {
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);
2604#endif
2605 bool exc_caught = false;
2606 try {
2607 {
2608 double tolua_ret = (double) self->angle(*q);
2609 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2610 }
2611 } catch (fawkes::Exception &e) {
2612 exc_caught = true;
2613 lua_pushstring(tolua_S, e.what_no_backtrace());
2614 }
2615 catch (std::exception &e) {
2616 exc_caught = true;
2617 lua_pushstring(tolua_S, e.what());
2618 }
2619 if (exc_caught) lua_error(tolua_S);
2620
2621 }
2622 return 1;
2623#ifndef TOLUA_RELEASE
2624 tolua_lerror:
2625 tolua_error(tolua_S,"#ferror in function 'angle'.",&tolua_err);
2626 return 0;
2627#endif
2628}
2629#endif //#ifndef TOLUA_DISABLE
2630
2631/* method: getAngle of class fawkes::tf::Quaternion */
2632#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_getAngle00
2633static int tolua_fawkestf_fawkes_tf_Quaternion_getAngle00(lua_State* tolua_S)
2634{
2635#ifndef TOLUA_RELEASE
2636 tolua_Error tolua_err;
2637 if (
2638 !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
2639 !tolua_isnoobj(tolua_S,2,&tolua_err)
2640 )
2641 goto tolua_lerror;
2642 else
2643#endif
2644 {
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);
2648#endif
2649 bool exc_caught = false;
2650 try {
2651 {
2652 double tolua_ret = (double) self->getAngle();
2653 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2654 }
2655 } catch (fawkes::Exception &e) {
2656 exc_caught = true;
2657 lua_pushstring(tolua_S, e.what_no_backtrace());
2658 }
2659 catch (std::exception &e) {
2660 exc_caught = true;
2661 lua_pushstring(tolua_S, e.what());
2662 }
2663 if (exc_caught) lua_error(tolua_S);
2664
2665 }
2666 return 1;
2667#ifndef TOLUA_RELEASE
2668 tolua_lerror:
2669 tolua_error(tolua_S,"#ferror in function 'getAngle'.",&tolua_err);
2670 return 0;
2671#endif
2672}
2673#endif //#ifndef TOLUA_DISABLE
2674
2675/* method: getAxis of class fawkes::tf::Quaternion */
2676#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_getAxis00
2677static int tolua_fawkestf_fawkes_tf_Quaternion_getAxis00(lua_State* tolua_S)
2678{
2679#ifndef TOLUA_RELEASE
2680 tolua_Error tolua_err;
2681 if (
2682 !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
2683 !tolua_isnoobj(tolua_S,2,&tolua_err)
2684 )
2685 goto tolua_lerror;
2686 else
2687#endif
2688 {
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);
2692#endif
2693 bool exc_caught = false;
2694 try {
2695 {
2696 fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->getAxis();
2697 {
2698#ifdef __cplusplus
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));
2702#else
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));
2706#endif
2707 }
2708 }
2709 } catch (fawkes::Exception &e) {
2710 exc_caught = true;
2711 lua_pushstring(tolua_S, e.what_no_backtrace());
2712 }
2713 catch (std::exception &e) {
2714 exc_caught = true;
2715 lua_pushstring(tolua_S, e.what());
2716 }
2717 if (exc_caught) lua_error(tolua_S);
2718
2719 }
2720 return 1;
2721#ifndef TOLUA_RELEASE
2722 tolua_lerror:
2723 tolua_error(tolua_S,"#ferror in function 'getAxis'.",&tolua_err);
2724 return 0;
2725#endif
2726}
2727#endif //#ifndef TOLUA_DISABLE
2728
2729/* method: inverse of class fawkes::tf::Quaternion */
2730#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_inverse00
2731static int tolua_fawkestf_fawkes_tf_Quaternion_inverse00(lua_State* tolua_S)
2732{
2733#ifndef TOLUA_RELEASE
2734 tolua_Error tolua_err;
2735 if (
2736 !tolua_isusertype(tolua_S,1,"const fawkes::tf::Quaternion",0,&tolua_err) ||
2737 !tolua_isnoobj(tolua_S,2,&tolua_err)
2738 )
2739 goto tolua_lerror;
2740 else
2741#endif
2742 {
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);
2746#endif
2747 bool exc_caught = false;
2748 try {
2749 {
2750 fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) self->inverse();
2751 {
2752#ifdef __cplusplus
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));
2756#else
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));
2760#endif
2761 }
2762 }
2763 } catch (fawkes::Exception &e) {
2764 exc_caught = true;
2765 lua_pushstring(tolua_S, e.what_no_backtrace());
2766 }
2767 catch (std::exception &e) {
2768 exc_caught = true;
2769 lua_pushstring(tolua_S, e.what());
2770 }
2771 if (exc_caught) lua_error(tolua_S);
2772
2773 }
2774 return 1;
2775#ifndef TOLUA_RELEASE
2776 tolua_lerror:
2777 tolua_error(tolua_S,"#ferror in function 'inverse'.",&tolua_err);
2778 return 0;
2779#endif
2780}
2781#endif //#ifndef TOLUA_DISABLE
2782
2783/* method: slerp of class fawkes::tf::Quaternion */
2784#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_slerp00
2785static int tolua_fawkestf_fawkes_tf_Quaternion_slerp00(lua_State* tolua_S)
2786{
2787#ifndef TOLUA_RELEASE
2788 tolua_Error tolua_err;
2789 if (
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)
2794 )
2795 goto tolua_lerror;
2796 else
2797#endif
2798 {
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);
2804#endif
2805 bool exc_caught = false;
2806 try {
2807 {
2808 fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) self->slerp(*q,t);
2809 {
2810#ifdef __cplusplus
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));
2814#else
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));
2818#endif
2819 }
2820 }
2821 } catch (fawkes::Exception &e) {
2822 exc_caught = true;
2823 lua_pushstring(tolua_S, e.what_no_backtrace());
2824 }
2825 catch (std::exception &e) {
2826 exc_caught = true;
2827 lua_pushstring(tolua_S, e.what());
2828 }
2829 if (exc_caught) lua_error(tolua_S);
2830
2831 }
2832 return 1;
2833#ifndef TOLUA_RELEASE
2834 tolua_lerror:
2835 tolua_error(tolua_S,"#ferror in function 'slerp'.",&tolua_err);
2836 return 0;
2837#endif
2838}
2839#endif //#ifndef TOLUA_DISABLE
2840
2841/* method: x of class fawkes::tf::Quaternion */
2842#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_x00
2843static int tolua_fawkestf_fawkes_tf_Quaternion_x00(lua_State* tolua_S)
2844{
2845#ifndef TOLUA_RELEASE
2846 tolua_Error tolua_err;
2847 if (
2848 !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2849 !tolua_isnoobj(tolua_S,2,&tolua_err)
2850 )
2851 goto tolua_lerror;
2852 else
2853#endif
2854 {
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);
2858#endif
2859 bool exc_caught = false;
2860 try {
2861 {
2862 const double tolua_ret = (const double) self->x();
2863 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2864 }
2865 } catch (fawkes::Exception &e) {
2866 exc_caught = true;
2867 lua_pushstring(tolua_S, e.what_no_backtrace());
2868 }
2869 catch (std::exception &e) {
2870 exc_caught = true;
2871 lua_pushstring(tolua_S, e.what());
2872 }
2873 if (exc_caught) lua_error(tolua_S);
2874
2875 }
2876 return 1;
2877#ifndef TOLUA_RELEASE
2878 tolua_lerror:
2879 tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
2880 return 0;
2881#endif
2882}
2883#endif //#ifndef TOLUA_DISABLE
2884
2885/* method: y of class fawkes::tf::Quaternion */
2886#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_y00
2887static int tolua_fawkestf_fawkes_tf_Quaternion_y00(lua_State* tolua_S)
2888{
2889#ifndef TOLUA_RELEASE
2890 tolua_Error tolua_err;
2891 if (
2892 !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2893 !tolua_isnoobj(tolua_S,2,&tolua_err)
2894 )
2895 goto tolua_lerror;
2896 else
2897#endif
2898 {
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);
2902#endif
2903 bool exc_caught = false;
2904 try {
2905 {
2906 const double tolua_ret = (const double) self->y();
2907 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2908 }
2909 } catch (fawkes::Exception &e) {
2910 exc_caught = true;
2911 lua_pushstring(tolua_S, e.what_no_backtrace());
2912 }
2913 catch (std::exception &e) {
2914 exc_caught = true;
2915 lua_pushstring(tolua_S, e.what());
2916 }
2917 if (exc_caught) lua_error(tolua_S);
2918
2919 }
2920 return 1;
2921#ifndef TOLUA_RELEASE
2922 tolua_lerror:
2923 tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
2924 return 0;
2925#endif
2926}
2927#endif //#ifndef TOLUA_DISABLE
2928
2929/* method: z of class fawkes::tf::Quaternion */
2930#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_z00
2931static int tolua_fawkestf_fawkes_tf_Quaternion_z00(lua_State* tolua_S)
2932{
2933#ifndef TOLUA_RELEASE
2934 tolua_Error tolua_err;
2935 if (
2936 !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2937 !tolua_isnoobj(tolua_S,2,&tolua_err)
2938 )
2939 goto tolua_lerror;
2940 else
2941#endif
2942 {
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);
2946#endif
2947 bool exc_caught = false;
2948 try {
2949 {
2950 const double tolua_ret = (const double) self->z();
2951 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2952 }
2953 } catch (fawkes::Exception &e) {
2954 exc_caught = true;
2955 lua_pushstring(tolua_S, e.what_no_backtrace());
2956 }
2957 catch (std::exception &e) {
2958 exc_caught = true;
2959 lua_pushstring(tolua_S, e.what());
2960 }
2961 if (exc_caught) lua_error(tolua_S);
2962
2963 }
2964 return 1;
2965#ifndef TOLUA_RELEASE
2966 tolua_lerror:
2967 tolua_error(tolua_S,"#ferror in function 'z'.",&tolua_err);
2968 return 0;
2969#endif
2970}
2971#endif //#ifndef TOLUA_DISABLE
2972
2973/* method: w of class fawkes::tf::Quaternion */
2974#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_w00
2975static int tolua_fawkestf_fawkes_tf_Quaternion_w00(lua_State* tolua_S)
2976{
2977#ifndef TOLUA_RELEASE
2978 tolua_Error tolua_err;
2979 if (
2980 !tolua_isusertype(tolua_S,1,"fawkes::tf::Quaternion",0,&tolua_err) ||
2981 !tolua_isnoobj(tolua_S,2,&tolua_err)
2982 )
2983 goto tolua_lerror;
2984 else
2985#endif
2986 {
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);
2990#endif
2991 bool exc_caught = false;
2992 try {
2993 {
2994 const double tolua_ret = (const double) self->w();
2995 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2996 }
2997 } catch (fawkes::Exception &e) {
2998 exc_caught = true;
2999 lua_pushstring(tolua_S, e.what_no_backtrace());
3000 }
3001 catch (std::exception &e) {
3002 exc_caught = true;
3003 lua_pushstring(tolua_S, e.what());
3004 }
3005 if (exc_caught) lua_error(tolua_S);
3006
3007 }
3008 return 1;
3009#ifndef TOLUA_RELEASE
3010 tolua_lerror:
3011 tolua_error(tolua_S,"#ferror in function 'w'.",&tolua_err);
3012 return 0;
3013#endif
3014}
3015#endif //#ifndef TOLUA_DISABLE
3016
3017/* method: setX of class fawkes::tf::Quaternion */
3018#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setX00
3019static int tolua_fawkestf_fawkes_tf_Quaternion_setX00(lua_State* tolua_S)
3020{
3021#ifndef TOLUA_RELEASE
3022 tolua_Error tolua_err;
3023 if (
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)
3027 )
3028 goto tolua_lerror;
3029 else
3030#endif
3031 {
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);
3036#endif
3037 bool exc_caught = false;
3038 try {
3039 {
3040 self->setX(x);
3041 }
3042 } catch (fawkes::Exception &e) {
3043 exc_caught = true;
3044 lua_pushstring(tolua_S, e.what_no_backtrace());
3045 }
3046 catch (std::exception &e) {
3047 exc_caught = true;
3048 lua_pushstring(tolua_S, e.what());
3049 }
3050 if (exc_caught) lua_error(tolua_S);
3051
3052 }
3053 return 0;
3054#ifndef TOLUA_RELEASE
3055 tolua_lerror:
3056 tolua_error(tolua_S,"#ferror in function 'setX'.",&tolua_err);
3057 return 0;
3058#endif
3059}
3060#endif //#ifndef TOLUA_DISABLE
3061
3062/* method: setY of class fawkes::tf::Quaternion */
3063#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setY00
3064static int tolua_fawkestf_fawkes_tf_Quaternion_setY00(lua_State* tolua_S)
3065{
3066#ifndef TOLUA_RELEASE
3067 tolua_Error tolua_err;
3068 if (
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)
3072 )
3073 goto tolua_lerror;
3074 else
3075#endif
3076 {
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);
3081#endif
3082 bool exc_caught = false;
3083 try {
3084 {
3085 self->setY(x);
3086 }
3087 } catch (fawkes::Exception &e) {
3088 exc_caught = true;
3089 lua_pushstring(tolua_S, e.what_no_backtrace());
3090 }
3091 catch (std::exception &e) {
3092 exc_caught = true;
3093 lua_pushstring(tolua_S, e.what());
3094 }
3095 if (exc_caught) lua_error(tolua_S);
3096
3097 }
3098 return 0;
3099#ifndef TOLUA_RELEASE
3100 tolua_lerror:
3101 tolua_error(tolua_S,"#ferror in function 'setY'.",&tolua_err);
3102 return 0;
3103#endif
3104}
3105#endif //#ifndef TOLUA_DISABLE
3106
3107/* method: setZ of class fawkes::tf::Quaternion */
3108#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setZ00
3109static int tolua_fawkestf_fawkes_tf_Quaternion_setZ00(lua_State* tolua_S)
3110{
3111#ifndef TOLUA_RELEASE
3112 tolua_Error tolua_err;
3113 if (
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)
3117 )
3118 goto tolua_lerror;
3119 else
3120#endif
3121 {
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);
3126#endif
3127 bool exc_caught = false;
3128 try {
3129 {
3130 self->setZ(x);
3131 }
3132 } catch (fawkes::Exception &e) {
3133 exc_caught = true;
3134 lua_pushstring(tolua_S, e.what_no_backtrace());
3135 }
3136 catch (std::exception &e) {
3137 exc_caught = true;
3138 lua_pushstring(tolua_S, e.what());
3139 }
3140 if (exc_caught) lua_error(tolua_S);
3141
3142 }
3143 return 0;
3144#ifndef TOLUA_RELEASE
3145 tolua_lerror:
3146 tolua_error(tolua_S,"#ferror in function 'setZ'.",&tolua_err);
3147 return 0;
3148#endif
3149}
3150#endif //#ifndef TOLUA_DISABLE
3151
3152/* method: setW of class fawkes::tf::Quaternion */
3153#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setW00
3154static int tolua_fawkestf_fawkes_tf_Quaternion_setW00(lua_State* tolua_S)
3155{
3156#ifndef TOLUA_RELEASE
3157 tolua_Error tolua_err;
3158 if (
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)
3162 )
3163 goto tolua_lerror;
3164 else
3165#endif
3166 {
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);
3171#endif
3172 bool exc_caught = false;
3173 try {
3174 {
3175 self->setW(x);
3176 }
3177 } catch (fawkes::Exception &e) {
3178 exc_caught = true;
3179 lua_pushstring(tolua_S, e.what_no_backtrace());
3180 }
3181 catch (std::exception &e) {
3182 exc_caught = true;
3183 lua_pushstring(tolua_S, e.what());
3184 }
3185 if (exc_caught) lua_error(tolua_S);
3186
3187 }
3188 return 0;
3189#ifndef TOLUA_RELEASE
3190 tolua_lerror:
3191 tolua_error(tolua_S,"#ferror in function 'setW'.",&tolua_err);
3192 return 0;
3193#endif
3194}
3195#endif //#ifndef TOLUA_DISABLE
3196
3197/* method: setValue of class fawkes::tf::Quaternion */
3198#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Quaternion_setValue00
3199static int tolua_fawkestf_fawkes_tf_Quaternion_setValue00(lua_State* tolua_S)
3200{
3201#ifndef TOLUA_RELEASE
3202 tolua_Error tolua_err;
3203 if (
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)
3210 )
3211 goto tolua_lerror;
3212 else
3213#endif
3214 {
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);
3222#endif
3223 bool exc_caught = false;
3224 try {
3225 {
3226 self->setValue(x,y,z,w);
3227 }
3228 } catch (fawkes::Exception &e) {
3229 exc_caught = true;
3230 lua_pushstring(tolua_S, e.what_no_backtrace());
3231 }
3232 catch (std::exception &e) {
3233 exc_caught = true;
3234 lua_pushstring(tolua_S, e.what());
3235 }
3236 if (exc_caught) lua_error(tolua_S);
3237
3238 }
3239 return 0;
3240#ifndef TOLUA_RELEASE
3241 tolua_lerror:
3242 tolua_error(tolua_S,"#ferror in function 'setValue'.",&tolua_err);
3243 return 0;
3244#endif
3245}
3246#endif //#ifndef TOLUA_DISABLE
3247
3248/* method: new of class fawkes::tf::Transform */
3249#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new00
3250static int tolua_fawkestf_fawkes_tf_Transform_new00(lua_State* tolua_S)
3251{
3252#ifndef TOLUA_RELEASE
3253 tolua_Error tolua_err;
3254 if (
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)
3258 )
3259 goto tolua_lerror;
3260 else
3261#endif
3262 {
3263 const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
3264 bool exc_caught = false;
3265 try {
3266 {
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");
3269 }
3270 } catch (fawkes::Exception &e) {
3271 exc_caught = true;
3272 lua_pushstring(tolua_S, e.what_no_backtrace());
3273 }
3274 catch (std::exception &e) {
3275 exc_caught = true;
3276 lua_pushstring(tolua_S, e.what());
3277 }
3278 if (exc_caught) lua_error(tolua_S);
3279
3280 }
3281 return 1;
3282#ifndef TOLUA_RELEASE
3283 tolua_lerror:
3284 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
3285 return 0;
3286#endif
3287}
3288#endif //#ifndef TOLUA_DISABLE
3289
3290/* method: new_local of class fawkes::tf::Transform */
3291#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new00_local
3292static int tolua_fawkestf_fawkes_tf_Transform_new00_local(lua_State* tolua_S)
3293{
3294#ifndef TOLUA_RELEASE
3295 tolua_Error tolua_err;
3296 if (
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)
3300 )
3301 goto tolua_lerror;
3302 else
3303#endif
3304 {
3305 const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
3306 bool exc_caught = false;
3307 try {
3308 {
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));
3312 }
3313 } catch (fawkes::Exception &e) {
3314 exc_caught = true;
3315 lua_pushstring(tolua_S, e.what_no_backtrace());
3316 }
3317 catch (std::exception &e) {
3318 exc_caught = true;
3319 lua_pushstring(tolua_S, e.what());
3320 }
3321 if (exc_caught) lua_error(tolua_S);
3322
3323 }
3324 return 1;
3325#ifndef TOLUA_RELEASE
3326 tolua_lerror:
3327 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
3328 return 0;
3329#endif
3330}
3331#endif //#ifndef TOLUA_DISABLE
3332
3333/* method: new of class fawkes::tf::Transform */
3334#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new01
3335static int tolua_fawkestf_fawkes_tf_Transform_new01(lua_State* tolua_S)
3336{
3337 tolua_Error tolua_err;
3338 if (
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)
3343 )
3344 goto tolua_lerror;
3345 else
3346 {
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;
3350 try {
3351 {
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");
3354 }
3355 } catch (fawkes::Exception &e) {
3356 exc_caught = true;
3357 lua_pushstring(tolua_S, e.what_no_backtrace());
3358 }
3359 catch (std::exception &e) {
3360 exc_caught = true;
3361 lua_pushstring(tolua_S, e.what());
3362 }
3363 if (exc_caught) lua_error(tolua_S);
3364
3365 }
3366 return 1;
3367tolua_lerror:
3368 return tolua_fawkestf_fawkes_tf_Transform_new00(tolua_S);
3369}
3370#endif //#ifndef TOLUA_DISABLE
3371
3372/* method: new_local of class fawkes::tf::Transform */
3373#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new01_local
3374static int tolua_fawkestf_fawkes_tf_Transform_new01_local(lua_State* tolua_S)
3375{
3376 tolua_Error tolua_err;
3377 if (
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)
3382 )
3383 goto tolua_lerror;
3384 else
3385 {
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;
3389 try {
3390 {
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));
3394 }
3395 } catch (fawkes::Exception &e) {
3396 exc_caught = true;
3397 lua_pushstring(tolua_S, e.what_no_backtrace());
3398 }
3399 catch (std::exception &e) {
3400 exc_caught = true;
3401 lua_pushstring(tolua_S, e.what());
3402 }
3403 if (exc_caught) lua_error(tolua_S);
3404
3405 }
3406 return 1;
3407tolua_lerror:
3408 return tolua_fawkestf_fawkes_tf_Transform_new00_local(tolua_S);
3409}
3410#endif //#ifndef TOLUA_DISABLE
3411
3412/* method: new of class fawkes::tf::Transform */
3413#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new02
3414static int tolua_fawkestf_fawkes_tf_Transform_new02(lua_State* tolua_S)
3415{
3416 tolua_Error tolua_err;
3417 if (
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)
3421 )
3422 goto tolua_lerror;
3423 else
3424 {
3425 const fawkes::tf::Transform* other = ((const fawkes::tf::Transform*) tolua_tousertype(tolua_S,2,0));
3426 bool exc_caught = false;
3427 try {
3428 {
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");
3431 }
3432 } catch (fawkes::Exception &e) {
3433 exc_caught = true;
3434 lua_pushstring(tolua_S, e.what_no_backtrace());
3435 }
3436 catch (std::exception &e) {
3437 exc_caught = true;
3438 lua_pushstring(tolua_S, e.what());
3439 }
3440 if (exc_caught) lua_error(tolua_S);
3441
3442 }
3443 return 1;
3444tolua_lerror:
3445 return tolua_fawkestf_fawkes_tf_Transform_new01(tolua_S);
3446}
3447#endif //#ifndef TOLUA_DISABLE
3448
3449/* method: new_local of class fawkes::tf::Transform */
3450#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_new02_local
3451static int tolua_fawkestf_fawkes_tf_Transform_new02_local(lua_State* tolua_S)
3452{
3453 tolua_Error tolua_err;
3454 if (
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)
3458 )
3459 goto tolua_lerror;
3460 else
3461 {
3462 const fawkes::tf::Transform* other = ((const fawkes::tf::Transform*) tolua_tousertype(tolua_S,2,0));
3463 bool exc_caught = false;
3464 try {
3465 {
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));
3469 }
3470 } catch (fawkes::Exception &e) {
3471 exc_caught = true;
3472 lua_pushstring(tolua_S, e.what_no_backtrace());
3473 }
3474 catch (std::exception &e) {
3475 exc_caught = true;
3476 lua_pushstring(tolua_S, e.what());
3477 }
3478 if (exc_caught) lua_error(tolua_S);
3479
3480 }
3481 return 1;
3482tolua_lerror:
3483 return tolua_fawkestf_fawkes_tf_Transform_new01_local(tolua_S);
3484}
3485#endif //#ifndef TOLUA_DISABLE
3486
3487/* method: getIdentity of class fawkes::tf::Transform */
3488#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_getIdentity00
3489static int tolua_fawkestf_fawkes_tf_Transform_getIdentity00(lua_State* tolua_S)
3490{
3491#ifndef TOLUA_RELEASE
3492 tolua_Error tolua_err;
3493 if (
3494 !tolua_isusertable(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
3495 !tolua_isnoobj(tolua_S,2,&tolua_err)
3496 )
3497 goto tolua_lerror;
3498 else
3499#endif
3500 {
3501 bool exc_caught = false;
3502 try {
3503 {
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");
3506 }
3507 } catch (fawkes::Exception &e) {
3508 exc_caught = true;
3509 lua_pushstring(tolua_S, e.what_no_backtrace());
3510 }
3511 catch (std::exception &e) {
3512 exc_caught = true;
3513 lua_pushstring(tolua_S, e.what());
3514 }
3515 if (exc_caught) lua_error(tolua_S);
3516
3517 }
3518 return 1;
3519#ifndef TOLUA_RELEASE
3520 tolua_lerror:
3521 tolua_error(tolua_S,"#ferror in function 'getIdentity'.",&tolua_err);
3522 return 0;
3523#endif
3524}
3525#endif //#ifndef TOLUA_DISABLE
3526
3527/* method: mult of class fawkes::tf::Transform */
3528#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_mult00
3529static int tolua_fawkestf_fawkes_tf_Transform_mult00(lua_State* tolua_S)
3530{
3531#ifndef TOLUA_RELEASE
3532 tolua_Error tolua_err;
3533 if (
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)
3538 )
3539 goto tolua_lerror;
3540 else
3541#endif
3542 {
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);
3548#endif
3549 bool exc_caught = false;
3550 try {
3551 {
3552 self->mult(*t1,*t2);
3553 }
3554 } catch (fawkes::Exception &e) {
3555 exc_caught = true;
3556 lua_pushstring(tolua_S, e.what_no_backtrace());
3557 }
3558 catch (std::exception &e) {
3559 exc_caught = true;
3560 lua_pushstring(tolua_S, e.what());
3561 }
3562 if (exc_caught) lua_error(tolua_S);
3563
3564 }
3565 return 0;
3566#ifndef TOLUA_RELEASE
3567 tolua_lerror:
3568 tolua_error(tolua_S,"#ferror in function 'mult'.",&tolua_err);
3569 return 0;
3570#endif
3571}
3572#endif //#ifndef TOLUA_DISABLE
3573
3574/* method: operator* of class fawkes::tf::Transform */
3575#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform__mul00
3576static int tolua_fawkestf_fawkes_tf_Transform__mul00(lua_State* tolua_S)
3577{
3578#ifndef TOLUA_RELEASE
3579 tolua_Error tolua_err;
3580 if (
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)
3584 )
3585 goto tolua_lerror;
3586 else
3587#endif
3588 {
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);
3593#endif
3594 bool exc_caught = false;
3595 try {
3596 {
3597 fawkes::tf::Vector3 tolua_ret = (fawkes::tf::Vector3) self->operator*(*x);
3598 {
3599#ifdef __cplusplus
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));
3603#else
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));
3607#endif
3608 }
3609 }
3610 } catch (fawkes::Exception &e) {
3611 exc_caught = true;
3612 lua_pushstring(tolua_S, e.what_no_backtrace());
3613 }
3614 catch (std::exception &e) {
3615 exc_caught = true;
3616 lua_pushstring(tolua_S, e.what());
3617 }
3618 if (exc_caught) lua_error(tolua_S);
3619
3620 }
3621 return 1;
3622#ifndef TOLUA_RELEASE
3623 tolua_lerror:
3624 tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err);
3625 return 0;
3626#endif
3627}
3628#endif //#ifndef TOLUA_DISABLE
3629
3630/* method: operator* of class fawkes::tf::Transform */
3631#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform__mul01
3632static int tolua_fawkestf_fawkes_tf_Transform__mul01(lua_State* tolua_S)
3633{
3634 tolua_Error tolua_err;
3635 if (
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)
3639 )
3640 goto tolua_lerror;
3641 else
3642 {
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);
3647#endif
3648 bool exc_caught = false;
3649 try {
3650 {
3651 fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) self->operator*(*q);
3652 {
3653#ifdef __cplusplus
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));
3657#else
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));
3661#endif
3662 }
3663 }
3664 } catch (fawkes::Exception &e) {
3665 exc_caught = true;
3666 lua_pushstring(tolua_S, e.what_no_backtrace());
3667 }
3668 catch (std::exception &e) {
3669 exc_caught = true;
3670 lua_pushstring(tolua_S, e.what());
3671 }
3672 if (exc_caught) lua_error(tolua_S);
3673
3674 }
3675 return 1;
3676tolua_lerror:
3677 return tolua_fawkestf_fawkes_tf_Transform__mul00(tolua_S);
3678}
3679#endif //#ifndef TOLUA_DISABLE
3680
3681/* method: getOrigin of class fawkes::tf::Transform */
3682#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_getOrigin00
3683static int tolua_fawkestf_fawkes_tf_Transform_getOrigin00(lua_State* tolua_S)
3684{
3685#ifndef TOLUA_RELEASE
3686 tolua_Error tolua_err;
3687 if (
3688 !tolua_isusertype(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
3689 !tolua_isnoobj(tolua_S,2,&tolua_err)
3690 )
3691 goto tolua_lerror;
3692 else
3693#endif
3694 {
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);
3698#endif
3699 bool exc_caught = false;
3700 try {
3701 {
3702 fawkes::tf::Vector3& tolua_ret = (fawkes::tf::Vector3&) self->getOrigin();
3703 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::tf::Vector3");
3704 }
3705 } catch (fawkes::Exception &e) {
3706 exc_caught = true;
3707 lua_pushstring(tolua_S, e.what_no_backtrace());
3708 }
3709 catch (std::exception &e) {
3710 exc_caught = true;
3711 lua_pushstring(tolua_S, e.what());
3712 }
3713 if (exc_caught) lua_error(tolua_S);
3714
3715 }
3716 return 1;
3717#ifndef TOLUA_RELEASE
3718 tolua_lerror:
3719 tolua_error(tolua_S,"#ferror in function 'getOrigin'.",&tolua_err);
3720 return 0;
3721#endif
3722}
3723#endif //#ifndef TOLUA_DISABLE
3724
3725/* method: getRotation of class fawkes::tf::Transform */
3726#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_getRotation00
3727static int tolua_fawkestf_fawkes_tf_Transform_getRotation00(lua_State* tolua_S)
3728{
3729#ifndef TOLUA_RELEASE
3730 tolua_Error tolua_err;
3731 if (
3732 !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transform",0,&tolua_err) ||
3733 !tolua_isnoobj(tolua_S,2,&tolua_err)
3734 )
3735 goto tolua_lerror;
3736 else
3737#endif
3738 {
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);
3742#endif
3743 bool exc_caught = false;
3744 try {
3745 {
3746 fawkes::tf::Quaternion tolua_ret = (fawkes::tf::Quaternion) self->getRotation();
3747 {
3748#ifdef __cplusplus
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));
3752#else
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));
3756#endif
3757 }
3758 }
3759 } catch (fawkes::Exception &e) {
3760 exc_caught = true;
3761 lua_pushstring(tolua_S, e.what_no_backtrace());
3762 }
3763 catch (std::exception &e) {
3764 exc_caught = true;
3765 lua_pushstring(tolua_S, e.what());
3766 }
3767 if (exc_caught) lua_error(tolua_S);
3768
3769 }
3770 return 1;
3771#ifndef TOLUA_RELEASE
3772 tolua_lerror:
3773 tolua_error(tolua_S,"#ferror in function 'getRotation'.",&tolua_err);
3774 return 0;
3775#endif
3776}
3777#endif //#ifndef TOLUA_DISABLE
3778
3779/* method: setOrigin of class fawkes::tf::Transform */
3780#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_setOrigin00
3781static int tolua_fawkestf_fawkes_tf_Transform_setOrigin00(lua_State* tolua_S)
3782{
3783#ifndef TOLUA_RELEASE
3784 tolua_Error tolua_err;
3785 if (
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)
3789 )
3790 goto tolua_lerror;
3791 else
3792#endif
3793 {
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);
3798#endif
3799 bool exc_caught = false;
3800 try {
3801 {
3802 self->setOrigin(*origin);
3803 }
3804 } catch (fawkes::Exception &e) {
3805 exc_caught = true;
3806 lua_pushstring(tolua_S, e.what_no_backtrace());
3807 }
3808 catch (std::exception &e) {
3809 exc_caught = true;
3810 lua_pushstring(tolua_S, e.what());
3811 }
3812 if (exc_caught) lua_error(tolua_S);
3813
3814 }
3815 return 0;
3816#ifndef TOLUA_RELEASE
3817 tolua_lerror:
3818 tolua_error(tolua_S,"#ferror in function 'setOrigin'.",&tolua_err);
3819 return 0;
3820#endif
3821}
3822#endif //#ifndef TOLUA_DISABLE
3823
3824/* method: setRotation of class fawkes::tf::Transform */
3825#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_setRotation00
3826static int tolua_fawkestf_fawkes_tf_Transform_setRotation00(lua_State* tolua_S)
3827{
3828#ifndef TOLUA_RELEASE
3829 tolua_Error tolua_err;
3830 if (
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)
3834 )
3835 goto tolua_lerror;
3836 else
3837#endif
3838 {
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);
3843#endif
3844 bool exc_caught = false;
3845 try {
3846 {
3847 self->setRotation(*q);
3848 }
3849 } catch (fawkes::Exception &e) {
3850 exc_caught = true;
3851 lua_pushstring(tolua_S, e.what_no_backtrace());
3852 }
3853 catch (std::exception &e) {
3854 exc_caught = true;
3855 lua_pushstring(tolua_S, e.what());
3856 }
3857 if (exc_caught) lua_error(tolua_S);
3858
3859 }
3860 return 0;
3861#ifndef TOLUA_RELEASE
3862 tolua_lerror:
3863 tolua_error(tolua_S,"#ferror in function 'setRotation'.",&tolua_err);
3864 return 0;
3865#endif
3866}
3867#endif //#ifndef TOLUA_DISABLE
3868
3869/* method: setIdentity of class fawkes::tf::Transform */
3870#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_setIdentity00
3871static int tolua_fawkestf_fawkes_tf_Transform_setIdentity00(lua_State* tolua_S)
3872{
3873#ifndef TOLUA_RELEASE
3874 tolua_Error tolua_err;
3875 if (
3876 !tolua_isusertype(tolua_S,1,"fawkes::tf::Transform",0,&tolua_err) ||
3877 !tolua_isnoobj(tolua_S,2,&tolua_err)
3878 )
3879 goto tolua_lerror;
3880 else
3881#endif
3882 {
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);
3886#endif
3887 bool exc_caught = false;
3888 try {
3889 {
3890 self->setIdentity();
3891 }
3892 } catch (fawkes::Exception &e) {
3893 exc_caught = true;
3894 lua_pushstring(tolua_S, e.what_no_backtrace());
3895 }
3896 catch (std::exception &e) {
3897 exc_caught = true;
3898 lua_pushstring(tolua_S, e.what());
3899 }
3900 if (exc_caught) lua_error(tolua_S);
3901
3902 }
3903 return 0;
3904#ifndef TOLUA_RELEASE
3905 tolua_lerror:
3906 tolua_error(tolua_S,"#ferror in function 'setIdentity'.",&tolua_err);
3907 return 0;
3908#endif
3909}
3910#endif //#ifndef TOLUA_DISABLE
3911
3912/* method: inverse of class fawkes::tf::Transform */
3913#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_inverse00
3914static int tolua_fawkestf_fawkes_tf_Transform_inverse00(lua_State* tolua_S)
3915{
3916#ifndef TOLUA_RELEASE
3917 tolua_Error tolua_err;
3918 if (
3919 !tolua_isusertype(tolua_S,1,"const fawkes::tf::Transform",0,&tolua_err) ||
3920 !tolua_isnoobj(tolua_S,2,&tolua_err)
3921 )
3922 goto tolua_lerror;
3923 else
3924#endif
3925 {
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);
3929#endif
3930 bool exc_caught = false;
3931 try {
3932 {
3933 fawkes::tf::Transform tolua_ret = (fawkes::tf::Transform) self->inverse();
3934 {
3935#ifdef __cplusplus
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));
3939#else
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));
3943#endif
3944 }
3945 }
3946 } catch (fawkes::Exception &e) {
3947 exc_caught = true;
3948 lua_pushstring(tolua_S, e.what_no_backtrace());
3949 }
3950 catch (std::exception &e) {
3951 exc_caught = true;
3952 lua_pushstring(tolua_S, e.what());
3953 }
3954 if (exc_caught) lua_error(tolua_S);
3955
3956 }
3957 return 1;
3958#ifndef TOLUA_RELEASE
3959 tolua_lerror:
3960 tolua_error(tolua_S,"#ferror in function 'inverse'.",&tolua_err);
3961 return 0;
3962#endif
3963}
3964#endif //#ifndef TOLUA_DISABLE
3965
3966/* method: inverseTimes of class fawkes::tf::Transform */
3967#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transform_inverseTimes00
3968static int tolua_fawkestf_fawkes_tf_Transform_inverseTimes00(lua_State* tolua_S)
3969{
3970#ifndef TOLUA_RELEASE
3971 tolua_Error tolua_err;
3972 if (
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)
3976 )
3977 goto tolua_lerror;
3978 else
3979#endif
3980 {
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);
3985#endif
3986 bool exc_caught = false;
3987 try {
3988 {
3989 fawkes::tf::Transform tolua_ret = (fawkes::tf::Transform) self->inverseTimes(*t);
3990 {
3991#ifdef __cplusplus
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));
3995#else
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));
3999#endif
4000 }
4001 }
4002 } catch (fawkes::Exception &e) {
4003 exc_caught = true;
4004 lua_pushstring(tolua_S, e.what_no_backtrace());
4005 }
4006 catch (std::exception &e) {
4007 exc_caught = true;
4008 lua_pushstring(tolua_S, e.what());
4009 }
4010 if (exc_caught) lua_error(tolua_S);
4011
4012 }
4013 return 1;
4014#ifndef TOLUA_RELEASE
4015 tolua_lerror:
4016 tolua_error(tolua_S,"#ferror in function 'inverseTimes'.",&tolua_err);
4017 return 0;
4018#endif
4019}
4020#endif //#ifndef TOLUA_DISABLE
4021
4022/* method: new of class fawkes::tf::Point */
4023#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Point_new00
4024static int tolua_fawkestf_fawkes_tf_Point_new00(lua_State* tolua_S)
4025{
4026#ifndef TOLUA_RELEASE
4027 tolua_Error tolua_err;
4028 if (
4029 !tolua_isusertable(tolua_S,1,"fawkes::tf::Point",0,&tolua_err) ||
4030 !tolua_isnoobj(tolua_S,2,&tolua_err)
4031 )
4032 goto tolua_lerror;
4033 else
4034#endif
4035 {
4036 bool exc_caught = false;
4037 try {
4038 {
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");
4041 }
4042 } catch (fawkes::Exception &e) {
4043 exc_caught = true;
4044 lua_pushstring(tolua_S, e.what_no_backtrace());
4045 }
4046 catch (std::exception &e) {
4047 exc_caught = true;
4048 lua_pushstring(tolua_S, e.what());
4049 }
4050 if (exc_caught) lua_error(tolua_S);
4051
4052 }
4053 return 1;
4054#ifndef TOLUA_RELEASE
4055 tolua_lerror:
4056 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4057 return 0;
4058#endif
4059}
4060#endif //#ifndef TOLUA_DISABLE
4061
4062/* method: new_local of class fawkes::tf::Point */
4063#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Point_new00_local
4064static int tolua_fawkestf_fawkes_tf_Point_new00_local(lua_State* tolua_S)
4065{
4066#ifndef TOLUA_RELEASE
4067 tolua_Error tolua_err;
4068 if (
4069 !tolua_isusertable(tolua_S,1,"fawkes::tf::Point",0,&tolua_err) ||
4070 !tolua_isnoobj(tolua_S,2,&tolua_err)
4071 )
4072 goto tolua_lerror;
4073 else
4074#endif
4075 {
4076 bool exc_caught = false;
4077 try {
4078 {
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));
4082 }
4083 } catch (fawkes::Exception &e) {
4084 exc_caught = true;
4085 lua_pushstring(tolua_S, e.what_no_backtrace());
4086 }
4087 catch (std::exception &e) {
4088 exc_caught = true;
4089 lua_pushstring(tolua_S, e.what());
4090 }
4091 if (exc_caught) lua_error(tolua_S);
4092
4093 }
4094 return 1;
4095#ifndef TOLUA_RELEASE
4096 tolua_lerror:
4097 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4098 return 0;
4099#endif
4100}
4101#endif //#ifndef TOLUA_DISABLE
4102
4103/* method: new of class fawkes::tf::Point */
4104#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Point_new01
4105static int tolua_fawkestf_fawkes_tf_Point_new01(lua_State* tolua_S)
4106{
4107 tolua_Error tolua_err;
4108 if (
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)
4114 )
4115 goto tolua_lerror;
4116 else
4117 {
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;
4122 try {
4123 {
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");
4126 }
4127 } catch (fawkes::Exception &e) {
4128 exc_caught = true;
4129 lua_pushstring(tolua_S, e.what_no_backtrace());
4130 }
4131 catch (std::exception &e) {
4132 exc_caught = true;
4133 lua_pushstring(tolua_S, e.what());
4134 }
4135 if (exc_caught) lua_error(tolua_S);
4136
4137 }
4138 return 1;
4139tolua_lerror:
4140 return tolua_fawkestf_fawkes_tf_Point_new00(tolua_S);
4141}
4142#endif //#ifndef TOLUA_DISABLE
4143
4144/* method: new_local of class fawkes::tf::Point */
4145#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Point_new01_local
4146static int tolua_fawkestf_fawkes_tf_Point_new01_local(lua_State* tolua_S)
4147{
4148 tolua_Error tolua_err;
4149 if (
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)
4155 )
4156 goto tolua_lerror;
4157 else
4158 {
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;
4163 try {
4164 {
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));
4168 }
4169 } catch (fawkes::Exception &e) {
4170 exc_caught = true;
4171 lua_pushstring(tolua_S, e.what_no_backtrace());
4172 }
4173 catch (std::exception &e) {
4174 exc_caught = true;
4175 lua_pushstring(tolua_S, e.what());
4176 }
4177 if (exc_caught) lua_error(tolua_S);
4178
4179 }
4180 return 1;
4181tolua_lerror:
4182 return tolua_fawkestf_fawkes_tf_Point_new00_local(tolua_S);
4183}
4184#endif //#ifndef TOLUA_DISABLE
4185
4186/* method: new of class fawkes::tf::Pose */
4187#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new00
4188static int tolua_fawkestf_fawkes_tf_Pose_new00(lua_State* tolua_S)
4189{
4190#ifndef TOLUA_RELEASE
4191 tolua_Error tolua_err;
4192 if (
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)
4196 )
4197 goto tolua_lerror;
4198 else
4199#endif
4200 {
4201 const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
4202 bool exc_caught = false;
4203 try {
4204 {
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");
4207 }
4208 } catch (fawkes::Exception &e) {
4209 exc_caught = true;
4210 lua_pushstring(tolua_S, e.what_no_backtrace());
4211 }
4212 catch (std::exception &e) {
4213 exc_caught = true;
4214 lua_pushstring(tolua_S, e.what());
4215 }
4216 if (exc_caught) lua_error(tolua_S);
4217
4218 }
4219 return 1;
4220#ifndef TOLUA_RELEASE
4221 tolua_lerror:
4222 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4223 return 0;
4224#endif
4225}
4226#endif //#ifndef TOLUA_DISABLE
4227
4228/* method: new_local of class fawkes::tf::Pose */
4229#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new00_local
4230static int tolua_fawkestf_fawkes_tf_Pose_new00_local(lua_State* tolua_S)
4231{
4232#ifndef TOLUA_RELEASE
4233 tolua_Error tolua_err;
4234 if (
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)
4238 )
4239 goto tolua_lerror;
4240 else
4241#endif
4242 {
4243 const fawkes::tf::Quaternion* q = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
4244 bool exc_caught = false;
4245 try {
4246 {
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));
4250 }
4251 } catch (fawkes::Exception &e) {
4252 exc_caught = true;
4253 lua_pushstring(tolua_S, e.what_no_backtrace());
4254 }
4255 catch (std::exception &e) {
4256 exc_caught = true;
4257 lua_pushstring(tolua_S, e.what());
4258 }
4259 if (exc_caught) lua_error(tolua_S);
4260
4261 }
4262 return 1;
4263#ifndef TOLUA_RELEASE
4264 tolua_lerror:
4265 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4266 return 0;
4267#endif
4268}
4269#endif //#ifndef TOLUA_DISABLE
4270
4271/* method: new of class fawkes::tf::Pose */
4272#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new01
4273static int tolua_fawkestf_fawkes_tf_Pose_new01(lua_State* tolua_S)
4274{
4275 tolua_Error tolua_err;
4276 if (
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)
4281 )
4282 goto tolua_lerror;
4283 else
4284 {
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;
4288 try {
4289 {
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");
4292 }
4293 } catch (fawkes::Exception &e) {
4294 exc_caught = true;
4295 lua_pushstring(tolua_S, e.what_no_backtrace());
4296 }
4297 catch (std::exception &e) {
4298 exc_caught = true;
4299 lua_pushstring(tolua_S, e.what());
4300 }
4301 if (exc_caught) lua_error(tolua_S);
4302
4303 }
4304 return 1;
4305tolua_lerror:
4306 return tolua_fawkestf_fawkes_tf_Pose_new00(tolua_S);
4307}
4308#endif //#ifndef TOLUA_DISABLE
4309
4310/* method: new_local of class fawkes::tf::Pose */
4311#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new01_local
4312static int tolua_fawkestf_fawkes_tf_Pose_new01_local(lua_State* tolua_S)
4313{
4314 tolua_Error tolua_err;
4315 if (
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)
4320 )
4321 goto tolua_lerror;
4322 else
4323 {
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;
4327 try {
4328 {
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));
4332 }
4333 } catch (fawkes::Exception &e) {
4334 exc_caught = true;
4335 lua_pushstring(tolua_S, e.what_no_backtrace());
4336 }
4337 catch (std::exception &e) {
4338 exc_caught = true;
4339 lua_pushstring(tolua_S, e.what());
4340 }
4341 if (exc_caught) lua_error(tolua_S);
4342
4343 }
4344 return 1;
4345tolua_lerror:
4346 return tolua_fawkestf_fawkes_tf_Pose_new00_local(tolua_S);
4347}
4348#endif //#ifndef TOLUA_DISABLE
4349
4350/* method: new of class fawkes::tf::Pose */
4351#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new02
4352static int tolua_fawkestf_fawkes_tf_Pose_new02(lua_State* tolua_S)
4353{
4354 tolua_Error tolua_err;
4355 if (
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)
4359 )
4360 goto tolua_lerror;
4361 else
4362 {
4363 const fawkes::tf::Pose* other = ((const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
4364 bool exc_caught = false;
4365 try {
4366 {
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");
4369 }
4370 } catch (fawkes::Exception &e) {
4371 exc_caught = true;
4372 lua_pushstring(tolua_S, e.what_no_backtrace());
4373 }
4374 catch (std::exception &e) {
4375 exc_caught = true;
4376 lua_pushstring(tolua_S, e.what());
4377 }
4378 if (exc_caught) lua_error(tolua_S);
4379
4380 }
4381 return 1;
4382tolua_lerror:
4383 return tolua_fawkestf_fawkes_tf_Pose_new01(tolua_S);
4384}
4385#endif //#ifndef TOLUA_DISABLE
4386
4387/* method: new_local of class fawkes::tf::Pose */
4388#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_new02_local
4389static int tolua_fawkestf_fawkes_tf_Pose_new02_local(lua_State* tolua_S)
4390{
4391 tolua_Error tolua_err;
4392 if (
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)
4396 )
4397 goto tolua_lerror;
4398 else
4399 {
4400 const fawkes::tf::Pose* other = ((const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
4401 bool exc_caught = false;
4402 try {
4403 {
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));
4407 }
4408 } catch (fawkes::Exception &e) {
4409 exc_caught = true;
4410 lua_pushstring(tolua_S, e.what_no_backtrace());
4411 }
4412 catch (std::exception &e) {
4413 exc_caught = true;
4414 lua_pushstring(tolua_S, e.what());
4415 }
4416 if (exc_caught) lua_error(tolua_S);
4417
4418 }
4419 return 1;
4420tolua_lerror:
4421 return tolua_fawkestf_fawkes_tf_Pose_new01_local(tolua_S);
4422}
4423#endif //#ifndef TOLUA_DISABLE
4424
4425/* method: getIdentity of class fawkes::tf::Pose */
4426#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Pose_getIdentity00
4427static int tolua_fawkestf_fawkes_tf_Pose_getIdentity00(lua_State* tolua_S)
4428{
4429#ifndef TOLUA_RELEASE
4430 tolua_Error tolua_err;
4431 if (
4432 !tolua_isusertable(tolua_S,1,"fawkes::tf::Pose",0,&tolua_err) ||
4433 !tolua_isnoobj(tolua_S,2,&tolua_err)
4434 )
4435 goto tolua_lerror;
4436 else
4437#endif
4438 {
4439 bool exc_caught = false;
4440 try {
4441 {
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");
4444 }
4445 } catch (fawkes::Exception &e) {
4446 exc_caught = true;
4447 lua_pushstring(tolua_S, e.what_no_backtrace());
4448 }
4449 catch (std::exception &e) {
4450 exc_caught = true;
4451 lua_pushstring(tolua_S, e.what());
4452 }
4453 if (exc_caught) lua_error(tolua_S);
4454
4455 }
4456 return 1;
4457#ifndef TOLUA_RELEASE
4458 tolua_lerror:
4459 tolua_error(tolua_S,"#ferror in function 'getIdentity'.",&tolua_err);
4460 return 0;
4461#endif
4462}
4463#endif //#ifndef TOLUA_DISABLE
4464
4465/* get function: stamp of class fawkes::tf::StampedTransform */
4466#ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__StampedTransform_stamp
4467static int tolua_get_fawkes__tf__StampedTransform_stamp(lua_State* tolua_S)
4468{
4469 fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,1,0);
4470#ifndef TOLUA_RELEASE
4471 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
4472#endif
4473 tolua_pushusertype(tolua_S,(void*)&self->stamp,"fawkes::Time");
4474 return 1;
4475}
4476#endif //#ifndef TOLUA_DISABLE
4477
4478/* set function: stamp of class fawkes::tf::StampedTransform */
4479#ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__StampedTransform_stamp
4480static int tolua_set_fawkes__tf__StampedTransform_stamp(lua_State* tolua_S)
4481{
4482 fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,1,0);
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);
4488#endif
4489 self->stamp = *((fawkes::Time*) tolua_tousertype(tolua_S,2,0))
4490;
4491 return 0;
4492}
4493#endif //#ifndef TOLUA_DISABLE
4494
4495/* get function: frame_id of class fawkes::tf::StampedTransform */
4496#ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__StampedTransform_frame_id
4497static int tolua_get_fawkes__tf__StampedTransform_frame_id(lua_State* tolua_S)
4498{
4499 fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,1,0);
4500#ifndef TOLUA_RELEASE
4501 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
4502#endif
4503 tolua_pushcppstring(tolua_S,(const char*)self->frame_id);
4504 return 1;
4505}
4506#endif //#ifndef TOLUA_DISABLE
4507
4508/* set function: frame_id of class fawkes::tf::StampedTransform */
4509#ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__StampedTransform_frame_id
4510static int tolua_set_fawkes__tf__StampedTransform_frame_id(lua_State* tolua_S)
4511{
4512 fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,1,0);
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);
4518#endif
4519 self->frame_id = ((std::string) tolua_tocppstring(tolua_S,2,0))
4520;
4521 return 0;
4522}
4523#endif //#ifndef TOLUA_DISABLE
4524
4525/* get function: child_frame_id of class fawkes::tf::StampedTransform */
4526#ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__StampedTransform_child_frame_id
4527static int tolua_get_fawkes__tf__StampedTransform_child_frame_id(lua_State* tolua_S)
4528{
4529 fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,1,0);
4530#ifndef TOLUA_RELEASE
4531 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'child_frame_id'",NULL);
4532#endif
4533 tolua_pushcppstring(tolua_S,(const char*)self->child_frame_id);
4534 return 1;
4535}
4536#endif //#ifndef TOLUA_DISABLE
4537
4538/* set function: child_frame_id of class fawkes::tf::StampedTransform */
4539#ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__StampedTransform_child_frame_id
4540static int tolua_set_fawkes__tf__StampedTransform_child_frame_id(lua_State* tolua_S)
4541{
4542 fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,1,0);
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);
4548#endif
4549 self->child_frame_id = ((std::string) tolua_tocppstring(tolua_S,2,0))
4550;
4551 return 0;
4552}
4553#endif //#ifndef TOLUA_DISABLE
4554
4555/* method: new of class fawkes::tf::StampedTransform */
4556#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_new00
4557static int tolua_fawkestf_fawkes_tf_StampedTransform_new00(lua_State* tolua_S)
4558{
4559#ifndef TOLUA_RELEASE
4560 tolua_Error tolua_err;
4561 if (
4562 !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedTransform",0,&tolua_err) ||
4563 !tolua_isnoobj(tolua_S,2,&tolua_err)
4564 )
4565 goto tolua_lerror;
4566 else
4567#endif
4568 {
4569 bool exc_caught = false;
4570 try {
4571 {
4573 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedTransform");
4574 }
4575 } catch (fawkes::Exception &e) {
4576 exc_caught = true;
4577 lua_pushstring(tolua_S, e.what_no_backtrace());
4578 }
4579 catch (std::exception &e) {
4580 exc_caught = true;
4581 lua_pushstring(tolua_S, e.what());
4582 }
4583 if (exc_caught) lua_error(tolua_S);
4584
4585 }
4586 return 1;
4587#ifndef TOLUA_RELEASE
4588 tolua_lerror:
4589 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4590 return 0;
4591#endif
4592}
4593#endif //#ifndef TOLUA_DISABLE
4594
4595/* method: new_local of class fawkes::tf::StampedTransform */
4596#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_new00_local
4597static int tolua_fawkestf_fawkes_tf_StampedTransform_new00_local(lua_State* tolua_S)
4598{
4599#ifndef TOLUA_RELEASE
4600 tolua_Error tolua_err;
4601 if (
4602 !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedTransform",0,&tolua_err) ||
4603 !tolua_isnoobj(tolua_S,2,&tolua_err)
4604 )
4605 goto tolua_lerror;
4606 else
4607#endif
4608 {
4609 bool exc_caught = false;
4610 try {
4611 {
4613 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::StampedTransform");
4614 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4615 }
4616 } catch (fawkes::Exception &e) {
4617 exc_caught = true;
4618 lua_pushstring(tolua_S, e.what_no_backtrace());
4619 }
4620 catch (std::exception &e) {
4621 exc_caught = true;
4622 lua_pushstring(tolua_S, e.what());
4623 }
4624 if (exc_caught) lua_error(tolua_S);
4625
4626 }
4627 return 1;
4628#ifndef TOLUA_RELEASE
4629 tolua_lerror:
4630 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4631 return 0;
4632#endif
4633}
4634#endif //#ifndef TOLUA_DISABLE
4635
4636/* method: new of class fawkes::tf::StampedTransform */
4637#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_new01
4638static int tolua_fawkestf_fawkes_tf_StampedTransform_new01(lua_State* tolua_S)
4639{
4640 tolua_Error tolua_err;
4641 if (
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)
4648 )
4649 goto tolua_lerror;
4650 else
4651 {
4652 const fawkes::tf::Transform* input = ((const fawkes::tf::Transform*) tolua_tousertype(tolua_S,2,0));
4653 const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,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;
4657 try {
4658 {
4659 fawkes::tf::StampedTransform* tolua_ret = (fawkes::tf::StampedTransform*) Mtolua_new((fawkes::tf::StampedTransform)(*input,*timestamp,frame_id,child_frame_id));
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);
4663 }
4664 } catch (fawkes::Exception &e) {
4665 exc_caught = true;
4666 lua_pushstring(tolua_S, e.what_no_backtrace());
4667 }
4668 catch (std::exception &e) {
4669 exc_caught = true;
4670 lua_pushstring(tolua_S, e.what());
4671 }
4672 if (exc_caught) lua_error(tolua_S);
4673
4674 }
4675 return 3;
4676tolua_lerror:
4677 return tolua_fawkestf_fawkes_tf_StampedTransform_new00(tolua_S);
4678}
4679#endif //#ifndef TOLUA_DISABLE
4680
4681/* method: new_local of class fawkes::tf::StampedTransform */
4682#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_new01_local
4683static int tolua_fawkestf_fawkes_tf_StampedTransform_new01_local(lua_State* tolua_S)
4684{
4685 tolua_Error tolua_err;
4686 if (
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)
4693 )
4694 goto tolua_lerror;
4695 else
4696 {
4697 const fawkes::tf::Transform* input = ((const fawkes::tf::Transform*) tolua_tousertype(tolua_S,2,0));
4698 const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,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;
4702 try {
4703 {
4704 fawkes::tf::StampedTransform* tolua_ret = (fawkes::tf::StampedTransform*) Mtolua_new((fawkes::tf::StampedTransform)(*input,*timestamp,frame_id,child_frame_id));
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);
4709 }
4710 } catch (fawkes::Exception &e) {
4711 exc_caught = true;
4712 lua_pushstring(tolua_S, e.what_no_backtrace());
4713 }
4714 catch (std::exception &e) {
4715 exc_caught = true;
4716 lua_pushstring(tolua_S, e.what());
4717 }
4718 if (exc_caught) lua_error(tolua_S);
4719
4720 }
4721 return 3;
4722tolua_lerror:
4723 return tolua_fawkestf_fawkes_tf_StampedTransform_new00_local(tolua_S);
4724}
4725#endif //#ifndef TOLUA_DISABLE
4726
4727/* method: set_data of class fawkes::tf::StampedTransform */
4728#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedTransform_set_data00
4729static int tolua_fawkestf_fawkes_tf_StampedTransform_set_data00(lua_State* tolua_S)
4730{
4731#ifndef TOLUA_RELEASE
4732 tolua_Error tolua_err;
4733 if (
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)
4737 )
4738 goto tolua_lerror;
4739 else
4740#endif
4741 {
4742 fawkes::tf::StampedTransform* self = (fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,1,0);
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);
4746#endif
4747 bool exc_caught = false;
4748 try {
4749 {
4750 self->set_data(*input);
4751 }
4752 } catch (fawkes::Exception &e) {
4753 exc_caught = true;
4754 lua_pushstring(tolua_S, e.what_no_backtrace());
4755 }
4756 catch (std::exception &e) {
4757 exc_caught = true;
4758 lua_pushstring(tolua_S, e.what());
4759 }
4760 if (exc_caught) lua_error(tolua_S);
4761
4762 }
4763 return 0;
4764#ifndef TOLUA_RELEASE
4765 tolua_lerror:
4766 tolua_error(tolua_S,"#ferror in function 'set_data'.",&tolua_err);
4767 return 0;
4768#endif
4769}
4770#endif //#ifndef TOLUA_DISABLE
4771
4772/* get function: stamp of class fawkes::tf::Stamped<fawkes::tf::Quaternion> */
4773#ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp
4774static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp(lua_State* tolua_S)
4775{
4777#ifndef TOLUA_RELEASE
4778 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
4779#endif
4780 tolua_pushusertype(tolua_S,(void*)&self->stamp,"fawkes::Time");
4781 return 1;
4782}
4783#endif //#ifndef TOLUA_DISABLE
4784
4785/* set function: stamp of class fawkes::tf::Stamped<fawkes::tf::Quaternion> */
4786#ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp
4787static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__stamp(lua_State* tolua_S)
4788{
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);
4795#endif
4796 self->stamp = *((fawkes::Time*) tolua_tousertype(tolua_S,2,0))
4797;
4798 return 0;
4799}
4800#endif //#ifndef TOLUA_DISABLE
4801
4802/* get function: frame_id of class fawkes::tf::Stamped<fawkes::tf::Quaternion> */
4803#ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id
4804static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id(lua_State* tolua_S)
4805{
4807#ifndef TOLUA_RELEASE
4808 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
4809#endif
4810 tolua_pushcppstring(tolua_S,(const char*)self->frame_id);
4811 return 1;
4812}
4813#endif //#ifndef TOLUA_DISABLE
4814
4815/* set function: frame_id of class fawkes::tf::Stamped<fawkes::tf::Quaternion> */
4816#ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id
4817static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Quaternion__frame_id(lua_State* tolua_S)
4818{
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);
4825#endif
4826 self->frame_id = ((std::string) tolua_tocppstring(tolua_S,2,0))
4827;
4828 return 0;
4829}
4830#endif //#ifndef TOLUA_DISABLE
4831
4832/* method: new of class fawkes::tf::Stamped<fawkes::tf::Quaternion> */
4833#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00
4834static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00(lua_State* tolua_S)
4835{
4836#ifndef TOLUA_RELEASE
4837 tolua_Error tolua_err;
4838 if (
4839 !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Quaternion>",0,&tolua_err) ||
4840 !tolua_isnoobj(tolua_S,2,&tolua_err)
4841 )
4842 goto tolua_lerror;
4843 else
4844#endif
4845 {
4846 bool exc_caught = false;
4847 try {
4848 {
4850 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Quaternion>");
4851 }
4852 } catch (fawkes::Exception &e) {
4853 exc_caught = true;
4854 lua_pushstring(tolua_S, e.what_no_backtrace());
4855 }
4856 catch (std::exception &e) {
4857 exc_caught = true;
4858 lua_pushstring(tolua_S, e.what());
4859 }
4860 if (exc_caught) lua_error(tolua_S);
4861
4862 }
4863 return 1;
4864#ifndef TOLUA_RELEASE
4865 tolua_lerror:
4866 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4867 return 0;
4868#endif
4869}
4870#endif //#ifndef TOLUA_DISABLE
4871
4872/* method: new_local of class fawkes::tf::Stamped<fawkes::tf::Quaternion> */
4873#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00_local
4874static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00_local(lua_State* tolua_S)
4875{
4876#ifndef TOLUA_RELEASE
4877 tolua_Error tolua_err;
4878 if (
4879 !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Quaternion>",0,&tolua_err) ||
4880 !tolua_isnoobj(tolua_S,2,&tolua_err)
4881 )
4882 goto tolua_lerror;
4883 else
4884#endif
4885 {
4886 bool exc_caught = false;
4887 try {
4888 {
4890 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Quaternion>");
4891 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4892 }
4893 } catch (fawkes::Exception &e) {
4894 exc_caught = true;
4895 lua_pushstring(tolua_S, e.what_no_backtrace());
4896 }
4897 catch (std::exception &e) {
4898 exc_caught = true;
4899 lua_pushstring(tolua_S, e.what());
4900 }
4901 if (exc_caught) lua_error(tolua_S);
4902
4903 }
4904 return 1;
4905#ifndef TOLUA_RELEASE
4906 tolua_lerror:
4907 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4908 return 0;
4909#endif
4910}
4911#endif //#ifndef TOLUA_DISABLE
4912
4913/* method: new of class fawkes::tf::Stamped<fawkes::tf::Quaternion> */
4914#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01
4915static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01(lua_State* tolua_S)
4916{
4917 tolua_Error tolua_err;
4918 if (
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)
4924 )
4925 goto tolua_lerror;
4926 else
4927 {
4928 const fawkes::tf::Quaternion* input = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
4929 const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
4930 const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
4931 bool exc_caught = false;
4932 try {
4933 {
4935 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Quaternion>");
4936 tolua_pushcppstring(tolua_S,(const char*)frame_id);
4937 }
4938 } catch (fawkes::Exception &e) {
4939 exc_caught = true;
4940 lua_pushstring(tolua_S, e.what_no_backtrace());
4941 }
4942 catch (std::exception &e) {
4943 exc_caught = true;
4944 lua_pushstring(tolua_S, e.what());
4945 }
4946 if (exc_caught) lua_error(tolua_S);
4947
4948 }
4949 return 2;
4950tolua_lerror:
4951 return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00(tolua_S);
4952}
4953#endif //#ifndef TOLUA_DISABLE
4954
4955/* method: new_local of class fawkes::tf::Stamped<fawkes::tf::Quaternion> */
4956#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01_local
4957static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new01_local(lua_State* tolua_S)
4958{
4959 tolua_Error tolua_err;
4960 if (
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)
4966 )
4967 goto tolua_lerror;
4968 else
4969 {
4970 const fawkes::tf::Quaternion* input = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
4971 const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
4972 const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
4973 bool exc_caught = false;
4974 try {
4975 {
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);
4980 }
4981 } catch (fawkes::Exception &e) {
4982 exc_caught = true;
4983 lua_pushstring(tolua_S, e.what_no_backtrace());
4984 }
4985 catch (std::exception &e) {
4986 exc_caught = true;
4987 lua_pushstring(tolua_S, e.what());
4988 }
4989 if (exc_caught) lua_error(tolua_S);
4990
4991 }
4992 return 2;
4993tolua_lerror:
4994 return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__new00_local(tolua_S);
4995}
4996#endif //#ifndef TOLUA_DISABLE
4997
4998/* method: set_data of class fawkes::tf::Stamped<fawkes::tf::Quaternion> */
4999#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__set_data00
5000static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Quaternion__set_data00(lua_State* tolua_S)
5001{
5002#ifndef TOLUA_RELEASE
5003 tolua_Error tolua_err;
5004 if (
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)
5008 )
5009 goto tolua_lerror;
5010 else
5011#endif
5012 {
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);
5017#endif
5018 bool exc_caught = false;
5019 try {
5020 {
5021 self->set_data(*input);
5022 }
5023 } catch (fawkes::Exception &e) {
5024 exc_caught = true;
5025 lua_pushstring(tolua_S, e.what_no_backtrace());
5026 }
5027 catch (std::exception &e) {
5028 exc_caught = true;
5029 lua_pushstring(tolua_S, e.what());
5030 }
5031 if (exc_caught) lua_error(tolua_S);
5032
5033 }
5034 return 0;
5035#ifndef TOLUA_RELEASE
5036 tolua_lerror:
5037 tolua_error(tolua_S,"#ferror in function 'set_data'.",&tolua_err);
5038 return 0;
5039#endif
5040}
5041#endif //#ifndef TOLUA_DISABLE
5042
5043/* get function: stamp of class fawkes::tf::Stamped<fawkes::tf::Vector3> */
5044#ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp
5045static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp(lua_State* tolua_S)
5046{
5048#ifndef TOLUA_RELEASE
5049 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
5050#endif
5051 tolua_pushusertype(tolua_S,(void*)&self->stamp,"fawkes::Time");
5052 return 1;
5053}
5054#endif //#ifndef TOLUA_DISABLE
5055
5056/* set function: stamp of class fawkes::tf::Stamped<fawkes::tf::Vector3> */
5057#ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp
5058static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__stamp(lua_State* tolua_S)
5059{
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);
5066#endif
5067 self->stamp = *((fawkes::Time*) tolua_tousertype(tolua_S,2,0))
5068;
5069 return 0;
5070}
5071#endif //#ifndef TOLUA_DISABLE
5072
5073/* get function: frame_id of class fawkes::tf::Stamped<fawkes::tf::Vector3> */
5074#ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id
5075static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id(lua_State* tolua_S)
5076{
5078#ifndef TOLUA_RELEASE
5079 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
5080#endif
5081 tolua_pushcppstring(tolua_S,(const char*)self->frame_id);
5082 return 1;
5083}
5084#endif //#ifndef TOLUA_DISABLE
5085
5086/* set function: frame_id of class fawkes::tf::Stamped<fawkes::tf::Vector3> */
5087#ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id
5088static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Vector3__frame_id(lua_State* tolua_S)
5089{
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);
5096#endif
5097 self->frame_id = ((std::string) tolua_tocppstring(tolua_S,2,0))
5098;
5099 return 0;
5100}
5101#endif //#ifndef TOLUA_DISABLE
5102
5103/* method: new of class fawkes::tf::Stamped<fawkes::tf::Vector3> */
5104#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00
5105static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00(lua_State* tolua_S)
5106{
5107#ifndef TOLUA_RELEASE
5108 tolua_Error tolua_err;
5109 if (
5110 !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Vector3>",0,&tolua_err) ||
5111 !tolua_isnoobj(tolua_S,2,&tolua_err)
5112 )
5113 goto tolua_lerror;
5114 else
5115#endif
5116 {
5117 bool exc_caught = false;
5118 try {
5119 {
5121 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Vector3>");
5122 }
5123 } catch (fawkes::Exception &e) {
5124 exc_caught = true;
5125 lua_pushstring(tolua_S, e.what_no_backtrace());
5126 }
5127 catch (std::exception &e) {
5128 exc_caught = true;
5129 lua_pushstring(tolua_S, e.what());
5130 }
5131 if (exc_caught) lua_error(tolua_S);
5132
5133 }
5134 return 1;
5135#ifndef TOLUA_RELEASE
5136 tolua_lerror:
5137 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5138 return 0;
5139#endif
5140}
5141#endif //#ifndef TOLUA_DISABLE
5142
5143/* method: new_local of class fawkes::tf::Stamped<fawkes::tf::Vector3> */
5144#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00_local
5145static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00_local(lua_State* tolua_S)
5146{
5147#ifndef TOLUA_RELEASE
5148 tolua_Error tolua_err;
5149 if (
5150 !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Vector3>",0,&tolua_err) ||
5151 !tolua_isnoobj(tolua_S,2,&tolua_err)
5152 )
5153 goto tolua_lerror;
5154 else
5155#endif
5156 {
5157 bool exc_caught = false;
5158 try {
5159 {
5161 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Vector3>");
5162 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5163 }
5164 } catch (fawkes::Exception &e) {
5165 exc_caught = true;
5166 lua_pushstring(tolua_S, e.what_no_backtrace());
5167 }
5168 catch (std::exception &e) {
5169 exc_caught = true;
5170 lua_pushstring(tolua_S, e.what());
5171 }
5172 if (exc_caught) lua_error(tolua_S);
5173
5174 }
5175 return 1;
5176#ifndef TOLUA_RELEASE
5177 tolua_lerror:
5178 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5179 return 0;
5180#endif
5181}
5182#endif //#ifndef TOLUA_DISABLE
5183
5184/* method: new of class fawkes::tf::Stamped<fawkes::tf::Vector3> */
5185#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01
5186static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01(lua_State* tolua_S)
5187{
5188 tolua_Error tolua_err;
5189 if (
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)
5195 )
5196 goto tolua_lerror;
5197 else
5198 {
5199 const fawkes::tf::Vector3* input = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
5200 const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
5201 const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
5202 bool exc_caught = false;
5203 try {
5204 {
5206 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Vector3>");
5207 tolua_pushcppstring(tolua_S,(const char*)frame_id);
5208 }
5209 } catch (fawkes::Exception &e) {
5210 exc_caught = true;
5211 lua_pushstring(tolua_S, e.what_no_backtrace());
5212 }
5213 catch (std::exception &e) {
5214 exc_caught = true;
5215 lua_pushstring(tolua_S, e.what());
5216 }
5217 if (exc_caught) lua_error(tolua_S);
5218
5219 }
5220 return 2;
5221tolua_lerror:
5222 return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00(tolua_S);
5223}
5224#endif //#ifndef TOLUA_DISABLE
5225
5226/* method: new_local of class fawkes::tf::Stamped<fawkes::tf::Vector3> */
5227#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01_local
5228static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new01_local(lua_State* tolua_S)
5229{
5230 tolua_Error tolua_err;
5231 if (
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)
5237 )
5238 goto tolua_lerror;
5239 else
5240 {
5241 const fawkes::tf::Vector3* input = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
5242 const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
5243 const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
5244 bool exc_caught = false;
5245 try {
5246 {
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);
5251 }
5252 } catch (fawkes::Exception &e) {
5253 exc_caught = true;
5254 lua_pushstring(tolua_S, e.what_no_backtrace());
5255 }
5256 catch (std::exception &e) {
5257 exc_caught = true;
5258 lua_pushstring(tolua_S, e.what());
5259 }
5260 if (exc_caught) lua_error(tolua_S);
5261
5262 }
5263 return 2;
5264tolua_lerror:
5265 return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__new00_local(tolua_S);
5266}
5267#endif //#ifndef TOLUA_DISABLE
5268
5269/* method: set_data of class fawkes::tf::Stamped<fawkes::tf::Vector3> */
5270#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__set_data00
5271static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Vector3__set_data00(lua_State* tolua_S)
5272{
5273#ifndef TOLUA_RELEASE
5274 tolua_Error tolua_err;
5275 if (
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)
5279 )
5280 goto tolua_lerror;
5281 else
5282#endif
5283 {
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);
5288#endif
5289 bool exc_caught = false;
5290 try {
5291 {
5292 self->set_data(*input);
5293 }
5294 } catch (fawkes::Exception &e) {
5295 exc_caught = true;
5296 lua_pushstring(tolua_S, e.what_no_backtrace());
5297 }
5298 catch (std::exception &e) {
5299 exc_caught = true;
5300 lua_pushstring(tolua_S, e.what());
5301 }
5302 if (exc_caught) lua_error(tolua_S);
5303
5304 }
5305 return 0;
5306#ifndef TOLUA_RELEASE
5307 tolua_lerror:
5308 tolua_error(tolua_S,"#ferror in function 'set_data'.",&tolua_err);
5309 return 0;
5310#endif
5311}
5312#endif //#ifndef TOLUA_DISABLE
5313
5314/* get function: stamp of class fawkes::tf::Stamped<fawkes::tf::Point> */
5315#ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__stamp
5316static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__stamp(lua_State* tolua_S)
5317{
5319#ifndef TOLUA_RELEASE
5320 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
5321#endif
5322 tolua_pushusertype(tolua_S,(void*)&self->stamp,"fawkes::Time");
5323 return 1;
5324}
5325#endif //#ifndef TOLUA_DISABLE
5326
5327/* set function: stamp of class fawkes::tf::Stamped<fawkes::tf::Point> */
5328#ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__stamp
5329static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__stamp(lua_State* tolua_S)
5330{
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);
5337#endif
5338 self->stamp = *((fawkes::Time*) tolua_tousertype(tolua_S,2,0))
5339;
5340 return 0;
5341}
5342#endif //#ifndef TOLUA_DISABLE
5343
5344/* get function: frame_id of class fawkes::tf::Stamped<fawkes::tf::Point> */
5345#ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__frame_id
5346static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Point__frame_id(lua_State* tolua_S)
5347{
5349#ifndef TOLUA_RELEASE
5350 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
5351#endif
5352 tolua_pushcppstring(tolua_S,(const char*)self->frame_id);
5353 return 1;
5354}
5355#endif //#ifndef TOLUA_DISABLE
5356
5357/* set function: frame_id of class fawkes::tf::Stamped<fawkes::tf::Point> */
5358#ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__frame_id
5359static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Point__frame_id(lua_State* tolua_S)
5360{
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);
5367#endif
5368 self->frame_id = ((std::string) tolua_tocppstring(tolua_S,2,0))
5369;
5370 return 0;
5371}
5372#endif //#ifndef TOLUA_DISABLE
5373
5374/* method: new of class fawkes::tf::Stamped<fawkes::tf::Point> */
5375#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00
5376static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00(lua_State* tolua_S)
5377{
5378#ifndef TOLUA_RELEASE
5379 tolua_Error tolua_err;
5380 if (
5381 !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Point>",0,&tolua_err) ||
5382 !tolua_isnoobj(tolua_S,2,&tolua_err)
5383 )
5384 goto tolua_lerror;
5385 else
5386#endif
5387 {
5388 bool exc_caught = false;
5389 try {
5390 {
5392 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Point>");
5393 }
5394 } catch (fawkes::Exception &e) {
5395 exc_caught = true;
5396 lua_pushstring(tolua_S, e.what_no_backtrace());
5397 }
5398 catch (std::exception &e) {
5399 exc_caught = true;
5400 lua_pushstring(tolua_S, e.what());
5401 }
5402 if (exc_caught) lua_error(tolua_S);
5403
5404 }
5405 return 1;
5406#ifndef TOLUA_RELEASE
5407 tolua_lerror:
5408 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5409 return 0;
5410#endif
5411}
5412#endif //#ifndef TOLUA_DISABLE
5413
5414/* method: new_local of class fawkes::tf::Stamped<fawkes::tf::Point> */
5415#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00_local
5416static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00_local(lua_State* tolua_S)
5417{
5418#ifndef TOLUA_RELEASE
5419 tolua_Error tolua_err;
5420 if (
5421 !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Point>",0,&tolua_err) ||
5422 !tolua_isnoobj(tolua_S,2,&tolua_err)
5423 )
5424 goto tolua_lerror;
5425 else
5426#endif
5427 {
5428 bool exc_caught = false;
5429 try {
5430 {
5432 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Point>");
5433 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5434 }
5435 } catch (fawkes::Exception &e) {
5436 exc_caught = true;
5437 lua_pushstring(tolua_S, e.what_no_backtrace());
5438 }
5439 catch (std::exception &e) {
5440 exc_caught = true;
5441 lua_pushstring(tolua_S, e.what());
5442 }
5443 if (exc_caught) lua_error(tolua_S);
5444
5445 }
5446 return 1;
5447#ifndef TOLUA_RELEASE
5448 tolua_lerror:
5449 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5450 return 0;
5451#endif
5452}
5453#endif //#ifndef TOLUA_DISABLE
5454
5455/* method: new of class fawkes::tf::Stamped<fawkes::tf::Point> */
5456#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01
5457static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01(lua_State* tolua_S)
5458{
5459 tolua_Error tolua_err;
5460 if (
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)
5466 )
5467 goto tolua_lerror;
5468 else
5469 {
5470 const fawkes::tf::Point* input = ((const fawkes::tf::Point*) tolua_tousertype(tolua_S,2,0));
5471 const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
5472 const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
5473 bool exc_caught = false;
5474 try {
5475 {
5477 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Point>");
5478 tolua_pushcppstring(tolua_S,(const char*)frame_id);
5479 }
5480 } catch (fawkes::Exception &e) {
5481 exc_caught = true;
5482 lua_pushstring(tolua_S, e.what_no_backtrace());
5483 }
5484 catch (std::exception &e) {
5485 exc_caught = true;
5486 lua_pushstring(tolua_S, e.what());
5487 }
5488 if (exc_caught) lua_error(tolua_S);
5489
5490 }
5491 return 2;
5492tolua_lerror:
5493 return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00(tolua_S);
5494}
5495#endif //#ifndef TOLUA_DISABLE
5496
5497/* method: new_local of class fawkes::tf::Stamped<fawkes::tf::Point> */
5498#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01_local
5499static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new01_local(lua_State* tolua_S)
5500{
5501 tolua_Error tolua_err;
5502 if (
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)
5508 )
5509 goto tolua_lerror;
5510 else
5511 {
5512 const fawkes::tf::Point* input = ((const fawkes::tf::Point*) tolua_tousertype(tolua_S,2,0));
5513 const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
5514 const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
5515 bool exc_caught = false;
5516 try {
5517 {
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);
5522 }
5523 } catch (fawkes::Exception &e) {
5524 exc_caught = true;
5525 lua_pushstring(tolua_S, e.what_no_backtrace());
5526 }
5527 catch (std::exception &e) {
5528 exc_caught = true;
5529 lua_pushstring(tolua_S, e.what());
5530 }
5531 if (exc_caught) lua_error(tolua_S);
5532
5533 }
5534 return 2;
5535tolua_lerror:
5536 return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__new00_local(tolua_S);
5537}
5538#endif //#ifndef TOLUA_DISABLE
5539
5540/* method: set_data of class fawkes::tf::Stamped<fawkes::tf::Point> */
5541#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__set_data00
5542static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Point__set_data00(lua_State* tolua_S)
5543{
5544#ifndef TOLUA_RELEASE
5545 tolua_Error tolua_err;
5546 if (
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)
5550 )
5551 goto tolua_lerror;
5552 else
5553#endif
5554 {
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);
5559#endif
5560 bool exc_caught = false;
5561 try {
5562 {
5563 self->set_data(*input);
5564 }
5565 } catch (fawkes::Exception &e) {
5566 exc_caught = true;
5567 lua_pushstring(tolua_S, e.what_no_backtrace());
5568 }
5569 catch (std::exception &e) {
5570 exc_caught = true;
5571 lua_pushstring(tolua_S, e.what());
5572 }
5573 if (exc_caught) lua_error(tolua_S);
5574
5575 }
5576 return 0;
5577#ifndef TOLUA_RELEASE
5578 tolua_lerror:
5579 tolua_error(tolua_S,"#ferror in function 'set_data'.",&tolua_err);
5580 return 0;
5581#endif
5582}
5583#endif //#ifndef TOLUA_DISABLE
5584
5585/* get function: stamp of class fawkes::tf::Stamped<fawkes::tf::Pose> */
5586#ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__stamp
5587static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__stamp(lua_State* tolua_S)
5588{
5590#ifndef TOLUA_RELEASE
5591 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stamp'",NULL);
5592#endif
5593 tolua_pushusertype(tolua_S,(void*)&self->stamp,"fawkes::Time");
5594 return 1;
5595}
5596#endif //#ifndef TOLUA_DISABLE
5597
5598/* set function: stamp of class fawkes::tf::Stamped<fawkes::tf::Pose> */
5599#ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__stamp
5600static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__stamp(lua_State* tolua_S)
5601{
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);
5608#endif
5609 self->stamp = *((fawkes::Time*) tolua_tousertype(tolua_S,2,0))
5610;
5611 return 0;
5612}
5613#endif //#ifndef TOLUA_DISABLE
5614
5615/* get function: frame_id of class fawkes::tf::Stamped<fawkes::tf::Pose> */
5616#ifndef TOLUA_DISABLE_tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id
5617static int tolua_get_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id(lua_State* tolua_S)
5618{
5620#ifndef TOLUA_RELEASE
5621 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'frame_id'",NULL);
5622#endif
5623 tolua_pushcppstring(tolua_S,(const char*)self->frame_id);
5624 return 1;
5625}
5626#endif //#ifndef TOLUA_DISABLE
5627
5628/* set function: frame_id of class fawkes::tf::Stamped<fawkes::tf::Pose> */
5629#ifndef TOLUA_DISABLE_tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id
5630static int tolua_set_fawkes__tf__Stamped_fawkes__tf__Pose__frame_id(lua_State* tolua_S)
5631{
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);
5638#endif
5639 self->frame_id = ((std::string) tolua_tocppstring(tolua_S,2,0))
5640;
5641 return 0;
5642}
5643#endif //#ifndef TOLUA_DISABLE
5644
5645/* method: new of class fawkes::tf::Stamped<fawkes::tf::Pose> */
5646#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00
5647static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00(lua_State* tolua_S)
5648{
5649#ifndef TOLUA_RELEASE
5650 tolua_Error tolua_err;
5651 if (
5652 !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Pose>",0,&tolua_err) ||
5653 !tolua_isnoobj(tolua_S,2,&tolua_err)
5654 )
5655 goto tolua_lerror;
5656 else
5657#endif
5658 {
5659 bool exc_caught = false;
5660 try {
5661 {
5663 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Pose>");
5664 }
5665 } catch (fawkes::Exception &e) {
5666 exc_caught = true;
5667 lua_pushstring(tolua_S, e.what_no_backtrace());
5668 }
5669 catch (std::exception &e) {
5670 exc_caught = true;
5671 lua_pushstring(tolua_S, e.what());
5672 }
5673 if (exc_caught) lua_error(tolua_S);
5674
5675 }
5676 return 1;
5677#ifndef TOLUA_RELEASE
5678 tolua_lerror:
5679 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5680 return 0;
5681#endif
5682}
5683#endif //#ifndef TOLUA_DISABLE
5684
5685/* method: new_local of class fawkes::tf::Stamped<fawkes::tf::Pose> */
5686#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00_local
5687static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00_local(lua_State* tolua_S)
5688{
5689#ifndef TOLUA_RELEASE
5690 tolua_Error tolua_err;
5691 if (
5692 !tolua_isusertable(tolua_S,1,"fawkes::tf::Stamped<fawkes::tf::Pose>",0,&tolua_err) ||
5693 !tolua_isnoobj(tolua_S,2,&tolua_err)
5694 )
5695 goto tolua_lerror;
5696 else
5697#endif
5698 {
5699 bool exc_caught = false;
5700 try {
5701 {
5703 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Pose>");
5704 tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5705 }
5706 } catch (fawkes::Exception &e) {
5707 exc_caught = true;
5708 lua_pushstring(tolua_S, e.what_no_backtrace());
5709 }
5710 catch (std::exception &e) {
5711 exc_caught = true;
5712 lua_pushstring(tolua_S, e.what());
5713 }
5714 if (exc_caught) lua_error(tolua_S);
5715
5716 }
5717 return 1;
5718#ifndef TOLUA_RELEASE
5719 tolua_lerror:
5720 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5721 return 0;
5722#endif
5723}
5724#endif //#ifndef TOLUA_DISABLE
5725
5726/* method: new of class fawkes::tf::Stamped<fawkes::tf::Pose> */
5727#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01
5728static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01(lua_State* tolua_S)
5729{
5730 tolua_Error tolua_err;
5731 if (
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)
5737 )
5738 goto tolua_lerror;
5739 else
5740 {
5741 const fawkes::tf::Pose* input = ((const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
5742 const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
5743 const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
5744 bool exc_caught = false;
5745 try {
5746 {
5748 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::tf::Stamped<fawkes::tf::Pose>");
5749 tolua_pushcppstring(tolua_S,(const char*)frame_id);
5750 }
5751 } catch (fawkes::Exception &e) {
5752 exc_caught = true;
5753 lua_pushstring(tolua_S, e.what_no_backtrace());
5754 }
5755 catch (std::exception &e) {
5756 exc_caught = true;
5757 lua_pushstring(tolua_S, e.what());
5758 }
5759 if (exc_caught) lua_error(tolua_S);
5760
5761 }
5762 return 2;
5763tolua_lerror:
5764 return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00(tolua_S);
5765}
5766#endif //#ifndef TOLUA_DISABLE
5767
5768/* method: new_local of class fawkes::tf::Stamped<fawkes::tf::Pose> */
5769#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01_local
5770static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new01_local(lua_State* tolua_S)
5771{
5772 tolua_Error tolua_err;
5773 if (
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)
5779 )
5780 goto tolua_lerror;
5781 else
5782 {
5783 const fawkes::tf::Pose* input = ((const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
5784 const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
5785 const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
5786 bool exc_caught = false;
5787 try {
5788 {
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);
5793 }
5794 } catch (fawkes::Exception &e) {
5795 exc_caught = true;
5796 lua_pushstring(tolua_S, e.what_no_backtrace());
5797 }
5798 catch (std::exception &e) {
5799 exc_caught = true;
5800 lua_pushstring(tolua_S, e.what());
5801 }
5802 if (exc_caught) lua_error(tolua_S);
5803
5804 }
5805 return 2;
5806tolua_lerror:
5807 return tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__new00_local(tolua_S);
5808}
5809#endif //#ifndef TOLUA_DISABLE
5810
5811/* method: set_data of class fawkes::tf::Stamped<fawkes::tf::Pose> */
5812#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__set_data00
5813static int tolua_fawkestf_fawkes_tf_Stamped_fawkes__tf__Pose__set_data00(lua_State* tolua_S)
5814{
5815#ifndef TOLUA_RELEASE
5816 tolua_Error tolua_err;
5817 if (
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)
5821 )
5822 goto tolua_lerror;
5823 else
5824#endif
5825 {
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);
5830#endif
5831 bool exc_caught = false;
5832 try {
5833 {
5834 self->set_data(*input);
5835 }
5836 } catch (fawkes::Exception &e) {
5837 exc_caught = true;
5838 lua_pushstring(tolua_S, e.what_no_backtrace());
5839 }
5840 catch (std::exception &e) {
5841 exc_caught = true;
5842 lua_pushstring(tolua_S, e.what());
5843 }
5844 if (exc_caught) lua_error(tolua_S);
5845
5846 }
5847 return 0;
5848#ifndef TOLUA_RELEASE
5849 tolua_lerror:
5850 tolua_error(tolua_S,"#ferror in function 'set_data'.",&tolua_err);
5851 return 0;
5852#endif
5853}
5854#endif //#ifndef TOLUA_DISABLE
5855
5856/* method: new of class fawkes::tf::StampedQuaternion */
5857#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedQuaternion_new00
5858static int tolua_fawkestf_fawkes_tf_StampedQuaternion_new00(lua_State* tolua_S)
5859{
5860#ifndef TOLUA_RELEASE
5861 tolua_Error tolua_err;
5862 if (
5863 !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedQuaternion",0,&tolua_err) ||
5864 !tolua_isnoobj(tolua_S,2,&tolua_err)
5865 )
5866 goto tolua_lerror;
5867 else
5868#endif
5869 {
5870 bool exc_caught = false;
5871 try {
5872 {
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");
5875 }
5876 } catch (fawkes::Exception &e) {
5877 exc_caught = true;
5878 lua_pushstring(tolua_S, e.what_no_backtrace());
5879 }
5880 catch (std::exception &e) {
5881 exc_caught = true;
5882 lua_pushstring(tolua_S, e.what());
5883 }
5884 if (exc_caught) lua_error(tolua_S);
5885
5886 }
5887 return 1;
5888#ifndef TOLUA_RELEASE
5889 tolua_lerror:
5890 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5891 return 0;
5892#endif
5893}
5894#endif //#ifndef TOLUA_DISABLE
5895
5896/* method: new_local of class fawkes::tf::StampedQuaternion */
5897#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedQuaternion_new00_local
5898static int tolua_fawkestf_fawkes_tf_StampedQuaternion_new00_local(lua_State* tolua_S)
5899{
5900#ifndef TOLUA_RELEASE
5901 tolua_Error tolua_err;
5902 if (
5903 !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedQuaternion",0,&tolua_err) ||
5904 !tolua_isnoobj(tolua_S,2,&tolua_err)
5905 )
5906 goto tolua_lerror;
5907 else
5908#endif
5909 {
5910 bool exc_caught = false;
5911 try {
5912 {
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));
5916 }
5917 } catch (fawkes::Exception &e) {
5918 exc_caught = true;
5919 lua_pushstring(tolua_S, e.what_no_backtrace());
5920 }
5921 catch (std::exception &e) {
5922 exc_caught = true;
5923 lua_pushstring(tolua_S, e.what());
5924 }
5925 if (exc_caught) lua_error(tolua_S);
5926
5927 }
5928 return 1;
5929#ifndef TOLUA_RELEASE
5930 tolua_lerror:
5931 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5932 return 0;
5933#endif
5934}
5935#endif //#ifndef TOLUA_DISABLE
5936
5937/* method: new of class fawkes::tf::StampedQuaternion */
5938#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedQuaternion_new01
5939static int tolua_fawkestf_fawkes_tf_StampedQuaternion_new01(lua_State* tolua_S)
5940{
5941 tolua_Error tolua_err;
5942 if (
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)
5948 )
5949 goto tolua_lerror;
5950 else
5951 {
5952 const fawkes::tf::Quaternion* input = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
5953 const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
5954 const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
5955 bool exc_caught = false;
5956 try {
5957 {
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);
5961 }
5962 } catch (fawkes::Exception &e) {
5963 exc_caught = true;
5964 lua_pushstring(tolua_S, e.what_no_backtrace());
5965 }
5966 catch (std::exception &e) {
5967 exc_caught = true;
5968 lua_pushstring(tolua_S, e.what());
5969 }
5970 if (exc_caught) lua_error(tolua_S);
5971
5972 }
5973 return 2;
5974tolua_lerror:
5975 return tolua_fawkestf_fawkes_tf_StampedQuaternion_new00(tolua_S);
5976}
5977#endif //#ifndef TOLUA_DISABLE
5978
5979/* method: new_local of class fawkes::tf::StampedQuaternion */
5980#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedQuaternion_new01_local
5981static int tolua_fawkestf_fawkes_tf_StampedQuaternion_new01_local(lua_State* tolua_S)
5982{
5983 tolua_Error tolua_err;
5984 if (
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)
5990 )
5991 goto tolua_lerror;
5992 else
5993 {
5994 const fawkes::tf::Quaternion* input = ((const fawkes::tf::Quaternion*) tolua_tousertype(tolua_S,2,0));
5995 const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
5996 const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
5997 bool exc_caught = false;
5998 try {
5999 {
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);
6004 }
6005 } catch (fawkes::Exception &e) {
6006 exc_caught = true;
6007 lua_pushstring(tolua_S, e.what_no_backtrace());
6008 }
6009 catch (std::exception &e) {
6010 exc_caught = true;
6011 lua_pushstring(tolua_S, e.what());
6012 }
6013 if (exc_caught) lua_error(tolua_S);
6014
6015 }
6016 return 2;
6017tolua_lerror:
6018 return tolua_fawkestf_fawkes_tf_StampedQuaternion_new00_local(tolua_S);
6019}
6020#endif //#ifndef TOLUA_DISABLE
6021
6022/* method: new of class fawkes::tf::StampedVector3 */
6023#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedVector3_new00
6024static int tolua_fawkestf_fawkes_tf_StampedVector3_new00(lua_State* tolua_S)
6025{
6026#ifndef TOLUA_RELEASE
6027 tolua_Error tolua_err;
6028 if (
6029 !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedVector3",0,&tolua_err) ||
6030 !tolua_isnoobj(tolua_S,2,&tolua_err)
6031 )
6032 goto tolua_lerror;
6033 else
6034#endif
6035 {
6036 bool exc_caught = false;
6037 try {
6038 {
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");
6041 }
6042 } catch (fawkes::Exception &e) {
6043 exc_caught = true;
6044 lua_pushstring(tolua_S, e.what_no_backtrace());
6045 }
6046 catch (std::exception &e) {
6047 exc_caught = true;
6048 lua_pushstring(tolua_S, e.what());
6049 }
6050 if (exc_caught) lua_error(tolua_S);
6051
6052 }
6053 return 1;
6054#ifndef TOLUA_RELEASE
6055 tolua_lerror:
6056 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6057 return 0;
6058#endif
6059}
6060#endif //#ifndef TOLUA_DISABLE
6061
6062/* method: new_local of class fawkes::tf::StampedVector3 */
6063#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedVector3_new00_local
6064static int tolua_fawkestf_fawkes_tf_StampedVector3_new00_local(lua_State* tolua_S)
6065{
6066#ifndef TOLUA_RELEASE
6067 tolua_Error tolua_err;
6068 if (
6069 !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedVector3",0,&tolua_err) ||
6070 !tolua_isnoobj(tolua_S,2,&tolua_err)
6071 )
6072 goto tolua_lerror;
6073 else
6074#endif
6075 {
6076 bool exc_caught = false;
6077 try {
6078 {
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));
6082 }
6083 } catch (fawkes::Exception &e) {
6084 exc_caught = true;
6085 lua_pushstring(tolua_S, e.what_no_backtrace());
6086 }
6087 catch (std::exception &e) {
6088 exc_caught = true;
6089 lua_pushstring(tolua_S, e.what());
6090 }
6091 if (exc_caught) lua_error(tolua_S);
6092
6093 }
6094 return 1;
6095#ifndef TOLUA_RELEASE
6096 tolua_lerror:
6097 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6098 return 0;
6099#endif
6100}
6101#endif //#ifndef TOLUA_DISABLE
6102
6103/* method: new of class fawkes::tf::StampedVector3 */
6104#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedVector3_new01
6105static int tolua_fawkestf_fawkes_tf_StampedVector3_new01(lua_State* tolua_S)
6106{
6107 tolua_Error tolua_err;
6108 if (
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)
6114 )
6115 goto tolua_lerror;
6116 else
6117 {
6118 const fawkes::tf::Vector3* input = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
6119 const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
6120 const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
6121 bool exc_caught = false;
6122 try {
6123 {
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);
6127 }
6128 } catch (fawkes::Exception &e) {
6129 exc_caught = true;
6130 lua_pushstring(tolua_S, e.what_no_backtrace());
6131 }
6132 catch (std::exception &e) {
6133 exc_caught = true;
6134 lua_pushstring(tolua_S, e.what());
6135 }
6136 if (exc_caught) lua_error(tolua_S);
6137
6138 }
6139 return 2;
6140tolua_lerror:
6141 return tolua_fawkestf_fawkes_tf_StampedVector3_new00(tolua_S);
6142}
6143#endif //#ifndef TOLUA_DISABLE
6144
6145/* method: new_local of class fawkes::tf::StampedVector3 */
6146#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedVector3_new01_local
6147static int tolua_fawkestf_fawkes_tf_StampedVector3_new01_local(lua_State* tolua_S)
6148{
6149 tolua_Error tolua_err;
6150 if (
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)
6156 )
6157 goto tolua_lerror;
6158 else
6159 {
6160 const fawkes::tf::Vector3* input = ((const fawkes::tf::Vector3*) tolua_tousertype(tolua_S,2,0));
6161 const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
6162 const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
6163 bool exc_caught = false;
6164 try {
6165 {
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);
6170 }
6171 } catch (fawkes::Exception &e) {
6172 exc_caught = true;
6173 lua_pushstring(tolua_S, e.what_no_backtrace());
6174 }
6175 catch (std::exception &e) {
6176 exc_caught = true;
6177 lua_pushstring(tolua_S, e.what());
6178 }
6179 if (exc_caught) lua_error(tolua_S);
6180
6181 }
6182 return 2;
6183tolua_lerror:
6184 return tolua_fawkestf_fawkes_tf_StampedVector3_new00_local(tolua_S);
6185}
6186#endif //#ifndef TOLUA_DISABLE
6187
6188/* method: new of class fawkes::tf::StampedPoint */
6189#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPoint_new00
6190static int tolua_fawkestf_fawkes_tf_StampedPoint_new00(lua_State* tolua_S)
6191{
6192#ifndef TOLUA_RELEASE
6193 tolua_Error tolua_err;
6194 if (
6195 !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPoint",0,&tolua_err) ||
6196 !tolua_isnoobj(tolua_S,2,&tolua_err)
6197 )
6198 goto tolua_lerror;
6199 else
6200#endif
6201 {
6202 bool exc_caught = false;
6203 try {
6204 {
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");
6207 }
6208 } catch (fawkes::Exception &e) {
6209 exc_caught = true;
6210 lua_pushstring(tolua_S, e.what_no_backtrace());
6211 }
6212 catch (std::exception &e) {
6213 exc_caught = true;
6214 lua_pushstring(tolua_S, e.what());
6215 }
6216 if (exc_caught) lua_error(tolua_S);
6217
6218 }
6219 return 1;
6220#ifndef TOLUA_RELEASE
6221 tolua_lerror:
6222 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6223 return 0;
6224#endif
6225}
6226#endif //#ifndef TOLUA_DISABLE
6227
6228/* method: new_local of class fawkes::tf::StampedPoint */
6229#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPoint_new00_local
6230static int tolua_fawkestf_fawkes_tf_StampedPoint_new00_local(lua_State* tolua_S)
6231{
6232#ifndef TOLUA_RELEASE
6233 tolua_Error tolua_err;
6234 if (
6235 !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPoint",0,&tolua_err) ||
6236 !tolua_isnoobj(tolua_S,2,&tolua_err)
6237 )
6238 goto tolua_lerror;
6239 else
6240#endif
6241 {
6242 bool exc_caught = false;
6243 try {
6244 {
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));
6248 }
6249 } catch (fawkes::Exception &e) {
6250 exc_caught = true;
6251 lua_pushstring(tolua_S, e.what_no_backtrace());
6252 }
6253 catch (std::exception &e) {
6254 exc_caught = true;
6255 lua_pushstring(tolua_S, e.what());
6256 }
6257 if (exc_caught) lua_error(tolua_S);
6258
6259 }
6260 return 1;
6261#ifndef TOLUA_RELEASE
6262 tolua_lerror:
6263 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6264 return 0;
6265#endif
6266}
6267#endif //#ifndef TOLUA_DISABLE
6268
6269/* method: new of class fawkes::tf::StampedPoint */
6270#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPoint_new01
6271static int tolua_fawkestf_fawkes_tf_StampedPoint_new01(lua_State* tolua_S)
6272{
6273 tolua_Error tolua_err;
6274 if (
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)
6280 )
6281 goto tolua_lerror;
6282 else
6283 {
6284 const fawkes::tf::Point* input = ((const fawkes::tf::Point*) tolua_tousertype(tolua_S,2,0));
6285 const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
6286 const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
6287 bool exc_caught = false;
6288 try {
6289 {
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);
6293 }
6294 } catch (fawkes::Exception &e) {
6295 exc_caught = true;
6296 lua_pushstring(tolua_S, e.what_no_backtrace());
6297 }
6298 catch (std::exception &e) {
6299 exc_caught = true;
6300 lua_pushstring(tolua_S, e.what());
6301 }
6302 if (exc_caught) lua_error(tolua_S);
6303
6304 }
6305 return 2;
6306tolua_lerror:
6307 return tolua_fawkestf_fawkes_tf_StampedPoint_new00(tolua_S);
6308}
6309#endif //#ifndef TOLUA_DISABLE
6310
6311/* method: new_local of class fawkes::tf::StampedPoint */
6312#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPoint_new01_local
6313static int tolua_fawkestf_fawkes_tf_StampedPoint_new01_local(lua_State* tolua_S)
6314{
6315 tolua_Error tolua_err;
6316 if (
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)
6322 )
6323 goto tolua_lerror;
6324 else
6325 {
6326 const fawkes::tf::Point* input = ((const fawkes::tf::Point*) tolua_tousertype(tolua_S,2,0));
6327 const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
6328 const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
6329 bool exc_caught = false;
6330 try {
6331 {
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);
6336 }
6337 } catch (fawkes::Exception &e) {
6338 exc_caught = true;
6339 lua_pushstring(tolua_S, e.what_no_backtrace());
6340 }
6341 catch (std::exception &e) {
6342 exc_caught = true;
6343 lua_pushstring(tolua_S, e.what());
6344 }
6345 if (exc_caught) lua_error(tolua_S);
6346
6347 }
6348 return 2;
6349tolua_lerror:
6350 return tolua_fawkestf_fawkes_tf_StampedPoint_new00_local(tolua_S);
6351}
6352#endif //#ifndef TOLUA_DISABLE
6353
6354/* method: new of class fawkes::tf::StampedPose */
6355#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPose_new00
6356static int tolua_fawkestf_fawkes_tf_StampedPose_new00(lua_State* tolua_S)
6357{
6358#ifndef TOLUA_RELEASE
6359 tolua_Error tolua_err;
6360 if (
6361 !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPose",0,&tolua_err) ||
6362 !tolua_isnoobj(tolua_S,2,&tolua_err)
6363 )
6364 goto tolua_lerror;
6365 else
6366#endif
6367 {
6368 bool exc_caught = false;
6369 try {
6370 {
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");
6373 }
6374 } catch (fawkes::Exception &e) {
6375 exc_caught = true;
6376 lua_pushstring(tolua_S, e.what_no_backtrace());
6377 }
6378 catch (std::exception &e) {
6379 exc_caught = true;
6380 lua_pushstring(tolua_S, e.what());
6381 }
6382 if (exc_caught) lua_error(tolua_S);
6383
6384 }
6385 return 1;
6386#ifndef TOLUA_RELEASE
6387 tolua_lerror:
6388 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6389 return 0;
6390#endif
6391}
6392#endif //#ifndef TOLUA_DISABLE
6393
6394/* method: new_local of class fawkes::tf::StampedPose */
6395#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPose_new00_local
6396static int tolua_fawkestf_fawkes_tf_StampedPose_new00_local(lua_State* tolua_S)
6397{
6398#ifndef TOLUA_RELEASE
6399 tolua_Error tolua_err;
6400 if (
6401 !tolua_isusertable(tolua_S,1,"fawkes::tf::StampedPose",0,&tolua_err) ||
6402 !tolua_isnoobj(tolua_S,2,&tolua_err)
6403 )
6404 goto tolua_lerror;
6405 else
6406#endif
6407 {
6408 bool exc_caught = false;
6409 try {
6410 {
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));
6414 }
6415 } catch (fawkes::Exception &e) {
6416 exc_caught = true;
6417 lua_pushstring(tolua_S, e.what_no_backtrace());
6418 }
6419 catch (std::exception &e) {
6420 exc_caught = true;
6421 lua_pushstring(tolua_S, e.what());
6422 }
6423 if (exc_caught) lua_error(tolua_S);
6424
6425 }
6426 return 1;
6427#ifndef TOLUA_RELEASE
6428 tolua_lerror:
6429 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6430 return 0;
6431#endif
6432}
6433#endif //#ifndef TOLUA_DISABLE
6434
6435/* method: new of class fawkes::tf::StampedPose */
6436#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPose_new01
6437static int tolua_fawkestf_fawkes_tf_StampedPose_new01(lua_State* tolua_S)
6438{
6439 tolua_Error tolua_err;
6440 if (
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)
6446 )
6447 goto tolua_lerror;
6448 else
6449 {
6450 const fawkes::tf::Pose* input = ((const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
6451 const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
6452 const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
6453 bool exc_caught = false;
6454 try {
6455 {
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);
6459 }
6460 } catch (fawkes::Exception &e) {
6461 exc_caught = true;
6462 lua_pushstring(tolua_S, e.what_no_backtrace());
6463 }
6464 catch (std::exception &e) {
6465 exc_caught = true;
6466 lua_pushstring(tolua_S, e.what());
6467 }
6468 if (exc_caught) lua_error(tolua_S);
6469
6470 }
6471 return 2;
6472tolua_lerror:
6473 return tolua_fawkestf_fawkes_tf_StampedPose_new00(tolua_S);
6474}
6475#endif //#ifndef TOLUA_DISABLE
6476
6477/* method: new_local of class fawkes::tf::StampedPose */
6478#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_StampedPose_new01_local
6479static int tolua_fawkestf_fawkes_tf_StampedPose_new01_local(lua_State* tolua_S)
6480{
6481 tolua_Error tolua_err;
6482 if (
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)
6488 )
6489 goto tolua_lerror;
6490 else
6491 {
6492 const fawkes::tf::Pose* input = ((const fawkes::tf::Pose*) tolua_tousertype(tolua_S,2,0));
6493 const fawkes::Time* timestamp = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
6494 const std::string frame_id = ((const std::string) tolua_tocppstring(tolua_S,4,0));
6495 bool exc_caught = false;
6496 try {
6497 {
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);
6502 }
6503 } catch (fawkes::Exception &e) {
6504 exc_caught = true;
6505 lua_pushstring(tolua_S, e.what_no_backtrace());
6506 }
6507 catch (std::exception &e) {
6508 exc_caught = true;
6509 lua_pushstring(tolua_S, e.what());
6510 }
6511 if (exc_caught) lua_error(tolua_S);
6512
6513 }
6514 return 2;
6515tolua_lerror:
6516 return tolua_fawkestf_fawkes_tf_StampedPose_new00_local(tolua_S);
6517}
6518#endif //#ifndef TOLUA_DISABLE
6519
6520/* method: clear of class fawkes::tf::Transformer */
6521#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_clear00
6522static int tolua_fawkestf_fawkes_tf_Transformer_clear00(lua_State* tolua_S)
6523{
6524#ifndef TOLUA_RELEASE
6525 tolua_Error tolua_err;
6526 if (
6527 !tolua_isusertype(tolua_S,1,"fawkes::tf::Transformer",0,&tolua_err) ||
6528 !tolua_isnoobj(tolua_S,2,&tolua_err)
6529 )
6530 goto tolua_lerror;
6531 else
6532#endif
6533 {
6534 fawkes::tf::Transformer* self = (fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
6535#ifndef TOLUA_RELEASE
6536 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
6537#endif
6538 bool exc_caught = false;
6539 try {
6540 {
6541 self->clear();
6542 }
6543 } catch (fawkes::Exception &e) {
6544 exc_caught = true;
6545 lua_pushstring(tolua_S, e.what_no_backtrace());
6546 }
6547 catch (std::exception &e) {
6548 exc_caught = true;
6549 lua_pushstring(tolua_S, e.what());
6550 }
6551 if (exc_caught) lua_error(tolua_S);
6552
6553 }
6554 return 0;
6555#ifndef TOLUA_RELEASE
6556 tolua_lerror:
6557 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
6558 return 0;
6559#endif
6560}
6561#endif //#ifndef TOLUA_DISABLE
6562
6563/* method: frame_exists of class fawkes::tf::Transformer */
6564#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_frame_exists00
6565static int tolua_fawkestf_fawkes_tf_Transformer_frame_exists00(lua_State* tolua_S)
6566{
6567#ifndef TOLUA_RELEASE
6568 tolua_Error tolua_err;
6569 if (
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)
6573 )
6574 goto tolua_lerror;
6575 else
6576#endif
6577 {
6578 const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
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);
6582#endif
6583 bool exc_caught = false;
6584 try {
6585 {
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);
6589 }
6590 } catch (fawkes::Exception &e) {
6591 exc_caught = true;
6592 lua_pushstring(tolua_S, e.what_no_backtrace());
6593 }
6594 catch (std::exception &e) {
6595 exc_caught = true;
6596 lua_pushstring(tolua_S, e.what());
6597 }
6598 if (exc_caught) lua_error(tolua_S);
6599
6600 }
6601 return 2;
6602#ifndef TOLUA_RELEASE
6603 tolua_lerror:
6604 tolua_error(tolua_S,"#ferror in function 'frame_exists'.",&tolua_err);
6605 return 0;
6606#endif
6607}
6608#endif //#ifndef TOLUA_DISABLE
6609
6610/* method: lookup_transform of class fawkes::tf::Transformer */
6611#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_lookup_transform00
6612static int tolua_fawkestf_fawkes_tf_Transformer_lookup_transform00(lua_State* tolua_S)
6613{
6614#ifndef TOLUA_RELEASE
6615 tolua_Error tolua_err;
6616 if (
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)
6623 )
6624 goto tolua_lerror;
6625 else
6626#endif
6627 {
6628 const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
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));
6631 const fawkes::Time* time = ((const fawkes::Time*) tolua_tousertype(tolua_S,4,0));
6632 fawkes::tf::StampedTransform* transform = ((fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,5,0));
6633#ifndef TOLUA_RELEASE
6634 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lookup_transform'", NULL);
6635#endif
6636 bool exc_caught = false;
6637 try {
6638 {
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);
6642 }
6643 } catch (fawkes::Exception &e) {
6644 exc_caught = true;
6645 lua_pushstring(tolua_S, e.what_no_backtrace());
6646 }
6647 catch (std::exception &e) {
6648 exc_caught = true;
6649 lua_pushstring(tolua_S, e.what());
6650 }
6651 if (exc_caught) lua_error(tolua_S);
6652
6653 }
6654 return 2;
6655#ifndef TOLUA_RELEASE
6656 tolua_lerror:
6657 tolua_error(tolua_S,"#ferror in function 'lookup_transform'.",&tolua_err);
6658 return 0;
6659#endif
6660}
6661#endif //#ifndef TOLUA_DISABLE
6662
6663/* method: lookup_transform of class fawkes::tf::Transformer */
6664#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_lookup_transform01
6665static int tolua_fawkestf_fawkes_tf_Transformer_lookup_transform01(lua_State* tolua_S)
6666{
6667 tolua_Error tolua_err;
6668 if (
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)
6674 )
6675 goto tolua_lerror;
6676 else
6677 {
6678 const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
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));
6681 fawkes::tf::StampedTransform* transform = ((fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,4,0));
6682#ifndef TOLUA_RELEASE
6683 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lookup_transform'", NULL);
6684#endif
6685 bool exc_caught = false;
6686 try {
6687 {
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);
6691 }
6692 } catch (fawkes::Exception &e) {
6693 exc_caught = true;
6694 lua_pushstring(tolua_S, e.what_no_backtrace());
6695 }
6696 catch (std::exception &e) {
6697 exc_caught = true;
6698 lua_pushstring(tolua_S, e.what());
6699 }
6700 if (exc_caught) lua_error(tolua_S);
6701
6702 }
6703 return 2;
6704tolua_lerror:
6705 return tolua_fawkestf_fawkes_tf_Transformer_lookup_transform00(tolua_S);
6706}
6707#endif //#ifndef TOLUA_DISABLE
6708
6709/* method: lookup_transform of class fawkes::tf::Transformer */
6710#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_lookup_transform02
6711static int tolua_fawkestf_fawkes_tf_Transformer_lookup_transform02(lua_State* tolua_S)
6712{
6713 tolua_Error tolua_err;
6714 if (
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)
6723 )
6724 goto tolua_lerror;
6725 else
6726 {
6727 const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
6728 const std::string target_frame = ((const std::string) tolua_tocppstring(tolua_S,2,0));
6729 const fawkes::Time* target_time = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
6730 const std::string source_frame = ((const std::string) tolua_tocppstring(tolua_S,4,0));
6731 const fawkes::Time* source_time = ((const fawkes::Time*) tolua_tousertype(tolua_S,5,0));
6732 const std::string fixed_frame = ((const std::string) tolua_tocppstring(tolua_S,6,0));
6733 fawkes::tf::StampedTransform* transform = ((fawkes::tf::StampedTransform*) tolua_tousertype(tolua_S,7,0));
6734#ifndef TOLUA_RELEASE
6735 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lookup_transform'", NULL);
6736#endif
6737 bool exc_caught = false;
6738 try {
6739 {
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);
6744 }
6745 } catch (fawkes::Exception &e) {
6746 exc_caught = true;
6747 lua_pushstring(tolua_S, e.what_no_backtrace());
6748 }
6749 catch (std::exception &e) {
6750 exc_caught = true;
6751 lua_pushstring(tolua_S, e.what());
6752 }
6753 if (exc_caught) lua_error(tolua_S);
6754
6755 }
6756 return 3;
6757tolua_lerror:
6758 return tolua_fawkestf_fawkes_tf_Transformer_lookup_transform01(tolua_S);
6759}
6760#endif //#ifndef TOLUA_DISABLE
6761
6762/* method: can_transform of class fawkes::tf::Transformer */
6763#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_can_transform00
6764static int tolua_fawkestf_fawkes_tf_Transformer_can_transform00(lua_State* tolua_S)
6765{
6766#ifndef TOLUA_RELEASE
6767 tolua_Error tolua_err;
6768 if (
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)
6774 )
6775 goto tolua_lerror;
6776 else
6777#endif
6778 {
6779 const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
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));
6782 const fawkes::Time* time = ((const fawkes::Time*) tolua_tousertype(tolua_S,4,0));
6783#ifndef TOLUA_RELEASE
6784 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'can_transform'", NULL);
6785#endif
6786 bool exc_caught = false;
6787 try {
6788 {
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);
6793 }
6794 } catch (fawkes::Exception &e) {
6795 exc_caught = true;
6796 lua_pushstring(tolua_S, e.what_no_backtrace());
6797 }
6798 catch (std::exception &e) {
6799 exc_caught = true;
6800 lua_pushstring(tolua_S, e.what());
6801 }
6802 if (exc_caught) lua_error(tolua_S);
6803
6804 }
6805 return 3;
6806#ifndef TOLUA_RELEASE
6807 tolua_lerror:
6808 tolua_error(tolua_S,"#ferror in function 'can_transform'.",&tolua_err);
6809 return 0;
6810#endif
6811}
6812#endif //#ifndef TOLUA_DISABLE
6813
6814/* method: can_transform of class fawkes::tf::Transformer */
6815#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_can_transform01
6816static int tolua_fawkestf_fawkes_tf_Transformer_can_transform01(lua_State* tolua_S)
6817{
6818 tolua_Error tolua_err;
6819 if (
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)
6827 )
6828 goto tolua_lerror;
6829 else
6830 {
6831 const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
6832 const std::string target_frame = ((const std::string) tolua_tocppstring(tolua_S,2,0));
6833 const fawkes::Time* target_time = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,0));
6834 const std::string source_frame = ((const std::string) tolua_tocppstring(tolua_S,4,0));
6835 const fawkes::Time* source_time = ((const fawkes::Time*) tolua_tousertype(tolua_S,5,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);
6839#endif
6840 bool exc_caught = false;
6841 try {
6842 {
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);
6848 }
6849 } catch (fawkes::Exception &e) {
6850 exc_caught = true;
6851 lua_pushstring(tolua_S, e.what_no_backtrace());
6852 }
6853 catch (std::exception &e) {
6854 exc_caught = true;
6855 lua_pushstring(tolua_S, e.what());
6856 }
6857 if (exc_caught) lua_error(tolua_S);
6858
6859 }
6860 return 4;
6861tolua_lerror:
6862 return tolua_fawkestf_fawkes_tf_Transformer_can_transform00(tolua_S);
6863}
6864#endif //#ifndef TOLUA_DISABLE
6865
6866/* method: transform_quaternion of class fawkes::tf::Transformer */
6867#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion00
6868static int tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion00(lua_State* tolua_S)
6869{
6870#ifndef TOLUA_RELEASE
6871 tolua_Error tolua_err;
6872 if (
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)
6878 )
6879 goto tolua_lerror;
6880 else
6881#endif
6882 {
6883 const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
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);
6889#endif
6890 bool exc_caught = false;
6891 try {
6892 {
6893 self->transform_quaternion(target_frame,*stamped_in,*stamped_out);
6894 tolua_pushcppstring(tolua_S,(const char*)target_frame);
6895 }
6896 } catch (fawkes::Exception &e) {
6897 exc_caught = true;
6898 lua_pushstring(tolua_S, e.what_no_backtrace());
6899 }
6900 catch (std::exception &e) {
6901 exc_caught = true;
6902 lua_pushstring(tolua_S, e.what());
6903 }
6904 if (exc_caught) lua_error(tolua_S);
6905
6906 }
6907 return 1;
6908#ifndef TOLUA_RELEASE
6909 tolua_lerror:
6910 tolua_error(tolua_S,"#ferror in function 'transform_quaternion'.",&tolua_err);
6911 return 0;
6912#endif
6913}
6914#endif //#ifndef TOLUA_DISABLE
6915
6916/* method: transform_vector of class fawkes::tf::Transformer */
6917#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_vector00
6918static int tolua_fawkestf_fawkes_tf_Transformer_transform_vector00(lua_State* tolua_S)
6919{
6920#ifndef TOLUA_RELEASE
6921 tolua_Error tolua_err;
6922 if (
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)
6928 )
6929 goto tolua_lerror;
6930 else
6931#endif
6932 {
6933 const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
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);
6939#endif
6940 bool exc_caught = false;
6941 try {
6942 {
6943 self->transform_vector(target_frame,*stamped_in,*stamped_out);
6944 tolua_pushcppstring(tolua_S,(const char*)target_frame);
6945 }
6946 } catch (fawkes::Exception &e) {
6947 exc_caught = true;
6948 lua_pushstring(tolua_S, e.what_no_backtrace());
6949 }
6950 catch (std::exception &e) {
6951 exc_caught = true;
6952 lua_pushstring(tolua_S, e.what());
6953 }
6954 if (exc_caught) lua_error(tolua_S);
6955
6956 }
6957 return 1;
6958#ifndef TOLUA_RELEASE
6959 tolua_lerror:
6960 tolua_error(tolua_S,"#ferror in function 'transform_vector'.",&tolua_err);
6961 return 0;
6962#endif
6963}
6964#endif //#ifndef TOLUA_DISABLE
6965
6966/* method: transform_point of class fawkes::tf::Transformer */
6967#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_point00
6968static int tolua_fawkestf_fawkes_tf_Transformer_transform_point00(lua_State* tolua_S)
6969{
6970#ifndef TOLUA_RELEASE
6971 tolua_Error tolua_err;
6972 if (
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)
6978 )
6979 goto tolua_lerror;
6980 else
6981#endif
6982 {
6983 const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
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);
6989#endif
6990 bool exc_caught = false;
6991 try {
6992 {
6993 self->transform_point(target_frame,*stamped_in,*stamped_out);
6994 tolua_pushcppstring(tolua_S,(const char*)target_frame);
6995 }
6996 } catch (fawkes::Exception &e) {
6997 exc_caught = true;
6998 lua_pushstring(tolua_S, e.what_no_backtrace());
6999 }
7000 catch (std::exception &e) {
7001 exc_caught = true;
7002 lua_pushstring(tolua_S, e.what());
7003 }
7004 if (exc_caught) lua_error(tolua_S);
7005
7006 }
7007 return 1;
7008#ifndef TOLUA_RELEASE
7009 tolua_lerror:
7010 tolua_error(tolua_S,"#ferror in function 'transform_point'.",&tolua_err);
7011 return 0;
7012#endif
7013}
7014#endif //#ifndef TOLUA_DISABLE
7015
7016/* method: transform_pose of class fawkes::tf::Transformer */
7017#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_pose00
7018static int tolua_fawkestf_fawkes_tf_Transformer_transform_pose00(lua_State* tolua_S)
7019{
7020#ifndef TOLUA_RELEASE
7021 tolua_Error tolua_err;
7022 if (
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)
7028 )
7029 goto tolua_lerror;
7030 else
7031#endif
7032 {
7033 const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
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);
7039#endif
7040 bool exc_caught = false;
7041 try {
7042 {
7043 self->transform_pose(target_frame,*stamped_in,*stamped_out);
7044 tolua_pushcppstring(tolua_S,(const char*)target_frame);
7045 }
7046 } catch (fawkes::Exception &e) {
7047 exc_caught = true;
7048 lua_pushstring(tolua_S, e.what_no_backtrace());
7049 }
7050 catch (std::exception &e) {
7051 exc_caught = true;
7052 lua_pushstring(tolua_S, e.what());
7053 }
7054 if (exc_caught) lua_error(tolua_S);
7055
7056 }
7057 return 1;
7058#ifndef TOLUA_RELEASE
7059 tolua_lerror:
7060 tolua_error(tolua_S,"#ferror in function 'transform_pose'.",&tolua_err);
7061 return 0;
7062#endif
7063}
7064#endif //#ifndef TOLUA_DISABLE
7065
7066/* method: transform_quaternion of class fawkes::tf::Transformer */
7067#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion01
7068static int tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion01(lua_State* tolua_S)
7069{
7070 tolua_Error tolua_err;
7071 if (
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)
7079 )
7080 goto tolua_lerror;
7081 else
7082 {
7083 const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
7084 const std::string target_frame = ((const std::string) tolua_tocppstring(tolua_S,2,0));
7085 const fawkes::Time* target_time = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,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);
7091#endif
7092 bool exc_caught = false;
7093 try {
7094 {
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);
7098 }
7099 } catch (fawkes::Exception &e) {
7100 exc_caught = true;
7101 lua_pushstring(tolua_S, e.what_no_backtrace());
7102 }
7103 catch (std::exception &e) {
7104 exc_caught = true;
7105 lua_pushstring(tolua_S, e.what());
7106 }
7107 if (exc_caught) lua_error(tolua_S);
7108
7109 }
7110 return 2;
7111tolua_lerror:
7112 return tolua_fawkestf_fawkes_tf_Transformer_transform_quaternion00(tolua_S);
7113}
7114#endif //#ifndef TOLUA_DISABLE
7115
7116/* method: transform_vector of class fawkes::tf::Transformer */
7117#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_vector01
7118static int tolua_fawkestf_fawkes_tf_Transformer_transform_vector01(lua_State* tolua_S)
7119{
7120 tolua_Error tolua_err;
7121 if (
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)
7129 )
7130 goto tolua_lerror;
7131 else
7132 {
7133 const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
7134 const std::string target_frame = ((const std::string) tolua_tocppstring(tolua_S,2,0));
7135 const fawkes::Time* target_time = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,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);
7141#endif
7142 bool exc_caught = false;
7143 try {
7144 {
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);
7148 }
7149 } catch (fawkes::Exception &e) {
7150 exc_caught = true;
7151 lua_pushstring(tolua_S, e.what_no_backtrace());
7152 }
7153 catch (std::exception &e) {
7154 exc_caught = true;
7155 lua_pushstring(tolua_S, e.what());
7156 }
7157 if (exc_caught) lua_error(tolua_S);
7158
7159 }
7160 return 2;
7161tolua_lerror:
7162 return tolua_fawkestf_fawkes_tf_Transformer_transform_vector00(tolua_S);
7163}
7164#endif //#ifndef TOLUA_DISABLE
7165
7166/* method: transform_point of class fawkes::tf::Transformer */
7167#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_point01
7168static int tolua_fawkestf_fawkes_tf_Transformer_transform_point01(lua_State* tolua_S)
7169{
7170 tolua_Error tolua_err;
7171 if (
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)
7179 )
7180 goto tolua_lerror;
7181 else
7182 {
7183 const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
7184 const std::string target_frame = ((const std::string) tolua_tocppstring(tolua_S,2,0));
7185 const fawkes::Time* target_time = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,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);
7191#endif
7192 bool exc_caught = false;
7193 try {
7194 {
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);
7198 }
7199 } catch (fawkes::Exception &e) {
7200 exc_caught = true;
7201 lua_pushstring(tolua_S, e.what_no_backtrace());
7202 }
7203 catch (std::exception &e) {
7204 exc_caught = true;
7205 lua_pushstring(tolua_S, e.what());
7206 }
7207 if (exc_caught) lua_error(tolua_S);
7208
7209 }
7210 return 2;
7211tolua_lerror:
7212 return tolua_fawkestf_fawkes_tf_Transformer_transform_point00(tolua_S);
7213}
7214#endif //#ifndef TOLUA_DISABLE
7215
7216/* method: transform_pose of class fawkes::tf::Transformer */
7217#ifndef TOLUA_DISABLE_tolua_fawkestf_fawkes_tf_Transformer_transform_pose01
7218static int tolua_fawkestf_fawkes_tf_Transformer_transform_pose01(lua_State* tolua_S)
7219{
7220 tolua_Error tolua_err;
7221 if (
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)
7229 )
7230 goto tolua_lerror;
7231 else
7232 {
7233 const fawkes::tf::Transformer* self = (const fawkes::tf::Transformer*) tolua_tousertype(tolua_S,1,0);
7234 const std::string target_frame = ((const std::string) tolua_tocppstring(tolua_S,2,0));
7235 const fawkes::Time* target_time = ((const fawkes::Time*) tolua_tousertype(tolua_S,3,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);
7241#endif
7242 bool exc_caught = false;
7243 try {
7244 {
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);
7248 }
7249 } catch (fawkes::Exception &e) {
7250 exc_caught = true;
7251 lua_pushstring(tolua_S, e.what_no_backtrace());
7252 }
7253 catch (std::exception &e) {
7254 exc_caught = true;
7255 lua_pushstring(tolua_S, e.what());
7256 }
7257 if (exc_caught) lua_error(tolua_S);
7258
7259 }
7260 return 2;
7261tolua_lerror:
7262 return tolua_fawkestf_fawkes_tf_Transformer_transform_pose00(tolua_S);
7263}
7264#endif //#ifndef TOLUA_DISABLE
7265
7266/* Open function */
7267TOLUA_API int tolua_fawkestf_open (lua_State* tolua_S)
7268{
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);
7281 #ifdef __cplusplus
7282 tolua_cclass(tolua_S,"Vector3","fawkes::tf::Vector3","",tolua_collect_fawkes__tf__Vector3);
7283 #else
7284 tolua_cclass(tolua_S,"Vector3","fawkes::tf::Vector3","",NULL);
7285 #endif
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);
7322 #ifdef __cplusplus
7323 tolua_cclass(tolua_S,"Quaternion","fawkes::tf::Quaternion","",tolua_collect_fawkes__tf__Quaternion);
7324 #else
7325 tolua_cclass(tolua_S,"Quaternion","fawkes::tf::Quaternion","",NULL);
7326 #endif
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);
7364 #ifdef __cplusplus
7365 tolua_cclass(tolua_S,"Transform","fawkes::tf::Transform","",tolua_collect_fawkes__tf__Transform);
7366 #else
7367 tolua_cclass(tolua_S,"Transform","fawkes::tf::Transform","",NULL);
7368 #endif
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);
7391 #ifdef __cplusplus
7392 tolua_cclass(tolua_S,"Point","fawkes::tf::Point","fawkes::tf::Vector3",tolua_collect_fawkes__tf__Point);
7393 #else
7394 tolua_cclass(tolua_S,"Point","fawkes::tf::Point","fawkes::tf::Vector3",NULL);
7395 #endif
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);
7404 #ifdef __cplusplus
7405 tolua_cclass(tolua_S,"Pose","fawkes::tf::Pose","fawkes::tf::Transform",tolua_collect_fawkes__tf__Pose);
7406 #else
7407 tolua_cclass(tolua_S,"Pose","fawkes::tf::Pose","fawkes::tf::Transform",NULL);
7408 #endif
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);
7421 #ifdef __cplusplus
7422 tolua_cclass(tolua_S,"StampedTransform","fawkes::tf::StampedTransform","fawkes::tf::Transform",tolua_collect_fawkes__tf__StampedTransform);
7423 #else
7424 tolua_cclass(tolua_S,"StampedTransform","fawkes::tf::StampedTransform","fawkes::tf::Transform",NULL);
7425 #endif
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);
7438 #ifdef __cplusplus
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_);
7440 #else
7441 tolua_cclass(tolua_S,"Stamped_fawkes__tf__Quaternion_","fawkes::tf::Stamped<fawkes::tf::Quaternion>","fawkes::tf::Quaternion",NULL);
7442 #endif
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);
7454 #ifdef __cplusplus
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_);
7456 #else
7457 tolua_cclass(tolua_S,"Stamped_fawkes__tf__Vector3_","fawkes::tf::Stamped<fawkes::tf::Vector3>","fawkes::tf::Vector3",NULL);
7458 #endif
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);
7470 #ifdef __cplusplus
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_);
7472 #else
7473 tolua_cclass(tolua_S,"Stamped_fawkes__tf__Point_","fawkes::tf::Stamped<fawkes::tf::Point>","fawkes::tf::Point",NULL);
7474 #endif
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);
7486 #ifdef __cplusplus
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_);
7488 #else
7489 tolua_cclass(tolua_S,"Stamped_fawkes__tf__Pose_","fawkes::tf::Stamped<fawkes::tf::Pose>","fawkes::tf::Pose",NULL);
7490 #endif
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);
7502 #ifdef __cplusplus
7503 tolua_cclass(tolua_S,"StampedQuaternion","fawkes::tf::StampedQuaternion","fawkes::tf::Stamped<fawkes::tf::Quaternion>",tolua_collect_fawkes__tf__StampedQuaternion);
7504 #else
7505 tolua_cclass(tolua_S,"StampedQuaternion","fawkes::tf::StampedQuaternion","fawkes::tf::Stamped<fawkes::tf::Quaternion>",NULL);
7506 #endif
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);
7515 #ifdef __cplusplus
7516 tolua_cclass(tolua_S,"StampedVector3","fawkes::tf::StampedVector3","fawkes::tf::Stamped<fawkes::tf::Vector3>",tolua_collect_fawkes__tf__StampedVector3);
7517 #else
7518 tolua_cclass(tolua_S,"StampedVector3","fawkes::tf::StampedVector3","fawkes::tf::Stamped<fawkes::tf::Vector3>",NULL);
7519 #endif
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);
7528 #ifdef __cplusplus
7529 tolua_cclass(tolua_S,"StampedPoint","fawkes::tf::StampedPoint","fawkes::tf::Stamped<fawkes::tf::Point>",tolua_collect_fawkes__tf__StampedPoint);
7530 #else
7531 tolua_cclass(tolua_S,"StampedPoint","fawkes::tf::StampedPoint","fawkes::tf::Stamped<fawkes::tf::Point>",NULL);
7532 #endif
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);
7541 #ifdef __cplusplus
7542 tolua_cclass(tolua_S,"StampedPose","fawkes::tf::StampedPose","fawkes::tf::Stamped<fawkes::tf::Pose>",tolua_collect_fawkes__tf__StampedPose);
7543 #else
7544 tolua_cclass(tolua_S,"StampedPose","fawkes::tf::StampedPose","fawkes::tf::Stamped<fawkes::tf::Pose>",NULL);
7545 #endif
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);
7575 return 1;
7576}
7577
7578
7579extern "C" {
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);
7583};
7584#endif
7585}
7586
7587
Base class for exceptions in Fawkes.
Definition: exception.h:36
virtual const char * what_no_backtrace() const noexcept
Get primary string (does not implicitly print the back trace).
Definition: exception.cpp:663
A class for handling time.
Definition: time.h:93
void clear()
Clear all data.
Transform that contains a timestamp and frame IDs.
Definition: types.h:92
void set_data(const tf::Transform &input)
Set the inherited Transform data.
Definition: types.h:121
fawkes::Time stamp
Timestamp of this transform.
Definition: types.h:95
std::string frame_id
Parent/reference frame ID.
Definition: types.h:97
std::string child_frame_id
Frame ID of child frame, e.g.
Definition: types.h:100
Wrapper class to add time stamp and frame ID to base types.
Definition: types.h:130
std::string frame_id
The frame_id associated this data.
Definition: types.h:133
fawkes::Time stamp
The timestamp associated with this data.
Definition: types.h:132
void set_data(const T &input)
Set the data element.
Definition: types.h:152
Coordinate transforms between any two frames in a system.
Definition: transformer.h:65
void transform_quaternion(const std::string &target_frame, const Stamped< Quaternion > &stamped_in, Stamped< Quaternion > &stamped_out) const
Transform a stamped Quaternion into the target frame.
void transform_point(const std::string &target_frame, const Stamped< Point > &stamped_in, Stamped< Point > &stamped_out) const
Transform a stamped point into the target frame.
void transform_pose(const std::string &target_frame, const Stamped< Pose > &stamped_in, Stamped< Pose > &stamped_out) const
Transform a stamped pose into the target frame.
bool frame_exists(const std::string &frame_id_str) const
Check if frame exists.
void lookup_transform(const std::string &target_frame, const std::string &source_frame, const fawkes::Time &time, StampedTransform &transform) const
Lookup transform.
bool can_transform(const std::string &target_frame, const std::string &source_frame, const fawkes::Time &time, std::string *error_msg=NULL) const
Test if a transform is possible.
void transform_vector(const std::string &target_frame, const Stamped< Vector3 > &stamped_in, Stamped< Vector3 > &stamped_out) const
Transform a stamped vector into the target frame.