// torus
//  face z-sorting to draw faces
//  In the case of a red torus, no face z-sorting technique is used and
//  failed to complete the torus.
// T. Kosaka CS TNCT 2001

#include <stdio.h>
#include <math.h>
#include <GL/glut.h>
#include "drawtools3D.h"
#ifndef M_PI
#define M_PI 3.141592653589793
#endif

#define MAXSIZE 8192

void userdraw(void);

void display(void)
{
    glClear( GL_COLOR_BUFFER_BIT);
    userdraw();
    glutSwapBuffers();
}

//////////////////////////////////////////////////////////////////
void drawcharX(float x,float y)
{
    drawLine(x,y,x+10,y+12);drawLine(x,y+12,x+10,y);
}

void drawcharY(float x,float y)
{
    drawLine(x+5,y,x+5,y+7);drawLine(x,y+12,x+5,y+7);drawLine(x+10,y+12,x+5,y+7);
}

void drawcharZ(float x,float y)
{
    drawLine(x,y+12,x+10,y+12);drawLine(x+10,y+12,x,y);drawLine(x,y,x+10,y);
}

void drawAxes(matrix3D_t view)
{
#define HALFAXIS  220
#define HALFAXIS1 (HALFAXIS-10)
    point3D_t axes[14]={
        {-HALFAXIS,0,0},{HALFAXIS,0,0},{HALFAXIS1,5,0},{HALFAXIS1,0,0},{0,0,0},
        {0,-HALFAXIS,0},{0,HALFAXIS,0},{0,HALFAXIS1,5},{0,HALFAXIS1,0},{0,0,0},
        {0,0,-HALFAXIS},{0,0,HALFAXIS},{5,0,HALFAXIS1},{0,0,HALFAXIS1}
    };
    vector3D_t vec[14];
    int i;
    for (i=0;i<14;i++) {
        vec[i]=Point2Vector(axes[i]);
        vec[i]=view*vec[i];
    }
    drawPolyline(vec,14);
    drawcharX(vec[1].v[0],vec[1].v[1]);
    drawcharY(vec[6].v[0],vec[6].v[1]);
    drawcharZ(vec[11].v[0]-14,vec[11].v[1]);
}

//////////////////////////////////////////////////////////////////
typedef struct {
    int NumberofVertices; //in the face
    short int pnt[8];
} face_t;
typedef struct {
    int NumberofVertices; //of the object
    point3D_t pnt[MAXSIZE];
    vector3D_t NormalVector[MAXSIZE]; // at the pnt
    int NumberofFaces; //of the object
    face_t fc[MAXSIZE];
} smoothpolyhedron_t;

static void makeTorus(smoothpolyhedron_t &torus,float r0,float r1)
{
    // r1 : radius of the ring
    // r0 : radius of the circle
    float circleangle;
    float ringangle;
    int NumCclEdge=20;
    int NumRngEdge=40;
    int i,j,k;
    vector3D_t unitx={1,0,0,1};
    vector3D_t vec;
    matrix3D_t mat;
    
    torus.NumberofVertices=NumCclEdge*NumRngEdge;

    mat=translationMTX(r1,0,0)*scalingMTX(r0,r0,r0);
    for(j=0;j<NumCclEdge;j++) {
        circleangle=j/(float)NumCclEdge*2.*M_PI;
        torus.NormalVector[j]=rotationZMTX(circleangle)*unitx;
        torus.pnt[j]=Vector2Point(mat*torus.NormalVector[j]);
    }
    for(i=1;i<NumRngEdge;i++) {
        ringangle=i/(float)NumRngEdge*2.*M_PI;
        mat=rotationYMTX(ringangle);
        for(j=0;j<NumCclEdge;j++) {
            k=NumCclEdge*i+j;
            torus.NormalVector[k]=mat*torus.NormalVector[j];
            vec=Point2Vector(torus.pnt[j]);
            torus.pnt[k]=Vector2Point(mat*vec);
        }
    }

    torus.NumberofFaces=NumCclEdge*NumRngEdge;

    for(i=0;i<NumRngEdge;i++) {
        if (i<NumRngEdge-1) {
            for(j=0;j<NumCclEdge;j++) {
                k=NumCclEdge*i+j;
                torus.fc[k].NumberofVertices=4;
                torus.fc[k].pnt[0]=k;
                torus.fc[k].pnt[1]=k+NumCclEdge;
                if (j!=NumCclEdge-1) {
                    torus.fc[k].pnt[2]=k+NumCclEdge+1;
                    torus.fc[k].pnt[3]=k+1;
                } else {
                    torus.fc[k].pnt[2]=NumCclEdge*i+NumCclEdge;
                    torus.fc[k].pnt[3]=NumCclEdge*i;
                }
            }
        } else {
            for(j=0;j<NumCclEdge;j++) {
                k=NumCclEdge*i+j;
                torus.fc[k].NumberofVertices=4;
                torus.fc[k].pnt[0]=k;
                torus.fc[k].pnt[1]=j;
                if (j!=NumCclEdge-1) {
                    torus.fc[k].pnt[2]=j+1;
                    torus.fc[k].pnt[3]=k+1;
                } else {
                    torus.fc[k].pnt[2]=0;
                    torus.fc[k].pnt[3]=NumCclEdge*i;
                }
            }
        }
    }
}

void userdraw(void)
{
    static int tick=0;
    float theta=0.5;
    matrix3D_t tilting=rotationXMTX(theta)*rotationYMTX(-theta);
    color_t White={1.,1.,1.};
    color_t Cyan={0,1,1};
    color_t Blue={0,0,1};
    color_t Red={1,0,0};

    int disp=(tick/400)%4;
    int tickindisp=tick%400;
    static smoothpolyhedron_t torus0;
    static smoothpolyhedron_t torus;
    vector3D_t unitz={0,0,1,1};
    vector3D_t LightVector0=rotationYMTX(0.2)*rotationXMTX(-1.2)*unitz;
    vector3D_t LightVector=tilting*LightVector0;
    vector3D_t ViewVector={0,0,1,1};
    vector3D_t ZeroVector={0,0,0,1};
    static vector3D_t vec[MAXSIZE];
    static vector3D_t nrmvec[MAXSIZE];
    vector3D_t vecbuff[8];
    vector3D_t nrmvecbuff[8];
    vector3D_t NormalVector;
    color_t colbuff[8];
    float normalzi;//z of normal vector of the face
    static float normalz[MAXSIZE];//z of normal vector of the face
    static int order[MAXSIZE];
    matrix3D_t rot,mat;
    color_t fillcolor;

    int i,j,k;
    if (tick==0) {
        makeTorus(torus0,60,180);
    }
    torus=torus0;
    setColor(White);
    drawAxes(tilting);

    switch(disp) {
    case 0: //visible or invisible
        glutSetWindowTitle("torus - wire frame model");
        rot=rotationYMTX(0.02*tickindisp);
        mat=tilting*rot;
        for (i=0;i<torus.NumberofVertices;i++) {
            vec[i]=Point2Vector(torus.pnt[i]);
            vec[i]=mat*vec[i];
        }
        setColor(Blue);
        for (i=0;i<torus.NumberofFaces;i++) {
            for (j=0;j<torus.fc[i].NumberofVertices;j++) {
                vecbuff[j]=vec[torus.fc[i].pnt[j]];
            }
            NormalVector=(vecbuff[1]-vecbuff[0])^(vecbuff[2]-vecbuff[0]);
            normalz[i]=NormalVector.v[2];
            if (normalz[i]<0.) {
                drawPolygon(vecbuff,torus.fc[i].NumberofVertices);
            }
        }
        setColor(Cyan);
        for (i=0;i<torus.NumberofFaces;i++) {
            if (0.<=normalz[i]) {
                for (j=0;j<torus.fc[i].NumberofVertices;j++) {
                    vecbuff[j]=vec[torus.fc[i].pnt[j]];
                }
                drawPolygon(vecbuff,torus.fc[i].NumberofVertices);
            }
        }
        break;
    case 1: // rotation about z-axis
        //removing hidden faces and Phong model Flat shading
        // this doesn't work correctly
        glutSetWindowTitle("torus - Flat shading without Z sorting");
        rot=rotationZMTX(0.02*tickindisp)*rotationYMTX(0.02*tickindisp);
        mat=tilting*rot;
        for (i=0;i<torus.NumberofVertices;i++) {
            vec[i]=Point2Vector(torus.pnt[i]);
            vec[i]=mat*vec[i];
        }
        for (i=0;i<torus.NumberofFaces;i++) {
            for (j=0;j<torus.fc[i].NumberofVertices;j++) {
                vecbuff[j]=vec[torus.fc[i].pnt[j]];
            }
            NormalVector=(vecbuff[1]-vecbuff[0])^(vecbuff[2]-vecbuff[0]);
            normalzi=NormalVector.v[2];
            if (0.<normalzi) {
                NormalVector=unitVector(NormalVector);
                fillcolor=PhongModel(LightVector,NormalVector,ViewVector,Red);
                fillPolygon(vecbuff,torus.fc[i].NumberofVertices,fillcolor);
            }
        }
        break;
    case 2:  // rotation about z-axis
        // removing hidden faces and Phong model Flat shading
        // sorting in depth order
        glutSetWindowTitle("torus - Flat shading with Z sorting");
        rot=rotationZMTX(0.02*tickindisp)*rotationYMTX(0.02*tickindisp);
        mat=tilting*rot;
        for (i=0;i<torus.NumberofVertices;i++) {
            vec[i]=Point2Vector(torus.pnt[i]);
            vec[i]=mat*vec[i];
        }

        // z-sort
        for (i=0;i<torus.NumberofFaces;i++) order[i]=i;
        for (i=0;i<torus.NumberofFaces;i++) {
            for (j=torus.NumberofFaces-2;i<=j;j--) {
                k=j+1;
                if (vec[torus.fc[order[k]].pnt[0]].v[2]<vec[torus.fc[order[j]].pnt[0]].v[2]) {
                    int tmp=order[k];
                    order[k]=order[j];
                    order[j]=tmp;
                }
            }
        }

        for (i=0;i<torus.NumberofFaces;i++) {
            for (j=0;j<torus.fc[order[i]].NumberofVertices;j++) {
                vecbuff[j]=vec[torus.fc[order[i]].pnt[j]];
            }
            NormalVector=(vecbuff[1]-vecbuff[0])^(vecbuff[2]-vecbuff[0]);
            normalzi=NormalVector.v[2];
            if (0.<normalzi) {
                NormalVector=unitVector(NormalVector);
                fillcolor=PhongModel(LightVector,NormalVector,ViewVector,Cyan);
                fillPolygon(vecbuff,torus.fc[order[i]].NumberofVertices,fillcolor);
            }
        }
        break;
    case 3: // rotation about z-axis
        glutSetWindowTitle("torus - Gouraud shading with Z sorting");
        //removing hidden faces and Phong model Gouraud shading
        rot=rotationZMTX(0.02*tickindisp)*rotationYMTX(0.02*tickindisp);
        mat=tilting*rot;
        ZeroVector=mat*ZeroVector;
        for (i=0;i<torus.NumberofVertices;i++) {
            vec[i]=Point2Vector(torus.pnt[i]);
            vec[i]=mat*vec[i];
            nrmvec[i]=mat*torus.NormalVector[i]-ZeroVector;
        }

        // z-sort
        for (i=0;i<torus.NumberofFaces;i++) order[i]=i;
        for (i=0;i<torus.NumberofFaces;i++) {
            for (j=torus.NumberofFaces-2;i<=j;j--) {
                k=j+1;
                if (vec[torus.fc[order[k]].pnt[0]].v[2]<vec[torus.fc[order[j]].pnt[0]].v[2]) {
                    int tmp=order[k];
                    order[k]=order[j];
                    order[j]=tmp;
                }
            }
        }

        for (i=0;i<torus.NumberofFaces;i++) {
            for (j=0;j<torus.fc[order[i]].NumberofVertices;j++) {
                vecbuff[j]=vec[torus.fc[order[i]].pnt[j]];
                nrmvecbuff[j]=nrmvec[torus.fc[order[i]].pnt[j]];
            }
            NormalVector=(vecbuff[1]-vecbuff[0])^(vecbuff[2]-vecbuff[0]);
            normalzi=NormalVector.v[2];
            if (0.<normalzi) {
                for (j=0;j<torus.fc[order[i]].NumberofVertices;j++) {
                    NormalVector=unitVector(nrmvecbuff[j]);
                    colbuff[j]=PhongModel(LightVector,NormalVector,ViewVector,Cyan);
                }
                gradatePolygon(vecbuff,colbuff,torus.fc[order[i]].NumberofVertices);
            }
        }
        //tick+=2;
        break;
    default:
        break;
    }
    tick++;
}

int main(int argc, char **argv)
{
    glutInit(&argc,argv);
    glutInitDisplayMode ( GLUT_DOUBLE | GLUT_RGB );
    glutInitWindowPosition(100,100);
    glutInitWindowSize(640,480);
    glutCreateWindow ("torus");
    glClearColor(0.0, 0.0, 0.0, 0.0);
    gluOrtho2D(-320., 320., -240.0, 240.0);
      // Define the dimensions of the Orthographic Viewing Volume
    glutIdleFunc(display); // idle event call back
    glutDisplayFunc(display);
    glutMainLoop();
    return 0;
}