define _USE_MATH_DEFINES define ACSIZE include iostream include cmath

#define _USE_MATH_DEFINES
#define ACSIZE  8

#include <iostream>
#include <cmath>
#include "glut.h"


GLuint teapotList;

struct point
{
    GLfloat x, y;
};
//
//
point j8[] =
{
    { -0.334818, 0.435331 },
    { 0.286438, -0.393495 },
    { 0.459462, 0.141540 },
    { -0.414498, -0.192829 },
    { -0.183790, 0.082102 },
    { -0.079263, -0.317383 },
    { 0.102254, 0.299133 },
    { 0.164216, -0.054399 }
};

int index = 50;
int quality = ACSIZE;
void accFrustsum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top,
    GLdouble zNear, GLdouble zFar, GLdouble pixdx,
    GLdouble pixdy, GLdouble eyedx, GLdouble eyedy, GLdouble focus)
{
    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] + eyedx*zNear / focus);
    dy = -(pixdy*ywsize / (GLdouble)viewport[3] + eyedy*zNear / focus);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glFrustum(left + dx, right + dx, bottom + dy, top + dy, zNear, zFar);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(-eyedx, eyedy, 0.0);
}

void accPerspective(GLdouble fovy, GLdouble aspect,
    GLdouble zNear, GLdouble zFar, GLdouble pixdx,
    GLdouble pixdy, GLdouble eyedx, GLdouble eyedy, GLdouble focus)
{
    GLdouble fov2, left, right, bottom, top;
    fov2 = ((fovy*M_PI) / 180) * 2;
    top = zNear / (cosf(fov2) / sinf(fov2));
    bottom = -top;
    right = top * aspect;
    left = -right;

    accFrustsum(left, right, bottom, top, zNear, zFar, pixdx, pixdy, eyedx, eyedy, focus);
}



void init(void)
{
    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);
}
void displayObjects(void)
{
    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, 16, 16);
    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, 16, 16);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(0.70, -0.90, 0.25);
   glMaterialfv(GL_FRONT, GL_DIFFUSE, octa_diffuse);
    glutSolidOctahedron();
    glPopMatrix();

    glPopMatrix();
}
void display(void)
{
    GLint viewport[4];
    int jitter;

    glGetIntegerv(GL_VIEWPORT, viewport);

    glClear(GL_ACCUM_BUFFER_BIT);
    
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        accPerspective(index,
            (GLdouble)viewport[2] / (GLdouble)viewport[3],
            1.0, 15.0, j8[quality].x, j8[quality].y, 0.0, 0.0, 5.0);
        displayObjects();
        glAccum(GL_ACCUM, 1.0 / ACSIZE);
        glAccum(GL_RETURN, ACSIZE / quality );
    
    
    glFlush();
}

void reshape(int w, int h)
{
    glViewport(0, 0, (GLsizei)w, (GLsizei)h);
}


void keyPressed(int key, int x, int y) {
    if (key == GLUT_KEY_LEFT)
    {
        index++;
        display();
    }
    else if (key == GLUT_KEY_RIGHT)
    {
        index--;
        display();
    }

    else if (key == GLUT_KEY_PAGE_UP)
    {
        quality++;
        display();
    }

    else if (key == GLUT_KEY_PAGE_DOWN)
    {
        if (quality > 1)
           quality--;
        display();
    }
}

int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB
        | GLUT_ACCUM | GLUT_DEPTH);
    glutInitWindowSize(250, 250);
    glutInitWindowPosition(100, 100);
    glutCreateWindow(argv[0]);
    init();
    glutReshapeFunc(reshape);
    glutDisplayFunc(display);
    glutSpecialFunc(keyPressed); 
    glutMainLoop();
    return 0;
}