lolengine
/
lol
mirror of https://github.com/lolengine/lol
1
0
Fork 0
Code Issues 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2510 Commits
5 Branches
384 MiB
 
 
 
Tree: 8222295f3b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8222295f3b'
${ noResults }
lol/src/easymesh/easymeshlua.h

670 lines
17 KiB
Raw Blame History 

  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. 

  15. namespace lol

  16. {

  17. 

  18. //-----------------------------------------------------------------------------

  19. class EasyMeshLuaLoader : public LuaLoader

  20. {

  21. public:

  22.     EasyMeshLuaLoader();

  23.     virtual ~EasyMeshLuaLoader();

  24. };

  25.     

  26. //-----------------------------------------------------------------------------

  27. class EasyMeshLuaObject : public LuaObjectDef

  28. {

  29.     typedef Lolua::VarPtr<EasyMeshLuaObject> EzMeshPtr;

  30.     EasyMesh m_instance;

  31. public:

  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 */