3dgraphics6.c

计算机图形学

}

void Yuan_3DXZ(Point3D A,int r,int color,Point3D B,float qx,float qy,float qz)
{

   int x,z,d,deltaE,deltaSE,x0,z0,X,Y,Z;

   x0 = A.x;
   z0 = A.z;

   x = x0;
   z = z0 + r;
   d = 5 - 4*r;
   deltaE = 12;
   deltaSE = 20 - 8*r;


   CirclePoints_3DXZ(A,x,z,color,B,qx,qy,qz);


   while((z-z0)>(x-x0))
   {
      if(d<=0)
      {
        d = d + deltaE;
        deltaSE=deltaSE + 8;
      }
      else
      {
         d = d + deltaSE;
         deltaSE=deltaSE + 16;
         z--;
      }
      deltaE=deltaE + 8;
      x++;
      CirclePoints_3DXZ(A,x,z,color,B,qx,qy,qz);
   }

}

/***************************/
/**                       **/
/**3D平行于X-Y平面的空间圆**/
/**       的旋转          **/
/***************************/
/* 3D圆的8对称点的显示 */
void CirclePoints_3DXY_XuanZhuan(Point3D A,int x,int y,int color,float q,int i,int j,int k,int flag,Point3D B,float qx,float qy,float qz)/* 圆心为A;*/
{
  int X,Y,Z;
  X = x; Y = y; Z = A.z;                /*(x,  y) */
     XuanZhuan3D_RY(&X,&Y,&Z,q,i,j,k,flag);
      Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
         putpixel(X,Y,color);

  X = A.x-A.y+y; Y = A.y-A.x+x; Z = A.z;/*(y,  x) */
      XuanZhuan3D_RY(&X,&Y,&Z,q,i,j,k,flag);
      Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
         putpixel(X,Y,color);

  X = A.x+A.y-y; Y = A.y-A.x+x; Z = A.z; /*(-y, x) */
      XuanZhuan3D_RY(&X,&Y,&Z,q,i,j,k,flag);
      Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
         putpixel(X,Y,color);


  X = 2*A.x-x; Y = y; Z = A.z;          /*(-x, y) */
     XuanZhuan3D_RY(&X,&Y,&Z,q,i,j,k,flag);
      Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
         putpixel(X,Y,color);

  X = A.x-A.y+y; Y = A.y+A.x-x; Z = A.z; /*(y, -x) */
       XuanZhuan3D_RY(&X,&Y,&Z,q,i,j,k,flag);
      Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
         putpixel(X,Y,color);


  X = x; Y = 2*A.y-y; Z = A.z;          /*(x, -y) */
       XuanZhuan3D_RY(&X,&Y,&Z,q,i,j,k,flag);
      Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
         putpixel(X,Y,color);

  X = 2*A.x-x; Y = 2*A.y-y; Z = A.z;    /*(-x,-y) */
       XuanZhuan3D_RY(&X,&Y,&Z,q,i,j,k,flag);
      Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
         putpixel(X,Y,color);

  X = A.x+A.y-y; Y = A.y+A.x-x; Z = A.z;/*(-y,-x) */
      XuanZhuan3D_RY(&X,&Y,&Z,q,i,j,k,flag);
      Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
         putpixel(X,Y,color);
}

void Yuan_3DXY_XuanZhuan(Point3D A,int r,int color,float q,Point3D D,int flag,Point3D B,float qx,float qy,float qz)
{

   int x,y,d,deltaE,deltaSE,x0,y0,X,Y,Z,i,j,k;

   i = D.x; j = D.y; k = D.z;

   x0 = A.x;
   y0 = A.y;

   x = x0;
   y = y0 + r;
   d = 5 - 4*r;
   deltaE = 12;
   deltaSE = 20 - 8*r;


   CirclePoints_3DXY_XuanZhuan(A,x,y,color,q,i,j,k,flag,B,qx,qy,qz);


   while((y-y0)>(x-x0))
   {
      if(d<=0)
      {
        d = d + deltaE;
        deltaSE=deltaSE + 8;
      }
      else
      {
         d = d + deltaSE;
         deltaSE=deltaSE + 16;
         y--;
      }
      deltaE=deltaE + 8;
      x++;
      CirclePoints_3DXY_XuanZhuan(A,x,y,color,q,i,j,k,flag,B,qx,qy,qz);
   }

}




/***************************/
/*                         */
/*  3D空间椭圆的中点算法   */
/*     平行于X - Y         */
/***************************/

/* 椭圆的4对称点的显示 */
void EllipsePoints_3DXY(Point3D A,int x,int y,int color,Point3D B,float qx,float qy,float qz) /*椭圆的中心为:(x0,y0)*/
{
  int X,Y,Z;
  X = x; Y = y; Z = A.z;                    /*(x,  y) */
      Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
          putpixel(X,Y,color);

  X = 2 * A.x - x; Y = y; Z = A.z;          /*(-x, y) */
       Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
          putpixel(X,Y,color);

  X = 2 * A.x - x; Y = 2 * A.y - y; Z = A.z;/*(-x,-y) */
        Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
          putpixel(X,Y,color);

  X = x; Y = 2 * A.y - y; Z = A.z;          /*(x, -y) */
         Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
          putpixel(X,Y,color);

}


/* 椭圆的中点算法 */
void MidPointEllipse_3DXY(Point3D A,int a,int b,int color,Point3D B,float qx,float qy,float qz)
{
  int x,y,xP,yP,x0,y0;
  float d,squrarea,squrareb;
   x0 = A.x;
   y0 = A.y;


  squrarea = a * a;
  squrareb = b * b;

  /*计算分解点P*/
  xP = (int)(0.5 + squrarea/sqrt(squrarea + squrareb));
  yP = (int)(0.5 + squrareb/sqrt(squrarea + squrareb));

 /* 生成上半部椭圆*/
  x = x0;
  y = y0 + b;
  d = 4 * (squrareb - squrarea * b) + squrarea;
  EllipsePoints_3DXY(A,x,y,color,B,qx,qy,qz);
  while((x - x0)<xP)
  {
    if(d<=0)
       d = d + 4 * squrareb * (2 * (x - x0) + 3);
    else
       {
         d = d + 4 * squrareb * (2 * (x - x0) + 3)-8 * squrarea * ((y - y0) - 1);
         y--;
       }
    x++;
    EllipsePoints_3DXY(A,x,y,color,B,qx,qy,qz);
  }

  /* 生成下半部椭圆*/
  x = x0 + a;
  y = y0;
  d = 4 * (squrarea - squrareb * a) + squrareb;
  EllipsePoints_3DXY(A,x,y,color,B,qx,qy,qz);
  while((y-y0) < yP)
  {
    if(d<=0)
       d = d + 4 * squrarea * (2 * (y - y0) + 3);
    else
       {
         d = d + 4 * squrarea * (2 * (y - y0) + 3)-8 * squrareb * ((x - x0) - 1);
         x--;
       }
     y++;
   EllipsePoints_3DXY(A,x,y,color,B,qx,qy,qz);
  }
}


/***************************/
/*                         */
/*    3D空间椭圆的旋转     */
/*                         */
/***************************/

/* 椭圆旋转后的4对称点的显示 */
void EllipsePoints_3DXY_XhuanZhuan(Point3D A,int x,int y,int color,float q,int i,int j,int k,int flag,Point3D B,float qx,float qy,float qz) /*椭圆的中心为:A*/
{
  int X,Y,Z;
  X = x; Y = y; Z = A.z;                    /*(x,  y) */
     XuanZhuan3D_RY(&X,&Y,&Z,q,i,j,k,flag);
      Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
         putpixel(X,Y,color);


  X = 2 * A.x - x; Y = y; Z = A.z;          /*(-x, y) */
       XuanZhuan3D_RY(&X,&Y,&Z,q,i,j,k,flag);
         Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
         putpixel(X,Y,color);

  X = 2 * A.x - x; Y = 2 * A.y - y; Z = A.z;/*(-x,-y) */
       XuanZhuan3D_RY(&X,&Y,&Z,q,i,j,k,flag);
         Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
         putpixel(X,Y,color);
  X = x; Y = 2 * A.y - y; Z = A.z;          /*(x, -y) */
        XuanZhuan3D_RY(&X,&Y,&Z,q,i,j,k,flag);
          Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
         putpixel(X,Y,color);
}



/* 椭圆的中点算法 */
void MidPointEllipse_3DXY_XhuanZhuan(Point3D A,int a,int b,int color,float q,Point3D D,int flag,Point3D B,float qx,float qy,float qz) /* 绕通过 D 点直线的旋转 */
{
  int x,y,xP,yP,x0,y0,i,j,k;
  float d,squrarea,squrareb;
   x0 = A.x;
   y0 = A.y;
   i = D.x; j = D.y; k = D.z;

  squrarea = a * a;
  squrareb = b * b;

  /*计算分解点P*/
  xP = (int)(0.5 + squrarea/sqrt(squrarea + squrareb));
  yP = (int)(0.5 + squrareb/sqrt(squrarea + squrareb));

 /* 生成上半部椭圆*/
  x = x0;
  y = y0 + b;
  d = 4 * (squrareb - squrarea * b) + squrarea;
  EllipsePoints_3DXY_XhuanZhuan(A,x,y,color,q,i,j,k,flag,B,qx,qy,qz);
  while((x - x0)<xP)
  {
    if(d<=0)
       d = d + 4 * squrareb * (2 * (x - x0) + 3);
    else
       {
         d = d + 4 * squrareb * (2 * (x - x0) + 3)-8 * squrarea * ((y - y0) - 1);
         y--;
       }
    x++;
    EllipsePoints_3DXY_XhuanZhuan(A,x,y,color,q,i,j,k,flag,B,qx,qy,qz);
  }

  /* 生成下半部椭圆*/
  x = x0 + a;
  y = y0;
  d = 4 * (squrarea - squrareb * a) + squrareb;
  EllipsePoints_3DXY_XhuanZhuan(A,x,y,color,q,i,j,k,flag,B,qx,qy,qz);
  while((y-y0) < yP)
  {
    if(d<=0)
       d = d + 4 * squrarea * (2 * (y - y0) + 3);
    else
       {
         d = d + 4 * squrarea * (2 * (y - y0) + 3)-8 * squrareb * ((x - x0) - 1);
         x--;
       }
     y++;
   EllipsePoints_3DXY_XhuanZhuan(A,x,y,color,q,i,j,k,flag,B,qx,qy,qz);
  }
}
/***************************/
/**                       **/
/**    圆柱的算法         **/
/**                       **/
/***************************/
void YuanZhu3D(Point3D A,int r,int h,Point3D B,float qx,float qy,float qz)
{
   Point3D T;
   T.x = A.x; T.y = A.y; T.z = A.z -h/2.0;
   while(T.z <= A.z + h/2.0)
   {
     Yuan_3DXY(T,r,6,B,qx,qy,qz);
     T.z++;
   }

   while(r>=0)
   {
      Yuan_3DXY(T,r,2,B,qx,qy,qz);
      r--;
   }
}

/******************************************/
/**                                      **/
/**   长方体的算法(包含隐藏面的消隐算法) **/
/**                                      **/
/******************************************/
void Cft3D(Point3D A,int a,int b,int h,Point3D B,float qx,float qy,float qz)
{
   int X,Y,Z,i,j;
   Point3D B1,B2,B3,B4,B5,B6;
   Depth dp[6],temp;

   B1.x = A.x + b/2.0; B1.y = A.y;         B1.z = A.z;

   B2.x = A.x;         B2.y = A.y + a/2.0; B2.z = A.z;

   B3.x = A.x - b/2.0; B3.y = A.y;         B3.z = A.z;

   B4.x = A.x;         B4.y = A.y - a/2.0; B4.z = A.z;

   B5.x = A.x;         B5.y = A.y;         B5.z = A.z - h/2.0;

   B6.x = A.x;         B6.y = A.y;         B6.z = A.z + h/2.0;

                                    /*深度信息初始化*/
   X = B1.x; Y = B1.y; Z = B1.z;
        Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
   dp[0].s = '1'; dp[0].d = Z;          /*第 1 面的深度*/

    X = B2.x; Y = B2.y; Z = B2.z;
        Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
   dp[1].s = '2'; dp[1].d = Z;          /*第 2 面的深度*/

    X = B3.x; Y = B3.y; Z = B3.z;
        Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
   dp[2].s = '3'; dp[2].d = Z;          /*第 3 面的深度*/


   X = B4.x; Y = B4.y; Z = B4.z;
        Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
   dp[3].s = '4'; dp[3].d = Z;          /*第 4 面的深度*/


   X = B5.x; Y = B5.y; Z = B5.z;
        Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
   dp[4].s = '5'; dp[4].d = Z;          /*第 5 面的深度*/

   X = B6.x; Y = B6.y; Z = B6.z;
        Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
   dp[5].s = '6'; dp[5].d = Z;          /*第 6 面的深度*/

    for(i = 0; i <=4; i++)                 /*  深度排序  */
   {
      for(j = i+1;j<=5;j++)
      {
         if(dp[i].d>dp[j].d)
         {
           temp.s = dp[i].s; temp.d = dp[i].d;
           dp[i].s = dp[j].s; dp[i].d = dp[j].d;
           dp[j].s = temp.s; dp[j].d = temp.d;
         }
      }
   }

   i = 0;

   while(i <= 5)      /*画家算法*/
  {
    switch(dp[i++].s)
    {


    case'1': Rect_3DYZ(B1,a,h,4,B,qx,qy,qz);
             break;

    case'2': Rect_3DXZ(B2,b,h,12,B,qx,qy,qz);
             break;

    case'3': Rect_3DYZ(B3,a,h,4,B,qx,qy,qz);
             break;

    case'4': Rect_3DXZ(B4,b,h,12,B,qx,qy,qz);
             break;

    case'5': Rect_3DXY(B5,a,b,1,B,qx,qy,qz);
             break;

    case'6': Rect_3DXY(B6,a,b,1,B,qx,qy,qz);
             break;
    }
  }
}

/***************************/
/**                       **/
/**   长方体的旋转        **/
/**                       **/
/***************************/
void Cft3D_XuanZhuan(Point3D A,int a,int b,int h,float q,Point3D D,int flag,Point3D B,float qx,float qy,float qz)
{
   int X,Y,Z,i,j;
   Depth dp[6],temp;
   Point3D B1,B2,B3,B4,B5,B6;

   B1.x = A.x + b/2.0; B1.y = A.y;         B1.z = A.z;

   B2.x = A.x;         B2.y = A.y + a/2.0; B2.z = A.z;

   B3.x = A.x - b/2.0; B3.y = A.y;         B3.z = A.z;

   B4.x = A.x;         B4.y = A.y - a/2.0; B4.z = A.z;

   B5.x = A.x;         B5.y = A.y;         B5.z = A.z - h/2.0;

   B6.x = A.x;         B6.y = A.y;         B6.z = A.z + h/2.0;

   /*深度信息初始化*/
   X = B1.x; Y = B1.y; Z = B1.z;
   XuanZhuan3D_RY(&X,&Y,&Z,q,D.x,D.y,D.z,flag);
        Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
   dp[0].s = '1'; dp[0].d = Z;          /*第 1 面的深度*/

    X = B2.x; Y = B2.y; Z = B2.z;
    XuanZhuan3D_RY(&X,&Y,&Z,q,D.x,D.y,D.z,flag);
        Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
   dp[1].s = '2'; dp[1].d = Z;          /*第 2 面的深度*/

    X = B3.x; Y = B3.y; Z = B3.z;
    XuanZhuan3D_RY(&X,&Y,&Z,q,D.x,D.y,D.z,flag);
        Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
   dp[2].s = '3'; dp[2].d = Z;          /*第 3 面的深度*/


   X = B4.x; Y = B4.y; Z = B4.z;
   XuanZhuan3D_RY(&X,&Y,&Z,q,D.x,D.y,D.z,flag);
        Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
   dp[3].s = '4'; dp[3].d = Z;          /*第 4 面的深度*/


   X = B5.x; Y = B5.y; Z = B5.z;
   XuanZhuan3D_RY(&X,&Y,&Z,q,D.x,D.y,D.z,flag);
        Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
   dp[4].s = '5'; dp[4].d = Z;          /*第 5 面的深度*/

   X = B6.x; Y = B6.y; Z = B6.z;
   XuanZhuan3D_RY(&X,&Y,&Z,q,D.x,D.y,D.z,flag);
        Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
   dp[5].s = '6'; dp[5].d = Z;          /*第 6 面的深度*/


   for(i = 0; i <=4; i++)                 /*  深度排序  */
   {
      for(j = i+1;j<=5;j++)
      {
         if(dp[i].d>dp[j].d)
         {
           temp.s = dp[i].s; temp.d = dp[i].d;
           dp[i].s = dp[j].s; dp[i].d = dp[j].d;
           dp[j].s = temp.s; dp[j].d = temp.d;
         }
      }
   }
   i = 0;
   while(i <= 5)      /*画家算法*/
  {
    switch(dp[i++].s)
    {

      case'1': Rect_3DYZ_XuanZhuan(B1,a,h,4,q,D,flag,B,qx,qy,qz);
               break;

      case'2': Rect_3DXZ_XuanZhuan(B2,b,h,12,q,D,flag,B,qx,qy,qz);
               break;

      case'3': Rect_3DYZ_XuanZhuan(B3,a,h,4,q,D,flag,B,qx,qy,qz);
               break;

      case'4': Rect_3DXZ_XuanZhuan(B4,b,h,12,q,D,flag,B,qx,qy,qz);
               break;

      case'5': Rect_3DXY_XuanZhuan(B5,a,b,1,q,D,flag,B,qx,qy,qz);
               break;

      case'6': Rect_3DXY_XuanZhuan(B6,a,b,1,q,D,flag,B,qx,qy,qz);
               break;
     }
  }
}

/***************************************/
/***                                 ***/
/***      常见的实物实体画法         ***/
/***                                 ***/
/***************************************/


/*****************************/
/**    栏杆(平行于X轴)      **/
/*****************************/
void LanGan_X(Point3D A,int L,int h,Point3D BB,float qx,float qy,float qz)
{
  int X,Y,Z,i,j;
  Point3D B;
  Depth dp[7],temp;

  X = A.x - L/2.0; Y = A.y; Z = A.z;    /*五条竖线的深度*/
     Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
  dp[0].s = 'A'; dp[0].d = Z;

  X = A.x - L/2.0+ L/4.0; Y = A.y; Z = A.z;
     Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
  dp[1].s = 'B'; dp[1].d = Z;

  X = A.x - L/2.0 + L/2.0; Y = A.y; Z = A.z;
    Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
  dp[2].s = 'C'; dp[2].d = Z;

  X = A.x - L/2.0 + 3*L/4.0; Y = A.y; Z = A.z;
     Point3D_2D(&X,&Y,&Z,B,qx,qy,qz);
  dp[3].s = 'D'; dp[3].d = Z;