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

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

Easymesh test tuto works with lua, but EzMesh seems broken.

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