//torussphere
//  Demonstration of shading and lighting with moving sphere and torus
//  mesh models
//  smooth shading
// T. Kosaka CS TNCT 16Aug2002

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

GLfloat White[] = { 1.0, 1.0, 1.0, 1.0 }; // R,G,B,A
GLfloat Cyan[] = { 0.0, 1.0, 1.0, 1.0 }; // R,G,B,A
GLfloat Gray[] = { 0.2, 0.2, 0.2, 1.0 }; // R,G,B,A
GLfloat Red[] = { 1.0, 0.0, 0.0, 1.0 }; // R,G,B,A
GLfloat Shine[] = { 20.0}; //0.0(large highlight) ... 128.0(small highlight)

void userdraw(void);

void display(void)
{
    glClear( GL_COLOR_BUFFER_BIT);
    glClear(GL_DEPTH_BUFFER_BIT); // depth check
    userdraw();
    glutSwapBuffers();
}

//////////////////////////////////////////////////////////////////
static void makeSphereGL(smoothpolyhedron_t &sphere,float r)
{
    // r : radius of the sphere
    float latitude;
    float longitude;
    int NumLatEdge=18;
    int NumLngEdge=32;
    int i,j,k;
    vector3D_t unitz={0,0,1,1};
    vector3D_t unityn={0,1,0,1};
    vector3D_t unitys={0,-1,0,1};
    matrix3D_t mat;
    vector3D_t vecbuff[4];
    
    sphere.NumberofVertices=1+(NumLatEdge-1)*NumLngEdge+1;

    sphere.NormalVector[0]=unityn;
    sphere.pnt[0]=Vector2Point(r*sphere.NormalVector[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;
            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;
                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;
                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;
                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;
                }
            }
        }
    }
    for (i=0;i<sphere.NumberofFaces;i++) {
        for (j=0;j<3;j++) {
            vecbuff[j]=Point2Vector(sphere.pnt[sphere.fc[i].pnt[j]]);
        }
        sphere.fc[i].NormalVector=(vecbuff[1]-vecbuff[0])^(vecbuff[2]-vecbuff[0]);
    }
}

static void makeTorusGL(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;
    vector3D_t vecbuff[4];
    
    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;
                }
            }
        }
    }
    for (i=0;i<torus.NumberofFaces;i++) {
        for (j=0;j<3;j++) {
            vecbuff[j]=Point2Vector(torus.pnt[torus.fc[i].pnt[j]]);
        }
        torus.fc[i].NormalVector=(vecbuff[1]-vecbuff[0])^(vecbuff[2]-vecbuff[0]);
    }
}

void userdraw(void)
{
    static int tick=0;
    int disp=(tick/200)%2;
    float k1=tick*0.01;
    static smoothpolyhedron_t sphere;
    static smoothpolyhedron_t torus;

    if (tick==0) {
        makeSphereGL(sphere,80);
        makeTorusGL(torus,60,180);
    }

    myInitView(1);

    glRotatef(k1*180.0, 0.0, 1.0, 0.0); // Matrix A
    glTranslatef(150.0, 0.0, 0.0); // Matrix B
    glRotatef(-k1*500.0, 0.0, 0.0, 1.0); // Matrix C
    glRotatef(k1*520.0, 1.0, 0.0, 0.0); // Matrix D

    glMaterialfv(GL_FRONT, GL_AMBIENT, Gray); //Attribute of the object
    glMaterialfv(GL_FRONT, GL_DIFFUSE, Cyan);
    glMaterialfv(GL_FRONT, GL_SPECULAR, White);
    glMaterialfv(GL_FRONT, GL_SHININESS, Shine);

    glEnable(GL_CULL_FACE); // Cull back face
    glCullFace(GL_BACK);    // Cull back face
    glShadeModel(GL_SMOOTH);

    glPushMatrix(); // save Matrix to the matrix buffer
    glTranslatef(90.0, 0.0, 0.0); // Matrix E
    glRotatef(k1*120.0, 1.0, 0.0, 0.0); // Matrix F
    // Then Transformation Matrix for the torus is A*B*C*D*E*F

    switch (disp) {
        case 0:
            putFlatPolyhedron(torus);
            break;
        case 1:
            putSmoothPolyhedron(torus);
            break;
        default:
            break;
    }

    glPopMatrix(); // load Matrix from the matrix buffer
    glPushMatrix(); // save Matrix to the matrix buffer
    glTranslatef(-90.0, 0.0, 0.0); // Matrix G
    glRotatef(-k1*120.0, 0.0, 1.0, 0.0); // Matrix H
    // Then Transformation Matrix for the sphere is A*B*C*D*G*H
    glMaterialfv(GL_FRONT, GL_DIFFUSE, Red); //Attribute of the object

    switch (disp) {
        case 0:
            putFlatPolyhedron(sphere);
            break;
        case 1:
            putSmoothPolyhedron(sphere);
            break;
        default:
            break;
    }

    glPopMatrix(); // load Matrix from the matrix buffer
    glRotatef(-k1*250.0, 0.0, 1.0, 0.0); // Matrix I
    glRotatef(-k1*200.0, 0.0, 0.0, 1.0); // Matrix J
    glTranslatef(0.0, 400.0*sin(2*M_PI*k1), 0.0); // Matrix K
    glScalef(0.4,1.2,0.4); // Matrix L
    // Then Transformation Matrix for the sphere is A*B*C*D*I*J*K*L
    glMaterialfv(GL_FRONT, GL_DIFFUSE, Gray); //Attribute of the object

    switch (disp) {
        case 0:
            putFlatPolyhedron(sphere);
            break;
        case 1:
            putSmoothPolyhedron(sphere);
            break;
        default:
            break;
    }

    tick++;
}

int main(int argc, char **argv)
{
    glutInit(&argc,argv);
    glutInitDisplayMode ( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); // depth check
    glutInitWindowPosition(100,100);
    glutInitWindowSize(640,480);
    glutCreateWindow ("torus&sphere");
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glViewport(0,0,640,480);               
    glutIdleFunc(display); // idle event call back
    glutDisplayFunc(display);
    glEnable(GL_DEPTH_TEST); // depth check (OpenGL inner Z-Buffer)
    glutMainLoop();
    return 0;
}