/*

 * Copyright (c) 1993-1997, Silicon Graphics, Inc.
 * ALL RIGHTS RESERVED 
 * Permission to use, copy, modify, and distribute this software for 
 * any purpose and without fee is hereby granted, provided that the above
 * copyright notice appear in all copies and that both the copyright notice
 * and this permission notice appear in supporting documentation, and that 
 * the name of Silicon Graphics, Inc. not be used in advertising
 * or publicity pertaining to distribution of the software without specific,
 * written prior permission. 
 *
 * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
 * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
 * FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON
 * GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
 * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
 * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
 * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
 * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN
 * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
 * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
 * 
 * US Government Users Restricted Rights 
 * Use, duplication, or disclosure by the Government is subject to
 * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
 * (c)(1)(ii) of the Rights in Technical Data and Computer Software
 * clause at DFARS 252.227-7013 and/or in similar or successor
 * clauses in the FAR or the DOD or NASA FAR Supplement.
 * Unpublished-- rights reserved under the copyright laws of the
 * United States.  Contractor/manufacturer is Silicon Graphics,
 * Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.
 *
 * OpenGL(R) is a registered trademark of Silicon Graphics, Inc.
 */

/*
 *  ProfondeurDeChamp.cpp
 *  This program demonstrates use of the accumulation buffer to
 *  create an out-of-focus depth-of-field effect.  The teapots
 *  are drawn several times into the accumulation buffer.  The
 *  viewing volume is jittered,except at the focal point,where
 *  the viewing volume is at the same position,each time.  In
 *  this case,the gold teapot remains in focus.
 */

#include <stdlib.h>
#include <math.h>

#include <GL/glut.h>

#include "Jitter.h"

#include "ModuleCouleurs.h"
#include "ModuleManipulateur.h"
#include "ModuleMenus.h"

#ifdef WIN32
#define distNear 1
#define distFar 20
#endif

#define PI_ 3.14159265358979323846

GLuint teapotList;

/* accFrustum()
 * The first 6 arguments are identical to the glFrustum() call.
 *  
 * pixdx and pixdy are anti-alias jitter in pixels. 
 * Set both equal to 0.0 for no anti-alias jitter.
 * eyedx and eyedy are depth-of field jitter in pixels. 
 * Set both equal to 0.0 for no depth of field effects.
 *
 * focus is distance from eye to plane in focus. 
 * focus must be greater than,but not equal to 0.0.
 *
 * Note that accFrustum() calls glTranslatef().  You will 
 * probably want to insure that your ModelView matrix has been 
 * initialized to identity before calling accFrustum().
 */
void accFrustum(GLdouble left,GLdouble right,GLdouble bottom,
   GLdouble top,GLdouble near,GLdouble far,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*distNear/focus);
  dy = -(pixdy*ywsize/(GLdouble) viewport[3] + eyedy*distNear/focus);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glFrustum(left + dx,right + dx,bottom + dy,top + dy,distNear,distFar);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  glTranslatef(-eyedx,-eyedy,0.0);
}

/*  accPerspective()
 * 
 *  The first 4 arguments are identical to the gluPerspective() call.
 *  pixdx and pixdy are anti-alias jitter in pixels. 
 *  Set both equal to 0.0 for no anti-alias jitter.
 *  eyedx and eyedy are depth-of field jitter in pixels. 
 *  Set both equal to 0.0 for no depth of field effects.
 *
 *  focus is distance from eye to plane in focus. 
 *  focus must be greater than,but not equal to 0.0.
 *
 *  Note that accPerspective() calls accFrustum().
 */
void accPerspective(GLdouble fovy,GLdouble aspect,
   GLdouble dNear,GLdouble dFar,GLdouble pixdx,GLdouble pixdy,
   GLdouble eyedx,GLdouble eyedy,GLdouble focus) {
   GLdouble fov2,left,right,bottom,top;
  fov2 =((fovy*PI_) / 180.0) / 2.0;
  top = dNear /(cos(fov2) / sin(fov2));
  bottom = -top;
  right = top * aspect;
  left = -right;
  accFrustum(left,right,bottom,top,dNear,dFar,
              pixdx,pixdy,eyedx,eyedy,focus);
}

void myinit(void) {
  GLfloat position[] = { 0.0,3.0,3.0,0.0 };
  GLfloat lmodel_ambient[] = { 0.2,0.2,0.2,1.0 };
  GLfloat local_view[] = { 0.0 };
  glLightfv(GL_LIGHT0,GL_AMBIENT,couleurNoir());
  glLightfv(GL_LIGHT0,GL_DIFFUSE,couleurBlanc());
  glLightfv(GL_LIGHT0,GL_POSITION,position);
  glLightModelfv(GL_LIGHT_MODEL_AMBIENT,lmodel_ambient);
  glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER,local_view);
  glFrontFace(GL_CW);
  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);
  glEnable(GL_AUTO_NORMAL);
  glEnable(GL_NORMALIZE);
  glEnable(GL_DEPTH_TEST);
  glClearColor(0.0,0.0,0.0,0.0);
  glClearAccum(0.0,0.0,0.0,0.0); 
/*  make teapot display list */
  teapotList = glGenLists(1);
  glNewList(teapotList,GL_COMPILE);
  glutSolidTeapot(0.5);
  glEndList();
}

void renderTeapot(GLfloat x,GLfloat y,GLfloat z,
   GLfloat ambr,GLfloat ambg,GLfloat ambb,
   GLfloat difr,GLfloat difg,GLfloat difb,
   GLfloat specr,GLfloat specg,GLfloat specb,GLfloat shine) {
  GLfloat mat[4];
  glPushMatrix();
  glTranslatef(0.0,0.5,-5.5);
  glScalef(1.6F,1.6F,1.F);
  manipulateurSouris();
  manipulateurClavier();
  glTranslatef(x,y,z);
  mat[0] = ambr; mat[1] = ambg; mat[2] = ambb; mat[3] = 1.0;  
  glMaterialfv(GL_FRONT,GL_AMBIENT,mat);
  mat[0] = difr; mat[1] = difg; mat[2] = difb;  
  glMaterialfv(GL_FRONT,GL_DIFFUSE,mat);
  mat[0] = specr; mat[1] = specg; mat[2] = specb;
  glMaterialfv(GL_FRONT,GL_SPECULAR,mat);
  glMaterialf(GL_FRONT,GL_SHININESS,shine*128.0);
  glCallList(teapotList);
  glPopMatrix();
}

/*  display() draws 5 teapots into the accumulation buffer 
 *  several times; each time with a jittered perspective.
 *  The focal point is at z = 5.0,so the gold teapot will 
 *  stay in focus.  The amount of jitter is adjusted by the
 *  magnitude of the accPerspective() jitter; in this example,0.33.
 *  In this example,the teapots are drawn 8 times.  See jitter.h
 */
void display(void) {
  int jitter;
  GLint viewport[4];
  glGetIntegerv(GL_VIEWPORT,viewport);
  glClear(GL_ACCUM_BUFFER_BIT);
  for(jitter = 0; jitter < 8; jitter++) {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    accPerspective(45.0,
        (GLdouble) viewport[2]/(GLdouble) viewport[3],
         1.0,15.0,0.0,0.0,
         0.33*j8[jitter].x,0.33*j8[jitter].y,5.0);
/*  ruby,gold,silver,emerald,and cyan teapots  */
    renderTeapot(-1.1,-0.5,1.0,0.1745,0.01175,
                  0.01175,0.61424,0.04136,0.04136,
                  0.727811,0.626959,0.626959,0.6);
    renderTeapot(-0.5,-0.5,0.5,0.24725,0.1995,
                  0.0745,0.75164,0.60648,0.22648,
                  0.628281,0.555802,0.366065,0.4);
    renderTeapot(0.2,-0.5,0.0,0.19225,0.19225,
                  0.19225,0.50754,0.50754,0.50754,
                  0.508273,0.508273,0.508273,0.4);
    renderTeapot(1.0,-0.5,-0.5,0.0215,0.1745,0.0215,
                  0.07568,0.61424,0.07568,0.633,
                  0.727811,0.633,0.6);
    renderTeapot(1.8,-0.5,-1.0,0.0,0.1,0.06,0.0,
                  0.50980392,0.50980392,0.50196078,
                  0.50196078,0.50196078,.25);
    glAccum(GL_ACCUM,0.125); }
  glAccum(GL_RETURN,1.0);
  glutSwapBuffers();
  glFlush();
}

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

/*  Main Loop
 *  Be certain you request an accumulation buffer.
 */

int main(int argc,char **argv) {
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_ACCUM|GLUT_DOUBLE);
  glutInitWindowSize(450,250); 
  glutInitWindowPosition(50,50); 
  glutCreateWindow("Profondeur de champ"); 
  myinit(); 
  creationMenuBasique();
  glutReshapeFunc(reshape);
  glutKeyboardFunc(keyBasique);
  glutSpecialFunc(specialBasique);
  glutMotionFunc(motionBasique);
  glutMouseFunc(sourisBasique);
  glutDisplayFunc(display);
  glutMainLoop();
  return(0);
}