E:/PPC/XFlib/source/xf_vecto.c

Go to the documentation of this file.

#include "xf_buffer.h"
#include "xf_vecto.h"
#include "xf_bg.h"
#include <malloc.h>

void xf_DoVect(u8 bg);



void XF_LoadVectoBg(u8 number){

        xf_dovecto = xf_DoVect;

        // si le bg existe déjà
        if (xf_bg[number].Alive){
                // on vérifie qu'il n'y a pas d'objets vectoriels déjà créés
                if (xf_bg[number].vectObjects){
                        // sinon on les efface ...
                        xf_vectObject * ptr;

                        while (xf_bg[number].vectObjects){
                                ptr = xf_bg[number].vectObjects;
                                while (ptr->next) ptr = ptr->next;
                                free(ptr);
                        }
                }

        }
        else{
                // si le fond n'existe pas, on en crée un, vide
                xf_bg[number].Alive = 1;
                xf_bg[number].Alpha = 32;
                xf_bg[number].Priority = number; // Priorit? classique
                xf_bg[number].BgMode = BG_BLANK;
                xf_bg[number].vectObjects = NULL;
        }

}

xf_vectObject* XF_VectoNew(u8 bg){
        xf_vectObject * ptr = xf_bg[bg].vectObjects;
        
        if (ptr){
                while (ptr->next) ptr=ptr->next;
                ptr->next = malloc(sizeof(xf_vectObject));
                ptr = ptr->next;
        }
        else {
                xf_bg[bg].vectObjects = malloc(sizeof(xf_vectObject));
                ptr = xf_bg[bg].vectObjects;
        }   
        ptr->next = 0; // Rien après  
        
        return ptr;
}  


void XF_ResetVecto(u8 bg){
        xf_vectObject *ptr;
        xf_vectObject *next;
        ptr = next = xf_bg[bg].vectObjects;
        
        xf_bg[bg].vectObjects = 0;
        
        while(ptr){
        
                next = ptr->next;
                free(ptr);
                
                ptr = next;
        }
}

void XF_VectoDelete(xf_vectObject* ptr){
        // Circulez !
        
        

}



void XF_VectoChgLine(xf_vectObject* ptr, s32 x1, s32 y1, s32 x2, s32 y2, u16 color, u8 alpha){

        ptr->objectType = VECT_LINE;
        ptr->x1 = x1; ptr->y1 = y1;
        ptr->x2 = x2; ptr->y2 = y2;
        ptr->color = color; ptr->alpha = alpha;
} 

xf_vectObject* XF_VectoAddLine(u8 bg, s32 x1, s32 y1, s32 x2, s32 y2, u16 color, u8 alpha)
{
        xf_vectObject* ptr = XF_VectoNew(bg);
        XF_VectoChgLine(ptr, x1, y1, x2, y2, color, alpha);
        return ptr;
}

void XF_VectoChgRectangle(xf_vectObject* ptr, s32 x1, s32 y1, s32 x2, s32 y2, u8 bordersize, u16 bordercolor, u16 color, s8 alpha)
{
        ptr->objectType = VECT_RECTANGLE;
        ptr->x1 = x1; ptr->y1 = y1;
        ptr->x2 = x2; ptr->y2 = y2;
        ptr->color = color; ptr->alpha = alpha;
        ptr->bordercolor = bordercolor;
        ptr->bordersize = bordersize;    
}   


xf_vectObject* XF_VectoAddRectangle(u8 bg, s32 x1, s32 y1, s32 x2, s32 y2, u8 bordersize, u16 bordercolor, u16 color, s8 alpha)
{
        xf_vectObject* ptr = XF_VectoNew(bg);
        XF_VectoChgRectangle(ptr, x1, y1, x2, y2, bordersize, bordercolor, color, alpha);
        return ptr;
}

void XF_VectoChgGradient(xf_vectObject* ptr, s32 x1, s32 y1, s32 x2, s32 y2, u16 color0, u16 color1, s8 alpha)
{
        ptr->objectType = VECT_GRADIENT;
        ptr->x1 = x1; ptr->y1 = y1;
        ptr->x2 = x2; ptr->y2 = y2;
        ptr->color = color1; ptr->alpha = alpha;
        ptr->bordercolor = color0; 
}   


xf_vectObject* XF_VectoAddGradient(u8 bg, s32 x1, s32 y1, s32 x2, s32 y2, u16 color0, u16 color1, s8 alpha)
{
        xf_vectObject* ptr = XF_VectoNew(bg);
        XF_VectoChgGradient(ptr, x1, y1, x2, y2, color0, color1, alpha);
        
        return ptr;
}




void xf_vectlineAlpha(s32 x1, s32 y1, s32 x2, s32 y2, u16 color, s8 alpha){

        s32 dx, dy, i, x1nc, y1nc, cumul, x, y;
        s32 temp;
        x = x1;
        y = y1;
        dx = x2 - x1;
        dy = y2 - y1;
        
        
        x1nc = (dx > 0) ? 1 : -1;
        y1nc = (dy > 0) ? 1 : -1;
        
        if (dx < 0) {
           dx=-dx;
           temp = x1;
           x1 = x2;
           x2 = temp;
        }       

        if (dy < 0) {
           dy=-dy;
           temp = y1;
           y1 = y2;
           y2 = temp;
        }       
        
        XF_AdjustCopyLimits(x1, y1, dx, dy);
        x2 = x1 + xf_limits.maxx-1;     y2 = y1 + xf_limits.maxy-1;
        x1 += xf_limits.minx;           y1 += xf_limits.miny;
        
        if((x >= x1) && (x < x2) && (y >= y1) && (y < y2))      XF_SetPixelAlpha(x, y, color, alpha);
        
        

        if (dx > dy){

                cumul = dx>>1;
                
                
                for (i=1; (i<=dx)&& !((x >= x1) && (x < x2) && (y >= y1) && (y < y2)); i++){

                        x += x1nc;
                        cumul += dy;
                        if (cumul >= dx){
                                cumul -= dx;
                                y += y1nc;
                        }
                }
                
                if((x >= x1) && (x < x2) && (y >= y1) && (y < y2)){
                        for (; (i<=dx) && (x >= x1) && (x < x2) && (y >= y1) && (y < y2); i++){
        
                                x += x1nc;
                                cumul += dy;
                                if (cumul >= dx){
                                        cumul -= dx;
                                        y += y1nc;
                                }
                                XF_SetPixelAlpha(x, y, color, alpha);
                        }
                }               
        }
        else{

                cumul = dy>>1;
                for (i=1; (i<=dy) && !((x >= x1) && (x < x2) && (y >= y1) && (y < y2)); i++){

                        y += y1nc;
                        cumul += dx;
                        if (cumul >= dy){
                                cumul -= dy;
                                x += x1nc;
                        }
                }               
                
                
                if((x >= x1) && (x < x2) && (y >= y1) && (y < y2)){
                
                        for (; (i<=dy)&&(x >= x1) && (x < x2) && (y >= y1) && (y < y2); i++){
        
                                y += y1nc;
                                cumul += dx;
                                if (cumul >= dy){
                                        cumul -= dy;
                                        x += x1nc;
                                }
                                XF_SetPixelAlpha(x, y, color, alpha);
                        }
                }               
        }

}



void xf_vectline(s32 x1, s32 y1, s32 x2, s32 y2, u16 color){

        s32 dx, dy, i, x1nc, y1nc, cumul, x, y;
        s32 temp;
        x = x1;
        y = y1;
        dx = x2 - x1;
        dy = y2 - y1;
        
        
        x1nc = (dx > 0) ? 1 : -1;
        y1nc = (dy > 0) ? 1 : -1;
        
        if (dx < 0) {
           dx=-dx;
           temp = x1;
           x1 = x2;
           x2 = temp;
        }       

        if (dy < 0) {
           dy=-dy;
           temp = y1;
           y1 = y2;
           y2 = temp;
        }       
        
        XF_AdjustCopyLimits(x1, y1, dx, dy);
        x2 = x1 + xf_limits.maxx-1;     y2 = y1 + xf_limits.maxy-1;
        x1 += xf_limits.minx;           y1 += xf_limits.miny;
        

        if((x >= x1) && (x < x2) && (y >= y1) && (y < y2))      XF_SetPixel(x, y, color);
        
        

        if (dx > dy){

                cumul = dx>>1;
                
                
                for (i=1; (i<=dx)&& !((x >= x1) && (x < x2) && (y >= y1) && (y < y2)); i++){

                        x += x1nc;
                        cumul += dy;
                        if (cumul >= dx){
                                cumul -= dx;
                                y += y1nc;
                        }
                }
                
                if((x >= x1) && (x < x2) && (y >= y1) && (y < y2)){
                        for (; (i<=dx) && (x >= x1) && (x < x2) && (y >= y1) && (y < y2); i++){
        
                                x += x1nc;
                                cumul += dy;
                                if (cumul >= dx){
                                        cumul -= dx;
                                        y += y1nc;
                                }
                                XF_SetPixel(x, y, color);
                        }
                }               
        }
        else{

                cumul = dy>>1;
                for (i=1; (i<=dy) && !((x >= x1) && (x < x2) && (y >= y1) && (y < y2)); i++){

                        y += y1nc;
                        cumul += dx;
                        if (cumul >= dy){
                                cumul -= dy;
                                x += x1nc;
                        }
                }               
                
                
                if((x >= x1) && (x < x2) && (y >= y1) && (y < y2)){
                
                        for (; (i<=dy)&&(x >= x1) && (x < x2) && (y >= y1) && (y < y2); i++){
        
                                y += y1nc;
                                cumul += dx;
                                if (cumul >= dy){
                                        cumul -= dy;
                                        x += x1nc;
                                }
                                XF_SetPixel(x, y, color);
                        }
                }               
        }

}

void DrawWuLine (s32 X0, s16 Y0, s16 X1, s16 Y1,
         u16 BaseColor)
{
   unsigned short IntensityBits = 5;
   unsigned short IntensityShift, ErrorAdj, ErrorAcc;
   unsigned short ErrorAccTemp, Weighting, WeightingComplementMask;
   short DeltaX, DeltaY, Temp, XDir;
   short NumLevels = 32;

   /* Make sure the line runs top to bottom */
   if (Y0 > Y1) {
      Temp = Y0; Y0 = Y1; Y1 = Temp;
      Temp = X0; X0 = X1; X1 = Temp;
   }
      
   XF_SetPixel(X0, Y0, BaseColor);

   if ((DeltaX = X1 - X0) >= 0) {
      XDir = 1;
   } else {
      XDir = -1;
      DeltaX = -DeltaX; /* make DeltaX positive */
   }

   if ((DeltaY = Y1 - Y0) == 0) {
      while (DeltaX-- != 0) {
         X0 += XDir;
         XF_SetPixel(X0, Y0, BaseColor);
      }
      return;
   }
   if (DeltaX == 0) {
      do {
         Y0++;
         XF_SetPixel(X0, Y0, BaseColor);
      } while (--DeltaY != 0);
      return;
   }
   if (DeltaX == DeltaY) {
      do {
         X0 += XDir;
         Y0++;
         XF_SetPixel(X0, Y0, BaseColor);
      } while (--DeltaY != 0);
      return;
   }
   /* Line is not horizontal, diagonal, or vertical */
   ErrorAcc = 0; 
   IntensityShift = 16 - IntensityBits;
   WeightingComplementMask = NumLevels - 1;

   if (DeltaY > DeltaX) {
      ErrorAdj = ((unsigned long) DeltaX << 16) / (unsigned long) DeltaY;
      /* Draw all pixels other than the first and last */
      while (--DeltaY) {
         ErrorAccTemp = ErrorAcc;   /* remember currrent accumulated error */
         ErrorAcc += ErrorAdj;      /* calculate error for next pixel */
         if (ErrorAcc <= ErrorAccTemp) {
            X0 += XDir;
         }
         Y0++; 
         Weighting = ErrorAcc >> IntensityShift;
         XF_SetPixelAlpha(X0, Y0, BaseColor, 32-Weighting);
         XF_SetPixelAlpha(X0 + XDir, Y0, BaseColor, 32-(Weighting ^ WeightingComplementMask));
      }

      XF_SetPixel(X1, Y1, BaseColor);
      return;
   }

   ErrorAdj = ((unsigned long) DeltaY << 16) / (unsigned long) DeltaX;
   /* Draw all pixels other than the first and last */
   while (--DeltaX) {
      ErrorAccTemp = ErrorAcc;   /* remember currrent accumulated error */
      ErrorAcc += ErrorAdj;      /* calculate error for next pixel */
      if (ErrorAcc <= ErrorAccTemp) {
         /* The error accumulator turned over, so advance the Y coord */
         Y0++;
      }
      X0 += XDir; 
          
      Weighting = ErrorAcc >> IntensityShift;
      XF_SetPixelAlpha(X0, Y0, BaseColor, 32-Weighting);
      XF_SetPixelAlpha(X0, Y0+1, BaseColor, 32-(Weighting ^ WeightingComplementMask));
   }

   XF_SetPixel(X1, Y1, BaseColor);
}


void DrawWuLineAlpha (s32 X0, s16 Y0, s16 X1, s16 Y1,
         u16 BaseColor, s32 alpha)
{
   unsigned short IntensityBits = 5;
   unsigned short IntensityShift, ErrorAdj, ErrorAcc;
   unsigned short ErrorAccTemp, Weighting, WeightingComplementMask;
   short DeltaX, DeltaY, Temp, XDir;
   short NumLevels = 32;

   /* Make sure the line runs top to bottom */
   if (Y0 > Y1) {
      Temp = Y0; Y0 = Y1; Y1 = Temp;
      Temp = X0; X0 = X1; X1 = Temp;
   }
      
   XF_SetPixelAlpha(X0, Y0, BaseColor, alpha);

   if ((DeltaX = X1 - X0) >= 0) {
      XDir = 1;
   } else {
      XDir = -1;
      DeltaX = -DeltaX; /* make DeltaX positive */
   }

   if ((DeltaY = Y1 - Y0) == 0) {
      while (DeltaX-- != 0) {
         X0 += XDir;
         XF_SetPixelAlpha(X0, Y0, BaseColor, alpha);
      }
      return;
   }
   if (DeltaX == 0) {
      do {
         Y0++;
         XF_SetPixelAlpha(X0, Y0, BaseColor, alpha);
      } while (--DeltaY != 0);
      return;
   }
   if (DeltaX == DeltaY) {
      do {
         X0 += XDir;
         Y0++;
         XF_SetPixelAlpha(X0, Y0, BaseColor, alpha);
      } while (--DeltaY != 0);
      return;
   }
   /* Line is not horizontal, diagonal, or vertical */
   ErrorAcc = 0; 
   IntensityShift = 16 - IntensityBits;
   WeightingComplementMask = NumLevels - 1;

   if (DeltaY > DeltaX) {
      ErrorAdj = ((unsigned long) DeltaX << 16) / (unsigned long) DeltaY;
      /* Draw all pixels other than the first and last */
      while (--DeltaY) {
         ErrorAccTemp = ErrorAcc;   /* remember currrent accumulated error */
         ErrorAcc += ErrorAdj;      /* calculate error for next pixel */
         if (ErrorAcc <= ErrorAccTemp) {
            X0 += XDir;
         }
         Y0++; 
         Weighting = ErrorAcc >> IntensityShift;
         XF_SetPixelAlpha(X0, Y0, BaseColor, ((32-Weighting)*alpha)>>5);
         XF_SetPixelAlpha(X0 + XDir, Y0, BaseColor, ((32-(Weighting ^ WeightingComplementMask))*alpha)>>5);
      }

      XF_SetPixelAlpha(X1, Y1, BaseColor, alpha);
      return;
   }

   ErrorAdj = ((unsigned long) DeltaY << 16) / (unsigned long) DeltaX;
   /* Draw all pixels other than the first and last */
   while (--DeltaX) {
      ErrorAccTemp = ErrorAcc;   /* remember currrent accumulated error */
      ErrorAcc += ErrorAdj;      /* calculate error for next pixel */
      if (ErrorAcc <= ErrorAccTemp) {
         /* The error accumulator turned over, so advance the Y coord */
         Y0++;
      }
      X0 += XDir; 
          
      Weighting = ErrorAcc >> IntensityShift;
      XF_SetPixelAlpha(X0, Y0, BaseColor, (((32-Weighting)*alpha)>>5));
      XF_SetPixelAlpha(X0, Y0+1, BaseColor, (((32-(Weighting ^ WeightingComplementMask))*alpha)>>5));
   }

   XF_SetPixelAlpha(X1, Y1, BaseColor, alpha);
}






extern inline void xf_plotline(s16 startx, s16 endx, s16 y, u16 color){
   u32 bigcolor = color | (color << 16);
        s16 x;
   
   if((startx&1) && (startx < endx)){ // Impair...
      XF_SetPixel(startx, y, bigcolor);
      startx++;
   }   
   
   u32 *buffer;
   buffer = (u32*)(xf_buffer+startx+y*WIDTH);
        for(x = startx; x < endx-1; x+=2) {
           *(buffer++) = bigcolor;
   }
                
        endx--;
   if(((endx&1) == 0)&&(endx > startx)){ // Impair...
      XF_SetPixel(endx, y, bigcolor);
   }   

   
}   

extern inline u16 xf_vectalpha(u32 color0, u32 color1, s32 alpha){
   if(alpha == 32) return color0;
   if(alpha == 0) return color1;
        color0 = (color0 | (color0<<16)) & ALPHA_MASK;
        color1 = (color1 | (color1<<16)) & ALPHA_MASK;

        //do alpha op
        color0 = ((((color0-color1)*alpha)>>5) + color1)&ALPHA_MASK;

        //recombine colors
        return (color0 | (color0 >> 16));
}   


void xf_vectgradient(s32 x1, s32 y1, s32 x2, s32 y2, u16 color0, u16 color1, u8 alpha){
   s16 temp, tempcol;

   // Bon ordre
   if(x1 > x2) {
      temp = x1;
      x1 = x2;
      x2 = temp;
        }   
   if(y1 > y2) {
      temp = y1;
      y1 = y2;
      y2 = temp;
      tempcol = color0;
      color0 = color1;
      color1 = tempcol; // Invert colors
        }   
              
   XF_AdjustCopyLimits(x1, y1, x2+1-x1, y2+1-y1); 
          
   s16 y;
        
        u32 div = (1 << 16) / (y2 - y1 + 1);

        if((xf_limits.minx > xf_limits.maxx) || (xf_limits.miny > xf_limits.maxy)) return;
        
        if(alpha == 32){                
           for(y = xf_limits.miny; y < xf_limits.maxy; y++) {
              tempcol = xf_vectalpha(color0, color1, 32-((div*y)>>11));
                   xf_plotline(x1 + xf_limits.minx, x1 + xf_limits.maxx, y1, tempcol);
                   y1++;
                }               
           
        }               
        else{
/*         for(y = starty; y < endy; y++) {
                for(x = startx; x < endx; x++) {
                 XF_SetPixelAlpha(x, y, color, alpha);
              }
                }               */         
        }   
   
   
}




void xf_vectrectangle(s32 x1, s32 y1, s32 x2, s32 y2, u8 bordersize, u16 bordercolor, u16 color, u8 alpha){
   s16 temp;
   
   // Bon ordre
   if(x1 > x2) {
      temp = x1;
      x1 = x2;
      x2 = temp;
        }   
   if(y1 > y2) {
      temp = y1;
      y1 = y2;
      y2 = temp;
        }   
        
//      XF_DebugText(0, 2, "%d %d %d %d   ", x1, y1, x2, y2);
      
   XF_AdjustCopyLimits(x1, y1, x2+1-x1, y2+1-y1); 

//      XF_DebugText(0, 3, "%d %d %d %d   ", xf_limits.minx, xf_limits.miny, xf_limits.maxx, xf_limits.maxy);
          
   s16 x, y;
  
        if((bordercolor != xf_transpcolor) && (bordersize)){ 
           // Haut et gauche...
           if(alpha == 32){
                   for(y = xf_limits.miny; (y < bordersize) && (y < xf_limits.maxy); y++){  
                      xf_plotline(x1+xf_limits.minx, x1+xf_limits.maxx, y+y1, bordercolor);
                        }       
                        
                   for(x = xf_limits.minx; (x < bordersize) && (x < xf_limits.maxx); x++){  
                           for(y = xf_limits.miny+1; y < xf_limits.maxy-1; y++){
                              XF_SetPixel(x + x1, y + y1, bordercolor);
                           }   
                        }       
                        
                   for(y = xf_limits.maxy-1; (y > (y2-y1) - bordersize) && (y >= xf_limits.miny); y--){  
                           xf_plotline(x1+xf_limits.minx, x1+xf_limits.maxx, y+y1, bordercolor);
                        }       
                        
                   for(x = xf_limits.maxx-1; (x > (x2-x1) - bordersize) && (x >= xf_limits.minx); x--){  
                           for(y = xf_limits.miny+1; y < xf_limits.maxy-1; y++){
                              XF_SetPixel(x + x1, y + y1, bordercolor);
                           }   
                        }               
                }               
                else{
                   for(y = xf_limits.miny; (y < bordersize) && (y < xf_limits.maxy); y++){  
                           for(x = xf_limits.minx; x < xf_limits.maxx; x++){
                              XF_SetPixelAlpha(x + x1, y + y1, bordercolor, alpha);
                           }   
                        }       
                        
                   for(x = xf_limits.minx; (x < bordersize) && (x < xf_limits.maxx); x++){  
                           for(y = xf_limits.miny+1; y < xf_limits.maxy-1; y++){
                              XF_SetPixelAlpha(x + x1, y + y1, bordercolor, alpha);
                           }   
                        }       
                        
                   for(y = xf_limits.maxy-1; (y > (y2-y1) - bordersize) && (y >= xf_limits.miny); y--){  
                           for(x = xf_limits.minx; x < xf_limits.maxx; x++){
                              XF_SetPixelAlpha(x + x1, y + y1, bordercolor, alpha);
                           }   
                        }       
                        
                   for(x = xf_limits.maxx-1; (x > (x2-x1) - bordersize) && (x >= xf_limits.minx); x--){  
                           for(y = xf_limits.miny+1; y < xf_limits.maxy-1; y++){
                              XF_SetPixelAlpha(x + x1, y + y1, bordercolor, alpha);
                           }   
                        }                  
                }                                       
                
        }       

          
        if(color != xf_transpcolor){        // Si visible...
                s16 startx, starty, endx, endy;
                startx = x1+bordersize; if(startx < x1+xf_limits.minx) startx = x1+xf_limits.minx;
                starty = y1 + bordersize; if(starty < y1 + xf_limits.miny) starty = y1 + xf_limits.miny;                
                endx = x2+1-bordersize; if(endx > x1+xf_limits.maxx) endx = x1+xf_limits.maxx;
                endy = y2+1-bordersize; if(endy > y1+xf_limits.maxy) endy = y1+xf_limits.maxy;

                if((startx >= endx) || (starty >= endy)) return;
                
                if(alpha == 32){
                   for(y = starty; y < endy; y++) xf_plotline(startx, endx, y, color);
                }               
                else{
                   for(y = starty; y < endy; y++) {
                        for(x = startx; x < endx; x++) {
                         XF_SetPixelAlpha(x, y, color, alpha);
                      }
                        }                          
                }   
        }       
   
   
}



void XF_VectoChgCircle(xf_vectObject* ptr, s32 x, s32 y, s16 bordersize, u16 bordercolor, u16 color, s8 alpha)
{
        ptr->objectType = VECT_CIRCLE;
        ptr->x1 = x; ptr->y1 = y;
        ptr->color = color; ptr->alpha = alpha;
        ptr->bordercolor = bordercolor;
        ptr->bordersize = bordersize;   
}   


xf_vectObject* XF_VectoAddCircle(u8 bg, s32 x, s32 y, s16 bordersize, u16 bordercolor, u16 color, s8 alpha)
{
        xf_vectObject* ptr = XF_VectoNew(bg);
        XF_VectoChgCircle(ptr, x, y, bordersize, bordercolor, color, alpha);
        return ptr;
}



void xf_vectcircle(s16 xCenter, s16 yCenter, s16 Radius, u16 bordercolor, u16 color, u16 alpha){
   
    int x=0;
    int y=Radius;
    int p=(5-(Radius<<2))>>2; //Midpoint Algorithm
    
    XF_SetPixel(xCenter  , yCenter+y, bordercolor);
    XF_SetPixel(xCenter  , yCenter-y, bordercolor);
    XF_SetPixel(xCenter+y, yCenter  , bordercolor);
    XF_SetPixel(xCenter-y, yCenter  , bordercolor);
    
         while(x++<y) {
      if(p<0) p+=1+(x<<1);
      else    p+=1+((x- --y)<<1);
      if(x<y) {
        XF_SetPixel(xCenter+x, yCenter+y, bordercolor);
        XF_SetPixel(xCenter-x, yCenter+y, bordercolor);
        XF_SetPixel(xCenter+x, yCenter-y, bordercolor);
        XF_SetPixel(xCenter-x, yCenter-y, bordercolor);
        XF_SetPixel(xCenter+y, yCenter+x, bordercolor);
        XF_SetPixel(xCenter-y, yCenter+x, bordercolor);
        XF_SetPixel(xCenter+y, yCenter-x, bordercolor);
        XF_SetPixel(xCenter-y, yCenter-x, bordercolor);
      }
                else if(x==y) 
                {
        XF_SetPixel(xCenter+x, yCenter+y, bordercolor);
        XF_SetPixel(xCenter-x, yCenter+y, bordercolor);
        XF_SetPixel(xCenter+x, yCenter-y, bordercolor);
        XF_SetPixel(xCenter-x, yCenter-y, bordercolor);
                }
        }
}   





void xf_DoVect(u8 bg){
        u16 alpha;
        
        xf_vectObject *o = xf_bg[bg].vectObjects;

        while (o){
           alpha = (o->alpha * xf_bg[bg].Alpha)>>5; // Alpha combiné
                
                if (o->objectType == VECT_LINE){
                   if(alpha == 32) DrawWuLine(o->x1, o->y1, o->x2, o->y2, o->color);// xf_vectline(o->x1, o->y1, o->x2, o->y2, o->color);
                   else DrawWuLineAlpha(o->x1, o->y1, o->x2, o->y2, o->color, alpha);// xf_vectline(o->x1, o->y1, o->x2, o->y2, o->color);//xf_vectlineAlpha(o->x1, o->y1, o->x2, o->y2, o->color, alpha);
                }
                else if (o->objectType == VECT_RECTANGLE){
                        xf_vectrectangle(o->x1, o->y1, o->x2, o->y2, o->bordersize, o->bordercolor, o->color, alpha);
                }
                else if (o->objectType == VECT_GRADIENT){
                        xf_vectgradient(o->x1, o->y1, o->x2, o->y2, o->bordercolor, o->color, alpha);
                }
                else if (o->objectType == VECT_CIRCLE){
                        xf_vectcircle(o->x1, o->y1, o->bordersize, o->bordercolor, o->color, alpha);
                }

                o = o->next;
        }

}

---