Fawkes API  Fawkes Development Version
fawkesgeometry_tolua.cpp
1 /*
2 ** Lua binding: fawkesgeometry
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 #ifndef __cplusplus
20 #include "stdlib.h"
21 #endif
22 #include "string.h"
23 
24 #include "tolua++.h"
25 
26 /* Exported function */
27 TOLUA_API int tolua_fawkesgeometry_open (lua_State* tolua_S);
28 
29 #include <geometry/hom_coord.h>
30 #include <geometry/transformable.h>
31 #include <geometry/hom_vector.h>
32 #include <geometry/hom_point.h>
33 #include <geometry/hom_transform.h>
34 #include <geometry/matrix.h>
35 #include <geometry/hom_vector.h>
36 #include <geometry/hom_point.h>
37 #include <geometry/hom_pose_2d.h>
38 #include <geometry/hom_coord.h>
39 #include <geometry/hom_coord.h>
40 #include <geometry/hom_vector.h>
41 
42 /* function to release collected object via destructor */
43 #ifdef __cplusplus
44 
45 static int tolua_collect_fawkes__HomTransform (lua_State* tolua_S)
46 {
47  fawkes::HomTransform* self = (fawkes::HomTransform*) tolua_tousertype(tolua_S,1,0);
48  Mtolua_delete(self);
49  return 0;
50 }
51 
52 static int tolua_collect_fawkes__HomPoint (lua_State* tolua_S)
53 {
54  fawkes::HomPoint* self = (fawkes::HomPoint*) tolua_tousertype(tolua_S,1,0);
55  Mtolua_delete(self);
56  return 0;
57 }
58 
59 static int tolua_collect_fawkes__HomCoord (lua_State* tolua_S)
60 {
61  fawkes::HomCoord* self = (fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
62  Mtolua_delete(self);
63  return 0;
64 }
65 
66 static int tolua_collect_fawkes__HomVector (lua_State* tolua_S)
67 {
68  fawkes::HomVector* self = (fawkes::HomVector*) tolua_tousertype(tolua_S,1,0);
69  Mtolua_delete(self);
70  return 0;
71 }
72 
73 static int tolua_collect_fawkes__HomPose2d (lua_State* tolua_S)
74 {
75  fawkes::HomPose2d* self = (fawkes::HomPose2d*) tolua_tousertype(tolua_S,1,0);
76  Mtolua_delete(self);
77  return 0;
78 }
79 #endif
80 
81 
82 /* function to register type */
83 static void tolua_reg_types (lua_State* tolua_S)
84 {
85  tolua_usertype(tolua_S,"fawkes::HomPose2d");
86  tolua_usertype(tolua_S,"fawkes::HomPoint");
87  tolua_usertype(tolua_S,"fawkes::Matrix");
88  tolua_usertype(tolua_S,"Printable");
89  tolua_usertype(tolua_S,"fawkes::HomCoord");
90  tolua_usertype(tolua_S,"fawkes::HomVector");
91  tolua_usertype(tolua_S,"fawkes::HomTransform");
92  tolua_usertype(tolua_S,"Transformable");
93 }
94 
95 /* method: new of class fawkes::HomCoord */
96 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_new00
97 static int tolua_fawkesgeometry_fawkes_HomCoord_new00(lua_State* tolua_S)
98 {
99 #ifndef TOLUA_RELEASE
100  tolua_Error tolua_err;
101  if (
102  !tolua_isusertable(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
103  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
104  !tolua_isnoobj(tolua_S,3,&tolua_err)
105  )
106  goto tolua_lerror;
107  else
108 #endif
109  {
110  const fawkes::HomCoord* c = ((const fawkes::HomCoord*) tolua_tousertype(tolua_S,2,0));
111  {
112  fawkes::HomCoord* tolua_ret = (fawkes::HomCoord*) Mtolua_new((fawkes::HomCoord)(*c));
113  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomCoord");
114  }
115  }
116  return 1;
117 #ifndef TOLUA_RELEASE
118  tolua_lerror:
119  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
120  return 0;
121 #endif
122 }
123 #endif //#ifndef TOLUA_DISABLE
124 
125 /* method: new_local of class fawkes::HomCoord */
126 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_new00_local
127 static int tolua_fawkesgeometry_fawkes_HomCoord_new00_local(lua_State* tolua_S)
128 {
129 #ifndef TOLUA_RELEASE
130  tolua_Error tolua_err;
131  if (
132  !tolua_isusertable(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
133  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
134  !tolua_isnoobj(tolua_S,3,&tolua_err)
135  )
136  goto tolua_lerror;
137  else
138 #endif
139  {
140  const fawkes::HomCoord* c = ((const fawkes::HomCoord*) tolua_tousertype(tolua_S,2,0));
141  {
142  fawkes::HomCoord* tolua_ret = (fawkes::HomCoord*) Mtolua_new((fawkes::HomCoord)(*c));
143  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomCoord");
144  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
145  }
146  }
147  return 1;
148 #ifndef TOLUA_RELEASE
149  tolua_lerror:
150  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
151  return 0;
152 #endif
153 }
154 #endif //#ifndef TOLUA_DISABLE
155 
156 /* method: delete of class fawkes::HomCoord */
157 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_delete00
158 static int tolua_fawkesgeometry_fawkes_HomCoord_delete00(lua_State* tolua_S)
159 {
160 #ifndef TOLUA_RELEASE
161  tolua_Error tolua_err;
162  if (
163  !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
164  !tolua_isnoobj(tolua_S,2,&tolua_err)
165  )
166  goto tolua_lerror;
167  else
168 #endif
169  {
170  fawkes::HomCoord* self = (fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
171 #ifndef TOLUA_RELEASE
172  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
173 #endif
174  Mtolua_delete(self);
175  }
176  return 0;
177 #ifndef TOLUA_RELEASE
178  tolua_lerror:
179  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
180  return 0;
181 #endif
182 }
183 #endif //#ifndef TOLUA_DISABLE
184 
185 /* method: x of class fawkes::HomCoord */
186 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_x00
187 static int tolua_fawkesgeometry_fawkes_HomCoord_x00(lua_State* tolua_S)
188 {
189 #ifndef TOLUA_RELEASE
190  tolua_Error tolua_err;
191  if (
192  !tolua_isusertype(tolua_S,1,"const fawkes::HomCoord",0,&tolua_err) ||
193  !tolua_isnoobj(tolua_S,2,&tolua_err)
194  )
195  goto tolua_lerror;
196  else
197 #endif
198  {
199  const fawkes::HomCoord* self = (const fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
200 #ifndef TOLUA_RELEASE
201  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'",NULL);
202 #endif
203  {
204  float tolua_ret = (float) self->x();
205  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
206  }
207  }
208  return 1;
209 #ifndef TOLUA_RELEASE
210  tolua_lerror:
211  tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
212  return 0;
213 #endif
214 }
215 #endif //#ifndef TOLUA_DISABLE
216 
217 /* method: x of class fawkes::HomCoord */
218 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_x01
219 static int tolua_fawkesgeometry_fawkes_HomCoord_x01(lua_State* tolua_S)
220 {
221  tolua_Error tolua_err;
222  if (
223  !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
224  !tolua_isnoobj(tolua_S,2,&tolua_err)
225  )
226  goto tolua_lerror;
227  else
228  {
229  fawkes::HomCoord* self = (fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
230 #ifndef TOLUA_RELEASE
231  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'",NULL);
232 #endif
233  {
234  float tolua_ret = (float) self->x();
235  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
236  }
237  }
238  return 1;
239 tolua_lerror:
240  return tolua_fawkesgeometry_fawkes_HomCoord_x00(tolua_S);
241 }
242 #endif //#ifndef TOLUA_DISABLE
243 
244 /* method: x of class fawkes::HomCoord */
245 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_x02
246 static int tolua_fawkesgeometry_fawkes_HomCoord_x02(lua_State* tolua_S)
247 {
248  tolua_Error tolua_err;
249  if (
250  !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
251  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
252  !tolua_isnoobj(tolua_S,3,&tolua_err)
253  )
254  goto tolua_lerror;
255  else
256  {
257  fawkes::HomCoord* self = (fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
258  float x = ((float) tolua_tonumber(tolua_S,2,0));
259 #ifndef TOLUA_RELEASE
260  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'",NULL);
261 #endif
262  {
263  fawkes::HomCoord& tolua_ret = (fawkes::HomCoord&) self->x(x);
264  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomCoord");
265  }
266  }
267  return 1;
268 tolua_lerror:
269  return tolua_fawkesgeometry_fawkes_HomCoord_x01(tolua_S);
270 }
271 #endif //#ifndef TOLUA_DISABLE
272 
273 /* method: y of class fawkes::HomCoord */
274 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_y00
275 static int tolua_fawkesgeometry_fawkes_HomCoord_y00(lua_State* tolua_S)
276 {
277 #ifndef TOLUA_RELEASE
278  tolua_Error tolua_err;
279  if (
280  !tolua_isusertype(tolua_S,1,"const fawkes::HomCoord",0,&tolua_err) ||
281  !tolua_isnoobj(tolua_S,2,&tolua_err)
282  )
283  goto tolua_lerror;
284  else
285 #endif
286  {
287  const fawkes::HomCoord* self = (const fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
288 #ifndef TOLUA_RELEASE
289  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'",NULL);
290 #endif
291  {
292  float tolua_ret = (float) self->y();
293  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
294  }
295  }
296  return 1;
297 #ifndef TOLUA_RELEASE
298  tolua_lerror:
299  tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
300  return 0;
301 #endif
302 }
303 #endif //#ifndef TOLUA_DISABLE
304 
305 /* method: y of class fawkes::HomCoord */
306 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_y01
307 static int tolua_fawkesgeometry_fawkes_HomCoord_y01(lua_State* tolua_S)
308 {
309  tolua_Error tolua_err;
310  if (
311  !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
312  !tolua_isnoobj(tolua_S,2,&tolua_err)
313  )
314  goto tolua_lerror;
315  else
316  {
317  fawkes::HomCoord* self = (fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
318 #ifndef TOLUA_RELEASE
319  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'",NULL);
320 #endif
321  {
322  float tolua_ret = (float) self->y();
323  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
324  }
325  }
326  return 1;
327 tolua_lerror:
328  return tolua_fawkesgeometry_fawkes_HomCoord_y00(tolua_S);
329 }
330 #endif //#ifndef TOLUA_DISABLE
331 
332 /* method: y of class fawkes::HomCoord */
333 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_y02
334 static int tolua_fawkesgeometry_fawkes_HomCoord_y02(lua_State* tolua_S)
335 {
336  tolua_Error tolua_err;
337  if (
338  !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
339  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
340  !tolua_isnoobj(tolua_S,3,&tolua_err)
341  )
342  goto tolua_lerror;
343  else
344  {
345  fawkes::HomCoord* self = (fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
346  float y = ((float) tolua_tonumber(tolua_S,2,0));
347 #ifndef TOLUA_RELEASE
348  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'",NULL);
349 #endif
350  {
351  fawkes::HomCoord& tolua_ret = (fawkes::HomCoord&) self->y(y);
352  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomCoord");
353  }
354  }
355  return 1;
356 tolua_lerror:
357  return tolua_fawkesgeometry_fawkes_HomCoord_y01(tolua_S);
358 }
359 #endif //#ifndef TOLUA_DISABLE
360 
361 /* method: z of class fawkes::HomCoord */
362 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_z00
363 static int tolua_fawkesgeometry_fawkes_HomCoord_z00(lua_State* tolua_S)
364 {
365 #ifndef TOLUA_RELEASE
366  tolua_Error tolua_err;
367  if (
368  !tolua_isusertype(tolua_S,1,"const fawkes::HomCoord",0,&tolua_err) ||
369  !tolua_isnoobj(tolua_S,2,&tolua_err)
370  )
371  goto tolua_lerror;
372  else
373 #endif
374  {
375  const fawkes::HomCoord* self = (const fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
376 #ifndef TOLUA_RELEASE
377  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'z'",NULL);
378 #endif
379  {
380  float tolua_ret = (float) self->z();
381  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
382  }
383  }
384  return 1;
385 #ifndef TOLUA_RELEASE
386  tolua_lerror:
387  tolua_error(tolua_S,"#ferror in function 'z'.",&tolua_err);
388  return 0;
389 #endif
390 }
391 #endif //#ifndef TOLUA_DISABLE
392 
393 /* method: z of class fawkes::HomCoord */
394 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_z01
395 static int tolua_fawkesgeometry_fawkes_HomCoord_z01(lua_State* tolua_S)
396 {
397  tolua_Error tolua_err;
398  if (
399  !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
400  !tolua_isnoobj(tolua_S,2,&tolua_err)
401  )
402  goto tolua_lerror;
403  else
404  {
405  fawkes::HomCoord* self = (fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
406 #ifndef TOLUA_RELEASE
407  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'z'",NULL);
408 #endif
409  {
410  float tolua_ret = (float) self->z();
411  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
412  }
413  }
414  return 1;
415 tolua_lerror:
416  return tolua_fawkesgeometry_fawkes_HomCoord_z00(tolua_S);
417 }
418 #endif //#ifndef TOLUA_DISABLE
419 
420 /* method: z of class fawkes::HomCoord */
421 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_z02
422 static int tolua_fawkesgeometry_fawkes_HomCoord_z02(lua_State* tolua_S)
423 {
424  tolua_Error tolua_err;
425  if (
426  !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
427  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
428  !tolua_isnoobj(tolua_S,3,&tolua_err)
429  )
430  goto tolua_lerror;
431  else
432  {
433  fawkes::HomCoord* self = (fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
434  float z = ((float) tolua_tonumber(tolua_S,2,0));
435 #ifndef TOLUA_RELEASE
436  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'z'",NULL);
437 #endif
438  {
439  fawkes::HomCoord& tolua_ret = (fawkes::HomCoord&) self->z(z);
440  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomCoord");
441  }
442  }
443  return 1;
444 tolua_lerror:
445  return tolua_fawkesgeometry_fawkes_HomCoord_z01(tolua_S);
446 }
447 #endif //#ifndef TOLUA_DISABLE
448 
449 /* method: w of class fawkes::HomCoord */
450 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_w00
451 static int tolua_fawkesgeometry_fawkes_HomCoord_w00(lua_State* tolua_S)
452 {
453 #ifndef TOLUA_RELEASE
454  tolua_Error tolua_err;
455  if (
456  !tolua_isusertype(tolua_S,1,"const fawkes::HomCoord",0,&tolua_err) ||
457  !tolua_isnoobj(tolua_S,2,&tolua_err)
458  )
459  goto tolua_lerror;
460  else
461 #endif
462  {
463  const fawkes::HomCoord* self = (const fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
464 #ifndef TOLUA_RELEASE
465  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'w'",NULL);
466 #endif
467  {
468  float tolua_ret = (float) self->w();
469  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
470  }
471  }
472  return 1;
473 #ifndef TOLUA_RELEASE
474  tolua_lerror:
475  tolua_error(tolua_S,"#ferror in function 'w'.",&tolua_err);
476  return 0;
477 #endif
478 }
479 #endif //#ifndef TOLUA_DISABLE
480 
481 /* method: w of class fawkes::HomCoord */
482 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_w01
483 static int tolua_fawkesgeometry_fawkes_HomCoord_w01(lua_State* tolua_S)
484 {
485  tolua_Error tolua_err;
486  if (
487  !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
488  !tolua_isnoobj(tolua_S,2,&tolua_err)
489  )
490  goto tolua_lerror;
491  else
492  {
493  fawkes::HomCoord* self = (fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
494 #ifndef TOLUA_RELEASE
495  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'w'",NULL);
496 #endif
497  {
498  float tolua_ret = (float) self->w();
499  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
500  }
501  }
502  return 1;
503 tolua_lerror:
504  return tolua_fawkesgeometry_fawkes_HomCoord_w00(tolua_S);
505 }
506 #endif //#ifndef TOLUA_DISABLE
507 
508 /* method: w of class fawkes::HomCoord */
509 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_w02
510 static int tolua_fawkesgeometry_fawkes_HomCoord_w02(lua_State* tolua_S)
511 {
512  tolua_Error tolua_err;
513  if (
514  !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
515  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
516  !tolua_isnoobj(tolua_S,3,&tolua_err)
517  )
518  goto tolua_lerror;
519  else
520  {
521  fawkes::HomCoord* self = (fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
522  float w = ((float) tolua_tonumber(tolua_S,2,0));
523 #ifndef TOLUA_RELEASE
524  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'w'",NULL);
525 #endif
526  {
527  fawkes::HomCoord& tolua_ret = (fawkes::HomCoord&) self->w(w);
528  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomCoord");
529  }
530  }
531  return 1;
532 tolua_lerror:
533  return tolua_fawkesgeometry_fawkes_HomCoord_w01(tolua_S);
534 }
535 #endif //#ifndef TOLUA_DISABLE
536 
537 /* method: rotate_x of class fawkes::HomCoord */
538 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_rotate_x00
539 static int tolua_fawkesgeometry_fawkes_HomCoord_rotate_x00(lua_State* tolua_S)
540 {
541 #ifndef TOLUA_RELEASE
542  tolua_Error tolua_err;
543  if (
544  !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
545  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
546  !tolua_isnoobj(tolua_S,3,&tolua_err)
547  )
548  goto tolua_lerror;
549  else
550 #endif
551  {
552  fawkes::HomCoord* self = (fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
553  float rad = ((float) tolua_tonumber(tolua_S,2,0));
554 #ifndef TOLUA_RELEASE
555  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotate_x'",NULL);
556 #endif
557  {
558  fawkes::HomCoord& tolua_ret = (fawkes::HomCoord&) self->rotate_x(rad);
559  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomCoord");
560  }
561  }
562  return 1;
563 #ifndef TOLUA_RELEASE
564  tolua_lerror:
565  tolua_error(tolua_S,"#ferror in function 'rotate_x'.",&tolua_err);
566  return 0;
567 #endif
568 }
569 #endif //#ifndef TOLUA_DISABLE
570 
571 /* method: rotate_y of class fawkes::HomCoord */
572 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_rotate_y00
573 static int tolua_fawkesgeometry_fawkes_HomCoord_rotate_y00(lua_State* tolua_S)
574 {
575 #ifndef TOLUA_RELEASE
576  tolua_Error tolua_err;
577  if (
578  !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
579  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
580  !tolua_isnoobj(tolua_S,3,&tolua_err)
581  )
582  goto tolua_lerror;
583  else
584 #endif
585  {
586  fawkes::HomCoord* self = (fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
587  float rad = ((float) tolua_tonumber(tolua_S,2,0));
588 #ifndef TOLUA_RELEASE
589  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotate_y'",NULL);
590 #endif
591  {
592  fawkes::HomCoord& tolua_ret = (fawkes::HomCoord&) self->rotate_y(rad);
593  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomCoord");
594  }
595  }
596  return 1;
597 #ifndef TOLUA_RELEASE
598  tolua_lerror:
599  tolua_error(tolua_S,"#ferror in function 'rotate_y'.",&tolua_err);
600  return 0;
601 #endif
602 }
603 #endif //#ifndef TOLUA_DISABLE
604 
605 /* method: rotate_z of class fawkes::HomCoord */
606 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_rotate_z00
607 static int tolua_fawkesgeometry_fawkes_HomCoord_rotate_z00(lua_State* tolua_S)
608 {
609 #ifndef TOLUA_RELEASE
610  tolua_Error tolua_err;
611  if (
612  !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
613  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
614  !tolua_isnoobj(tolua_S,3,&tolua_err)
615  )
616  goto tolua_lerror;
617  else
618 #endif
619  {
620  fawkes::HomCoord* self = (fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
621  float rad = ((float) tolua_tonumber(tolua_S,2,0));
622 #ifndef TOLUA_RELEASE
623  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotate_z'",NULL);
624 #endif
625  {
626  fawkes::HomCoord& tolua_ret = (fawkes::HomCoord&) self->rotate_z(rad);
627  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomCoord");
628  }
629  }
630  return 1;
631 #ifndef TOLUA_RELEASE
632  tolua_lerror:
633  tolua_error(tolua_S,"#ferror in function 'rotate_z'.",&tolua_err);
634  return 0;
635 #endif
636 }
637 #endif //#ifndef TOLUA_DISABLE
638 
639 /* method: transform of class fawkes::HomCoord */
640 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord_transform00
641 static int tolua_fawkesgeometry_fawkes_HomCoord_transform00(lua_State* tolua_S)
642 {
643 #ifndef TOLUA_RELEASE
644  tolua_Error tolua_err;
645  if (
646  !tolua_isusertype(tolua_S,1,"fawkes::HomCoord",0,&tolua_err) ||
647  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomTransform",0,&tolua_err)) ||
648  !tolua_isnoobj(tolua_S,3,&tolua_err)
649  )
650  goto tolua_lerror;
651  else
652 #endif
653  {
654  fawkes::HomCoord* self = (fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
655  const fawkes::HomTransform* t = ((const fawkes::HomTransform*) tolua_tousertype(tolua_S,2,0));
656 #ifndef TOLUA_RELEASE
657  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'transform'",NULL);
658 #endif
659  {
660  fawkes::HomCoord& tolua_ret = (fawkes::HomCoord&) self->transform(*t);
661  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomCoord");
662  }
663  }
664  return 1;
665 #ifndef TOLUA_RELEASE
666  tolua_lerror:
667  tolua_error(tolua_S,"#ferror in function 'transform'.",&tolua_err);
668  return 0;
669 #endif
670 }
671 #endif //#ifndef TOLUA_DISABLE
672 
673 /* method: operator- of class fawkes::HomCoord */
674 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord__sub00
675 static int tolua_fawkesgeometry_fawkes_HomCoord__sub00(lua_State* tolua_S)
676 {
677 #ifndef TOLUA_RELEASE
678  tolua_Error tolua_err;
679  if (
680  !tolua_isusertype(tolua_S,1,"const fawkes::HomCoord",0,&tolua_err) ||
681  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
682  !tolua_isnoobj(tolua_S,3,&tolua_err)
683  )
684  goto tolua_lerror;
685  else
686 #endif
687  {
688  const fawkes::HomCoord* self = (const fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
689  const fawkes::HomCoord* h = ((const fawkes::HomCoord*) tolua_tousertype(tolua_S,2,0));
690 #ifndef TOLUA_RELEASE
691  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'",NULL);
692 #endif
693  {
694  fawkes::HomCoord tolua_ret = (fawkes::HomCoord) self->operator-(*h);
695  {
696 #ifdef __cplusplus
697  void* tolua_obj = Mtolua_new((fawkes::HomCoord)(tolua_ret));
698  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomCoord");
699  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
700 #else
701  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomCoord));
702  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomCoord");
703  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
704 #endif
705  }
706  }
707  }
708  return 1;
709 #ifndef TOLUA_RELEASE
710  tolua_lerror:
711  tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
712  return 0;
713 #endif
714 }
715 #endif //#ifndef TOLUA_DISABLE
716 
717 /* method: operator+ of class fawkes::HomCoord */
718 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord__add00
719 static int tolua_fawkesgeometry_fawkes_HomCoord__add00(lua_State* tolua_S)
720 {
721 #ifndef TOLUA_RELEASE
722  tolua_Error tolua_err;
723  if (
724  !tolua_isusertype(tolua_S,1,"const fawkes::HomCoord",0,&tolua_err) ||
725  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
726  !tolua_isnoobj(tolua_S,3,&tolua_err)
727  )
728  goto tolua_lerror;
729  else
730 #endif
731  {
732  const fawkes::HomCoord* self = (const fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
733  const fawkes::HomCoord* h = ((const fawkes::HomCoord*) tolua_tousertype(tolua_S,2,0));
734 #ifndef TOLUA_RELEASE
735  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'",NULL);
736 #endif
737  {
738  fawkes::HomCoord tolua_ret = (fawkes::HomCoord) self->operator+(*h);
739  {
740 #ifdef __cplusplus
741  void* tolua_obj = Mtolua_new((fawkes::HomCoord)(tolua_ret));
742  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomCoord");
743  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
744 #else
745  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomCoord));
746  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomCoord");
747  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
748 #endif
749  }
750  }
751  }
752  return 1;
753 #ifndef TOLUA_RELEASE
754  tolua_lerror:
755  tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err);
756  return 0;
757 #endif
758 }
759 #endif //#ifndef TOLUA_DISABLE
760 
761 /* method: operator* of class fawkes::HomCoord */
762 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord__mul00
763 static int tolua_fawkesgeometry_fawkes_HomCoord__mul00(lua_State* tolua_S)
764 {
765 #ifndef TOLUA_RELEASE
766  tolua_Error tolua_err;
767  if (
768  !tolua_isusertype(tolua_S,1,"const fawkes::HomCoord",0,&tolua_err) ||
769  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
770  !tolua_isnoobj(tolua_S,3,&tolua_err)
771  )
772  goto tolua_lerror;
773  else
774 #endif
775  {
776  const fawkes::HomCoord* self = (const fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
777  const fawkes::HomCoord* h = ((const fawkes::HomCoord*) tolua_tousertype(tolua_S,2,0));
778 #ifndef TOLUA_RELEASE
779  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'",NULL);
780 #endif
781  {
782  float tolua_ret = (float) self->operator*(*h);
783  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
784  }
785  }
786  return 1;
787 #ifndef TOLUA_RELEASE
788  tolua_lerror:
789  tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err);
790  return 0;
791 #endif
792 }
793 #endif //#ifndef TOLUA_DISABLE
794 
795 /* method: operator* of class fawkes::HomCoord */
796 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord__mul01
797 static int tolua_fawkesgeometry_fawkes_HomCoord__mul01(lua_State* tolua_S)
798 {
799  tolua_Error tolua_err;
800  if (
801  !tolua_isusertype(tolua_S,1,"const fawkes::HomCoord",0,&tolua_err) ||
802  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
803  !tolua_isnoobj(tolua_S,3,&tolua_err)
804  )
805  goto tolua_lerror;
806  else
807  {
808  const fawkes::HomCoord* self = (const fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
809  const float s = ((const float) tolua_tonumber(tolua_S,2,0));
810 #ifndef TOLUA_RELEASE
811  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'",NULL);
812 #endif
813  {
814  fawkes::HomCoord tolua_ret = (fawkes::HomCoord) self->operator*(s);
815  {
816 #ifdef __cplusplus
817  void* tolua_obj = Mtolua_new((fawkes::HomCoord)(tolua_ret));
818  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomCoord");
819  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
820 #else
821  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomCoord));
822  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomCoord");
823  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
824 #endif
825  }
826  }
827  }
828  return 1;
829 tolua_lerror:
830  return tolua_fawkesgeometry_fawkes_HomCoord__mul00(tolua_S);
831 }
832 #endif //#ifndef TOLUA_DISABLE
833 
834 /* method: operator== of class fawkes::HomCoord */
835 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomCoord__eq00
836 static int tolua_fawkesgeometry_fawkes_HomCoord__eq00(lua_State* tolua_S)
837 {
838 #ifndef TOLUA_RELEASE
839  tolua_Error tolua_err;
840  if (
841  !tolua_isusertype(tolua_S,1,"const fawkes::HomCoord",0,&tolua_err) ||
842  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
843  !tolua_isnoobj(tolua_S,3,&tolua_err)
844  )
845  goto tolua_lerror;
846  else
847 #endif
848  {
849  const fawkes::HomCoord* self = (const fawkes::HomCoord*) tolua_tousertype(tolua_S,1,0);
850  const fawkes::HomCoord* h = ((const fawkes::HomCoord*) tolua_tousertype(tolua_S,2,0));
851 #ifndef TOLUA_RELEASE
852  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
853 #endif
854  {
855  bool tolua_ret = (bool) self->operator==(*h);
856  tolua_pushboolean(tolua_S,(bool)tolua_ret);
857  }
858  }
859  return 1;
860 #ifndef TOLUA_RELEASE
861  tolua_lerror:
862  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
863  return 0;
864 #endif
865 }
866 #endif //#ifndef TOLUA_DISABLE
867 
868 /* method: new of class fawkes::HomPose2d */
869 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_new00
870 static int tolua_fawkesgeometry_fawkes_HomPose2d_new00(lua_State* tolua_S)
871 {
872 #ifndef TOLUA_RELEASE
873  tolua_Error tolua_err;
874  if (
875  !tolua_isusertable(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
876  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPoint",0,&tolua_err)) ||
877  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::HomVector",0,&tolua_err)) ||
878  !tolua_isnoobj(tolua_S,4,&tolua_err)
879  )
880  goto tolua_lerror;
881  else
882 #endif
883  {
884  const fawkes::HomPoint* pos = ((const fawkes::HomPoint*) tolua_tousertype(tolua_S,2,0));
885  const fawkes::HomVector* orientation = ((const fawkes::HomVector*) tolua_tousertype(tolua_S,3,0));
886  {
887  fawkes::HomPose2d* tolua_ret = (fawkes::HomPose2d*) Mtolua_new((fawkes::HomPose2d)(*pos,*orientation));
888  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPose2d");
889  }
890  }
891  return 1;
892 #ifndef TOLUA_RELEASE
893  tolua_lerror:
894  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
895  return 0;
896 #endif
897 }
898 #endif //#ifndef TOLUA_DISABLE
899 
900 /* method: new_local of class fawkes::HomPose2d */
901 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_new00_local
902 static int tolua_fawkesgeometry_fawkes_HomPose2d_new00_local(lua_State* tolua_S)
903 {
904 #ifndef TOLUA_RELEASE
905  tolua_Error tolua_err;
906  if (
907  !tolua_isusertable(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
908  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPoint",0,&tolua_err)) ||
909  (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const fawkes::HomVector",0,&tolua_err)) ||
910  !tolua_isnoobj(tolua_S,4,&tolua_err)
911  )
912  goto tolua_lerror;
913  else
914 #endif
915  {
916  const fawkes::HomPoint* pos = ((const fawkes::HomPoint*) tolua_tousertype(tolua_S,2,0));
917  const fawkes::HomVector* orientation = ((const fawkes::HomVector*) tolua_tousertype(tolua_S,3,0));
918  {
919  fawkes::HomPose2d* tolua_ret = (fawkes::HomPose2d*) Mtolua_new((fawkes::HomPose2d)(*pos,*orientation));
920  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPose2d");
921  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
922  }
923  }
924  return 1;
925 #ifndef TOLUA_RELEASE
926  tolua_lerror:
927  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
928  return 0;
929 #endif
930 }
931 #endif //#ifndef TOLUA_DISABLE
932 
933 /* method: new of class fawkes::HomPose2d */
934 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_new01
935 static int tolua_fawkesgeometry_fawkes_HomPose2d_new01(lua_State* tolua_S)
936 {
937  tolua_Error tolua_err;
938  if (
939  !tolua_isusertable(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
940  !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
941  !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
942  !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
943  !tolua_isnoobj(tolua_S,5,&tolua_err)
944  )
945  goto tolua_lerror;
946  else
947  {
948  float x = ((float) tolua_tonumber(tolua_S,2,0.0));
949  float y = ((float) tolua_tonumber(tolua_S,3,0.0));
950  float yaw = ((float) tolua_tonumber(tolua_S,4,0.0));
951  {
952  fawkes::HomPose2d* tolua_ret = (fawkes::HomPose2d*) Mtolua_new((fawkes::HomPose2d)(x,y,yaw));
953  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPose2d");
954  }
955  }
956  return 1;
957 tolua_lerror:
958  return tolua_fawkesgeometry_fawkes_HomPose2d_new00(tolua_S);
959 }
960 #endif //#ifndef TOLUA_DISABLE
961 
962 /* method: new_local of class fawkes::HomPose2d */
963 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_new01_local
964 static int tolua_fawkesgeometry_fawkes_HomPose2d_new01_local(lua_State* tolua_S)
965 {
966  tolua_Error tolua_err;
967  if (
968  !tolua_isusertable(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
969  !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
970  !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
971  !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
972  !tolua_isnoobj(tolua_S,5,&tolua_err)
973  )
974  goto tolua_lerror;
975  else
976  {
977  float x = ((float) tolua_tonumber(tolua_S,2,0.0));
978  float y = ((float) tolua_tonumber(tolua_S,3,0.0));
979  float yaw = ((float) tolua_tonumber(tolua_S,4,0.0));
980  {
981  fawkes::HomPose2d* tolua_ret = (fawkes::HomPose2d*) Mtolua_new((fawkes::HomPose2d)(x,y,yaw));
982  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPose2d");
983  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
984  }
985  }
986  return 1;
987 tolua_lerror:
988  return tolua_fawkesgeometry_fawkes_HomPose2d_new00_local(tolua_S);
989 }
990 #endif //#ifndef TOLUA_DISABLE
991 
992 /* method: new of class fawkes::HomPose2d */
993 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_new02
994 static int tolua_fawkesgeometry_fawkes_HomPose2d_new02(lua_State* tolua_S)
995 {
996  tolua_Error tolua_err;
997  if (
998  !tolua_isusertable(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
999  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPose2d",0,&tolua_err)) ||
1000  !tolua_isnoobj(tolua_S,3,&tolua_err)
1001  )
1002  goto tolua_lerror;
1003  else
1004  {
1005  const fawkes::HomPose2d* p = ((const fawkes::HomPose2d*) tolua_tousertype(tolua_S,2,0));
1006  {
1007  fawkes::HomPose2d* tolua_ret = (fawkes::HomPose2d*) Mtolua_new((fawkes::HomPose2d)(*p));
1008  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPose2d");
1009  }
1010  }
1011  return 1;
1012 tolua_lerror:
1013  return tolua_fawkesgeometry_fawkes_HomPose2d_new01(tolua_S);
1014 }
1015 #endif //#ifndef TOLUA_DISABLE
1016 
1017 /* method: new_local of class fawkes::HomPose2d */
1018 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_new02_local
1019 static int tolua_fawkesgeometry_fawkes_HomPose2d_new02_local(lua_State* tolua_S)
1020 {
1021  tolua_Error tolua_err;
1022  if (
1023  !tolua_isusertable(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
1024  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPose2d",0,&tolua_err)) ||
1025  !tolua_isnoobj(tolua_S,3,&tolua_err)
1026  )
1027  goto tolua_lerror;
1028  else
1029  {
1030  const fawkes::HomPose2d* p = ((const fawkes::HomPose2d*) tolua_tousertype(tolua_S,2,0));
1031  {
1032  fawkes::HomPose2d* tolua_ret = (fawkes::HomPose2d*) Mtolua_new((fawkes::HomPose2d)(*p));
1033  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPose2d");
1034  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1035  }
1036  }
1037  return 1;
1038 tolua_lerror:
1039  return tolua_fawkesgeometry_fawkes_HomPose2d_new01_local(tolua_S);
1040 }
1041 #endif //#ifndef TOLUA_DISABLE
1042 
1043 /* method: delete of class fawkes::HomPose2d */
1044 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_delete00
1045 static int tolua_fawkesgeometry_fawkes_HomPose2d_delete00(lua_State* tolua_S)
1046 {
1047 #ifndef TOLUA_RELEASE
1048  tolua_Error tolua_err;
1049  if (
1050  !tolua_isusertype(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
1051  !tolua_isnoobj(tolua_S,2,&tolua_err)
1052  )
1053  goto tolua_lerror;
1054  else
1055 #endif
1056  {
1057  fawkes::HomPose2d* self = (fawkes::HomPose2d*) tolua_tousertype(tolua_S,1,0);
1058 #ifndef TOLUA_RELEASE
1059  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
1060 #endif
1061  Mtolua_delete(self);
1062  }
1063  return 0;
1064 #ifndef TOLUA_RELEASE
1065  tolua_lerror:
1066  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
1067  return 0;
1068 #endif
1069 }
1070 #endif //#ifndef TOLUA_DISABLE
1071 
1072 /* method: x of class fawkes::HomPose2d */
1073 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_x00
1074 static int tolua_fawkesgeometry_fawkes_HomPose2d_x00(lua_State* tolua_S)
1075 {
1076 #ifndef TOLUA_RELEASE
1077  tolua_Error tolua_err;
1078  if (
1079  !tolua_isusertype(tolua_S,1,"const fawkes::HomPose2d",0,&tolua_err) ||
1080  !tolua_isnoobj(tolua_S,2,&tolua_err)
1081  )
1082  goto tolua_lerror;
1083  else
1084 #endif
1085  {
1086  const fawkes::HomPose2d* self = (const fawkes::HomPose2d*) tolua_tousertype(tolua_S,1,0);
1087 #ifndef TOLUA_RELEASE
1088  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'",NULL);
1089 #endif
1090  {
1091  float tolua_ret = (float) self->x();
1092  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1093  }
1094  }
1095  return 1;
1096 #ifndef TOLUA_RELEASE
1097  tolua_lerror:
1098  tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
1099  return 0;
1100 #endif
1101 }
1102 #endif //#ifndef TOLUA_DISABLE
1103 
1104 /* method: x of class fawkes::HomPose2d */
1105 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_x01
1106 static int tolua_fawkesgeometry_fawkes_HomPose2d_x01(lua_State* tolua_S)
1107 {
1108  tolua_Error tolua_err;
1109  if (
1110  !tolua_isusertype(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
1111  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1112  !tolua_isnoobj(tolua_S,3,&tolua_err)
1113  )
1114  goto tolua_lerror;
1115  else
1116  {
1117  fawkes::HomPose2d* self = (fawkes::HomPose2d*) tolua_tousertype(tolua_S,1,0);
1118  float x = ((float) tolua_tonumber(tolua_S,2,0));
1119 #ifndef TOLUA_RELEASE
1120  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'x'",NULL);
1121 #endif
1122  {
1123  self->x(x);
1124  }
1125  }
1126  return 0;
1127 tolua_lerror:
1128  return tolua_fawkesgeometry_fawkes_HomPose2d_x00(tolua_S);
1129 }
1130 #endif //#ifndef TOLUA_DISABLE
1131 
1132 /* method: y of class fawkes::HomPose2d */
1133 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_y00
1134 static int tolua_fawkesgeometry_fawkes_HomPose2d_y00(lua_State* tolua_S)
1135 {
1136 #ifndef TOLUA_RELEASE
1137  tolua_Error tolua_err;
1138  if (
1139  !tolua_isusertype(tolua_S,1,"const fawkes::HomPose2d",0,&tolua_err) ||
1140  !tolua_isnoobj(tolua_S,2,&tolua_err)
1141  )
1142  goto tolua_lerror;
1143  else
1144 #endif
1145  {
1146  const fawkes::HomPose2d* self = (const fawkes::HomPose2d*) tolua_tousertype(tolua_S,1,0);
1147 #ifndef TOLUA_RELEASE
1148  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'",NULL);
1149 #endif
1150  {
1151  float tolua_ret = (float) self->y();
1152  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1153  }
1154  }
1155  return 1;
1156 #ifndef TOLUA_RELEASE
1157  tolua_lerror:
1158  tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
1159  return 0;
1160 #endif
1161 }
1162 #endif //#ifndef TOLUA_DISABLE
1163 
1164 /* method: y of class fawkes::HomPose2d */
1165 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_y01
1166 static int tolua_fawkesgeometry_fawkes_HomPose2d_y01(lua_State* tolua_S)
1167 {
1168  tolua_Error tolua_err;
1169  if (
1170  !tolua_isusertype(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
1171  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1172  !tolua_isnoobj(tolua_S,3,&tolua_err)
1173  )
1174  goto tolua_lerror;
1175  else
1176  {
1177  fawkes::HomPose2d* self = (fawkes::HomPose2d*) tolua_tousertype(tolua_S,1,0);
1178  float y = ((float) tolua_tonumber(tolua_S,2,0));
1179 #ifndef TOLUA_RELEASE
1180  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'y'",NULL);
1181 #endif
1182  {
1183  self->y(y);
1184  }
1185  }
1186  return 0;
1187 tolua_lerror:
1188  return tolua_fawkesgeometry_fawkes_HomPose2d_y00(tolua_S);
1189 }
1190 #endif //#ifndef TOLUA_DISABLE
1191 
1192 /* method: yaw of class fawkes::HomPose2d */
1193 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_yaw00
1194 static int tolua_fawkesgeometry_fawkes_HomPose2d_yaw00(lua_State* tolua_S)
1195 {
1196 #ifndef TOLUA_RELEASE
1197  tolua_Error tolua_err;
1198  if (
1199  !tolua_isusertype(tolua_S,1,"const fawkes::HomPose2d",0,&tolua_err) ||
1200  !tolua_isnoobj(tolua_S,2,&tolua_err)
1201  )
1202  goto tolua_lerror;
1203  else
1204 #endif
1205  {
1206  const fawkes::HomPose2d* self = (const fawkes::HomPose2d*) tolua_tousertype(tolua_S,1,0);
1207 #ifndef TOLUA_RELEASE
1208  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'yaw'",NULL);
1209 #endif
1210  {
1211  float tolua_ret = (float) self->yaw();
1212  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1213  }
1214  }
1215  return 1;
1216 #ifndef TOLUA_RELEASE
1217  tolua_lerror:
1218  tolua_error(tolua_S,"#ferror in function 'yaw'.",&tolua_err);
1219  return 0;
1220 #endif
1221 }
1222 #endif //#ifndef TOLUA_DISABLE
1223 
1224 /* method: yaw of class fawkes::HomPose2d */
1225 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_yaw01
1226 static int tolua_fawkesgeometry_fawkes_HomPose2d_yaw01(lua_State* tolua_S)
1227 {
1228  tolua_Error tolua_err;
1229  if (
1230  !tolua_isusertype(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
1231  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1232  !tolua_isnoobj(tolua_S,3,&tolua_err)
1233  )
1234  goto tolua_lerror;
1235  else
1236  {
1237  fawkes::HomPose2d* self = (fawkes::HomPose2d*) tolua_tousertype(tolua_S,1,0);
1238  float yaw = ((float) tolua_tonumber(tolua_S,2,0));
1239 #ifndef TOLUA_RELEASE
1240  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'yaw'",NULL);
1241 #endif
1242  {
1243  self->yaw(yaw);
1244  }
1245  }
1246  return 0;
1247 tolua_lerror:
1248  return tolua_fawkesgeometry_fawkes_HomPose2d_yaw00(tolua_S);
1249 }
1250 #endif //#ifndef TOLUA_DISABLE
1251 
1252 /* method: position of class fawkes::HomPose2d */
1253 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_position00
1254 static int tolua_fawkesgeometry_fawkes_HomPose2d_position00(lua_State* tolua_S)
1255 {
1256 #ifndef TOLUA_RELEASE
1257  tolua_Error tolua_err;
1258  if (
1259  !tolua_isusertype(tolua_S,1,"const fawkes::HomPose2d",0,&tolua_err) ||
1260  !tolua_isnoobj(tolua_S,2,&tolua_err)
1261  )
1262  goto tolua_lerror;
1263  else
1264 #endif
1265  {
1266  const fawkes::HomPose2d* self = (const fawkes::HomPose2d*) tolua_tousertype(tolua_S,1,0);
1267 #ifndef TOLUA_RELEASE
1268  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'position'",NULL);
1269 #endif
1270  {
1271  const fawkes::HomPoint& tolua_ret = (const fawkes::HomPoint&) self->position();
1272  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const fawkes::HomPoint");
1273  }
1274  }
1275  return 1;
1276 #ifndef TOLUA_RELEASE
1277  tolua_lerror:
1278  tolua_error(tolua_S,"#ferror in function 'position'.",&tolua_err);
1279  return 0;
1280 #endif
1281 }
1282 #endif //#ifndef TOLUA_DISABLE
1283 
1284 /* method: orientation of class fawkes::HomPose2d */
1285 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_orientation00
1286 static int tolua_fawkesgeometry_fawkes_HomPose2d_orientation00(lua_State* tolua_S)
1287 {
1288 #ifndef TOLUA_RELEASE
1289  tolua_Error tolua_err;
1290  if (
1291  !tolua_isusertype(tolua_S,1,"const fawkes::HomPose2d",0,&tolua_err) ||
1292  !tolua_isnoobj(tolua_S,2,&tolua_err)
1293  )
1294  goto tolua_lerror;
1295  else
1296 #endif
1297  {
1298  const fawkes::HomPose2d* self = (const fawkes::HomPose2d*) tolua_tousertype(tolua_S,1,0);
1299 #ifndef TOLUA_RELEASE
1300  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'orientation'",NULL);
1301 #endif
1302  {
1303  const fawkes::HomVector& tolua_ret = (const fawkes::HomVector&) self->orientation();
1304  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const fawkes::HomVector");
1305  }
1306  }
1307  return 1;
1308 #ifndef TOLUA_RELEASE
1309  tolua_lerror:
1310  tolua_error(tolua_S,"#ferror in function 'orientation'.",&tolua_err);
1311  return 0;
1312 #endif
1313 }
1314 #endif //#ifndef TOLUA_DISABLE
1315 
1316 /* method: set_position of class fawkes::HomPose2d */
1317 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPose2d_set_position00
1318 static int tolua_fawkesgeometry_fawkes_HomPose2d_set_position00(lua_State* tolua_S)
1319 {
1320 #ifndef TOLUA_RELEASE
1321  tolua_Error tolua_err;
1322  if (
1323  !tolua_isusertype(tolua_S,1,"fawkes::HomPose2d",0,&tolua_err) ||
1324  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPoint",0,&tolua_err)) ||
1325  !tolua_isnoobj(tolua_S,3,&tolua_err)
1326  )
1327  goto tolua_lerror;
1328  else
1329 #endif
1330  {
1331  fawkes::HomPose2d* self = (fawkes::HomPose2d*) tolua_tousertype(tolua_S,1,0);
1332  const fawkes::HomPoint* p = ((const fawkes::HomPoint*) tolua_tousertype(tolua_S,2,0));
1333 #ifndef TOLUA_RELEASE
1334  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_position'",NULL);
1335 #endif
1336  {
1337  self->set_position(*p);
1338  }
1339  }
1340  return 0;
1341 #ifndef TOLUA_RELEASE
1342  tolua_lerror:
1343  tolua_error(tolua_S,"#ferror in function 'set_position'.",&tolua_err);
1344  return 0;
1345 #endif
1346 }
1347 #endif //#ifndef TOLUA_DISABLE
1348 
1349 /* method: new of class fawkes::HomTransform */
1350 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_new00
1351 static int tolua_fawkesgeometry_fawkes_HomTransform_new00(lua_State* tolua_S)
1352 {
1353 #ifndef TOLUA_RELEASE
1354  tolua_Error tolua_err;
1355  if (
1356  !tolua_isusertable(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
1357  !tolua_isnoobj(tolua_S,2,&tolua_err)
1358  )
1359  goto tolua_lerror;
1360  else
1361 #endif
1362  {
1363  {
1364  fawkes::HomTransform* tolua_ret = (fawkes::HomTransform*) Mtolua_new((fawkes::HomTransform)());
1365  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomTransform");
1366  }
1367  }
1368  return 1;
1369 #ifndef TOLUA_RELEASE
1370  tolua_lerror:
1371  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1372  return 0;
1373 #endif
1374 }
1375 #endif //#ifndef TOLUA_DISABLE
1376 
1377 /* method: new_local of class fawkes::HomTransform */
1378 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_new00_local
1379 static int tolua_fawkesgeometry_fawkes_HomTransform_new00_local(lua_State* tolua_S)
1380 {
1381 #ifndef TOLUA_RELEASE
1382  tolua_Error tolua_err;
1383  if (
1384  !tolua_isusertable(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
1385  !tolua_isnoobj(tolua_S,2,&tolua_err)
1386  )
1387  goto tolua_lerror;
1388  else
1389 #endif
1390  {
1391  {
1392  fawkes::HomTransform* tolua_ret = (fawkes::HomTransform*) Mtolua_new((fawkes::HomTransform)());
1393  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomTransform");
1394  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1395  }
1396  }
1397  return 1;
1398 #ifndef TOLUA_RELEASE
1399  tolua_lerror:
1400  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1401  return 0;
1402 #endif
1403 }
1404 #endif //#ifndef TOLUA_DISABLE
1405 
1406 /* method: new of class fawkes::HomTransform */
1407 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_new01
1408 static int tolua_fawkesgeometry_fawkes_HomTransform_new01(lua_State* tolua_S)
1409 {
1410  tolua_Error tolua_err;
1411  if (
1412  !tolua_isusertable(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
1413  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomTransform",0,&tolua_err)) ||
1414  !tolua_isnoobj(tolua_S,3,&tolua_err)
1415  )
1416  goto tolua_lerror;
1417  else
1418  {
1419  const fawkes::HomTransform* ht = ((const fawkes::HomTransform*) tolua_tousertype(tolua_S,2,0));
1420  {
1421  fawkes::HomTransform* tolua_ret = (fawkes::HomTransform*) Mtolua_new((fawkes::HomTransform)(*ht));
1422  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomTransform");
1423  }
1424  }
1425  return 1;
1426 tolua_lerror:
1427  return tolua_fawkesgeometry_fawkes_HomTransform_new00(tolua_S);
1428 }
1429 #endif //#ifndef TOLUA_DISABLE
1430 
1431 /* method: new_local of class fawkes::HomTransform */
1432 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_new01_local
1433 static int tolua_fawkesgeometry_fawkes_HomTransform_new01_local(lua_State* tolua_S)
1434 {
1435  tolua_Error tolua_err;
1436  if (
1437  !tolua_isusertable(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
1438  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomTransform",0,&tolua_err)) ||
1439  !tolua_isnoobj(tolua_S,3,&tolua_err)
1440  )
1441  goto tolua_lerror;
1442  else
1443  {
1444  const fawkes::HomTransform* ht = ((const fawkes::HomTransform*) tolua_tousertype(tolua_S,2,0));
1445  {
1446  fawkes::HomTransform* tolua_ret = (fawkes::HomTransform*) Mtolua_new((fawkes::HomTransform)(*ht));
1447  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomTransform");
1448  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1449  }
1450  }
1451  return 1;
1452 tolua_lerror:
1453  return tolua_fawkesgeometry_fawkes_HomTransform_new00_local(tolua_S);
1454 }
1455 #endif //#ifndef TOLUA_DISABLE
1456 
1457 /* method: new of class fawkes::HomTransform */
1458 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_new02
1459 static int tolua_fawkesgeometry_fawkes_HomTransform_new02(lua_State* tolua_S)
1460 {
1461  tolua_Error tolua_err;
1462  if (
1463  !tolua_isusertable(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
1464  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Matrix",0,&tolua_err)) ||
1465  !tolua_isnoobj(tolua_S,3,&tolua_err)
1466  )
1467  goto tolua_lerror;
1468  else
1469  {
1470  const fawkes::Matrix* m = ((const fawkes::Matrix*) tolua_tousertype(tolua_S,2,0));
1471  {
1472  fawkes::HomTransform* tolua_ret = (fawkes::HomTransform*) Mtolua_new((fawkes::HomTransform)(*m));
1473  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomTransform");
1474  }
1475  }
1476  return 1;
1477 tolua_lerror:
1478  return tolua_fawkesgeometry_fawkes_HomTransform_new01(tolua_S);
1479 }
1480 #endif //#ifndef TOLUA_DISABLE
1481 
1482 /* method: new_local of class fawkes::HomTransform */
1483 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_new02_local
1484 static int tolua_fawkesgeometry_fawkes_HomTransform_new02_local(lua_State* tolua_S)
1485 {
1486  tolua_Error tolua_err;
1487  if (
1488  !tolua_isusertable(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
1489  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::Matrix",0,&tolua_err)) ||
1490  !tolua_isnoobj(tolua_S,3,&tolua_err)
1491  )
1492  goto tolua_lerror;
1493  else
1494  {
1495  const fawkes::Matrix* m = ((const fawkes::Matrix*) tolua_tousertype(tolua_S,2,0));
1496  {
1497  fawkes::HomTransform* tolua_ret = (fawkes::HomTransform*) Mtolua_new((fawkes::HomTransform)(*m));
1498  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomTransform");
1499  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1500  }
1501  }
1502  return 1;
1503 tolua_lerror:
1504  return tolua_fawkesgeometry_fawkes_HomTransform_new01_local(tolua_S);
1505 }
1506 #endif //#ifndef TOLUA_DISABLE
1507 
1508 /* method: delete of class fawkes::HomTransform */
1509 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_delete00
1510 static int tolua_fawkesgeometry_fawkes_HomTransform_delete00(lua_State* tolua_S)
1511 {
1512 #ifndef TOLUA_RELEASE
1513  tolua_Error tolua_err;
1514  if (
1515  !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
1516  !tolua_isnoobj(tolua_S,2,&tolua_err)
1517  )
1518  goto tolua_lerror;
1519  else
1520 #endif
1521  {
1522  fawkes::HomTransform* self = (fawkes::HomTransform*) tolua_tousertype(tolua_S,1,0);
1523 #ifndef TOLUA_RELEASE
1524  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
1525 #endif
1526  Mtolua_delete(self);
1527  }
1528  return 0;
1529 #ifndef TOLUA_RELEASE
1530  tolua_lerror:
1531  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
1532  return 0;
1533 #endif
1534 }
1535 #endif //#ifndef TOLUA_DISABLE
1536 
1537 /* method: reset of class fawkes::HomTransform */
1538 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_reset00
1539 static int tolua_fawkesgeometry_fawkes_HomTransform_reset00(lua_State* tolua_S)
1540 {
1541 #ifndef TOLUA_RELEASE
1542  tolua_Error tolua_err;
1543  if (
1544  !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
1545  !tolua_isnoobj(tolua_S,2,&tolua_err)
1546  )
1547  goto tolua_lerror;
1548  else
1549 #endif
1550  {
1551  fawkes::HomTransform* self = (fawkes::HomTransform*) tolua_tousertype(tolua_S,1,0);
1552 #ifndef TOLUA_RELEASE
1553  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reset'",NULL);
1554 #endif
1555  {
1556  fawkes::HomTransform& tolua_ret = (fawkes::HomTransform&) self->reset();
1557  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomTransform");
1558  }
1559  }
1560  return 1;
1561 #ifndef TOLUA_RELEASE
1562  tolua_lerror:
1563  tolua_error(tolua_S,"#ferror in function 'reset'.",&tolua_err);
1564  return 0;
1565 #endif
1566 }
1567 #endif //#ifndef TOLUA_DISABLE
1568 
1569 /* method: invert of class fawkes::HomTransform */
1570 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_invert00
1571 static int tolua_fawkesgeometry_fawkes_HomTransform_invert00(lua_State* tolua_S)
1572 {
1573 #ifndef TOLUA_RELEASE
1574  tolua_Error tolua_err;
1575  if (
1576  !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
1577  !tolua_isnoobj(tolua_S,2,&tolua_err)
1578  )
1579  goto tolua_lerror;
1580  else
1581 #endif
1582  {
1583  fawkes::HomTransform* self = (fawkes::HomTransform*) tolua_tousertype(tolua_S,1,0);
1584 #ifndef TOLUA_RELEASE
1585  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'invert'",NULL);
1586 #endif
1587  {
1588  fawkes::HomTransform& tolua_ret = (fawkes::HomTransform&) self->invert();
1589  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomTransform");
1590  }
1591  }
1592  return 1;
1593 #ifndef TOLUA_RELEASE
1594  tolua_lerror:
1595  tolua_error(tolua_S,"#ferror in function 'invert'.",&tolua_err);
1596  return 0;
1597 #endif
1598 }
1599 #endif //#ifndef TOLUA_DISABLE
1600 
1601 /* method: get_inverse of class fawkes::HomTransform */
1602 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_get_inverse00
1603 static int tolua_fawkesgeometry_fawkes_HomTransform_get_inverse00(lua_State* tolua_S)
1604 {
1605 #ifndef TOLUA_RELEASE
1606  tolua_Error tolua_err;
1607  if (
1608  !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
1609  !tolua_isnoobj(tolua_S,2,&tolua_err)
1610  )
1611  goto tolua_lerror;
1612  else
1613 #endif
1614  {
1615  fawkes::HomTransform* self = (fawkes::HomTransform*) tolua_tousertype(tolua_S,1,0);
1616 #ifndef TOLUA_RELEASE
1617  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_inverse'",NULL);
1618 #endif
1619  {
1621  {
1622 #ifdef __cplusplus
1623  void* tolua_obj = Mtolua_new((fawkes::HomTransform)(tolua_ret));
1624  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomTransform");
1625  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1626 #else
1627  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomTransform));
1628  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomTransform");
1629  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1630 #endif
1631  }
1632  }
1633  }
1634  return 1;
1635 #ifndef TOLUA_RELEASE
1636  tolua_lerror:
1637  tolua_error(tolua_S,"#ferror in function 'get_inverse'.",&tolua_err);
1638  return 0;
1639 #endif
1640 }
1641 #endif //#ifndef TOLUA_DISABLE
1642 
1643 /* method: rotate_x of class fawkes::HomTransform */
1644 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_rotate_x00
1645 static int tolua_fawkesgeometry_fawkes_HomTransform_rotate_x00(lua_State* tolua_S)
1646 {
1647 #ifndef TOLUA_RELEASE
1648  tolua_Error tolua_err;
1649  if (
1650  !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
1651  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1652  !tolua_isnoobj(tolua_S,3,&tolua_err)
1653  )
1654  goto tolua_lerror;
1655  else
1656 #endif
1657  {
1658  fawkes::HomTransform* self = (fawkes::HomTransform*) tolua_tousertype(tolua_S,1,0);
1659  float rad = ((float) tolua_tonumber(tolua_S,2,0));
1660 #ifndef TOLUA_RELEASE
1661  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotate_x'",NULL);
1662 #endif
1663  {
1664  self->rotate_x(rad);
1665  }
1666  }
1667  return 0;
1668 #ifndef TOLUA_RELEASE
1669  tolua_lerror:
1670  tolua_error(tolua_S,"#ferror in function 'rotate_x'.",&tolua_err);
1671  return 0;
1672 #endif
1673 }
1674 #endif //#ifndef TOLUA_DISABLE
1675 
1676 /* method: rotate_y of class fawkes::HomTransform */
1677 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_rotate_y00
1678 static int tolua_fawkesgeometry_fawkes_HomTransform_rotate_y00(lua_State* tolua_S)
1679 {
1680 #ifndef TOLUA_RELEASE
1681  tolua_Error tolua_err;
1682  if (
1683  !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
1684  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1685  !tolua_isnoobj(tolua_S,3,&tolua_err)
1686  )
1687  goto tolua_lerror;
1688  else
1689 #endif
1690  {
1691  fawkes::HomTransform* self = (fawkes::HomTransform*) tolua_tousertype(tolua_S,1,0);
1692  float rad = ((float) tolua_tonumber(tolua_S,2,0));
1693 #ifndef TOLUA_RELEASE
1694  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotate_y'",NULL);
1695 #endif
1696  {
1697  self->rotate_y(rad);
1698  }
1699  }
1700  return 0;
1701 #ifndef TOLUA_RELEASE
1702  tolua_lerror:
1703  tolua_error(tolua_S,"#ferror in function 'rotate_y'.",&tolua_err);
1704  return 0;
1705 #endif
1706 }
1707 #endif //#ifndef TOLUA_DISABLE
1708 
1709 /* method: rotate_z of class fawkes::HomTransform */
1710 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_rotate_z00
1711 static int tolua_fawkesgeometry_fawkes_HomTransform_rotate_z00(lua_State* tolua_S)
1712 {
1713 #ifndef TOLUA_RELEASE
1714  tolua_Error tolua_err;
1715  if (
1716  !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
1717  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1718  !tolua_isnoobj(tolua_S,3,&tolua_err)
1719  )
1720  goto tolua_lerror;
1721  else
1722 #endif
1723  {
1724  fawkes::HomTransform* self = (fawkes::HomTransform*) tolua_tousertype(tolua_S,1,0);
1725  float rad = ((float) tolua_tonumber(tolua_S,2,0));
1726 #ifndef TOLUA_RELEASE
1727  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rotate_z'",NULL);
1728 #endif
1729  {
1730  self->rotate_z(rad);
1731  }
1732  }
1733  return 0;
1734 #ifndef TOLUA_RELEASE
1735  tolua_lerror:
1736  tolua_error(tolua_S,"#ferror in function 'rotate_z'.",&tolua_err);
1737  return 0;
1738 #endif
1739 }
1740 #endif //#ifndef TOLUA_DISABLE
1741 
1742 /* method: trans of class fawkes::HomTransform */
1743 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_trans00
1744 static int tolua_fawkesgeometry_fawkes_HomTransform_trans00(lua_State* tolua_S)
1745 {
1746 #ifndef TOLUA_RELEASE
1747  tolua_Error tolua_err;
1748  if (
1749  !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
1750  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1751  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1752  !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
1753  !tolua_isnoobj(tolua_S,5,&tolua_err)
1754  )
1755  goto tolua_lerror;
1756  else
1757 #endif
1758  {
1759  fawkes::HomTransform* self = (fawkes::HomTransform*) tolua_tousertype(tolua_S,1,0);
1760  float dx = ((float) tolua_tonumber(tolua_S,2,0));
1761  float dy = ((float) tolua_tonumber(tolua_S,3,0));
1762  float dz = ((float) tolua_tonumber(tolua_S,4,0.0));
1763 #ifndef TOLUA_RELEASE
1764  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'trans'",NULL);
1765 #endif
1766  {
1767  self->trans(dx,dy,dz);
1768  }
1769  }
1770  return 0;
1771 #ifndef TOLUA_RELEASE
1772  tolua_lerror:
1773  tolua_error(tolua_S,"#ferror in function 'trans'.",&tolua_err);
1774  return 0;
1775 #endif
1776 }
1777 #endif //#ifndef TOLUA_DISABLE
1778 
1779 /* method: set_trans of class fawkes::HomTransform */
1780 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_set_trans00
1781 static int tolua_fawkesgeometry_fawkes_HomTransform_set_trans00(lua_State* tolua_S)
1782 {
1783 #ifndef TOLUA_RELEASE
1784  tolua_Error tolua_err;
1785  if (
1786  !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
1787  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1788  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1789  !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
1790  !tolua_isnoobj(tolua_S,5,&tolua_err)
1791  )
1792  goto tolua_lerror;
1793  else
1794 #endif
1795  {
1796  fawkes::HomTransform* self = (fawkes::HomTransform*) tolua_tousertype(tolua_S,1,0);
1797  float x = ((float) tolua_tonumber(tolua_S,2,0));
1798  float y = ((float) tolua_tonumber(tolua_S,3,0));
1799  float z = ((float) tolua_tonumber(tolua_S,4,0.0));
1800 #ifndef TOLUA_RELEASE
1801  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_trans'",NULL);
1802 #endif
1803  {
1804  self->set_trans(x,y,z);
1805  }
1806  }
1807  return 0;
1808 #ifndef TOLUA_RELEASE
1809  tolua_lerror:
1810  tolua_error(tolua_S,"#ferror in function 'set_trans'.",&tolua_err);
1811  return 0;
1812 #endif
1813 }
1814 #endif //#ifndef TOLUA_DISABLE
1815 
1816 /* method: mDH of class fawkes::HomTransform */
1817 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_mDH00
1818 static int tolua_fawkesgeometry_fawkes_HomTransform_mDH00(lua_State* tolua_S)
1819 {
1820 #ifndef TOLUA_RELEASE
1821  tolua_Error tolua_err;
1822  if (
1823  !tolua_isusertype(tolua_S,1,"fawkes::HomTransform",0,&tolua_err) ||
1824  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
1825  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
1826  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
1827  !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
1828  !tolua_isnoobj(tolua_S,6,&tolua_err)
1829  )
1830  goto tolua_lerror;
1831  else
1832 #endif
1833  {
1834  fawkes::HomTransform* self = (fawkes::HomTransform*) tolua_tousertype(tolua_S,1,0);
1835  const float alpha = ((const float) tolua_tonumber(tolua_S,2,0));
1836  const float a = ((const float) tolua_tonumber(tolua_S,3,0));
1837  const float theta = ((const float) tolua_tonumber(tolua_S,4,0));
1838  const float d = ((const float) tolua_tonumber(tolua_S,5,0));
1839 #ifndef TOLUA_RELEASE
1840  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mDH'",NULL);
1841 #endif
1842  {
1843  self->mDH(alpha,a,theta,d);
1844  }
1845  }
1846  return 0;
1847 #ifndef TOLUA_RELEASE
1848  tolua_lerror:
1849  tolua_error(tolua_S,"#ferror in function 'mDH'.",&tolua_err);
1850  return 0;
1851 #endif
1852 }
1853 #endif //#ifndef TOLUA_DISABLE
1854 
1855 /* method: operator* of class fawkes::HomTransform */
1856 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform__mul00
1857 static int tolua_fawkesgeometry_fawkes_HomTransform__mul00(lua_State* tolua_S)
1858 {
1859 #ifndef TOLUA_RELEASE
1860  tolua_Error tolua_err;
1861  if (
1862  !tolua_isusertype(tolua_S,1,"const fawkes::HomTransform",0,&tolua_err) ||
1863  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomVector",0,&tolua_err)) ||
1864  !tolua_isnoobj(tolua_S,3,&tolua_err)
1865  )
1866  goto tolua_lerror;
1867  else
1868 #endif
1869  {
1870  const fawkes::HomTransform* self = (const fawkes::HomTransform*) tolua_tousertype(tolua_S,1,0);
1871  const fawkes::HomVector* v = ((const fawkes::HomVector*) tolua_tousertype(tolua_S,2,0));
1872 #ifndef TOLUA_RELEASE
1873  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'",NULL);
1874 #endif
1875  {
1876  fawkes::HomVector tolua_ret = (fawkes::HomVector) self->operator*(*v);
1877  {
1878 #ifdef __cplusplus
1879  void* tolua_obj = Mtolua_new((fawkes::HomVector)(tolua_ret));
1880  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomVector");
1881  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1882 #else
1883  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomVector));
1884  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomVector");
1885  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1886 #endif
1887  }
1888  }
1889  }
1890  return 1;
1891 #ifndef TOLUA_RELEASE
1892  tolua_lerror:
1893  tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err);
1894  return 0;
1895 #endif
1896 }
1897 #endif //#ifndef TOLUA_DISABLE
1898 
1899 /* method: operator* of class fawkes::HomTransform */
1900 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform__mul01
1901 static int tolua_fawkesgeometry_fawkes_HomTransform__mul01(lua_State* tolua_S)
1902 {
1903  tolua_Error tolua_err;
1904  if (
1905  !tolua_isusertype(tolua_S,1,"const fawkes::HomTransform",0,&tolua_err) ||
1906  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPoint",0,&tolua_err)) ||
1907  !tolua_isnoobj(tolua_S,3,&tolua_err)
1908  )
1909  goto tolua_lerror;
1910  else
1911  {
1912  const fawkes::HomTransform* self = (const fawkes::HomTransform*) tolua_tousertype(tolua_S,1,0);
1913  const fawkes::HomPoint* p = ((const fawkes::HomPoint*) tolua_tousertype(tolua_S,2,0));
1914 #ifndef TOLUA_RELEASE
1915  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'",NULL);
1916 #endif
1917  {
1918  fawkes::HomPoint tolua_ret = (fawkes::HomPoint) self->operator*(*p);
1919  {
1920 #ifdef __cplusplus
1921  void* tolua_obj = Mtolua_new((fawkes::HomPoint)(tolua_ret));
1922  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomPoint");
1923  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1924 #else
1925  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomPoint));
1926  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomPoint");
1927  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1928 #endif
1929  }
1930  }
1931  }
1932  return 1;
1933 tolua_lerror:
1934  return tolua_fawkesgeometry_fawkes_HomTransform__mul00(tolua_S);
1935 }
1936 #endif //#ifndef TOLUA_DISABLE
1937 
1938 /* method: operator* of class fawkes::HomTransform */
1939 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform__mul02
1940 static int tolua_fawkesgeometry_fawkes_HomTransform__mul02(lua_State* tolua_S)
1941 {
1942  tolua_Error tolua_err;
1943  if (
1944  !tolua_isusertype(tolua_S,1,"const fawkes::HomTransform",0,&tolua_err) ||
1945  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPose2d",0,&tolua_err)) ||
1946  !tolua_isnoobj(tolua_S,3,&tolua_err)
1947  )
1948  goto tolua_lerror;
1949  else
1950  {
1951  const fawkes::HomTransform* self = (const fawkes::HomTransform*) tolua_tousertype(tolua_S,1,0);
1952  const fawkes::HomPose2d* p = ((const fawkes::HomPose2d*) tolua_tousertype(tolua_S,2,0));
1953 #ifndef TOLUA_RELEASE
1954  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'",NULL);
1955 #endif
1956  {
1957  fawkes::HomPose2d tolua_ret = (fawkes::HomPose2d) self->operator*(*p);
1958  {
1959 #ifdef __cplusplus
1960  void* tolua_obj = Mtolua_new((fawkes::HomPose2d)(tolua_ret));
1961  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomPose2d");
1962  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1963 #else
1964  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomPose2d));
1965  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomPose2d");
1966  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1967 #endif
1968  }
1969  }
1970  }
1971  return 1;
1972 tolua_lerror:
1973  return tolua_fawkesgeometry_fawkes_HomTransform__mul01(tolua_S);
1974 }
1975 #endif //#ifndef TOLUA_DISABLE
1976 
1977 /* method: operator== of class fawkes::HomTransform */
1978 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform__eq00
1979 static int tolua_fawkesgeometry_fawkes_HomTransform__eq00(lua_State* tolua_S)
1980 {
1981 #ifndef TOLUA_RELEASE
1982  tolua_Error tolua_err;
1983  if (
1984  !tolua_isusertype(tolua_S,1,"const fawkes::HomTransform",0,&tolua_err) ||
1985  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomTransform",0,&tolua_err)) ||
1986  !tolua_isnoobj(tolua_S,3,&tolua_err)
1987  )
1988  goto tolua_lerror;
1989  else
1990 #endif
1991  {
1992  const fawkes::HomTransform* self = (const fawkes::HomTransform*) tolua_tousertype(tolua_S,1,0);
1993  const fawkes::HomTransform* t = ((const fawkes::HomTransform*) tolua_tousertype(tolua_S,2,0));
1994 #ifndef TOLUA_RELEASE
1995  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
1996 #endif
1997  {
1998  bool tolua_ret = (bool) self->operator==(*t);
1999  tolua_pushboolean(tolua_S,(bool)tolua_ret);
2000  }
2001  }
2002  return 1;
2003 #ifndef TOLUA_RELEASE
2004  tolua_lerror:
2005  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
2006  return 0;
2007 #endif
2008 }
2009 #endif //#ifndef TOLUA_DISABLE
2010 
2011 /* method: print_info of class fawkes::HomTransform */
2012 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_print_info00
2013 static int tolua_fawkesgeometry_fawkes_HomTransform_print_info00(lua_State* tolua_S)
2014 {
2015 #ifndef TOLUA_RELEASE
2016  tolua_Error tolua_err;
2017  if (
2018  !tolua_isusertype(tolua_S,1,"const fawkes::HomTransform",0,&tolua_err) ||
2019  !tolua_isstring(tolua_S,2,1,&tolua_err) ||
2020  !tolua_isstring(tolua_S,3,1,&tolua_err) ||
2021  !tolua_isstring(tolua_S,4,1,&tolua_err) ||
2022  !tolua_isnoobj(tolua_S,5,&tolua_err)
2023  )
2024  goto tolua_lerror;
2025  else
2026 #endif
2027  {
2028  const fawkes::HomTransform* self = (const fawkes::HomTransform*) tolua_tousertype(tolua_S,1,0);
2029  const char* name = ((const char*) tolua_tostring(tolua_S,2,0));
2030  const char* col_sep = ((const char*) tolua_tostring(tolua_S,3,0));
2031  const char* row_sep = ((const char*) tolua_tostring(tolua_S,4,0));
2032 #ifndef TOLUA_RELEASE
2033  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'print_info'",NULL);
2034 #endif
2035  {
2036  self->print_info(name,col_sep,row_sep);
2037  }
2038  }
2039  return 0;
2040 #ifndef TOLUA_RELEASE
2041  tolua_lerror:
2042  tolua_error(tolua_S,"#ferror in function 'print_info'.",&tolua_err);
2043  return 0;
2044 #endif
2045 }
2046 #endif //#ifndef TOLUA_DISABLE
2047 
2048 /* method: get_matrix of class fawkes::HomTransform */
2049 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomTransform_get_matrix00
2050 static int tolua_fawkesgeometry_fawkes_HomTransform_get_matrix00(lua_State* tolua_S)
2051 {
2052 #ifndef TOLUA_RELEASE
2053  tolua_Error tolua_err;
2054  if (
2055  !tolua_isusertype(tolua_S,1,"const fawkes::HomTransform",0,&tolua_err) ||
2056  !tolua_isnoobj(tolua_S,2,&tolua_err)
2057  )
2058  goto tolua_lerror;
2059  else
2060 #endif
2061  {
2062  const fawkes::HomTransform* self = (const fawkes::HomTransform*) tolua_tousertype(tolua_S,1,0);
2063 #ifndef TOLUA_RELEASE
2064  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get_matrix'",NULL);
2065 #endif
2066  {
2067  const fawkes::Matrix& tolua_ret = (const fawkes::Matrix&) self->get_matrix();
2068  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const fawkes::Matrix");
2069  }
2070  }
2071  return 1;
2072 #ifndef TOLUA_RELEASE
2073  tolua_lerror:
2074  tolua_error(tolua_S,"#ferror in function 'get_matrix'.",&tolua_err);
2075  return 0;
2076 #endif
2077 }
2078 #endif //#ifndef TOLUA_DISABLE
2079 
2080 /* method: new of class fawkes::HomVector */
2081 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_new00
2082 static int tolua_fawkesgeometry_fawkes_HomVector_new00(lua_State* tolua_S)
2083 {
2084 #ifndef TOLUA_RELEASE
2085  tolua_Error tolua_err;
2086  if (
2087  !tolua_isusertable(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
2088  !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
2089  !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
2090  !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
2091  !tolua_isnoobj(tolua_S,5,&tolua_err)
2092  )
2093  goto tolua_lerror;
2094  else
2095 #endif
2096  {
2097  float x = ((float) tolua_tonumber(tolua_S,2,0));
2098  float y = ((float) tolua_tonumber(tolua_S,3,0));
2099  float z = ((float) tolua_tonumber(tolua_S,4,0));
2100  {
2101  fawkes::HomVector* tolua_ret = (fawkes::HomVector*) Mtolua_new((fawkes::HomVector)(x,y,z));
2102  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomVector");
2103  }
2104  }
2105  return 1;
2106 #ifndef TOLUA_RELEASE
2107  tolua_lerror:
2108  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
2109  return 0;
2110 #endif
2111 }
2112 #endif //#ifndef TOLUA_DISABLE
2113 
2114 /* method: new_local of class fawkes::HomVector */
2115 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_new00_local
2116 static int tolua_fawkesgeometry_fawkes_HomVector_new00_local(lua_State* tolua_S)
2117 {
2118 #ifndef TOLUA_RELEASE
2119  tolua_Error tolua_err;
2120  if (
2121  !tolua_isusertable(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
2122  !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
2123  !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
2124  !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
2125  !tolua_isnoobj(tolua_S,5,&tolua_err)
2126  )
2127  goto tolua_lerror;
2128  else
2129 #endif
2130  {
2131  float x = ((float) tolua_tonumber(tolua_S,2,0));
2132  float y = ((float) tolua_tonumber(tolua_S,3,0));
2133  float z = ((float) tolua_tonumber(tolua_S,4,0));
2134  {
2135  fawkes::HomVector* tolua_ret = (fawkes::HomVector*) Mtolua_new((fawkes::HomVector)(x,y,z));
2136  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomVector");
2137  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2138  }
2139  }
2140  return 1;
2141 #ifndef TOLUA_RELEASE
2142  tolua_lerror:
2143  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
2144  return 0;
2145 #endif
2146 }
2147 #endif //#ifndef TOLUA_DISABLE
2148 
2149 /* method: new of class fawkes::HomVector */
2150 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_new01
2151 static int tolua_fawkesgeometry_fawkes_HomVector_new01(lua_State* tolua_S)
2152 {
2153  tolua_Error tolua_err;
2154  if (
2155  !tolua_isusertable(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
2156  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
2157  !tolua_isnoobj(tolua_S,3,&tolua_err)
2158  )
2159  goto tolua_lerror;
2160  else
2161  {
2162  const fawkes::HomCoord* h = ((const fawkes::HomCoord*) tolua_tousertype(tolua_S,2,0));
2163  {
2164  fawkes::HomVector* tolua_ret = (fawkes::HomVector*) Mtolua_new((fawkes::HomVector)(*h));
2165  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomVector");
2166  }
2167  }
2168  return 1;
2169 tolua_lerror:
2170  return tolua_fawkesgeometry_fawkes_HomVector_new00(tolua_S);
2171 }
2172 #endif //#ifndef TOLUA_DISABLE
2173 
2174 /* method: new_local of class fawkes::HomVector */
2175 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_new01_local
2176 static int tolua_fawkesgeometry_fawkes_HomVector_new01_local(lua_State* tolua_S)
2177 {
2178  tolua_Error tolua_err;
2179  if (
2180  !tolua_isusertable(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
2181  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
2182  !tolua_isnoobj(tolua_S,3,&tolua_err)
2183  )
2184  goto tolua_lerror;
2185  else
2186  {
2187  const fawkes::HomCoord* h = ((const fawkes::HomCoord*) tolua_tousertype(tolua_S,2,0));
2188  {
2189  fawkes::HomVector* tolua_ret = (fawkes::HomVector*) Mtolua_new((fawkes::HomVector)(*h));
2190  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomVector");
2191  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2192  }
2193  }
2194  return 1;
2195 tolua_lerror:
2196  return tolua_fawkesgeometry_fawkes_HomVector_new00_local(tolua_S);
2197 }
2198 #endif //#ifndef TOLUA_DISABLE
2199 
2200 /* method: delete of class fawkes::HomVector */
2201 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_delete00
2202 static int tolua_fawkesgeometry_fawkes_HomVector_delete00(lua_State* tolua_S)
2203 {
2204 #ifndef TOLUA_RELEASE
2205  tolua_Error tolua_err;
2206  if (
2207  !tolua_isusertype(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
2208  !tolua_isnoobj(tolua_S,2,&tolua_err)
2209  )
2210  goto tolua_lerror;
2211  else
2212 #endif
2213  {
2214  fawkes::HomVector* self = (fawkes::HomVector*) tolua_tousertype(tolua_S,1,0);
2215 #ifndef TOLUA_RELEASE
2216  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
2217 #endif
2218  Mtolua_delete(self);
2219  }
2220  return 0;
2221 #ifndef TOLUA_RELEASE
2222  tolua_lerror:
2223  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
2224  return 0;
2225 #endif
2226 }
2227 #endif //#ifndef TOLUA_DISABLE
2228 
2229 /* method: length of class fawkes::HomVector */
2230 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_length00
2231 static int tolua_fawkesgeometry_fawkes_HomVector_length00(lua_State* tolua_S)
2232 {
2233 #ifndef TOLUA_RELEASE
2234  tolua_Error tolua_err;
2235  if (
2236  !tolua_isusertype(tolua_S,1,"const fawkes::HomVector",0,&tolua_err) ||
2237  !tolua_isnoobj(tolua_S,2,&tolua_err)
2238  )
2239  goto tolua_lerror;
2240  else
2241 #endif
2242  {
2243  const fawkes::HomVector* self = (const fawkes::HomVector*) tolua_tousertype(tolua_S,1,0);
2244 #ifndef TOLUA_RELEASE
2245  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'length'",NULL);
2246 #endif
2247  {
2248  float tolua_ret = (float) self->length();
2249  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2250  }
2251  }
2252  return 1;
2253 #ifndef TOLUA_RELEASE
2254  tolua_lerror:
2255  tolua_error(tolua_S,"#ferror in function 'length'.",&tolua_err);
2256  return 0;
2257 #endif
2258 }
2259 #endif //#ifndef TOLUA_DISABLE
2260 
2261 /* method: set_length of class fawkes::HomVector */
2262 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_set_length00
2263 static int tolua_fawkesgeometry_fawkes_HomVector_set_length00(lua_State* tolua_S)
2264 {
2265 #ifndef TOLUA_RELEASE
2266  tolua_Error tolua_err;
2267  if (
2268  !tolua_isusertype(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
2269  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2270  !tolua_isnoobj(tolua_S,3,&tolua_err)
2271  )
2272  goto tolua_lerror;
2273  else
2274 #endif
2275  {
2276  fawkes::HomVector* self = (fawkes::HomVector*) tolua_tousertype(tolua_S,1,0);
2277  float length = ((float) tolua_tonumber(tolua_S,2,0));
2278 #ifndef TOLUA_RELEASE
2279  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_length'",NULL);
2280 #endif
2281  {
2282  fawkes::HomVector& tolua_ret = (fawkes::HomVector&) self->set_length(length);
2283  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomVector");
2284  }
2285  }
2286  return 1;
2287 #ifndef TOLUA_RELEASE
2288  tolua_lerror:
2289  tolua_error(tolua_S,"#ferror in function 'set_length'.",&tolua_err);
2290  return 0;
2291 #endif
2292 }
2293 #endif //#ifndef TOLUA_DISABLE
2294 
2295 /* method: unit of class fawkes::HomVector */
2296 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_unit00
2297 static int tolua_fawkesgeometry_fawkes_HomVector_unit00(lua_State* tolua_S)
2298 {
2299 #ifndef TOLUA_RELEASE
2300  tolua_Error tolua_err;
2301  if (
2302  !tolua_isusertype(tolua_S,1,"fawkes::HomVector",0,&tolua_err) ||
2303  !tolua_isnoobj(tolua_S,2,&tolua_err)
2304  )
2305  goto tolua_lerror;
2306  else
2307 #endif
2308  {
2309  fawkes::HomVector* self = (fawkes::HomVector*) tolua_tousertype(tolua_S,1,0);
2310 #ifndef TOLUA_RELEASE
2311  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unit'",NULL);
2312 #endif
2313  {
2314  fawkes::HomVector& tolua_ret = (fawkes::HomVector&) self->unit();
2315  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomVector");
2316  }
2317  }
2318  return 1;
2319 #ifndef TOLUA_RELEASE
2320  tolua_lerror:
2321  tolua_error(tolua_S,"#ferror in function 'unit'.",&tolua_err);
2322  return 0;
2323 #endif
2324 }
2325 #endif //#ifndef TOLUA_DISABLE
2326 
2327 /* method: angle_xy of class fawkes::HomVector */
2328 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomVector_angle_xy00
2329 static int tolua_fawkesgeometry_fawkes_HomVector_angle_xy00(lua_State* tolua_S)
2330 {
2331 #ifndef TOLUA_RELEASE
2332  tolua_Error tolua_err;
2333  if (
2334  !tolua_isusertype(tolua_S,1,"const fawkes::HomVector",0,&tolua_err) ||
2335  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomVector",0,&tolua_err)) ||
2336  !tolua_isnoobj(tolua_S,3,&tolua_err)
2337  )
2338  goto tolua_lerror;
2339  else
2340 #endif
2341  {
2342  const fawkes::HomVector* self = (const fawkes::HomVector*) tolua_tousertype(tolua_S,1,0);
2343  const fawkes::HomVector* h = ((const fawkes::HomVector*) tolua_tousertype(tolua_S,2,0));
2344 #ifndef TOLUA_RELEASE
2345  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'angle_xy'",NULL);
2346 #endif
2347  {
2348  float tolua_ret = (float) self->angle_xy(*h);
2349  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2350  }
2351  }
2352  return 1;
2353 #ifndef TOLUA_RELEASE
2354  tolua_lerror:
2355  tolua_error(tolua_S,"#ferror in function 'angle_xy'.",&tolua_err);
2356  return 0;
2357 #endif
2358 }
2359 #endif //#ifndef TOLUA_DISABLE
2360 
2361 /* method: new of class fawkes::HomPoint */
2362 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_new00
2363 static int tolua_fawkesgeometry_fawkes_HomPoint_new00(lua_State* tolua_S)
2364 {
2365 #ifndef TOLUA_RELEASE
2366  tolua_Error tolua_err;
2367  if (
2368  !tolua_isusertable(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
2369  !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
2370  !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
2371  !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
2372  !tolua_isnoobj(tolua_S,5,&tolua_err)
2373  )
2374  goto tolua_lerror;
2375  else
2376 #endif
2377  {
2378  float x = ((float) tolua_tonumber(tolua_S,2,0.0));
2379  float y = ((float) tolua_tonumber(tolua_S,3,0.0));
2380  float z = ((float) tolua_tonumber(tolua_S,4,0.0));
2381  {
2382  fawkes::HomPoint* tolua_ret = (fawkes::HomPoint*) Mtolua_new((fawkes::HomPoint)(x,y,z));
2383  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPoint");
2384  }
2385  }
2386  return 1;
2387 #ifndef TOLUA_RELEASE
2388  tolua_lerror:
2389  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
2390  return 0;
2391 #endif
2392 }
2393 #endif //#ifndef TOLUA_DISABLE
2394 
2395 /* method: new_local of class fawkes::HomPoint */
2396 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_new00_local
2397 static int tolua_fawkesgeometry_fawkes_HomPoint_new00_local(lua_State* tolua_S)
2398 {
2399 #ifndef TOLUA_RELEASE
2400  tolua_Error tolua_err;
2401  if (
2402  !tolua_isusertable(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
2403  !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
2404  !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
2405  !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
2406  !tolua_isnoobj(tolua_S,5,&tolua_err)
2407  )
2408  goto tolua_lerror;
2409  else
2410 #endif
2411  {
2412  float x = ((float) tolua_tonumber(tolua_S,2,0.0));
2413  float y = ((float) tolua_tonumber(tolua_S,3,0.0));
2414  float z = ((float) tolua_tonumber(tolua_S,4,0.0));
2415  {
2416  fawkes::HomPoint* tolua_ret = (fawkes::HomPoint*) Mtolua_new((fawkes::HomPoint)(x,y,z));
2417  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPoint");
2418  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2419  }
2420  }
2421  return 1;
2422 #ifndef TOLUA_RELEASE
2423  tolua_lerror:
2424  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
2425  return 0;
2426 #endif
2427 }
2428 #endif //#ifndef TOLUA_DISABLE
2429 
2430 /* method: new of class fawkes::HomPoint */
2431 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_new01
2432 static int tolua_fawkesgeometry_fawkes_HomPoint_new01(lua_State* tolua_S)
2433 {
2434  tolua_Error tolua_err;
2435  if (
2436  !tolua_isusertable(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
2437  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
2438  !tolua_isnoobj(tolua_S,3,&tolua_err)
2439  )
2440  goto tolua_lerror;
2441  else
2442  {
2443  const fawkes::HomCoord* h = ((const fawkes::HomCoord*) tolua_tousertype(tolua_S,2,0));
2444  {
2445  fawkes::HomPoint* tolua_ret = (fawkes::HomPoint*) Mtolua_new((fawkes::HomPoint)(*h));
2446  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPoint");
2447  }
2448  }
2449  return 1;
2450 tolua_lerror:
2451  return tolua_fawkesgeometry_fawkes_HomPoint_new00(tolua_S);
2452 }
2453 #endif //#ifndef TOLUA_DISABLE
2454 
2455 /* method: new_local of class fawkes::HomPoint */
2456 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_new01_local
2457 static int tolua_fawkesgeometry_fawkes_HomPoint_new01_local(lua_State* tolua_S)
2458 {
2459  tolua_Error tolua_err;
2460  if (
2461  !tolua_isusertable(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
2462  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomCoord",0,&tolua_err)) ||
2463  !tolua_isnoobj(tolua_S,3,&tolua_err)
2464  )
2465  goto tolua_lerror;
2466  else
2467  {
2468  const fawkes::HomCoord* h = ((const fawkes::HomCoord*) tolua_tousertype(tolua_S,2,0));
2469  {
2470  fawkes::HomPoint* tolua_ret = (fawkes::HomPoint*) Mtolua_new((fawkes::HomPoint)(*h));
2471  tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::HomPoint");
2472  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2473  }
2474  }
2475  return 1;
2476 tolua_lerror:
2477  return tolua_fawkesgeometry_fawkes_HomPoint_new00_local(tolua_S);
2478 }
2479 #endif //#ifndef TOLUA_DISABLE
2480 
2481 /* method: delete of class fawkes::HomPoint */
2482 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_delete00
2483 static int tolua_fawkesgeometry_fawkes_HomPoint_delete00(lua_State* tolua_S)
2484 {
2485 #ifndef TOLUA_RELEASE
2486  tolua_Error tolua_err;
2487  if (
2488  !tolua_isusertype(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
2489  !tolua_isnoobj(tolua_S,2,&tolua_err)
2490  )
2491  goto tolua_lerror;
2492  else
2493 #endif
2494  {
2495  fawkes::HomPoint* self = (fawkes::HomPoint*) tolua_tousertype(tolua_S,1,0);
2496 #ifndef TOLUA_RELEASE
2497  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
2498 #endif
2499  Mtolua_delete(self);
2500  }
2501  return 0;
2502 #ifndef TOLUA_RELEASE
2503  tolua_lerror:
2504  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
2505  return 0;
2506 #endif
2507 }
2508 #endif //#ifndef TOLUA_DISABLE
2509 
2510 /* method: distance of class fawkes::HomPoint */
2511 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_distance00
2512 static int tolua_fawkesgeometry_fawkes_HomPoint_distance00(lua_State* tolua_S)
2513 {
2514 #ifndef TOLUA_RELEASE
2515  tolua_Error tolua_err;
2516  if (
2517  !tolua_isusertype(tolua_S,1,"const fawkes::HomPoint",0,&tolua_err) ||
2518  !tolua_isnoobj(tolua_S,2,&tolua_err)
2519  )
2520  goto tolua_lerror;
2521  else
2522 #endif
2523  {
2524  const fawkes::HomPoint* self = (const fawkes::HomPoint*) tolua_tousertype(tolua_S,1,0);
2525 #ifndef TOLUA_RELEASE
2526  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'distance'",NULL);
2527 #endif
2528  {
2529  float tolua_ret = (float) self->distance();
2530  tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2531  }
2532  }
2533  return 1;
2534 #ifndef TOLUA_RELEASE
2535  tolua_lerror:
2536  tolua_error(tolua_S,"#ferror in function 'distance'.",&tolua_err);
2537  return 0;
2538 #endif
2539 }
2540 #endif //#ifndef TOLUA_DISABLE
2541 
2542 /* method: move of class fawkes::HomPoint */
2543 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_move00
2544 static int tolua_fawkesgeometry_fawkes_HomPoint_move00(lua_State* tolua_S)
2545 {
2546 #ifndef TOLUA_RELEASE
2547  tolua_Error tolua_err;
2548  if (
2549  !tolua_isusertype(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
2550  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2551  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2552  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
2553  !tolua_isnoobj(tolua_S,5,&tolua_err)
2554  )
2555  goto tolua_lerror;
2556  else
2557 #endif
2558  {
2559  fawkes::HomPoint* self = (fawkes::HomPoint*) tolua_tousertype(tolua_S,1,0);
2560  float dx = ((float) tolua_tonumber(tolua_S,2,0));
2561  float dy = ((float) tolua_tonumber(tolua_S,3,0));
2562  float dz = ((float) tolua_tonumber(tolua_S,4,0));
2563 #ifndef TOLUA_RELEASE
2564  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'move'",NULL);
2565 #endif
2566  {
2567  fawkes::HomPoint& tolua_ret = (fawkes::HomPoint&) self->move(dx,dy,dz);
2568  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomPoint");
2569  }
2570  }
2571  return 1;
2572 #ifndef TOLUA_RELEASE
2573  tolua_lerror:
2574  tolua_error(tolua_S,"#ferror in function 'move'.",&tolua_err);
2575  return 0;
2576 #endif
2577 }
2578 #endif //#ifndef TOLUA_DISABLE
2579 
2580 /* method: move_to of class fawkes::HomPoint */
2581 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint_move_to00
2582 static int tolua_fawkesgeometry_fawkes_HomPoint_move_to00(lua_State* tolua_S)
2583 {
2584 #ifndef TOLUA_RELEASE
2585  tolua_Error tolua_err;
2586  if (
2587  !tolua_isusertype(tolua_S,1,"fawkes::HomPoint",0,&tolua_err) ||
2588  !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
2589  !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
2590  !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
2591  !tolua_isnoobj(tolua_S,5,&tolua_err)
2592  )
2593  goto tolua_lerror;
2594  else
2595 #endif
2596  {
2597  fawkes::HomPoint* self = (fawkes::HomPoint*) tolua_tousertype(tolua_S,1,0);
2598  float x = ((float) tolua_tonumber(tolua_S,2,0));
2599  float y = ((float) tolua_tonumber(tolua_S,3,0));
2600  float z = ((float) tolua_tonumber(tolua_S,4,0));
2601 #ifndef TOLUA_RELEASE
2602  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'move_to'",NULL);
2603 #endif
2604  {
2605  fawkes::HomPoint& tolua_ret = (fawkes::HomPoint&) self->move_to(x,y,z);
2606  tolua_pushusertype(tolua_S,(void*)&tolua_ret,"fawkes::HomPoint");
2607  }
2608  }
2609  return 1;
2610 #ifndef TOLUA_RELEASE
2611  tolua_lerror:
2612  tolua_error(tolua_S,"#ferror in function 'move_to'.",&tolua_err);
2613  return 0;
2614 #endif
2615 }
2616 #endif //#ifndef TOLUA_DISABLE
2617 
2618 /* method: operator- of class fawkes::HomPoint */
2619 #ifndef TOLUA_DISABLE_tolua_fawkesgeometry_fawkes_HomPoint__sub00
2620 static int tolua_fawkesgeometry_fawkes_HomPoint__sub00(lua_State* tolua_S)
2621 {
2622 #ifndef TOLUA_RELEASE
2623  tolua_Error tolua_err;
2624  if (
2625  !tolua_isusertype(tolua_S,1,"const fawkes::HomPoint",0,&tolua_err) ||
2626  (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const fawkes::HomPoint",0,&tolua_err)) ||
2627  !tolua_isnoobj(tolua_S,3,&tolua_err)
2628  )
2629  goto tolua_lerror;
2630  else
2631 #endif
2632  {
2633  const fawkes::HomPoint* self = (const fawkes::HomPoint*) tolua_tousertype(tolua_S,1,0);
2634  const fawkes::HomPoint* p = ((const fawkes::HomPoint*) tolua_tousertype(tolua_S,2,0));
2635 #ifndef TOLUA_RELEASE
2636  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'",NULL);
2637 #endif
2638  {
2639  fawkes::HomVector tolua_ret = (fawkes::HomVector) self->operator-(*p);
2640  {
2641 #ifdef __cplusplus
2642  void* tolua_obj = Mtolua_new((fawkes::HomVector)(tolua_ret));
2643  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomVector");
2644  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2645 #else
2646  void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(fawkes::HomVector));
2647  tolua_pushusertype(tolua_S,tolua_obj,"fawkes::HomVector");
2648  tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2649 #endif
2650  }
2651  }
2652  }
2653  return 1;
2654 #ifndef TOLUA_RELEASE
2655  tolua_lerror:
2656  tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
2657  return 0;
2658 #endif
2659 }
2660 #endif //#ifndef TOLUA_DISABLE
2661 
2662 /* Open function */
2663 TOLUA_API int tolua_fawkesgeometry_open (lua_State* tolua_S)
2664 {
2665  tolua_open(tolua_S);
2666  tolua_reg_types(tolua_S);
2667  tolua_module(tolua_S,NULL,0);
2668  tolua_beginmodule(tolua_S,NULL);
2669  tolua_module(tolua_S,"fawkes",0);
2670  tolua_beginmodule(tolua_S,"fawkes");
2671  #ifdef __cplusplus
2672  tolua_cclass(tolua_S,"HomCoord","fawkes::HomCoord","Printable",tolua_collect_fawkes__HomCoord);
2673  #else
2674  tolua_cclass(tolua_S,"HomCoord","fawkes::HomCoord","Printable",NULL);
2675  #endif
2676  tolua_beginmodule(tolua_S,"HomCoord");
2677  tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomCoord_new00);
2678  tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomCoord_new00_local);
2679  tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomCoord_new00_local);
2680  tolua_function(tolua_S,"delete",tolua_fawkesgeometry_fawkes_HomCoord_delete00);
2681  tolua_function(tolua_S,"x",tolua_fawkesgeometry_fawkes_HomCoord_x00);
2682  tolua_function(tolua_S,"x",tolua_fawkesgeometry_fawkes_HomCoord_x01);
2683  tolua_function(tolua_S,"x",tolua_fawkesgeometry_fawkes_HomCoord_x02);
2684  tolua_function(tolua_S,"y",tolua_fawkesgeometry_fawkes_HomCoord_y00);
2685  tolua_function(tolua_S,"y",tolua_fawkesgeometry_fawkes_HomCoord_y01);
2686  tolua_function(tolua_S,"y",tolua_fawkesgeometry_fawkes_HomCoord_y02);
2687  tolua_function(tolua_S,"z",tolua_fawkesgeometry_fawkes_HomCoord_z00);
2688  tolua_function(tolua_S,"z",tolua_fawkesgeometry_fawkes_HomCoord_z01);
2689  tolua_function(tolua_S,"z",tolua_fawkesgeometry_fawkes_HomCoord_z02);
2690  tolua_function(tolua_S,"w",tolua_fawkesgeometry_fawkes_HomCoord_w00);
2691  tolua_function(tolua_S,"w",tolua_fawkesgeometry_fawkes_HomCoord_w01);
2692  tolua_function(tolua_S,"w",tolua_fawkesgeometry_fawkes_HomCoord_w02);
2693  tolua_function(tolua_S,"rotate_x",tolua_fawkesgeometry_fawkes_HomCoord_rotate_x00);
2694  tolua_function(tolua_S,"rotate_y",tolua_fawkesgeometry_fawkes_HomCoord_rotate_y00);
2695  tolua_function(tolua_S,"rotate_z",tolua_fawkesgeometry_fawkes_HomCoord_rotate_z00);
2696  tolua_function(tolua_S,"transform",tolua_fawkesgeometry_fawkes_HomCoord_transform00);
2697  tolua_function(tolua_S,".sub",tolua_fawkesgeometry_fawkes_HomCoord__sub00);
2698  tolua_function(tolua_S,".add",tolua_fawkesgeometry_fawkes_HomCoord__add00);
2699  tolua_function(tolua_S,".mul",tolua_fawkesgeometry_fawkes_HomCoord__mul00);
2700  tolua_function(tolua_S,".mul",tolua_fawkesgeometry_fawkes_HomCoord__mul01);
2701  tolua_function(tolua_S,".eq",tolua_fawkesgeometry_fawkes_HomCoord__eq00);
2702  tolua_endmodule(tolua_S);
2703  tolua_endmodule(tolua_S);
2704  tolua_module(tolua_S,"fawkes",0);
2705  tolua_beginmodule(tolua_S,"fawkes");
2706  #ifdef __cplusplus
2707  tolua_cclass(tolua_S,"HomPose2d","fawkes::HomPose2d","Transformable",tolua_collect_fawkes__HomPose2d);
2708  #else
2709  tolua_cclass(tolua_S,"HomPose2d","fawkes::HomPose2d","Transformable",NULL);
2710  #endif
2711  tolua_beginmodule(tolua_S,"HomPose2d");
2712  tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomPose2d_new00);
2713  tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomPose2d_new00_local);
2714  tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomPose2d_new00_local);
2715  tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomPose2d_new01);
2716  tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomPose2d_new01_local);
2717  tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomPose2d_new01_local);
2718  tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomPose2d_new02);
2719  tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomPose2d_new02_local);
2720  tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomPose2d_new02_local);
2721  tolua_function(tolua_S,"delete",tolua_fawkesgeometry_fawkes_HomPose2d_delete00);
2722  tolua_function(tolua_S,"x",tolua_fawkesgeometry_fawkes_HomPose2d_x00);
2723  tolua_function(tolua_S,"x",tolua_fawkesgeometry_fawkes_HomPose2d_x01);
2724  tolua_function(tolua_S,"y",tolua_fawkesgeometry_fawkes_HomPose2d_y00);
2725  tolua_function(tolua_S,"y",tolua_fawkesgeometry_fawkes_HomPose2d_y01);
2726  tolua_function(tolua_S,"yaw",tolua_fawkesgeometry_fawkes_HomPose2d_yaw00);
2727  tolua_function(tolua_S,"yaw",tolua_fawkesgeometry_fawkes_HomPose2d_yaw01);
2728  tolua_function(tolua_S,"position",tolua_fawkesgeometry_fawkes_HomPose2d_position00);
2729  tolua_function(tolua_S,"orientation",tolua_fawkesgeometry_fawkes_HomPose2d_orientation00);
2730  tolua_function(tolua_S,"set_position",tolua_fawkesgeometry_fawkes_HomPose2d_set_position00);
2731  tolua_endmodule(tolua_S);
2732  tolua_endmodule(tolua_S);
2733  tolua_module(tolua_S,"fawkes",0);
2734  tolua_beginmodule(tolua_S,"fawkes");
2735  #ifdef __cplusplus
2736  tolua_cclass(tolua_S,"HomTransform","fawkes::HomTransform","",tolua_collect_fawkes__HomTransform);
2737  #else
2738  tolua_cclass(tolua_S,"HomTransform","fawkes::HomTransform","",NULL);
2739  #endif
2740  tolua_beginmodule(tolua_S,"HomTransform");
2741  tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomTransform_new00);
2742  tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomTransform_new00_local);
2743  tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomTransform_new00_local);
2744  tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomTransform_new01);
2745  tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomTransform_new01_local);
2746  tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomTransform_new01_local);
2747  tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomTransform_new02);
2748  tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomTransform_new02_local);
2749  tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomTransform_new02_local);
2750  tolua_function(tolua_S,"delete",tolua_fawkesgeometry_fawkes_HomTransform_delete00);
2751  tolua_function(tolua_S,"reset",tolua_fawkesgeometry_fawkes_HomTransform_reset00);
2752  tolua_function(tolua_S,"invert",tolua_fawkesgeometry_fawkes_HomTransform_invert00);
2753  tolua_function(tolua_S,"get_inverse",tolua_fawkesgeometry_fawkes_HomTransform_get_inverse00);
2754  tolua_function(tolua_S,"rotate_x",tolua_fawkesgeometry_fawkes_HomTransform_rotate_x00);
2755  tolua_function(tolua_S,"rotate_y",tolua_fawkesgeometry_fawkes_HomTransform_rotate_y00);
2756  tolua_function(tolua_S,"rotate_z",tolua_fawkesgeometry_fawkes_HomTransform_rotate_z00);
2757  tolua_function(tolua_S,"trans",tolua_fawkesgeometry_fawkes_HomTransform_trans00);
2758  tolua_function(tolua_S,"set_trans",tolua_fawkesgeometry_fawkes_HomTransform_set_trans00);
2759  tolua_function(tolua_S,"mDH",tolua_fawkesgeometry_fawkes_HomTransform_mDH00);
2760  tolua_function(tolua_S,".mul",tolua_fawkesgeometry_fawkes_HomTransform__mul00);
2761  tolua_function(tolua_S,".mul",tolua_fawkesgeometry_fawkes_HomTransform__mul01);
2762  tolua_function(tolua_S,".mul",tolua_fawkesgeometry_fawkes_HomTransform__mul02);
2763  tolua_function(tolua_S,".eq",tolua_fawkesgeometry_fawkes_HomTransform__eq00);
2764  tolua_function(tolua_S,"print_info",tolua_fawkesgeometry_fawkes_HomTransform_print_info00);
2765  tolua_function(tolua_S,"get_matrix",tolua_fawkesgeometry_fawkes_HomTransform_get_matrix00);
2766  tolua_endmodule(tolua_S);
2767  tolua_endmodule(tolua_S);
2768  tolua_module(tolua_S,"fawkes",0);
2769  tolua_beginmodule(tolua_S,"fawkes");
2770  #ifdef __cplusplus
2771  tolua_cclass(tolua_S,"HomVector","fawkes::HomVector","fawkes::HomCoord",tolua_collect_fawkes__HomVector);
2772  #else
2773  tolua_cclass(tolua_S,"HomVector","fawkes::HomVector","fawkes::HomCoord",NULL);
2774  #endif
2775  tolua_beginmodule(tolua_S,"HomVector");
2776  tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomVector_new00);
2777  tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomVector_new00_local);
2778  tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomVector_new00_local);
2779  tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomVector_new01);
2780  tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomVector_new01_local);
2781  tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomVector_new01_local);
2782  tolua_function(tolua_S,"delete",tolua_fawkesgeometry_fawkes_HomVector_delete00);
2783  tolua_function(tolua_S,"length",tolua_fawkesgeometry_fawkes_HomVector_length00);
2784  tolua_function(tolua_S,"set_length",tolua_fawkesgeometry_fawkes_HomVector_set_length00);
2785  tolua_function(tolua_S,"unit",tolua_fawkesgeometry_fawkes_HomVector_unit00);
2786  tolua_function(tolua_S,"angle_xy",tolua_fawkesgeometry_fawkes_HomVector_angle_xy00);
2787  tolua_endmodule(tolua_S);
2788  tolua_endmodule(tolua_S);
2789  tolua_module(tolua_S,"fawkes",0);
2790  tolua_beginmodule(tolua_S,"fawkes");
2791  #ifdef __cplusplus
2792  tolua_cclass(tolua_S,"HomPoint","fawkes::HomPoint","fawkes::HomCoord",tolua_collect_fawkes__HomPoint);
2793  #else
2794  tolua_cclass(tolua_S,"HomPoint","fawkes::HomPoint","fawkes::HomCoord",NULL);
2795  #endif
2796  tolua_beginmodule(tolua_S,"HomPoint");
2797  tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomPoint_new00);
2798  tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomPoint_new00_local);
2799  tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomPoint_new00_local);
2800  tolua_function(tolua_S,"new",tolua_fawkesgeometry_fawkes_HomPoint_new01);
2801  tolua_function(tolua_S,"new_local",tolua_fawkesgeometry_fawkes_HomPoint_new01_local);
2802  tolua_function(tolua_S,".call",tolua_fawkesgeometry_fawkes_HomPoint_new01_local);
2803  tolua_function(tolua_S,"delete",tolua_fawkesgeometry_fawkes_HomPoint_delete00);
2804  tolua_function(tolua_S,"distance",tolua_fawkesgeometry_fawkes_HomPoint_distance00);
2805  tolua_function(tolua_S,"move",tolua_fawkesgeometry_fawkes_HomPoint_move00);
2806  tolua_function(tolua_S,"move_to",tolua_fawkesgeometry_fawkes_HomPoint_move_to00);
2807  tolua_function(tolua_S,".sub",tolua_fawkesgeometry_fawkes_HomPoint__sub00);
2808  tolua_endmodule(tolua_S);
2809  tolua_endmodule(tolua_S);
2810  tolua_endmodule(tolua_S);
2811  return 1;
2812 }
2813 
2814 
2815 extern "C" {
2816 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
2817  TOLUA_API int luaopen_fawkesgeometry (lua_State* tolua_S) {
2818  return tolua_fawkesgeometry_open(tolua_S);
2819 };
2820 #endif
2821 }
2822 
2823 
virtual float y() const
RO-getter for y.
Definition: hom_coord.cpp:115
virtual HomCoord & rotate_x(float rad)
Convenience function to rotate the HomCoord around the x-axis.
Definition: hom_coord.cpp:206
float angle_xy(const HomVector &h) const
Compute the angle between two vectors.
Definition: hom_vector.cpp:117
HomPoint & move(float dx, float dy, float dz)
Move the point by the given coordiantes.
Definition: hom_point.cpp:101
A general matrix class.
Definition: matrix.h:33
A 2-dimensional pose, i.e.
Definition: hom_pose_2d.h:33
HomVector & set_length(float length)
Scales the vector such that it has the given length.
Definition: hom_vector.cpp:99
HomTransform & reset()
Reset transformation.
HomVector & unit()
Brings the vector to unit-length.
Definition: hom_vector.cpp:87
virtual HomCoord & rotate_y(float rad)
Convenience function to rotate the HomCoord around the y-axis.
Definition: hom_coord.cpp:220
This class describes a homogeneous transformation.
Definition: hom_transform.h:31
A homogeneous point.
Definition: hom_point.h:33
float length() const
Calculates the length of the vector.
Definition: hom_vector.cpp:69
HomPoint & move_to(float x, float y, float z)
Move the point to the given coordiantes.
Definition: hom_point.cpp:117
virtual float z() const
RO-getter for z.
Definition: hom_coord.cpp:145
virtual float w() const
RO-getter for w.
Definition: hom_coord.cpp:175
Base class for homogeneous primitives (vector and point).
Definition: hom_coord.h:34
float yaw() const
Get the angle of the current orientation [0...2pi].
HomCoord & transform(const HomTransform &t)
Transform the vector with the given transform.
Definition: hom_coord.cpp:387
A homogeneous vector.
Definition: hom_vector.h:31
float distance() const
Obtain distance from the point to the origin.
Definition: hom_point.cpp:88
virtual HomCoord & rotate_z(float rad)
Convenience function to rotate the HomCoord around the z-axis.
Definition: hom_coord.cpp:234
float x() const
Get the x-coordinate of the position.
virtual HomTransform & invert()
Invert the transformation.
const HomPoint & position() const
Get the position.
virtual float x() const
RO-getter for x.
Definition: hom_coord.cpp:85
float y() const
Get the y-coordinate of the position.
virtual HomTransform get_inverse()
Obtain inverse transform.
const HomVector & orientation() const
Get the orientation vector.