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.
2749 Commits
5 Branches
329 MiB
 
 
 
Tree: 4d78d62a70
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4d78d62a70'
${ noResults }
lol/src/easymesh/easymeshlua.h

668 lines
17 KiB
Raw Blame History 

  1. //

  2. //  Lol Engine — EasyMesh Lua loader

  3. //

  4. //  Copyright © 2009—2015 Benjamin “Touky” Huet <huet.benjamin@gmail.com>

  5. //

  6. //  Lol Engine 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 EasyMeshLuaObject : public LuaObject

  20. {

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

  22.     EasyMesh m_instance;

  23. public:

  24.     //-------------------------------------------------------------------------

  25.     EasyMeshLuaObject(String const& name);

  26.     virtual ~EasyMeshLuaObject();

  27.     EasyMesh& GetMesh() { return m_instance; }

  28. 

  29.     //-------------------------------------------------------------------------

  30.     static EasyMeshLuaObject* New(lua_State* l, int arg_nb);

  31.     static const LuaObjectLibrary* GetLib();

  32. 

  33.     //-------------------------------------------------------------------------

  34.     static int AppendCylinder(lua_State* l)

  35.     {

  36.         LuaStack s(l);

  37.         EzMeshPtr m;

  38.         LuaInt32 nsides;

  39.         LuaFloat h, d1, d2;

  40.         LuaBool dualside(false, true), smooth(false, true), close(false, true);

  41.         s >> m >> nsides >> h >> d1 >> d2 >> dualside >> smooth >> close;

  42.         m->m_instance.AppendCylinder(nsides, h, d1, d2, dualside, smooth, close);

  43.         return 0;

  44.     }

  45.     static int AppendSphere(lua_State* l)

  46.     {

  47.         LuaStack s(l);

  48.         EzMeshPtr m;

  49.         LuaInt32 ndivisions;

  50.         LuaFloat d;

  51.         s >> m >> ndivisions >> d;

  52.         m->m_instance.AppendSphere(ndivisions, d);

  53.         return 0;

  54.     }

  55.     static int AppendCapsule(lua_State* l)

  56.     {

  57.         LuaStack s(l);

  58.         EzMeshPtr m;

  59.         LuaInt32 ndivisions;

  60.         LuaFloat h, d;

  61.         s >> m >> ndivisions >> h >> d;

  62.         m->m_instance.AppendCapsule(ndivisions, h, d);

  63.         return 0;

  64.     }

  65.     static int AppendTorus(lua_State* l)

  66.     {

  67.         LuaStack s(l);

  68.         EzMeshPtr m;

  69.         LuaInt32 ndivisions;

  70.         LuaFloat d1, d2;

  71.         s >> m >> ndivisions >> d1 >> d2;

  72.         m->m_instance.AppendTorus(ndivisions, d1, d2);

  73.         return 0;

  74.     }

  75.     static int AppendBox(lua_State* l)

  76.     {

  77.         LuaStack s(l);

  78.         EzMeshPtr m;

  79.         LuaVec3 size;

  80.         LuaFloat chamf(0.f, true);

  81.         LuaBool smooth(false, true);

  82.         s >> m >> size >> chamf >> smooth;

  83.         m->m_instance.AppendBox(size, chamf, smooth);

  84.         return 0;

  85.     }

  86.     static int AppendStar(lua_State* l)

  87.     {

  88.         LuaStack s(l);

  89.         EzMeshPtr m;

  90.         LuaInt32 nbranches;

  91.         LuaFloat d1, d2;

  92.         LuaBool fade(false, true), fade2(false, true);

  93.         s >> m >> nbranches >> d1 >> d2 >> fade >> fade2;

  94.         m->m_instance.AppendStar(nbranches, d1, d2, fade, fade2);

  95.         return 0;

  96.     }

  97.     static int AppendExpandedStar(lua_State* l)

  98.     {

  99.         LuaStack s(l);

  100.         EzMeshPtr m;

  101.         LuaInt32 nbranches;

  102.         LuaFloat d1, d2, extrad(0.f, true);

  103.         s >> m >> nbranches >> d1 >> d2 >> extrad;

  104.         m->m_instance.AppendExpandedStar(nbranches, d1, d2, extrad);

  105.         return 0;

  106.     }

  107.     static int AppendDisc(lua_State* l)

  108.     {

  109.         LuaStack s(l);

  110.         EzMeshPtr m;

  111.         LuaInt32 nsides;

  112.         LuaFloat d;

  113.         LuaBool fade(false, true);

  114.         s >> m >> nsides >> d >> fade;

  115.         m->m_instance.AppendDisc(nsides, d, fade);

  116.         return 0;

  117.     }

  118.     static int AppendSimpleTriangle(lua_State* l)

  119.     {

  120.         LuaStack s(l);

  121.         EzMeshPtr m;

  122.         LuaFloat d;

  123.         LuaBool fade(false, true);

  124.         s >> m >> d >> fade;

  125.         m->m_instance.AppendSimpleTriangle(d, fade);

  126.         return 0;

  127.     }

  128.     static int AppendSimpleQuad(lua_State* l)

  129.     {

  130.         LuaStack s(l);

  131.         EzMeshPtr m;

  132.         LuaFloat size;

  133.         LuaBool fade(false, true);

  134.         s >> m >> size >> fade;

  135.         m->m_instance.AppendSimpleQuad(size, fade);

  136.         return 0;

  137.     }

  138.     static int AppendCog(lua_State* l)

  139.     {

  140.         LuaStack s(l);

  141.         EzMeshPtr m;

  142.         LuaInt32 nbsides;

  143.         LuaFloat h, sidemul(0.f, true);

  144.         LuaVec2 d0, d1, d2;

  145.         LuaBool offset(false, true);

  146.         s >> m >> nbsides >> h >> d0 >> d1 >> d2 >> sidemul >> offset;

  147.         m->m_instance.AppendCog(nbsides, h, d0().x, d0().y, d1().x, d1().y, d2().x, d2().y, sidemul, offset);

  148.         return 0;

  149.     }

  150.     //-------------------------------------------------------------------------

  151.     static int TranslateX(lua_State* l)

  152.     {

  153.         LuaStack s(l);

  154.         EzMeshPtr m;

  155.         LuaFloat f;

  156.         s >> m >> f;

  157.         m->m_instance.TranslateX(f);

  158.         return 0;

  159.     }

  160.     static int TranslateY(lua_State* l)

  161.     {

  162.         LuaStack s(l);

  163.         EzMeshPtr m;

  164.         LuaFloat f;

  165.         s >> m >> f;

  166.         m->m_instance.TranslateY(f);

  167.         return 0;

  168.     }

  169.     static int TranslateZ(lua_State* l)

  170.     {

  171.         LuaStack s(l);

  172.         EzMeshPtr m;

  173.         LuaFloat f;

  174.         s >> m >> f;

  175.         m->m_instance.TranslateZ(f);

  176.         return 0;

  177.     }

  178.     static int Translate(lua_State* l)

  179.     {

  180.         LuaStack s(l);

  181.         EzMeshPtr m;

  182.         LuaVec3 v;

  183.         s >> m >> v;

  184.         m->m_instance.Translate(v);

  185.         return 0;

  186.     }

  187.     //-------------------------------------------------------------------------

  188.     static int RotateX(lua_State* l)

  189.     {

  190.         LuaStack s(l);

  191.         EzMeshPtr m;

  192.         LuaFloat a;

  193.         s >> m >> a;

  194.         m->m_instance.RotateX(a);

  195.         return 0;

  196.     }

  197.     static int RotateY(lua_State* l)

  198.     {

  199.         LuaStack s(l);

  200.         EzMeshPtr m;

  201.         LuaFloat a;

  202.         s >> m >> a;

  203.         m->m_instance.RotateY(a);

  204.         return 0;

  205.     }

  206.     static int RotateZ(lua_State* l)

  207.     {

  208.         LuaStack s(l);

  209.         EzMeshPtr m;

  210.         LuaFloat a;

  211.         s >> m >> a;

  212.         m->m_instance.RotateZ(a);

  213.         return 0;

  214.     }

  215.     static int Rotate(lua_State* l)

  216.     {

  217.         LuaStack s(l);

  218.         EzMeshPtr m;

  219.         LuaFloat a;

  220.         LuaVec3 v;

  221.         s >> m >> a >> v;

  222.         m->m_instance.Rotate(a, v);

  223.         return 0;

  224.     }

  225.     //-------------------------------------------------------------------------

  226.     static int ScaleX(lua_State* l)

  227.     {

  228.         LuaStack s(l);

  229.         EzMeshPtr m;

  230.         LuaFloat x;

  231.         s >> m >> x;

  232.         m->m_instance.ScaleX(x);

  233.         return 0;

  234.     }

  235.     static int ScaleY(lua_State* l)

  236.     {

  237.         LuaStack s(l);

  238.         EzMeshPtr m;

  239.         LuaFloat y;

  240.         s >> m >> y;

  241.         m->m_instance.ScaleY(y);

  242.         return 0;

  243.     }

  244.     static int ScaleZ(lua_State* l)

  245.     {

  246.         LuaStack s(l);

  247.         EzMeshPtr m;

  248.         LuaFloat z;

  249.         s >> m >> z;

  250.         m->m_instance.ScaleZ(z);

  251.         return 0;

  252.     }

  253.     static int Scale(lua_State* l)

  254.     {

  255.         LuaStack s(l);

  256.         EzMeshPtr m;

  257.         LuaVec3 v;

  258.         s >> m >> v;

  259.         m->m_instance.Scale(v);

  260.         return 0;

  261.     }

  262.     //-------------------------------------------------------------------------

  263.     static int RadialJitter(lua_State* l)

  264.     {

  265.         LuaStack s(l);

  266.         EzMeshPtr m;

  267.         LuaFloat f;

  268.         s >> m >> f;

  269.         m->m_instance.RadialJitter(f);

  270.         return 0;

  271.     }

  272.     //-------------------------------------------------------------------------

  273.     static int TaperX(lua_State* l)

  274.     {

  275.         LuaStack s(l);

  276.         EzMeshPtr m;

  277.         LuaFloat y, z, xoff(0.f, true);

  278.         LuaBool abs(true, true);

  279.         s >> m >> y >> z >> xoff >> abs;

  280.         m->m_instance.TaperX(y, z, xoff, abs);

  281.         return 0;

  282.     }

  283.     static int TaperY(lua_State* l)

  284.     {

  285.         LuaStack s(l);

  286.         EzMeshPtr m;

  287.         LuaFloat x, z, yoff(0.f, true);

  288.         LuaBool abs(true, true);

  289.         s >> m >> x >> z >> yoff >> abs;

  290.         m->m_instance.TaperY(x, z, yoff, abs);

  291.         return 0;

  292.     }

  293.     static int TaperZ(lua_State* l)

  294.     {

  295.         LuaStack s(l);

  296.         EzMeshPtr m;

  297.         LuaFloat x, y, zoff(0.f, true);

  298.         LuaBool abs(true, true);

  299.         s >> m >> x >> y >> zoff >> abs;

  300.         m->m_instance.TaperZ(x, y, zoff, abs);

  301.         return 0;

  302.     }

  303.     //-------------------------------------------------------------------------

  304.     static int TwistX(lua_State* l)

  305.     {

  306.         LuaStack s(l);

  307.         EzMeshPtr m;

  308.         LuaFloat t, toff(0.f, true);

  309.         s >> m >> t >> toff;

  310.         m->m_instance.TwistX(t, toff);

  311.         return 0;

  312.     }

  313.     static int TwistY(lua_State* l)

  314.     {

  315.         LuaStack s(l);

  316.         EzMeshPtr m;

  317.         LuaFloat t, toff(0.f, true);

  318.         s >> m >> t >> toff;

  319.         m->m_instance.TwistY(t, toff);

  320.         return 0;

  321.     }

  322.     static int TwistZ(lua_State* l)

  323.     {

  324.         LuaStack s(l);

  325.         EzMeshPtr m;

  326.         LuaFloat t, toff(0.f, true);

  327.         s >> m >> t >> toff;

  328.         m->m_instance.TwistZ(t, toff);

  329.         return 0;

  330.     }

  331.     //-------------------------------------------------------------------------

  332.     static int ShearX(lua_State* l)

  333.     {

  334.         LuaStack s(l);

  335.         EzMeshPtr m;

  336.         LuaFloat y, z, xoff(0.f, true);

  337.         LuaBool abs(true, true);

  338.         s >> m >> y >> z >> xoff >> abs;

  339.         m->m_instance.ShearX(y, z, xoff, abs);

  340.         return 0;

  341.     }

  342.     static int ShearY(lua_State* l)

  343.     {

  344.         LuaStack s(l);

  345.         EzMeshPtr m;

  346.         LuaFloat x, z, yoff(0.f, true);

  347.         LuaBool abs(true, true);

  348.         s >> m >> x >> z >> yoff >> abs;

  349.         m->m_instance.ShearY(x, z, yoff, abs);

  350.         return 0;

  351.     }

  352.     static int ShearZ(lua_State* l)

  353.     {

  354.         LuaStack s(l);

  355.         EzMeshPtr m;

  356.         LuaFloat x, y, zoff(0.f, true);

  357.         LuaBool abs(true, true);

  358.         s >> m >> x >> y >> zoff >> abs;

  359.         m->m_instance.ShearZ(x, y, zoff, abs);

  360.         return 0;

  361.     }

  362.     //-------------------------------------------------------------------------

  363.     static int StretchX(lua_State* l)

  364.     {

  365.         LuaStack s(l);

  366.         EzMeshPtr m;

  367.         LuaFloat y, z, xoff(0.f, true);

  368.         s >> m >> y >> z >> xoff;

  369.         m->m_instance.StretchX(y, z, xoff);

  370.         return 0;

  371.     }

  372.     static int StretchY(lua_State* l)

  373.     {

  374.         LuaStack s(l);

  375.         EzMeshPtr m;

  376.         LuaFloat x, z, yoff(0.f, true);

  377.         s >> m >> x >> z >> yoff;

  378.         m->m_instance.StretchY(x, z, yoff);

  379.         return 0;

  380.     }

  381.     static int StretchZ(lua_State* l)

  382.     {

  383.         LuaStack s(l);

  384.         EzMeshPtr m;

  385.         LuaFloat x, y, zoff(0.f, true);

  386.         s >> m >> x >> y >> zoff;

  387.         m->m_instance.StretchZ(x, y, zoff);

  388.         return 0;

  389.     }

  390.     //-------------------------------------------------------------------------

  391.     static int BendXY(lua_State* l)

  392.     {

  393.         LuaStack s(l);

  394.         EzMeshPtr m;

  395.         LuaFloat t, toff(0.f, true);

  396.         s >> m >> t >> toff;

  397.         m->m_instance.BendXY(t, toff);

  398.         return 0;

  399.     }

  400.     static int BendXZ(lua_State* l)

  401.     {

  402.         LuaStack s(l);

  403.         EzMeshPtr m;

  404.         LuaFloat t, toff(0.f, true);

  405.         s >> m >> t >> toff;

  406.         m->m_instance.BendXZ(t, toff);

  407.         return 0;

  408.     }

  409.     static int BendYX(lua_State* l)

  410.     {

  411.         LuaStack s(l);

  412.         EzMeshPtr m;

  413.         LuaFloat t, toff(0.f, true);

  414.         s >> m >> t >> toff;

  415.         m->m_instance.BendYX(t, toff);

  416.         return 0;

  417.     }

  418.     static int BendYZ(lua_State* l)

  419.     {

  420.         LuaStack s(l);

  421.         EzMeshPtr m;

  422.         LuaFloat t, toff(0.f, true);

  423.         s >> m >> t >> toff;

  424.         m->m_instance.BendYZ(t, toff);

  425.         return 0;

  426.     }

  427.     static int BendZX(lua_State* l)

  428.     {

  429.         LuaStack s(l);

  430.         EzMeshPtr m;

  431.         LuaFloat t, toff(0.f, true);

  432.         s >> m >> t >> toff;

  433.         m->m_instance.BendZX(t, toff);

  434.         return 0;

  435.     }

  436.     static int BendZY(lua_State* l)

  437.     {

  438.         LuaStack s(l);

  439.         EzMeshPtr m;

  440.         LuaFloat t, toff(0.f, true);

  441.         s >> m >> t >> toff;

  442.         m->m_instance.BendZY(t, toff);

  443.         return 0;

  444.     }

  445.     //-------------------------------------------------------------------------

  446.     static int MirrorX(lua_State* l)

  447.     {

  448.         LuaStack s(l);

  449.         EzMeshPtr m;

  450.         s >> m;

  451.         m->m_instance.MirrorX();

  452.         return 0;

  453.     }

  454.     static int MirrorY(lua_State* l)

  455.     {

  456.         LuaStack s(l);

  457.         EzMeshPtr m;

  458.         s >> m;

  459.         m->m_instance.MirrorY();

  460.         return 0;

  461.     }

  462.     static int MirrorZ(lua_State* l)

  463.     {

  464.         LuaStack s(l);

  465.         EzMeshPtr m;

  466.         s >> m;

  467.         m->m_instance.MirrorZ();

  468.         return 0;

  469.     }

  470.     //-------------------------------------------------------------------------

  471.     static int LoopStart(lua_State* l)

  472.     {

  473.         LuaStack s(l);

  474.         EzMeshPtr m;

  475.         LuaInt32 loopnb;

  476.         s >> m >> loopnb;

  477.         m->m_instance.LoopStart(loopnb);

  478.         return 0;

  479.     }

  480.     static int LoopEnd(lua_State* l)

  481.     {

  482.         LuaStack s(l);

  483.         EzMeshPtr m;

  484.         s >> m;

  485.         m->m_instance.LoopEnd();

  486.         return 0;

  487.     }

  488.     static int OpenBrace(lua_State* l)

  489.     {

  490.         LuaStack s(l);

  491.         EzMeshPtr m;

  492.         s >> m;

  493.         m->m_instance.OpenBrace();

  494.         return 0;

  495.     }

  496.     static int CloseBrace(lua_State* l)

  497.     {

  498.         LuaStack s(l);

  499.         EzMeshPtr m;

  500.         s >> m;

  501.         m->m_instance.CloseBrace();

  502.         return 0;

  503.     }

  504.     //-------------------------------------------------------------------------

  505.     static int ToggleScaleWinding(lua_State* l)

  506.     {

  507.         LuaStack s(l);

  508.         EzMeshPtr m;

  509.         s >> m;

  510.         m->m_instance.ToggleScaleWinding();

  511.         return 0;

  512.     }

  513.     static int ToggleQuadWeighting(lua_State* l)

  514.     {

  515.         LuaStack s(l);

  516.         EzMeshPtr m;

  517.         s >> m;

  518.         m->m_instance.ToggleQuadWeighting();

  519.         return 0;

  520.     }

  521.     static int TogglePostBuildNormal(lua_State* l)

  522.     {

  523.         LuaStack s(l);

  524.         EzMeshPtr m;

  525.         s >> m;

  526.         m->m_instance.TogglePostBuildNormal();

  527.         return 0;

  528.     }

  529.     static int ToggleVerticeNoCleanup(lua_State* l)

  530.     {

  531.         LuaStack s(l);

  532.         EzMeshPtr m;

  533.         s >> m;

  534.         m->m_instance.ToggleVerticeNoCleanup();

  535.         return 0;

  536.     }

  537.     //-------------------------------------------------------------------------

  538.     static int VerticesMerge(lua_State* l)

  539.     {

  540.         LuaStack s(l);

  541.         EzMeshPtr m;

  542.         s >> m;

  543.         m->m_instance.VerticesMerge();

  544.         return 0;

  545.     }

  546.     static int VerticesSeparate(lua_State* l)

  547.     {

  548.         LuaStack s(l);

  549.         EzMeshPtr m;

  550.         s >> m;

  551.         m->m_instance.VerticesSeparate();

  552.         return 0;

  553.     }

  554.     static int VerticesCleanup(lua_State* l)

  555.     {

  556.         LuaStack s(l);

  557.         EzMeshPtr m;

  558.         s >> m;

  559.         m->m_instance.VerticesCleanup();

  560.         return 0;

  561.     }

  562.     //-------------------------------------------------------------------------

  563.     static int Duplicate(lua_State* l)

  564.     {

  565.         LuaStack s(l);

  566.         EzMeshPtr m;

  567.         LuaVec3 ds(vec3(1.f));

  568.         s >> m >> ds;

  569.         m->m_instance.DupAndScale(ds, true);

  570.         return 0;

  571.     }

  572.     static int Smooth(lua_State* l)

  573.     {

  574.         LuaStack s(l);

  575.         EzMeshPtr m;

  576.         LuaInt32 pass, split_per_pass, smooth_per_pass;

  577.         s >> m >> pass >> split_per_pass >> smooth_per_pass;

  578.         m->m_instance.SmoothMesh(pass, split_per_pass, smooth_per_pass);

  579.         return 0;

  580.     }

  581.     static int SplitTriangles(lua_State* l)

  582.     {

  583.         LuaStack s(l);

  584.         EzMeshPtr m;

  585.         LuaInt32 pass;

  586.         s >> m >> pass;

  587.         m->m_instance.SplitTriangles(pass);

  588.         return 0;

  589.     }

  590.     static int Chamfer(lua_State* l)

  591.     {

  592.         LuaStack s(l);

  593.         EzMeshPtr m;

  594.         LuaFloat f;

  595.         s >> m >> f;

  596.         m->m_instance.Chamfer(f);

  597.         return 0;

  598.     }

  599.     //-------------------------------------------------------------------------

  600.     static int SetCurColor(lua_State* l)

  601.     {

  602.         LuaStack s(l);

  603.         EzMeshPtr m;

  604.         LuaColor c;

  605.         s >> m >> c;

  606.         m->m_instance.SetCurColor(c);

  607.         return 0;

  608.     }

  609.     static int SetCurColorA(lua_State* l)

  610.     {

  611.         LuaStack s(l);

  612.         EzMeshPtr m;

  613.         LuaColor c;

  614.         s >> m >> c;

  615.         m->m_instance.SetCurColorA(c);

  616.         return 0;

  617.     }

  618.     static int SetCurColorB(lua_State* l)

  619.     {

  620.         LuaStack s(l);

  621.         EzMeshPtr m;

  622.         LuaColor c;

  623.         m->m_instance.SetCurColorB(c);

  624.         return 0;

  625.     }

  626.     static int SetVertColor(lua_State* l)

  627.     {

  628.         LuaStack s(l);

  629.         EzMeshPtr m;

  630.         LuaColor c;

  631.         s >> m >> c;

  632.         m->m_instance.SetVertColor(c);

  633.         return 0;

  634.     }

  635.     /*

  636.     (csgu|csgunion)          { return token::T_CSGUNION; }

  637.     (csgs|CsgSub)            { return token::T_CSGSUBSTRACT; }

  638.     (csgsl|CsgSubL)          { return token::T_CSGSUBSTRACTLOSS; }

  639.     (csga|csgand)            { return token::T_CSGAND; }

  640.     (csgx|csgxor)            { return token::T_CSGXOR; }

  641.     */

  642. 

  643. };

  644. 

  645. //-----------------------------------------------------------------------------

  646. class EasyMeshLuaLoader : public LuaLoader

  647. {

  648.     friend class EasyMeshLuaObject;

  649. 

  650. public:

  651.     EasyMeshLuaLoader();

  652.     virtual ~EasyMeshLuaLoader();

  653.     //Virtual Store lua object ------------------------------------------------

  654.     virtual void Store(LuaObject* obj);

  655.     array<EasyMeshLuaObject*>& GetInstances();

  656. 

  657.     //-------------------------------------------------------------------------

  658. protected:

  659.     static void RegisterMesh(EasyMeshLuaObject* mesh, String const& name);

  660. public:

  661.     static bool GetRegisteredMeshes(map<String, EasyMeshLuaObject*>& meshes);

  662. 

  663. private:

  664.     static map<String, EasyMeshLuaObject*> m_meshes;

  665. };

  666. 

  667. } /* namespace lol */