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/dyna.hh"
22 using namespace object;
23 #include "game/module.hh"
24 #include "game/missile.hh"
25 using namespace game;
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 "Missile"
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
CheckTypesigMissile(shptr<Missile> obj)43 CheckTypesigMissile( shptr<Missile> obj )
44 {
45 CHECK_TYPESIG(obj,TYPESIG_MISSILE);
46 }
47 #endif // ! DOXYGEN
48
49 /*****************************************************************************
50 * Lua's garbage collector indirectly invokes this C++ destructor.
51 *****************************************************************************/
52 INTERN int
Missile_Destroy(lua_State * L)53 Missile_Destroy( lua_State* L )
54 {
55 try {
56
57 return DESTROY_USERDATA_SHPTR<Missile>( L, CheckTypesigMissile );
58
59 } CATCH_LUA_EXCEPTION
60 return 0;
61 }
62
63 /*****************************************************************************
64 * table Missile:GetMatrix()
65 *****************************************************************************/
66 INTERN int
Missile_GetMatrix(lua_State * L)67 Missile_GetMatrix( lua_State* L )
68 {
69 try {
70
71 shptr<Missile> missile = POP_USERDATA_AS_SHPTR<Missile>( L );
72 CHECK_TYPESIG(missile,TYPESIG_MISSILE);
73 PUSH_TABLE_FROM_MATRIX( L, missile->GetMatrix() );
74 return 1; // stack items to return
75
76 } CATCH_LUA_EXCEPTION
77 return 0;
78 }
79
80 /*****************************************************************************
81 * string Missile:GetName()
82 *****************************************************************************/
83 INTERN int
Missile_GetName(lua_State * L)84 Missile_GetName( lua_State* L )
85 {
86 try {
87
88 Missile* missile = POP_USERDATA_AS_SHPTR<Missile>( L ).PTR();
89 CHECK_TYPESIG(missile,TYPESIG_MISSILE);
90 lua_pushstring( L, missile->GetName().c_str() );
91 return 1; // stack items to return
92
93 } CATCH_LUA_EXCEPTION
94 return 0;
95 }
96
97 /*****************************************************************************
98 * Vec3 Missile:GetPosition()
99 *****************************************************************************/
100 INTERN int
Missile_GetPosition(lua_State * L)101 Missile_GetPosition( lua_State* L )
102 {
103 try {
104
105 shptr<Missile> missile = POP_USERDATA_AS_SHPTR<Missile>( L );
106 CHECK_TYPESIG(missile,TYPESIG_MISSILE);
107 const WorldVertex pos = missile->GetPosition();
108 PUSH_VECTOR3( L, pos );
109 return 1; // stack items to return
110
111 } CATCH_LUA_EXCEPTION
112 return 0;
113 }
114
115 /*****************************************************************************
116 * number Missile:GetRawPtr()
117 *****************************************************************************/
118 INTERN int
Missile_GetRawPtr(lua_State * L)119 Missile_GetRawPtr( lua_State* L )
120 {
121 try {
122
123 Missile* missile = POP_USERDATA_AS_SHPTR<Missile>( L ).PTR();
124 CHECK_TYPESIG(missile,TYPESIG_MISSILE);
125 lua_pushnumber( L, long(static_cast<Missile*>(missile)) );
126 return 1; // stack items to return
127
128 } CATCH_LUA_EXCEPTION
129 return 0;
130 }
131
132 /*****************************************************************************
133 * bool Missile:IfCollidable()
134 *****************************************************************************/
135 INTERN int
Missile_IfCollidable(lua_State * L)136 Missile_IfCollidable( lua_State* L )
137 {
138 try {
139
140 shptr<Missile> missile = POP_USERDATA_AS_SHPTR<Missile>( L );
141 CHECK_TYPESIG(missile,TYPESIG_MISSILE);
142 lua_pushboolean( L, missile->IfCollidable() );
143 return 1; // stack items to return
144
145 } CATCH_LUA_EXCEPTION
146 return 0;
147 }
148
149 /*****************************************************************************
150 * bool Missile:IfCollision()
151 *****************************************************************************/
152 INTERN int
Missile_IfCollision(lua_State * L)153 Missile_IfCollision( lua_State* L )
154 {
155 try {
156
157 shptr<Missile> missile = POP_USERDATA_AS_SHPTR<Missile>( L );
158 CHECK_TYPESIG(missile,TYPESIG_MISSILE);
159 lua_pushboolean( L, missile->IfCollision() );
160 return 1; // stack items to return
161
162 } CATCH_LUA_EXCEPTION
163 return 0;
164 }
165
166 /*****************************************************************************
167 * bool Missile:IfCollisionFatal()
168 *****************************************************************************/
169 INTERN int
Missile_IfCollisionFatal(lua_State * L)170 Missile_IfCollisionFatal( lua_State* L )
171 {
172 try {
173
174 shptr<Missile> missile = POP_USERDATA_AS_SHPTR<Missile>( L );
175 CHECK_TYPESIG(missile,TYPESIG_MISSILE);
176 lua_pushboolean( L, missile->IfCollisionFatal() );
177 return 1; // stack items to return
178
179 } CATCH_LUA_EXCEPTION
180 return 0;
181 }
182
183 /*****************************************************************************
184 * bool Missile:IfZombie()
185 *****************************************************************************/
186 INTERN int
Missile_IfZombie(lua_State * L)187 Missile_IfZombie( lua_State* L )
188 {
189 try {
190
191 shptr<Missile> missile = POP_USERDATA_AS_SHPTR<Missile>( L );
192 CHECK_TYPESIG(missile,TYPESIG_MISSILE);
193 lua_pushboolean( L, missile->IfZombie() );
194 return 1; // stack items to return
195
196 } CATCH_LUA_EXCEPTION
197 return 0;
198 }
199
200 /*****************************************************************************
201 * Missile:New( target, launcher, launcherSpeed, radiusGeo, malfunction )
202 *****************************************************************************/
203 INTERN int
Missile_New(lua_State * L)204 Missile_New( lua_State* L )
205 {
206 try {
207
208 const bool malfunction = POP_BOOL( L );
209 const Meter particleRadiusGeo = Meter( POP_FP( L ) );
210 const Speed launcherSpeed = Speed( POP_FP( L ) );
211 shptr<Dyna> launcher = POP_USERDATA_AS_SHPTR<Dyna>( L );
212 shptr<Dyna> target = POP_USERDATA_AS_SHPTR<Dyna>( L );
213 CHECK_TYPESIG(launcher,TYPESIG_OBJECT);
214 CHECK_TYPESIG(target,TYPESIG_OBJECT);
215 shptr<Missile> missile = new Missile( target, *launcher, launcherSpeed, particleRadiusGeo, malfunction );
216 return NEW_USERDATA_SHPTR<Missile>( L, missile, BIND_METATABLE_NAME );
217
218 } CATCH_LUA_EXCEPTION
219 return 0;
220 }
221
222 /*****************************************************************************
223 * Missile:Reset()
224 *****************************************************************************/
225 INTERN int
Missile_Reset(lua_State * L)226 Missile_Reset( lua_State* L )
227 {
228 try {
229
230 shptr<Missile> missile = POP_USERDATA_AS_SHPTR<Missile>( L );
231 CHECK_TYPESIG(missile,TYPESIG_MISSILE);
232 missile->Reset();
233
234 } CATCH_LUA_EXCEPTION
235 return 0;
236 }
237
238 /*****************************************************************************
239 * Missile:Rotate( axis, radian )
240 *****************************************************************************/
241 INTERN int
Missile_Rotate(lua_State * L)242 Missile_Rotate( lua_State* L )
243 {
244 try {
245
246 const fp radian = POP_FP( L );
247 const uint axis = POP_INT( L );
248 shptr<Missile> missile = POP_USERDATA_AS_SHPTR<Missile>( L );
249 CHECK_TYPESIG(missile,TYPESIG_MISSILE);
250 missile->Rotate( axis, radian );
251
252 } CATCH_LUA_EXCEPTION
253 return 0;
254 }
255
256 /*****************************************************************************
257 * Missile:SetCollidable( bool )
258 *****************************************************************************/
259 INTERN int
Missile_SetCollidable(lua_State * L)260 Missile_SetCollidable( lua_State* L )
261 {
262 try {
263
264 const bool f = POP_BOOL( L );
265 shptr<Missile> missile = POP_USERDATA_AS_SHPTR<Missile>( L );
266 CHECK_TYPESIG(missile,TYPESIG_MISSILE);
267 missile->SetCollidable( f );
268
269 } CATCH_LUA_EXCEPTION
270 return 0;
271 }
272
273 /*****************************************************************************
274 * Missile:SetCollision( int )
275 *****************************************************************************/
276 INTERN int
Missile_SetCollision(lua_State * L)277 Missile_SetCollision( lua_State* L )
278 {
279 try {
280
281 const int collision = POP_INT( L );
282 shptr<Missile> missile = POP_USERDATA_AS_SHPTR<Missile>( L );
283 CHECK_TYPESIG(missile,TYPESIG_MISSILE);
284 missile->SetCollision( static_cast<Missile::eCollision>( collision ) );
285
286 } CATCH_LUA_EXCEPTION
287 return 0;
288 }
289
290 /*****************************************************************************
291 * Missile:SetMatrix( matrix )
292 *****************************************************************************/
293 INTERN int
Missile_SetMatrix(lua_State * L)294 Missile_SetMatrix( lua_State* L )
295 {
296 try {
297
298 Matrix m; POP_TABLE_INTO_MATRIX( L, m );
299 shptr<Missile> missile = POP_USERDATA_AS_SHPTR<Missile>( L );
300 CHECK_TYPESIG(missile,TYPESIG_MISSILE);
301 missile->SetMatrix( m, Missile::PLACEMENT );
302
303 } CATCH_LUA_EXCEPTION
304 return 0;
305 }
306
307 /*****************************************************************************
308 * Missile:SetPosition( x,y,z|Vec3 )
309 *****************************************************************************/
310 INTERN int
Missile_SetPosition(lua_State * L)311 Missile_SetPosition( lua_State* L )
312 {
313 try {
314
315 const WorldVertex pos = POP_VECTOR3<WorldVertex>( L );
316 shptr<Missile> missile = POP_USERDATA_AS_SHPTR<Missile>( L );
317 CHECK_TYPESIG(missile,TYPESIG_MISSILE);
318 missile->SetPosition( pos );
319
320 } CATCH_LUA_EXCEPTION
321 return 0;
322 }
323
324 /*****************************************************************************
325 * Missile:Zombify()
326 *****************************************************************************/
327 INTERN int
Missile_Zombify(lua_State * L)328 Missile_Zombify( lua_State* L )
329 {
330 try {
331
332 shptr<Missile> missile = POP_USERDATA_AS_SHPTR<Missile>( L );
333 CHECK_TYPESIG(missile,TYPESIG_MISSILE);
334 missile->Zombify();
335
336 } CATCH_LUA_EXCEPTION
337 return 0;
338 }
339
340 //==============================================================================
341 // Register binding with Lua.
342 //==============================================================================
343
344 #if ! DOXYGEN
345
346 INTERN const struct luaL_reg sMethodTable[] =
347 {
348 { "New", Missile_New },
349 { "__gc", Missile_Destroy },
350 { "GetMatrix", Missile_GetMatrix },
351 { "GetName", Missile_GetName },
352 { "GetPosition", Missile_GetPosition },
353 { "GetRawPtr", Missile_GetRawPtr },
354 { "IfCollidable", Missile_IfCollidable },
355 { "IfCollision", Missile_IfCollision },
356 { "IfCollisionFatal", Missile_IfCollisionFatal },
357 { "IfZombie", Missile_IfZombie },
358 { "Reset", Missile_Reset },
359 { "Rotate", Missile_Rotate },
360 { "SetCollidable", Missile_SetCollidable },
361 { "SetCollision", Missile_SetCollision },
362 { "SetMatrix", Missile_SetMatrix },
363 { "SetPosition", Missile_SetPosition },
364 { "Zombify", Missile_Zombify },
365 { NULL, NULL }
366 };
367
368 void
RegisterMissile(lua_State * L)369 RegisterMissile( lua_State* L )
370 {
371 REGISTER_BINDING( L,
372 BIND_METATABLE_NAME,
373 BIND_CLASS_NAME,
374 sMethodTable );
375 }
376
377 #endif // ! DOXYGEN
378
379 } // namespace bind
380
381 } // namespace lua
382