/* $Id: reflect.c,v 3.0 1998/02/14 18:42:29 brianp Exp $ */

/*
 * Demo of a reflective, texture-mapped surface with OpenGL.
 * Brian Paul   August 14, 1995   This file is in the public domain.
 *
 * Hardware texture mapping is highly recommended!
 *
 * The basic steps are:
 *    1. Render the reflective object (a polygon) from the normal viewpoint,
 *       setting the stencil planes = 1.
 *    2. Render the scene from a special viewpoint:  the viewpoint which
 *       is on the opposite side of the reflective plane.  Only draw where
 *       stencil = 1.  This draws the objects in the reflective surface.
 *    3. Render the scene from the original viewpoint.  This draws the
 *       objects in the normal fashion.  Use blending when drawing
 *       the reflective, textured surface.
 *
 * This is a very crude demo.  It could be much better.
 */
 
/*
 * Dirk Reiners (reiners@igd.fhg.de) made some modifications to this code.
 *
 * August 1996 - A few optimizations by Brian
 */

/*
 * April, 1997 - Added Mark Kilgard's changes.
 */

/*
 * $Log: reflect.c,v $
 * Revision 3.0  1998/02/14 18:42:29  brianp
 * initial rev
 *
 */

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

#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>

#include "ReadTex.h"
#include "ModuleManipulateur.h"
#include "ModuleMenus.h"
#include "ModuleReshape.h"

#define USE_ZBUFFER
#define USE_TEXTURE
#define DEG2RAD (3.14159/180.0)
#define TABLE_TEXTURE "reflect.rgb"
#define MAX_OBJECTS 2

static int ImgWidth,ImgHeight;
static GLenum ImgFormat;
static GLubyte *Image = NULL;
static GLint table_list;
static GLint objects_list[MAX_OBJECTS];
static GLfloat xrot,yrot;
static GLfloat spin;

static void make_table(void) {
  static GLfloat table_mat[] = { 1.0F,1.0F,1.0F,0.6F };
  static GLfloat gray[] = { 0.4F,0.4F,0.4F,1.0F };
  table_list = glGenLists(1);
  glNewList(table_list,GL_COMPILE);
  glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,table_mat);
  glMaterialfv(GL_FRONT,GL_DIFFUSE,table_mat);
  glMaterialfv(GL_FRONT,GL_AMBIENT,gray);
  glPushMatrix();
  glScalef(4.0,4.0,4.0);
  glBegin(GL_POLYGON);
  glNormal3f(0.0,1.0,0.0);
  glTexCoord2f(0.0,0.0); 
  glVertex3f(-1.0,0.0, 1.0);
  glTexCoord2f(1.0,0.0); 
  glVertex3f(1.0,0.0, 1.0);
  glTexCoord2f(1.0,1.0); 
  glVertex3f(1.0,0.0,-1.0);
  glTexCoord2f(0.0,1.0); 
  glVertex3f(-1.0,0.0,-1.0);
  glEnd();
  glPopMatrix();
  glDisable(GL_TEXTURE_2D);
  glEndList();
}

static void make_objects(void) {
  GLUquadricObj *q;
  static GLfloat cyan[] = { 0.0F,1.0F,1.0F,1.0F };
  static GLfloat green[] = { 0.2F,1.0F,0.2F,1.0F };
  static GLfloat black[] = { 0.0F,0.0F,0.0F,0.0F };
  q = gluNewQuadric();
  gluQuadricDrawStyle(q,GLU_FILL);
  gluQuadricNormals(q,GLU_SMOOTH);
  objects_list[0] = glGenLists(1);
  glNewList(objects_list[0],GL_COMPILE);
  glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,cyan);
  glMaterialfv(GL_FRONT,GL_EMISSION,black);
  gluCylinder(q,0.5,0.5, 1.0,15,10);
  glEndList();
  objects_list[1] = glGenLists(1);
  glNewList(objects_list[1],GL_COMPILE);
  glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,green);
  glMaterialfv(GL_FRONT,GL_EMISSION,black);
  gluCylinder(q,1.5,0.0, 2.5,15,10);
  glEndList();
}

static GLfloat light_pos[] = { 0.0,20.0,0.0,1.0 };

static void init(void) {
  make_table();
  make_objects();
#ifdef USE_TEXTURE
  Image = LoadRGBImage(TABLE_TEXTURE,&ImgWidth,&ImgHeight,&ImgFormat);
  if(!Image) {
    printf("Couldn't read %s\n",TABLE_TEXTURE);
    exit(0); }
  gluBuild2DMipmaps(GL_TEXTURE_2D,3,ImgWidth,ImgHeight,ImgFormat,GL_UNSIGNED_BYTE,Image);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
#endif
  xrot = 30.0;
  yrot = 50.0;
  spin = 0.0;
#ifndef USE_ZBUFFER
  glEnable(GL_CULL_FACE);
#endif
  glShadeModel(GL_SMOOTH);
  glEnable(GL_LIGHT0);
  glEnable(GL_LIGHTING);
  glClearColor(0.5,0.5,0.5,1.0);
  glEnable(GL_NORMALIZE);
}

static void draw_objects(GLfloat eyex,GLfloat eyey,GLfloat eyez) {
#ifndef USE_ZBUFFER
  if(eyex<0.5) {
#endif
    glPushMatrix();
    glTranslatef(1.0,1.5,0.0);
    glRotatef(spin,1.0,0.5,0.0);
    glRotatef(0.5F*spin,0.0,0.5,1.0);
    glCallList(objects_list[0]);
    glPopMatrix();
    glPushMatrix();
    glTranslatef(-1.0,(float) (0.85+3.0*fabs(cos(0.01*spin))),0.0);
    glRotatef(0.5F*spin,0.0,0.5,1.0);
    glRotatef(spin,1.0,0.5,0.0);
    glScalef(0.5,0.5,0.5);
    glCallList(objects_list[1]);
    glPopMatrix();
#ifndef USE_ZBUFFER
    }
    else {  
    glPushMatrix();
    glTranslatef(-1.0,0.85+3.0*fabs(cos(0.01*spin)),0.0);
    glRotatef(0.5*spin,0.0,0.5,1.0);
    glRotatef(spin,1.0,0.5,0.0);
    glScalef(0.5,0.5,0.5);
    glCallList(objects_list[1]);
    glPopMatrix();
    glPushMatrix();
    glTranslatef(1.0,1.5,0.0);
    glRotatef(spin,1.0,0.5,0.0);
    glRotatef(0.5*spin,0.0,0.5,1.0);
    glCallList(objects_list[0]);
    glPopMatrix(); }
#endif
}

static void draw_table(void) {
  glCallList(table_list);
}

static void display(void) {
  GLfloat dist = 20.0;
  GLfloat eyex,eyey,eyez;
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
  eyex =(float) (dist * cos(yrot*DEG2RAD) * cos(xrot*DEG2RAD));
  eyez =(float) (dist * sin(yrot*DEG2RAD) * cos(xrot*DEG2RAD));
  eyey =(float) (dist * sin(xrot*DEG2RAD));
  glPushMatrix();
  gluLookAt(eyex,eyey,eyez,0.0,0.0,0.0, 0.0,1.0,0.0);
  manipulateurSouris();
  manipulateurClavier();
  glLightfv(GL_LIGHT0,GL_POSITION,light_pos);
  glEnable(GL_STENCIL_TEST);
#ifdef USE_ZBUFFER
  glDisable(GL_DEPTH_TEST);
#endif
  glStencilFunc(GL_ALWAYS,1,0xffffffff);
  glStencilOp(GL_REPLACE,GL_REPLACE,GL_REPLACE);
  glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE);
  draw_table();
  glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
#ifdef USE_ZBUFFER
  glEnable(GL_DEPTH_TEST);
#endif
  if(eyey>0.0) {
    glPushMatrix();
    glStencilFunc(GL_EQUAL,1,0xffffffff);
    glStencilOp(GL_KEEP,GL_KEEP,GL_KEEP);
    glScalef(1.0,-1.0,1.0);
    glLightfv(GL_LIGHT0,GL_POSITION,light_pos);
    draw_objects(eyex,eyey,eyez);
    glPopMatrix();
    glLightfv(GL_LIGHT0,GL_POSITION,light_pos); }
  glDisable(GL_STENCIL_TEST);
  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
#ifdef USE_TEXTURE
  glEnable(GL_TEXTURE_2D);
#endif
  draw_table();
  glDisable(GL_TEXTURE_2D);
  glDisable(GL_BLEND);
  glPushMatrix();
  draw_objects(eyex,eyey,eyez);
  glPopMatrix();
  glPopMatrix();
  glutSwapBuffers();
}

#if 0
void display(void) {
  GLfloat dist = 20.0;
  GLfloat eyex,eyey,eyez;
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
  eyex = dist * cos(yrot*DEG2RAD) * cos(xrot*DEG2RAD);
  eyez = dist * sin(yrot*DEG2RAD) * cos(xrot*DEG2RAD);
  eyey = dist * sin(xrot*DEG2RAD);
  glPushMatrix();
  gluLookAt(eyex,eyey,eyez,0.0,0.0,0.0, 0.0,1.0,0.0);
  manipulateurSouris();
  manipulateurClavier();
  draw_table();
  glPopMatrix();
  auxSwapBuffers(); }
#endif

static void idle(void) {
  spin += 2.0;
  yrot += 3.0;
  glutPostRedisplay() ;
}

int main(int argc,char **argv) {
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_DOUBLE|GLUT_STENCIL);
  glutInitWindowSize(400,300); 
  glutInitWindowPosition(50,50); 
  glutCreateWindow("Réflexions par mappage de texture"); 
  init(); 
  creationMenuBasique();
  setParametresFrustumBasique(-1.0F,1.0F,-1.0,1.0F,4.0F,300.0F,0.0F,0.0F,0.0F);
  setManipulateurDistance(20.0F);
  glutReshapeFunc(reshapeFrustumBasique);
  glutIdleFunc(idle);
  glutKeyboardFunc(keyBasique);
  glutSpecialFunc(specialBasique);
  glutMotionFunc(motionBasique);
  glutMouseFunc(sourisBasique);
  glutDisplayFunc(display);
  glutMainLoop();
  return(0);
}