OpenGL——3D Rendering Pipeline

// Computer Graphics: HW3
// 3D Transformation: 


#include <iostream>
#include <string>
#include <cstdlib>
#include <cmath>
#include <cstdio>
#include <vector>
#include <gl/glut.h>
#include <iomanip>
#include <fstream>

using namespace std;

const int dimension = 4;
const double PI = acos(-1);
const double eps = 0.0000001;

//定义向量 
struct vec {
    float x;
    float y;
    float z;
    vec(float _x=0, float _y=0, float _z=0):x(_x), y(_y), z(_z){}
};

//向量的叉乘并化为单位向量 
vec cross(vec a, vec b)
{
    vec res;
    res.x = a.y * b.z - b.y * a.z;
    res.y = -(a.x * b.z - b.x * a.z);
    res.z = a.x * b.y - b.x * a.y;
    float l = sqrt(res.x*res.x+res.y*res.y+res.z*res.z);
    res.x = res.x / l;
    res.y = res.y / l;
    res.z = res.z / l;
    return res;
}

//定义多边形的点 
struct poly_point {        
    float x;
    float y;
    float z;
    float w;
    poly_point(){ x=0; y=0; z=0; w=1;}
    poly_point(float _x, float _y, float _z, float _w=1){ x=_x; y=_y; z=_z; w=_w;}
};

//定义矩阵用作变换操作  
struct mat {                    
    float m[4][4];
    mat()
    {
        memset(m,0,sizeof(m));
        m[0][0]=m[1][1]=m[2][2]=m[3][3]=1;        
    }
    void reset_mat()
    {
        memset(m,0,sizeof(m));
        m[0][0]=m[1][1]=m[2][2]=m[3][3]=1;
    }
};

//新建各种变换矩阵，初始化为单位矩阵 
mat T,S,R,Rx,Ry,Rz,Sh,TM, M,GRM,EM,Mirrorx, PM, WTVM;

//重载*号实现矩阵乘法
mat operator * (mat a, mat b)        
{
    mat c;
    memset(c.m,0,sizeof(c.m));    //注意要先初始化为0 
    for(int i=0; i<dimension; i++)
        for(int j=0; j<dimension; j++)
            for(int k=0; k<dimension; k++)
                c.m[i][j] += (a.m[i][k]*b.m[k][j]);        
    return c;
}

//定义矩阵乘以向量 
poly_point mat_mul_vec(mat t, poly_point pp)
{
    poly_point res;
    res.x = t.m[0][0]*pp.x+t.m[0][1]*pp.y+t.m[0][2]*pp.z+t.m[0][3]*pp.w;
    res.y = t.m[1][0]*pp.x+t.m[1][1]*pp.y+t.m[1][2]*pp.z+t.m[1][3]*pp.w;
    res.z = t.m[2][0]*pp.x+t.m[2][1]*pp.y+t.m[2][2]*pp.z+t.m[2][3]*pp.w;
    res.w = t.m[3][0]*pp.x+t.m[3][1]*pp.y+t.m[3][2]*pp.z+t.m[3][3]*pp.w;
    return res;
}
//输出矩阵用作测试 
void print_mat(mat M)
{
    for(int i=0; i<dimension; i++)
    {
        for(int j=0; j<dimension; j++)
            printf("%.2lf ", M.m[i][j]);
        printf("
");
    }
    printf("
");
}

int num_tm=0;                                                //记录输入object的个数 
poly_point poly_vertex[10][2000], observe[10][2000];        //保存原来的输入的多边形的点，保存经历所有变换后的点用于输出 
int poly_face[4000][4];                                        //保存多边形的面用于画线 
string file_name;                                            //读取asc文件的文件名 
float VL,VR,VB,VT;                                            //viewport的坐标                 
float Near, Far, FOV;                                        //求PM投影矩阵用到的参数 
int height, width, n;                                        //n为多边形组成每个面的点的个数 
int num_vertex, num_face;                                    //记录输入的多边形的点的个数和面的个数 
void displayFunc(void);
void ReadInput(bool& IsExit);

//hw3
void scale(float sx, float sy, float sz);                    //scale放缩变换    
void rotate(float rx, float ry, float rz, int i=0);            //rotate旋转变换 
void translate(float tx, float ty, float tz);                //translate平移变换 
void reset(); 
//获得EM和PM矩阵 
void observer(float PX, float PY, float PZ, float CX, float CY, float CZ, float Tilt, float Near, float Far, float FOV);
void view(float VL, float VR, float VB, float VT);            //获得WTVM矩阵 
void display();                                                //做observer和viewport变换并画点 
void read_asc_file();                                        //读取asc文件 
void transform(mat t);                                        //输入一个矩阵，对poly_vertex里的每个点做一次变换 
void projection(float AR, float Near, float Far, float FOV);//投影变换，即获得PM矩阵 
void per_div();                                                //perspective divide
void transform_observe(mat t);                                //对observe中的每个点进行矩阵变换 
void DrawWindow();                                            //画框框 
void print_mat(mat t);                                        //输出矩阵测试 
void print();                                                //输出点测试 

//hw1中已经实现的函数 
void drawDot(int x, int y, float r, float g, float b);    
void drawLine1(int x0, int x1, int y0, int y1, bool xy_interchange);
void drawLine2(int x0, int x1, int y0, int y1, bool xy_interchange);
void drawLine3(int x0, int x1, int y0, int y1, bool xy_interchange);
void drawLine4(int x0, int x1, int y0, int y1, bool xy_interchange);
void DrawLines_4(int x1, int y1, int x2, int y2);

void myKeyboard(unsigned char key, int x, int y) 
{
    cout << "KEYYYY" << endl;
    switch(key) {
    // Draw dots with 'd' or 'D'
    case 'q':
    case 'Q':
        //glutMouseFunc(Mymouse);
          exit(0);
          break;
    }
}
void ReadInput(bool& IsExit)
{
    float sx,sy,sz, tx,ty,tz, rx,ry,rz;
    float PX, PY, PZ, CX, CY, CZ, Tilt; 
    string command,comment;
    cin>>command;
    if (command=="scale")
    {
        cout<<command<<endl;
        cin>>sx>>sy>>sz;
        scale(sx,sy,sz);    
    }
    else if (command=="rotate")
    {
        cout<<command<<endl;
        cin>>rx>>ry>>rz;
        rotate(rx,ry,rz,0);    
    }
    else if (command=="translate")
    {
        cout<<command<<endl;
        cin>>tx>>ty>>tz;
        translate(tx,ty,tz);    
    }
    else if (command=="reset")
    {
        cout<<command<<endl;
        //reset();
    }
    else if (command=="observer")
    {
        cout<<command<<endl;
        cin>>PX>>PY>>PZ>>CX>>CY>>CZ>>Tilt>>Near>>Far>>FOV;
        observer(PX,PY,PZ,CX,CY,CZ,Tilt,Near,Far,FOV);
    }
    else if (command=="viewport")
    {
        cout<<command<<endl;
        cin>>VL>>VR>>VB>>VT;
        view(VL,VR,VB,VT);
    }
    else if (command=="end")
    {
        cout<<command<<endl;
        IsExit=true;
        //exit(0);
    }
    else if (command=="#")
    {
        getline(cin, comment);
    }
    else if (command=="display")
    {
        cout<<command<<endl;
        display();
    }
    else if (command=="object")
    {
        cout<<command<<endl;
        cin >> file_name;
        read_asc_file();
    }
}


// Display function
void displayFunc(void){
  
  freopen("test.in", "r", stdin);
  bool IsExit;
  IsExit=false;
  // clear the entire window to the background color
  glClear(GL_COLOR_BUFFER_BIT);
  while (!IsExit)
  {
    glClearColor(0.0, 0.0, 0.0, 0.0); 
//    redraw();
  // draw the contents!!! Iterate your object's data structure!
  // flush the queue to actually paint the dots on the opengl window
    glFlush();
    ReadInput(IsExit);
  }
 // infile.close();
  //exit(0);
}


// Main
void main(int ac, char** av) {
  //initial();
  
  int winSizeX, winSizeY;
  string name;
  
  if(ac == 3) {
    winSizeX = atoi(av[1]);
    winSizeY = atoi(av[2]);
//        cout<<"Done";
  }
  else { // default window size
    winSizeX = 800;
    winSizeY = 600;

  }
  
    
//  cout<<"Please input file name:"<<endl;
//  cin>>name;
//  infile.open(name.c_str());
 // exit(0);
 // infile.open("inp3.txt");
// infile.open(av[1]);
  width  = winSizeX;
  height = winSizeY;

  // initialize OpenGL utility toolkit (glut)
  glutInit(&ac, av);

  // single disply and RGB color mapping
  glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); // set display mode
  glutInitWindowSize(winSizeX, winSizeY);      // set window size
  glutInitWindowPosition(0, 0);                // set window position on screen
  glutCreateWindow("Lab2 Window");       // set window title
  
  // set up the mouse and keyboard callback functions
   // register the keyboard action function
  glutKeyboardFunc(myKeyboard);
  // displayFunc is called whenever there is a need to redisplay the window,
  // e.g., when the window is exposed from under another window or when the window is de-iconified
  glutDisplayFunc(displayFunc); // register the redraw function
  
  // set background color
  glClearColor(0.0, 0.0, 0.0, 0.0);     // set the background to black
  glClear(GL_COLOR_BUFFER_BIT); // clear the buffer

  // misc setup
  glMatrixMode(GL_PROJECTION);  // setup coordinate system
  glLoadIdentity();
  gluOrtho2D(0, winSizeX, 0, winSizeY);
  glShadeModel(GL_FLAT);
  glFlush();
  glutMainLoop();
}


void scale(float sx, float sy, float sz)
{
    S.m[0][0]=sx;    S.m[1][1]=sy;    S.m[2][2]=sz;
    TM=S*TM;
}
void rotate(float rx, float ry, float rz, int i)
{
    if(i == 0)
    {
        rx = rx * PI / 180.0;    ry = ry * PI / 180.0;    rz = rz * PI / 180.0;
    }
    Rx.m[1][1]=cos(rx);    Rx.m[2][2]=cos(rx);    Rx.m[1][2]=-sin(rx);    Rx.m[2][1]=sin(rx);
    Ry.m[0][0]=cos(ry);    Ry.m[2][2]=cos(ry);    Ry.m[0][2]=sin(ry);        Ry.m[2][0]=-sin(ry);
    Rz.m[0][0]=cos(rz);    Rz.m[1][1]=cos(rz);    Rz.m[0][1]=-sin(rz);    Rz.m[1][0]=sin(rz);
    R = Rz*Ry*Rz;
    TM=R*TM;
}
void translate(float tx, float ty, float tz)
{
    T.m[0][3]=tx;    T.m[1][3]=ty;    T.m[2][3]=tz;
    TM=T*TM;
}
void reset()
{
    /*T.reset_mat(),S.reset_mat(),R.reset_mat(),Rx.reset_mat(),Ry.reset_mat(),Rz.reset_mat(),
    Sh.reset_mat(),TM.reset_mat(), M.reset_mat(),GRM.reset_mat(),EM.reset_mat(),Mirrorx.reset_mat(), 
    PM.reset_mat(), WTVM.reset_mat();*/
    for(int j=0; j<num_tm; j++)
    {
        for(int i=1; i<=num_vertex; i++) 
        {
            observe[j][i].x = poly_vertex[j][i].x; 
            observe[j][i].y = poly_vertex[j][i].y;
            observe[j][i].z = poly_vertex[j][i].z;
        }
    }
    
}
void observer(float PX, float PY, float PZ, float CX, float CY, float CZ, float Tilt, float Near, float Far, float FOV)
{
    //GRM
    translate(-PX,-PY,-PZ);
    //print_mat(T);
    float x = CX-PX;
    float y = CY-PY;
    float z = CZ-PZ;
    //Tilt=Tilt*PI/180.0;
    float l=sqrt(x*x+y*y+z*z);
    vec v(x,y,z);
    vec t(0,1,sin(Tilt*PI/180.0));
    vec v3;
    v3.x = v.x/l; v3.y = v.y/l; v3.z = v.z/l;
    vec v1=cross(v,t);
    vec v2=cross(v1,v3);
    GRM.m[0][0]=v1.x;    GRM.m[0][1]=v1.y;    GRM.m[0][2]=v1.z;
    GRM.m[1][0]=v2.x;    GRM.m[1][1]=v2.y;    GRM.m[1][2]=v2.z;
    GRM.m[2][0]=v3.x;    GRM.m[2][1]=v3.y;    GRM.m[2][2]=v3.z;
    //GRM.m[1][2]=-0.71;
    //float ry = abs(asin(x/sqrt(x*x+y*y+z*z)));
    /*float ry = abs(asin(x/sqrt(x*x+y*y+z*z)));
    float rx = atan(y/sqrt(pow(x,2.0)+pow(z,2.0)));
    float rz = Tilt*PI/180.0;

    rotate(rx,ry,rz,1);
    print_mat(Ry);
    print_mat(Rx);
    print_mat(Rz);
    Mirrorx.m[0][0]=-1;
    GRM = Mirrorx*Rz*Rx*Ry;*/
    //GRM.m[1][1]=0.71;
    //GRM.m[1][2]=-0.71;
    //GRM.m[2][1]=-0.71;
    //GRM.m[2][2]=-0.71;
    //Mirrorx.m[0][0]=-1;
    printf("GRM
");
    print_mat(GRM);
    EM = Mirrorx*GRM*T;
    //print_mat(EM);
    transform_observe(EM);
    //print();

    //projection(1.33,Near,Far,FOV);
}
void view(float VL, float VR, float VB, float VT)
{
    DrawWindow();
    float WL=-1, WR=1, WB=-1, WT=1;
    translate(-WL, -WB, 0);    
    WTVM = T * WTVM;    
    scale((VR-VL)/(WR-WL), (VT-VB)/(WT-WB), 1);
    WTVM = S * WTVM;    
    translate(VL, VB, 0);    
    WTVM = T * WTVM;
    printf("WTVM
");
    print_mat(WTVM);
    //transform_observe(WTVM);
    
}
void display()
{
    projection((VR-VL)/(VT-VB),Near,Far,FOV);
    transform_observe(WTVM);
    cout << "num_tm: " << num_tm << endl;
    //cout << num_vertex << " " << num_face << endl;
    //print();
    for(int k=0; k<num_tm; k++)
    {
        for(int i=0; i<num_face; i++) 
        {
            for(int j=0; j<n-1; j++)
                DrawLines_4(observe[k][poly_face[i][j]].x, observe[k][poly_face[i][j]].y, observe[k][poly_face[i][j+1]].x, observe[k][poly_face[i][j+1]].y);
            DrawLines_4(observe[k][poly_face[i][n-1]].x, observe[k][poly_face[i][n-1]].y, observe[k][poly_face[i][0]].x, observe[k][poly_face[i][0]].y);
        }
    }
    reset();
    EM.reset_mat();
    PM.reset_mat();
    WTVM.reset_mat();
}
void read_asc_file()
{
    num_tm++;
    cout << file_name << endl;
    ifstream fin(file_name);
    fin >> num_vertex >> num_face;
    cout << num_vertex << " " << num_face << endl;
    // read vertex one by one
    for(int i=1; i<=num_vertex; i++) 
    {
        fin >> poly_vertex[num_tm-1][i].x >> poly_vertex[num_tm-1][i].y >> poly_vertex[num_tm-1][i].z;
    }
    // read face one by one
    for(int i=0; i<num_face; i++) 
    {
        fin >> n;
        for(int j=0; j<n; j++)
            fin >> poly_face[i][j];
    }
    
    transform(TM);//
    reset();
    TM.reset_mat();
    
    //print();
}

void transform(mat t)
{
    for(int i=1; i<=num_vertex; i++) 
        poly_vertex[num_tm-1][i] = mat_mul_vec(t, poly_vertex[num_tm-1][i]);
}
void transform_observe(mat t)
{
    for(int j=0; j<num_tm; j++)
    {
        for(int i=1; i<=num_vertex; i++) 
            observe[j][i] = mat_mul_vec(t, observe[j][i]);
    }
}    

void projection(float AR, float Near, float Far, float FOV)
{
    //PM
    FOV=FOV*PI/180.0;
    float Y=Far*tan(FOV);
    float H=Near*tan(FOV);
    PM.m[1][1]=AR;
    PM.m[2][2]=Y/(Y-H)*tan(FOV);
    PM.m[2][3]=Y*H/(H-Y)*tan(FOV);
    PM.m[3][2]=tan(FOV);
    PM.m[3][3]=0;
    /*PM.m[1][1]=AR;
    PM.m[2][2]=0.58;
    PM.m[3][2]=0.58;
    PM.m[3][3]=0;*
    PM.m[2][3]=-0.58;*/
    print_mat(PM);
    transform_observe(PM);

    per_div();    //
}

void per_div()
{
    for(int j=0; j<num_tm; j++)
    {
        for(int i=1; i<=num_vertex; i++) 
        {
            observe[j][i].x /= observe[j][i].w;
            observe[j][i].y /= observe[j][i].w;
            observe[j][i].z /= observe[j][i].w;
            observe[j][i].w /= observe[j][i].w;
        }
    }
    
}

void DrawWindow()
{
    DrawLines_4(VL, VB, VR, VB);
    DrawLines_4(VR, VB, VR, VT);
    DrawLines_4(VR, VT, VL, VT);
    DrawLines_4(VL, VT, VL, VB);
}

void print()
{
    for(int j=0; j<num_tm; j++)
    {
        for(int i=1; i<=num_vertex; i++)
            cout <<  poly_vertex[j][i].x << " " << poly_vertex[j][i].y << " " << poly_vertex[j][i].z << endl;
    }
}




































//////////////////////////////////////////////////////////////////////////////////////hw1///////////////////////////////////////////////////////////
void DrawLines_4(int x1, int y1, int x2, int y2) //判断画哪一种线
{
    if(x1 >= x2)
    {
        if(y1 >= y2)
        {
            swap(x1, x2);
            swap(y1, y2);
            if((y2-y1) >= (x2-x1))            
                drawLine2(x1, y1, x2, y2, 1);    
            else
                drawLine1(x1, y1, x2, y2, 1);
        }
        else
        {
            if((y2-y1) >= (x1-x2))
                drawLine3(x1, y1, x2, y2, 1);
            else
                drawLine4(x2, y2, x1, y1, 1);
        }                
    }
    else
    {
        if(y2 >= y1)
        {
            if((y2-y1) <= (x2-x1))
                drawLine1(x1, y1, x2, y2, 1);
            else
                drawLine2(x1, y1, x2, y2, 1);
        }
        else
        {
            if((y1-y2) <= (x2-x1))
                drawLine4(x1, y1, x2, y2, 1);
            else
                drawLine3(x2, y2, x1, y1, 1);
        }
    }
    
    glFlush();
}

// draw a dot at location with integer coordinates (x,y), and with color (r,g,b)
void drawDot(int x, int y, float r, float g, float b) 
{
    glBegin(GL_POINTS);
  
    // set the color of dot
    glColor3f(r, g, b);
  
    // invert height because the opengl origin is at top-left instead of bottom-left
    glVertex2i(x ,  height-y);
  
    glEnd();
}

// Draw line for dx>0 and dy>0
void drawLine1(int x1, int y1, int x2, int y2, bool xy_interchange) //0-45度
{
    //cout << "Drawing Line1!" << endl;
    int x = x1;
    int y = y1;    

    int a = y2 - y1;
    int b = x1 - x2;
    int d = 2 * a + b;
    int IncE = 2 * a;
    int IncNE = 2 * (a + b);

    while(x <= x2)
    {
        if(d <= 0)
        {
            x++;
            d += IncE;
        }
        else
        {
            x++;
            y++;
            d += IncNE;
        }
        drawDot(x, height-y, 0.0, 0.0, 10.0);
        
    }
}

// Draw line for dx>0 and dy<0
void drawLine2(int x1, int y1, int x2, int y2, bool xy_interchange) //45-90度
{
    //cout << "Drawing Line2!" << endl;
    //转换为0-45度的情况
    swap(x2, y2);
    swap(x1, y1);

    int x = x1;
    int y = y1;
    
    int a = y2 - y1;
    int b = x1 - x2;
    int d = 2 * a + b;
    int IncE = 2 * a;
    int IncNE = 2 * (a + b);

    while(x <= x2)
    {
        if(d <= 0)
        {
            x++;
            d += IncE;
        }
        else
        {
            x++;
            y++;
            d += IncNE;
        }
        drawDot(y, height-x, 0.0, 0.0, 10.0);
        
    }    
}

// Draw line for dx<0 and dy>0
void drawLine3(int x1, int y1, int x2, int y2, bool xy_interchange) //90-135度
{
    //cout << "Drawing Line3!" << endl;
    swap(x2, y2);
    swap(x1, y1);
    y1 = -y1;
    y2 = -y2;
    int x = x1;
    int y = y1;

    int a = y2 - y1;
    int b = x1 - x2;
    int d = 2 * a + b;
    int IncE = 2 * a;
    int IncNE = 2 * (a + b);

    while(x <= x2)
    {
        if(d <= 0)
        {
            x++;
            d += IncE;
        }
        else
        {
            x++;
            y++;
            d += IncNE;
        }
        drawDot(-y, height-x, 0.0, 0.0, 10.0);
        
    }
}

// Draw line for dx<0 and dy>0
void drawLine4(int x1, int y1, int x2, int y2, bool xy_interchange) //135-180度
{
    //cout << "Drawing Line4!" << endl;
    y1 = -y1;
    y2 = -y2;
    int x = x1;
    int y = y1;
    
    int a = y2 - y1;
    int b = x1 - x2;
    int d = 2 * a + b;
    int IncE = 2 * a;
    int IncNE = 2 * (a + b);

    while(x <= x2)
    {
        if(d <= 0)
        {
            x++;
            d += IncE;
        }
        else
        {
            x++;
            y++;
            d += IncNE;
        }
        drawDot(x, height+y, 0.0, 0.0, 10.0);
        
    }
}