// torus with class
//  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 "CGCore3D.h"
#ifndef M_PI
#define M_PI 3.141592653589793
#endif

void userdraw(void);

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

//////////////////////////////////////////////////////////////////
static void makeTorus(C_Smoothpolyhedron &torus,float r0,float r1,int NumCclEdge,int NumRngEdge,C_Color color,opticalAttribute_t attr)
{
    // r0 : radius of the circle
    // r1 : radius of the ring
    // NumCclEdge : number of segments along the circle
    // NumRngEdge : number of segments along the ring
    int NumberVertices;      //多面体を構成する頂点の数
    C_Vertex *Vertex;        //多面体を構成する頂点の座標
    C_Vector *NormalVector;  //各擬似頂点位置の法線ベクトル
    int NumberFaces;         //多面体を構成する面の数
    C_Face *Face;            //多面体を構成する面の定義
    float circleangle;
    float ringangle;
    int i,j,k;
    C_Vertex unitx(1,0,0);
    C_Vertex vec;
    C_Matrix mat,mat1,mat2,mat3;
    
    NumberVertices=NumCclEdge*NumRngEdge;
    Vertex=new C_Vertex[NumberVertices];
    NormalVector=new C_Vector[NumberVertices];

    mat1.setScale(r0,r0,r0);
    mat2.setTranslation(r1,0,0);
    mat=mat2*mat1;
    for(j=0;j<NumCclEdge;j++) {
        circleangle=j/(float)NumCclEdge*2.*M_PI;
        mat3.setRotationZ(circleangle);
        NormalVector[j]=mat3*unitx;
        Vertex[j]=mat*NormalVector[j];
    }
    for(i=1;i<NumRngEdge;i++) {
        ringangle=i/(float)NumRngEdge*2.*M_PI;
        mat.setRotationY(ringangle);
        for(j=0;j<NumCclEdge;j++) {
            k=NumCclEdge*i+j;
            NormalVector[k]=mat*NormalVector[j];
            Vertex[k]=mat*Vertex[j];
        }
    }

    NumberFaces=NumCclEdge*NumRngEdge;
    Face=new C_Face[NumberFaces];

    for(i=0;i<NumRngEdge;i++) {
        if (i<NumRngEdge-1) {
            for(j=0;j<NumCclEdge;j++) {
                k=NumCclEdge*i+j;
                Face[k].numberVertices=4;
                Face[k].VertexNumber=new int[4];
                Face[k].VertexNumber[0]=k;
                Face[k].VertexNumber[1]=k+NumCclEdge;
                if (j!=NumCclEdge-1) {
                    Face[k].VertexNumber[2]=k+NumCclEdge+1;
                    Face[k].VertexNumber[3]=k+1;
                } else {
                    Face[k].VertexNumber[2]=NumCclEdge*i+NumCclEdge;
                    Face[k].VertexNumber[3]=NumCclEdge*i;
                }
            }
        } else {
            for(j=0;j<NumCclEdge;j++) {
                k=NumCclEdge*i+j;
                Face[k].numberVertices=4;
                Face[k].VertexNumber=new int[4];
                Face[k].VertexNumber[0]=k;
                Face[k].VertexNumber[1]=j;
                if (j!=NumCclEdge-1) {
                    Face[k].VertexNumber[2]=j+1;
                    Face[k].VertexNumber[3]=k+1;
                } else {
                    Face[k].VertexNumber[2]=0;
                    Face[k].VertexNumber[3]=NumCclEdge*i;
                }
            }
        }
    }
    torus.createSmoothPolyhedron(Vertex,NormalVector,NumberVertices,Face,NumberFaces,color,attr);
    delete[] Vertex;
    delete[] NormalVector;
    for (i=0;i<NumberFaces;i++) Face[i].~C_Face();
    delete[] Face;

}

void userdraw(void)
{
    static int tick=0;
    int disp=(tick/200)%5;
    static C_Smoothpolyhedron torus;
    float phi=0.5;    // for tilting
    float theta=-0.5; // for tilting
    C_Vector ViewVector(0,0,1);
    C_Vector LightVector(0,1,0);
    C_Scene myScene;

    if (tick==0) {
        opticalAttribute_t attr;
        C_Color Cyan(0,1,1);
        attr.kspe=0.7; // specular reflection coefficient
        attr.kdif=0.6; // diffuse reflection coefficient
        attr.kamb=0.4; // ambient light coefficient
        makeTorus(torus,60,180,20,40,Cyan,attr);
    }
    myScene.drawAxes();

    myScene.initializeTMatrix();
    myScene.setRotationZ(0.05*tick);
    myScene.setScale(1,0.8+0.2*sin(0.05*tick),1);
    myScene.setRotationY(0.02*tick);

    switch (disp) {
    case 0:
        myScene.drawPolyhedronWire(torus);
        break;
    case 1:
        myScene.drawPolyhedronSurface(torus);
        break;
    case 2:
        myScene.drawPolyhedronSmoothSurface(torus);
        break;
    case 3:
        myScene.drawPolyhedronSurfaceZSort(torus);
        break;
    case 4:
        myScene.drawPolyhedronSmoothSurfaceZSort(torus);
        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;
}