#include "include.h"
#include "util3d.h"
#include "render.h"
#include "init.h"
#include "geom_menu.h"
#include "geom.h"
#include "light.h"
#include "globals.h"

// global variables
RenderState gstate;
float cm[16] = {
    1.0f, 0.0f, 0.0f, 0.0f,
    0.0f, 1.0f, 0.0f, 0.0f,
    0.0f, 0.0f, 1.0f, 0.0f,
    0.0f, 0.0f, 0.0f, 1.0f
};
int window_size[2];

void UpdateMatrix();
void Transformations();
int main(int argc, char *argv[]);


void draw_bkground()
{
    glPushAttrib(GL_ALL_ATTRIB_BITS);
    glTexImage2D(GL_TEXTURE_2D, 0, gstate.bg_sizeZ, gstate.bg_sizeX,
                 gstate.bg_sizeY, 0, gstate.bg_sizeZ == 3 ? GL_RGB : GL_RGBA,
                 GL_UNSIGNED_BYTE, gstate.bg_data);
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
    glBegin(GL_POLYGON);
        glTexCoord2f(0.0, 0.0); 
        glVertex2f(-0.0038f * window_size[X], -0.0038f * window_size[Y]);
        glTexCoord2f(1.0, 0.0); 
        glVertex2f( 0.0038f * window_size[X], -0.0038f * window_size[Y]);
        glTexCoord2f(1.0, 1.0); 
        glVertex2f( 0.0038f * window_size[X],  0.0038f * window_size[Y]);
        glTexCoord2f(0.0, 1.0); 
        glVertex2f(-0.0038f * window_size[X],  0.0038f * window_size[Y]);
    glEnd();
    glPopAttrib();
}

// update the rotation matrix
void UpdateMatrix()
{
    glPushMatrix();
    glLoadIdentity();

    switch(gstate.axis) {
	case 'x': case 'X': case 'y': case 'Y':
	    glRotatef(gstate.xrot, 1.0f, 0.0f, 0.0f);
	    glRotatef(gstate.yrot, 0.0f, 1.0f, 0.0f);
	    break;

	case 'z': case 'Z':
	    glRotatef(gstate.zrot, 0.0f, 0.0f, 1.0f);
	    break;
    }

    glMultMatrixf(cm);
    // put the commulative matrix on top of the matrix stack
    glGetFloatv(GL_MODELVIEW_MATRIX, cm);
    glPopMatrix();
}

// applies the translations and scaling
void Transformations()
{
    UpdateMatrix();
    glLoadIdentity();

    glTranslatef(gstate.dx, gstate.dy, gstate.dz);
    glScalef(gstate.scale_factor, gstate.scale_factor, gstate.scale_factor);

    glMultMatrixf(cm);
}

void CreateCB(struct Togl *togl)
{
    InitStates();
    InitEvent();
    init_geom_data();
    InitGL();
}

void ReshapeCB(struct Togl *togl)
{
    window_size[X] = Togl_Width(togl);
    window_size[Y] = Togl_Height(togl);

    glViewport(0, 0, window_size[X], window_size[Y]);
}

void RenderCB(struct Togl *togl)
{
    double aspect;

    aspect = (double)window_size[X]/(double)window_size[Y];

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0, aspect, gstate.nearCP, gstate.farCP);
    gluLookAt(gstate.cop[X], gstate.cop[Y], gstate.cop[Z], gstate.vrp[X], 
              gstate.vrp[Y], gstate.vrp[Z], 0.0, 1.0, 0.0);

    if (gstate.bg_on) {
        glClear(GL_DEPTH_BUFFER_BIT);

        if (!gstate.texmap) {
            glEnable(GL_TEXTURE_2D);
        }
        if (gstate.wire_frame) {
            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
        }

        glDisable(GL_DEPTH_TEST);
        glPushMatrix();
        draw_bkground();
        glPopMatrix();
        glEnable(GL_DEPTH_TEST);

        if (gstate.wire_frame) {
            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
        }
        if (!gstate.texmap) {
            glDisable(GL_TEXTURE_2D);
        }
    }
    else {
        glClearColor(gstate.bg_r/(float)255, gstate.bg_g/(float)255, 
                     gstate.bg_b/(float)255, 0.0);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    }

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glPushMatrix();
    Transformations();

    if (gstate.texmap && gstate.envmap) {
        gstate.num_polygons = geometry_display_list();
    }
    else {
        glCallList(1);
    }

    glPopMatrix();

    glFlush();
    Togl_SwapBuffers(togl);
}

int main(int argc, char *argv[])
{
    Tk_Main(argc, argv, InitTcl);
    return 0;
}