source: trunk/src/easymesh/easymeshlua.h @ 3863

Last change on this file since 3863 was 3863, checked in by touky, 7 years ago

2nd pass on Lua integration.
First pass on EzMesh integration (doesn't work yet)

File size: 17.7 KB
Line 
1//
2//  MY CLASS TYPE
3//
4//  Copyright © 2009-2015 Benjamin "Touky" Huet <huet.benjamin@gmail.com>
5//
6//  This program is free software. It comes without any warranty, to
7//  the extent permitted by applicable law. You can redistribute it
8//  and/or modify it under the terms of the Do What the Fuck You Want
9//  to Public License, Version 2, as published by the WTFPL Task Force.
10//  See http://www.wtfpl.net/ for more details.
11//
12
13#pragma once
14
15namespace lol
16{
17
18//-----------------------------------------------------------------------------
19class EasyMeshLuaLoader : public LuaLoader
20{
21public:
22    EasyMeshLuaLoader();
23    virtual ~EasyMeshLuaLoader();
24};
25   
26//-----------------------------------------------------------------------------
27class EasyMeshLuaObject : public LuaObjectDef
28{
29    typedef Lolua::VarPtr<EasyMeshLuaObject> EzMeshPtr;
30    EasyMesh m_instance;
31public:
32    //-------------------------------------------------------------------------
33    EasyMeshLuaObject();
34    virtual ~EasyMeshLuaObject();
35
36    //-------------------------------------------------------------------------
37    static EasyMeshLuaObject* New(LuaState* l, int arg_nb);
38    static const LuaObjectLib* GetLib();
39
40    //-------------------------------------------------------------------------
41    static int AppendCylinder(LuaState* l)
42    {
43        LuaStack s(l);
44        EzMeshPtr m;
45        LuaInt32 nsides;
46        LuaFloat h, d1, d2;
47        LuaBool dualside(false, true), smooth(false, true), close(false, true);
48        s >> m >> nsides >> h >> d1 >> d2 >> dualside >> smooth >> close;
49        m->m_instance.AppendCylinder(nsides, h, d1, d2, dualside, smooth, close);
50        return 0;
51    }
52    static int AppendSphere(LuaState* l)
53    {
54        LuaStack s(l);
55        EzMeshPtr m;
56        LuaInt32 ndivisions;
57        LuaFloat d;
58        s >> m >> ndivisions >> d;
59        m->m_instance.AppendSphere(ndivisions, d);
60        return 0;
61    }
62    static int AppendCapsule(LuaState* l)
63    {
64        LuaStack s(l);
65        EzMeshPtr m;
66        LuaInt32 ndivisions;
67        LuaFloat h, d;
68        s >> m >> ndivisions >> h >> d;
69        m->m_instance.AppendCapsule(ndivisions, h, d);
70        return 0;
71    }
72    static int AppendTorus(LuaState* l)
73    {
74        LuaStack s(l);
75        EzMeshPtr m;
76        LuaInt32 ndivisions;
77        LuaFloat d1, d2;
78        s >> m >> ndivisions >> d1 >> d2;
79        m->m_instance.AppendTorus(ndivisions, d1, d2);
80        return 0;
81    }
82    static int AppendBox(LuaState* l)
83    {
84        LuaStack s(l);
85        EzMeshPtr m;
86        LuaVec3 size;
87        LuaFloat chamf(0.f, true);
88        LuaBool smooth(false, true);
89        s >> m >> size >> chamf >> smooth;
90        m->m_instance.AppendBox(size, chamf, smooth);
91        return 0;
92    }
93    static int AppendStar(LuaState* l)
94    {
95        LuaStack s(l);
96        EzMeshPtr m;
97        LuaInt32 nbranches;
98        LuaFloat d1, d2;
99        LuaBool fade(false, true), fade2(false, true);
100        s >> m >> nbranches >> d1 >> d2 >> fade >> fade2;
101        m->m_instance.AppendStar(nbranches, d1, d2, fade, fade2);
102        return 0;
103    }
104    static int AppendExpandedStar(LuaState* l)
105    {
106        LuaStack s(l);
107        EzMeshPtr m;
108        LuaInt32 nbranches;
109        LuaFloat d1, d2, extrad(0.f, true);
110        s >> m >> nbranches >> d1 >> d2 >> extrad;
111        m->m_instance.AppendExpandedStar(nbranches, d1, d2, extrad);
112        return 0;
113    }
114    static int AppendDisc(LuaState* l)
115    {
116        LuaStack s(l);
117        EzMeshPtr m;
118        LuaInt32 nsides;
119        LuaFloat d;
120        LuaBool fade(false, true);
121        s >> m >> nsides >> d >> fade;
122        m->m_instance.AppendDisc(nsides, d, fade);
123        return 0;
124    }
125    static int AppendSimpleTriangle(LuaState* l)
126    {
127        LuaStack s(l);
128        EzMeshPtr m;
129        LuaFloat d;
130        LuaBool fade(false, true);
131        s >> m >> d >> fade;
132        m->m_instance.AppendSimpleTriangle(d, fade);
133        return 0;
134    }
135    static int AppendSimpleQuad(LuaState* l)
136    {
137        LuaStack s(l);
138        EzMeshPtr m;
139        LuaFloat size;
140        LuaBool fade(false, true);
141        s >> m >> size >> fade;
142        m->m_instance.AppendSimpleQuad(size, fade);
143        return 0;
144    }
145    static int AppendCog(LuaState* l)
146    {
147        LuaStack s(l);
148        EzMeshPtr m;
149        LuaInt32 nbsides;
150        LuaFloat h, sidemul(0.f, true);
151        LuaVec2 d0, d1, d2;
152        LuaBool offset(false, true);
153        s >> m >> nbsides >> h >> d0 >> d1 >> d2 >> sidemul >> offset;
154        m->m_instance.AppendCog(nbsides, h, d0().x, d0().y, d1().x, d1().y, d2().x, d2().y, sidemul, offset);
155        return 0;
156    }
157    //-------------------------------------------------------------------------
158    static int TranslateX(LuaState* l)
159    {
160        LuaStack s(l);
161        EzMeshPtr m;
162        LuaFloat f;
163        s >> m >> f;
164        m->m_instance.TranslateX(f);
165        return 0;
166    }
167    static int TranslateY(LuaState* l)
168    {
169        LuaStack s(l);
170        EzMeshPtr m;
171        LuaFloat f;
172        s >> m >> f;
173        m->m_instance.TranslateY(f);
174        return 0;
175    }
176    static int TranslateZ(LuaState* l)
177    {
178        LuaStack s(l);
179        EzMeshPtr m;
180        LuaFloat f;
181        s >> m >> f;
182        m->m_instance.TranslateZ(f);
183        return 0;
184    }
185    static int Translate(LuaState* l)
186    {
187        LuaStack s(l);
188        EzMeshPtr m;
189        LuaVec3 v;
190        s >> m >> v;
191        m->m_instance.Translate(v);
192        return 0;
193    }
194    //-------------------------------------------------------------------------
195    static int RotateX(LuaState* l)
196    {
197        LuaStack s(l);
198        EzMeshPtr m;
199        LuaFloat a;
200        s >> m >> a;
201        m->m_instance.RotateX(a);
202        return 0;
203    }
204    static int RotateY(LuaState* l)
205    {
206        LuaStack s(l);
207        EzMeshPtr m;
208        LuaFloat a;
209        s >> m >> a;
210        m->m_instance.RotateY(a);
211        return 0;
212    }
213    static int RotateZ(LuaState* l)
214    {
215        LuaStack s(l);
216        EzMeshPtr m;
217        LuaFloat a;
218        s >> m >> a;
219        m->m_instance.RotateZ(a);
220        return 0;
221    }
222    static int Rotate(LuaState* l)
223    {
224        LuaStack s(l);
225        EzMeshPtr m;
226        LuaFloat a;
227        LuaVec3 v;
228        s >> m >> a >> v;
229        m->m_instance.Rotate(a, v);
230        return 0;
231    }
232    //-------------------------------------------------------------------------
233    static int ScaleX(LuaState* l)
234    {
235        LuaStack s(l);
236        EzMeshPtr m;
237        LuaFloat x;
238        s >> m >> x;
239        m->m_instance.ScaleX(x);
240        return 0;
241    }
242    static int ScaleY(LuaState* l)
243    {
244        LuaStack s(l);
245        EzMeshPtr m;
246        LuaFloat y;
247        s >> m >> y;
248        m->m_instance.ScaleY(y);
249        return 0;
250    }
251    static int ScaleZ(LuaState* l)
252    {
253        LuaStack s(l);
254        EzMeshPtr m;
255        LuaFloat z;
256        s >> m >> z;
257        m->m_instance.ScaleZ(z);
258        return 0;
259    }
260    static int Scale(LuaState* l)
261    {
262        LuaStack s(l);
263        EzMeshPtr m;
264        LuaVec3 v;
265        s >> m >> v;
266        m->m_instance.Scale(v);
267        return 0;
268    }
269    //-------------------------------------------------------------------------
270    static int RadialJitter(LuaState* l)
271    {
272        LuaStack s(l);
273        EzMeshPtr m;
274        LuaFloat f;
275        s >> m >> f;
276        m->m_instance.RadialJitter(f);
277        return 0;
278    }
279    //-------------------------------------------------------------------------
280    static int TaperX(LuaState* l)
281    {
282        LuaStack s(l);
283        EzMeshPtr m;
284        LuaFloat y, z, xoff(0.f, true);
285        LuaBool abs(true, true);
286        s >> m >> y >> z >> xoff >> abs;
287        m->m_instance.TaperX(y, z, xoff, abs);
288        return 0;
289    }
290    static int TaperY(LuaState* l)
291    {
292        LuaStack s(l);
293        EzMeshPtr m;
294        LuaFloat x, z, yoff(0.f, true);
295        LuaBool abs(true, true);
296        s >> m >> x >> z >> yoff >> abs;
297        m->m_instance.TaperY(x, z, yoff, abs);
298        return 0;
299    }
300    static int TaperZ(LuaState* l)
301    {
302        LuaStack s(l);
303        EzMeshPtr m;
304        LuaFloat x, y, zoff(0.f, true);
305        LuaBool abs(true, true);
306        s >> m >> x >> y >> zoff >> abs;
307        m->m_instance.TaperZ(x, y, zoff, abs);
308        return 0;
309    }
310    //-------------------------------------------------------------------------
311    static int TwistX(LuaState* l)
312    {
313        LuaStack s(l);
314        EzMeshPtr m;
315        LuaFloat t, toff(0.f, true);
316        s >> m >> t >> toff;
317        m->m_instance.TwistX(t, toff);
318        return 0;
319    }
320    static int TwistY(LuaState* l)
321    {
322        LuaStack s(l);
323        EzMeshPtr m;
324        LuaFloat t, toff(0.f, true);
325        s >> m >> t >> toff;
326        m->m_instance.TwistY(t, toff);
327        return 0;
328    }
329    static int TwistZ(LuaState* l)
330    {
331        LuaStack s(l);
332        EzMeshPtr m;
333        LuaFloat t, toff(0.f, true);
334        s >> m >> t >> toff;
335        m->m_instance.TwistZ(t, toff);
336        return 0;
337    }
338    //-------------------------------------------------------------------------
339    static int ShearX(LuaState* l)
340    {
341        LuaStack s(l);
342        EzMeshPtr m;
343        LuaFloat y, z, xoff(0.f, true);
344        LuaBool abs(true, true);
345        s >> m >> y >> z >> xoff >> abs;
346        m->m_instance.ShearX(y, z, xoff, abs);
347        return 0;
348    }
349    static int ShearY(LuaState* l)
350    {
351        LuaStack s(l);
352        EzMeshPtr m;
353        LuaFloat x, z, yoff(0.f, true);
354        LuaBool abs(true, true);
355        s >> m >> x >> z >> yoff >> abs;
356        m->m_instance.ShearY(x, z, yoff, abs);
357        return 0;
358    }
359    static int ShearZ(LuaState* l)
360    {
361        LuaStack s(l);
362        EzMeshPtr m;
363        LuaFloat x, y, zoff(0.f, true);
364        LuaBool abs(true, true);
365        s >> m >> x >> y >> zoff >> abs;
366        m->m_instance.ShearZ(x, y, zoff, abs);
367        return 0;
368    }
369    //-------------------------------------------------------------------------
370    static int StretchX(LuaState* l)
371    {
372        LuaStack s(l);
373        EzMeshPtr m;
374        LuaFloat y, z, xoff(0.f, true);
375        s >> m >> y >> z >> xoff;
376        m->m_instance.StretchX(y, z, xoff);
377        return 0;
378    }
379    static int StretchY(LuaState* l)
380    {
381        LuaStack s(l);
382        EzMeshPtr m;
383        LuaFloat x, z, yoff(0.f, true);
384        s >> m >> x >> z >> yoff;
385        m->m_instance.StretchY(x, z, yoff);
386        return 0;
387    }
388    static int StretchZ(LuaState* l)
389    {
390        LuaStack s(l);
391        EzMeshPtr m;
392        LuaFloat x, y, zoff(0.f, true);
393        s >> m >> x >> y >> zoff;
394        m->m_instance.StretchZ(x, y, zoff);
395        return 0;
396    }
397    //-------------------------------------------------------------------------
398    static int BendXY(LuaState* l)
399    {
400        LuaStack s(l);
401        EzMeshPtr m;
402        LuaFloat t, toff(0.f, true);
403        s >> m >> t >> toff;
404        m->m_instance.BendXY(t, toff);
405        return 0;
406    }
407    static int BendXZ(LuaState* l)
408    {
409        LuaStack s(l);
410        EzMeshPtr m;
411        LuaFloat t, toff(0.f, true);
412        s >> m >> t >> toff;
413        m->m_instance.BendXZ(t, toff);
414        return 0;
415    }
416    static int BendYX(LuaState* l)
417    {
418        LuaStack s(l);
419        EzMeshPtr m;
420        LuaFloat t, toff(0.f, true);
421        s >> m >> t >> toff;
422        m->m_instance.BendYX(t, toff);
423        return 0;
424    }
425    static int BendYZ(LuaState* l)
426    {
427        LuaStack s(l);
428        EzMeshPtr m;
429        LuaFloat t, toff(0.f, true);
430        s >> m >> t >> toff;
431        m->m_instance.BendYZ(t, toff);
432        return 0;
433    }
434    static int BendZX(LuaState* l)
435    {
436        LuaStack s(l);
437        EzMeshPtr m;
438        LuaFloat t, toff(0.f, true);
439        s >> m >> t >> toff;
440        m->m_instance.BendZX(t, toff);
441        return 0;
442    }
443    static int BendZY(LuaState* l)
444    {
445        LuaStack s(l);
446        EzMeshPtr m;
447        LuaFloat t, toff(0.f, true);
448        s >> m >> t >> toff;
449        m->m_instance.BendZY(t, toff);
450        return 0;
451    }
452    //-------------------------------------------------------------------------
453    static int MirrorX(LuaState* l)
454    {
455        LuaStack s(l);
456        EzMeshPtr m;
457        s >> m;
458        m->m_instance.MirrorX();
459        return 0;
460    }
461    static int MirrorY(LuaState* l)
462    {
463        LuaStack s(l);
464        EzMeshPtr m;
465        s >> m;
466        m->m_instance.MirrorY();
467        return 0;
468    }
469    static int MirrorZ(LuaState* l)
470    {
471        LuaStack s(l);
472        EzMeshPtr m;
473        s >> m;
474        m->m_instance.MirrorZ();
475        return 0;
476    }
477    //-------------------------------------------------------------------------
478    static int LoopStart(LuaState* l)
479    {
480        LuaStack s(l);
481        EzMeshPtr m;
482        LuaInt32 loopnb;
483        s >> m >> loopnb;
484        m->m_instance.LoopStart(loopnb);
485        return 0;
486    }
487    static int LoopEnd(LuaState* l)
488    {
489        LuaStack s(l);
490        EzMeshPtr m;
491        s >> m;
492        m->m_instance.LoopEnd();
493        return 0;
494    }
495    static int OpenBrace(LuaState* l)
496    {
497        LuaStack s(l);
498        EzMeshPtr m;
499        s >> m;
500        m->m_instance.OpenBrace();
501        return 0;
502    }
503    static int CloseBrace(LuaState* l)
504    {
505        LuaStack s(l);
506        EzMeshPtr m;
507        s >> m;
508        m->m_instance.CloseBrace();
509        return 0;
510    }
511    //-------------------------------------------------------------------------
512    static int ToggleScaleWinding(LuaState* l)
513    {
514        LuaStack s(l);
515        EzMeshPtr m;
516        s >> m;
517        m->m_instance.ToggleScaleWinding();
518        return 0;
519    }
520    static int ToggleQuadWeighting(LuaState* l)
521    {
522        LuaStack s(l);
523        EzMeshPtr m;
524        s >> m;
525        m->m_instance.ToggleQuadWeighting();
526        return 0;
527    }
528    static int TogglePostBuildNormal(LuaState* l)
529    {
530        LuaStack s(l);
531        EzMeshPtr m;
532        s >> m;
533        m->m_instance.TogglePostBuildNormal();
534        return 0;
535    }
536    static int ToggleVerticeNoCleanup(LuaState* l)
537    {
538        LuaStack s(l);
539        EzMeshPtr m;
540        s >> m;
541        m->m_instance.ToggleVerticeNoCleanup();
542        return 0;
543    }
544    //-------------------------------------------------------------------------
545    static int VerticesMerge(LuaState* l)
546    {
547        LuaStack s(l);
548        EzMeshPtr m;
549        s >> m;
550        m->m_instance.VerticesMerge();
551        return 0;
552    }
553    static int VerticesSeparate(LuaState* l)
554    {
555        LuaStack s(l);
556        EzMeshPtr m;
557        s >> m;
558        m->m_instance.VerticesSeparate();
559        return 0;
560    }
561    //-------------------------------------------------------------------------
562    static int Duplicate(LuaState* l)
563    {
564        LuaStack s(l);
565        EzMeshPtr m;
566        LuaVec3 ds(vec3(1.f));
567        s >> m >> ds;
568        m->m_instance.DupAndScale(ds, true);
569        return 0;
570    }
571    static int Smooth(LuaState* l)
572    {
573        LuaStack s(l);
574        EzMeshPtr m;
575        LuaInt32 pass, split_per_pass, smooth_per_pass;
576        s >> m >> pass >> split_per_pass >> smooth_per_pass;
577        m->m_instance.SmoothMesh(pass, split_per_pass, smooth_per_pass);
578        return 0;
579    }
580    static int SplitTriangles(LuaState* l)
581    {
582        LuaStack s(l);
583        EzMeshPtr m;
584        LuaInt32 pass;
585        s >> m >> pass;
586        m->m_instance.SplitTriangles(pass);
587        return 0;
588    }
589    static int Chamfer(LuaState* l)
590    {
591        LuaStack s(l);
592        EzMeshPtr m;
593        LuaFloat f;
594        s >> m >> f;
595        m->m_instance.Chamfer(f);
596        return 0;
597    }
598    //-------------------------------------------------------------------------
599    static int SetCurColor(LuaState* l)
600    {
601        LuaStack s(l);
602        EzMeshPtr m;
603        s >> m;
604        LuaVec4 c;
605        if (s.GetArgs() == 1 && !c.IsValid(l, 2))
606        {
607            LuaString str;
608            s >> str;
609            c = Color::C8BppHexString(str);
610        }
611        m->m_instance.SetCurColor(c);
612        return 0;
613    }
614    static int SetCurColorA(LuaState* l)
615    {
616        LuaStack s(l);
617        EzMeshPtr m;
618        s >> m;
619        LuaVec4 c;
620        if (s.GetArgs() == 1 && !c.IsValid(l, 2))
621        {
622            LuaString str;
623            s >> str;
624            c = Color::C8BppHexString(str);
625        }
626        m->m_instance.SetCurColorA(c);
627        return 0;
628    }
629    static int SetCurColorB(LuaState* l)
630    {
631        LuaStack s(l);
632        EzMeshPtr m;
633        s >> m;
634        LuaVec4 c;
635        if (s.GetArgs() == 1 && !c.IsValid(l, 2))
636        {
637            LuaString str;
638            s >> str;
639            c = Color::C8BppHexString(str);
640        }
641        m->m_instance.SetCurColorB(c);
642        return 0;
643    }
644    static int SetVertColor(LuaState* l)
645    {
646        LuaStack s(l);
647        EzMeshPtr m;
648        s >> m;
649        LuaVec4 c;
650        if (s.GetArgs() == 1 && !c.IsValid(l, 2))
651        {
652            LuaString str;
653            s >> str;
654            c = Color::C8BppHexString(str);
655        }
656        m->m_instance.SetVertColor(c);
657        return 0;
658    }
659    /*
660    (csgu|csgunion)          { return token::T_CSGUNION; }
661    (csgs|CsgSub)            { return token::T_CSGSUBSTRACT; }
662    (csgsl|CsgSubL)          { return token::T_CSGSUBSTRACTLOSS; }
663    (csga|csgand)            { return token::T_CSGAND; }
664    (csgx|csgxor)            { return token::T_CSGXOR; }
665    */
666
667};
668
669} /* namespace lol */
Note: See TracBrowser for help on using the repository browser.