Attachment 49179 Details for Bug 39285 – Test program

Test program

saa.c (text/x-csrc), 16.61 KB, created by Ruslan Kabatsayev on 2011-07-16 10:41:04 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Ruslan Kabatsayev

Created: 2011-07-16 10:41:04 UTC

Size: 16.61 KB

patch

obsolete

>#include <GL/gl.h>
>#include <GL/glu.h>
>#include <stdlib.h>
>#include <string.h>
>#include <stdio.h>
>#include <math.h>
>#include <GL/glut.h>
>#define PI_ 3.14159265358979323846
>
>void glBindFramebufferEXT(GLenum target, GLuint framebuffer);
>void glDeleteFramebuffersEXT(GLsizei n,GLuint* framebuffers);
>void glGenFramebuffersEXT(GLsizei n,GLuint* ids);
>GLenum glCheckFramebufferStatusEXT(GLenum target);
>GLsync glFramebufferRenderbufferEXT(GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer);
>void glDeleteRenderbuffersEXT(GLsizei n,GLuint* renderbuffers);
>void glGenRenderbuffersEXT(GLsizei n,GLuint* renderbuffers);
>void glBindRenderbufferEXT(GLenum target,GLuint renderbuffer);
>void glRenderbufferStorageEXT(GLenum target,GLenum internalformat,GLsizei width,GLsizei height);
>void glFramebufferTexture2DEXT(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level);
>
>#define true 1
>#define false 0
>
>#define objectsDefinition 16
>
>int texW=0;
>int texH=0;
>int windowW=0;
>int windowH=0;
>
>int ACSIZE=4;
>
>int startTime=-1;
>int endTime=-1;
>int frameNumber=0;
>
>double angle=0;
>
>GLuint displayObjectsList=0;
>GLuint fboName=0;
>GLuint renderBuffer=0;
>GLuint textureID=0;
>
>GLboolean intelWorkaround=false;
>GLboolean useFramebuffer=false;
>GLboolean npotSupport=true;
>GLboolean fboSupport=true;
>GLboolean rotate=true;
>GLboolean useAccum=false;
>
>typedef struct _jitter
>{
>    double x;
>    double y;
>}JITTER;
>
>JITTER j_1[1]={{0.5,0.5}};
>JITTER j2[2]={{0.25, 0.75}, {0.75, 0.25}};
>JITTER j3[3]={{0.5033922635, 0.8317967229}, 
>            {0.7806016275, 0.2504380877},
>            {0.2261828938, 0.4131553612}};
>JITTER j4[4]={{0.375, 0.25}, 
>            {0.125, 0.75},
>            {0.875, 0.25},
>            {0.625, 0.75}};
>JITTER j5[5]={{0.5, 0.5},
>            {0.3, 0.1},
>            {0.7, 0.9},
>            {0.9, 0.3},
>            {0.1, 0.7}};
>JITTER j6[6]={{0.4646464646, 0.4646464646},
>            {0.1313131313, 0.7979797979},
>            {0.5353535353, 0.8686868686},
>            {0.8686868686, 0.5353535353},
>            {0.7979797979, 0.1313131313},
>            {0.2020202020, 0.2020202020}};
>JITTER j8[8]={{0.5625, 0.4375},
>            {0.0625, 0.9375},
>            {0.3125, 0.6875},
>            {0.6875, 0.8125},
>            {0.8125, 0.1875},
>            {0.9375, 0.5625},
>            {0.4375, 0.0625},
>            {0.1875, 0.3125}};
>JITTER j9[9]={{0.5, 0.5},
>            {0.1666666666, 0.9444444444},
>            {0.5, 0.1666666666},
>            {0.5, 0.8333333333},
>            {0.1666666666, 0.2777777777},
>            {0.8333333333, 0.3888888888},
>            {0.1666666666, 0.6111111111},
>            {0.8333333333, 0.7222222222},
>            {0.8333333333, 0.0555555555}};
>JITTER j12[12]={{0.4166666666, 0.625},
>            {0.9166666666, 0.875},
>            {0.25, 0.375},
>            {0.4166666666, 0.125},
>            {0.75, 0.125},
>            {0.0833333333, 0.125},
>            {0.75, 0.625},
>            {0.25, 0.875},
>            {0.5833333333, 0.375},
>            {0.9166666666, 0.375},
>            {0.0833333333, 0.625},
>            {0.583333333, 0.875}};
>JITTER j16[16]={{0.375, 0.4375},
>            {0.625, 0.0625},
>            {0.875, 0.1875},
>            {0.125, 0.0625},
>            {0.375, 0.6875},
>            {0.875, 0.4375},
>            {0.625, 0.5625},
>            {0.375, 0.9375},
>            {0.625, 0.3125},
>            {0.125, 0.5625},
>            {0.125, 0.8125},
>            {0.375, 0.1875},
>            {0.875, 0.9375},
>            {0.875, 0.6875},
>            {0.125, 0.3125},
>            {0.625, 0.8125}};
>JITTER* j=j4;
>
>// Antialiasing-only version of RedBook-introduced function (no support for blur etc.)
>void accFrustum(GLdouble left, GLdouble right, GLdouble bottom,
>    GLdouble top, GLdouble near, GLdouble far, GLdouble pixdx, 
>    GLdouble pixdy)
>{
>    GLdouble xwsize, ywsize; 
>    GLdouble dx, dy;
>    GLint viewport[4];
>
>    glGetIntegerv (GL_VIEWPORT, viewport);
>
>    xwsize = right - left;
>    ywsize = top - bottom;
>    dx = -(pixdx*xwsize/(GLdouble) viewport[2]);
>    dy = -(pixdy*ywsize/(GLdouble) viewport[3]);
>
>    glMatrixMode(GL_PROJECTION);
>    glLoadIdentity();
>    glFrustum (left + dx, right + dx, bottom + dy, top + dy, 
>        near, far);
>}
>
>// Antialiasing-only version of RedBook-introduced function (no support for blur etc.)
>void accPerspective(GLdouble fovy, GLdouble aspect, 
>    GLdouble near, GLdouble far, GLdouble pixdx, GLdouble pixdy)
>{
>    GLdouble fov2,left,right,bottom,top;
>    fov2 = ((fovy*PI_) / 180.0) / 2.0;
>
>    top = near / (cos(fov2) / sin(fov2));
>    bottom = -top;
>    right = top * aspect;
>    left = -right;
>
>    accFrustum(left, right, bottom, top, near, far,
>        pixdx, pixdy);
>}
>
>
>void renderObjects()
>{
>    GLfloat torus_diffuse[] = { 0.7, 0.7, 0.0, 1.0 };
>    GLfloat cube_diffuse[] = { 0.0, 0.7, 0.7, 1.0 };
>    GLfloat sphere_diffuse[] = { 0.7, 0.0, 0.7, 1.0 };
>    GLfloat octa_diffuse[] = { 0.7, 0.4, 0.4, 1.0 };
>    
>    glPushMatrix ();
>    glTranslatef (0.0, 0.0, -5.0); 
>    glRotatef (30.0, 1.0, 0.0, 0.0);
>
>    glPushMatrix ();
>    glTranslatef (-0.80, 0.35, 0.0); 
>    glRotatef (100.0, 1.0, 0.0, 0.0);
>    glMaterialfv(GL_FRONT, GL_DIFFUSE, torus_diffuse);
>    glutSolidTorus (0.275, 0.85, objectsDefinition, objectsDefinition);
>    glPopMatrix ();
>
>    glPushMatrix ();
>    glTranslatef (-0.75, -0.50, 0.0); 
>    glRotatef (45.0, 0.0, 0.0, 1.0);
>    glRotatef (45.0, 1.0, 0.0, 0.0);
>    glMaterialfv(GL_FRONT, GL_DIFFUSE, cube_diffuse);
>    glutSolidCube (1.5);
>    glPopMatrix ();
>
>    glPushMatrix ();
>    glTranslatef (0.75, 0.60, 0.0); 
>    glRotatef (30.0, 1.0, 0.0, 0.0);
>    glMaterialfv(GL_FRONT, GL_DIFFUSE, sphere_diffuse);
>    glutSolidSphere (1.0, objectsDefinition, objectsDefinition);
>    glPopMatrix ();
>
>    glPushMatrix ();
>    glTranslatef (0.70, -0.90, 0.25); 
>    glMaterialfv(GL_FRONT, GL_DIFFUSE, octa_diffuse);
>    glutSolidOctahedron ();
>    glPopMatrix ();
>
>    glPopMatrix ();
>}
>
>void init(void)
>{
>    const char* extensions=(char*)glGetString(GL_EXTENSIONS);
>    if(strstr(extensions,"GL_EXT_framebuffer_object")==0)
>    {
>        fprintf(stderr,"FBO is unsupported. Disabling FBO usage.\n");
>        fboSupport=false;
>        useFramebuffer=false;
>        useAccum=true;
>    }
>    if(strstr(extensions,"GL_ARB_texture_non_power_of_two")==0)
>    {
>        fprintf(stderr,"Non power of 2 textures are unsupported. Using power of two.\n");
>        npotSupport=false;
>    }
>    GLfloat mat_ambient[] = { 1.0, 1.0, 1.0, 1.0 };
>    GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
>    GLfloat light_position[] = { 0.0, 0.0, 10.0, 1.0 };
>    GLfloat lm_ambient[] = { 0.2, 0.2, 0.2, 1.0 };
>
>    glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
>    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
>    glMaterialf(GL_FRONT, GL_SHININESS, 50.0);
>    glLightfv(GL_LIGHT0, GL_POSITION, light_position);
>    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lm_ambient);
>    
>    glEnable(GL_LIGHTING);
>    glEnable(GL_LIGHT0);
>    glEnable(GL_DEPTH_TEST);
>    glShadeModel (GL_FLAT);
>
>    glClearColor(0.0, 0.0, 0.0, 0.0);
>    glClearAccum(0.0, 0.0, 0.0, 0.0);
>
>    displayObjectsList=glGenLists(1);
>    glNewList(displayObjectsList,GL_COMPILE);
>    renderObjects();
>    glEndList();
>}
>
>void displayObjects(void) 
>{
>    glMatrixMode(GL_MODELVIEW);
>    glPushMatrix ();
>    glTranslatef(0.0,0.0,-5.0);
>    glRotatef(angle,0,1.0,0.0);
>    glTranslatef(0.0,0.0,5.0);
>
>    glCallList(displayObjectsList);
>
>    glPopMatrix ();
>}
>
>void renderTexture(int jitter)
>{
>    GLfloat currentAlpha=(1.)/(1+jitter);
>
>    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);
>    if(jitter==0)
>    {
>        glClearColor(0.4,0,0,1);
>        glClear(GL_COLOR_BUFFER_BIT);
>        glClearColor(0,0,0,1);
>    }
>
>    glMatrixMode(GL_PROJECTION);
>    glPushMatrix();
>    glLoadIdentity();
>    glOrtho(0,1,0,1,0,1);
>    glMatrixMode(GL_MODELVIEW);
>    glPushMatrix();
>    glLoadIdentity();
>    glBindTexture(GL_TEXTURE_2D,textureID);
>    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
>
>    glEnable(GL_TEXTURE_2D);
>    glDisable(GL_LIGHTING);
>    glDisable(GL_CULL_FACE);
>    glDisable(GL_DEPTH_TEST);
>    glEnable(GL_BLEND);
>
>    glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE);
>
>    GLfloat texCoordW=1,texCoordH=1;
>    glBegin(GL_QUADS);
>        glTexCoord2f(0,0);
>        glVertex2f(0,0);
>        glTexCoord2f(0,texCoordH);
>        glVertex2f(0,1);
>        glTexCoord2f(texCoordW,texCoordH);
>        glVertex2f(1,1);
>        glTexCoord2f(texCoordW,0);
>        glVertex2f(1,0);
>    glEnd();
>
>    glPopMatrix();
>    glMatrixMode(GL_PROJECTION);
>    glPopMatrix();
>
>    glDisable(GL_BLEND);
>    glEnable(GL_DEPTH_TEST);
>    glEnable(GL_CULL_FACE);
>    glEnable(GL_LIGHTING);
>    glDisable(GL_TEXTURE_2D);
>
>    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,fboName);
>}
>
>void display(void)
>{
>
>    if(useFramebuffer)
>    {
>        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,fboName);
>        useAccum=0;
>    }
>    else
>        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);
>
>    if(rotate)
>    {
>        glutPostRedisplay();
>        angle+=10;
>    }
>
>    GLint viewport[4];
>    int jitter;
>    glGetIntegerv (GL_VIEWPORT, viewport);
>    glClearColor(0,0,0,1);
>
>    if(useAccum)
>    {
>        glClear(GL_ACCUM_BUFFER_BIT);
>        for (jitter = 0; jitter < ACSIZE; jitter++)
>        {
>            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
>            accPerspective (50.0, (GLdouble) viewport[2]/(GLdouble) viewport[3], 1.0, 15.0, j[jitter].x, j[jitter].y);
>            displayObjects ();
>            glAccum(GL_ACCUM, 1.0/ACSIZE);
>        }
>        glAccum (GL_RETURN, 1.0);
>    }
>    else if(useFramebuffer)
>    {
>        if(intelWorkaround)
>        {
>            // without these rebindings intel doesn't seem to render to texture once every frame
>            glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);
>            glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,fboName);
>        }
>        for (jitter = 0; jitter < ACSIZE; jitter++)
>        {
>            GLfloat currentAlpha=(1.)/(1+jitter);
>            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
>            accPerspective (50.0, (GLdouble) viewport[2]/(GLdouble) viewport[3], 1.0, 15.0, j[jitter].x, j[jitter].y);
>            displayObjects ();
>            glColorMask(0,0,0,1);
>            glClearColor(0,0,0,currentAlpha);
>            glClear(GL_COLOR_BUFFER_BIT);
>            glColorMask(1,1,1,1);
>            renderTexture(jitter);
>            // uncomment this and you'll see that next frame will be empty (first one when > 1 jitter frames)
>            // glClear(GL_COLOR_BUFFER_BIT);
>        }
>    }
>    else // no antialiasing
>    {
>        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
>        glMatrixMode(GL_PROJECTION);
>        glLoadIdentity();
>        gluPerspective(50,(GLdouble)viewport[2]/(GLdouble)viewport[3],1,15);
>        displayObjects();
>    }
>
>    glutSwapBuffers();
>
>    frameNumber++;
>    endTime=glutGet(GLUT_ELAPSED_TIME);
>    if(endTime-startTime>500)
>    {
>        char buf[256];
>        sprintf(buf,"%d jitter frame%s, %ssing AB, %ssing FB, %.2f FPS, angle %.0f deg",
>                ACSIZE,
>                (ACSIZE>1?"s":""),
>                (useAccum?"u":"not u"),
>                (useFramebuffer?"u":"not u"),
>                1000.0*frameNumber/(endTime-startTime),
>                angle);
>        glutSetWindowTitle(buf);
>        startTime=glutGet(GLUT_ELAPSED_TIME);
>        frameNumber=0;
>    }
>}
>
>void reshape(int w, int h)
>{
>    texW=w;
>    texH=h;
>    windowW=w;
>    windowH=h;
>    glViewport(0, 0, (GLsizei) w, (GLsizei) h);
>
>    if(fboSupport)
>    {
>        if(textureID)
>          glDeleteTextures(1,&textureID);
>        if(fboName)
>          glDeleteFramebuffersEXT(1,&fboName);
>        if(renderBuffer)
>            glDeleteRenderbuffersEXT(1,&renderBuffer);
>
>        glGenTextures(1,&textureID);
>        glBindTexture(GL_TEXTURE_2D,textureID);
>
>        if(!npotSupport)
>        {
>            texW=1<<(int)ceil(log(w)/log(2));
>            texH=1<<(int)ceil(log(h)/log(2));
>            fprintf(stderr,"Window dimensions: (%d,%d); using texture: (%d,%d)\n",w,h,texW,texH);
>        }
>
>        glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA8,texW,texH,0,GL_RGBA,GL_UNSIGNED_BYTE,NULL);
>        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
>        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
>        glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE);
>
>        glGenFramebuffersEXT(1,&fboName);
>        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,fboName);
>
>        glGenRenderbuffersEXT(1,&renderBuffer);
>        glBindRenderbufferEXT(GL_RENDERBUFFER_EXT,renderBuffer);
>        glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT,GL_DEPTH_COMPONENT32,texW,texH);
>        glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_RENDERBUFFER_EXT,renderBuffer);
>
>        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,textureID,0);
>        GLenum status=glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
>
>        if(status!=GL_FRAMEBUFFER_COMPLETE_EXT)
>        {
>          const char* errorDescription=0;
>          switch(status)
>          {
>            case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
>                errorDescription="GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
>                break;
>            case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
>                errorDescription="GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
>                break;
>            case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
>                errorDescription="GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
>                break;
>            case GL_INVALID_FRAMEBUFFER_OPERATION_EXT:
>                errorDescription="GL_INVALID_FRAMEBUFFER_OPERATION";
>                break;
>            case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
>                errorDescription="GL_FRAMEBUFFER_UNSUPPORTED";
>                break;
>            default:
>                errorDescription="Unknown";
>                break;
>          }
>          fprintf(stderr,"***Error: framebuffer incomplete: %s\n",errorDescription);
>        }
>
>        glBindRenderbufferEXT(GL_RENDERBUFFER_EXT,0);
>        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);
>        glBindTexture(GL_TEXTURE_2D,0);
>    }
>}
>
>void keyboard(unsigned char key,int x,int y)
>{
>    switch(key)
>    {
>        case '1':
>            ACSIZE=1;
>            j=j_1;
>            break;
>        case '2':
>            ACSIZE=2;
>            j=j2;
>            break;
>        case '3':
>            ACSIZE=3;
>            j=j3;
>            break;
>        case '4':
>            ACSIZE=4;
>            j=j4;
>            break;
>        case '5':
>            ACSIZE=5;
>            j=j5;
>            break;
>        case '6':
>            ACSIZE=6;
>            j=j6;
>            break;
>        case '8':
>            ACSIZE=8;
>            j=j8;
>            break;
>        case '9':
>            ACSIZE=9;
>            j=j9;
>            break;
>        case '0':
>            ACSIZE=12;
>            j=j12;
>            break;
>        case '-':
>            ACSIZE=16;
>            j=j16;
>            break;
>        case 'r':
>            rotate^=true;
>            break;
>        case 'a':
>        {
>            if(!useAccum && useFramebuffer)
>            {
>                useAccum=true;
>                useFramebuffer=0;
>            }
>            else
>                useAccum^=true;
>            break;
>        }
>        case 'f':
>        {
>            if(fboSupport)
>              useFramebuffer^=true;
>            else
>              useFramebuffer=false;
>            break;
>        }
>        case 'i':
>            intelWorkaround^=true;
>            break;
>        case 'q':
>            exit(0);
>            break;
>    }
>    glutPostRedisplay();
>}
>
>GLboolean isNumber(const char* str)
>{
>    int i=0;
>    for(i=0;str[i];i++)
>        if(!isdigit(str[i]))
>            return false;
>    return true;
>}
>
>/*  Main Loop
> *    *  Be certain you request an accumulation buffer.
> *    */
>int main(int argc, char** argv)
>{
>    glutInit(&argc, argv);
>    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB
>                        | GLUT_ACCUM | GLUT_DEPTH);
>    int w=640,h=480;
>    if(argc>=3)
>    {
>        if(argc>3 || !isNumber(argv[1]) || !isNumber(argv[2]))
>        {
>            fprintf(stderr,"Usage: %s [Width Height]\n",argv[0]);
>            exit(2);
>        }
>        w=atoi(argv[1]);
>        h=atoi(argv[2]);
>    }
>    glutInitWindowSize (w, h);
>    glutCreateWindow ("Antialiasing via accumulation buffer/frame buffer object demo");
>    init();
>    glutReshapeFunc(reshape);
>    glutDisplayFunc(display);
>    glutKeyboardFunc(keyboard);
>    startTime=glutGet(GLUT_ELAPSED_TIME);
>
>    fprintf(stderr,"Controls:\n[1-689]: set \\1 jitter points\n"
>            "[0]: set 12 jitter points\n[-]: set 16 jitter points\n"
>            "r: toggle rotation\na: toggle accumulation buffer use\nf: toggle FBO use\n"
>            "i: toggle work around intel bug\n"
>            "q: quit\n");
>    glutMainLoop();
>    return 0;
>}

Actions: View

Attachments on bug 39285: 49179

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.