// ------------------------------------------------------------------------
// This program is complementary material for the book:
//
// Frank Nielsen
//
// Visual Computing: Geometry, Graphics, and Vision
//
// ISBN: 1-58450-427-7
//
// Charles River Media, Inc.
//
//
// All programs are available at http://www.charlesriver.com/visualcomputing/
//
// You may use this program for ACADEMIC and PERSONAL purposes ONLY. 
//
//
// The use of this program in a commercial product requires EXPLICITLY
// written permission from the author. The author is NOT responsible or 
// liable for damage or loss that may be caused by the use of this program. 
//
// Copyright (c) 2005. Frank Nielsen. All rights reserved.
// ------------------------------------------------------------------------
 
// ------------------------------------------------------------------------
// File: spheremap.cpp
// 
// Description: Reflection mapping in OpenGL(R) using a sphere map texture image
// ------------------------------------------------------------------------


#include "stdafx.h"
#include <windows.h>

#include <fstream>
#include <GL/gl.h>
#include <GL/glut.h>
#include <math.h>

using namespace std;

float angle=0.0;

// Load a PPM Image that does not contain comments.

unsigned char * LoadImagePPM(char *ifile,  int &w, int &h)
{
	char dummy1=0, dummy2=0; int maxc;
	unsigned char * img;
	ifstream fileinput(ifile, ios::binary);

	fileinput.get(dummy1);
	fileinput.get(dummy2);
	if ((dummy1!='P')&&(dummy2!='6')) {cerr<<"Not P6 PPM file"<<endl; return NULL;}
 
    fileinput >> w >> h;
    fileinput >> maxc;
    fileinput.get(dummy1);
	
    img=new  unsigned char[3*w*h];
	fileinput.read((char *)img, 3*w*h); 
	fileinput.close();
	return img;
}

#define M_PI        3.14159265358979323846

SetupTexturewithMipmap(char* filename, GLuint id);

static GLfloat lightposition[] = {-10.0, 10.0, 10.0, 0.0};
static GLfloat lightambient[] = {0.3, 0.3, 0.3, 1.0};
static GLfloat lightspecular[] = {0.8, 0.6, 0.8, 1.0};
static GLfloat lightdiffuse[] = {1.0, 1.0, 1.0, 1.0};
static GLfloat materialdiffuse[] = {1.0, 0.7, 1.0, 0.0};

GLuint texid[1];

void reshape(GLsizei w, GLsizei h)
{
  glViewport(0, 0, w, h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(54.0, (GLfloat)(w/h), 2, 100);
}



void Init()
{
  glClearColor(1,1,1, 0.0);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(54.0, 1.0, 2.0, 100.0);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  glLightfv(GL_LIGHT0, GL_POSITION, lightposition);
  glLightfv(GL_LIGHT0, GL_AMBIENT, lightambient);
  glLightfv(GL_LIGHT0, GL_DIFFUSE, lightdiffuse);
  glLightfv(GL_LIGHT0, GL_SPECULAR, lightspecular);
  glEnable(GL_LIGHT0);
  glEnable(GL_LIGHTING);
  glEnable(GL_NORMALIZE);
  glEnable(GL_DEPTH_TEST);
  glGenTextures(1, texid);
  
  SetupTexturewithMipmap("mirrorball512.ppm", texid[0]);

  glBindTexture(GL_TEXTURE_2D, texid[0]);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
  glEnable(GL_TEXTURE_2D);
}

void RenderScene()
{
  glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
  glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
  glEnable(GL_TEXTURE_GEN_S);
  glEnable(GL_TEXTURE_GEN_T);

  angle+=1.0;if (angle>360) angle-=360;

  glRotatef(angle,1,0,1);
  glutSolidTeapot(1.0);
  
  glDisable(GL_TEXTURE_GEN_T);
  glDisable(GL_TEXTURE_GEN_S);
}

void display()
{
  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  glTranslatef(0.0, 0.0, -4.0);
  glPushMatrix();
 
  glMaterialfv(GL_FRONT, GL_DIFFUSE, materialdiffuse);
  glBindTexture(GL_TEXTURE_2D, texid[0]);
  RenderScene();
  glPopMatrix();
  glutSwapBuffers();
}



void idle()
{
glutPostRedisplay();
}

void keyboard(unsigned char c, int x, int y)
{
  static int move=1;
  switch(c){
  case 'q':
    exit(0);
  case ' ':
    move=move?0:1;
    if(move == 1) glutIdleFunc(NULL);
    else glutIdleFunc(idle);
    break;
  default:
    break;
  }
}




int _tmain(int argc, _TCHAR* argv[])
{
 
 
cout<<"Visual Computing: Geometry, Graphics, and Vision (ISBN:1-58450-427-7)"<<endl;
cout<<"Demo program\n\n"<<endl;


  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
 
  glutInitWindowPosition(0,0);
  glutInitWindowSize(1024,1024);

  glutCreateWindow("Reflection mapping using a sphere map");

  Init();
 
  glutDisplayFunc(display);
  glutIdleFunc(idle);
  glutReshapeFunc(reshape);
  glutKeyboardFunc(keyboard);
  glutMainLoop();
 
  return 0;
}



int SetupTexturewithMipmap(char* filename, GLuint id)
{ 
 int size; 
  GLubyte* data; 
 
  data=LoadImagePPM(filename,size,size);
  cout<<"Texture size:"<<size<<endl;
  glBindTexture(GL_TEXTURE_2D, id); 
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 
  gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, size, size,  GL_RGB, GL_UNSIGNED_BYTE, data);
  
 return 1;
}