Attachment 31092 Details for Bug 6098 – Testcase

Testcase

bug6098.c (text/x-csrc), 8.44 KB, created by Thomas Zimmermann on 2009-11-10 07:55:13 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Thomas Zimmermann

Created: 2009-11-10 07:55:13 UTC

Size: 8.44 KB

patch

obsolete

>
>/*
> * Test case for "http://bugs.freedesktop.org/show_bug.cgi?id=6098"
> *
> * This code is public domain.
> */
>
>/*
> * Compile with:
> *
> *    gcc -lglut -lX11 -lGL  bug6098.c
> *
> * Viewing:
> *
> *   Move mouse and hold down the left or right mouse buttons.
> *
> * Setup:
> *
> *   F1 : switch between negative/positive z-values (default: negative)
> *   F2 : switch between CCW and CW face orientation (default: CCW)
> *   F3 : enable/disable backface culling (default: disabled)
> *
> * The white point at (0,10,0) is the point-light source. The quad on the
> * right is a reference in CCW with upwards-facing normal. The quad on the
> * left is drawn via the evaluator mechanism. It is meant to be in CCW order,
> * but lighting seems like for CW.
> *
> * For example: at the beginning press F3 to enable backface culling. This
> * indicates the generated normals are pointing upwards (towards the
> * lightsource); but lighting looks dark, like for a backface.
> *
> * However, the results look correct if z runs towards positive infinity and
> * CW order is selected. Switching to negative z-values with CCW should result
> * in correct results as well.
> */
>
>#include <stdio.h>
>#include <stdlib.h>
>#include <GL/glut.h>
>
>static const GLfloat g_points[][48] = {{0,0, 0,  1,0, 0,  2,0, 0,  3,0, 0,
>                                        0,0, 1,  1,0, 1,  2,0, 1,  3,0, 1,
>                                        0,0, 2,  1,0, 2,  2,0, 2,  3,0, 2,
>                                        0,0, 3,  1,0, 3,  2,0, 3,  3,0, 3},
>                                       {0,0,-0,  1,0,-0,  2,0,-0,  3,0,-0,
>                                        0,0,-1,  1,0,-1,  2,0,-1,  3,0,-1,
>                                        0,0,-2,  1,0,-2,  2,0,-2,  3,0,-2,
>                                        0,0,-3,  1,0,-3,  2,0,-3,  3,0,-3}};
>
>/*
>static const GLfloat g_points[][48] = {{0,0, 0,  1,1, 0,  2,2, 0,  3,3, 0,
>                                        0,3, 1,  1,2, 1,  2,1, 1,  3,0, 1,
>                                        0,0, 2,  1,1, 2,  2,2, 2,  3,3, 2,
>                                        0,3, 3,  1,2, 3,  2,1, 3,  3,0, 3},
>                                       {0,0,-0,  1,1,-0,  2,2,-0,  3,3,-0,
>                                        0,3,-1,  1,2,-1,  2,1,-1,  3,0,-1,
>                                        0,0,-2,  1,1,-2,  2,2,-2,  3,3,-2,
>                                        0,3,-3,  1,2,-3,  2,1,-3,  3,0,-3}};
>*/
>
>static const GLfloat g_udim = 4;
>static const GLfloat g_uspc = 4;
>static const GLfloat g_vdim = 4;
>static const GLfloat g_vspc = 4;
>static       GLenum  g_orient = GL_CCW;
>static       int     g_cullb = 0;
>static const int     g_gennorm = 1;
>static       int     g_negz = 1;
>
>
>static GLfloat g_pov[] = {10, 0, 0}; /* spherical coordinate */
>
>static int g_button[2] = {0, 0};
>
>static void
>glut_mouse(int button, int state, int x, int y)
>{
>        static int old_x = 0;
>        static int old_y = 0;
>
>        if (button==GLUT_LEFT_BUTTON) {
>                g_button[0] = state==GLUT_DOWN;
>        }
>        if (button==GLUT_RIGHT_BUTTON) {
>                g_button[1] = state==GLUT_DOWN;
>        }
>
>        old_x = x;
>        old_y = y;
>}
>
>static void
>glut_passivemotion(int x, int y)
>{
>        static int old_x = 0;
>        static int old_y = 0;
>
>        if (g_button[0]) {
>                g_pov[0] += ((float)y-old_y) / 5;
>                glutPostRedisplay();
>        }
>        if (g_button[1]) {
>                g_pov[1] += ((float)old_x-x) / 5;
>                g_pov[2] += ((float)old_y-y) / 5;
>                glutPostRedisplay();
>        }
>
>        old_x = x;
>        old_y = y;
>}
>
>static void
>glut_special(int key, int x, int y)
>{
>        switch (key) {
>        case GLUT_KEY_F1:
>                g_negz = !g_negz;
>                if (g_negz) {
>                        printf("z is negative\n");
>                } else {
>                        printf("z positive\n");
>                }
>                glutPostRedisplay();
>                break;
>        case GLUT_KEY_F2:
>                if (g_orient == GL_CCW) {
>                        g_orient = GL_CW;
>                        printf("CW orientation\n");
>                } else {
>                        g_orient = GL_CCW;
>                        printf("CCW orientation\n");
>                }
>                glutPostRedisplay();
>                break;
>        case GLUT_KEY_F3:
>                g_cullb = !g_cullb;
>                if (g_cullb) {
>                        printf("cull backfaces\n");
>                } else {
>                        printf("dont call backfaces\n");
>                }
>                glutPostRedisplay();
>                break;
>        default:
>                break;
>        }
>}
>
>static void
>glut_reshape(int width, int height)
>{
>        glClearColor(0.5, 0.5, 0.5, 0);
>        glViewport(0, 0, width, height);
>}
>
>static void
>glut_display(void)
>{
>        GLenum err;
>
>        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
>
>        glPushAttrib(GL_ALL_ATTRIB_BITS);
>
>        glEnable(GL_DEPTH_TEST);
>
>        /* Setup lights
>         */
>
>        GLfloat light0_pos[] = { 0, 10, 0, 1};
>        GLfloat light0_col[] = { 1,  0, 0, 1};
>
>        glLightfv(GL_LIGHT0, GL_POSITION,    light0_pos);
>        glLightf( GL_LIGHT0, GL_SPOT_CUTOFF, 180);
>        glLightfv(GL_LIGHT0, GL_DIFFUSE,     light0_col);
>        glEnable(GL_LIGHT0);
>
>        glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
>        glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,     GL_TRUE);
>
>        /* Setup view
>         */
>
>        glMatrixMode(GL_PROJECTION);
>        glPushMatrix();
>        glFrustum(-0.12, 0.12, -0.09, 0.09, 0.1, 1024.0-0.1);
>
>        glMatrixMode(GL_MODELVIEW);
>        glPushMatrix();
>        glTranslatef(0, 0, -g_pov[0]);
>        glRotatef(-g_pov[2], 1, 0, 0);
>        glRotatef(-g_pov[1], 0, 1, 0);
>
>        /* Draw light positions
>         */
>
>        glPointSize(3);
>        glBegin(GL_POINTS);
>                glColor3f(1, 1, 1);
>                glVertex4fv(light0_pos);
>        glEnd();
>
>        /* Draw coordinate system
>         */
>
>        glBegin(GL_LINES);
>                glColor3f(1, 0, 0);
>                glVertex3f(0, 0, 0);
>                glVertex3f(5, 0, 0);
>                glColor3f(0, 1, 0);
>                glVertex3f(0, 0, 0);
>                glVertex3f(0, 5, 0);
>                glColor3f(0, 0, 1);
>                glVertex3f(0, 0, 0);
>                glVertex3f(0, 0, 5);
>        glEnd();
>
>        /* Setup geometry
>         */
>
>        glEnable(GL_LIGHTING);
>
>        glFrontFace(g_orient);
>
>        if (g_cullb) {
>                glCullFace(GL_BACK);
>                glEnable(GL_CULL_FACE);
>        } else {
>                glDisable(GL_CULL_FACE);
>        }
>
>        glMap2f(GL_MAP2_VERTEX_3, 0.0f, 1.0f, 3*g_vdim, g_udim,
>                                  0.0f, 1.0f, 3,        g_vdim,
>                                                        g_points[g_negz]);
>
>        glEnable(GL_MAP2_VERTEX_3);
>
>        glEnable(GL_AUTO_NORMAL);
>
>        glMapGrid2f(g_vspc*g_vdim, 0, 1, g_vspc*g_udim, 0, 1);
>
>        glMatrixMode(GL_MODELVIEW);
>        glPushMatrix();
>
>        if (g_negz) {
>                glTranslatef(-1.5, -1.5, 1.5);
>        } else {
>                glTranslatef(-1.5, -1.5, -1.5);
>        }
>        glEvalMesh2(GL_FILL, 0, g_vspc*g_udim, 0, g_vspc*g_vdim);
>
>        /* Draw quad as reference
>         */
>        glFrontFace(GL_CCW);
>        glBegin(GL_QUADS);
>                glNormal3f(0, 1, 0);
>                glVertex3f(3, 0,  0);
>                glVertex3f(6, 0,  0);
>                glVertex3f(6, 0, -3);
>                glVertex3f(3, 0, -3);
>        glEnd();
>
>        glMatrixMode(GL_MODELVIEW);
>        glPopMatrix();
>
>        /* Cleanup
>         */
>
>        glMatrixMode(GL_MODELVIEW);
>        glPopMatrix();
>
>        glMatrixMode(GL_PROJECTION);
>        glPopMatrix();
>
>        glPopAttrib();
>
>        if ((err = glGetError()) != GL_NONE) {
>                fprintf(stderr, "GL error: %s\n", gluErrorString(err));
>        }
>
>        glutSwapBuffers();
>}
>
>
>int
>main(int argc, char **argv)
>{
>        int w;
>
>        glutInit(&argc, argv);
>
>        glutInitDisplayMode(GLUT_DEPTH|GLUT_DOUBLE|GLUT_RGBA);
>        glutInitWindowSize(640, 480);
>
>        w = glutCreateWindow("http://bugs.freedesktop.org/show_bug.cgi?id=6098");
>
>        if (!w) {
>                exit(EXIT_FAILURE);
>        }
>
>        glutReshapeFunc(glut_reshape);
>        glutDisplayFunc(glut_display);
>        glutMouseFunc(glut_mouse);
>        glutMotionFunc(glut_passivemotion);
>        glutPassiveMotionFunc(glut_passivemotion);
>        glutSpecialFunc(glut_special);
>
>        glutMainLoop();
>
>        exit(EXIT_SUCCESS);
>}

Actions: View

Attachments on bug 6098: 31092

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.