Free Electron
LuaObject.h
Go to the documentation of this file.
1 /* Copyright (C) 2003-2021 Free Electron Organization
2  Any use of this software requires a license. If a valid license
3  was not distributed with this file, visit freeelectron.org. */
4 
5 /** @file */
6 
7 #ifndef __lua_LuaObject_h__
8 #define __lua_LuaObject_h__
9 
10 namespace fe
11 {
12 namespace ext
13 {
14 
15 class LuaBaseObject
16 {
17  public:
18  LuaBaseObject(void) {}
19 virtual ~LuaBaseObject(void) {}
20  sp<LuaBaseType > &type(void) { return m_spType; }
21  LuaContext *context(void) { return m_spType->context(); }
22  protected:
23  sp<LuaBaseType > m_spType;
24 };
25 
26 template<class T, FE_UWORD tid>
27 class LuaObject : public LuaBaseObject
28 {
29  private:
30  LuaObject(void) { feX("LuaObject::LuaObject", "should never call"); }
31  public:
32  typedef LuaObject<T,tid> t_luott;
33  LuaObject(LuaContext *pContext, const T &data)
34  {
35  m_spType = pContext->lookup(tid);
36  m_data = data;
37  m_spType->pushMetaTable();
38  lua_setmetatable(m_spType->state(), -2);
39  }
40 virtual ~LuaObject(void){}
41  // factory that pushes onto stack
42 static LuaObject<T,tid> *push(LuaContext *pContext, const T &data)
43  {
44  void *pBlock = lua_newuserdata(pContext->state(),
45  sizeof(t_luott));
46  t_luott *pObj = new(pBlock)t_luott(pContext, data);
47  return pObj;
48  }
49  T &data(void) { return m_data; }
50 static int destroy(lua_State *pLuaState)
51  {
52  void *pV = lua_touserdata(pLuaState, -1);
53  t_luott *pW = (t_luott *)pV;
54  pW->~t_luott();
55  return 0;
56  }
57 static t_luott *selfIsFirst(lua_State *pLuaState)
58  {
59  if(!lua_isuserdata(pLuaState, 1))
60  {
61  LuaContext::error(pLuaState, "self not first parameter");
62  return NULL;
63  }
64  t_luott *pObj = (t_luott *)lua_touserdata(pLuaState, 1);
65  if(pObj->type() != pObj->context()->lookup(tid))
66  {
67  LuaContext::error(pLuaState, "self not first parameter");
68  return NULL;
69  }
70  return pObj;
71  }
72 
73 static String argType(lua_State *pLuaState,U32 index)
74  {
75  if (!lua_getmetatable(pLuaState, 2))
76  {
77  return "<no metatable>";
78  }
79 
80  lua_rawget(pLuaState, LUA_REGISTRYINDEX);
81  return lua_tostring(pLuaState, -1);
82  }
83  protected:
84  String aliasedName(String a_name)
85  {
86  LuaContext* pContext=context();
87  return pContext? pContext->aliasedName(a_name): a_name;
88  }
89 
90  private:
91  T m_data;
92 };
93 
94 /* ----------------------------------------------------------------------- */
95 // RECORD
96 typedef LuaObject<Record, LuaContext::e_record> t_lua_record;
97 class LuaRecordObject : public t_lua_record
98 {
99  public:
100 virtual ~LuaRecordObject(void) {}
101 static int index(lua_State *pLuaState);
102 static int newindex(lua_State *pLuaState);
103 static int isValid(lua_State *pLuaState);
104 static int check(lua_State *pLuaState);
105 static int layout(lua_State *pLuaState);
106 static int clone(lua_State *pLuaState);
107 //static int deepclone(lua_State *pLuaState);
108 };
109 
110 
111 typedef LuaType<Record, LuaRecordObject> t_lua_record_t;
112 class LuaRecordType : public t_lua_record_t
113 {
114  public:
115  LuaRecordType(LuaContext *pContext,const String &mtn);
116 virtual ~LuaRecordType(void){}
117 virtual void pushNewMetaTable(void);
118 };
119 
120 
121 /* ----------------------------------------------------------------------- */
122 // LAYOUT
123 typedef LuaObject<sp<Layout>, LuaContext::e_layout> t_lua_layout;
124 class LuaLayoutObject : public t_lua_layout
125 {
126  public:
127 virtual ~LuaLayoutObject(void) {}
128 static int index(lua_State *pLuaState);
129 static int scope(lua_State *pLuaState);
130 static int populate(lua_State *pLuaState);
131 static int createRecord(lua_State *pLuaState);
132 static int name(lua_State *pLuaState);
133 };
134 
135 typedef LuaType<sp<Layout>, LuaLayoutObject> t_lua_layout_t;
136 class LuaLayoutType : public t_lua_layout_t
137 {
138  public:
139  LuaLayoutType(LuaContext *pContext,const String &mtn);
140 virtual ~LuaLayoutType(void){}
141 };
142 
143 /* ----------------------------------------------------------------------- */
144 // SCOPE
145 typedef LuaObject<sp<Scope>, LuaContext::e_scope> t_lua_scope;
146 class LuaScopeObject : public t_lua_scope
147 {
148  public:
149 virtual ~LuaScopeObject(void) {}
150 static int index(lua_State *pLuaState);
151 static int declare(lua_State *pLuaState);
152 static int createRecord(lua_State *pLuaState);
153 };
154 
155 typedef LuaType<sp<Scope>, LuaScopeObject> t_lua_scope_t;
156 class LuaScopeType : public t_lua_scope_t
157 {
158  public:
159  LuaScopeType(LuaContext *pContext,const String &mtn);
160 virtual ~LuaScopeType(void){}
161 };
162 
163 /* ----------------------------------------------------------------------- */
164 // RECORD GROUP
165 typedef LuaObject<sp<RecordGroup>, LuaContext::e_group> t_lua_group;
166 class LuaGroupObject : public t_lua_group
167 {
168  public:
169 virtual ~LuaGroupObject(void) {}
170 static int index(lua_State *pLuaState);
171 static int iterator(lua_State *pLuaState);
172 static int newiterator(lua_State *pLuaState);
173 static int length(lua_State *pLuaState);
174 static int add(lua_State *pLuaState);
175 static int remove(lua_State *pLuaState);
176 static int lookup(lua_State *pLuaState);
177 static int setWeak(lua_State *pLuaState);
178 static int clear(lua_State *pLuaState);
179 static int array(lua_State *pLuaState);
180 };
181 
182 typedef LuaType<sp<RecordGroup>, LuaGroupObject> t_lua_group_t;
183 class LuaGroupType : public t_lua_group_t
184 {
185  public:
186  LuaGroupType(LuaContext *pContext,const String &mtn);
187 virtual ~LuaGroupType(void){}
188 virtual void pushNewMetaTable(void);
189 };
190 
191 /* ----------------------------------------------------------------------- */
192 // RECORD GROUP ITERATOR
193 typedef LuaObject<RecordGroup::iterator, LuaContext::e_groupit> t_lua_groupit;
194 class LuaGroupItObject : public t_lua_groupit
195 {
196  public:
197 virtual ~LuaGroupItObject(void) {}
198 static int index(lua_State *pLuaState);
199 };
200 
201 typedef LuaType<RecordGroup::iterator, LuaGroupItObject> t_lua_groupit_t;
202 class LuaGroupItType : public t_lua_groupit_t
203 {
204  public:
205  LuaGroupItType(LuaContext *pContext,const String &mtn);
206 virtual ~LuaGroupItType(void){}
207 };
208 
209 /* ----------------------------------------------------------------------- */
210 // RECORD Array
211 typedef LuaObject<sp<RecordArray>, LuaContext::e_array> t_lua_array;
212 class LuaArrayObject : public t_lua_array
213 {
214  public:
215 virtual ~LuaArrayObject(void) {}
216 static int index(lua_State *pLuaState);
217 static int iterator(lua_State *pLuaState);
218 static int newiterator(lua_State *pLuaState);
219 static int length(lua_State *pLuaState);
220 static int check(lua_State *pLuaState);
221 static int add(lua_State *pLuaState);
222 static int remove(lua_State *pLuaState);
223 };
224 
225 typedef LuaType<sp<RecordArray>, LuaArrayObject> t_lua_array_t;
226 class LuaArrayType : public t_lua_array_t
227 {
228  public:
229  LuaArrayType(LuaContext *pContext,const String &mtn);
230 virtual ~LuaArrayType(void){}
231 virtual void pushNewMetaTable(void);
232 };
233 
234 class LuaArrayContext
235 {
236  public:
237  sp<RecordArray> m_spRecordArray;
238  I32 m_index;
239 };
240 
241 typedef LuaObject<LuaArrayContext, LuaContext::e_arrayit> t_lua_arrayit;
242 class LuaArrayItObject : public t_lua_arrayit
243 {
244  public:
245 virtual ~LuaArrayItObject(void) {}
246 static int index(lua_State *pLuaState);
247 };
248 
249 typedef LuaType<LuaArrayContext, LuaArrayItObject> t_lua_arrayit_t;
250 class LuaArrayItType : public t_lua_arrayit_t
251 {
252  public:
253  LuaArrayItType(LuaContext *pContext,const String &mtn);
254 virtual ~LuaArrayItType(void){}
255 };
256 
257 /* ----------------------------------------------------------------------- */
258 // integer array
259 typedef LuaObject< Array<I32>*, LuaContext::e_intarray> t_lua_intarray;
260 class LuaIntArrayObject : public t_lua_intarray
261 {
262  public:
263 virtual ~LuaIntArrayObject(void) {}
264 static int index(lua_State *pLuaState);
265 static int iterator(lua_State *pLuaState);
266 static int newiterator(lua_State *pLuaState);
267 static int length(lua_State *pLuaState);
268 static int add(lua_State *pLuaState);
269 static int resize(lua_State *pLuaState);
270 };
271 
272 typedef LuaType< Array<I32>* , LuaIntArrayObject> t_lua_intarray_t;
273 class LuaIntArrayType : public t_lua_intarray_t
274 {
275  public:
276  LuaIntArrayType(LuaContext *pContext,const String &mtn);
277 virtual ~LuaIntArrayType(void) {}
278 virtual void pushNewMetaTable(void);
279 };
280 
281 class LuaIntArrayContext
282 {
283  public:
284  Array<I32>* m_pIntArray;
285  I32 m_index;
286 };
287 
288 typedef LuaObject<LuaIntArrayContext,
289  LuaContext::e_intarrayit> t_lua_intarrayit;
290 class LuaIntArrayItObject : public t_lua_intarrayit
291 {
292  public:
293 virtual ~LuaIntArrayItObject(void) {}
294 static int index(lua_State *pLuaState);
295 };
296 
297 typedef LuaType<LuaIntArrayContext, LuaIntArrayItObject> t_lua_intarrayit_t;
298 class LuaIntArrayItType : public t_lua_intarrayit_t
299 {
300  public:
301  LuaIntArrayItType(LuaContext *pContext,const String &mtn);
302 virtual ~LuaIntArrayItType(void) {}
303 };
304 
305 /* ----------------------------------------------------------------------- */
306 // float vector
307 typedef LuaObject<float *, LuaContext::e_vector> t_lua_vector;
308 class LuaVectorObject : public t_lua_vector
309 {
310  public:
311 virtual ~LuaVectorObject(void) {}
312 static int newindex(lua_State *pLuaState);
313 static int index(lua_State *pLuaState);
314 };
315 
316 typedef LuaType<float *, LuaVectorObject> t_lua_vector_t;
317 class LuaVectorType : public t_lua_vector_t
318 {
319  public:
320  LuaVectorType(LuaContext *pContext,const String &mtn);
321 virtual ~LuaVectorType(void){}
322 virtual void pushNewMetaTable(void);
323 };
324 
325 /* ----------------------------------------------------------------------- */
326 // StateCatalog specialization
327 typedef LuaObject< sp<StateCatalog>, LuaContext::e_statecatalog> t_lua_statecatalog;
328 class LuaStateCatalogObject : public t_lua_statecatalog
329 {
330  public:
331 virtual ~LuaStateCatalogObject(void) {}
332 static int index(lua_State *pLuaState);
333 static int getState(lua_State *pLuaState);
334 static int setState(lua_State *pLuaState);
335 };
336 
337 typedef LuaType< sp<StateCatalog>, LuaStateCatalogObject> t_lua_statecatalog_t;
338 class LuaStateCatalogType : public t_lua_statecatalog_t
339 {
340  public:
341  LuaStateCatalogType(LuaContext *pContext,
342  const String &mtn);
343 virtual ~LuaStateCatalogType(void){}
344 };
345 
346 template<class T, FE_UWORD tid>
347 class LuaDeletableObject : public LuaObject<T,tid>
348 {
349  public:
350  typedef LuaDeletableObject<T,tid> t_luott;
351 
352  LuaDeletableObject(LuaContext *pContext,
353  const T &data, BWORD a_deletable):
354  LuaObject<T,tid>(pContext,data),
355  m_deletable(a_deletable) {}
356 
357 static LuaObject<T,tid> *push(LuaContext *pContext, const T &data,
358  BWORD a_deletable=FALSE)
359  {
360  void *pBlock = lua_newuserdata(pContext->state(),
361  sizeof(t_luott));
362  t_luott *pObj = new(pBlock)t_luott(pContext, data, a_deletable);
363  return pObj;
364  }
365 
366 static int destroy(lua_State *pLuaState)
367  {
368  void *pV = lua_touserdata(pLuaState, -1);
369  t_luott *pW = (t_luott *)pV;
370 
371  if(pW->m_deletable)
372  {
373  T pT=pW->data();
374  delete pT;
375  }
376 
377  pW->~t_luott();
378  return 0;
379  }
380  BWORD m_deletable;
381 };
382 
383 /* ----------------------------------------------------------------------- */
384 // SpatialTransform specialization
385 typedef LuaDeletableObject<SpatialTransform*,
386  LuaContext::e_transform> t_lua_transform;
387 class LuaTransformObject : public t_lua_transform
388 {
389  public:
390 virtual ~LuaTransformObject(void) {}
391 static int newindex(lua_State *pLuaState);
392 static int index(lua_State *pLuaState);
393 static int eq(lua_State *pLuaState);
394 static int copy(lua_State *pLuaState);
395 static int set(lua_State *pLuaState);
396 };
397 
398 typedef LuaType<SpatialTransform*, LuaTransformObject> t_lua_transform_t;
399 class LuaTransformType : public t_lua_transform_t
400 {
401  public:
402  LuaTransformType(LuaContext *pContext,
403  const String &mtn);
404 virtual ~LuaTransformType(void){}
405 virtual void pushNewMetaTable(void);
406 };
407 
408 /* ----------------------------------------------------------------------- */
409 // Vector<> specialization
410 template<int N, class T, FE_UWORD tid>
411 class LuaVectorNObject :
412  public LuaDeletableObject<Vector<N,T>*, tid>
413 {
414  public:
415 virtual ~LuaVectorNObject(void) {}
416 static int newindex(lua_State *pLuaState);
417 static int index(lua_State *pLuaState);
418 static int eq(lua_State *pLuaState);
419 static int unm(lua_State *pLuaState);
420 static int add(lua_State *pLuaState);
421 static int sub(lua_State *pLuaState);
422 static int mul(lua_State *pLuaState);
423 static int copy(lua_State *pLuaState);
424 static int unit(lua_State *pLuaState);
425 static int normalize(lua_State *pLuaState);
426 static int magnitude(lua_State *pLuaState);
427 static int dot(lua_State *pLuaState);
428 static int cross3(lua_State *pLuaState);
429 static int set(lua_State *pLuaState);
430 };
431 
432 template<int N, class T, FE_UWORD tid>
433 int LuaVectorNObject<N,T,tid>::index(lua_State *pLuaState)
434 {
435  LuaVectorNObject<N,T,tid> *pObj = (LuaVectorNObject<N,T,tid> *)
436  LuaObject<T,tid>::selfIsFirst(pLuaState);
437  if(!pObj)
438  {
439  return 0;
440  }
441 
442  if(lua_isnumber(pLuaState, -1))
443  {
444  int index = (int)lua_tonumber(pLuaState, -1);
445  lua_pop(pLuaState, 1);
446  lua_pushnumber(pLuaState, (*pObj->data())[index]);
447  return 1;
448  }
449 
450  String methodName = lua_tostring(pLuaState, -1);
451 
452  lua_pop(pLuaState, 1);
453 
454  if(!pObj->type()->pushMethod(methodName))
455  {
456  return 0;
457  }
458 
459  return 1;
460 }
461 
462 template<int N, class T, FE_UWORD tid>
463 int LuaVectorNObject<N,T,tid>::newindex(lua_State *pLuaState)
464 {
465  LuaVectorNObject<N,T,tid> *pObj =
466  (LuaVectorNObject<N,T,tid> *)lua_touserdata(pLuaState, 1);
467  if(!pObj|| !lua_isnumber(pLuaState, -2))
468  {
469  return 0;
470  }
471 
472  int index = (int)lua_tonumber(pLuaState, -2);
473  float value = (float)lua_tonumber(pLuaState, -1);
474 
475  setAt(*pObj->data(),index,(Real)value);
476 
477  lua_pushnumber(pLuaState, value);
478  return 1;
479 }
480 
481 template<int N, class T, FE_UWORD tid>
482 int LuaVectorNObject<N,T,tid>::eq(lua_State *pLuaState)
483 {
484  LuaVectorNObject<N,T,tid> *pObj =
485  (LuaVectorNObject<N,T,tid> *)lua_touserdata(pLuaState, 1);
486  if(!pObj)
487  {
488  return 0;
489  }
490 
491  LuaVectorNObject<N,T,tid>* pOther;
492  if((pOther=reinterpret_cast<LuaVectorNObject<N,T,tid>*>
493  (luaL_checkudata(pLuaState,2,pObj->type()->name().c_str()))))
494  {
495  lua_pushboolean(pLuaState,*pObj->data() == *pOther->data());
496  return 1;
497  }
498 
499  feLog("LuaVectorNObject::eq incompatible argType \"%s\"\n",
500  LuaObject<T,tid>::argType(pLuaState,2).c_str());
501  return 0;
502 }
503 
504 //* unary negation
505 template<int N, class T, FE_UWORD tid>
506 int LuaVectorNObject<N,T,tid>::unm(lua_State *pLuaState)
507 {
508  LuaVectorNObject<N,T,tid> *pObj =
509  (LuaVectorNObject<N,T,tid> *)lua_touserdata(pLuaState, 1);
510  if(!pObj)
511  {
512  return 0;
513  }
514 
515  Vector<N,T>* pNegative=new Vector<N,T>(-(*pObj->data()));
516  LuaVectorNObject<N,T,tid>::push(pObj->context(),pNegative,TRUE);
517  return 1;
518 }
519 
520 template<int N, class T, FE_UWORD tid>
521 int LuaVectorNObject<N,T,tid>::add(lua_State *pLuaState)
522 {
523  LuaVectorNObject<N,T,tid> *pObj =
524  (LuaVectorNObject<N,T,tid> *)lua_touserdata(pLuaState, 1);
525  if(!pObj)
526  {
527  return 0;
528  }
529 
530  LuaVectorNObject<N,T,tid>* pOther;
531  if((pOther=reinterpret_cast<LuaVectorNObject<N,T,tid>*>
532  (luaL_checkudata(pLuaState,2,pObj->type()->name().c_str()))))
533  {
534  Vector<N,T>* pSum=new Vector<N,T>(*pObj->data() + *pOther->data());
535  LuaVectorNObject<N,T,tid>::push(pObj->context(),pSum,TRUE);
536  return 1;
537  }
538 
539  feLog("LuaVectorNObject::add incompatible argType \"%s\"\n",
540  LuaObject<T,tid>::argType(pLuaState,2).c_str());
541  return 0;
542 }
543 
544 template<int N, class T, FE_UWORD tid>
545 int LuaVectorNObject<N,T,tid>::sub(lua_State *pLuaState)
546 {
547  LuaVectorNObject<N,T,tid> *pObj =
548  (LuaVectorNObject<N,T,tid> *)lua_touserdata(pLuaState, 1);
549  if(!pObj)
550  {
551  return 0;
552  }
553 
554  LuaVectorNObject<N,T,tid>* pOther;
555  if((pOther=reinterpret_cast<LuaVectorNObject<N,T,tid>*>
556  (luaL_checkudata(pLuaState,2,pObj->type()->name().c_str()))))
557  {
558  Vector<N,T>* pDiff=new Vector<N,T>(*pObj->data() - *pOther->data());
559  LuaVectorNObject<N,T,tid>::push(pObj->context(),pDiff,TRUE);
560  return 1;
561  }
562 
563  feLog("LuaVectorNObject::sub incompatible argType \"%s\"\n",
564  LuaObject<T,tid>::argType(pLuaState,2).c_str());
565  return 0;
566 }
567 
568 template<int N, class T, FE_UWORD tid>
569 int LuaVectorNObject<N,T,tid>::mul(lua_State *pLuaState)
570 {
571  I32 scalarPos= -1;
572  LuaVectorNObject<N,T,tid> *pObj =
573  (LuaVectorNObject<N,T,tid> *)lua_touserdata(pLuaState, 1);
574  if(!pObj)
575  {
576  scalarPos= -2;
577  pObj = (LuaVectorNObject<N,T,tid> *)lua_touserdata(pLuaState, 2);
578  }
579  if(!pObj)
580  {
581  return 0;
582  }
583 
584  F32 scalar=0.0f;
585  if(lua_isnumber(pLuaState,scalarPos))
586  {
587  scalar = (F32)lua_tonumber(pLuaState,scalarPos);
588  }
589  else
590  {
591  return 0;
592  }
593 
594  Vector<N,T>* pSum=new Vector<N,T>(*pObj->data() * (Real)scalar);
595  LuaVectorNObject<N,T,tid>::push(pObj->context(),pSum,TRUE);
596  return 1;
597 }
598 
599 template<int N, class T, FE_UWORD tid>
600 int LuaVectorNObject<N,T,tid>::copy(lua_State *pLuaState)
601 {
602  LuaVectorNObject<N,T,tid> *pObj =
603  (LuaVectorNObject<N,T,tid> *)lua_touserdata(pLuaState, 1);
604  if(!pObj)
605  {
606  return 0;
607  }
608 
609  Vector<N,T>* pDuplicate=new Vector<N,T>(*pObj->data());
610  LuaVectorNObject<N,T,tid>::push(pObj->context(),pDuplicate,TRUE);
611  return 1;
612 }
613 
614 template<int N, class T, FE_UWORD tid>
615 int LuaVectorNObject<N,T,tid>::unit(lua_State *pLuaState)
616 {
617  LuaVectorNObject<N,T,tid> *pObj =
618  (LuaVectorNObject<N,T,tid> *)lua_touserdata(pLuaState, 1);
619  if(!pObj)
620  {
621  return 0;
622  }
623 
624  Vector<N,T>* pNormal=new Vector<N,T>(fe::unit(*pObj->data()));
625  LuaVectorNObject<N,T,tid>::push(pObj->context(),pNormal,TRUE);
626  return 1;
627 }
628 
629 template<int N, class T, FE_UWORD tid>
630 int LuaVectorNObject<N,T,tid>::normalize(lua_State *pLuaState)
631 {
632  LuaVectorNObject<N,T,tid> *pObj =
633  (LuaVectorNObject<N,T,tid> *)lua_touserdata(pLuaState, 1);
634  if(!pObj)
635  {
636  return 0;
637  }
638 
639  fe::normalize(*pObj->data());
640  LuaVectorNObject<N,T,tid>::push(pObj->context(),pObj->data());
641  return 1;
642 }
643 
644 template<int N, class T, FE_UWORD tid>
645 int LuaVectorNObject<N,T,tid>::magnitude(lua_State *pLuaState)
646 {
647  LuaVectorNObject<N,T,tid> *pObj =
648  (LuaVectorNObject<N,T,tid> *)lua_touserdata(pLuaState, 1);
649  if(!pObj)
650  {
651  return 0;
652  }
653 
654  F32 length=fe::magnitude(*pObj->data());
655  lua_pushnumber(pLuaState, length);
656  return 1;
657 }
658 
659 template<int N, class T, FE_UWORD tid>
660 int LuaVectorNObject<N,T,tid>::dot(lua_State *pLuaState)
661 {
662  LuaVectorNObject<N,T,tid> *pObj =
663  (LuaVectorNObject<N,T,tid> *)lua_touserdata(pLuaState, 1);
664  if(!pObj)
665  {
666  return 0;
667  }
668 
669  LuaVectorNObject<N,T,tid>* pOther;
670  if((pOther=reinterpret_cast<LuaVectorNObject<N,T,tid>*>
671  (luaL_checkudata(pLuaState,2,pObj->type()->name().c_str()))))
672  {
673  F32 dot=fe::dot(*pObj->data(),*pOther->data());
674  lua_pushnumber(pLuaState, dot);
675  return 1;
676  }
677 
678  feLog("LuaVectorNObject::dot incompatible argType \"%s\"\n",
679  LuaObject<T,tid>::argType(pLuaState,2).c_str());
680  return 0;
681 }
682 
683 template<int N, class T, FE_UWORD tid>
684 int LuaVectorNObject<N,T,tid>::cross3(lua_State *pLuaState)
685 {
686  LuaVectorNObject<N,T,tid> *pObj =
687  (LuaVectorNObject<N,T,tid> *)lua_touserdata(pLuaState, 1);
688  if(!pObj)
689  {
690  return 0;
691  }
692 
693  LuaVectorNObject<N,T,tid>* pOther;
694  if((pOther=reinterpret_cast<LuaVectorNObject<N,T,tid>*>
695  (luaL_checkudata(pLuaState,2,pObj->type()->name().c_str()))))
696  {
697 // Vector<N,T>* pCross=
698 // new Vector<N,T>(fe::cross3(*pObj->data(),*pOther->data()));
699 
700  Vector<3,T> lhs(*pObj->data());
701  Vector<3,T> rhs(*pOther->data());
702  Vector<3,T> result=fe::cross3(lhs,rhs);
703  Vector<N,T>* pCross=new Vector<N,T>(result);
704 
705  LuaVectorNObject<N,T,tid>::push(pObj->context(),pCross,TRUE);
706  return 1;
707  }
708 
709  feLog("LuaVectorNObject::cross3 incompatible argType \"%s\"\n",
710  LuaObject<T,tid>::argType(pLuaState,2).c_str());
711  return 0;
712 }
713 
714 template<int N, class T, FE_UWORD tid>
715 int LuaVectorNObject<N,T,tid>::set(lua_State *pLuaState)
716 {
717  LuaVectorNObject<N,T,tid> *pObj =
718  (LuaVectorNObject<N,T,tid> *)lua_touserdata(pLuaState, 1);
719  if(!pObj)
720  {
721  return 0;
722  }
723 
724  LuaVectorNObject<N,T,tid>* pOther;
725  if((pOther=reinterpret_cast<LuaVectorNObject<N,T,tid>*>
726  (luaL_checkudata(pLuaState,2,pObj->type()->name().c_str()))))
727  {
728  *pObj->data()=*pOther->data();
729  LuaVectorNObject<N,T,tid>::push(pObj->context(),pObj->data());
730  return 1;
731  }
732 
733  Vector<N,T>& rVector = *pObj->data();
734  fe::set(rVector);
735 
736  if(lua_isnumber(pLuaState, 2))
737  {
738  rVector[0]=(Real)lua_tonumber(pLuaState, 2);
739  }
740  if(N>1 && lua_isnumber(pLuaState, 3))
741  {
742  rVector[1]=(Real)lua_tonumber(pLuaState, 3);
743  }
744  if(N>2 && lua_isnumber(pLuaState, 4))
745  {
746  rVector[2]=(Real)lua_tonumber(pLuaState, 4);
747  }
748  if(N>3 && lua_isnumber(pLuaState, 5))
749  {
750  rVector[3]=(Real)lua_tonumber(pLuaState, 5);
751  }
752 
753  LuaVectorNObject<N,T,tid>::push(pObj->context(),pObj->data());
754  return 1;
755 }
756 
757 template<int N, class T, FE_UWORD tid>
758 class LuaVectorNType:
759  public LuaType< Vector<N,T>*, LuaVectorNObject<N,T,tid> >
760 {
761  public:
762  LuaVectorNType(LuaContext *pContext,const String &mtn);
763 virtual ~LuaVectorNType(void){}
764 virtual void pushNewMetaTable(void);
765 };
766 
767 template<int N, class T, FE_UWORD tid>
768 inline LuaVectorNType<N,T,tid>::LuaVectorNType(
769  LuaContext *pContext,const String &mtn):
770  LuaType< Vector<N,T>*, LuaVectorNObject<N,T,tid> >(pContext, mtn)
771 {
772  //* unit normalize magnitude dot cross3 set
773  LuaBaseType::setMethod("copy", LuaVectorNObject<N,T,tid>::copy);
774  LuaBaseType::setMethod("unit", LuaVectorNObject<N,T,tid>::unit);
775  LuaBaseType::setMethod("normalize", LuaVectorNObject<N,T,tid>::normalize);
776  LuaBaseType::setMethod("magnitude", LuaVectorNObject<N,T,tid>::magnitude);
777  LuaBaseType::setMethod("dot", LuaVectorNObject<N,T,tid>::dot);
778  LuaBaseType::setMethod("cross3", LuaVectorNObject<N,T,tid>::cross3);
779  LuaBaseType::setMethod("set", LuaVectorNObject<N,T,tid>::set);
780 }
781 
782 template<int N, class T, FE_UWORD tid>
783 void LuaVectorNType<N,T,tid>::pushNewMetaTable(void)
784 {
785  lua_State *pLuaState = LuaVectorNType<N,T,tid>::m_pContext->state();
786 
787 // lua_newtable(pLuaState);
788  luaL_newmetatable(pLuaState,LuaVectorNType<N,T,tid>::m_mtname.c_str());
789 
790  // call index newindex add sub mul div unm pow concat lt le eq
791 
792  lua_pushstring(pLuaState, "__gc");
793  lua_pushcfunction(pLuaState, (LuaVectorNObject<N,T,tid>::destroy));
794  lua_settable(pLuaState, -3);
795 
796  lua_pushstring(pLuaState, "__index");
797  lua_pushcfunction(pLuaState, (LuaVectorNObject<N,T,tid>::index));
798  lua_settable(pLuaState, -3);
799 
800  lua_pushstring(pLuaState, "__newindex");
801  lua_pushcfunction(pLuaState, (LuaVectorNObject<N,T,tid>::newindex));
802  lua_settable(pLuaState, -3);
803 
804  lua_pushstring(pLuaState, "__eq");
805  lua_pushcfunction(pLuaState, (LuaVectorNObject<N,T,tid>::eq));
806  lua_settable(pLuaState, -3);
807 
808  lua_pushstring(pLuaState, "__unm");
809  lua_pushcfunction(pLuaState, (LuaVectorNObject<N,T,tid>::unm));
810  lua_settable(pLuaState, -3);
811 
812  lua_pushstring(pLuaState, "__add");
813  lua_pushcfunction(pLuaState, (LuaVectorNObject<N,T,tid>::add));
814  lua_settable(pLuaState, -3);
815 
816  lua_pushstring(pLuaState, "__sub");
817  lua_pushcfunction(pLuaState, (LuaVectorNObject<N,T,tid>::sub));
818  lua_settable(pLuaState, -3);
819 
820  lua_pushstring(pLuaState, "__mul");
821  lua_pushcfunction(pLuaState, (LuaVectorNObject<N,T,tid>::mul));
822  lua_settable(pLuaState, -3);
823 }
824 
825 /* ----------------------------------------------------------------------- */
826 // Vector4 specialization
827 typedef LuaVectorNObject<4,Real,LuaContext::e_vector4> t_lua_vector4;
828 class LuaVector4Object : public t_lua_vector4
829 {
830  public:
831 virtual ~LuaVector4Object(void) {}
832 };
833 
834 typedef LuaVectorNType<4,Real,LuaContext::e_vector4> t_lua_vector4_t;
835 class LuaVector4Type : public t_lua_vector4_t
836 {
837  public:
838  LuaVector4Type(LuaContext *pContext,const String &mtn):
839  LuaVectorNType<4,Real,LuaContext::e_vector4>(
840  pContext,mtn) {}
841 };
842 
843 /* ----------------------------------------------------------------------- */
844 // Vector4f specialization
845 typedef LuaVectorNObject<4,float,LuaContext::e_vector4f> t_lua_vector4f;
846 class LuaVector4fObject : public t_lua_vector4f
847 {
848  public:
849 virtual ~LuaVector4fObject(void) {}
850 };
851 
852 typedef LuaVectorNType<4,float,LuaContext::e_vector4f> t_lua_vector4f_t;
853 class LuaVector4fType : public t_lua_vector4f_t
854 {
855  public:
856  LuaVector4fType(LuaContext *pContext,const String &mtn):
857  LuaVectorNType<4,float,LuaContext::e_vector4f>(
858  pContext,mtn) {}
859 };
860 
861 /* ----------------------------------------------------------------------- */
862 // Vector3 specialization
863 typedef LuaVectorNObject<3,float,LuaContext::e_vector3> t_lua_vector3;
864 class LuaVector3Object : public t_lua_vector3
865 {
866  public:
867 virtual ~LuaVector3Object(void) {}
868 };
869 
870 typedef LuaVectorNType<3,float,LuaContext::e_vector3> t_lua_vector3_t;
871 class LuaVector3Type : public t_lua_vector3_t
872 {
873  public:
874  LuaVector3Type(LuaContext *pContext,const String &mtn):
875  LuaVectorNType<3,float,LuaContext::e_vector3>(
876  pContext,mtn) {}
877 };
878 
879 /* ----------------------------------------------------------------------- */
880 // Vector2 specialization
881 typedef LuaVectorNObject<2,float,LuaContext::e_vector2> t_lua_vector2;
882 class LuaVector2Object : public t_lua_vector2
883 {
884  public:
885 virtual ~LuaVector2Object(void) {}
886 };
887 
888 typedef LuaVectorNType<2,float,LuaContext::e_vector2> t_lua_vector2_t;
889 class LuaVector2Type : public t_lua_vector2_t
890 {
891  public:
892  LuaVector2Type(LuaContext *pContext,const String &mtn):
893  LuaVectorNType<2,float,LuaContext::e_vector2>(
894  pContext,mtn) {}
895 };
896 
897 } /* namespace ext */
898 } /* namespace fe */
899 
900 #endif /* __lua_LuaObject_h__ */
901 
fe
kernel
Definition: namespace.dox:3
Generated by   doxygen 1.8.13