EZMesh : Added Vertices{Merge|Separate} and PostBuildNormal.

src/easymesh/easymesh-parser.y

@@ -46,11 +46,13 @@
 %start mesh_description
 
 %token T_LOOP T_COLOR T_ACOLOR T_BCOLOR T_VCOLOR
+%token T_TOGGLESCALEWINDING T_TOGGLEQUADWEIGHTING T_TOGGLEPOSTBUILDNORMAL T_TOGGLEVERTNOCLEANUP
+%token T_VERTMERGE T_VERTSEPARATE
 
 %token T_TRANSLATEX T_ROTATEX T_TAPERX T_TWISTX T_SHEARX T_STRETCHX T_BENDXY T_BENDXZ T_SCALEX T_MIRRORX
 %token T_TRANSLATEY T_ROTATEY T_TAPERY T_TWISTY T_SHEARY T_STRETCHY T_BENDYX T_BENDYZ T_SCALEY T_MIRRORY
 %token T_TRANSLATEZ T_ROTATEZ T_TAPERZ T_TWISTZ T_SHEARZ T_STRETCHZ T_BENDZX T_BENDZY T_SCALEZ T_MIRRORZ
-%token T_TRANSLATE T_ROTATE T_SCALE T_TOGGLESCALEWINDING T_TOGGLEQUADWEIGHTING T_RADIALJITTER T_SPLITTRIANGLE T_SMOOTHMESH
+%token T_TRANSLATE T_ROTATE T_SCALE  T_RADIALJITTER T_SPLITTRIANGLE T_SMOOTHMESH
 %token T_DUPLICATE
 %token T_CSGUNION T_CSGSUBSTRACT T_CSGSUBSTRACTLOSS T_CSGAND T_CSGXOR
 %token T_CHAMFER
@@ -233,6 +235,10 @@ transform_command:
   | T_SMOOTHMESH iv iv iv  { mc.m_mesh.SmoothMesh($2, $3, $4); }
   | T_TOGGLESCALEWINDING   { mc.m_mesh.ToggleScaleWinding(); }
   | T_TOGGLEQUADWEIGHTING  { mc.m_mesh.ToggleQuadWeighting(); }
+  | T_TOGGLEPOSTBUILDNORMAL { mc.m_mesh.TogglePostBuildNormal(); }
+  | T_TOGGLEVERTNOCLEANUP  { mc.m_mesh.ToggleVerticeNoCleanup(); }
+  | T_VERTMERGE            { mc.m_mesh.VerticesMerge(); }
+  | T_VERTSEPARATE         { mc.m_mesh.VerticesSeparate(); }
   ;
 
 primitive_command:

src/easymesh/easymesh-scanner.l

@@ -54,13 +54,19 @@ typedef lol::EasyMeshParser::token_type token_type;
 (csgx|csgxor)            { return token::T_CSGXOR; }
 
 (lp|loop)                { return token::T_LOOP; }
-(tsw|tglscalewind)       { return token::T_TOGGLESCALEWINDING; }
-(tqw|tglquadweight)      { return token::T_TOGGLEQUADWEIGHTING; }
 (sc|setcolor)            { return token::T_COLOR; }
 (sca|setcolora)          { return token::T_ACOLOR; }
 (scb|setcolorb)          { return token::T_BCOLOR; }
 (scv|setcolorv)          { return token::T_VCOLOR; }
 
+(tsw|tglscalewind)       { return token::T_TOGGLESCALEWINDING; }
+(tqw|tglquadweight)      { return token::T_TOGGLEQUADWEIGHTING; }
+(tpbn|tglpstbuildnormal) { return token::T_TOGGLEPOSTBUILDNORMAL; }
+(tvnc|tglvertnocleanup)  { return token::T_TOGGLEVERTNOCLEANUP; }
+
+(vm|vertmerge)           { return token::T_VERTMERGE; }
+(vs|vertseparate)        { return token::T_VERTSEPARATE; }
+
 (tx|translatex)          { return token::T_TRANSLATEX; }
 (ty|translatey)          { return token::T_TRANSLATEY; }
 (tz|translatez)          { return token::T_TRANSLATEZ; }

src/easymesh/easymesh.cpp

@@ -453,6 +453,15 @@ bool EasyMesh::Compile(char const *command)
         BD()->Enable(MeshBuildOperation::CommandExecution);
         ExecuteCmdStack();
         BD()->Disable(MeshBuildOperation::CommandExecution);
+
+        if (!BD()->IsEnabled(MeshBuildOperation::PreventVertCleanup))
+            VerticesCleanup();
+
+        if (BD()->IsEnabled(MeshBuildOperation::PostBuildComputeNormals))
+            ComputeNormals(0, m_indices.Count());
+
+        BD()->Disable(MeshBuildOperation::PostBuildComputeNormals);
+        BD()->Disable(MeshBuildOperation::PreventVertCleanup);
     }
     return res;
 }
@@ -490,155 +499,47 @@ bool EasyMesh::Compile(char const *command)
 //-----------------------------------------------------------------------------
 void EasyMesh::ExecuteCmdStack()
 {
+#define DO_EXEC_CMD(MESH_CMD, FUNC_PARAMS)  \
+        case EasyMeshCmdType::MESH_CMD:     \
+        { EZM_CALL_FUNC FUNC_PARAMS; break; }
+
     for (BD()->Cmdi() = 0; BD()->Cmdi() < BD()->CmdStack().GetCmdNb(); ++BD()->Cmdi())
     {
         switch (BD()->CmdStack().GetCmd(BD()->Cmdi()))
         {
-            case EasyMeshCmdType::MeshCsg:
-            {
-                EZM_CALL_FUNC(MeshCsg, CSGUsage);
-                break;
-            }
-            case EasyMeshCmdType::LoopStart:
-            {
-                EZM_CALL_FUNC(LoopStart, int);
-                break;
-            }
-            case EasyMeshCmdType::LoopEnd:
-            {
-                EZM_CALL_FUNC(LoopEnd);
-                break;
-            }
-            case EasyMeshCmdType::OpenBrace:
-            {
-                EZM_CALL_FUNC(OpenBrace);
-                break;
-            }
-            case EasyMeshCmdType::CloseBrace:
-            {
-                EZM_CALL_FUNC(CloseBrace);
-                break;
-            }
-            case EasyMeshCmdType::ScaleWinding:
-            {
-                EZM_CALL_FUNC(ToggleScaleWinding);
-                break;
-            }
-            case EasyMeshCmdType::QuadWeighting:
-            {
-                EZM_CALL_FUNC(ToggleQuadWeighting);
-                break;
-            }
-            case EasyMeshCmdType::SetColorA:
-            {
-                EZM_CALL_FUNC(SetCurColorA, vec4);
-                break;
-            }
-            case EasyMeshCmdType::SetColorB:
-            {
-                EZM_CALL_FUNC(SetCurColorB, vec4);
-                break;
-            }
-            case EasyMeshCmdType::SetVertColor:
-            {
-                EZM_CALL_FUNC(SetVertColor, vec4);
-                break;
-            }
-            case EasyMeshCmdType::Translate:
-            {
-                EZM_CALL_FUNC(Translate, vec3);
-                break;
-            }
-            case EasyMeshCmdType::Rotate:
-            {
-                EZM_CALL_FUNC(Rotate, float, vec3);
-                break;
-            }
-            case EasyMeshCmdType::RadialJitter:
-            {
-                EZM_CALL_FUNC(RadialJitter, float);
-                break;
-            }
-            case EasyMeshCmdType::MeshTranform:
-            {
-                EZM_CALL_FUNC(DoMeshTransform, MeshTransform, Axis, Axis, float, float, float, bool);
-                break;
-            }
-            case EasyMeshCmdType::Scale:
-            {
-                EZM_CALL_FUNC(Scale, vec3);
-                break;
-            }
-            case EasyMeshCmdType::DupAndScale:
-            {
-                EZM_CALL_FUNC(DupAndScale, vec3, bool);
-                break;
-            }
-            case EasyMeshCmdType::Chamfer:
-            {
-                EZM_CALL_FUNC(Chamfer, float);
-                break;
-            }
-            case EasyMeshCmdType::SplitTriangles:
-            {
-                EZM_CALL_FUNC(SplitTriangles, int);
-                break;
-            }
-            case EasyMeshCmdType::SmoothMesh:
-            {
-                EZM_CALL_FUNC(SmoothMesh, int, int, int);
-                break;
-            }
-            case EasyMeshCmdType::AppendCylinder:
-            {
-                EZM_CALL_FUNC(AppendCylinder, int, float, float, float, bool, bool, bool);
-                break;
-            }
-            case EasyMeshCmdType::AppendCapsule:
-            {
-                EZM_CALL_FUNC(AppendCapsule, int, float, float);
-                break;
-            }
-            case EasyMeshCmdType::AppendTorus:
-            {
-                EZM_CALL_FUNC(AppendTorus, int, float, float);
-                break;
-            }
-            case EasyMeshCmdType::AppendBox:
-            {
-                EZM_CALL_FUNC(AppendBox, vec3, float, bool);
-                break;
-            }
-            case EasyMeshCmdType::AppendStar:
-            {
-                EZM_CALL_FUNC(AppendStar, int, float, float, bool, bool);
-                break;
-            }
-            case EasyMeshCmdType::AppendExpandedStar:
-            {
-                EZM_CALL_FUNC(AppendExpandedStar, int, float, float, float);
-                break;
-            }
-            case EasyMeshCmdType::AppendDisc:
-            {
-                EZM_CALL_FUNC(AppendDisc, int, float, bool);
-                break;
-            }
-            case EasyMeshCmdType::AppendSimpleTriangle:
-            {
-                EZM_CALL_FUNC(AppendSimpleTriangle, float, bool);
-                break;
-            }
-            case EasyMeshCmdType::AppendSimpleQuad:
-            {
-                EZM_CALL_FUNC(AppendSimpleQuad, vec2, vec2, float, bool);
-                break;
-            }
-            case EasyMeshCmdType::AppendCog:
-            {
-                EZM_CALL_FUNC(AppendCog, int, float, float, float, float, float, float, float, float, bool);
-                break;
-            }
+            DO_EXEC_CMD(MeshCsg,                (MeshCsg, CSGUsage))
+            DO_EXEC_CMD(LoopStart,              (LoopStart, int))
+            DO_EXEC_CMD(LoopEnd,                (LoopEnd))
+            DO_EXEC_CMD(OpenBrace,              (OpenBrace))
+            DO_EXEC_CMD(CloseBrace,             (CloseBrace))
+            DO_EXEC_CMD(ScaleWinding,           (ToggleScaleWinding))
+            DO_EXEC_CMD(QuadWeighting,          (ToggleQuadWeighting))
+            DO_EXEC_CMD(PostBuildNormal,        (TogglePostBuildNormal))
+            DO_EXEC_CMD(PreventVertCleanup,     (ToggleVerticeNoCleanup))
+            DO_EXEC_CMD(VerticesMerge,          (VerticesMerge))
+            DO_EXEC_CMD(VerticesSeparate,       (VerticesSeparate))
+            DO_EXEC_CMD(SetColorA,              (SetCurColorA, vec4))
+            DO_EXEC_CMD(SetColorB,              (SetCurColorB, vec4))
+            DO_EXEC_CMD(SetVertColor,           (SetVertColor, vec4))
+            DO_EXEC_CMD(Translate,              (Translate, vec3))
+            DO_EXEC_CMD(Rotate,                 (Rotate, float, vec3))
+            DO_EXEC_CMD(RadialJitter,           (RadialJitter, float))
+            DO_EXEC_CMD(MeshTranform,           (DoMeshTransform, MeshTransform, Axis, Axis, float, float, float, bool))
+            DO_EXEC_CMD(Scale,                  (Scale, vec3))
+            DO_EXEC_CMD(DupAndScale,            (DupAndScale, vec3, bool))
+            DO_EXEC_CMD(Chamfer,                (Chamfer, float))
+            DO_EXEC_CMD(SplitTriangles,         (SplitTriangles, int))
+            DO_EXEC_CMD(SmoothMesh,             (SmoothMesh, int, int, int))
+            DO_EXEC_CMD(AppendCylinder,         (AppendCylinder, int, float, float, float, bool, bool, bool))
+            DO_EXEC_CMD(AppendCapsule,          (AppendCapsule, int, float, float))
+            DO_EXEC_CMD(AppendTorus,            (AppendTorus, int, float, float))
+            DO_EXEC_CMD(AppendBox,              (AppendBox, vec3, float, bool))
+            DO_EXEC_CMD(AppendStar,             (AppendStar, int, float, float, bool, bool))
+            DO_EXEC_CMD(AppendExpandedStar,     (AppendExpandedStar, int, float, float, float))
+            DO_EXEC_CMD(AppendDisc,             (AppendDisc, int, float, bool))
+            DO_EXEC_CMD(AppendSimpleTriangle,   (AppendSimpleTriangle, float, bool))
+            DO_EXEC_CMD(AppendSimpleQuad,       (AppendSimpleQuad, vec2, vec2, float, bool))
+            DO_EXEC_CMD(AppendCog,              (AppendCog, int, float, float, float, float, float, float, float, float, bool))
             default:
                 ASSERT(0, "Unknown command pseudo bytecode");
         }
@@ -775,8 +676,6 @@ bool EasyMesh::SetRender(bool should_render)
 //-------------------
 // "Collisions" functions
 //-------------------
-#define VX_ALONE -2
-#define VX_MASTER -1
 
 //-----------------------------------------------------------------------------
 //helpers func to retrieve a vertex.
@@ -1121,6 +1020,7 @@ void EasyMesh::MeshCsg(CSGUsage csg_operation)
     m_cursors.Last().m1 = m_vert.Count();
     m_cursors.Last().m2 = m_indices.Count();
 
+    VerticesCleanup();
     //DONE for the splitting !
 }
 
@@ -1148,6 +1048,30 @@ void EasyMesh::ToggleQuadWeighting()
     BD()->Toggle(MeshBuildOperation::QuadWeighting);
 }
 
+//-----------------------------------------------------------------------------
+void EasyMesh::TogglePostBuildNormal()
+{
+    if (BD()->IsEnabled(MeshBuildOperation::CommandRecording))
+    {
+        BD()->CmdStack().AddCmd(EasyMeshCmdType::PostBuildNormal);
+        return;
+    }
+
+    BD()->Toggle(MeshBuildOperation::PostBuildComputeNormals);
+}
+
+//-----------------------------------------------------------------------------
+void EasyMesh::ToggleVerticeNoCleanup()
+{
+    if (BD()->IsEnabled(MeshBuildOperation::CommandRecording))
+    {
+        BD()->CmdStack().AddCmd(EasyMeshCmdType::PreventVertCleanup);
+        return;
+    }
+
+    BD()->Toggle(MeshBuildOperation::PreventVertCleanup);
+}
+
 //-----------------------------------------------------------------------------
 void EasyMesh::SetCurColor(vec4 const &color)
 {
@@ -1308,6 +1232,13 @@ void EasyMesh::AppendTriangleDuplicateVerts(int i1, int i2, int i3, int base)
 //-----------------------------------------------------------------------------
 void EasyMesh::ComputeNormals(int start, int vcount)
 {
+    
+    if (BD()->IsEnabled(MeshBuildOperation::CommandExecution) &&
+        BD()->IsEnabled(MeshBuildOperation::PostBuildComputeNormals))
+        return;
+
+    Array< Array<vec3> > normals;
+    normals.Resize(m_vert.Count());
     for (int i = 0; i < vcount; i += 3)
     {
         vec3 v0 = m_vert[m_indices[start + i + 2]].m_coord
@@ -1317,8 +1248,143 @@ void EasyMesh::ComputeNormals(int start, int vcount)
         vec3 n = normalize(cross(v1, v0));
 
         for (int j = 0; j < 3; j++)
-            m_vert[m_indices[start + i + j]].m_normal = n;
+            normals[m_indices[start + i + j]] << n;
+    }
+
+    for (int i = 0; i < normals.Count(); i++)
+    {
+        if (normals[i].Count() > 0)
+        {
+            //remove doubles
+            for (int j = 0; j < normals[i].Count(); ++j)
+                for (int k = j + 1; k < normals[i].Count(); ++k)
+                    if (1.f - dot(normals[i][k], normals[i][j]) < .00001f)
+                        normals[i].Remove(k--);
+
+            vec3 newv = vec3::zero;
+            for (int j = 0; j < normals[i].Count(); ++j)
+                newv += normals[i][j];
+            m_vert[i].m_normal = normalize(newv / (float)normals[i].Count());
+        }
+    }
+}
+
+//-----------------------------------------------------------------------------
+void EasyMesh::VerticesCleanup()
+{
+    Array<int> vert_ids;
+    vert_ids.Resize(m_vert.Count(), 0);
+
+    //1: Remove triangles with two vertices on each other
+    for (int i = 0; i < m_indices.Count(); i += 3)
+    {
+        bool remove = false;
+        for (int j = 0; !remove && j < 3; ++j)
+            if (length(m_vert[m_indices[i + j]].m_coord - m_vert[m_indices[i + (j + 1) % 3]].m_coord) < .00001f)
+                remove = true;
+        if (remove)
+        {
+            m_indices.RemoveSwap(i, 3);
+            i -= 3;
+        }
+        else
+        {
+            //1.5: Mark all used vertices
+            for (int j = 0; j < 3; ++j)
+                vert_ids[m_indices[i + j]] = 1;
+        }
     }
+
+    //2: Remove all unused vertices
+    Array<VertexData> old_vert = m_vert;
+    int shift = 0;
+    m_vert.Empty();
+    for (int i = 0; i < vert_ids.Count(); ++i)
+    {
+        //Unused vertex, update the shift quantity instead of keeping it.
+        if (vert_ids[i] == 0)
+            shift++;
+        else
+            m_vert << old_vert[i];
+        //Always mark it with the shift quantity
+        vert_ids[i] = shift;
+    }
+
+    //3: Update the indices
+    for (int i = 0; i < m_indices.Count(); ++i)
+        m_indices[i] -= vert_ids[m_indices[i]];
+}
+
+//-----------------------------------------------------------------------------
+void EasyMesh::VerticesMerge()
+{
+    if (BD()->IsEnabled(MeshBuildOperation::CommandRecording))
+    {
+        BD()->CmdStack().AddCmd(EasyMeshCmdType::VerticesMerge);
+        return;
+    }
+
+    //1: Crunch all vertices in the dictionnary
+    VertexDictionnary vert_dict;
+    for (int i = m_cursors.Last().m1; i < m_vert.Count(); i++)
+        vert_dict.AddVertex(i, m_vert[i].m_coord);
+
+    //2: Update the indices
+    for (int i = 0; i < m_indices.Count(); ++i)
+    {
+        int master = vert_dict.FindVertexMaster(m_indices[i]);
+        if (master >= 0)
+            m_indices[i] = master;
+    }
+
+    //2: Cleanup
+    VerticesCleanup();
+}
+
+//-----------------------------------------------------------------------------
+void EasyMesh::VerticesSeparate()
+{
+    if (BD()->IsEnabled(MeshBuildOperation::CommandRecording))
+    {
+        BD()->CmdStack().AddCmd(EasyMeshCmdType::VerticesSeparate);
+        return;
+    }
+
+    Array< Array<int> > new_ids;
+    Array<int> vert_ids;
+    vert_ids.Resize(m_vert.Count(), 0);
+
+    //1: Mark all used vertices
+    for (int i = 0; i < m_indices.Count(); ++i)
+        vert_ids[m_indices[i]]++;
+
+    //2: Update the vertices
+    int vbase = m_cursors.Last().m1;
+    int vcount = m_vert.Count();
+    new_ids.Resize(vcount);
+    for (int i = vbase; i < vcount; i++)
+    {
+        while (vert_ids[i] > 1)
+        {
+            //Add duplicate
+            new_ids[i] << m_vert.Count();
+            AddDuplicateVertex(i);
+            vert_ids[i]--;
+        }
+    }
+
+    //3: Update the indices
+    for (int i = 0; i < m_indices.Count(); ++i)
+    {
+        if (new_ids[m_indices[i]].Count())
+        {
+            int j = new_ids[m_indices[i]].Pop();
+            m_indices[i] = j;
+        }
+    }
+
+    //4: Cleanup
+    VerticesCleanup();
 }
 
 //-----------------------------------------------------------------------------

src/easymesh/easymesh.h

@@ -201,11 +201,13 @@ struct MeshBuildOperation
     enum Value
     {
         //When this flag is up, negative scaling will not invert faces.
-        ScaleWinding        = (1 << 0),
-        CommandRecording    = (1 << 1),
-        CommandExecution    = (1 << 2),
-        QuadWeighting       = (1 << 3),
-        IgnoreQuadWeighting = (1 << 4),
+        ScaleWinding                = (1 << 0),
+        CommandRecording            = (1 << 1),
+        CommandExecution            = (1 << 2),
+        QuadWeighting               = (1 << 3),
+        IgnoreQuadWeighting         = (1 << 4),
+        PostBuildComputeNormals     = (1 << 5),
+        PreventVertCleanup          = (1 << 6),
 
         All     = 0xffffffff
     }
@@ -229,10 +231,15 @@ struct EasyMeshCmdType
 
         ScaleWinding,
         QuadWeighting,
+        PostBuildNormal,
+        PreventVertCleanup,
         SetColorA,
         SetColorB,
         SetVertColor,
 
+        VerticesMerge,
+        VerticesSeparate,
+
         Translate,
         Rotate,
         RadialJitter,
@@ -702,6 +709,10 @@ public:
     void ToggleScaleWinding();
     /* [cmd:tqw] When active, quad will have a fifth center vertex */
     void ToggleQuadWeighting();
+    /* [cmd:tpbn] When active, normal will be computed after the build */
+    void TogglePostBuildNormal();
+    /* [cmd:tpbn] When active, normal will be computed after the build */
+    void ToggleVerticeNoCleanup();
     /* [cmd:sc] Set both color */
     void SetCurColor(vec4 const &color);
     /* [cmd:sca] Set base color A */
@@ -726,6 +737,13 @@ private:
     void AppendTriangle(int i1, int i2, int i3, int base);
     void AppendTriangleDuplicateVerts(int i1, int i2, int i3, int base);
     void ComputeNormals(int start, int vcount);
+public:
+    /* Remove all unused */
+    void VerticesCleanup();
+    /* Merge vertices AKA: smooth */
+    void VerticesMerge();
+    /* Merge vertices AKA: Flat */
+    void VerticesSeparate();
 public: //DEBUG
     void ComputeTexCoord(float uv_scale, int uv_offset);
 
@@ -984,7 +1002,7 @@ public:
     int GetVertexCount() { return m_vert.Count(); }
     vec3 const &GetVertexLocation(int i) { return m_vert[i].m_coord; }
 
-private:
+//private:
     Array<uint16_t>     m_indices;
     Array<VertexData>   m_vert;
 

src/generated/easymesh-parser.h

@@ -141,69 +141,73 @@ namespace lol {
      T_ACOLOR = 260,
      T_BCOLOR = 261,
      T_VCOLOR = 262,
-     T_TRANSLATEX = 263,
-     T_ROTATEX = 264,
-     T_TAPERX = 265,
-     T_TWISTX = 266,
-     T_SHEARX = 267,
-     T_STRETCHX = 268,
-     T_BENDXY = 269,
-     T_BENDXZ = 270,
-     T_SCALEX = 271,
-     T_MIRRORX = 272,
-     T_TRANSLATEY = 273,
-     T_ROTATEY = 274,
-     T_TAPERY = 275,
-     T_TWISTY = 276,
-     T_SHEARY = 277,
-     T_STRETCHY = 278,
-     T_BENDYX = 279,
-     T_BENDYZ = 280,
-     T_SCALEY = 281,
-     T_MIRRORY = 282,
-     T_TRANSLATEZ = 283,
-     T_ROTATEZ = 284,
-     T_TAPERZ = 285,
-     T_TWISTZ = 286,
-     T_SHEARZ = 287,
-     T_STRETCHZ = 288,
-     T_BENDZX = 289,
-     T_BENDZY = 290,
-     T_SCALEZ = 291,
-     T_MIRRORZ = 292,
-     T_TRANSLATE = 293,
-     T_ROTATE = 294,
-     T_SCALE = 295,
-     T_TOGGLESCALEWINDING = 296,
-     T_TOGGLEQUADWEIGHTING = 297,
-     T_RADIALJITTER = 298,
-     T_SPLITTRIANGLE = 299,
-     T_SMOOTHMESH = 300,
-     T_DUPLICATE = 301,
-     T_CSGUNION = 302,
-     T_CSGSUBSTRACT = 303,
-     T_CSGSUBSTRACTLOSS = 304,
-     T_CSGAND = 305,
-     T_CSGXOR = 306,
-     T_CHAMFER = 307,
-     T_CYLINDER = 308,
-     T_BOX = 309,
-     T_SMOOTHCHAMFBOX = 310,
-     T_FLATCHAMFBOX = 311,
-     T_SPHERE = 312,
-     T_CAPSULE = 313,
-     T_STAR = 314,
-     T_EXPANDEDSTAR = 315,
-     T_DISC = 316,
-     T_TRIANGLE = 317,
-     T_QUAD = 318,
-     T_COG = 319,
-     T_TORUS = 320,
-     T_ERROR = 321,
-     F_NUMBER = 322,
-     I_NUMBER = 323,
-     BOOLEAN = 324,
-     COLOR = 325
+     T_TOGGLESCALEWINDING = 263,
+     T_TOGGLEQUADWEIGHTING = 264,
+     T_TOGGLEPOSTBUILDNORMAL = 265,
+     T_TOGGLEVERTNOCLEANUP = 266,
+     T_VERTMERGE = 267,
+     T_VERTSEPARATE = 268,
+     T_TRANSLATEX = 269,
+     T_ROTATEX = 270,
+     T_TAPERX = 271,
+     T_TWISTX = 272,
+     T_SHEARX = 273,
+     T_STRETCHX = 274,
+     T_BENDXY = 275,
+     T_BENDXZ = 276,
+     T_SCALEX = 277,
+     T_MIRRORX = 278,
+     T_TRANSLATEY = 279,
+     T_ROTATEY = 280,
+     T_TAPERY = 281,
+     T_TWISTY = 282,
+     T_SHEARY = 283,
+     T_STRETCHY = 284,
+     T_BENDYX = 285,
+     T_BENDYZ = 286,
+     T_SCALEY = 287,
+     T_MIRRORY = 288,
+     T_TRANSLATEZ = 289,
+     T_ROTATEZ = 290,
+     T_TAPERZ = 291,
+     T_TWISTZ = 292,
+     T_SHEARZ = 293,
+     T_STRETCHZ = 294,
+     T_BENDZX = 295,
+     T_BENDZY = 296,
+     T_SCALEZ = 297,
+     T_MIRRORZ = 298,
+     T_TRANSLATE = 299,
+     T_ROTATE = 300,
+     T_SCALE = 301,
+     T_RADIALJITTER = 302,
+     T_SPLITTRIANGLE = 303,
+     T_SMOOTHMESH = 304,
+     T_DUPLICATE = 305,
+     T_CSGUNION = 306,
+     T_CSGSUBSTRACT = 307,
+     T_CSGSUBSTRACTLOSS = 308,
+     T_CSGAND = 309,
+     T_CSGXOR = 310,
+     T_CHAMFER = 311,
+     T_CYLINDER = 312,
+     T_BOX = 313,
+     T_SMOOTHCHAMFBOX = 314,
+     T_FLATCHAMFBOX = 315,
+     T_SPHERE = 316,
+     T_CAPSULE = 317,
+     T_STAR = 318,
+     T_EXPANDEDSTAR = 319,
+     T_DISC = 320,
+     T_TRIANGLE = 321,
+     T_QUAD = 322,
+     T_COG = 323,
+     T_TORUS = 324,
+     T_ERROR = 325,
+     F_NUMBER = 326,
+     I_NUMBER = 327,
+     BOOLEAN = 328,
+     COLOR = 329
    };
 
     };
@@ -377,7 +381,7 @@ namespace lol {
 } // lol
 
 /* Line 34 of lalr1.cc  */
-#line 381 "generated/easymesh-parser.h"
+#line 385 "generated/easymesh-parser.h"
 
 
 

test/data/mesh-buffer.txt

@@ -1,9 +1,10 @@
-addlight 0 position (4 -4 0) color #fff
+//addlight 0 position (1 -.5 1.5) color #fff
 addlight 1 position (0 0 6) color #bfb
-clearcolor #d0d
+clearcolor #ddd
 showgizmo true
 showlight true
 
+
 //SCENE SETUP END
 
 //addlight 0.0 position (1 0 1) color #0ff
@@ -11,17 +12,17 @@ showlight true
 
 //custom setmesh "sc#f00 ab 2 ty 1.5 ab 2"
 
-
 custom setmesh "
 
 //tqw
 //CMD TEST
-sc#0f0 ab 5
+//sc#0f0 asph 1 10
+//sc#0f0 ab 10
 //sc#0f0 afcb 1 -.2
 //sc#0f0 acg 8 1 1 1 2 2 1.5 1.5 -.4
 //sc#0f0 as 6 1 2
 //sc#0f0 scb#f00 aes 6 1 2 2
-//sc#0f0 ac 6 1 1
+//sc#0f0 ac 6 5 2 2 false true true
 //sc#0f0 aq 1
 //splt 2 smth 4 0 1
 
@@ -48,6 +49,14 @@ sc#0f0 ab 5
 //sc#0f0 ab 2 ty 1.5 ab 2
 //sc#00f ab 2 ty 1.5 ab 2
 
+
+
+[sc#88f afcb 10 10 10 .25 tx 0]
+csgs [sc#fff afcb 10 10 10 .25 t 2 2 2]
+//[sc#fff afcb 7 7 7 .25]
+//[sc#ff2 afcb 7 7 7 .25 t 1 1 1 csgs]
+
+
 "
 
 //splt 0 
@@ -92,8 +101,3 @@ sc#0f0 ab 5
 
 //[sc#ff2 asph 2 10 10 10]
 //[sc#400 asph 2 10 10 10 t 2 2 2 csgs]
-
-//[sc#88f afcb 10 10 10 .25 tx 0]
-//[sc#fff afcb 10 10 10 .25 t 2 2 2 csgs]
-//[sc#fff afcb 7 7 7 .25]
-//[sc#ff2 afcb 7 7 7 .25 t 1 1 1 csgs]

test/easymeshdictionnary.js

@@ -25,12 +25,20 @@ CmdType(["csgx",  "csgxor"], "Performs a Xor operation as :\n(current_scope_Outs
 //-------------------------------------------------------------------------
 CmdType(["tsw", "tglscalewind"], "When active, on negative-scaling,\nnormal-vector correction will not occur\nDefault : Inactive");
 CmdType(["tqw", "tglquadweight"], "When active, quad will have a fifth center vertex\nDefault : Inactive");
+CmdType(["tpbn", "tglpstbuildnormal"], "When active, normal will be only computed after all the command\nDefault : Inactive");
+CmdType(["tvnc", "tglvertnocleanup"], "When active, vertices cleanup will not be done at the end of all the commands\nDefault : Inactive");
 CmdType(["sc",  "setcolor"], "Set A & B color", [CmdArg("color", "color")]);
 CmdType(["sca", "setcolora"], "Set A color", [CmdArg("color", "color")]);
 CmdType(["scb", "setcolorb"], "Set B color", [CmdArg("color", "color")]);
 CmdType(["scv", "setcolorv"], "Set the color of all vertices in this scope", [CmdArg("color", "color")]);
 CmdType(["lp",  "loop"], "Performs a loop with the code in the braces.\nDoesn't open a new scope.", [CmdArg("int", "loopnb"), CmdArg("[ ]", "Loop command")]);
 
+//-------------------------------------------------------------------------
+//Vertices operations
+//-------------------------------------------------------------------------
+CmdType(["vm", "vertmerge"], "Will merge all the same face vertices");
+CmdType(["vs", "vertseparate"], "Will separate all the same face vertices");
+
 //-------------------------------------------------------------------------
 //Mesh transform operations
 //-------------------------------------------------------------------------

test/meshviewer.cpp

@@ -729,6 +729,8 @@ public:
 #endif //ALL_FEATURES
             }
         }
+
+        //Scene setup update
         if (m_ssetup)
         {
             m_camera->SetProjection(mat_gizmo);
@@ -756,6 +758,29 @@ public:
             }
             m_camera->SetProjection(save_proj);
         }
+
+#if 0 //Debug normal draw
+        for (int i = m_meshes.Count() - 1; 0 <= i && i < m_meshes.Count(); i++)
+        {
+            for (int j = 0; j < m_meshes[i]->m_indices.Count(); j += 3)
+            {
+                VertexData v[3] = { m_meshes[i]->m_vert[m_meshes[i]->m_indices[j  ]],
+                                    m_meshes[i]->m_vert[m_meshes[i]->m_indices[j+1]],
+                                    m_meshes[i]->m_vert[m_meshes[i]->m_indices[j+2]]
+                                    };
+                for (int k = 0; k < 3; k++)
+                    Debug::DrawLine((m_mat * mat4::translate(v[k].m_coord)).v3.xyz,
+                                    (m_mat * mat4::translate(v[(k+1)%3].m_coord)).v3.xyz, vec4(vec3((v[k].m_coord.z + 1.f)*.5f),1.f));
+            }
+            for (int j = 0; j < m_meshes[i]->m_vert.Count(); j++)
+            {
+                VertexData &v = m_meshes[i]->m_vert[m_meshes[i]->m_indices[j]];
+                Debug::DrawLine((m_mat * mat4::translate(v.m_coord)).v3.xyz,
+                                (m_mat * mat4::translate(v.m_coord)).v3.xyz +
+                                (m_mat * vec4(v.m_normal * 5.f, 0.f)).xyz, vec4(lol::abs(v.m_normal), 1.f));
+            }
+        }
+#endif
     }
 
 private: