/* An OpenGL scene of a very crude deer in a forest.
Copyright (C) 2006 by Agnes Chang
This program is released under the GNU General Public License.
Submitted for CS 307 Creative Scene Assignment 
Prototype for one scene in final project
Based on show-object-natural.cc by Scott D. Anderson, Fall 2006
*/

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

//#include "achang.cpp"
#include <f06/objects.h>

// the model objects
GLMmodel* deer = NULL;        // the main character
GLMmodel* birchSimple = NULL;
GLMmodel* fallBirch = NULL;
GLMmodel* fir = NULL; 
GLMmodel* mapleCluster = NULL;
GLMmodel* oak = NULL;
GLMmodel* pinecones = NULL;
GLMmodel* pineCraggy = NULL;
GLMmodel* pineFast = NULL;
GLMmodel* redwoodSapling = NULL;
GLMmodel* shrub1 = NULL;

// bounding boxes
GLfloat BoundingBox[6] = {-10, 10, 0, 12, -5, 5};    // for the scene [minx,maxx,miny,maxy,minz,maxz]
GLfloat deerBBox[6];         // individual bbox per item
GLfloat birchSimpleBBox[6];
GLfloat fallBirchBBox[6];
GLfloat firBBox[6]; 
GLfloat mapleClusterBBox[6];
GLfloat oakBBox[6];
GLfloat pineconesBBox[6];
GLfloat pineCraggyBBox[6];
GLfloat pineFastBBox[6];
GLfloat redwoodSaplingBBox[6];
GLfloat shrub1BBox[6];


void initmodel(void) {
        deer = glmReadOBJ("deer.obj");
        if (!deer) exit(0);
        glmBoundingBox(deer,deerBBox);
        printf("deer Bounding Box is (%f,%f,%f,%f,%f,%f)\n",
               deerBBox[0], deerBBox[1],
               deerBBox[2], deerBBox[3],
               deerBBox[4], deerBBox[5]);  
        glmFacetNormals(deer);
        glmVertexNormals(deer, 90.0);
        
        birchSimple = glmReadOBJ("birchSimple.obj");
        if (!birchSimple) exit(0);
        glmBoundingBox(birchSimple,birchSimpleBBox);
        printf("birchSimple Bounding Box is (%f,%f,%f,%f,%f,%f)\n",
               birchSimpleBBox[0], birchSimpleBBox[1],
               birchSimpleBBox[2], birchSimpleBBox[3],
               birchSimpleBBox[4], birchSimpleBBox[5]);  
        glmFacetNormals(birchSimple);
        glmVertexNormals(birchSimple, 90.0);
        
        fallBirch = glmReadOBJ("fallBirch.obj");
        if (!fallBirch) exit(0);
        glmBoundingBox(fallBirch,fallBirchBBox);
        printf("fallBirch Bounding Box is (%f,%f,%f,%f,%f,%f)\n",
               fallBirchBBox[0], fallBirchBBox[1],
               fallBirchBBox[2], fallBirchBBox[3],
               fallBirchBBox[4], fallBirchBBox[5]);  
        glmFacetNormals(fallBirch);
        glmVertexNormals(fallBirch, 90.0);
        
        fir = glmReadOBJ("fir.obj");
        if (!fir) exit(0);
        glmBoundingBox(fir,firBBox);
        printf("fir Bounding Box is (%f,%f,%f,%f,%f,%f)\n",
               firBBox[0], firBBox[1],
               firBBox[2], firBBox[3],
               firBBox[4], firBBox[5]);  
        glmFacetNormals(fir);
        glmVertexNormals(fir, 90.0);
        
        mapleCluster = glmReadOBJ("mapleCluster.obj");
        if (!mapleCluster) exit(0);
        glmBoundingBox(mapleCluster,mapleClusterBBox);
        printf("mapleCluster Bounding Box is (%f,%f,%f,%f,%f,%f)\n",
               mapleClusterBBox[0], mapleClusterBBox[1],
               mapleClusterBBox[2], mapleClusterBBox[3],
               mapleClusterBBox[4], mapleClusterBBox[5]);  
        glmFacetNormals(mapleCluster);
        glmVertexNormals(mapleCluster, 90.0);

        oak = glmReadOBJ("oak.obj");
        if (!oak) exit(0);
        glmBoundingBox(oak,oakBBox);
        printf("oak Bounding Box is (%f,%f,%f,%f,%f,%f)\n",
               oakBBox[0], oakBBox[1],
               oakBBox[2], oakBBox[3],
               oakBBox[4], oakBBox[5]);  
        glmFacetNormals(oak);
        glmVertexNormals(oak, 90.0);
        
        pinecones = glmReadOBJ("pinecones.obj");
        if (!pinecones) exit(0);
        glmBoundingBox(pinecones,pineconesBBox);
        printf("pinecones Bounding Box is (%f,%f,%f,%f,%f,%f)\n",
               pineconesBBox[0], pineconesBBox[1],
               pineconesBBox[2], pineconesBBox[3],
               pineconesBBox[4], pineconesBBox[5]);  
        glmFacetNormals(pinecones);
        glmVertexNormals(pinecones, 90.0);
        
        pineCraggy = glmReadOBJ("pineCraggy.obj");
        if (!pineCraggy) exit(0);
        glmBoundingBox(pineCraggy,pineCraggyBBox);
        printf("pineCraggy Bounding Box is (%f,%f,%f,%f,%f,%f)\n",
               pineCraggyBBox[0], pineCraggyBBox[1],
               pineCraggyBBox[2], pineCraggyBBox[3],
               pineCraggyBBox[4], pineCraggyBBox[5]);  
        glmFacetNormals(pineCraggy);
        glmVertexNormals(pineCraggy, 90.0);
        
        pineFast = glmReadOBJ("pineFast.obj");
        if (!pineFast) exit(0);
        glmBoundingBox(pineFast,pineFastBBox);
        printf("pineFast Bounding Box is (%f,%f,%f,%f,%f,%f)\n",
               pineFastBBox[0], pineFastBBox[1],
               pineFastBBox[2], pineFastBBox[3],
               pineFastBBox[4], pineFastBBox[5]);  
        glmFacetNormals(pineFast);
        glmVertexNormals(pineFast, 90.0);
        
        redwoodSapling = glmReadOBJ("redwoodSapling.obj");
        if (!redwoodSapling) exit(0);
        glmBoundingBox(redwoodSapling,redwoodSaplingBBox);
        printf("redwoodSapling Bounding Box is (%f,%f,%f,%f,%f,%f)\n",
               redwoodSaplingBBox[0], redwoodSaplingBBox[1],
               redwoodSaplingBBox[2], redwoodSaplingBBox[3],
               redwoodSaplingBBox[4], redwoodSaplingBBox[5]);  
        glmFacetNormals(redwoodSapling);
        glmVertexNormals(redwoodSapling, 90.0);
        
        shrub1 = glmReadOBJ("shrub1.obj");
        if (!shrub1) exit(0);
        glmBoundingBox(shrub1,shrub1BBox);
        printf("shrub1 Bounding Box is (%f,%f,%f,%f,%f,%f)\n",
               shrub1BBox[0], shrub1BBox[1],
               shrub1BBox[2], shrub1BBox[3],
               shrub1BBox[4], shrub1BBox[5]);  
        glmFacetNormals(shrub1);
        glmVertexNormals(shrub1, 90.0);
}


// Need a custom camera to zoom in and properly see everything
// note: something funny happens to sky2 (back of the box)
//    when I use this camera.  :'(  I can't figure out why.
//    I'll fix this in the next version.
void setCamera() {
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(90,1,1,20);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(0, 6, 15, 
	      0, 8, -5, 
	      0, 1, 0);
}


void display(void) {
    twDisplayInit();
    //setCamera();
    twCamera();
    glPushAttrib(GL_ALL_ATTRIB_BITS);
    GLfloat pos[] = { 0.0, 0.0, 1.0, 0.0 };
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glLightfv(GL_LIGHT0, GL_POSITION, pos);
	
	// The green plain that will eventually be textured with grass.
	twTriple plainColor = {0.2, 0.4, 0};
	twColor(plainColor,0,0);
	glBegin(GL_QUADS);
	glVertex3f( BoundingBox[0], BoundingBox[2], BoundingBox[4] );
	glVertex3f( BoundingBox[1], BoundingBox[2], BoundingBox[4] );
	glVertex3f( BoundingBox[1], BoundingBox[2], BoundingBox[5] );
	glVertex3f( BoundingBox[0], BoundingBox[2], BoundingBox[5] );
	glEnd();
	
	// The plains that will eventually be textured with a sunset.
	twTriple skyColor = {0.5, 1, 1};
	twColor(skyColor,0,0);
	// The left side of the box: sky part 1.
	glBegin(GL_QUADS);
	glVertex3f( BoundingBox[0], BoundingBox[2], BoundingBox[4] );
	glVertex3f( BoundingBox[0], BoundingBox[2], BoundingBox[5] );
	glVertex3f( BoundingBox[0], BoundingBox[3], BoundingBox[5] );
	glVertex3f( BoundingBox[0], BoundingBox[3], BoundingBox[4] );
	glEnd();
	// The back side of the box: sky part 2.
	glBegin(GL_QUADS);
	glVertex3f( BoundingBox[0], BoundingBox[3], BoundingBox[4] );
	glVertex3f( BoundingBox[1], BoundingBox[3], BoundingBox[4] );
	glVertex3f( BoundingBox[1], BoundingBox[2], BoundingBox[4] );
	glVertex3f( BoundingBox[0], BoundingBox[2], BoundingBox[4] );
	glEnd();
	// The right side of the box: sky part 2.
	glBegin(GL_QUADS);
	glVertex3f( BoundingBox[1], BoundingBox[3], BoundingBox[5] );
	glVertex3f( BoundingBox[1], BoundingBox[3], BoundingBox[4] );
	glVertex3f( BoundingBox[1], BoundingBox[2], BoundingBox[4] );
	glVertex3f( BoundingBox[1], BoundingBox[2], BoundingBox[5] );
	glEnd();
	
	
	// Place deer near center.  Rotate slightly so we do not just 
	// see a square head, which is boring.
	// The deer is super crude at this stage; its just a dummy;
	// again, I will update this later.
	glPushMatrix();
	glTranslatef(2,0,2);
	glScalef( 0.7, 0.7, 0.7 );
	glRotatef( -40, 0, 1, 0 );
	glmDraw(deer, GLM_SMOOTH | GLM_MATERIAL);
	glPopMatrix();
	
	// Scatter some pine cones...
	glPushMatrix();
		glScalef( 0.7, 0.7, 0.7 );
		glTranslatef(2,0,0);
    	glmDraw(pinecones, GLM_SMOOTH | GLM_MATERIAL);
    	glTranslatef(-6,0,4);
    	glmDraw(pinecones, GLM_SMOOTH | GLM_MATERIAL);
    	glTranslatef(4,0,-5);
    	glmDraw(pinecones, GLM_SMOOTH | GLM_MATERIAL);
    	glTranslatef(1,0,2);
    	glmDraw(pinecones, GLM_SMOOTH | GLM_MATERIAL);
    	glTranslatef(-3,0,2);
    	glmDraw(pinecones, GLM_SMOOTH | GLM_MATERIAL);
    	glTranslatef(2,0,-3);
    	glmDraw(pinecones, GLM_SMOOTH | GLM_MATERIAL);
    glPopMatrix();
	
	// Place trees, two of each kind, around the deer in a random fashion.
	glPushMatrix();
    	glTranslatef(3,0,-3);
	achangBirchMedium(false);
    glPopMatrix();
    glPushMatrix();
        glTranslatef(6,0,4);
	achangBirchMedium(false);
    glPopMatrix();
    
    glPushMatrix();
    	glTranslatef(-6,0,-3.5);
    	glmDraw(birchSimple, GLM_SMOOTH | GLM_MATERIAL); 
    glPopMatrix();
    glPushMatrix();
        glTranslatef(-9,0,1.3);
    	glmDraw(birchSimple, GLM_SMOOTH | GLM_MATERIAL);   
    glPopMatrix();
    
    glPushMatrix();
    	glTranslatef(-7,0,2);
    	glmDraw(fallBirch, GLM_SMOOTH | GLM_MATERIAL);  
    glPopMatrix();
    glPushMatrix();
        glTranslatef(5,0,-2);
	    glmDraw(fallBirch, GLM_SMOOTH | GLM_MATERIAL);    
    glPopMatrix();
    
    glPushMatrix();
		glTranslatef(-3.8,0,0);
 		glmDraw(fir, GLM_SMOOTH | GLM_MATERIAL);
    glPopMatrix();
    glPushMatrix();
    	glTranslatef(6.8,0,2);
 		glmDraw(fir, GLM_SMOOTH | GLM_MATERIAL);
    glPopMatrix();
    
  	glPushMatrix();
  		glTranslatef(-8,0,-2);
    	glmDraw(mapleCluster, GLM_SMOOTH | GLM_MATERIAL);
    glPopMatrix();
    glPushMatrix();
		glTranslatef(-5,0,4);
    	glmDraw(mapleCluster, GLM_SMOOTH | GLM_MATERIAL);
    glPopMatrix();
    
    glPushMatrix();
    	glTranslatef(1.8,0,0);
    	glmDraw(oak, GLM_SMOOTH | GLM_MATERIAL);
    glPopMatrix();
    glPushMatrix();
		glTranslatef(-4.5,0,-1);
    	glmDraw(oak, GLM_SMOOTH | GLM_MATERIAL);
    glPopMatrix();
    
    glPushMatrix();
		glTranslatef(0.5,0,-4);
    	glmDraw(pineCraggy, GLM_SMOOTH | GLM_MATERIAL);
    glPopMatrix();
    glPushMatrix();
    	glTranslatef(3,0,0.7);
    	glmDraw(pineCraggy, GLM_SMOOTH | GLM_MATERIAL);
    glPopMatrix();

    glPushMatrix();
		glTranslatef(8,0,-4);
    	glmDraw(pineFast, GLM_SMOOTH | GLM_MATERIAL);
    glPopMatrix();
    glPushMatrix();
    	glTranslatef(-8,0,2);
    	glmDraw(pineFast, GLM_SMOOTH | GLM_MATERIAL);
    glPopMatrix();
    
    glPushMatrix();
		glTranslatef(8.5,0,4.5);
    	glmDraw(redwoodSapling, GLM_SMOOTH | GLM_MATERIAL);
    glPopMatrix();
    glPushMatrix();
		glTranslatef(7,0,-2.3);
    	glmDraw(redwoodSapling, GLM_SMOOTH | GLM_MATERIAL);
    glPopMatrix();
    
    glPushMatrix();
		glTranslatef(-4,0,4);
    	glmDraw(shrub1, GLM_SMOOTH | GLM_MATERIAL);
    glPopMatrix();
    glPushMatrix();
		glTranslatef(7,0,0.3);
    	glmDraw(shrub1, GLM_SMOOTH | GLM_MATERIAL);
    glPopMatrix();
    
    glPopAttrib();
    glFlush();
    glutSwapBuffers();
}

int main(int argc, char* argv[]) {
    char buf[256];

    initmodel();

    /* Ready to start doing OpenGL */

    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
    glutInitWindowSize(500,500);
    glutCreateWindow(argv[0]);
    glutDisplayFunc(display);

    twBoundingBox(BoundingBox[0],BoundingBox[1],
                  BoundingBox[2],BoundingBox[3],
                  BoundingBox[4],BoundingBox[5]);
    twMainInit();
    glutMainLoop();
    return (0);
}