//sphere
//  mesh modeling
//  Gouraud shading
// T. Kosaka CS TNCT 8Aug2002

#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 makeSphere(smoothpolyhedron_t &sphere,float r)
{
    // r : radius of the sphere
    //球の赤道面はｘｚ平面上にあり，北極はｙ軸上（＋方向）にあり，
    //南極はy軸上（−方向）にある
    float latitude; /*緯度（赤道面から上方向が＋）*/
    float longitude; /*経度（x軸方向が0で北極から見て反時計回りが＋）*/
    int NumLatEdge=18; /*経度方向分割数（線の数（＝点の数−１））*/
    int NumLngEdge=32; /*緯度方向分割数（線の数（＝点の数））*/
    int i,j,k;
    vector3D_t unitz={0,0,1,1}; /*z方向単位ベクトル*/
    vector3D_t unityn={0,1,0,1}; /*y方向＋（北極方向）*/
    vector3D_t unitys={0,-1,0,1}; /*y方向−（南極方向）単位ベクトル*/
    matrix3D_t mat;
    
    //球（見かけ上の球）を構成する頂点の数
    sphere.NumberofVertices=1+(NumLatEdge-1)*NumLngEdge+1;

    //頂点の座標とその頂点における法線ベクトルの定義
    sphere.NormalVector[0]=unityn; //点番号0（北極点）における法線ベクトル
    sphere.pnt[0]=Vector2Point(r*sphere.NormalVector[0]);//点番号0の点の座標（北極点）
    for(i=1;i<NumLatEdge;i++) {//経線にそって北極から南極に向かって点を定義してゆく
        latitude=(NumLatEdge/2.-i)/(float)NumLatEdge*M_PI;//緯度（経線に沿った角度（北緯が負））
        mat=rotationXMTX(-latitude);
        for(j=0;j<NumLngEdge;j++) {//緯線に沿った作業
            k=NumLngEdge*(i-1)+j+1;
            longitude=(float)j/NumLngEdge*2.*M_PI;//経度（経線に沿った角度（ｘ軸方向が0））
            sphere.NormalVector[k]=rotationYMTX(longitude)*mat*unitz;//頂点での法線方向ベクトル
            sphere.pnt[k]=Vector2Point(r*sphere.NormalVector[k]);//頂点の座標
        }
    }
    k=(NumLatEdge-1)*NumLngEdge+1;
    sphere.NormalVector[k]=unitys;
    sphere.pnt[k]=Vector2Point(r*sphere.NormalVector[k]);

    //球（見かけ上の球）を構成する面の数
    sphere.NumberofFaces=NumLatEdge*NumLngEdge;

    //面の定義（面を構成する点番号の定義））
    for(i=0;i<NumLatEdge;i++) {
        if (i==0) {             //最初のところは三角形（北極点のまわり）
            for(j=0;j<NumLngEdge;j++) {
                k=j;
                sphere.fc[k].NumberofVertices=3; //頂点数は3
                sphere.fc[k].pnt[0]=0;
                sphere.fc[k].pnt[1]=k+1;
                if (j!=NumLngEdge-1) {
                    sphere.fc[k].pnt[2]=k+2;
                } else {
                    sphere.fc[k].pnt[2]=1;
                }
            }
        } else if (i<NumLatEdge-1) {    //中間は四角形
            for(j=0;j<NumLngEdge;j++) {
                k=NumLngEdge*i+j;
                sphere.fc[k].NumberofVertices=4; //頂点数は4
                sphere.fc[k].pnt[0]=k+1-NumLngEdge;
                sphere.fc[k].pnt[1]=k+1;
                if (j!=NumLngEdge-1) {
                    sphere.fc[k].pnt[2]=k+2;
                    sphere.fc[k].pnt[3]=k+2-NumLngEdge;
                } else {
                    sphere.fc[k].pnt[2]=NumLngEdge*i+1;
                    sphere.fc[k].pnt[3]=NumLngEdge*i+1-NumLngEdge;
                }
            }
        } else {             //最後のところは三角形（南極点のまわり）
            for(j=0;j<NumLngEdge;j++) {
                k=NumLngEdge*i+j;
                sphere.fc[k].NumberofVertices=3; //頂点数は3
                sphere.fc[k].pnt[0]=k+1-NumLngEdge;
                sphere.fc[k].pnt[1]=(NumLatEdge-1)*NumLngEdge+1;
                if (j!=NumLngEdge-1) {
                    sphere.fc[k].pnt[2]=k+2-NumLngEdge;
                } else {
                    sphere.fc[k].pnt[2]=NumLngEdge*i+1-NumLngEdge;
                }
            }
        }
    }
}

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)%3;
    int tickindisp=tick%200;
    static smoothpolyhedron_t sphere0;
    static smoothpolyhedron_t sphere;
    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};
    color_t ColCyan={0,1,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
    matrix3D_t rot,mat;
    color_t fillcolor;
    int i,j;

    if (tick==0) {
        makeSphere(sphere0,150);
    }
    setColor(White);
    drawAxes(tilting);

    sphere=sphere0;
    switch(disp) {
    case 0: //visible or invisible
        glutSetWindowTitle("sphere - wire frame model");
        rot=rotationYMTX(0.02*tickindisp);
        mat=tilting*rot;
        for (i=0;i<sphere.NumberofVertices;i++) {
            vec[i]=Point2Vector(sphere.pnt[i]);
            vec[i]=mat*vec[i];
        }
        setColor(Blue);
        for (i=0;i<sphere.NumberofFaces;i++) {
            for (j=0;j<sphere.fc[i].NumberofVertices;j++) {
                vecbuff[j]=vec[sphere.fc[i].pnt[j]];
            }
            NormalVector=(vecbuff[1]-vecbuff[0])^(vecbuff[2]-vecbuff[0]);
            normalz[i]=NormalVector.v[2];
            if (normalz[i]<0.) {
                drawPolygon(vecbuff,sphere.fc[i].NumberofVertices);
            }
        }
        setColor(Cyan);
        for (i=0;i<sphere.NumberofFaces;i++) {
            if (0.<=normalz[i]) {
                for (j=0;j<sphere.fc[i].NumberofVertices;j++) {
                    vecbuff[j]=vec[sphere.fc[i].pnt[j]];
                }
                drawPolygon(vecbuff,sphere.fc[i].NumberofVertices);
            }
        }
        break;
    case 1: //removing hidden faces and Phong model Flat shading
        glutSetWindowTitle("sphere - removing hidden faces and Phong model Flat shading");
        rot=rotationYMTX(0.02*tickindisp);
        mat=tilting*rot;
        for (i=0;i<sphere.NumberofVertices;i++) {
            vec[i]=Point2Vector(sphere.pnt[i]);
            vec[i]=mat*vec[i];
        }
        for (i=0;i<sphere.NumberofFaces;i++) {
            for (j=0;j<sphere.fc[i].NumberofVertices;j++) {
                vecbuff[j]=vec[sphere.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,ColCyan);
                fillPolygon(vecbuff,sphere.fc[i].NumberofVertices,fillcolor);
            }
        }
        break;
    case 2: //removing hidden faces and Phong model Gouraud shading
        glutSetWindowTitle("sphere - removing hidden faces and Phong model Gouraud shading");
        rot=rotationYMTX(0.02*tickindisp);
        mat=tilting*rot;
        ZeroVector=mat*ZeroVector;
        for (i=0;i<sphere.NumberofVertices;i++) {
            vec[i]=Point2Vector(sphere.pnt[i]);
            vec[i]=mat*vec[i];
            nrmvec[i]=mat*sphere.NormalVector[i]-ZeroVector;
        }
        for (i=0;i<sphere.NumberofFaces;i++) {
            for (j=0;j<sphere.fc[i].NumberofVertices;j++) {
                vecbuff[j]=vec[sphere.fc[i].pnt[j]];
                nrmvecbuff[j]=nrmvec[sphere.fc[i].pnt[j]];
            }
            NormalVector=(vecbuff[1]-vecbuff[0])^(vecbuff[2]-vecbuff[0]);
            normalzi=NormalVector.v[2];
            if (0.<normalzi) {
                for (j=0;j<sphere.fc[i].NumberofVertices;j++) {
                    NormalVector=unitVector(nrmvecbuff[j]);
                    colbuff[j]=PhongModel(LightVector,NormalVector,ViewVector,ColCyan);
                }
                gradatePolygon(vecbuff,colbuff,sphere.fc[i].NumberofVertices);
            }
        }
        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 ("sphere");
    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;
}