//polyhedron (dancing dodecahedron and icosahedron)
//  the order of drawing objects
// 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

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[32];
} face_t;
typedef struct {
    int NumberofVertices; //of the object
    point3D_t pnt[100];
    int NumberofFaces; //of the object
    face_t fc[32];
} polyhedron_t;

static void makeDodecahedron(polyhedron_t &dodecahedron,float size)
{
    // size : an edge length of the dodecahedron
    float theta=2.0/5.0*M_PI;// 2 Pi/5 a central angle of the pentagon
    float alpha=3.0/5.0*M_PI;// an interior angle of the pentagon
    float r0;                // a radius of an inscribed circle
    float r1;                // a radius of a circumscribed circle
    float s1;                // a length of a diagonal line of the pentagon
    float r2;                // a radius of a circumscribed circle of the pentagon whose edge length is equal to s1
    float h1,h2,h;           // heights of the dodecahedron

    float r[4],th0[4],ha[4];
    int i,j,k;
    float th;
    face_t face[]={
        {5,{0,1,2,3,4}},{5,{0,5,10,6,1}},{5,{1,6,11,7,2}},
        {5,{2,7,12,8,3}},{5,{3,8,13,9,4}},{5,{4,9,14,5,0}},
        {5,{10,15,16,11,6}},{5,{11,16,17,12,7}},{5,{12,17,18,13,8}},
        {5,{13,18,19,14,9}},{5,{14,19,15,10,5}},{5,{15,19,18,17,16}}
    }; // every face has five vertices and showing vertex numbers

    dodecahedron.NumberofVertices=20;

    r1=size/(2.0*sin(theta/2.0));
    r0=r1*cos(theta/2.0);
    s1=2.0*size*sin(alpha/2.0);
    r2=s1/(2.0*sin(theta/2.0));
    h1=sqrt(size*size-(r2-r1)*(r2-r1));
    h2=sqrt((r0+r1)*(r0+r1)-(r2-r0)*(r2-r0));
    h=h1+h2;
    r[0]=r1; th0[0]=0.0; ha[0]=h-0.5*h;
    r[1]=r2; th0[1]=0.0; ha[1]=h2-0.5*h;
    r[2]=r2; th0[2]=0.2*M_PI; ha[2]=h1-0.5*h;
    r[3]=r1; th0[3]=0.2*M_PI; ha[3]=0.0-0.5*h;
    for (i = 0; i<4; i++){
        for (j = 0; j<5; j++){
            th=0.4*M_PI*(float)j+th0[i];
            k=5*i+j;
            dodecahedron.pnt[k].z=-r[i]*sin(th);
            dodecahedron.pnt[k].x=r[i]*cos(th);
            dodecahedron.pnt[k].y=ha[i];
        }
    }

    dodecahedron.NumberofFaces=12;

    for (i = 0; i<dodecahedron.NumberofFaces; i++){
        dodecahedron.fc[i]=face[i];
    }
}

static void makeIcosahedron(polyhedron_t &icosahedron,float size)
{
    // size : an edge length of the icosahedron
    float r1,r2,h1,h2,h3;
    float th0[2],h[2];
    int i,j,k;
    float th;
    face_t face[]={
        {3,{0,1,2}},{3,{0,2,3}},{3,{0,3,4}},{3,{0,4,5}},{3,{0,5,1}},
        {3,{1,6,2}},{3,{2,7,3}},{3,{3,8,4}},{3,{4,9,5}},{3,{5,10,1}},
        {3,{2,6,7}},{3,{3,7,8}},{3,{4,8,9}},{3,{5,9,10}},{3,{1,10,6}},
        {3,{6,11,7}},{3,{7,11,8}},{3,{8,11,9}},{3,{9,11,10}},{3,{10,11,6}}
    }; // every face has five vertices and showing vertex numbers

    icosahedron.NumberofVertices=12;

    r1=size*0.5/tan(0.2*M_PI); // a radius of an inscribed circle of the triangle
    r2=size*0.5/sin(0.2*M_PI); // a radius of a circumscribed circle of the triangle
    h1=sqrt(size*size-r2*r2);                     // height of vertex 1
    h2=h1+sqrt(3.0/4.0*size*size-(r2-r1)*(r2-r1));// height of vertex 1
    h3=h1+h2;                               // height of the icosahedron
    icosahedron.pnt[0].z=0.0;
    icosahedron.pnt[0].x=0.0;
    icosahedron.pnt[0].y=h3-h3/2;
    icosahedron.pnt[11].z=0.0;
    icosahedron.pnt[11].x=0.0;
    icosahedron.pnt[11].y=0.0-h3/2;
    th0[0]=0.0; h[0]=h2;
    th0[1]=0.2*M_PI; h[1]=h1;
    for (i = 0; i<2; i++){
        for (j = 0; j<5; j++){
            th=0.4*M_PI*(float)j+th0[i];
            k=5*i+j+1;
            icosahedron.pnt[k].z=-r2*sin(th);
            icosahedron.pnt[k].x=r2*cos(th);
            icosahedron.pnt[k].y=h[i]-h3/2;
        }
    }

    icosahedron.NumberofFaces=20;

    for (i = 0; i<icosahedron.NumberofFaces; i++){
        icosahedron.fc[i]=face[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};

    int disp=(tick/200)%2;
    static polyhedron_t dodecahedron0;
    polyhedron_t dodecahedron;
    static polyhedron_t icosahedron0;
    polyhedron_t icosahedron;
    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};
    color_t ColCyan={0,1,1};
    color_t ColRed={1,0,0};
    vector3D_t vec[32];
    vector3D_t vecbuff[32];
    vector3D_t NormalVector;
    vector3D_t ZeroVector={0,0,0,1};
    vector3D_t vecd,veci;

    float normalzi;//z of normal vector of the face
    float normalz[32];//z of normal vector of the face
    matrix3D_t rot,matd,mati;
    color_t fillcolor;
    int order[2];

    int i,j,lp;
    if (tick==0) {
        makeDodecahedron(dodecahedron0,70);
        makeIcosahedron(icosahedron0,110);
    }
    setColor(White);
    drawAxes(tilting);
    icosahedron=icosahedron0;
    dodecahedron=dodecahedron0;
    matd=translationMTX(130,0,0)*rotationYMTX(0.04*tick)*rotationZMTX(0.03*tick)*translationMTX(100,0,0)*rotationYMTX(0.01*tick)*rotationXMTX(0.02*tick);
    mati=translationMTX(130,0,0)*rotationYMTX(0.04*tick)*rotationZMTX(0.03*tick)*translationMTX(-100,0,0)*rotationYMTX(0.01*tick)*rotationXMTX(0.02*tick);
    switch(disp) {
    case 0: //visible or invisible
        glutSetWindowTitle("polyhedrons - wire frame models");
        rot=rotationYMTX(0.01*tick);
        matd=tilting*rot*matd;
        mati=tilting*rot*mati;
        for (i=0;i<dodecahedron.NumberofVertices;i++) {
            vec[i]=Point2Vector(dodecahedron.pnt[i]);
            vec[i]=matd*vec[i];
        }
        setColor(Blue);
        for (i=0;i<dodecahedron.NumberofFaces;i++) {
            for (j=0;j<dodecahedron.fc[i].NumberofVertices;j++) {
                vecbuff[j]=vec[dodecahedron.fc[i].pnt[j]];
            }
            NormalVector=(vecbuff[1]-vecbuff[0])^(vecbuff[2]-vecbuff[0]);
            normalz[i]=NormalVector.v[2];
            if (normalz[i]<0.) {
                drawPolygon(vecbuff,dodecahedron.fc[i].NumberofVertices);
            }
        }
        setColor(Cyan);
        for (i=0;i<dodecahedron.NumberofFaces;i++) {
            if (0.<=normalz[i]) {
                for (j=0;j<dodecahedron.fc[i].NumberofVertices;j++) {
                    vecbuff[j]=vec[dodecahedron.fc[i].pnt[j]];
                }
                drawPolygon(vecbuff,dodecahedron.fc[i].NumberofVertices);
            }
        }

        for (i=0;i<icosahedron.NumberofVertices;i++) {
            vec[i]=Point2Vector(icosahedron.pnt[i]);
            vec[i]=mati*vec[i];
        }
        setColor(Blue);
        for (i=0;i<icosahedron.NumberofFaces;i++) {
            for (j=0;j<icosahedron.fc[i].NumberofVertices;j++) {
                vecbuff[j]=vec[icosahedron.fc[i].pnt[j]];
            }
            NormalVector=(vecbuff[1]-vecbuff[0])^(vecbuff[2]-vecbuff[0]);
            normalz[i]=NormalVector.v[2];
            if (normalz[i]<0.) {
                drawPolygon(vecbuff,icosahedron.fc[i].NumberofVertices);
            }
        }
        setColor(Cyan);
        for (i=0;i<icosahedron.NumberofFaces;i++) {
            if (0.<=normalz[i]) {
                for (j=0;j<icosahedron.fc[i].NumberofVertices;j++) {
                    vecbuff[j]=vec[icosahedron.fc[i].pnt[j]];
                }
                drawPolygon(vecbuff,icosahedron.fc[i].NumberofVertices);
            }
        }
        break;
    case 1: //removing hidden faces and Phong model Flat shading
        glutSetWindowTitle("polyhedrons - removing hidden faces and Phong model Flat shading");
        rot=rotationYMTX(0.01*tick);
        matd=tilting*rot*matd;
        mati=tilting*rot*mati;
        vecd=matd*ZeroVector;
        veci=mati*ZeroVector;
        if (vecd.v[2]<veci.v[2]) {
            order[0]=0;order[1]=1;
        } else {
            order[0]=1;order[1]=0;
        }

        for (lp=0;lp<2;lp++) {
            if (order[lp]==0) {
                for (i=0;i<dodecahedron.NumberofVertices;i++) {
                    vec[i]=Point2Vector(dodecahedron.pnt[i]);
                    vec[i]=matd*vec[i];
                }
                for (i=0;i<dodecahedron.NumberofFaces;i++) {
                    for (j=0;j<dodecahedron.fc[i].NumberofVertices;j++) {
                        vecbuff[j]=vec[dodecahedron.fc[i].pnt[j]];
                    }
                    NormalVector=(vecbuff[1]-vecbuff[0])^(vecbuff[2]-vecbuff[0]);
                    normalzi=NormalVector.v[2];
                    if (0.<normalzi) {
                        for (j=0;j<dodecahedron.fc[i].NumberofVertices;j++) {
                        }
                        NormalVector=unitVector(NormalVector);
                        fillcolor=PhongModel(LightVector,NormalVector,ViewVector,ColCyan);
                        fillPolygon(vecbuff,dodecahedron.fc[i].NumberofVertices,fillcolor);
                    }
                }
            }
            if (order[lp]==1) {
                for (i=0;i<icosahedron.NumberofVertices;i++) {
                    vec[i]=Point2Vector(icosahedron.pnt[i]);
                    vec[i]=mati*vec[i];
                }
                for (i=0;i<icosahedron.NumberofFaces;i++) {
                    for (j=0;j<icosahedron.fc[i].NumberofVertices;j++) {
                        vecbuff[j]=vec[icosahedron.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,ColRed);
                        fillPolygon(vecbuff,icosahedron.fc[i].NumberofVertices,fillcolor);
                    }
                }
            }
        }
        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 ("polyhedrons");
    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;
}