lolengine
/
lol
kopia lustrzana https://github.com/lolengine/lol
1
0
Forkuj 0
Kod Zgłoszenia 0 Wydania 0 Wiki Aktywność
2095 Commity
5 Gałęzie
18 MiB
 
 
 
Drzewo: 44dec8612e
lol/src/easymesh/easymeshbuild.h

414 wiersze
14 KiB
Czysty Wina Historia 

  1. //

  2. // Lol Engine

  3. //

  4. // Copyright: (c) 2009-2013 Benjamin "Touky" Huet <huet.benjamin@gmail.com>

  5. //            (c) 2010-2014 Sam Hocevar <sam@hocevar.net>

  6. //            (c) 2009-2013 Cédric Lecacheur <jordx@free.fr>

  7. //   This program is free software; you can redistribute it and/or

  8. //   modify it under the terms of the Do What The Fuck You Want To

  9. //   Public License, Version 2, as published by Sam Hocevar. See

  10. //   http://www.wtfpl.net/ for more details.

  11. //

  12. 

  13. //

  14. // The EasyMesh class

  15. // ------------------

  16. //

  17. 

  18. #if !defined __EASYMESHBUILD_EASYMESHBUILD_H__

  19. #define __EASYMESHBUILD_EASYMESHBUILD_H__

  20. 

  21. namespace lol

  22. {

  23. 

  24. struct MeshBuildOperation

  25. {

  26.     DEF_VALUE

  27.         //When this flag is up, negative scaling will not invert faces.

  28.         ADD_VALUE_SET(ScaleWinding                , (1 << 0))

  29.         ADD_VALUE_SET(CommandRecording            , (1 << 1))

  30.         ADD_VALUE_SET(CommandExecution            , (1 << 2))

  31.         ADD_VALUE_SET(QuadWeighting               , (1 << 3))

  32.         ADD_VALUE_SET(IgnoreQuadWeighting         , (1 << 4))

  33.         ADD_VALUE_SET(PostBuildComputeNormals     , (1 << 5))

  34.         ADD_VALUE_SET(PreventVertCleanup          , (1 << 6))

  35. 

  36.         ADD_VALUE_SET(All                         , 0xffff)

  37.     END_E_VALUE

  38. 

  39.     LOL_DECLARE_ENUM_METHODS(MeshBuildOperation)

  40. };

  41. 

  42. struct EasyMeshCmdType

  43. {

  44.     DEF_VALUE

  45.         ADD_VALUE(MeshCsg)

  46. 

  47.         ADD_VALUE(LoopStart)

  48.         ADD_VALUE(LoopEnd)

  49.         ADD_VALUE(OpenBrace)

  50.         ADD_VALUE(CloseBrace)

  51. 

  52.         ADD_VALUE(ScaleWinding)

  53.         ADD_VALUE(QuadWeighting)

  54.         ADD_VALUE(PostBuildNormal)

  55.         ADD_VALUE(PreventVertCleanup)

  56.         ADD_VALUE(SetColorA)

  57.         ADD_VALUE(SetColorB)

  58.         ADD_VALUE(SetVertColor)

  59. 

  60.         ADD_VALUE(VerticesMerge)

  61.         ADD_VALUE(VerticesSeparate)

  62. 

  63.         ADD_VALUE(Translate)

  64.         ADD_VALUE(Rotate)

  65.         ADD_VALUE(RadialJitter)

  66.         ADD_VALUE(MeshTranform)

  67.         ADD_VALUE(Scale)

  68.         ADD_VALUE(DupAndScale)

  69.         ADD_VALUE(Chamfer)

  70. 

  71.         ADD_VALUE(SplitTriangles)

  72.         ADD_VALUE(SmoothMesh)

  73. 

  74.         ADD_VALUE(AppendCylinder)

  75.         ADD_VALUE(AppendCapsule)

  76.         ADD_VALUE(AppendTorus)

  77.         ADD_VALUE(AppendBox)

  78.         ADD_VALUE(AppendStar)

  79.         ADD_VALUE(AppendExpandedStar)

  80.         ADD_VALUE(AppendDisc)

  81.         ADD_VALUE(AppendSimpleTriangle)

  82.         ADD_VALUE(AppendSimpleQuad)

  83.         ADD_VALUE(AppendCog)

  84.     END_E_VALUE

  85. 

  86.     LOL_DECLARE_ENUM_METHODS(EasyMeshCmdType)

  87. };

  88. 

  89. LOL_SAFE_ENUM(MeshType,

  90.     Triangle,

  91.     Quad,

  92.     Box,

  93.     Sphere,

  94.     Capsule,

  95.     Torus,

  96.     Cylinder,

  97.     Disc,

  98.     Star,

  99.     ExpandedStar,

  100.     Cog,

  101. 

  102.     MAX

  103. );

  104. 

  105. struct TexCoordBuildType

  106. {

  107.     DEF_VALUE

  108.         ADD_VALUE_SET(TriangleDefault     , 0)

  109.         ADD_VALUE_SET(QuadDefault         , 0)

  110.         ADD_VALUE_SET(BoxDefault          , 0)

  111.         ADD_VALUE_SET(SphereDefault       , 0)

  112.         ADD_VALUE_SET(CapsuleDefault      , 0)

  113.         ADD_VALUE_SET(TorusDefault        , 0)

  114.         ADD_VALUE_SET(CylinderDefault     , 0)

  115.         ADD_VALUE_SET(DiscDefault         , 0)

  116.         ADD_VALUE_SET(StarDefault         , 0)

  117.         ADD_VALUE_SET(ExpandedStarDefault , 0)

  118.         ADD_VALUE_SET(CogDefault          , 0)

  119. 

  120.         //NEVER FORGET TO INCREMENT THIS WHEN ADDING A VALUE

  121.         ADD_VALUE_SET(Max                 , 1)

  122.     END_E_VALUE

  123. 

  124.     LOL_DECLARE_ENUM_METHODS(TexCoordBuildType)

  125. };

  126. 

  127. LOL_SAFE_ENUM(MeshFaceType,

  128.     BoxFront    = 0,

  129.     QuadDefault = 0,

  130.     BoxLeft     = 1,

  131.     BoxBack     = 2,

  132.     BoxRight    = 3,

  133.     BoxTop      = 4,

  134.     BoxBottom   = 5,

  135. 

  136.     Max

  137. );

  138. 

  139. LOL_SAFE_ENUM(TexCoordPos,

  140.     BL, // Bottom Left

  141.     BR, // Bottom Right

  142.     TL, // Top Left

  143.     TR  // Top Right

  144. );

  145. 

  146. class EasyMeshBuildData

  147. {

  148. public:

  149.     EasyMeshBuildData()

  150.     {

  151.         m_color_a = vec4(0.f, 0.f, 0.f, 1.f);

  152.         m_color_b = vec4(0.f, 0.f, 0.f, 1.f);

  153.         m_texcoord_offset = vec2(0.f);

  154.         m_texcoord_offset2 = vec2(0.f);

  155.         m_texcoord_scale = vec2(1.f);

  156.         m_texcoord_scale2 = vec2(1.f);

  157.         m_build_flags = 0;

  158.         m_i_cmd = 0;

  159.         m_exec_nb = -1;

  160.         for (int i = 0; i < MeshType::MAX; ++i)

  161.         {

  162.             m_texcoord_build_type[i] = TexCoordBuildType::TriangleDefault;

  163.             m_texcoord_build_type2[i] = TexCoordBuildType::TriangleDefault;

  164.         }

  165.     }

  166. 

  167.     inline CommandStack &CmdStack() { return m_stack; }

  168.     inline int &Cmdi()              { return m_i_cmd; }

  169.     inline int &CmdExecNb()         { return m_exec_nb; }

  170.     inline Array<int, int> &LoopStack(){ return m_loop_stack; }

  171.     inline vec4 &ColorA()           { return m_color_a; }

  172.     inline vec4 &ColorB()           { return m_color_b; }

  173.     inline vec2 &TexCoordOffset()   { return m_texcoord_offset; }

  174.     inline vec2 &TexCoordScale()    { return m_texcoord_scale; }

  175.     inline vec2 &TexCoordOffset2()  { return m_texcoord_offset2; }

  176.     inline vec2 &TexCoordScale2()   { return m_texcoord_scale2; }

  177. 

  178.     //UV1

  179.     void SetTexCoordBuildType(MeshType mt, TexCoordBuildType tcbt) { m_texcoord_build_type[mt.ToScalar()] = (1 << (tcbt + 1)) | (m_texcoord_build_type[mt.ToScalar()] & 1); }

  180.     TexCoordBuildType GetTexCoordBuildType(MeshType mt)

  181.     {

  182.         uint32_t flag = (uint32_t)((m_texcoord_build_type[mt.ToScalar()] & ~(1)) >> 1);

  183.         int i = 0;

  184.         while (flag >>= 1)

  185.             i++;

  186.         return TexCoordBuildType(i);

  187.     }

  188.     void SetTexCoordCustomBuild(MeshType mt, MeshFaceType face, vec2 BL, vec2 TR)

  189.     {

  190.         if (face.ToScalar() >= m_texcoord_custom_build[mt.ToScalar()].Count())

  191.             m_texcoord_custom_build[mt.ToScalar()].Resize(face.ToScalar() + 1);

  192.         m_texcoord_custom_build[mt.ToScalar()][face.ToScalar()].m1 = BL;

  193.         m_texcoord_custom_build[mt.ToScalar()][face.ToScalar()].m2 = TR;

  194.         m_texcoord_build_type[mt.ToScalar()] |= 1;

  195.     }

  196.     void ClearTexCoordCustomBuild(MeshType mt) { m_texcoord_build_type[mt.ToScalar()] &= ~1; }

  197.     /* FIXME : Do something better ? */

  198.     vec2 TexCoord(MeshType mt, TexCoordPos tcp, MeshFaceType face)

  199.     {

  200.         vec2 BL = vec2(0.f);

  201.         vec2 TR = vec2(0.f);

  202.         if (m_texcoord_build_type[mt.ToScalar()] & 1

  203.              && face.ToScalar() < m_texcoord_custom_build[mt.ToScalar()].Count())

  204.         {

  205.             BL = m_texcoord_custom_build[mt.ToScalar()][face.ToScalar()].m1;

  206.             TR = m_texcoord_custom_build[mt.ToScalar()][face.ToScalar()].m2;

  207.         }

  208.         else

  209.         {

  210.             /* unused for now, but will be if new BuildType are added. */

  211.             TexCoordBuildType tcbt = GetTexCoordBuildType(mt);

  212.             UNUSED(tcbt);

  213.             if (mt == MeshType::Triangle)

  214.                 mt = mt;

  215.             else if (mt == MeshType::Quad)

  216.             {

  217.                 // There's nothin' else than QuadDefault

  218.                 BL = vec2(0.f);

  219.                 TR = vec2(1.f);

  220.             }

  221.             else if (mt == MeshType::Box)

  222.             {

  223.                 vec2 data[][2] =

  224.                 { // TexCoordBuildType::BoxDefault

  225.                     { vec2(0.f), vec2(.5f) },

  226.                     { vec2(.5f, 0.f), vec2(1.f, .5f) },

  227.                     { vec2(0.f), vec2(.5f) },

  228.                     { vec2(.5f, 0.f), vec2(1.f, .5f) },

  229.                     { vec2(0.f, .5f), vec2(.5f, 1.f) },

  230.                     { vec2(.5f, .5f), vec2(1.f, 1.f) }

  231.                 };

  232.                 BL = data[face.ToScalar()][0]; // [tcbt]

  233.                 TR = data[face.ToScalar()][1]; // [tcbt]

  234.             }

  235.             else if (mt == MeshType::Sphere)

  236.                 mt = mt;

  237.             else if (mt == MeshType::Capsule)

  238.                 mt = mt;

  239.             else if (mt == MeshType::Torus)

  240.                 mt = mt;

  241.             else if (mt == MeshType::Cylinder)

  242.                 mt = mt;

  243.             else if (mt == MeshType::Disc)

  244.                 mt = mt;

  245.             else if (mt == MeshType::Star)

  246.                 mt = mt;

  247.             else if (mt == MeshType::ExpandedStar)

  248.                 mt = mt;

  249.             else if (mt == MeshType::Cog)

  250.                 mt = mt;

  251.         }

  252. 

  253.         vec2 res = vec2(.0f);

  254.         if (tcp == TexCoordPos::BL)

  255.             res = BL;

  256.         else if (tcp == TexCoordPos::BR)

  257.             res = vec2(TR.x, BL.y);

  258.         else if (tcp == TexCoordPos::TL)

  259.             res = vec2(BL.x, TR.y);

  260.         else if (tcp == TexCoordPos::TR)

  261.             res = TR;

  262. 

  263.         return res * m_texcoord_scale + m_texcoord_offset2;

  264.     }

  265. 

  266.     // UV2

  267.     void SetTexCoordBuildType2(MeshType mt, TexCoordBuildType tcbt) { m_texcoord_build_type2[mt.ToScalar()] = (1 << (tcbt + 1)) | (m_texcoord_build_type2[mt.ToScalar()] & 1); }

  268.     TexCoordBuildType GetTexCoordBuildType2(MeshType mt)

  269.     {

  270.         uint32_t flag = ((m_texcoord_build_type2[mt.ToScalar()] & ~(1)) >> 1);

  271.         int i = 0;

  272.         while (flag >>= 1)

  273.             i++;

  274.         return TexCoordBuildType(i);

  275.     }

  276.     void SetTexCoordCustomBuild2(MeshType mt, MeshFaceType face, vec2 BL, vec2 TR)

  277.     {

  278.         if (face.ToScalar() >= m_texcoord_custom_build2[mt.ToScalar()].Count())

  279.             m_texcoord_custom_build2[mt.ToScalar()].Resize(face.ToScalar() + 1);

  280.         m_texcoord_custom_build2[mt.ToScalar()][face.ToScalar()].m1 = BL;

  281.         m_texcoord_custom_build2[mt.ToScalar()][face.ToScalar()].m2 = TR;

  282.         m_texcoord_build_type2[mt.ToScalar()] |= 1;

  283.     }

  284.     void ClearTexCoordCustomBuild2(MeshType mt) { m_texcoord_build_type2[mt.ToScalar()] &= ~1; }

  285.     vec2 TexCoord2(MeshType mt, TexCoordPos tcp, MeshFaceType face)

  286.     {

  287.         vec2 BL = vec2(0.f);

  288.         vec2 TR = vec2(0.f);

  289.         if (m_texcoord_build_type2[mt.ToScalar()] & 1

  290.              && face.ToScalar() < m_texcoord_custom_build2[mt.ToScalar()].Count())

  291.         {

  292.             BL = m_texcoord_custom_build2[mt.ToScalar()][face.ToScalar()].m1;

  293.             TR = m_texcoord_custom_build2[mt.ToScalar()][face.ToScalar()].m2;

  294.         }

  295.         else

  296.         {

  297.             TexCoordBuildType tcbt = GetTexCoordBuildType2(mt);

  298.             UNUSED(tcbt);

  299.             if (mt == MeshType::Triangle)

  300.                 mt = mt;

  301.             else if (mt == MeshType::Quad)

  302.             {

  303.                 // There's nothin' else than QuadDefault

  304.                 BL = vec2(0.f);

  305.                 TR = vec2(1.f);

  306.             }

  307.             else if (mt == MeshType::Box)

  308.             {

  309.                 vec2 data[][2] =

  310.                 { // TexCoordBuildType::BoxDefault

  311.                     { vec2(0.f), vec2(.5f) },

  312.                     { vec2(.5f, 0.f), vec2(1.f, .5f) },

  313.                     { vec2(0.f), vec2(.5f) },

  314.                     { vec2(.5f, 0.f), vec2(1.f, .5f) },

  315.                     { vec2(0.f, .5f), vec2(.5f, 1.f) },

  316.                     { vec2(.5f, .5f), vec2(1.f, 1.f) }

  317.                 };

  318.                 BL = data[face.ToScalar()][0]; // [tcbt]

  319.                 TR = data[face.ToScalar()][1]; // [tcbt]

  320.             }

  321.             else if (mt == MeshType::Sphere)

  322.                 mt = mt;

  323.             else if (mt == MeshType::Capsule)

  324.                 mt = mt;

  325.             else if (mt == MeshType::Torus)

  326.                 mt = mt;

  327.             else if (mt == MeshType::Cylinder)

  328.                 mt = mt;

  329.             else if (mt == MeshType::Disc)

  330.                 mt = mt;

  331.             else if (mt == MeshType::Star)

  332.                 mt = mt;

  333.             else if (mt == MeshType::ExpandedStar)

  334.                 mt = mt;

  335.             else if (mt == MeshType::Cog)

  336.                 mt = mt;

  337.         }

  338. 

  339.         vec2 res = vec2(.0f);

  340.         if (tcp == TexCoordPos::BL)

  341.             res = BL;

  342.         else if (tcp == TexCoordPos::BR)

  343.             res = vec2(TR.x, BL.y);

  344.         else if (tcp == TexCoordPos::TL)

  345.             res = vec2(BL.x, TR.y);

  346.         else if (tcp == TexCoordPos::TR)

  347.             res = TR;

  348. 

  349.         return res * m_texcoord_scale + m_texcoord_offset2;

  350.     }

  351. 

  352.     inline bool IsEnabled(MeshBuildOperation mbo) { return (m_build_flags & mbo) != 0; }

  353.     inline void Enable(MeshBuildOperation mbo) { m_build_flags |= mbo; }

  354.     inline void Disable(MeshBuildOperation mbo) { m_build_flags &= ~mbo; }

  355.     inline void Toggle(MeshBuildOperation mbo) { m_build_flags ^= mbo; }

  356.     inline void Set(MeshBuildOperation mbo, bool value) { if (value) Enable(mbo); else Disable(mbo); }

  357. 

  358. public:

  359.     CommandStack        m_stack;

  360.     int                 m_i_cmd;

  361.     int                 m_exec_nb;

  362.     Array<int, int>     m_loop_stack;

  363.     vec4                m_color_a;

  364.     vec4                m_color_b;

  365.     vec2                m_texcoord_offset;

  366.     vec2                m_texcoord_offset2;

  367.     vec2                m_texcoord_scale;

  368.     vec2                m_texcoord_scale2;

  369.     Array<vec2, vec2>   m_texcoord_custom_build[MeshType::MAX];

  370.     Array<vec2, vec2>   m_texcoord_custom_build2[MeshType::MAX];

  371.     uint32_t            m_texcoord_build_type[MeshType::MAX];

  372.     uint32_t            m_texcoord_build_type2[MeshType::MAX];

  373.     uint32_t            m_build_flags;

  374. };

  375. 

  376. /* A safe enum for VertexDictionnary operations. */

  377. struct VDictType

  378. {

  379.     DEF_VALUE

  380.         ADD_VALUE_SET(DoesNotExist  , -3)

  381.         ADD_VALUE_SET(Alone         , -2)

  382.         ADD_VALUE_SET(Master        , -1)

  383.     END_E_VALUE

  384. 

  385.     LOL_DECLARE_ENUM_METHODS(VDictType)

  386. };

  387. 

  388. /* TODO : replace VDict by a proper Half-edge system */

  389. //a class whose goal is to keep a list of the adjacent vertices for mesh operations purposes

  390. class VertexDictionnary

  391. {

  392. public:

  393.     int FindVertexMaster(const int search_idx);

  394.     bool FindMatchingVertices(const int search_idx, Array<int> &matching_ids);

  395.     bool FindConnectedVertices(const int search_idx, const Array<uint16_t> &tri_list, const int tri0, Array<int> &connected_vert, Array<int> const *ignored_tri = nullptr);

  396.     bool FindConnectedTriangles(const int search_idx, const Array<uint16_t> &tri_list, const int tri0, Array<int> &connected_tri, Array<int> const *ignored_tri = nullptr);

  397.     bool FindConnectedTriangles(const ivec2 &search_idx, const Array<uint16_t> &tri_list, const int tri0, Array<int> &connected_tri, Array<int> const *ignored_tri = nullptr);

  398.     bool FindConnectedTriangles(const ivec3 &search_idx, const Array<uint16_t> &tri_list, const int tri0, Array<int> &connected_tri, Array<int> const *ignored_tri = nullptr);

  399.     void AddVertex(int vert_id, vec3 vert_coord);

  400.     void RemoveVertex(int vert_id);

  401.     bool GetMasterList(Array<int> &ret_master_list) { ret_master_list = master_list; return ret_master_list.Count() > 0; }

  402.     void Clear() { vertex_list.Empty(); }

  403. private:

  404.     //<VertexId, VertexLocation, VertexMasterId>

  405.     Array<int, vec3, int>   vertex_list;

  406.     //List of the master_ vertices

  407.     Array<int>              master_list;

  408. };

  409. 

  410. } /* namespace lol */

  411. 

  412. #endif /* __EASYMESHBUILD_EASYMESHBUILD_H__ */