On create_graphic with :poly argument, handling of the normal vectors is improved.

git-svn-id: svn+ssh://svn.sourceforge.jp/svnroot/molby/trunk@585 a2be9bc6-48de-4e38-9406-05402d4bc13c

diff --git a/MolLib/MainView.c b/MolLib/MainView.c
index c9e089c..d4e3e97 100755 (executable)
--- a/MolLib/MainView.c
+++ b/MolLib/MainView.c
@@ -1468,26 +1468,28 @@ drawGraphics(MainView *mview)
                                enableLighting();
                                break;
                        case kMainViewGraphicPoly: {
-                               Vector v0, v1, v2, v3;
+                       /*      Vector v0, v1, v2, v3; */
                                glBegin(GL_TRIANGLE_FAN);
-                               v1.x = g->points[0] - g->points[g->npoints - 3];
+                       /*      v1.x = g->points[0] - g->points[g->npoints - 3];
                                v1.y = g->points[1] - g->points[g->npoints - 2];
                                v1.z = g->points[2] - g->points[g->npoints - 1];
-                               v0 = v1;
+                               v0 = v1;  */
                                for (j = 0; j < g->npoints; j++) {
-                                       v2.x = g->points[j * 3 + 3] - g->points[j * 3];
+                               /*      v2.x = g->points[j * 3 + 3] - g->points[j * 3];
                                        v2.y = g->points[j * 3 + 4] - g->points[j * 3 + 1];
                                        v2.z = g->points[j * 3 + 5] - g->points[j * 3 + 2];
                                        VecCross(v3, v1, v2);
                                        if (NormalizeVec(&v3, &v3) == 0)
-                                               glNormal3f(v3.x, v3.y, v3.z);
+                                               glNormal3f(v3.x, v3.y, v3.z); */
+                                       glNormal3fv(&g->normals[j * 3]);
                                        glVertex3fv(&g->points[j * 3]);
-                                       v1 = v2;
+                               /*      v1 = v2; */
                                }
                                if (g->closed) {
-                                       VecCross(v3, v1, v0);
+                               /*      VecCross(v3, v1, v0);
                                        if (NormalizeVec(&v3, &v3) == 0)
-                                               glNormal3f(v3.x, v3.y, v3.z);
+                                               glNormal3f(v3.x, v3.y, v3.z); */
+                                       glNormal3fv(g->normals);
                                        glVertex3fv(g->points);
                                }
                                glEnd();

diff --git a/MolLib/Ruby_bind/ruby_bind.c b/MolLib/Ruby_bind/ruby_bind.c
index fdae4fd..327ecbe 100644 (file)
--- a/MolLib/Ruby_bind/ruby_bind.c
+++ b/MolLib/Ruby_bind/ruby_bind.c
@@ -9424,6 +9424,66 @@ s_Molecule_ExportGraphic(int argc, VALUE *argv, VALUE self)
 
 #pragma mark ------ Graphics ------
 
+static void
+s_CalculateGraphicNormals(MainViewGraphic *gp)
+{
+       int i;
+       Vector v1, v2, v3;
+       if (gp == NULL || gp->npoints < 3)
+               return;
+       AssignArray(&gp->normals, &gp->nnormals, sizeof(GLfloat) * 3, gp->npoints - 1, NULL);
+       v1.x = gp->points[3] - gp->points[0];
+       v1.y = gp->points[4] - gp->points[1];
+       v1.z = gp->points[5] - gp->points[2];
+       /*  nv[i] = (v[i-1]-v[0]).cross(v[i]-v[0]) (i=2..n-1)  */
+       for (i = 2; i < gp->npoints; i++) {
+               v2.x = gp->points[i * 3] - gp->points[0];
+               v2.y = gp->points[i * 3 + 1] - gp->points[1];
+               v2.z = gp->points[i * 3 + 2] - gp->points[2];
+               VecCross(v3, v1, v2);
+               NormalizeVec(&v3, &v3);
+               gp->normals[i * 3] = v3.x;
+               gp->normals[i * 3 + 1] = v3.y;
+               gp->normals[i * 3 + 2] = v3.z;
+               v1 = v2;
+       }
+       /*  normals[0] = average of all nv[i] (i=2..n-1)  */
+       VecZero(v1);
+       for (i = 2; i < gp->npoints; i++) {
+               v1.x += gp->normals[i * 3];
+               v1.y += gp->normals[i * 3 + 1];
+               v1.z += gp->normals[i * 3 + 2];
+       }
+       NormalizeVec(&v1, &v1);
+       gp->normals[0] = v1.x;
+       gp->normals[1] = v1.y;
+       gp->normals[2] = v1.z;
+       /*  normals[1] = nv[2].normalize  */
+       v2.x = gp->normals[6];
+       v2.y = gp->normals[7];
+       v2.z = gp->normals[8];
+       NormalizeVec(&v1, &v2);
+       gp->normals[3] = v1.x;
+       gp->normals[4] = v1.y;
+       gp->normals[5] = v1.z;
+       /*  normals[i] = (nv[i] + nv[i+1]).normalize (i=2..n-2)  */
+       for (i = 2; i < gp->npoints; i++) {
+               if (i == gp->npoints - 1)
+                       VecZero(v3);
+               else {
+                       v3.x = gp->normals[i * 3 + 3];
+                       v3.y = gp->normals[i * 3 + 4];
+                       v3.z = gp->normals[i * 3 + 5];
+               }
+               VecInc(v2, v3);
+               NormalizeVec(&v1, &v2);
+               gp->normals[i * 3] = v1.x;
+               gp->normals[i * 3 + 1] = v1.y;
+               gp->normals[i * 3 + 2] = v1.z;
+               v2 = v3;
+       }
+}
+
 /*
  *  call-seq:
  *     insert_graphic(index, kind, color, points, fill = nil) -> integer
@@ -9531,6 +9591,10 @@ s_Molecule_InsertGraphic(int argc, VALUE *argv, VALUE self)
                g.points[6] = g.points[8] = g.points[9] = g.points[10] = 0;
                g.points[7] = g.points[11] = g.points[3];
        }
+       if (g.kind == kMainViewGraphicPoly) {
+               /*  Calculate normals  */
+               s_CalculateGraphicNormals(&g);
+       }
        MainView_insertGraphic(mol->mview, idx, &g);
        
        {
@@ -9772,6 +9836,10 @@ s_Molecule_SetGraphicPoint(int argc, VALUE *argv, VALUE self)
                        gp->points[pindex * 3 + 2] = v.z;
                }
        }
+       if (gp->kind == kMainViewGraphicPoly) {
+               /*  Calculate normals  */
+               s_CalculateGraphicNormals(gp);
+       }
        MolActionCallback_registerUndo(mol, act);
        MolActionRelease(act);          
        MoleculeCallback_notifyModification(mol, 0);