Attachment 34773 Details for Bug 27521 – program triggering the bug (compile with -std=c99)

program triggering the bug (compile with -std=c99)

kmsvbo.c (text/x-csrc), 6.66 KB, created by Wiktor Janas on 2010-04-07 12:04:35 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Wiktor Janas

Created: 2010-04-07 12:04:35 UTC

Size: 6.66 KB

patch

obsolete

>#include <stdlib.h>
>#include <stdio.h>
>#include <string.h>
>
>#define GL_GLEXT_PROTOTYPES
>#include <GL/gl.h>
>#include <GL/glut.h>
>
>// the data for vbos
>static GLuint  idcs[24];  // for silhouette
>static GLfloat verts[108];
>static GLfloat normals[108];
>static int idcs_p, verts_p;
>
>// vbo handles
>static GLuint idcs_vbo, verts_vbo, normals_vbo;
>
>
>/*
> * The following creates cube (hopefully) mimicking the way Blender does.
> * Each of 6 faces is broken into 2 triangles, each triangle has its
> * vertices stored separately in CCW order (Blender uses face culling,
> * although it is not required to reproduce the bug).
> * The silhouette is created from the same vertex data by drawing 12 lines.
> * Each line is given as a pair of indices.
> */
>static void add_square(int perm[3])
>{
>    static GLfloat v[6][3] = {
>        {1,-1,-1},  {-1,-1,-1},  {-1,1,-1},
>        {1,-1,-1},  {-1, 1,-1},  { 1,1,-1},
>    };
>    static GLfloat n[3] = { 0,0,1 };
>
>#define f(j,x) (perm[j] > 0 ? x[perm[j]-1] : -x[-perm[j]-1])
>    for(int i=0; i<6; i++)
>        for(int j=0; j<3; j++) {
>            verts[verts_p]   = f(j,v[i]);
>            normals[verts_p] = f(j,n);
>            verts_p++;
>        }
>#undef f
>}
>
>static void make_cube()
>{
>    { int perm[3]={ 1, 2, 3}; add_square(perm); } // front
>    { int perm[3]={-3, 2, 1}; add_square(perm); } // right
>    { int perm[3]={-1, 2,-3}; add_square(perm); } // back
>    { int perm[3]={ 3, 2,-1}; add_square(perm); } // left
>    { int perm[3]={ 1, 3,-2}; add_square(perm); } // top
>    { int perm[3]={ 1,-3, 2}; add_square(perm); } // bottom
>
>    idcs[idcs_p++] =  0; idcs[idcs_p++] =  1;
>    idcs[idcs_p++] =  1; idcs[idcs_p++] =  2;
>    idcs[idcs_p++] =  2; idcs[idcs_p++] =  5;
>    idcs[idcs_p++] =  5; idcs[idcs_p++] =  0;
>    idcs[idcs_p++] =  0; idcs[idcs_p++] =  9;
>    idcs[idcs_p++] =  9; idcs[idcs_p++] =  11;
>    idcs[idcs_p++] =  11; idcs[idcs_p++] =  5;
>    idcs[idcs_p++] =  9; idcs[idcs_p++] =  12;
>    idcs[idcs_p++] =  12; idcs[idcs_p++] =  17;
>    idcs[idcs_p++] =  17; idcs[idcs_p++] =  16;
>    idcs[idcs_p++] =  17; idcs[idcs_p++] =  2;
>    idcs[idcs_p++] =  12; idcs[idcs_p++] =  1;
>
>    printf("idcs_p=%d, verts_p=%d\n",idcs_p,verts_p);
>}
>
>/*
> * Creates VBO from given data.
> * Blender does this in a more complicated way, but this suffices.
> */
>static GLuint make_vbo(GLenum target, const void *data, int size)
>{
>    GLuint id;
>    glGenBuffersARB(1, &id);
>    glBindBufferARB(target, id);
>    glBufferDataARB(target, size, data, GL_STATIC_DRAW);
>    glBindBufferARB(target, 0);
>    return id;
>}
>
>static void init(void)
>{
>    make_cube();
>    idcs_vbo = make_vbo(GL_ELEMENT_ARRAY_BUFFER, idcs, sizeof(idcs));
>    verts_vbo = make_vbo(GL_ARRAY_BUFFER, verts, sizeof(verts));
>    normals_vbo = make_vbo(GL_ARRAY_BUFFER, normals, sizeof(normals));
>
>    glClearColor(0.0,0.0,0.0,1.0);
>    glEnable(GL_DEPTH_TEST);
>
>    GLfloat ambientcolor[4]={.1,.1,.1,1};
>    GLfloat light0color[4]={.4,.4,.4,1};
>    GLfloat light1color[4]={.4,.4,.4,1};
>    GLfloat light2color[4]={.4,.4,.4,1};
>    glEnable(GL_COLOR_MATERIAL);
>    glLightfv(GL_LIGHT0, GL_DIFFUSE, light0color);
>    glLightfv(GL_LIGHT1, GL_DIFFUSE, light1color);
>    glLightfv(GL_LIGHT2, GL_DIFFUSE, light2color);
>    glLightModelfv(GL_LIGHT_MODEL_AMBIENT,ambientcolor);
>    glEnable(GL_LIGHT0);
>    glEnable(GL_LIGHT1);
>    glEnable(GL_LIGHT2);
>    glEnable(GL_LIGHTING);
>}
>
>static void place_lights(void)
>{
>    GLfloat light0pos[4] = {3,2,5,1};
>    GLfloat light1pos[4] = {-2,-3,0,1};
>    GLfloat light2pos[4] = {-5,3,-4,1};
>    glLightfv(GL_LIGHT0, GL_POSITION, light0pos);
>    glLightfv(GL_LIGHT1, GL_POSITION, light1pos);
>    glLightfv(GL_LIGHT2, GL_POSITION, light2pos);
>}
>
>static void set_wireframe_style(void)
>{
>    glDepthMask(GL_FALSE);
>    glDisable(GL_LIGHTING);
>    glColor3ub(255, 140, 25);
>    glLineWidth(2);
>}
>
>static void set_solid_style(void)
>{
>    glLineWidth(1);
>    glColor3ub(255, 255, 255);
>    glEnable(GL_LIGHTING);
>    glDepthMask(GL_TRUE);
>}
>
>/*
> * The "manual" mode renders the picture correctly.
> * It is expected that vbo mode produces exactly the same picture.
> */
>static void render_manual(void)
>{
>    set_wireframe_style();
>
>    glBegin(GL_LINES);
>    for(int i=0;i<idcs_p;i++)
>        glVertex3fv(verts+3*idcs[i]);
>    glEnd();
>
>    set_solid_style();
>
>    glBegin(GL_TRIANGLES);
>    for(int i=0;i<verts_p;i+=3) {
>        glNormal3fv(normals+i);
>        glVertex3fv(verts+i);
>    }
>    glEnd();
>}
>
>/*
> * The "vbo" mode, which does not work.
> */
>static void render_vbo(void)
>{
>    glBindBufferARB(GL_ARRAY_BUFFER, verts_vbo);
>    glVertexPointer(3, GL_FLOAT, 0, NULL);
>
>    glBindBufferARB(GL_ARRAY_BUFFER, normals_vbo);
>    glNormalPointer(GL_FLOAT, 0, NULL);
>
>    glBindBufferARB(GL_ARRAY_BUFFER, 0);
>
>    set_wireframe_style();
>
>    glEnableClientState(GL_VERTEX_ARRAY);
>
>    glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, idcs_vbo);
>    /**
>     ** the interesting thing: if you comment out glDrawElements call below,
>     ** rendering will be correct (without silhouette obviously). However,
>     ** if the following call is made, glDrawArrays will not render everything
>     ** it should.
>     **/
>    glDrawElements(GL_LINES, idcs_p, GL_UNSIGNED_INT, NULL);
>    glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, 0);
>
>    set_solid_style();
>
>    glEnableClientState(GL_NORMAL_ARRAY);
>
>    glDrawArrays(GL_TRIANGLES, 0, verts_p/3);
>
>    glDisableClientState(GL_VERTEX_ARRAY);
>    glDisableClientState(GL_NORMAL_ARRAY);
>}
>
>static GLfloat theta;
>
>static void render(void)
>{
>    /*
>     * here I have noted that glDepthMask(GL_FALSE) will stop glClear from
>     * clearing the depth buffer. However,
>     * http://www.khronos.org/opengles/documentation/opengles1_0/html/glDepthMask.html
>     * explicitly states "glDepthMask does not affect glClear".
>     */
>    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
>
>    glLoadIdentity();
>    gluLookAt(.5,-2,-3, 0,0,0, 0,-1,0);
>
>    place_lights();
>
>    glPushMatrix();
>    glRotatef(theta,0,1,0);
>    //render_manual(); /* this works */
>    render_vbo(); /* this does not */
>    glPopMatrix();
>
>    glutSwapBuffers();
>}
>
>static void timer(int arg)
>{
>    theta += .25;
>    glutPostRedisplay();
>    glutTimerFunc(20,timer,0);
>}
>
>static void resize(int w, int h)
>{
>    int matrix;
>    glGetIntegerv(GL_MATRIX_MODE, &matrix);
>    glMatrixMode(GL_PROJECTION);
>    glLoadIdentity();
>    glViewport(0,0,w,h);
>    gluPerspective(80.0, (double)w/(double)h, 0.5, 15.0);
>    glMatrixMode(matrix);
>}
>
>int main (int argc, char *argv[])
>{
>    glutInit(&argc, argv);
>    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH|GLUT_ALPHA);
>    glutInitWindowSize(512,512);
>    glutCreateWindow("KMS VBO test");
>
>    glutDisplayFunc(render);
>    glutReshapeFunc(resize);
>    glutTimerFunc(20,timer,0);
>
>    init();
>    resize(512,512);
>
>    glutMainLoop();
>
>    return 0;
>}

Actions: View

Attachments on bug 27521: 34773 | 34774

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.