vẽ bánh xe quay

#pragma once
#include "cstring"
#include "cmath"
#include "stdlib.h"
typedef float matrix33 [3][3];
// hang so PI
#define M_PI 3.14159265358979
// macro doi tu do --> radian
#define RAD(goc) ((goc)*(M_PI/180.0))
// macro doi tu radian --> goc
#define GOC(rad) ((rad)*180.0/M_PI)
// ham lam tron
#define ROUND(n) ((int)(n+0.5))
void matrix_zezo(matrix33 m)
{    for(int i=0;i<3;i++)
        for(int j=0;j<3;j++)
            m[i][j]=0;
}
void matrix_id(matrix33 m)
{    matrix_zezo(m);
    m[0][0]=m[1][1]=m[2][2]=1;
}
void mul_matrix(float x,float y,matrix33 m,float &xout,float &yout)
{    xout = x*m[0][0] +y*m[1][0] + m[2][0];
    yout = x*m[0][1] +y*m[1][1] + m[2][1];
}
void mul_matrix(matrix33 ma,matrix33 mb,matrix33 mout)
{    matrix33 mtmp;matrix_zezo(mtmp);
    for(int i=0;i<3;i++)
    {    for(int j=0;j<3;j++)
        {    float sum=0;
            for(int k=0;k<3;k++)
            {    sum+=ma[i][k]*mb[k][j];
            }//k
            mtmp[i][j] =sum;
        }//j
    }//i
    memcpy(mout,mtmp,sizeof(mtmp));
}
void matrix_translate(matrix33 m,float dx,float dy)
{    matrix33 mtmp;matrix_id(mtmp);
    mtmp[2][0]=dx;mtmp[2][1]=dy;
    mul_matrix(m,mtmp,m);
}
void matrix_scale(matrix33 m,float sx,float sy)
{    matrix33 mtmp;matrix_id(mtmp);
    mtmp[0][0]=sx;mtmp[1][1]=sy;
    mul_matrix(m,mtmp,m);
}
void matrix_rotate(matrix33 m,float angle)
{    matrix33 mtmp;matrix_id(mtmp);
    mtmp[0][0]=cos(RAD(angle));mtmp[0][1]=sin(RAD(angle));
    mtmp[1][0]=-sin(RAD(angle));mtmp[1][1]=cos(RAD(angle));
    mul_matrix(m,mtmp,m);
}
void matrix_rotate(matrix33 m,float angle,float x,float y)
{    matrix_translate(m,-x,-y);
    matrix_rotate(m,angle);
    matrix_translate(m,x,y);    
}
void matrix_reflectiion(matrix33 m,float ox,float oy)
{    matrix33 mtmp;matrix_id(mtmp);
    mtmp[0][0]=ox;mtmp[1][1]=oy;
    mul_matrix(m,mtmp,m);
}
void matrix_shear(matrix33 m,float shx,float shy)
{    matrix33 mtmp;matrix_id(mtmp);
    mtmp[0][1]=shx;mtmp[1][0]=shy;
    mul_matrix(m,mtmp,m);
}

#pragma comment( linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"" )
#include"iostream"
#include"math.h"
#include "glut.h"
#include"Afine.h"
#define Round(x) int(x+0.5)
#define PI 3.1416
#define Rad(x)(x*PI/180)
int width,height,xc,yc,xi,yi;
int alpha=0,_angle=0,alpha1=0;
int dx=0,dy=0;
struct colorentry
{    GLubyte Red;
    GLubyte Blue;
    GLubyte Green;
    colorentry() {Red=Green=Blue=0; }
    colorentry(GLbyte R,GLbyte G,GLbyte B)
    {    Red=R;     Green=G; Blue=B;
    }
    int operator==(colorentry &c)
    {    return (Red==c.Red && Green==c.Green && Blue==c.Blue);
    }
    int operator!=(colorentry &c)
    {    return !(*this==c);
    }
};
void onkey(unsigned char key,int x,int y);
void OnSize(int width,int height);
void OnIdle();
void PutPixel(int x,int y,colorentry c);
void PutPixel(int x,int y);
colorentry GetPixel(int x,int y);
void DrawLineDDA(int x1,int y1,int x2,int y2);
void DrawRectangle_Rotate(int xc,int yc,int a, int b, int alpha,colorentry c) 
{   int dPoints[][2] = { {-a,b},{a,b},{a,-b},{-a,-b} }; 
    int n = 4;
    float x,y,xout,yout; 
    matrix33 mkq; matrix_id(mkq); 

    matrix_rotate(mkq,alpha,xc,yc); // xoay quanh xc,yc
    glBegin(GL_LINE_LOOP); 
        glColor3ub(c.Red,c.Green,c.Blue); 
        for(int i=0;i
        {   x = xc + dPoints[i][0]; y = yc + dPoints[i][1]; 
            mul_matrix(x,y,mkq,xout,yout); 
            glVertex2f(xout,yout); 
        }
    glEnd(); 
}
void Put8Pixcel(int xc, int yc, int x, int y);
void CircleMidpoint(int xc, int yc, int r);
void swap(int &a,int &b);
void hematroi()
{    float x1,y1,x2,y2,x1out,y1out,x2out,y2out,x3,y3,x4,y4;    
    int r=30;
    CircleMidpoint(xc, yc, r);    
    x1=xc+r;    y1=yc+r;
    x2=xc+r+10;     y2=yc+r+10;
    DrawLineDDA(x1,y1,x2,y2);    
    matrix33 mkq; matrix_id(mkq);
    for(float i=0;i<360;i+=22.5)
    {    matrix_rotate(mkq,i,xc,yc); // xoay quanh xc,yc
        mul_matrix(x1,y1,mkq,x1out,y1out); 
        mul_matrix(x2,y2,mkq,x2out,y2out); 
        DrawLineDDA(x1out,y1out,x2out,y2out);
    }
    // trai dat 
    glColor3ub(255,200,0);
    matrix_rotate(mkq,alpha,xc,yc);
    x1=xc+200;
    y1=yc;
    mul_matrix(x1,y1,mkq,x1out,y1out); 
    CircleMidpoint(x1out,y1out,20);
    // mat trang
    matrix33 mkq1; matrix_id(mkq1);
    x3=x1out+70;
    y3=y1out;
    matrix_rotate(mkq1,alpha1,x1out,y1out);
    mul_matrix(x3,y3,mkq1,x4,y4);
    glColor3ub(0,0,255);
    CircleMidpoint(x4,y4,20);
}
void banhxe()
{    int x1,y1;
    float x1out,y1out;
    int r=80;
    CircleMidpoint(xc, yc, r);
    r-=30;
    x1=xc+r;
    y1=yc+r;
    glColor3ub(0,0,255);
    matrix33 mkq; matrix_id(mkq);
    matrix_rotate(mkq,alpha,xc,yc); // xoay quanh xc,yc
    mul_matrix(x1,y1,mkq,x1out,y1out);    
    DrawLineDDA(xc,yc,x1out,y1out);    
    for(float i=0;i<360;i+=45)
    {    matrix_rotate(mkq,i,xc,yc); // xoay quanh xc,yc
        mul_matrix(x1,y1,mkq,x1out,y1out);        
        DrawLineDDA(xc,yc,x1out,y1out);
    }
}
//-----------------------------------
void myInit();
void mydraw()
{    glClear(GL_COLOR_BUFFER_BIT);
    glColor3ub(255,0,0);
//    int xMax = glutGet(GLUT_WINDOW_WIDTH); 
//    int yMax = glutGet(GLUT_WINDOW_HEIGHT); 
//    DrawRectangle_Rotate(xMax/2,yMax/2,200,100,_angle,colorentry(255,0,0)); 
    hematroi();
//    banhxe();
    glFlush();
    glutSwapBuffers();
}
void OnTime(int ms)
{//    _angle = (int)(_angle+5)%360;
//    alpha1 = (int)(alpha1-3)%360;
    if(xc    {    dx=10;
        dy=0;
    }
    if(yc>80 && xc==width-80)
    {    dy=-10;
        dx=0;
    }
    if(yc==80 && xc>80)
    {    dx=-10;
        dy=0;
    }
    if(xc==80 && yc
    {    dy=10;
        dx=0;
    }
    if(yc==height-80 && xc
    {    dx=10;
        dy=0;
    }    
    //xc += dx;
       // yc += dy;    
    alpha = (int)(alpha+10)%360;    
    glutTimerFunc(ms,OnTime,ms);
}
void main()
{    glutInitDisplayMode(GLUT_RGB|GLUT_DOUBLE);
    glutInitWindowPosition(100,100);
    glutInitWindowSize(640,480);
    glutCreateWindow("test");
    myInit();
    glutDisplayFunc(mydraw);
    glutReshapeFunc(OnSize);
    glutTimerFunc(200,OnTime,200);
    glutKeyboardFunc(onkey);
    glutIdleFunc(OnIdle);
    glutMainLoop();
}
void myInit()
{    width=glutGet(GLUT_WINDOW_WIDTH);
    height=glutGet(GLUT_WINDOW_HEIGHT);
    xc=width/2;
    yc=height/2;
}
void Put8Pixcel(int xc, int yc, int x, int y)
{    PutPixel(xc + x, yc + y);
    PutPixel(xc + x, yc - y);
    PutPixel(xc - x, yc + y);   
    PutPixel(xc - x, yc - y);
    PutPixel(xc + y, yc + x);
    PutPixel(xc + y, yc - x);
    PutPixel(xc - y, yc + x);   
    PutPixel(xc - y, yc - x);
}
void CircleMidpoint(int xc, int yc, int r)
{    int x=0,y=r;
    int p=1-r;
    Put8Pixcel(xc,yc,x,y);        
    while(x
    {    if(p<0)
            p+=(x<<1)+3;
        else
        {    p+=((x-y)<<1)+5;
            y--;
        }
        ++x;
        Put8Pixcel(xc,yc,x,y);
    }
}
colorentry GetPixel(int x,int y)
{    GLbyte color[3];
    float Pos[4];
    glRasterPos2d(x,y);
    glGetFloatv(GL_CURRENT_RASTER_POSITION,Pos);
    glReadPixels(Pos[0],Pos[1],1,1,GL_RGB,GL_UNSIGNED_BYTE,color);
    return colorentry(color[0],color[1],color[2]);
}
void onkey(unsigned char key,int x,int y)
{    switch(key)
    {    case 27: exit(0);
    }
}
void OnSize(int width,int height)
{    glViewport(0, 0 , (GLsizei)width,(GLsizei)height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0,(GLdouble)width,0, (GLdouble)height);
}
void OnIdle()
{    glutPostRedisplay();
}
void PutPixel(int x,int y,colorentry c)
{    glColor3ub(c.Red,c.Green,c.Blue);
    glBegin(GL_POINTS);
        glVertex2f(x,y);
    glEnd();
}
void PutPixel(int x,int y)
{    glBegin(GL_POINTS);
        glVertex2f(x,y);
    glEnd();
}
void DrawLineDDA(int x1,int y1,int x2,int y2)
{    float ax,ay,x,y;
    float m;
    ax=x2-x1;
    ay=y2-y1;    
    if(abs(ax)>= abs(ay))
{    if(x1>x2)
        {    swap(x1,x2);
            swap(y1,y2);
        }
        m=(float)(y2-y1)/(x2-x1);
        y=y1;
        for(x=x1;x
        {    PutPixel(x,Round(y));
            y+=m;
        }
    }
    else
    {    if(y1>y2)
        {    swap(x1,x2);
            swap(y1,y2);
        }
        x=x1;
        m=(float)(x2-x1)/(y2-y1);
        for(y=y1;y
        {    PutPixel(Round(x),y);
            x+=m;
        }
    }
}
void swap(int &a,int &b)
{    int x=a;
    a=b;
    b=x;
}