DDA，中点划线，Bresenham任意斜率算法

void lineWithDDA(GLint x0, GLint y0, GLint xn, GLint yn) //dda算法
{
	int steps;
	float x=x0, y=y0,delta_x,delta_y;
	int dx = xn - x0;  int dy = yn - y0;
	if (abs(dx) > abs(dy))                  //判断循环次数
	{
		steps = abs(dx);
	}
	else
	{
		steps = abs(dy);
	}
	glColor3f(0.0, 0.0, 1.0);
	glPointSize(2);
	delta_x = (float)dx / (float)steps;         //计算每一步x的增量
	delta_y = (float)dy / (float)steps;          //计算每一步y的增量
	glBegin(GL_POINTS);
	glVertex2f(x, y);       //画起始点，之后通过循环加增量
	for (int i = 1; i <= steps; i++)           //以相对坐标差大的为绘图方向，循环steps次
	{
		x += delta_x;            //其中一个为1，另一个为k或者1/k
		y += delta_y;              //不用分情况考虑|k|>1或者|k|<1的情况
		glVertex2f(x,y);         
	}
	glEnd();
}

DDA画任意斜率

然后是中点换线算法的

void lineWithMiddle(int x0, int y0, int xn, int yn)  //中点划线算法

{

    glColor3f(0.0, 1.0, 0.0);

    float a, b, d1, d2, d, x, y,steps;

    a = y0 - yn ; b = xn - x0;        //d为初值

    x = x0, y = y0;            //从 （x0,y0）开始绘图

    glPointSize(2);

    glBegin(GL_POINTS);

    glVertex2f(x, y);

    if (abs(a) <= abs(b))                      //|k|<=1                   

    {         

       steps = abs(b);

       if (float(-a) / b>=0)       //0<=k<=1

       {

           d = 2 * a + b;

           d1 = 2 * a, d2 = 2 * (a + b);            //d都×2把浮点数转为整数

           for (int i = 1; i <= steps; i++)

           {

              if (d < 0)

              {

                  x++, y++, d += d2;

              }

              else

              {

                  x++, d += d1;

              }

              glVertex2f(x, y);

           }

       }

       else              //-1<=k<0

       {

           d = 2 * a - b;

           d1 = 2 * a, d2 = 2 * (a - b);            //d都×2把浮点数转为整数

           for (int i = 1; i <= steps; i++)

           {

              if (d < 0)

              {   x++, d += d1;}

              else

               {x++, y--, d += d2;  }  

              glVertex2f(x, y);

           }

       }

   

       glEnd();

    }

    else                            //|K|>1

    {

       steps = abs(a);

       if (float(-a)/b>0)                              //1

Bresenham算法原理类似，大家自己推一遍嘛，都是分四种情况，我就不发出来了！