VOID VECBuffer::ComputeScanLinesT(VECDrawablePolygon * Poly)
{
  VECVertex * V1 = Poly->Vertices.GetFirst();
  VECVertex * V2;

  INT long_d, short_d;
  INT d, add_dh, add_dl;
  register INT inc_xh, inc_yh, inc_xl, inc_yl;
  register INT i, k;

  INT dXscr, dYscr, Scr1, Scr2, dScr, Yscr, Xscr;
  DOUBLE A, TanA, TanB;
  DOUBLE U, V, X, Y, Z, dU, dV, dX, dY, dZ, lW; 

  static INT TabScr[NB_PT_TEXT+1];
  static DOUBLE TabX[NB_PT_TEXT+1];
  static DOUBLE TabY[NB_PT_TEXT+1];
  static DOUBLE TabZ[NB_PT_TEXT+1];
  static DOUBLE TabU[NB_PT_TEXT+1];
  static DOUBLE TabV[NB_PT_TEXT+1];

  // initialisation des scan lines
  for (i=G_YMin; i<=G_YMax; i++)
  {
    G_Start[i].X = RESOLUTION_MAX_X;
    G_End[i].X = 0;
  }
  G_YMin = RESOLUTION_MAX_Y;
  G_YMax = 0;

  if(V1->ScreenVertex.Y > G_YMax) G_YMax = V1->ScreenVertex.Y;
  if(V1->ScreenVertex.Y < G_YMin) G_YMin = V1->ScreenVertex.Y;

  // boucle sur les arretes
  while(V2 = Poly->Vertices.GetNext())
  {
    if(V2->ScreenVertex.Y > G_YMax) G_YMax = V2->ScreenVertex.Y;
    if(V2->ScreenVertex.Y < G_YMin) G_YMin = V2->ScreenVertex.Y;

    U = V1->U;
    V = V1->V;
    X = V1->CameraVertex.X;
    Y = V1->CameraVertex.Y;
    Z = V1->CameraVertex.Z;

    dU = (V2->U - U) / NB_PT_TEXT;
    dV = (V2->V - V) / NB_PT_TEXT;
    dX = (V2->CameraVertex.X - X) / NB_PT_TEXT;
    dY = (V2->CameraVertex.Y - Y) / NB_PT_TEXT;
    dZ = (V2->CameraVertex.Z - Z) / NB_PT_TEXT;

    dXscr = V2->ScreenVertex.X - V1->ScreenVertex.X; 
    dYscr = V2->ScreenVertex.Y - V1->ScreenVertex.Y;

    if(dXscr < 0)
    {
      dXscr = -dXscr;
      inc_xh = -1;
      inc_xl = -1;
    } else {
      inc_xh = 1;
      inc_xl = 1;
    }
    if(dYscr < 0)
    {
      dYscr = -dYscr;
      inc_yh = -1;
      inc_yl = -1;
    } else {
      inc_yh = 1;
      inc_yl = 1;
    }

    if (dXscr > dYscr)
    {

      Scr1 = V1->ScreenVertex.X;

      A = (DOUBLE)(V1->ScreenVertex.X - (INT)HalfWidth);
      TanA = X / Z;
     
      lW = X;
      for(k=0; k<NB_PT_TEXT+1; k++)
      {	
        lW += dX;
	TanB = lW / Z;

        Scr2 = (INT)(A*TanB/TanA) + HalfWidth; 
        dScr = Scr2 - Scr1;

        if(dScr < 0) dScr = -dScr;

        TabScr[k] = Scr1;
        TabX[k] = dX / (DOUBLE)dScr;
        TabY[k] = dY / (DOUBLE)dScr;
        TabZ[k] = dZ / (DOUBLE)dScr;
        TabU[k] = dU / (DOUBLE)dScr;
        TabV[k] = dV / (DOUBLE)dScr;

        Scr1 = Scr2;
      }

      long_d = dXscr;
      short_d = dYscr; 
      inc_yl = 0;

      Yscr = V1->ScreenVertex.Y;
      Xscr = V1->ScreenVertex.X;

      d = (short_d<<1) - long_d;
      add_dl = short_d<<1;
      add_dh = (short_d<<1) - (long_d<<1);

      dU = TabU[0];
      dV = TabV[0];
      dX = TabX[0];
      dY = TabY[0];
      dZ = TabZ[0];
      k = 0;
      for(i=0; i<=long_d; i++)
      {
	if(G_Start[Yscr].X > (INT)Xscr)
	{
	  G_Start[Yscr].X = (INT)Xscr;
	  G_Start[Yscr].CamVert.X = X;
	  G_Start[Yscr].CamVert.Y = Y;
	  G_Start[Yscr].CamVert.Z = Z;
	  G_Start[Yscr].U = U;
	  G_Start[Yscr].V = V;
	}
	if(G_End[Yscr].X < (INT)Xscr)
	{
	  G_End[Yscr].X = (INT)Xscr;
	  G_End[Yscr].CamVert.X = X;
	  G_End[Yscr].CamVert.Y = Y;
	  G_End[Yscr].CamVert.Z = Z;
	  G_End[Yscr].U = U;
	  G_End[Yscr].V = V;
	}
        if(Xscr == TabScr[k])
	{
	  k++;
          dU = TabU[k];
	  dV = TabV[k];
	  dX = TabX[k];
	  dY = TabY[k];
	  dZ = TabZ[k];
        }
	if(d >= 0)
        {
          Yscr += inc_yh;
          Xscr += inc_xh;
	  d += add_dh;
	} else {
          Yscr += inc_yl;
          Xscr += inc_xl;
	  d += add_dl;
	}

        X+=dX; Y+=dY; Z+=dZ; U+=dU; V+=dV;
      }
    } else {
      Scr1 = V1->ScreenVertex.Y;
      A = (DOUBLE)(V1->ScreenVertex.Y - (INT)HalfHeight);
      TanA = Y / Z;
     
      lW = Y;
      for(k=0; k<NB_PT_TEXT+1; k++)
      {	
        lW += dY;
	TanB = lW / Z;

        Scr2 = (INT)(A*TanB/TanA) + HalfHeight; 
        dScr = Scr2 - Scr1;

        if(dScr < 0) dScr = -dScr;

        TabScr[k] = Scr1;
        TabX[k] = dX / dScr;
        TabY[k] = dY / dScr;
        TabZ[k] = dZ / dScr;
        TabU[k] = dU / dScr;
        TabV[k] = dV / dScr;

        Scr1 = Scr2;
      }

      long_d = dYscr;
      short_d = dXscr; 
      inc_xl = 0;

      Yscr = V1->ScreenVertex.Y;
      Xscr = V1->ScreenVertex.X;

      d = (short_d<<1) - long_d;
      add_dl = short_d<<1;
      add_dh = (short_d<<1) - (long_d<<1);

      dU = TabU[0];
      dV = TabV[0];
      dX = TabX[0];
      dY = TabY[0];
      dZ = TabZ[0];

      for(i=0; i<=long_d; i++)
      {
	if(G_Start[Yscr].X > (INT)Xscr)
	{
	  G_Start[Yscr].X = (INT)Xscr;
	  G_Start[Yscr].CamVert.X = X;
	  G_Start[Yscr].CamVert.Y = Y;
	  G_Start[Yscr].CamVert.Z = Z;
	  G_Start[Yscr].U = U;
	  G_Start[Yscr].V = V;
	}
	if(G_End[Yscr].X < (INT)Xscr)
	{
	  G_End[Yscr].X = (INT)Xscr;
	  G_End[Yscr].CamVert.X = X;
	  G_End[Yscr].CamVert.Y = Y;
	  G_End[Yscr].CamVert.Z = Z;
	  G_End[Yscr].U = U;
	  G_End[Yscr].V = V;
	}
        if(Xscr == TabScr[k])
	{
          k++;
          dU = TabU[k];
	  dV = TabV[k];
	  dX = TabX[k];
	  dY = TabY[k];
	  dZ = TabZ[k];
        }
	if(d >= 0)
        {
          Yscr += inc_yh;
          Xscr += inc_xh;
	  d += add_dh;
	} else {
          Yscr += inc_yl;
          Xscr += inc_xl;
	  d += add_dl;
	}

        X+=dX; Y+=dY; Z+=dZ; U+=dU; V+=dV;
      }
    }
    V1 = V2;
  }
}