Question

以下程序使用normalize函数将四面体转换为半球形。但是在normalize函数中没有调用OpenGL函数。只更改少数变量的值，甚至不传递给其他函数。这个函数如何正常化？

    #include<stdio.h>
    #include<GL/glut.h>
    #include<math.h>
    GLfloat v[4][3]={{0.0,0.0,1.0},{0.0,1.0,0.0},{-1.0,-0.5,0.0},{1.0,-0.5,0.0}};
    int n;
    GLfloat theta[3]={0,0,0};
    int axis=2;

    void normalize(GLfloat *pt)
    {
        double d=0;
        int i;
        for(i=0;i<3;i++)
            d+=pt[i]*pt[i];
        d=sqrt(d);
        if(d>0)
            for(i=0;i<3;i++)
                pt[i]/=d;
    }
    void triangle(GLfloat* a,GLfloat* b,GLfloat* c)
    {
    //  glBegin(GL_POLYGON);
        glBegin(GL_LINE_LOOP);
         glVertex3fv(a);
         glVertex3fv(b);
         glVertex3fv(c);
        glEnd( );
    }

    void divide_triangle(GLfloat* a,GLfloat* b,GLfloat* c,int m)
    {
        GLfloat v1[3],v2[3],v3[3];
        int j;

        if(m>0)
        {
            for(j=0;j<3;j++)
            {
                v1[j]=(a[j]+b[j])/2;
                v2[j]=(a[j]+c[j])/2;
                v3[j]=(c[j]+b[j])/2;
            }

            normalize(v1);         // normalize function called from here
            normalize(v2);
            normalize(v3);

            divide_triangle(a,v1,v2,m-1);
            divide_triangle(c,v2,v3,m-1);
            divide_triangle(b,v3,v1,m-1);
            divide_triangle(v1,v2,v3,m-1);
        }
        else
            triangle(a,b,c);
    }

    void tetrahedron(int m)
    {
    //  glColor3f(0,1,0);                       // green
    //  divide_triangle(v[3],v[2],v[1],m);                      // bottom face of semi-sphere
        glColor3f(1,0,0);                       // red
        divide_triangle(v[0],v[1],v[2],m);
        glColor3f(0,0,1);                       // blue
        divide_triangle(v[0],v[3],v[1],m);
        glColor3f(0,0,0);                       // black
        divide_triangle(v[0],v[2],v[3],m);
    }
    void spin()
    {
        theta[axis]=theta[axis]+0.05;
        if(theta[axis]>0.06)
            theta[axis]=0;
        glutPostRedisplay();
    }
    void mouse(int btn,int state, int x,int y)
    {
        if(btn==GLUT_LEFT_BUTTON&&state==GLUT_DOWN)
            axis=0;
        if(btn==GLUT_RIGHT_BUTTON&&state==GLUT_DOWN)
            axis=1;
        if(btn==GLUT_MIDDLE_BUTTON&&state==GLUT_DOWN)
            axis=2;
    }

    void display()
    {
        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
        glEnable(GL_DEPTH_TEST);
        glRotatef(theta[0],1,0,0);   // x-axis spin
        glRotatef(theta[1],0,1,0);   // y-axis spin
        glRotatef(theta[2],0,0,1);   // z-axis spin

        tetrahedron(n);
        glFlush( );
    }

    void myinit( )
    {
        glClearColor(1,1,1,1);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity( );
        glOrtho(-2,2,-2,2,-2,2);
        glMatrixMode(GL_MODELVIEW);
    }

    void main()
    {
        printf("No of divisions : ");
        scanf("%d",&n);
        glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);
        glutInitWindowSize(500,500);
        glutCreateWindow("3D SEMI SPHERE APPROXIMATION BY SIERPINSKI GASKET ");
        glutDisplayFunc(display);
        glutIdleFunc(spin);
        glutMouseFunc(mouse);
        myinit( );
        glutMainLoop( );
    }

Answer 1

程序有自己的规范化功能。通过找到每个边缘的中点，将每个三角形面递归地划分为四个相等大小的较小三角形。这些中点位于球体表面的错误位置，因此标准化函数用于将每个插值点的半径与球体中心的半径与现有点的半径相等。递归越深，它就越接近球体。

我不知道为什么你发现normalize功能是个谜。缩放三个组件以使其大小为1（除非所有组件均为0）是完全正常的（借口双关语）方法。

递归函数divide_triangle将每个子三角形传递给最后一行triangle(a,b,c);中的openGL，这是达到递归深度限制的时间。在该深度之下，三角形被分开。在那个深度，它们被传递给图形引擎。

在球近似程序

1 个答案: