newave.c

嵌入式GUI OpenGL源代码。OpenGL是嵌入式开发中常用的一种GUI系统。

{
    switch(value) 
    {
        case WEAK  : dt = 0.001; break;
        case NORMAL: dt = 0.004; break;
        case STRONG: dt = 0.008; break;
    }
}

void setDisplay(int value)
{
    displayMode = value;
    switch(value) 
    {
        case WIREFRAME   : 
            glShadeModel(GL_FLAT); 
            glDisable(GL_LIGHTING);
            break;
        case HIDDENLINE: 
            glShadeModel(GL_FLAT); 
            glDisable(GL_LIGHTING);
            break;
        case FLATSHADED  : 
            glShadeModel(GL_FLAT); 
            glEnable(GL_LIGHTING);
            break;
        case SMOOTHSHADED: 
            glShadeModel(GL_SMOOTH); 
            glEnable(GL_LIGHTING);
            break;
        case TEXTURED: 
            glShadeModel(GL_SMOOTH); 
            glEnable(GL_LIGHTING);
            break;
    }
    glutPostRedisplay();
}

void setOther(int value)
{
    switch (value)
    {
        case FULLSCREEN: 
            glutFullScreen();
            break;
        case FACENORMALS: 
            drawFaceNorms = !drawFaceNorms;
            break;
        case ANTIALIAS: 
            antialias = !antialias;
            if (antialias)
            {
                glEnable(GL_BLEND);
                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                glEnable(GL_LINE_SMOOTH);
                glLineWidth(1.5);
            }
            else
            {
                glDisable(GL_BLEND);
                glDisable(GL_LINE_SMOOTH);
                glLineWidth(1.0);
            }
            break;
        case ENVMAP: 
            envMap = !envMap;
            if (envMap)
            {
                glBindTexture(GL_TEXTURE_2D, texId2);
                glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
                glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
                glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
                glEnable(GL_TEXTURE_GEN_S);
                glEnable(GL_TEXTURE_GEN_T);
            }
            else
            {
                glBindTexture(GL_TEXTURE_2D, texId1);
                glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
                glDisable(GL_TEXTURE_GEN_S);
                glDisable(GL_TEXTURE_GEN_T);
            }
            break;
    }
    glutPostRedisplay();
}

void setMain(int value)
{
    switch(value) 
    {
        case 1: edit();    break;
        case 2:    go();      break; /* set idle func to something */
        case 3: stop();    break; /* set idle func to null */
        case 4:    reverse(); break;
        case 5:    exit(0);   break;
    }
}


void drawFaceNormals(void)
{
    glColor3f(1.0,1.0,1.0);
    for (i = 0; i < grid - 1; ++i)
    {
        for (j = 0; j < grid - 1; ++j)
        {
            glBegin(GL_LINES);
            glVertex3fv(faceNormSegs[0][0][i][j]);
            glVertex3fv(faceNormSegs[0][1][i][j]);
            glEnd();

            glBegin(GL_LINES);
            glVertex3fv(faceNormSegs[1][0][i][j]);
            glVertex3fv(faceNormSegs[1][1][i][j]);
            glEnd();
        }
    }
}

void drawSmoothShaded(void)
{
    glColor3f(0.8f, 0.2f, 0.8f);
    for (i = 0; i < grid - 1; ++i)
    {
        glBegin(GL_TRIANGLE_STRIP);
        for (j = 0; j < grid; ++j)
        {
            glNormal3fv( vertNorms[i][j] );
            glVertex3f( i, j, posit[i][j] );
            glNormal3fv( vertNorms[i+1][j] );
            glVertex3f( i+1, j, posit[i+1][j] );
        }
        glEnd();
    }
}

void drawWireframe(void)
{
    glColor3f(1.0, 1.0, 1.0);

    for(i=0;i<grid;i++)
    {
        glBegin(GL_LINE_STRIP);
        for(j=0;j<grid;j++)
            glVertex3f( (float) i, (float) j, (float) posit[i][j]);
        glEnd();
    }
    
    for(i=0;i<grid;i++)
    {
        glBegin(GL_LINE_STRIP);
        for(j=0;j<grid;j++)
            glVertex3f( (float) j, (float) i, (float) posit[j][i]);
        glEnd();
    }
}

void drawFlatShaded(void)
{
    glEnable(GL_POLYGON_OFFSET_FILL);
    glColor3f(0.8f, 0.2f, 0.8f);
    for (i = 0; i < grid - 1; ++i)
    {
        glBegin(GL_TRIANGLE_STRIP);
        glVertex3f( (float) i, (float) 0, (float) posit[i][0]);
        glVertex3f( (float) i+1, (float) 0, (float) posit[i+1][0]);
        for (j = 1; j < grid; ++j)
        {
            glNormal3fv( faceNorms[0][i][j-1] );
            glVertex3f( (float) i, (float) j, (float) posit[i][j]);
              glNormal3fv( faceNorms[1][i][j-1] );
            glVertex3f( (float) i+1, (float) j, (float) posit[i+1][j]);
        }
        glEnd();
    }
    glDisable(GL_POLYGON_OFFSET_FILL);
}

void drawHiddenLine(void)
{
    glEnable(GL_POLYGON_OFFSET_FILL);
    glColor3f(0.8f, 0.2f, 0.8f);
    for (i = 0; i < grid - 1; ++i)
    {
        glBegin(GL_TRIANGLE_STRIP);
        glVertex3f( (float) i, (float) 0, (float) posit[i][0]);
        glVertex3f( (float) i+1, (float) 0, (float) posit[i+1][0]);
        for (j = 1; j < grid; ++j)
        {
            glVertex3f( (float) i, (float) j, (float) posit[i][j]);
            glVertex3f( (float) i+1, (float) j, (float) posit[i+1][j]);
        }
        glEnd();
    }    
    glDisable(GL_POLYGON_OFFSET_FILL);
    
    glColor3f(1.0,1.0,1.0);
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    for (i = 0; i < grid - 1; ++i)
    {
        glBegin(GL_TRIANGLE_STRIP);
        glVertex3f( (float) i, (float) 0, (float) posit[i][0]);
        glVertex3f( (float) i+1, (float) 0, (float) posit[i+1][0]);
        for (j = 1; j < grid; ++j)
        {
            glVertex3f( (float) i, (float) j, (float) posit[i][j]);
            glVertex3f( (float) i+1, (float) j, (float) posit[i+1][j]);
        }
        glEnd();
    }    
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}

void loadImageTexture(void)
{

    glGenTextures(1,&texId1);
    glBindTexture(GL_TEXTURE_2D, texId1);
    imgLoad(texFilename1, 0, 0, &texWidth, &texHeight, &texData);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, 4, 
        texWidth, texHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE,
        texData );

    glGenTextures(1,&texId2);
    glBindTexture(GL_TEXTURE_2D, texId2);
    imgLoad(texFilename2, 0, 0, &texWidth, &texHeight, &texData);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, 4, 
        texWidth, texHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE,
        texData );
}

void drawTextured(void)
{
    glColor3f(1.0f, 1.0f, 1.0f);
    glEnable(GL_TEXTURE_2D);
    for (i = 0; i < grid - 1; ++i)
    {
        glBegin(GL_TRIANGLE_STRIP);
        for (j = 0; j < grid; ++j)
        {
            glNormal3fv( vertNorms[i][j] );
            glTexCoord2fv( texCoords[i][j] );
            glVertex3f( i, j, posit[i][j] );
            glNormal3fv( vertNorms[i+1][j] );
            glTexCoord2fv( texCoords[i+1][j] );
            glVertex3f( i+1, j, posit[i+1][j] );
        }
        glEnd();
    }
    glDisable(GL_TEXTURE_2D);
}


void reshape(int width, int height)
{
    xsize = width; 
    ysize = height;
    aspect = (float)xsize/(float)ysize;
    glViewport(0, 0, xsize, ysize);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glutPostRedisplay();
}

void display(void) 
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(64.0, aspect, zNear, zFar);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity(); 

    glTranslatef(0.0,0.0,-sdepth);
    glRotatef(-stheta, 1.0, 0.0, 0.0);
    glRotatef(sphi, 0.0, 0.0, 1.0);
    glTranslatef(-(float)((grid+1)/2-1), -(float)((grid+1)/2-1), 0.0);

      getFaceNorms();
    getVertNorms();

    switch (displayMode) 
    {
        case WIREFRAME: drawWireframe(); break;
        case HIDDENLINE: drawHiddenLine(); break;
        case FLATSHADED: drawFlatShaded(); break;
        case SMOOTHSHADED: drawSmoothShaded(); break;
        case TEXTURED: drawTextured(); break;
    }

    if (drawFaceNorms)    
    {
        getFaceNormSegs();
        drawFaceNormals();
    }

    glutSwapBuffers();
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}

void visibility(int state)
{
    if ((state == GLUT_VISIBLE) && waving)
        go();
    else 
        stop();
}

void motion(int x, int y)
{
    if (leftButton)
    {
        sphi += (float)(x - downX) / 4.0;
        stheta += (float)(downY - y) / 4.0;
    }
    if (middleButton)
    {
        sdepth += (float)(downY - y) / 10.0;
    }
    downX = x;
    downY = y;
    glutPostRedisplay();
}


void mouse(int button, int state, int x, int y)
{
    downX = x;
    downY = y;
    leftButton = ((button == GLUT_LEFT_BUTTON) && 
                  (state == GLUT_DOWN));
    middleButton = ((button == GLUT_MIDDLE_BUTTON) && 
                    (state == GLUT_DOWN));
}

void keyboard(unsigned char ch, int x, int y)
{
    switch (ch) 
    {
        case '+': sdepth += 2.0; break;
        case '-': sdepth -= 2.0; break;
        case 27: exit(0); break;
    }
    glutPostRedisplay();
}

int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(500, 500);
    glutCreateWindow("Newave");
    if (argc > 1 && argv[1] != 0)
        texFilename1 = argv[1];
    if (argc > 2 && argv[2] != 0)
        texFilename2 = argv[2];
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glPolygonOffset(1.0, 1.0);
    glEnable(GL_CULL_FACE);
    glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
    glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
    glEnable(GL_COLOR_MATERIAL);
    glColorMaterial(GL_FRONT, GL_DIFFUSE);
    glLightfv (GL_LIGHT0, GL_POSITION, lightPosition);
    glEnable(GL_LIGHT0);
    loadImageTexture();

    setSize(MEDIUM);
    setSpeed(NORMAL);
    setDisplay(TEXTURED);
    setOther(ENVMAP);
    reset(HILLFOUR);

    glutReshapeFunc(reshape);
    glutDisplayFunc(display);
    glutVisibilityFunc(visibility);

    glutKeyboardFunc(keyboard);
    glutMouseFunc(mouse);
    glutMotionFunc(motion);

    displayMenu = glutCreateMenu(setDisplay);
    glutAddMenuEntry("Wireframe", WIREFRAME);
    glutAddMenuEntry("Hidden Line", HIDDENLINE);
    glutAddMenuEntry("Flat Shaded", FLATSHADED);
    glutAddMenuEntry("Smooth Shaded", SMOOTHSHADED);
    glutAddMenuEntry("Textured", TEXTURED);

    otherMenu = glutCreateMenu(setOther);
    glutAddMenuEntry("Full Screen", FULLSCREEN);
    glutAddMenuEntry("Face Normals", FACENORMALS);
    glutAddMenuEntry("Antialias", ANTIALIAS);
    glutAddMenuEntry("Environment Map", ENVMAP);

    speedMenu = glutCreateMenu(setSpeed);
    glutAddMenuEntry("Weak", WEAK);
    glutAddMenuEntry("Normal", NORMAL);
    glutAddMenuEntry("Strong", STRONG);

    sizeMenu = glutCreateMenu(setSize);
    glutAddMenuEntry("Small", SMALL);
    glutAddMenuEntry("Medium", MEDIUM);
    glutAddMenuEntry("Large", LARGE);
    glutAddMenuEntry("Extra Large", XLARGE);

    resetMenu = glutCreateMenu(reset);
    glutAddMenuEntry("Current", CURRENT);
    glutAddMenuEntry("Spike", SPIKE);
    glutAddMenuEntry("Hole", HOLE);
    glutAddMenuEntry("Diagonal Wall", DIAGONALWALL);
    glutAddMenuEntry("Side Wall", SIDEWALL);
    glutAddMenuEntry("Middle Block", MIDDLEBLOCK);
    glutAddMenuEntry("Diagonal Block", DIAGONALBLOCK);
    glutAddMenuEntry("Corner Block", CORNERBLOCK);
    glutAddMenuEntry("Hill", HILL);
    glutAddMenuEntry("Hill Four", HILLFOUR);

    mainMenu = glutCreateMenu(setMain);
    glutAddMenuEntry("Go", 2);
    glutAddMenuEntry("Stop", 3);
    glutAddMenuEntry("Reverse", 4);
    glutAddSubMenu("Display", displayMenu);
    glutAddSubMenu("Reset", resetMenu);
    glutAddSubMenu("Size", sizeMenu);
    glutAddSubMenu("Speed", speedMenu);
    glutAddSubMenu("Other", otherMenu);
    glutAddMenuEntry("Exit", 5);
    glutAttachMenu(GLUT_RIGHT_BUTTON);

    glutMainLoop();
    return 0;             /* ANSI C requires main to return int. */
}