#include <GL/glut.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#define WINDSIZEX 100
#define WINDSIZEY 100

#define MIN(x, y) (((x) <= (y)) ? (x) : (y))

GLenum        *bufs;
GLint          nDrawBufs;

static void GetBufferInfo() {
    GLint          i, j;
    GLsizei        nBufs, nMaxBufs, nAuxBufs, totalBufs;
    GLint          doingStereo, doingDoubleBuffer;
    GLenum         bufList[4] = {
        GL_FRONT_LEFT,
        GL_BACK_LEFT,
        GL_FRONT_RIGHT,
        GL_BACK_RIGHT};
    // Find out the maximum number of buffers that we can simultaneously
    // draw into.
    glGetIntegerv(GL_MAX_DRAW_BUFFERS, &nMaxBufs);

    // Get the number of aux buffers that are available.
    glGetIntegerv(GL_AUX_BUFFERS, &nAuxBufs);

    // Find out if we are doing double buffering or stereo.
    glGetIntegerv(GL_DOUBLEBUFFER, &doingDoubleBuffer);

    glGetIntegerv(GL_STEREO, &doingStereo);

    // Calculate the number of front & back buffers.
    nBufs = (1 + doingDoubleBuffer) * (1 + doingStereo);

    // Allocate an array where we can put the DrawBuffers list.
    totalBufs = nBufs + nAuxBufs;
    nDrawBufs = MIN(totalBufs, nMaxBufs);
    bufs = malloc(nDrawBufs * sizeof(GLenum));

    printf("max buffers number: %d\n", nMaxBufs);
    printf("aux buffers number: %d\n", nAuxBufs);
    printf("double buffers: %d\n", doingDoubleBuffer);
    printf("stereo buffers: %d\n", doingStereo);
    printf("draw buffers number: %d\n", nDrawBufs);

    for (i=0; i<nBufs; i++) {
        bufs[i] = bufList[i];
    }
    for (i=nBufs, j=0; i < nDrawBufs; i++, j++) {
        bufs[i] = GL_AUX0 + j;
    }
}



void init(void)
{
    glShadeModel(GL_SMOOTH);

    glClearColor(0.6f, 0.3f, 0.8f, 1.0f);
    glClearDepth(0.0f);

    GetBufferInfo();
}

static void test(void)
{    
   GLfloat expected[] = {0.8, 0.3, 0.7, 1.0};
   GLfloat      pt1[3] = { 0.8F, -0.8F,  0.0f};
    GLfloat      pt2[3] = { 0.0F,  0.8F,  0.0f};
    GLfloat      pt3[3] = {-0.8F, -0.8F,  0.0f};
    GLfloat      pixBuf[4];
   GLint i;


   glDrawBuffers(nDrawBufs, bufs);

   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    /* Draw a little triangle */
    glBegin(GL_TRIANGLES);
    glColor4fv(expected);
    glVertex3f(pt1[0], pt1[1], pt1[2]);
    glVertex3f(pt2[0], pt2[1], pt2[2]);
    glVertex3f(pt3[0], pt3[1], pt3[2]);
    glEnd();

       for (i=0; i<nDrawBufs; i++) {
        glReadBuffer(bufs[i]);
        glReadPixels(WINDSIZEX/2, WINDSIZEY/2, 1, 1, GL_RGBA, GL_FLOAT, pixBuf);

        if ((fabs(pixBuf[0] - expected[0]) > 0.01) ||
            (fabs(pixBuf[1] - expected[1]) > 0.01) ||
            (fabs(pixBuf[2] - expected[2]) > 0.01) ||
            (fabs(pixBuf[3] - expected[3]) > 0.01) ) {
      printf("error! i is: %d\n", i);
      printf("expected: %f %f %f %f\n", expected[0], expected[1], expected[2], expected[3]);
      printf("actual: %f %f %f %f\n", pixBuf[0], pixBuf[1], pixBuf[2], pixBuf[3]);
      printf("\n");
         }
    }
    exit(0);
}

void display(void)
{
    glViewport(0, 0, WINDSIZEX, WINDSIZEY);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
    glOrtho(-1.0, 1.0, -1.0, 1.0, 0.0, 1.0);
    //gluOrtho2D(0, WINDSIZEX, 0, WINDSIZEY);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();

    test();
}

int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
   glutInitWindowSize(WINDSIZEX, WINDSIZEY);
   glutInitWindowPosition(100, 100);
   glutCreateWindow(argv[0]);
   init();
   glutDisplayFunc(display);
   glutMainLoop();
   return 0; 
}