1 /*****************************************************************************
2 * $LastChangedDate: 2011-03-17 19:59:52 -0400 (Thu, 17 Mar 2011) $
3 * @file
4 * @author Jim E. Brooks http://www.palomino3d.org
5 * @brief Interface of C functions for Lua scripts.
6 * @remarks @remarks module.txt documents how to export new C++ classes to Lua.
7 *
8 * ----------------------------
9 * -- THIS IS AUTO-GENERATED --
10 * ----------------------------
11 *
12 *//*
13 * LEGAL: COPYRIGHT (C) 2008 JIM E. BROOKS
14 * THIS SOURCE CODE IS RELEASED UNDER THE TERMS
15 * OF THE GNU GENERAL PUBLIC LICENSE VERSION 2 (GPL 2).
16 *****************************************************************************/
17
18 #include "base/module.hh"
19 using namespace base;
20 #include "object/module.hh"
21 #include "object/aircraft.hh"
22 using namespace object;
23 #include "program/module.hh"
24 #include "program/aircraft_models.hh"
25 using namespace program;
26 #include "lua_bind/module.hh"
27 #include "lua_bind/bind.hh"
28
29 namespace lua {
30
31
32 namespace bind {
33
34 #define BIND_CLASS_NAME "Aircraft"
35 #define BIND_METATABLE_NAME LUABIND_METATABLE_STRING(BIND_CLASS_NAME)
36
37 //==============================================================================
38 // C functions called by Lua that access C++ objects.
39 //==============================================================================
40 // Need a function to check typesig because of macro/template limitations.
41 #if ! DOXYGEN
42 INTERN void
CheckTypesigAircraft(shptr<Aircraft> obj)43 CheckTypesigAircraft( shptr<Aircraft> obj )
44 {
45 CHECK_TYPESIG(obj,TYPESIG_AIRCRAFT);
46 }
47 #endif // ! DOXYGEN
48
49 /*****************************************************************************
50 * Lua's garbage collector indirectly invokes this C++ destructor.
51 *****************************************************************************/
52 INTERN int
Aircraft_Destroy(lua_State * L)53 Aircraft_Destroy( lua_State* L )
54 {
55 try {
56
57 return DESTROY_USERDATA_SHPTR<Aircraft>( L, CheckTypesigAircraft );
58
59 } CATCH_LUA_EXCEPTION
60 return 0;
61 }
62
63 /*****************************************************************************
64 * Aircraft:EnableBrakes(bool)
65 *****************************************************************************/
66 INTERN int
Aircraft_EnableBrakes(lua_State * L)67 Aircraft_EnableBrakes( lua_State* L )
68 {
69 try {
70
71 const bool enable = POP_BOOL( L );
72 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
73 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
74 aircraft->EnableBrakes( enable );
75
76 } CATCH_LUA_EXCEPTION
77 return 0;
78 }
79
80 /*****************************************************************************
81 * Aircraft:EnableCoordinatedTurn( bool )
82 *****************************************************************************/
83 INTERN int
Aircraft_EnableCoordinatedTurn(lua_State * L)84 Aircraft_EnableCoordinatedTurn( lua_State* L )
85 {
86 try {
87
88 const bool coturn = POP_BOOL( L );
89 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
90 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
91 aircraft->EnableCoordinatedTurn( coturn );
92
93 } CATCH_LUA_EXCEPTION
94 return 0;
95 }
96
97 /*****************************************************************************
98 * table Aircraft:GetMatrix()
99 *****************************************************************************/
100 INTERN int
Aircraft_GetMatrix(lua_State * L)101 Aircraft_GetMatrix( lua_State* L )
102 {
103 try {
104
105 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
106 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
107 PUSH_TABLE_FROM_MATRIX( L, aircraft->GetMatrix() );
108 return 1; // stack items to return
109
110 } CATCH_LUA_EXCEPTION
111 return 0;
112 }
113
114 /*****************************************************************************
115 * string Aircraft:GetName()
116 *****************************************************************************/
117 INTERN int
Aircraft_GetName(lua_State * L)118 Aircraft_GetName( lua_State* L )
119 {
120 try {
121
122 Aircraft* aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L ).PTR();
123 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
124 lua_pushstring( L, aircraft->GetName().c_str() );
125 return 1; // stack items to return
126
127 } CATCH_LUA_EXCEPTION
128 return 0;
129 }
130
131 /*****************************************************************************
132 * Aircraft:GetPhysics()
133 *****************************************************************************/
134 INTERN int
Aircraft_GetPhysics(lua_State * L)135 Aircraft_GetPhysics( lua_State* L )
136 {
137 try {
138
139 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
140 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
141 return NEW_USERDATA_PTR( L,
142 &aircraft->GetPhysics(),
143 LUABIND_METATABLE_STRING("AircraftPhysics") );
144
145 } CATCH_LUA_EXCEPTION
146 return 0;
147 }
148
149 /*****************************************************************************
150 * Vec3 Aircraft:GetPosition()
151 *****************************************************************************/
152 INTERN int
Aircraft_GetPosition(lua_State * L)153 Aircraft_GetPosition( lua_State* L )
154 {
155 try {
156
157 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
158 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
159 const WorldVertex pos = aircraft->GetPosition();
160 PUSH_VECTOR3( L, pos );
161 return 1; // stack items to return
162
163 } CATCH_LUA_EXCEPTION
164 return 0;
165 }
166
167 /*****************************************************************************
168 * number Aircraft:GetRawPtr()
169 *****************************************************************************/
170 INTERN int
Aircraft_GetRawPtr(lua_State * L)171 Aircraft_GetRawPtr( lua_State* L )
172 {
173 try {
174
175 Aircraft* aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L ).PTR();
176 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
177 lua_pushnumber( L, long(static_cast<Aircraft*>(aircraft)) );
178 return 1; // stack items to return
179
180 } CATCH_LUA_EXCEPTION
181 return 0;
182 }
183
184 /*****************************************************************************
185 * eState Aircraft:GetState()
186 *****************************************************************************/
187 INTERN int
Aircraft_GetState(lua_State * L)188 Aircraft_GetState( lua_State* L )
189 {
190 try {
191
192 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
193 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
194 lua_pushnumber( L, aircraft->GetState() );
195 return 1; // stack items to return
196
197 } CATCH_LUA_EXCEPTION
198 return 0;
199 }
200
201 /*****************************************************************************
202 * fp Aircraft:GetThrottle()
203 *****************************************************************************/
204 INTERN int
Aircraft_GetThrottle(lua_State * L)205 Aircraft_GetThrottle( lua_State* L )
206 {
207 try {
208
209 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
210 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
211 lua_pushnumber( L, aircraft->GetThrottle() );
212 return 1; // stack items to return
213
214 } CATCH_LUA_EXCEPTION
215 return 0;
216 }
217
218 /*****************************************************************************
219 * bool Aircraft:IfBrakes()
220 *****************************************************************************/
221 INTERN int
Aircraft_IfBrakes(lua_State * L)222 Aircraft_IfBrakes( lua_State* L )
223 {
224 try {
225
226 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
227 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
228 lua_pushboolean( L, aircraft->IfBrakes() );
229 return 1; // stack items to return
230
231 } CATCH_LUA_EXCEPTION
232 return 0;
233 }
234
235 /*****************************************************************************
236 * bool Aircraft:IfCollidable()
237 *****************************************************************************/
238 INTERN int
Aircraft_IfCollidable(lua_State * L)239 Aircraft_IfCollidable( lua_State* L )
240 {
241 try {
242
243 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
244 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
245 lua_pushboolean( L, aircraft->IfCollidable() );
246 return 1; // stack items to return
247
248 } CATCH_LUA_EXCEPTION
249 return 0;
250 }
251
252 /*****************************************************************************
253 * bool Aircraft:IfCollision()
254 *****************************************************************************/
255 INTERN int
Aircraft_IfCollision(lua_State * L)256 Aircraft_IfCollision( lua_State* L )
257 {
258 try {
259
260 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
261 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
262 lua_pushboolean( L, aircraft->IfCollision() );
263 return 1; // stack items to return
264
265 } CATCH_LUA_EXCEPTION
266 return 0;
267 }
268
269 /*****************************************************************************
270 * bool Aircraft:IfCollisionFatal()
271 *****************************************************************************/
272 INTERN int
Aircraft_IfCollisionFatal(lua_State * L)273 Aircraft_IfCollisionFatal( lua_State* L )
274 {
275 try {
276
277 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
278 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
279 lua_pushboolean( L, aircraft->IfCollisionFatal() );
280 return 1; // stack items to return
281
282 } CATCH_LUA_EXCEPTION
283 return 0;
284 }
285
286 /*****************************************************************************
287 * bool Aircraft:IfCoordinatedTurnEnabled()
288 *****************************************************************************/
289 INTERN int
Aircraft_IfCoordinatedTurnEnabled(lua_State * L)290 Aircraft_IfCoordinatedTurnEnabled( lua_State* L )
291 {
292 try {
293
294 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
295 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
296 lua_pushboolean( L, aircraft->IfCoordinatedTurnEnabled() );
297 return 1; // stack items to return
298
299 } CATCH_LUA_EXCEPTION
300 return 0;
301 }
302
303 /*****************************************************************************
304 * bool Aircraft:IfCoordinatedTurnExecuting()
305 *****************************************************************************/
306 INTERN int
Aircraft_IfCoordinatedTurnExecuting(lua_State * L)307 Aircraft_IfCoordinatedTurnExecuting( lua_State* L )
308 {
309 try {
310
311 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
312 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
313 lua_pushboolean( L, aircraft->IfCoordinatedTurnExecuting() );
314 return 1; // stack items to return
315
316 } CATCH_LUA_EXCEPTION
317 return 0;
318 }
319
320 /*****************************************************************************
321 * bool Aircraft:IfHasPropeller()
322 *****************************************************************************/
323 INTERN int
Aircraft_IfHasPropeller(lua_State * L)324 Aircraft_IfHasPropeller( lua_State* L )
325 {
326 try {
327
328 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
329 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
330 lua_pushboolean( L, aircraft->IfHasPropeller() );
331 return 1; // stack items to return
332
333 } CATCH_LUA_EXCEPTION
334 return 0;
335 }
336
337 /*****************************************************************************
338 * bool Aircraft:IfLandingGear() / down=true
339 *****************************************************************************/
340 INTERN int
Aircraft_IfLandingGear(lua_State * L)341 Aircraft_IfLandingGear( lua_State* L )
342 {
343 try {
344
345 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
346 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
347 lua_pushboolean( L, aircraft->IfLandingGear() );
348 return 1; // stack items to return
349
350 } CATCH_LUA_EXCEPTION
351 return 0;
352 }
353
354 /*****************************************************************************
355 * bool Aircraft:IfWheelBrakes()
356 *****************************************************************************/
357 INTERN int
Aircraft_IfWheelBrakes(lua_State * L)358 Aircraft_IfWheelBrakes( lua_State* L )
359 {
360 try {
361
362 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
363 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
364 lua_pushboolean( L, aircraft->IfWheelBrakes() );
365 return 1; // stack items to return
366
367 } CATCH_LUA_EXCEPTION
368 return 0;
369 }
370
371 /*****************************************************************************
372 * bool Aircraft:IfZombie()
373 *****************************************************************************/
374 INTERN int
Aircraft_IfZombie(lua_State * L)375 Aircraft_IfZombie( lua_State* L )
376 {
377 try {
378
379 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
380 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
381 lua_pushboolean( L, aircraft->IfZombie() );
382 return 1; // stack items to return
383
384 } CATCH_LUA_EXCEPTION
385 return 0;
386 }
387
388 /*****************************************************************************
389 * Aircraft:New( x,y,z|Vec3, Aircraft::eType, ModelCache.LOAD_SHARED|LOAD_COPY )
390 *****************************************************************************/
391 INTERN int
Aircraft_New(lua_State * L)392 Aircraft_New( lua_State* L )
393 {
394 try {
395
396 const bool loadCopy = POP_BOOL( L );
397 const eAircraftType aircraftType = static_cast<eAircraftType>( POP_INT( L ) );
398 const WorldVertex pos = POP_VECTOR3<WorldVertex>( L );
399 shptr<Aircraft> aircraft = program::MakeAircraft( aircraftType, pos, loadCopy );
400 return NEW_USERDATA_SHPTR<Aircraft>( L, aircraft, BIND_METATABLE_NAME );
401
402 } CATCH_LUA_EXCEPTION
403 return 0;
404 }
405
406 /*****************************************************************************
407 * Aircraft:PhysicalRotate( axis, controlFraction, controlFreq )
408 *****************************************************************************/
409 INTERN int
Aircraft_PhysicalRotate(lua_State * L)410 Aircraft_PhysicalRotate( lua_State* L )
411 {
412 try {
413
414 const Milliseconds controlFreq( POP_INT( L ) );
415 const fp controlFrac = POP_FP( L );
416 const uint axis = POP_INT( L );
417 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
418 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
419 aircraft->PhysicalRotate( axis, controlFrac, controlFreq );
420
421 } CATCH_LUA_EXCEPTION
422 return 0;
423 }
424
425 /*****************************************************************************
426 * Aircraft.PlayEngineSound( volume )
427 *****************************************************************************/
428 INTERN int
Aircraft_PlayEngineSound(lua_State * L)429 Aircraft_PlayEngineSound( lua_State* L )
430 {
431 try {
432
433 const fp volume = POP_FP( L );
434 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
435 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
436 aircraft->PlayEngineSound( volume );
437
438 } CATCH_LUA_EXCEPTION
439 return 0;
440 }
441
442 /*****************************************************************************
443 * Aircraft:Reset()
444 *****************************************************************************/
445 INTERN int
Aircraft_Reset(lua_State * L)446 Aircraft_Reset( lua_State* L )
447 {
448 try {
449
450 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
451 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
452 aircraft->Reset();
453
454 } CATCH_LUA_EXCEPTION
455 return 0;
456 }
457
458 /*****************************************************************************
459 * Aircraft:Rotate( axis, radian )
460 *****************************************************************************/
461 INTERN int
Aircraft_Rotate(lua_State * L)462 Aircraft_Rotate( lua_State* L )
463 {
464 try {
465
466 const fp radian = POP_FP( L );
467 const uint axis = POP_INT( L );
468 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
469 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
470 aircraft->Rotate( axis, radian );
471
472 } CATCH_LUA_EXCEPTION
473 return 0;
474 }
475
476 /*****************************************************************************
477 * Aircraft:SetCollidable( bool )
478 *****************************************************************************/
479 INTERN int
Aircraft_SetCollidable(lua_State * L)480 Aircraft_SetCollidable( lua_State* L )
481 {
482 try {
483
484 const bool f = POP_BOOL( L );
485 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
486 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
487 aircraft->SetCollidable( f );
488
489 } CATCH_LUA_EXCEPTION
490 return 0;
491 }
492
493 /*****************************************************************************
494 * Aircraft:SetCollision( int )
495 *****************************************************************************/
496 INTERN int
Aircraft_SetCollision(lua_State * L)497 Aircraft_SetCollision( lua_State* L )
498 {
499 try {
500
501 const int collision = POP_INT( L );
502 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
503 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
504 aircraft->SetCollision( static_cast<Aircraft::eCollision>( collision ) );
505
506 } CATCH_LUA_EXCEPTION
507 return 0;
508 }
509
510 /*****************************************************************************
511 * Aircraft:SetLandingGear( bool ) / down=true
512 * SUBTLE: This is a NOP is speed is zero.
513 * Use sim.LANDING_GEAR_UP/DOWN.
514 *****************************************************************************/
515 INTERN int
Aircraft_SetLandingGear(lua_State * L)516 Aircraft_SetLandingGear( lua_State* L )
517 {
518 try {
519
520 const bool down = POP_BOOL( L );
521 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
522 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
523 aircraft->SetLandingGear( down );
524
525 } CATCH_LUA_EXCEPTION
526 return 0;
527 }
528
529 /*****************************************************************************
530 * Aircraft:SetMatrix( matrix )
531 *****************************************************************************/
532 INTERN int
Aircraft_SetMatrix(lua_State * L)533 Aircraft_SetMatrix( lua_State* L )
534 {
535 try {
536
537 Matrix m; POP_TABLE_INTO_MATRIX( L, m );
538 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
539 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
540 aircraft->SetMatrix( m, Aircraft::PLACEMENT );
541
542 } CATCH_LUA_EXCEPTION
543 return 0;
544 }
545
546 /*****************************************************************************
547 * Aircraft:SetPosition( x,y,z|Vec3 )
548 *****************************************************************************/
549 INTERN int
Aircraft_SetPosition(lua_State * L)550 Aircraft_SetPosition( lua_State* L )
551 {
552 try {
553
554 const WorldVertex pos = POP_VECTOR3<WorldVertex>( L );
555 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
556 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
557 aircraft->SetPosition( pos );
558
559 } CATCH_LUA_EXCEPTION
560 return 0;
561 }
562
563 /*****************************************************************************
564 * Aircraft:SetShadowCaster( bool )
565 *****************************************************************************/
566 INTERN int
Aircraft_SetShadowCaster(lua_State * L)567 Aircraft_SetShadowCaster( lua_State* L )
568 {
569 try {
570
571 // Should be called prior to SceneGraph::AttachObject() else no effect.
572 const bool enable = POP_BOOL( L );
573 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
574 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
575 aircraft->SetShadowCaster( enable );
576
577 } CATCH_LUA_EXCEPTION
578 return 0;
579 }
580
581 /*****************************************************************************
582 * Aircraft:SetState( eState )
583 *****************************************************************************/
584 INTERN int
Aircraft_SetState(lua_State * L)585 Aircraft_SetState( lua_State* L )
586 {
587 try {
588
589 const Aircraft::eState state = static_cast<Aircraft::eState>( POP_INT( L ) );
590 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
591 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
592 aircraft->SetState( state );
593
594 } CATCH_LUA_EXCEPTION
595 return 0;
596 }
597
598 /*****************************************************************************
599 * Aircraft:SetThrottle( fp )
600 *****************************************************************************/
601 INTERN int
Aircraft_SetThrottle(lua_State * L)602 Aircraft_SetThrottle( lua_State* L )
603 {
604 try {
605
606 const fp throttle = POP_FP( L );
607 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
608 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
609 aircraft->SetThrottle( throttle );
610
611 } CATCH_LUA_EXCEPTION
612 return 0;
613 }
614
615 /*****************************************************************************
616 * Aircraft.StopEngineSound()
617 *****************************************************************************/
618 INTERN int
Aircraft_StopEngineSound(lua_State * L)619 Aircraft_StopEngineSound( lua_State* L )
620 {
621 try {
622
623 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
624 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
625 aircraft->StopEngineSound();
626
627 } CATCH_LUA_EXCEPTION
628 return 0;
629 }
630
631 /*****************************************************************************
632 * Aircraft:SwingBayDoors( fraction ) safe NOP if aircraft has no bay
633 *****************************************************************************/
634 INTERN int
Aircraft_SwingBayDoors(lua_State * L)635 Aircraft_SwingBayDoors( lua_State* L )
636 {
637 try {
638
639 const fp fraction = POP_FP( L );
640 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
641 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
642 aircraft->SwingBayDoors( fraction );
643
644 } CATCH_LUA_EXCEPTION
645 return 0;
646 }
647
648 /*****************************************************************************
649 * Aircraft:SwingWings( fraction ) safe NOP if not swing-wing aircraft
650 *****************************************************************************/
651 INTERN int
Aircraft_SwingWings(lua_State * L)652 Aircraft_SwingWings( lua_State* L )
653 {
654 try {
655
656 const fp fraction = POP_FP( L );
657 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
658 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
659 aircraft->SwingWings( fraction );
660
661 } CATCH_LUA_EXCEPTION
662 return 0;
663 }
664
665 /*****************************************************************************
666 * Aircraft:ToggleBrakes()
667 *****************************************************************************/
668 INTERN int
Aircraft_ToggleBrakes(lua_State * L)669 Aircraft_ToggleBrakes( lua_State* L )
670 {
671 try {
672
673 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
674 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
675 aircraft->EnableBrakes( not aircraft->IfBrakes() );
676
677 } CATCH_LUA_EXCEPTION
678 return 0;
679 }
680
681 /*****************************************************************************
682 * bool Aircraft:ToggleLandingGear() / returns true if landing gear changed state
683 *****************************************************************************/
684 INTERN int
Aircraft_ToggleLandingGear(lua_State * L)685 Aircraft_ToggleLandingGear( lua_State* L )
686 {
687 try {
688
689 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
690 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
691 const bool state = aircraft->IfLandingGear();
692 aircraft->SetLandingGear( not state );
693 lua_pushboolean( L, state != aircraft->IfLandingGear() ); // true if state changed
694 return 1; // stack items to return
695
696 } CATCH_LUA_EXCEPTION
697 return 0;
698 }
699
700 /*****************************************************************************
701 * Aircraft:Zombify()
702 *****************************************************************************/
703 INTERN int
Aircraft_Zombify(lua_State * L)704 Aircraft_Zombify( lua_State* L )
705 {
706 try {
707
708 shptr<Aircraft> aircraft = POP_USERDATA_AS_SHPTR<Aircraft>( L );
709 CHECK_TYPESIG(aircraft,TYPESIG_AIRCRAFT);
710 aircraft->Zombify();
711
712 } CATCH_LUA_EXCEPTION
713 return 0;
714 }
715
716 //==============================================================================
717 // Register binding with Lua.
718 //==============================================================================
719
720 #if ! DOXYGEN
721
722 INTERN const struct luaL_reg sMethodTable[] =
723 {
724 { "New", Aircraft_New },
725 { "__gc", Aircraft_Destroy },
726 { "EnableBrakes", Aircraft_EnableBrakes },
727 { "EnableCoordinatedTurn", Aircraft_EnableCoordinatedTurn },
728 { "GetMatrix", Aircraft_GetMatrix },
729 { "GetName", Aircraft_GetName },
730 { "GetPhysics", Aircraft_GetPhysics },
731 { "GetPosition", Aircraft_GetPosition },
732 { "GetRawPtr", Aircraft_GetRawPtr },
733 { "GetState", Aircraft_GetState },
734 { "GetThrottle", Aircraft_GetThrottle },
735 { "IfBrakes", Aircraft_IfBrakes },
736 { "IfCollidable", Aircraft_IfCollidable },
737 { "IfCollision", Aircraft_IfCollision },
738 { "IfCollisionFatal", Aircraft_IfCollisionFatal },
739 { "IfCoordinatedTurnEnabled", Aircraft_IfCoordinatedTurnEnabled },
740 { "IfCoordinatedTurnExecuting", Aircraft_IfCoordinatedTurnExecuting },
741 { "IfHasPropeller", Aircraft_IfHasPropeller },
742 { "IfLandingGear", Aircraft_IfLandingGear },
743 { "IfWheelBrakes", Aircraft_IfWheelBrakes },
744 { "IfZombie", Aircraft_IfZombie },
745 { "PhysicalRotate", Aircraft_PhysicalRotate },
746 { "PlayEngineSound", Aircraft_PlayEngineSound },
747 { "Reset", Aircraft_Reset },
748 { "Rotate", Aircraft_Rotate },
749 { "SetCollidable", Aircraft_SetCollidable },
750 { "SetCollision", Aircraft_SetCollision },
751 { "SetLandingGear", Aircraft_SetLandingGear },
752 { "SetMatrix", Aircraft_SetMatrix },
753 { "SetPosition", Aircraft_SetPosition },
754 { "SetShadowCaster", Aircraft_SetShadowCaster },
755 { "SetState", Aircraft_SetState },
756 { "SetThrottle", Aircraft_SetThrottle },
757 { "StopEngineSound", Aircraft_StopEngineSound },
758 { "SwingBayDoors", Aircraft_SwingBayDoors },
759 { "SwingWings", Aircraft_SwingWings },
760 { "ToggleBrakes", Aircraft_ToggleBrakes },
761 { "ToggleLandingGear", Aircraft_ToggleLandingGear },
762 { "Zombify", Aircraft_Zombify },
763 { NULL, NULL }
764 };
765
766 void
RegisterAircraft(lua_State * L)767 RegisterAircraft( lua_State* L )
768 {
769 REGISTER_BINDING( L,
770 BIND_METATABLE_NAME,
771 BIND_CLASS_NAME,
772 sMethodTable );
773 }
774
775 #endif // ! DOXYGEN
776
777 } // namespace bind
778
779 } // namespace lua
780