fix weld vertices and primitive normal directions

source/blender/bmesh/operators/primitiveops.c

 #include "MEM_guardedalloc.h"
 
 #include "DNA_meshdata_types.h"
 #include "DNA_mesh_types.h"
 #include "DNA_object_types.h"
 #include "DNA_scene_types.h"
 
 #include "BLI_utildefines.h"
 
 #include "BLI_math.h"
@@ skipping 23 matching lines @@
         {144.72f,105.144f,-89.443f},
         {55.277f,-170.128f,89.443f},
         {-144.72f,-105.144f,89.443f},
         {-144.72f,105.144f,89.443f},
         {55.277f,170.128f,89.443f},
         {178.885f,0.0f,89.443f},
         {0.0f,0.0f,200.0f}
 };
 
 static short icoface[20][3] = {
-        {1,0,2},
+        {0,1,2},
         {1,0,5},
-        {2,0,3},
-        {3,0,4},
-        {4,0,5},
+        {0,2,3},
+        {0,3,4},
+        {0,4,5},
         {1,5,10},
         {2,1,6},
         {3,2,7},
         {4,3,8},
         {5,4,9},
-        {10,1,6},
-        {6,2,7},
-        {7,3,8},
-        {8,4,9},
-        {9,5,10},
+        {1,10,6},
+        {2,6,7},
+        {3,7,8},
+        {4,8,9},
+        {5,9,10},
         {6,10,11},
         {7,6,11},
         {8,7,11},
         {9,8,11},
         {10,9,11}
 };
 
 // HACK: these can also be found in cmoview.tga.c, but are here so that they can be found by linker
 // this hack is only used so that scons+mingw + split-sources hack works
         // ------------------------------- start copied code
@@ skipping 220 matching lines @@
 
         BMO_Get_Mat4(op, "mat", mat);
 
         phid= 2.0f*(float)M_PI/tot;
         phi= .25f*(float)M_PI;
 
         /* one segment first */
         phi= 0;·
         phid/=2;
         for(a=0; a<=tot; a++) {
-                vec[0]= dia*sinf(phi);
+                /* Going in this direction, then edge extruding, makes normals face outward */
+                vec[0]= -dia*sinf(phi);

[Ender79, 2011/09/03 12:55:53]

Since it seems essentially random which direction the normal will point when
extruding a face from a wire edge, it seems fine to flip it here if that fixes
the issue. But I wonder if this will start to show up in other places (addons).
I guess if it becomes a real problem, maybe we can flip the "randomness" so it
is always random the other way.

                 vec[1]= 0.0;
                 vec[2]= dia*cosf(phi);
                 eve= BM_Make_Vert(bm, vec, NULL);
                 BMO_SetFlag(bm, eve, VERT_MARK);
 
                 if(a==0) v1= eve;
                 else {
                         e = BM_Make_Edge(bm, preveve, eve, NULL, 0);
                         BMO_SetFlag(bm, e, EDGE_ORIG);
                 }
 
                 phi+= phid;
                 preveve = eve;
         }
 
-        /* extrude and rotate */
-        phi= M_PI/seg;
+        /* extrude and rotate; negative phi to make normals face outward */
+        phi= -M_PI/seg;
         q[0]= cos(phi);
         q[3]= sin(phi);
         q[1]=q[2]= 0;
         quat_to_mat3(cmat, q);
 
         for(a=0; a<seg; a++) {
                 if (a) {
                         BMO_InitOpf(bm, &bmop, "extrude_edge_only edges=%s", &prevop, "geomout");
                         BMO_Exec_Op(bm, &bmop);
                         BMO_Finish_Op(bm, &prevop);
@@ skipping 135 matching lines @@
 
         if (cap_ends) {
                 vec[0] = vec[1] = 0.0f;
                 vec[2] = 0.0;
                 mul_m4_v3(mat, vec);
 ················
                 cent1 = BM_Make_Vert(bm, vec, NULL);
         }
 
         for (a=0; a<segs; a++, phi+=phid) {
-                vec[0]= dia*sinf(phi);
+                /* Going this way ends up with normal(s) upward */
+                vec[0]= -dia*sinf(phi);
                 vec[1]= dia*cosf(phi);
                 vec[2]= 0.0f;
                 mul_m4_v3(mat, vec);
                 v1 = BM_Make_Vert(bm, vec, NULL);
 
                 BMO_SetFlag(bm, v1, VERT_MARK);
 ················
                 if (lastv1)
                         BM_Make_Edge(bm, v1, lastv1, NULL, 0);
 ················
@@ skipping 11 matching lines @@
         }
 
         if (!a)
                 return;
 
         BM_Make_Edge(bm, lastv1, firstv1, NULL, 0);
 
         if (cap_ends) {
                 BMFace *f;
 ················
-                f = BM_Make_QuadTri(bm, cent1, firstv1, v1, NULL, NULL, 0);
+                f = BM_Make_QuadTri(bm, cent1, v1, firstv1, NULL, NULL, 0);

[Ender79, 2011/09/03 12:55:53]

All these quadtri swaps look right for sure. The initial implementation before
these changes likely just shows how Blender's mode of drawing two-sided faces by
default can lead to thinking everything is all right when it in fact is not.

                 BMO_SetFlag(bm, f, FACE_NEW);
         }
 ········
         if (!cap_tris) {
                 BMO_CallOpf(bm, "dissolvefaces faces=%ff", FACE_NEW);
         }
 ········
         BMO_Flag_To_Slot(bm, op, "vertout", VERT_MARK, BM_VERT);
 }
 
@@ skipping 49 matching lines @@
 
                 BMO_SetFlag(bm, v1, VERT_MARK);
                 BMO_SetFlag(bm, v2, VERT_MARK);
 
                 if (a) {
                         if (cap_ends) {
                                 BMFace *f;
 ································
                                 f = BM_Make_QuadTri(bm, cent1, lastv1, v1, NULL, NULL, 0);
                                 BMO_SetFlag(bm, f, FACE_NEW);
-                                f = BM_Make_QuadTri(bm, v2, lastv2, cent2, NULL, NULL, 0);
+                                f = BM_Make_QuadTri(bm, cent2, v2, lastv2, NULL, NULL, 0);
                                 BMO_SetFlag(bm, f, FACE_NEW);
                         }
                         BM_Make_QuadTri(bm, lastv1, lastv2, v2, v1, NULL, 0);
                 } else {
                         firstv1 = v1;
                         firstv2 = v2;
                 }
 
                 lastv1 = v1;
                 lastv2 = v2;
         }
 
         if (!a)
                 return;
 
         if (cap_ends) {
                 BMFace *f;
 ················
-                f = BM_Make_QuadTri(bm, cent1, firstv1, v1, NULL, NULL, 0);
+                f = BM_Make_QuadTri(bm, cent1, v1, firstv1, NULL, NULL, 0);
                 BMO_SetFlag(bm, f, FACE_NEW);
-                f = BM_Make_QuadTri(bm, v2, firstv2, cent2, NULL, NULL, 0);
+                f = BM_Make_QuadTri(bm, cent2, firstv2, v2, NULL, NULL, 0);
                 BMO_SetFlag(bm, f, FACE_NEW);
         }
 ········
         if (!cap_tris) {
                 BMO_CallOpf(bm, "dissolvefaces faces=%ff", FACE_NEW);
         }
 ········
-        BM_Make_QuadTri(bm, firstv1, firstv2, v2, v1, NULL, 0);
+        BM_Make_QuadTri(bm, v1, v2, firstv2, firstv1, NULL, 0);
 
         BMO_CallOpf(bm, "removedoubles verts=%fv dist=%f", VERT_MARK, 0.000001);
         BMO_Flag_To_Slot(bm, op, "vertout", VERT_MARK, BM_VERT);
 }
 
 void bmesh_create_cube_exec(BMesh *bm, BMOperator *op)
 {
         BMVert *v1, *v2, *v3, *v4, *v5, *v6, *v7, *v8;
         float vec[3], mat[4][4], off = BMO_Get_Float(op, "size") / 2.0f;
 
@@ skipping 62 matching lines @@
         BM_Make_QuadTri(bm, v6, v7, v3, v2, NULL, 0);
         BM_Make_QuadTri(bm, v7, v8, v4, v3, NULL, 0);
         BM_Make_QuadTri(bm, v8, v5, v1, v4, NULL, 0);
 ········
         /*top/bottom*/
         BM_Make_QuadTri(bm, v1, v2, v3, v4, NULL, 0);
         BM_Make_QuadTri(bm, v8, v7, v6, v5, NULL, 0);
 
         BMO_Flag_To_Slot(bm, op, "vertout", VERT_MARK, BM_VERT);
 }