Revision: 48895
          
http://projects.blender.org/scm/viewvc.php?view=rev&root=bf-blender&revision=48895
Author:   psy-fi
Date:     2012-07-13 19:20:18 +0000 (Fri, 13 Jul 2012)
Log Message:
-----------
UV transform correction
=======================
* Make a better estimate of closest loops by taking angle sign into
account.

Modified Paths:
--------------
    
branches/soc-2012-bratwurst/source/blender/editors/transform/transform_generics.c

Modified: 
branches/soc-2012-bratwurst/source/blender/editors/transform/transform_generics.c
===================================================================
--- 
branches/soc-2012-bratwurst/source/blender/editors/transform/transform_generics.c
   2012-07-13 14:21:17 UTC (rev 48894)
+++ 
branches/soc-2012-bratwurst/source/blender/editors/transform/transform_generics.c
   2012-07-13 19:20:18 UTC (rev 48895)
@@ -1781,13 +1781,12 @@
                        copy_v3_v3(edge_world_parall, edge_vec_init2);
                }
                /* tmp! */
+               angle = loops[0].angle;
                copy_v3_v3(edge_world_parall, edge_vec_init1);
 
                normalize_v3(edge_world_parall);
-               mul_v3_fl(edge_world_parall, angle*displaced_length);
+               mul_v3_fl(edge_world_parall, cos(angle)*displaced_length);
 
-               angle = acos(angle);
-
                /* to get an 'outward' direction in uv space, just get the 
perpendicular vector.
                 * To get a correct outward vector, we need to negate the 
vector appropriately
                 * according to the winding of the loop */
@@ -1922,7 +1921,7 @@
                        UVTransCorrInfoUV *first_island_uv, *uvtcuv;
                        float projv[3], proj_len;
                        UVTCLoop boundary_loops[2];
-                       const UVTCLoop boundary_loop_init = {-10.0, NULL, 
FALSE};
+                       const UVTCLoop boundary_loop_init = {4*M_PI, NULL, 
FALSE};
                        int index;
                        BMVert *v = td[i].eve;
 
@@ -1945,6 +1944,7 @@
                                float angle1, angle2;
                                float dot_tmp;
                                float proj_prev[3], proj_next[3];
+                               float cross1[3], cross2[3];
                                int index_next, index_prev;
                                BMLoop *l_next, *l_prev, *l = uvtcuv->l;
 
@@ -1976,37 +1976,40 @@
                                sub_v3_v3v3(proj_next, proj_next, td[i].iloc);
                                sub_v3_v3v3(proj_prev, proj_prev, td[i].iloc);
 
+                               cross_v3_v3v3(cross1, projv, proj_next);
+                               cross_v3_v3v3(cross2, projv, proj_prev);
                                /* now calculate the angles between the edges 
and the displacement vector */
                                dot_tmp = dot_v3v3(projv, projv);
 
-                               angle1 = dot_v3v3(projv, 
proj_next)/(sqrtf(dot_tmp*dot_v3v3(proj_next, proj_next)));
-                               angle2 = dot_v3v3(projv, 
proj_prev)/(sqrtf(dot_tmp*dot_v3v3(proj_prev, proj_prev)));
+                               angle1 = acos(dot_v3v3(projv, 
proj_next)/(sqrtf(dot_tmp*dot_v3v3(proj_next, proj_next))));
+                               angle2 = acos(dot_v3v3(projv, 
proj_prev)/(sqrtf(dot_tmp*dot_v3v3(proj_prev, proj_prev))));
 
+                               if(signf(dot_v3v3(cross1, 
uvtc->init_normal[index])) > 0.0) {
+                                       angle1 = 2*M_PI - angle1;
+                               }
+                               if(signf(dot_v3v3(cross2, 
uvtc->init_normal[index])) > 0.0) {
+                                       angle2 = 2*M_PI - angle2;
+                               }
+
                                /* store the loops that have the minimum angle 
with the displacement vector */
-                               if((angle1 > boundary_loops[0].angle) && 
(!boundary_loops[1].loop || l_next->v != boundary_loops[1].loop->v)) {
-                                       boundary_loops[1].angle = 
boundary_loops[0].angle;
-                                       boundary_loops[1].loop = 
boundary_loops[0].loop;
-                                       boundary_loops[1].prev = 
boundary_loops[0].prev;
-
+                               if((angle1 < boundary_loops[0].angle)) {
                                        boundary_loops[0].angle = angle1;
                                        boundary_loops[0].loop = l_next;
                                        boundary_loops[0].prev = FALSE;
-                               } else if((angle1 > boundary_loops[1].angle) && 
(!boundary_loops[0].loop || l_next->v != boundary_loops[0].loop->v)) {
-                                       boundary_loops[1].angle = angle1;
+                               }
+                               if(((2*M_PI - angle1) < 
boundary_loops[1].angle)) {
+                                       boundary_loops[1].angle = 2*M_PI - 
angle1;
                                        boundary_loops[1].loop = l_next;
                                        boundary_loops[1].prev = FALSE;
                                }
 
-                               if((angle2 > boundary_loops[0].angle) && 
(!boundary_loops[1].loop || l_prev->v != boundary_loops[1].loop->v)) {
-                                       boundary_loops[1].angle = 
boundary_loops[0].angle;
-                                       boundary_loops[1].loop = 
boundary_loops[0].loop;
-                                       boundary_loops[1].prev = 
boundary_loops[0].prev;
-
+                               if((angle2 < boundary_loops[0].angle)) {
                                        boundary_loops[0].angle = angle2;
                                        boundary_loops[0].loop = l_prev;
                                        boundary_loops[0].prev = TRUE;
-                               } else if((angle2 > boundary_loops[1].angle) && 
(!boundary_loops[0].loop || l_prev->v != boundary_loops[0].loop->v)) {
-                                       boundary_loops[1].angle = angle2;
+                               }
+                               if(((2*M_PI - angle2) < 
boundary_loops[1].angle)) {
+                                       boundary_loops[1].angle = 2*M_PI - 
angle2;
                                        boundary_loops[1].loop = l_prev;
                                        boundary_loops[1].prev = TRUE;
                                }

_______________________________________________
Bf-blender-cvs mailing list
[email protected]
http://lists.blender.org/mailman/listinfo/bf-blender-cvs

Reply via email to