Forum Casio - Autres questions


Index du Forum » Autres questions » [fx-CG 20] Liste des meilleures fonctions
LancelotHors ligneMembrePoints: 1274 Défis: 160 Message

[fx-CG 20] Liste des meilleures fonctions

Posté le 05/10/2013 18:41


Bonjour à tous et à toutes (oui, je pense qu'il n'y a pas que des hommes sur PC )

Afin de faciliter et d'encourager le travaille du programmeur en C, C++ sur fx-CG 20, j'ai décider d'ouvrir ce topic pour poster les meilleurs fonctions (affichage d'une image, Getkey, ...) que vous trouvez utile pour programmer. ce topic a comme but de faciliter la découverte de ces fonctions pour les nouveaux programmeurs (comme moi ) mais aussi permettre au expérimenté de faire part de leurs meilleurs fonctions qu'il ont crées ou utilisent

En voici celles qui me sont arrivées:
Getkey
Getkey
Le .c
int keydown(int basic_keycode)
{
    const unsigned short* keyboard_register = (unsigned short*)0xA44B0000;
    [purple]int[/purple] row, col, word, bit;
    row = basic_keycode%10;
    col = basic_keycode/10-1;
    word = row>>1;
    bit = col + 8*(row&1);
    [b][blue]return[/blue][/b] (0 != (keyboard_register[word] & 1<<bit));
}


Le .h
[brown]#ifndef _KEY[/brown]
[brown]#define _KEY[/brown]

[purple]int[/purple] key_down(int basic_keycode);

[b][green]/***************/
/** Key codes **/
/***************/[/green][/b]
[brown]#define K_F1    79[/brown]
[brown]#define K_F2    69[/brown]
[brown]#define K_F3    59[/brown]
[brown]#define K_F4    49[/brown]
[brown]#define K_F5    39[/brown]
[brown]#define K_F6    29[/brown]

[brown]#define K_SHIFT 78[/brown]
[brown]#define K_OPTN  68[/brown]
[brown]#define K_VARS  58[/brown]
[brown]#define K_MENU  48[/brown]
[brown]#define K_LEFT  38[/brown]
[brown]#define K_UP    28[/brown]

[brown]#define K_ALPHA 77[/brown]
[brown]#define K_SQR   67[/brown]
[brown]#define K_EXPO  57[/brown]
[brown]#define K_EXIT  47[/brown]
[brown]#define K_DOWN  37[/brown]
[brown]#define K_RIGHT 27[/brown]

[brown]#define K_THETA 76[/brown]
[brown]#define K_LOG   66[/brown]
[brown]#define K_LN    56[/brown]
[brown]#define K_SIN   46[/brown]
[brown]#define K_COS   36[/brown]
[brown]#define K_TAN   26[/brown]

[brown]#define K_FRAC  75[/brown]
[brown]#define K_FD    65[/brown]
[brown]#define K_LPAR  55[/brown]
[brown]#define K_RPAR  45[/brown]
[brown]#define K_COMMA 35[/brown]
[brown]#define K_STORE 25[/brown]

[brown]#define K_7     74[/brown]
[brown]#define K_8     64[/brown]
[brown]#define K_9     54[/brown]
[brown]#define K_DEL   34[/brown]

[brown]#define K_4     73[/brown]
[brown]#define K_5     63[/brown]
[brown]#define K_6     53[/brown]
[brown]#define K_MULT  43[/brown]
[brown]#define K_DIV   33[/brown]

[brown]#define K_1     72[/brown]
[brown]#define K_2     62[/brown]
[brown]#define K_3     52[/brown]
[brown]#define K_PLUS  42[/brown]
[brown]#define K_MINUS 32[/brown]

[brown]#define K_0     71[/brown]
[brown]#define K_DOT   61[/brown]
[brown]#define K_EXP   51[/brown]
[brown]#define K_NEG   41[/brown]
[brown]#define K_EXE   31[/brown]

[brown]#define K_AC    10[/brown]

#endif [green]//_KEY[/green]




Afficher un pixel
Afficher un pixel
void point(int x, int y, int color)
{
    char* VRAM = (char*)0xA8000000;
    VRAM += 2*(y*LCD_WIDTH_PX + x);
    *(VRAM++) = (color&0x0000FF00)>>8;
    *(VRAM++) = (color&0x000000FF);
    return;
}

Afficher un pixel avec la transparence
Afficher un pixel avec la transparence
static void text_drawPoint(int x, [purple]int[/purple] y, [purple]int[/purple] size, [purple]int[/purple] color, [purple]int[/purple] alpha)
{
    [purple]int[/purple] i, j;
    short* vram = VRAM;
    [b][blue]if[/blue][/b](x+size>=LCD_WIDTH_PX || x<0 || y+size>=LCD_HEIGHT_PX || y<0) [b][blue]return[/blue][/b];
    vram += y*LCD_WIDTH_PX + x;
    [b][blue]if[/blue][/b](alpha == [maroon]32[/maroon]) {
        [b][blue]for[/blue][/b](i=size ; i ; i--, vram+=LCD_WIDTH_PX-size) {
            [b][blue]for[/blue][/b](j=size ; j ; j--) {
                *(vram++) = color;
            }
        }
    } [b][blue]else[/blue][/b] {
        [b][blue]for[/blue][/b](i=size ; i ; i--, vram+=LCD_WIDTH_PX-size) {
            [b][blue]for[/blue][/b](j=size ; j ; j--) {
                *(vram++) = ((((color & 0xf81f) * alpha + (*vram & 0xf81f) * (32-alpha)) >> 5) & 0xf81f) |
                            ((((color & 0x07e0) * alpha + (*vram & 0x07e0) * (32-alpha)) >> 5) & 0x07e0);
            }
        }
    }
}

Valeur d'un pixel
Valeur d'un pixel
short CL_Getpixel(short x, short y)
{
     short *VRAM = GetVRAMAdress();
     [b][blue]return[/blue][/b] *(VRAM + (y * LCD_WIDTH_PX) + x);
}

Afficher une ligne
Afficher une ligne
void line(int x1, [purple]int[/purple] y1, [purple]int[/purple] x2, [purple]int[/purple] y2, short color)
{
    [purple]int[/purple] i, x, y, dx, dy, sx, sy, cumul;
    x = x1;
    y = y1;
    dx = x2 - x1;
    dy = y2 - y1;
    sx = sgn(dx);
    sy = sgn(dy);
    dx = abs(dx);
    dy = abs(dy);
    Bdisp_SetPoint_VRAM( x,  y,(int)  color );
    [b][blue]if[/blue][/b](dx > dy)
    {
        cumul = dx / 2;
        [b][blue]for[/blue][/b](i=[maroon]1[/maroon] ; i<dx ; i++)
        {
            x += sx;
            cumul += dy;
            [b][blue]if[/blue][/b](cumul > dx)
            {
                cumul -= dx;
                y += sy;
            }
            Bdisp_SetPoint_VRAM( x, y,(int)  color );
        }
    }
    [b][blue]else[/blue][/b]
    {
        cumul = dy / 2;
        [b][blue]for[/blue][/b](i=[maroon]1[/maroon] ; i<dy ; i++)
        {
            y += sy;
            cumul += dx;
            [b][blue]if[/blue][/b](cumul > dy)
            {
                cumul -= dy;
                x += sx;
            }
            Bdisp_SetPoint_VRAM(x, y,(int) color);
        }
    }
}

Tracer un cercle
Tracer un cercle
void drawCircle(int x0, [purple]int[/purple] y0, [purple]int[/purple] rayon, [purple]int[/purple] couleur)
{
   [purple]int[/purple] er = [maroon]1[/maroon] - rayon;
   [purple]int[/purple] erY = [maroon]1[/maroon];
   [purple]int[/purple] erX = -2 * rayon;
   [purple]int[/purple] x = rayon, y = [maroon]0[/maroon];

   point(x0, y0 + rayon, couleur);
   point(x0, y0 - rayon, couleur);
   point(x0 + rayon, y0, couleur);
   point(x0 - rayon, y0, couleur);

   [b][blue]while[/blue][/b](y < x)
   {
     [b][blue]if[/blue][/b](er > 0)
     {
       x--;
       erX += [maroon]2[/maroon];
       er += erX;
     }
     y++;
     erY += [maroon]2[/maroon];
     er += erY;    
     point(x0 + x, y0 + y, couleur);
     point(x0 - x, y0 + y, couleur);
     point(x0 + x, y0 - y, couleur);
     point(x0 - x, y0 - y, couleur);
     point(x0 + y, y0 + x, couleur);
     point(x0 - y, y0 + x, couleur);
     point(x0 + y, y0 - x, couleur);
     point(x0 - y, y0 - x, couleur);
   }
}

dessiner un cercle avec la transparence
dessiner un cercle avec la transparence

[brown]#define VRAM 0xA8000000[/brown]

void drawCircleAlpha(int x0, [purple]int[/purple] y0, [purple]int[/purple] rayon, [purple]int[/purple] couleur, [purple]int[/purple] alpha)
{
   [purple]int[/purple] er = [maroon]1[/maroon] - rayon;
   [purple]int[/purple] erY = [maroon]1[/maroon];
   [purple]int[/purple] erX = -2 * rayon;
   [purple]int[/purple] x = rayon, y = [maroon]0[/maroon];

   drawPoint(x0, y0 + rayon, [maroon]1[/maroon], couleur, alpha);
   drawPoint(x0, y0 - rayon, [maroon]1[/maroon], couleur, alpha);
   drawPoint(x0 + rayon, y0, [maroon]1[/maroon], couleur, alpha);
   drawPoint(x0 - rayon, y0, [maroon]1[/maroon], couleur, alpha);

   [b][blue]while[/blue][/b](y < x)
   {
     [b][blue]if[/blue][/b](error > 0)
     {
       x--;
       erX += [maroon]2[/maroon];
       er += erX;
     }
     y++;
     erY += [maroon]2[/maroon];
     er += erY;    
     drawPoint(x0 + x, y0 + y, [maroon]1[/maroon], couleur, alpha);
     drawPoint(x0 - x, y0 + y, [maroon]1[/maroon], couleur, alpha);
     drawPoint(x0 + x, y0 - y, [maroon]1[/maroon], couleur, alpha);
     drawPoint(x0 - x, y0 - y, [maroon]1[/maroon], couleur, alpha);
     drawPoint(x0 + y, y0 + x, [maroon]1[/maroon], couleur, alpha);
     drawPoint(x0 - y, y0 + x, [maroon]1[/maroon], couleur, alpha);
     drawPoint(x0 + y, y0 - x, [maroon]1[/maroon], couleur, alpha);
     drawPoint(x0 - y, y0 - x, [maroon]1[/maroon], couleur, alpha);
   }
}

static void drawPoint(int x, [purple]int[/purple] y, [purple]int[/purple] size, [purple]int[/purple] color, [purple]int[/purple] alpha)
{
     [purple]int[/purple] i, j;
     short* vram = VRAM;
     [b][blue]if[/blue][/b](x+size>=LCD_WIDTH_PX || x<0 || y+size>=LCD_HEIGHT_PX || y<0) [b][blue]return[/blue][/b];
     vram += y*LCD_WIDTH_PX + x;
     [b][blue]if[/blue][/b](alpha == [maroon]32[/maroon]) {
         [b][blue]for[/blue][/b](i=size ; i ; i--, vram+=LCD_WIDTH_PX-size) {
             [b][blue]for[/blue][/b](j=size ; j ; j--) {
                 *(vram++) = color;
             }
         }
     } [b][blue]else[/blue][/b] {
         [b][blue]for[/blue][/b](i=size ; i ; i--, vram+=LCD_WIDTH_PX-size) {
             [b][blue]for[/blue][/b](j=size ; j ; j--) {
                 *(vram++) = ((((color & 0xf81f) * alpha + (*vram & 0xf81f) * (32-alpha)) >> 5) & 0xf81f) |
                             ((((color & 0x07e0) * alpha + (*vram & 0x07e0) * (32-alpha)) >> 5) & 0x07e0);
             }
         }
     }
}


Tracer un disque
Tracer un disque
void CL_drawDiscus(int x0, [purple]int[/purple] y0, [purple]int[/purple] rayon, [purple]int[/purple] couleur)
{
     [purple]int[/purple] k;
     [purple]int[/purple] x,y,d;
     [b][blue]for[/blue][/b] (k=[maroon]0[/maroon]; k <= rayon; k++)
     {
         x = [maroon]0[/maroon];
         y = k;
         d = k - 1;
         [b][blue]while[/blue][/b] (y >= x)
         {
             CL_point( x0 + x, y0 + y, couleur);
             CL_point( x0 + y, y0 + x, couleur);
             CL_point( x0 - x, y0 + y, couleur);
             CL_point( x0 - y, y0 + x, couleur);
             CL_point( x0 + x, y0 - y, couleur);
             CL_point( x0 + y, y0 - x, couleur);
             CL_point( x0 - x, y0 - y, couleur);
             CL_point( x0 - y, y0 - x, couleur);
             [b][blue]if[/blue][/b] (d >= [maroon]2[/maroon]*x)
             {          
                 d -=[maroon]2[/maroon]*x+1;
                 x++;
             }
             [b][blue]else[/blue][/b] if (d < 2*(k-y))
             {
                 d += [maroon]2[/maroon]*y-1;
                 y--;
             }
             [b][blue]else[/blue][/b]
             {
                 d += [maroon]2[/maroon]*(y-x-1);
                 y--;
                 x++;
             }
         }
     }
}

Tracer un rectangle rempli
Tracer un rectangle rempli
void CL_Filled_Rectangle( [purple]int[/purple] xi, [purple]int[/purple] yi, [purple]int[/purple] xi2, [purple]int[/purple] yi2, unsigned short color)
{
         unsigned short* VRAM = GetVRAMAdress();
         [purple]int[/purple] i,j;
         const [purple]int[/purple] x = max(0,min(xi,xi2));
         const [purple]int[/purple] x2 = min( LCD_WIDTH_PX,max(xi,xi2));
        
         const [purple]int[/purple] y = max(0,min(yi,yi2));
         const [purple]int[/purple] y2 = min( LCD_WIDTH_PX,max(yi,yi2));
        
         const [purple]int[/purple] xm = max(x,x2);
         const [purple]int[/purple] ym = max(y,y2);
        
         const [purple]int[/purple] xe = x2-x+1;
        
         VRAM += LCD_WIDTH_PX*y + x;
         [b][blue]for[/blue][/b](j = min(y,y2); j <= ym; j++) {
                 [b][blue]for[/blue][/b](i=min(x,x2); i <= xm; i++) {
                         *(VRAM++) = color;
                 }
                 VRAM += LCD_WIDTH_PX-xe;
         }
}

tracer un polygone
tracer un polygone
void drawPoly(int xy[], int points, int color)
{
     int i;
     [b][blue]for[/blue][/b](i = [maroon]0[/maroon]; i < (points*2); i+=[maroon]2[/maroon])
     {
         [b][blue]if[/blue][/b](i < (points*2)-4)
         {
             line(xy[i ], xy[i+1], xy[i+2], xy[i+3], color);
         } [b][blue]else[/blue][/b]
         {
             line(xy[i ], xy[i+1], xy[0], xy[1], color);
         }
     }
}

Tracer un polygone rempli
Tracer un polygone rempli
static [purple]int[/purple] Filled_polygon_quicksord_partition(int *t, [purple]int[/purple] p, [purple]int[/purple] r) [green]//from MonochromeLib by PierrotLL[/green]
{
     [purple]int[/purple] i, j, x, tmp;
     j = p - 1;
     x = t[r];
     [b][blue]for[/blue][/b](i=p ; i<r ; i++)
     {
         [b][blue]if[/blue][/b](x > t[i ])
         {
             j++;
             tmp = t[j];
             t[j] = t[i ];
             t[i ] = tmp;
         }
     }
     t[r] = t[j+1];
     t[j+1] = x;
     [b][blue]return[/blue][/b] j + 1;
}

static void Filled_polygon_quicksord(int* t, [purple]int[/purple] p, [purple]int[/purple] r) [green]//from MonochromeLib by PierrotLL[/green]
{
     [purple]int[/purple] q;
     [b][blue]if[/blue][/b](p < r)
     {
         q = Filled_polygon_quicksord_partition(t, p, r);
         Filled_polygon_quicksord(t, p, q-1);
         Filled_polygon_quicksord(t, q+1, r);
     }
}


void Filled_polygon(const [purple]int[/purple] *x, const [purple]int[/purple] *y, [purple]int[/purple] nb_vertices, unsigned short color) [green]//from MonochromeLib by PierrotLL[/green]
{
     [purple]int[/purple] i, j, dx, dy, ymin, ymax;
     [purple]int[/purple] *cut_in_line, nb_cut;
     [b][blue]if[/blue][/b](nb_vertices < 3) [b][blue]return[/blue][/b];
     cut_in_line = malloc(nb_vertices*sizeof(int));
     [b][blue]if[/blue][/b](!cut_in_line) [b][blue]return[/blue][/b];
     ymin = ymax = y[0];
     [b][blue]for[/blue][/b](i=[maroon]1[/maroon] ; i<nb_vertices ; i++)
     {
         [b][blue]if[/blue][/b](y[i ] < ymin) ymin = y[i ];
         [b][blue]if[/blue][/b](y[i ] > ymax) ymax = y[i ];
     }
     [b][blue]for[/blue][/b](i=ymin ; i<=ymax ; i++)
     {
         nb_cut = [maroon]0[/maroon];
         [b][blue]for[/blue][/b](j=[maroon]0[/maroon] ; j<nb_vertices ; j++)
         {
             [b][blue]if[/blue][/b]((y[j]<=i && y[(j+1)%nb_vertices]>=i) || (y[j]>=i && y[(j+1)%nb_vertices]<=i))
             {
                 dy = abs(y[j]-y[(j+1)%nb_vertices]);
                 [b][blue]if[/blue][/b](dy)
                 {
                     dx = x[(j+1)%nb_vertices]-x[j];
                     cut_in_line[nb_cut] = x[j] + [b][green]/*random*/[/green][/b](abs(i-y[j]+sgn(i-y[j])/2)*dx/dy);
                     nb_cut++;
                 }
             }
         }
         Filled_polygon_quicksord(cut_in_line, [maroon]0[/maroon], nb_cut-1);
         j = [maroon]0[/maroon];
         [b][blue]while[/blue][/b](j<nb_cut-2 && cut_in_line[j]==cut_in_line[j+1]) j++;
         [b][blue]while[/blue][/b](j < nb_cut)
         {
             [b][blue]if[/blue][/b](j == nb_cut-1) Horizontal_Line(cut_in_line[j-1]+1, cut_in_line[j], i, color);
             [b][blue]else[/blue][/b]
             {
                 dx = [maroon]1[/maroon];
                 [b][blue]while[/blue][/b](j+dx<nb_cut-1 && cut_in_line[j+dx]==cut_in_line[j+dx+1]) dx++;
                 Horizontal_Line(cut_in_line[j], cut_in_line[j+dx], i, color);
                 j += dx;
             }
             j++;
         }
     }
     free(cut_in_line);
}

[brown]#define abs(a) ((a) < 0 ? -(a) : (a))[/brown]
[brown]#define min(a,b) (((a) < (b))? (a) : (b))[/brown]
[brown]#define max(a,b) (((a) > (b))? (a) : (b))[/brown]
[brown]#define sgn(a) ((a) < 0 ? (-1) : (a) > 0 ? (1) : (a))[/brown]


void Horizontal_Line(int x1, [purple]int[/purple] x2, [purple]int[/purple] y, unsigned short color)
{
     unsigned short* VRAM = GetVRAMAdress();
     [purple]int[/purple] i;
     [purple]int[/purple] xi = max(min(x1,x2),[maroon]0[/maroon]);
     [purple]int[/purple] xf = min(max(x1,x2),LCD_WIDTH_PX);
     [b][blue]if[/blue][/b](y < 0 || y > LCD_HEIGHT_PX) [b][blue]return[/blue][/b];
     [b][blue]for[/blue][/b](i=xi; i <= xf; i++)
     VRAM[LCD_WIDTH_PX*y + i] = color;
}

Afficher du texte
Afficher du texte
void text_printC(int x, [purple]int[/purple] y, [purple]char[/purple] c, [purple]int[/purple] size, [purple]int[/purple] color)
{
    [purple]int[/purple] i, j, byte_width, alpha;
    char* data;
    [b][blue]if[/blue][/b](c<32 || c>127 || size<1) [b][blue]return[/blue][/b];
    byte_width = ((used_font[b]->[/b]width-1)>>3)+1;
    data = used_font[b]->[/b]data + byte_width * used_font[b]->[/b]height * (c-32);
    alpha = [maroon]32[/maroon] - ((color>>16) % 32);
    color &= [maroon]0[/maroon]xFFFF;
    [b][blue]for[/blue][/b](i=[maroon]0[/maroon] ; i<used_font[b]->[/b]height ; i++) {
        [b][blue]for[/blue][/b](j=[maroon]0[/maroon] ; j<used_font[b]->[/b]width ; j++) {
            [b][blue]if[/blue][/b](data[i*byte_width+(j>>3)] & (128>>(j&7)))
                text_drawPoint(x+j*size, y+i*size, size, color, alpha);
            [b][blue]else[/blue][/b] if(used_font[b]->[/b]flags & ANTIALIASING) { [green]// Antialiasing[/green]
                [b][blue]if[/blue][/b](text_readPix(data, j, i-1, used_font[b]->[/b]width, used_font[b]->[/b]height)) {
                    [b][blue]if[/blue][/b](text_readPix(data, j-1, i, used_font[b]->[/b]width, used_font[b]->[/b]height)) text_antialias(x+j*size, y+i*size, size, color, alpha, [maroon]0[/maroon]);
                    [b][blue]if[/blue][/b](text_readPix(data, j+1, i, used_font[b]->[/b]width, used_font[b]->[/b]height)) text_antialias(x+j*size, y+i*size, size, color, alpha, [maroon]1[/maroon]);
                }
                [b][blue]if[/blue][/b](text_readPix(data, j, i+1, used_font[b]->[/b]width, used_font[b]->[/b]height)) {
                    [b][blue]if[/blue][/b](text_readPix(data, j-1, i, used_font[b]->[/b]width, used_font[b]->[/b]height)) text_antialias(x+j*size, y+i*size, size, color, alpha, [maroon]2[/maroon]);
                    [b][blue]if[/blue][/b](text_readPix(data, j+1, i, used_font[b]->[/b]width, used_font[b]->[/b]height)) text_antialias(x+j*size, y+i*size, size, color, alpha, [maroon]3[/maroon]);
                }
            }
        }
    }
}

void text_print(int x, [purple]int[/purple] y, char* c, [purple]int[/purple] size, [purple]int[/purple] color)
{
    [purple]int[/purple] save_x = x;
    [b][blue]for[/blue][/b]( ; *c ; c++) {
        [b][blue]if[/blue][/b](*c == [gray]'\n'[/gray]) {
            x = save_x;
            y += (used_font[b]->[/b]height + used_font[b]->[/b]height/2) * size;
        } [b][blue]else[/blue][/b] {
            text_printC(x, y, *c, size, color);
            x += size * text_widthC(*c);
        }
    }
}

Affiche un sprite
Affiche un sprite
void CopySpriteNbitMasked(const unsigned char* data, int x, int y, int width, int height, const short* palette, short maskColor, unsigned int bitwidth)
{
    short* VRAM = (short*)0xA8000000; //ou  color_t* VRAM = (color_t*) GetVRAMAddress();
    int offset = 0;
    int availbits ;
    int j,i;
    unsigned char buf;
    short thiss;
    short color;

    VRAM += (128*3*y + x);
    for(j=y; j<y+height; j++)
    {
        availbits = 0;

        for(i=x; i<x+width;  i++)
        {
            if (!availbits)
            {
                buf = data[offset++];
                availbits = 8;
            }
            thiss = ((short)buf>>(8-bitwidth));
            color = palette[thiss];
            if(color != maskColor && i >= 0 && i<384)
            {
                *VRAM = color;
            }
            VRAM++;
            buf<=bitwidth;
            availbits-=bitwidth;
        }
        VRAM += (128*3-width);
    }
}

Affiche un sprite (en 16 bit)
Affiche un sprite (en 16 bit)
void CopySpriteMasked(short* bitmap, int x, int y, int width, int height, short mask)
{
    short* VRAM = (short*)0xA8000000;

    int y_index;
    int x_index;
    short * base = y * 128*3 + x + VRAM;
    for (y_index = height; y_index > 0; --y_index, base += 128*3 - width) {
        for (x_index = width; x_index > 0; --x_index, ++base, ++bitmap) {
            if (*bitmap != mask) *base = *bitmap;
        }
    }
}

Affiche un sprite 16 bit avec de la transparence
Affiche un sprite 16 bit avec de la transparence
void alphaSprite(int x, int y, int width, int height, short* bitmap, short alpha)
{
    short* VRAM = (short*)0xA8000000;
    int x_inc = width;
    if (y < 0)
    {
        bitmap -= y * width;
        height += y;
        y = 0;
    }
    if (height > 216 - y) height = 216 - y;

    if (x < 0)
    {
        bitmap -= x;
        width += x;
        x = 0;
    }
    if (width > 128*3 - x) width = 128*3 - x;

    x_inc -= width;

    int y_index;
    int x_index;
    short * base = y * 128*3 + x + VRAM;
    for (y_index = height; y_index > 0; y_index--, base += 128*3 - width, bitmap += x_inc)
    {
        for (x_index = width; x_index > 0; x_index--, base++ , bitmap++ )
        {
            if (*bitmap!=alpha && *bitmap!= 0xffff) *base = *bitmap;
        }
    }
}

Afficher des sprites avec de la transparence
Afficher des sprites avec de la transparence
void CopySpriteNbitMaskedAlpha(const unsigned char* data, [purple]int[/purple] x, [purple]int[/purple] y, [purple]int[/purple] width, [purple]int[/purple] height, const color_t* palette, color_t maskColor, [purple]unsigned int[/purple] bitwidth,int alpha)
{
    color_t* VRAM = (color_t*) GetVRAMAdress();
    VRAM += (LCD_WIDTH_PX*y + x);
    alpha %= [maroon]32[/maroon];
    [purple]int[/purple] i,j;
    [purple]int[/purple] offset = [maroon]0[/maroon];
    [purple]unsigned char[/purple] buf=[maroon]0[/maroon];
    [b][blue]for[/blue][/b](j=y; j<y+height; j++)
    {
       [purple]int[/purple] availbits = [maroon]0[/maroon];
       [b][blue]for[/blue][/b](i=x; i<x+width;  i++)
       {
          [b][blue]if[/blue][/b] (!availbits)
          {
             buf = data[offset++];
             availbits = [maroon]8[/maroon];
          }
          color_t thiss = ((color_t)buf>>(8-bitwidth));
          color_t color = palette[thiss];
          [b][blue]if[/blue][/b](color != maskColor&& i >=[maroon]0[/maroon] && i<384)
             *VRAM = ((((color & 0xF81F) * alpha + (*VRAM & 0xF81F) * (32-alpha)) >> 5) & 0xF81F) |
             ((((color & 0x07E0) * alpha + (*VRAM & 0x07E0) * (32-alpha)) >> 5) & 0x07E0);
          VRAM++;
          buf<<=bitwidth;
          availbits-=bitwidth;
       }
       VRAM += (LCD_WIDTH_PX-width);
    }
}



Transforme un entier en une chaîne de caractères
Transforme un entier en une chaîne de caractères
char* int2str(char* c, [purple]int[/purple] n)
{
    [b][blue]if[/blue][/b](n==[maroon]0[/maroon])
    {
        c[0] = [gray]'0'[/gray];
        c[1] = [maroon]0[/maroon];
    }
    [b][blue]else[/blue][/b]
    {
        [purple]int[/purple] i, l=[maroon]0[/maroon];
        [b][blue]for[/blue][/b](i=n ; i ; i/=[maroon]10[/maroon])
            l++;
        c[l] = [maroon]0[/maroon];
        [b][blue]for[/blue][/b](i=n ; i ; i/=[maroon]10[/maroon])
            c[--l] = i%10+[gray]'0'[/gray];
    }
    [b][blue]return[/blue][/b] c;
}

Abs
Abs
unsigned [purple]int[/purple] abs(int i){
      [b][blue]return[/blue][/b] (i<0?-i:i);
}

Nombre au hasard
Chiffre au hasard
unsigned [purple]int[/purple] random(int seed, [purple]int[/purple] value) [green]// Function from Simon Lothar[/green]
{
    static [purple]unsigned int[/purple] lastrandom = [maroon]0[/maroon]x12345678;
    [b][blue]if[/blue][/b](seed) lastrandom = seed;
    lastrandom = (0x41C64E6D * lastrandom) + 0x3039;
    [b][blue]return[/blue][/b] ((lastrandom >> 16) % value);
}

Réglage des fps
Réglage des fps
void setFps(int fpsWish) [green]//1 pour 128, [maroon]2[/maroon] pour 64, [maroon]3[/maroon] pour 42, [maroon]128[/maroon]/fpsWish en fait[/green]
{
     static [purple]unsigned int[/purple] fps = [maroon]0[/maroon], fps_count = [maroon]0[/maroon];

     [b][blue]do[/blue][/b]
     {
         fps = RTC_GetTicks();
     }
     [b][blue]while[/blue][/b](fps < fps_count+fpsWish);
     fps_count = RTC_GetTicks();
}




N'hésitez pas à exposez ici vos plus belles découvertes !


ColorLib regroupe toutes ses fonctions




Pages : Précédente1, 2, 3, 4, 5Suivante
LancelotHors ligneMembrePoints: 1274 Défis: 160 Message

Citer : Posté le 06/10/2013 15:58 | #


C'est sur quoi je travaille .Ce sera la fxCG20LIb mais je peut changer le mon peut-être si il y a d'autres bonnes propositions.

Ajouté le 06/10/2013 à 16:04 :
Et voici pour l'instant à quoi cela ressemble pour l'instant je reprend les fonctions postées sur PC. Mais je rajouterai surement des fonctions plus personnelles.

fx-CG20Lib
fx-CG20Lib
le .c
[b][green]/*************************************************************/
/** fxCG20Lib - Color graphic library [b][blue]for[/blue][/b] fx-CG20 - fx-CG10 **/
/** fxCG20Libis a free software                             **/
/**                                                         **/
/** @author Lancelot                                        **/
/**                                                         **/
/** @file fxCG20Lib.c                                       **/
/** Code file of fxCG20Lib                                  **/
/**                                                         **/
/** @date 10-06-2013                                        **/
/*************************************************************/

[brown]#include [gray]"fxCG20Lib.h"[/gray][/brown]
[brown]#include <display_syscalls.h>[/brown]

/******************************/
/** Dependencies management  **/
/******************************/

[brown]#ifdef CGL_ALL[/brown]
    
    [brown]#define _KEY[/brown]
    [brown]#define POINT[/brown]
    [brown]#define LINE[/brown]
    [brown]#define RANDOM[/brown]
    [brown]#define ABS[/brown]
    [brown]#define CIRCLE[/brown]
    
    [brown]#endif[/brown]


/***********************/
/****   Functions   ****/
/***********************/

[brown]#ifdef _KEY[/brown]

[purple]int[/purple] key_down(int basic_keycode);

/***************/
/** Key codes **/
/***************/[/green][/b]

[brown]#define K_F1    79[/brown]
[brown]#define K_F2    69[/brown]
[brown]#define K_F3    59[/brown]
[brown]#define K_F4    49[/brown]
[brown]#define K_F5    39[/brown]
[brown]#define K_F6    29[/brown]

[brown]#define K_SHIFT 78[/brown]
[brown]#define K_OPTN  68[/brown]
[brown]#define K_VARS  58[/brown]
[brown]#define K_MENU  48[/brown]
[brown]#define K_LEFT  38[/brown]
[brown]#define K_UP    28[/brown]

[brown]#define K_ALPHA 77[/brown]
[brown]#define K_SQR   67[/brown]
[brown]#define K_EXPO  57[/brown]
[brown]#define K_EXIT  47[/brown]
[brown]#define K_DOWN  37[/brown]
[brown]#define K_RIGHT 27[/brown]

[brown]#define K_THETA 76[/brown]
[brown]#define K_LOG   66[/brown]
[brown]#define K_LN    56[/brown]
[brown]#define K_SIN   46[/brown]
[brown]#define K_COS   36[/brown]
[brown]#define K_TAN   26[/brown]

[brown]#define K_FRAC  75[/brown]
[brown]#define K_FD    65[/brown]
[brown]#define K_LPAR  55[/brown]
[brown]#define K_RPAR  45[/brown]
[brown]#define K_COMMA 35[/brown]
[brown]#define K_STORE 25[/brown]

[brown]#define K_7     74[/brown]
[brown]#define K_8     64[/brown]
[brown]#define K_9     54[/brown]
[brown]#define K_DEL   34[/brown]

[brown]#define K_4     73[/brown]
[brown]#define K_5     63[/brown]
[brown]#define K_6     53[/brown]
[brown]#define K_MULT  43[/brown]
[brown]#define K_DIV   33[/brown]

[brown]#define K_1     72[/brown]
[brown]#define K_2     62[/brown]
[brown]#define K_3     52[/brown]
[brown]#define K_PLUS  42[/brown]
[brown]#define K_MINUS 32[/brown]

[brown]#define K_0     71[/brown]
[brown]#define K_DOT   61[/brown]
[brown]#define K_EXP   51[/brown]
[brown]#define K_NEG   41[/brown]
[brown]#define K_EXE   31[/brown]

[brown]#define K_AC    10[/brown]


[purple]int[/purple] keydown(int basic_keycode)
{
     const unsigned short* keyboard_register = (unsigned short*)0xA44B0000;
     [purple]int[/purple] row, col, word, bit;
     row = basic_keycode%10;
     col = basic_keycode/10-1;
     word = row>>1;
     bit = col + 8*(row&1);
     [b][blue]return[/blue][/b] (0 != (keyboard_register[word] & 1<<bit));
}


[brown]#endif [green]//_KEY[/brown][/green]

[brown]#ifdef LINE[/brown]

void line(int x1, [purple]int[/purple] y1, [purple]int[/purple] x2, [purple]int[/purple] y2, short color)
{
    [purple]int[/purple] i, x, y, dx, dy, sx, sy, cumul;
    x = x1;
    y = y1;
    dx = x2 - x1;
    dy = y2 - y1;
    sx = sgn(dx);
    sy = sgn(dy);
    dx = abs(dx);
    dy = abs(dy);
    Bdisp_SetPoint_VRAM( x,  y,(int)  color );
    [b][blue]if[/blue][/b](dx > dy)
    {
        cumul = dx / 2;
        [b][blue]for[/blue][/b](i=[maroon]1[/maroon] ; i<dx ; i++)
        {
            x += sx;
            cumul += dy;
            [b][blue]if[/blue][/b](cumul > dx)
            {
                cumul -= dx;
                y += sy;
            }
            Bdisp_SetPoint_VRAM( x, y,(int)  color );
        }
    }
    [b][blue]else[/blue][/b]
    {
        cumul = dy / 2;
        [b][blue]for[/blue][/b](i=[maroon]1[/maroon] ; i<dy ; i++)
        {
            y += sy;
            cumul += dx;
            [b][blue]if[/blue][/b](cumul > dy)
            {
                cumul -= dy;
                x += sx;
            }
            Bdisp_SetPoint_VRAM(x, y,(int) color);
        }
    }
}

[brown]#endif [green]//LINE[/brown][/green]

[brown]#ifdef POINT[/brown]

void point(int x, [purple]int[/purple] y, [purple]int[/purple] color)
{
     char* VRAM = (char*)0xA8000000;
     VRAM += [maroon]2[/maroon]*(y*LCD_WIDTH_PX + x);
     *(VRAM++) = (color&0x0000FF00)>>8;
     *(VRAM++) = (color&0x000000FF);
     [b][blue]return[/blue][/b];
}

[brown]#endif [green]//POINT[/brown][/green]

[brown]#ifdef RANDOM[/brown]

[purple]unsigned int[/purple] random(int seed, [purple]int[/purple] value) [green]// Function from Simon Lothar[/green]
{
    static [purple]unsigned int[/purple] lastrandom = [maroon]0[/maroon]x12345678;
    [b][blue]if[/blue][/b](seed) lastrandom = seed;
    lastrandom = (0x41C64E6D * lastrandom) + 0x3039;
    [b][blue]return[/blue][/b] ((lastrandom >> 16) % value);
}

[brown]#endif [green]// RANDOM[/brown][/green]

[brown]#ifdef ABS[/brown]

[purple]int[/purple] abs (int nombre)
{
    [b][blue]if[/blue][/b](nombre < 0)return -nombre;
    [b][blue]return[/blue][/b] nombre;
}

[brown]#endif [green]// ABS[/brown][/green]

[brown]#ifdef CIRCLE[/brown]

void drawCircle(int x0, [purple]int[/purple] y0, [purple]int[/purple] rayon, [purple]int[/purple] couleur)
{
    [purple]int[/purple] er = [maroon]1[/maroon] - rayon;
    [purple]int[/purple] erY = [maroon]1[/maroon];
    [purple]int[/purple] erX = -2 * rayon;
    [purple]int[/purple] x = rayon, y = [maroon]0[/maroon];

    point(x0, y0 + rayon, couleur);
    point(x0, y0 - rayon, couleur);
    point(x0 + rayon, y0, couleur);
    point(x0 - rayon, y0, couleur);

    [b][blue]while[/blue][/b](y < x)
    {
      [b][blue]if[/blue][/b](er > 0)
      {
        x--;
        erX += [maroon]2[/maroon];
        er += erX;
      }
      y++;
      erY += [maroon]2[/maroon];
      er += erY;    
      point(x0 + x, y0 + y, couleur);
      point(x0 - x, y0 + y, couleur);
      point(x0 + x, y0 - y, couleur);
      point(x0 - x, y0 - y, couleur);
      point(x0 + y, y0 + x, couleur);
      point(x0 - y, y0 + x, couleur);
      point(x0 + y, y0 - x, couleur);
      point(x0 - y, y0 - x, couleur);
    }
}

[brown]#endif [green]// CIRCLE[/brown][/green]

Le .h
/*************************************************************/
/** fxCG20Lib - Color graphic library for fx-CG20 - fx-CG10 **/
/** fxCG20Libis a free software                             **/
/**                                                         **/
/** @author Lancelot                                        **/
/**                                                         **/
/** @file fxCG20Lib.h                                       **/
/** Include header for fxCG20Lib                            **/
/**                                                         **/
/** @date 10-06-2013                                        **/
/*************************************************************/

#ifndef fXCG20LIB
#define fXCG20LIB

/****************************************************/
/** uncomment #define of functions you want to use **/
/****************************************************/

// #define CGL_ALL //Auto define all functions

// #define _KEY
// #define LINE
// #define POINT
// #define RANDOM
// #define ABS
// #define CIRCLE

#endif // fXCG20LIB



M'hésiter pas à me signaler les erreurs commises et de possibles améliorations. Mais après il faudrai tester le fonctionnement.

De l'aide sera toujours la bien venue.
Calculatrices : Casio 35+ SH4 (modifiée 75) et fx-CG 20 PRIZM
Projets que je soutiens
Des exemples parmi tant d'autres
Pokémon Jade de Dododormeur
Zelda de Smashmaster
Super Geek Brothers de Siapran
Mes Programmes
Mes Programmes
Mes Projets
Mes Projets
ColorLib
Add-ins Jetpack Joyride et Pac-Man sur PRIZM (les 2 non commencés mais en réflexion)
A la recherche des sprites jetpack Joride si quelqu'un les a en couleur
AlphacreatorHors ligneMembrePoints: 1464 Défis: 43 Message

Citer : Posté le 06/10/2013 16:34 | #


Une question, la fonction pour générer un nombre aléatoirement fonctionne-t-il pour les graphs monochromes? (graph 75 SH4 en particulier)
DodormeurHors ligneAncien rédacteurPoints: 3928 Défis: 82 Message

Citer : Posté le 06/10/2013 16:35 | #


par contre, la fonction point devrait s'appeler pixel (un point peut avoir une taille definie (comme un carré), tandis qu'un pixel fait ... un pixel)
Pokemon !!!!!! => pokemon stadium/battle

mes meilleurs jeux
Cliquer pour enrouler
un jeu avec des niveaux de gris mais compatible SH4 (mais en monochrome pour les SH4) => bomberman
envie de plonger dans la mer pour ramasser des tresors? => ballon sea
envie de sauver l'univers dans un jeu avec une longue durée de vie? => saviors of the future
un add-in addictif avec plein de secret et de trophées => evasion survival
un shmup bien dur et sadique => saviors 2

projets
Cliquer pour enrouler

pokemon
Cliquer pour enrouler



encodage des données de combat (sprite, attaques et nom)
   100%

systeme de combat
   100%

encodage des données de pokemon (niveau d'apprentisage et evolution)
   100%


moteur de la carte
   50%

level design
   1%

finition de pokemon jade
   42%

merci a tout le monde pour son soutien


projets que je soutiens
Cliquer pour enrouler
minecraft de limachi
zelda prizm de smashmaster (en esperant qu'il puisse le finir)
les tests de marmotti
un RPG de dark storm (dont je connais le nom, mais pas vous ) Arcuz !
LancelotHors ligneMembrePoints: 1274 Défis: 160 Message

Citer : Posté le 06/10/2013 16:39 | #


@ Dodormeur : Corrigé

Voici la version avec toutes les fonctions de ce topic jusqu'à aujourd'hui.

Le .c
Le .c
[green]/*************************************************************/
/** fxCG20Lib - Color graphic library for fx-CG20 - fx-CG10 **/
/** fxCG20Libis a free software                             **/
/**                                                         **/
/** @author Lancelot                                        **/
/**                                                         **/
/** @file fxCG20Lib.c                                       **/
/** Code file of fxCG20Lib                                  **/
/**                                                         **/
/** @date 10-06-2013                                        **/
/*************************************************************/[/green]

[brown]#include [gray]"fxCG20Lib.h"[/gray][/brown]
[brown]#include <display_syscalls.h>[/brown]

/******************************/
/** Dependencies management  **/
/******************************/

[brown]#ifdef CGL_ALL[/brown]
    
    [brown]#define KEY[/brown]
    [brown]#define PIXEL[/brown]
    [brown]#define LINE[/brown]
    [brown]#define RANDOM[/brown]
    [brown]#define ABS[/brown]
    [brown]#define CIRCLE[/brown]
    [brown]#define TEXT[/brown]
    [brown]#define ALPHASPRITE[/brown]
    [brown]#define SPRITE16[/brown]
    [brown]#define SPRITE[/brown]
    [brown]#define INT2STR[/brown]
    [brown]#define FPS[/brown]
    
    [brown]#endif[/brown]


/***********************/
/****   Functions   ****/
/***********************/

[brown]#ifdef KEY[/brown]

[purple]int[/purple] key_down(int basic_keycode);

/***************/
/** Key codes **/
/***************/

[brown]#define K_F1    79[/brown]
[brown]#define K_F2    69[/brown]
[brown]#define K_F3    59[/brown]
[brown]#define K_F4    49[/brown]
[brown]#define K_F5    39[/brown]
[brown]#define K_F6    29[/brown]

[brown]#define K_SHIFT 78[/brown]
[brown]#define K_OPTN  68[/brown]
[brown]#define K_VARS  58[/brown]
[brown]#define K_MENU  48[/brown]
[brown]#define K_LEFT  38[/brown]
[brown]#define K_UP    28[/brown]

[brown]#define K_ALPHA 77[/brown]
[brown]#define K_SQR   67[/brown]
[brown]#define K_EXPO  57[/brown]
[brown]#define K_EXIT  47[/brown]
[brown]#define K_DOWN  37[/brown]
[brown]#define K_RIGHT 27[/brown]

[brown]#define K_THETA 76[/brown]
[brown]#define K_LOG   66[/brown]
[brown]#define K_LN    56[/brown]
[brown]#define K_SIN   46[/brown]
[brown]#define K_COS   36[/brown]
[brown]#define K_TAN   26[/brown]

[brown]#define K_FRAC  75[/brown]
[brown]#define K_FD    65[/brown]
[brown]#define K_LPAR  55[/brown]
[brown]#define K_RPAR  45[/brown]
[brown]#define K_COMMA 35[/brown]
[brown]#define K_STORE 25[/brown]

[brown]#define K_7     74[/brown]
[brown]#define K_8     64[/brown]
[brown]#define K_9     54[/brown]
[brown]#define K_DEL   34[/brown]

[brown]#define K_4     73[/brown]
[brown]#define K_5     63[/brown]
[brown]#define K_6     53[/brown]
[brown]#define K_MULT  43[/brown]
[brown]#define K_DIV   33[/brown]

[brown]#define K_1     72[/brown]
[brown]#define K_2     62[/brown]
[brown]#define K_3     52[/brown]
[brown]#define K_PLUS  42[/brown]
[brown]#define K_MINUS 32[/brown]

[brown]#define K_0     71[/brown]
[brown]#define K_DOT   61[/brown]
[brown]#define K_EXP   51[/brown]
[brown]#define K_NEG   41[/brown]
[brown]#define K_EXE   31[/brown]

[brown]#define K_AC    10[/brown]


[purple]int[/purple] keydown(int basic_keycode)
{
     const unsigned short* keyboard_register = (unsigned short*)0xA44B0000;
     [purple]int[/purple] row, col, word, bit;
     row = basic_keycode%10;
     col = basic_keycode/10-1;
     word = row>>1;
     bit = col + 8*(row&1);
     [b][blue]return[/blue][/b] (0 != (keyboard_register[word] & 1<<bit));
}


[brown]#endif [green]//KEY[/brown][/green]

[brown]#ifdef LINE[/brown]

void line(int x1, [purple]int[/purple] y1, [purple]int[/purple] x2, [purple]int[/purple] y2, short color)
{
    [purple]int[/purple] i, x, y, dx, dy, sx, sy, cumul;
    x = x1;
    y = y1;
    dx = x2 - x1;
    dy = y2 - y1;
    sx = sgn(dx);
    sy = sgn(dy);
    dx = abs(dx);
    dy = abs(dy);
    Bdisp_SetPoint_VRAM( x,  y,(int)  color );
    [b][blue]if[/blue][/b](dx > dy)
    {
        cumul = dx / 2;
        [b][blue]for[/blue][/b](i=[maroon]1[/maroon] ; i<dx ; i++)
        {
            x += sx;
            cumul += dy;
            [b][blue]if[/blue][/b](cumul > dx)
            {
                cumul -= dx;
                y += sy;
            }
            Bdisp_SetPoint_VRAM( x, y,(int)  color );
        }
    }
    [b][blue]else[/blue][/b]
    {
        cumul = dy / 2;
        [b][blue]for[/blue][/b](i=[maroon]1[/maroon] ; i<dy ; i++)
        {
            y += sy;
            cumul += dx;
            [b][blue]if[/blue][/b](cumul > dy)
            {
                cumul -= dy;
                x += sx;
            }
            Bdisp_SetPoint_VRAM(x, y,(int) color);
        }
    }
}

[brown]#endif [green]//LINE[/brown][/green]

[brown]#ifdef PIXEL[/brown]

void point(int x, [purple]int[/purple] y, [purple]int[/purple] color)
{
     char* VRAM = (char*)0xA8000000;
     VRAM += [maroon]2[/maroon]*(y*LCD_WIDTH_PX + x);
     *(VRAM++) = (color&0x0000FF00)>>8;
     *(VRAM++) = (color&0x000000FF);
     [b][blue]return[/blue][/b];
}

[brown]#endif [green]//PIXEL[/brown][/green]

[brown]#ifdef RANDOM[/brown]

[purple]unsigned int[/purple] random(int seed, [purple]int[/purple] value) [green]// Function from Simon Lothar[/green]
{
    static [purple]unsigned int[/purple] lastrandom = [maroon]0[/maroon]x12345678;
    [b][blue]if[/blue][/b](seed) lastrandom = seed;
    lastrandom = (0x41C64E6D * lastrandom) + 0x3039;
    [b][blue]return[/blue][/b] ((lastrandom >> 16) % value);
}

[brown]#endif [green]// RANDOM[/brown][/green]

[brown]#ifdef ABS[/brown]

[purple]int[/purple] abs (int nombre)
{
    [b][blue]if[/blue][/b](nombre < 0)return -nombre;
    [b][blue]return[/blue][/b] nombre;
}

[brown]#endif [green]// ABS[/brown][/green]

[brown]#ifdef CIRCLE[/brown]

void drawCircle(int x0, [purple]int[/purple] y0, [purple]int[/purple] rayon, [purple]int[/purple] couleur)
{
    [purple]int[/purple] er = [maroon]1[/maroon] - rayon;
    [purple]int[/purple] erY = [maroon]1[/maroon];
    [purple]int[/purple] erX = -2 * rayon;
    [purple]int[/purple] x = rayon, y = [maroon]0[/maroon];

    point(x0, y0 + rayon, couleur);
    point(x0, y0 - rayon, couleur);
    point(x0 + rayon, y0, couleur);
    point(x0 - rayon, y0, couleur);

    [b][blue]while[/blue][/b](y < x)
    {
      [b][blue]if[/blue][/b](er > 0)
      {
        x--;
        erX += [maroon]2[/maroon];
        er += erX;
      }
      y++;
      erY += [maroon]2[/maroon];
      er += erY;    
      point(x0 + x, y0 + y, couleur);
      point(x0 - x, y0 + y, couleur);
      point(x0 + x, y0 - y, couleur);
      point(x0 - x, y0 - y, couleur);
      point(x0 + y, y0 + x, couleur);
      point(x0 - y, y0 + x, couleur);
      point(x0 + y, y0 - x, couleur);
      point(x0 - y, y0 - x, couleur);
    }
}

[brown]#endif [green]// CIRCLE[/brown][/green]

[brown]#ifdef TEXT[/brown]


typedef [purple]struct[/purple] {
    char* data;
    [purple]int[/purple] width, height, flags;
} Font;

[green]// Flags :[/green]
[brown]#define MONOSPACE    0x00000001[/brown]
[brown]#define ANTIALIASING 0x00000002[/brown]

const static [purple]char[/purple] default_data[] = {
    0,[maroon]0[/maroon],[maroon]0[/maroon],[maroon]0[/maroon],[maroon]0[/maroon],           [green]// [gray]' '[/gray][/green]
    128,[maroon]128[/maroon],[maroon]128[/maroon],[maroon]0[/maroon],[maroon]128[/maroon],   [green]// [gray]'!'[/gray][/green]
    160,[maroon]160[/maroon],[maroon]0[/maroon],[maroon]0[/maroon],[maroon]0[/maroon],       [green]// [gray]'"'[/gray][/green]
    80,[maroon]248[/maroon],[maroon]80[/maroon],[maroon]248[/maroon],[maroon]80[/maroon],    [green]// [gray]'[brown]#'[/gray][/brown][/green]
    64,[maroon]224[/maroon],[maroon]64[/maroon],[maroon]224[/maroon],[maroon]64[/maroon],    [green]// [gray]'$'[/gray][/green]
    200,[maroon]208[/maroon],[maroon]32[/maroon],[maroon]88[/maroon],[maroon]152[/maroon],   [green]// [gray]'%'[/gray][/green]
    0,[maroon]96[/maroon],[maroon]64[/maroon],[maroon]144[/maroon],[maroon]96[/maroon],      [green]// [gray]'&'[/gray][/green]
    128,[maroon]128[/maroon],[maroon]0[/maroon],[maroon]0[/maroon],[maroon]0[/maroon],       [green]// [gray]'''[/gray][/green]
    64,[maroon]128[/maroon],[maroon]128[/maroon],[maroon]128[/maroon],[maroon]64[/maroon],   [green]// [gray]'('[/gray][/green]
    128,[maroon]64[/maroon],[maroon]64[/maroon],[maroon]64[/maroon],[maroon]128[/maroon],    [green]// [gray]')'[/gray][/green]
    64,[maroon]224[/maroon],[maroon]64[/maroon],[maroon]160[/maroon],[maroon]0[/maroon],     [green]// [gray]'*'[/gray][/green]
    32,[maroon]32[/maroon],[maroon]248[/maroon],[maroon]32[/maroon],[maroon]32[/maroon],     [green]// [gray]'+'[/gray][/green]
    0,[maroon]0[/maroon],[maroon]0[/maroon],[maroon]128[/maroon],[maroon]128[/maroon],       [green]// [gray]','[/gray][/green]
    0,[maroon]0[/maroon],[maroon]248[/maroon],[maroon]0[/maroon],[maroon]0[/maroon],         [green]// [gray]'-'[/gray][/green]
    0,[maroon]0[/maroon],[maroon]0[/maroon],[maroon]0[/maroon],[maroon]128[/maroon],       [green]// [gray]'.'[/gray][/green]
    8,[maroon]16[/maroon],[maroon]32[/maroon],[maroon]64[/maroon],[maroon]128[/maroon],      [green]// [gray]'/'[/gray][/green]
    248,[maroon]136[/maroon],[maroon]136[/maroon],[maroon]136[/maroon],[maroon]248[/maroon], [green]// [gray]'0'[/gray][/green]
    192,[maroon]64[/maroon],[maroon]64[/maroon],[maroon]64[/maroon],[maroon]64[/maroon],     [green]// [gray]'1'[/gray][/green]
    240,[maroon]16[/maroon],[maroon]240[/maroon],[maroon]128[/maroon],[maroon]240[/maroon],  [green]// [gray]'2'[/gray][/green]
    240,[maroon]16[/maroon],[maroon]112[/maroon],[maroon]16[/maroon],[maroon]240[/maroon],   [green]// [gray]'3'[/gray][/green]
    128,[maroon]136[/maroon],[maroon]136[/maroon],[maroon]248[/maroon],[maroon]8[/maroon],   [green]// [gray]'4'[/gray][/green]
    248,[maroon]128[/maroon],[maroon]248[/maroon],[maroon]8[/maroon],[maroon]248[/maroon],   [green]// [gray]'5'[/gray][/green]
    248,[maroon]128[/maroon],[maroon]248[/maroon],[maroon]136[/maroon],[maroon]248[/maroon], [green]// [gray]'6'[/gray][/green]
    248,[maroon]8[/maroon],[maroon]8[/maroon],[maroon]8[/maroon],[maroon]8[/maroon],         [green]// [gray]'7'[/gray][/green]
    248,[maroon]136[/maroon],[maroon]248[/maroon],[maroon]136[/maroon],[maroon]248[/maroon], [green]// [gray]'8'[/gray][/green]
    248,[maroon]136[/maroon],[maroon]248[/maroon],[maroon]8[/maroon],[maroon]248[/maroon],   [green]// [gray]'9'[/gray][/green]
    0,[maroon]0[/maroon],[maroon]128[/maroon],[maroon]0[/maroon],[maroon]128[/maroon],       [green]// [gray]':'[/gray][/green]
    0,[maroon]128[/maroon],[maroon]0[/maroon],[maroon]128[/maroon],[maroon]128[/maroon],     [green]// [gray]';'[/gray][/green]
    32,[maroon]64[/maroon],[maroon]128[/maroon],[maroon]64[/maroon],[maroon]32[/maroon],     [green]// [gray]'<'[/gray][/green]
    0,[maroon]248[/maroon],[maroon]0[/maroon],[maroon]248[/maroon],[maroon]0[/maroon],       [green]// [gray]'='[/gray][/green]
    128,[maroon]64[/maroon],[maroon]32[/maroon],[maroon]64[/maroon],[maroon]128[/maroon],    [green]// [gray]'>'[/gray][/green]
    224,[maroon]16[/maroon],[maroon]96[/maroon],[maroon]0[/maroon],[maroon]64[/maroon],      [green]// [gray]'?'[/gray][/green]
    248,[maroon]136[/maroon],[maroon]184[/maroon],[maroon]168[/maroon],[maroon]184[/maroon], [green]// [gray]'@'[/gray][/green]
    248,[maroon]136[/maroon],[maroon]248[/maroon],[maroon]136[/maroon],[maroon]136[/maroon], [green]// [gray]'A'[/gray][/green]
    240,[maroon]136[/maroon],[maroon]248[/maroon],[maroon]136[/maroon],[maroon]240[/maroon], [green]// [gray]'B'[/gray][/green]
    248,[maroon]128[/maroon],[maroon]128[/maroon],[maroon]128[/maroon],[maroon]248[/maroon], [green]// [gray]'C'[/gray][/green]
    240,[maroon]136[/maroon],[maroon]136[/maroon],[maroon]136[/maroon],[maroon]240[/maroon], [green]// [gray]'D'[/gray][/green]
    248,[maroon]128[/maroon],[maroon]240[/maroon],[maroon]128[/maroon],[maroon]248[/maroon], [green]// [gray]'E'[/gray][/green]
    248,[maroon]128[/maroon],[maroon]240[/maroon],[maroon]128[/maroon],[maroon]128[/maroon], [green]// [gray]'F'[/gray][/green]
    120,[maroon]128[/maroon],[maroon]184[/maroon],[maroon]136[/maroon],[maroon]120[/maroon], [green]// [gray]'G'[/gray][/green]
    136,[maroon]136[/maroon],[maroon]248[/maroon],[maroon]136[/maroon],[maroon]136[/maroon], [green]// [gray]'H'[/gray][/green]
    128,[maroon]128[/maroon],[maroon]128[/maroon],[maroon]128[/maroon],[maroon]128[/maroon], [green]// [gray]'I'[/gray][/green]
    16,[maroon]16[/maroon],[maroon]16[/maroon],[maroon]144[/maroon],[maroon]96[/maroon],     [green]// [gray]'J'[/gray][/green]
    136,[maroon]144[/maroon],[maroon]224[/maroon],[maroon]144[/maroon],[maroon]136[/maroon], [green]// [gray]'K'[/gray][/green]
    128,[maroon]128[/maroon],[maroon]128[/maroon],[maroon]128[/maroon],[maroon]248[/maroon], [green]// [gray]'L'[/gray][/green]
    136,[maroon]216[/maroon],[maroon]168[/maroon],[maroon]136[/maroon],[maroon]136[/maroon], [green]// [gray]'M'[/gray][/green]
    248,[maroon]136[/maroon],[maroon]136[/maroon],[maroon]136[/maroon],[maroon]136[/maroon], [green]// [gray]'N'[/gray][/green]
    248,[maroon]136[/maroon],[maroon]136[/maroon],[maroon]136[/maroon],[maroon]248[/maroon], [green]// [gray]'O'[/gray][/green]
    248,[maroon]136[/maroon],[maroon]248[/maroon],[maroon]128[/maroon],[maroon]128[/maroon], [green]// [gray]'P'[/gray][/green]
    112,[maroon]136[/maroon],[maroon]136[/maroon],[maroon]152[/maroon],[maroon]120[/maroon], [green]// [gray]'Q'[/gray][/green]
    248,[maroon]136[/maroon],[maroon]248[/maroon],[maroon]144[/maroon],[maroon]136[/maroon], [green]// [gray]'R'[/gray][/green]
    248,[maroon]128[/maroon],[maroon]248[/maroon],[maroon]8[/maroon],[maroon]248[/maroon],   [green]// [gray]'S'[/gray][/green]
    248,[maroon]32[/maroon],[maroon]32[/maroon],[maroon]32[/maroon],[maroon]32[/maroon],     [green]// [gray]'T'[/gray][/green]
    136,[maroon]136[/maroon],[maroon]136[/maroon],[maroon]136[/maroon],[maroon]248[/maroon], [green]// [gray]'U'[/gray][/green]
    136,[maroon]136[/maroon],[maroon]80[/maroon],[maroon]80[/maroon],[maroon]32[/maroon],    [green]// [gray]'V'[/gray][/green]
    168,[maroon]168[/maroon],[maroon]168[/maroon],[maroon]168[/maroon],[maroon]248[/maroon], [green]// [gray]'W'[/gray][/green]
    136,[maroon]80[/maroon],[maroon]32[/maroon],[maroon]80[/maroon],[maroon]136[/maroon],    [green]// [gray]'X'[/gray][/green]
    136,[maroon]80[/maroon],[maroon]32[/maroon],[maroon]32[/maroon],[maroon]32[/maroon],     [green]// [gray]'Y'[/gray][/green]
    248,[maroon]8[/maroon],[maroon]112[/maroon],[maroon]128[/maroon],[maroon]248[/maroon],   [green]// [gray]'Z'[/gray][/green]
    192,[maroon]128[/maroon],[maroon]128[/maroon],[maroon]128[/maroon],[maroon]192[/maroon], [green]// [gray]'['[/gray][/green]
    128,[maroon]64[/maroon],[maroon]32[/maroon],[maroon]16[/maroon],[maroon]8[/maroon],      [green]// [gray]'\'[/gray][/green]
    192,[maroon]64[/maroon],[maroon]64[/maroon],[maroon]64[/maroon],[maroon]192[/maroon],    [green]// [gray]']'[/gray][/green]
    64,[maroon]160[/maroon],[maroon]0[/maroon],[maroon]0[/maroon],[maroon]0[/maroon],        [green]// [gray]'^'[/gray][/green]
    0,[maroon]0[/maroon],[maroon]0[/maroon],[maroon]0[/maroon],[maroon]248[/maroon],         [green]// [gray]'_'[/gray][/green]
    128,[maroon]64[/maroon],[maroon]0[/maroon],[maroon]0[/maroon],[maroon]0[/maroon],        [green]// [gray]'`'[/gray][/green]
    0,[maroon]112[/maroon],[maroon]144[/maroon],[maroon]144[/maroon],[maroon]112[/maroon],   [green]// [gray]'a'[/gray][/green]
    128,[maroon]224[/maroon],[maroon]144[/maroon],[maroon]144[/maroon],[maroon]224[/maroon], [green]// [gray]'b'[/gray][/green]
    0,[maroon]96[/maroon],[maroon]128[/maroon],[maroon]128[/maroon],[maroon]96[/maroon],     [green]// [gray]'c'[/gray][/green]
    16,[maroon]112[/maroon],[maroon]144[/maroon],[maroon]144[/maroon],[maroon]112[/maroon],  [green]// [gray]'d'[/gray][/green]
    96,[maroon]144[/maroon],[maroon]240[/maroon],[maroon]128[/maroon],[maroon]112[/maroon],  [green]// [gray]'e'[/gray][/green]
    48,[maroon]64[/maroon],[maroon]224[/maroon],[maroon]64[/maroon],[maroon]64[/maroon],     [green]// [gray]'f'[/gray][/green]
    112,[maroon]144[/maroon],[maroon]112[/maroon],[maroon]16[/maroon],[maroon]224[/maroon],  [green]// [gray]'g'[/gray][/green]
    128,[maroon]128[/maroon],[maroon]224[/maroon],[maroon]144[/maroon],[maroon]144[/maroon], [green]// [gray]'h'[/gray][/green]
    128,[maroon]0[/maroon],[maroon]128[/maroon],[maroon]128[/maroon],[maroon]128[/maroon],   [green]// [gray]'i'[/gray][/green]
    64,[maroon]0[/maroon],[maroon]64[/maroon],[maroon]64[/maroon],[maroon]128[/maroon],      [green]// [gray]'j'[/gray][/green]
    128,[maroon]128[/maroon],[maroon]160[/maroon],[maroon]192[/maroon],[maroon]160[/maroon], [green]// [gray]'k'[/gray][/green]
    128,[maroon]128[/maroon],[maroon]128[/maroon],[maroon]128[/maroon],[maroon]128[/maroon], [green]// [gray]'l'[/gray][/green]
    0,[maroon]0[/maroon],[maroon]240[/maroon],[maroon]168[/maroon],[maroon]168[/maroon],     [green]// [gray]'m'[/gray][/green]
    0,[maroon]0[/maroon],[maroon]224[/maroon],[maroon]144[/maroon],[maroon]144[/maroon],     [green]// [gray]'n'[/gray][/green]
    0,[maroon]96[/maroon],[maroon]144[/maroon],[maroon]144[/maroon],[maroon]96[/maroon],     [green]// [gray]'o'[/gray][/green]
    0,[maroon]240[/maroon],[maroon]144[/maroon],[maroon]240[/maroon],[maroon]128[/maroon],   [green]// [gray]'p'[/gray][/green]
    0,[maroon]240[/maroon],[maroon]144[/maroon],[maroon]240[/maroon],[maroon]16[/maroon],    [green]// [gray]'q'[/gray][/green]
    0,[maroon]176[/maroon],[maroon]192[/maroon],[maroon]128[/maroon],[maroon]128[/maroon],   [green]// [gray]'r'[/gray][/green]
    0,[maroon]112[/maroon],[maroon]64[/maroon],[maroon]32[/maroon],[maroon]224[/maroon],     [green]// [gray]'s'[/gray][/green]
    0,[maroon]128[/maroon],[maroon]224[/maroon],[maroon]128[/maroon],[maroon]96[/maroon],    [green]// [gray]'t'[/gray][/green]
    0,[maroon]0[/maroon],[maroon]144[/maroon],[maroon]144[/maroon],[maroon]96[/maroon],      [green]// [gray]'u'[/gray][/green]
    0,[maroon]0[/maroon],[maroon]136[/maroon],[maroon]80[/maroon],[maroon]32[/maroon],       [green]// [gray]'v'[/gray][/green]
    0,[maroon]0[/maroon],[maroon]168[/maroon],[maroon]168[/maroon],[maroon]80[/maroon],      [green]// [gray]'w'[/gray][/green]
    0,[maroon]0[/maroon],[maroon]144[/maroon],[maroon]96[/maroon],[maroon]144[/maroon],      [green]// [gray]'x'[/gray][/green]
    0,[maroon]160[/maroon],[maroon]224[/maroon],[maroon]32[/maroon],[maroon]192[/maroon],    [green]// [gray]'y'[/gray][/green]
    0,[maroon]240[/maroon],[maroon]32[/maroon],[maroon]64[/maroon],[maroon]240[/maroon],     [green]// [gray]'z'[/gray][/green]
    96,[maroon]64[/maroon],[maroon]192[/maroon],[maroon]64[/maroon],[maroon]96[/maroon],     [green]// [gray]'{'[/gray][/green]
    128,[maroon]128[/maroon],[maroon]128[/maroon],[maroon]128[/maroon],[maroon]128[/maroon], [green]// [gray]'|'[/gray][/green]
    192,[maroon]64[/maroon],[maroon]96[/maroon],[maroon]64[/maroon],[maroon]192[/maroon],    [green]// [gray]'}'[/gray][/green]
    0,[maroon]0[/maroon],[maroon]80[/maroon],[maroon]160[/maroon],[maroon]0[/maroon]         [green]// [gray]'~'[/gray][/green]
};

static Font default_font = {default_data, [maroon]5[/maroon], [maroon]5[/maroon], [maroon]0[/maroon]};

/*
color on 32bits : 16 bits [b][blue]for[/blue][/b] alpha transparency + 16 bits [b][blue]for[/blue][/b] color.
alpha=[maroon]0[/maroon] mean opaque, alpha=[maroon]32[/maroon] mean totaly transparent.
example : 0x0010FFFF mean [gray]"white, [maroon]50[/maroon]% opacity"[/gray]
*/[/green][/b]


[green]//Local variables[/green]
[brown]#define LCD_WIDTH_PX 384[/brown]
[brown]#define LCD_HEIGHT_PX 216[/brown]
[brown]#define VRAM 0xA8000000[/brown]
Font* used_font = &default_font;

[green]//private functions[/green]
static void text_drawPoint(int x, [purple]int[/purple] y, [purple]int[/purple] size, [purple]int[/purple] color, [purple]int[/purple] alpha)
{
    [purple]int[/purple] i, j;
    short* vram = VRAM;
    [b][blue]if[/blue][/b](x+size>=LCD_WIDTH_PX || x<0 || y+size>=LCD_HEIGHT_PX || y<0) [b][blue]return[/blue][/b];
    vram += y*LCD_WIDTH_PX + x;
    [b][blue]if[/blue][/b](alpha == [maroon]32[/maroon]) {
        [b][blue]for[/blue][/b](i=size ; i ; i--, vram+=LCD_WIDTH_PX-size) {
            [b][blue]for[/blue][/b](j=size ; j ; j--) {
                *(vram++) = color;
            }
        }
    } [b][blue]else[/blue][/b] {
        [b][blue]for[/blue][/b](i=size ; i ; i--, vram+=LCD_WIDTH_PX-size) {
            [b][blue]for[/blue][/b](j=size ; j ; j--) {
                *(vram++) = ((((color & 0xf81f) * alpha + (*vram & 0xf81f) * (32-alpha)) >> 5) & 0xf81f) |
                            ((((color & 0x07e0) * alpha + (*vram & 0x07e0) * (32-alpha)) >> 5) & 0x07e0);
            }
        }
    }
}

static [purple]int[/purple] text_readPix(char* data, [purple]int[/purple] x, [purple]int[/purple] y, [purple]int[/purple] w, [purple]int[/purple] h)
{
    [purple]int[/purple] byte_width = ((w-1)>>3)+1;
    [b][blue]if[/blue][/b](x<0 || x>=w || y<0 || y>=h) [b][blue]return[/blue][/b] 0;
    [b][blue]return[/blue][/b] 0 != (data[y*byte_width+(x>>3)] & (128>>(x&7)));
}

static void text_antialias(int x, [purple]int[/purple] y, [purple]int[/purple] size, [purple]int[/purple] color, [purple]int[/purple] alpha, [purple]int[/purple] corner)
{
    [purple]int[/purple] i, j, m=size>>1;
    switch(corner) {
        case 0: [green]//top left[/green]
            [b][blue]for[/blue][/b](i=[maroon]0[/maroon] ; i<size-m ; i++) {
                [b][blue]for[/blue][/b](j=[maroon]0[/maroon] ; j<size-i-m-1 ; j++)
                    text_drawPoint(x+j, y+i, [maroon]1[/maroon], color, alpha);
                text_drawPoint(x+j, y+i, [maroon]1[/maroon], color, alpha>>1);
            }
            [b][blue]break[/blue][/b];
        case 1: [green]//top right[/green]
            [b][blue]for[/blue][/b](i=[maroon]0[/maroon] ; i<size-m ; i++) {
                text_drawPoint(x+i+m, y+i, [maroon]1[/maroon], color, alpha>>1);
                [b][blue]for[/blue][/b](j=i+m+1 ; j<size ; j++)
                    text_drawPoint(x+j, y+i, [maroon]1[/maroon], color, alpha);
            }
            [b][blue]break[/blue][/b];
        case 2: [green]//bottom left[/green]
            [b][blue]for[/blue][/b](i=m ; i<size ; i++) {
                [b][blue]for[/blue][/b](j=[maroon]0[/maroon] ; j<i-m ; j++)
                    text_drawPoint(x+j, y+i, [maroon]1[/maroon], color, alpha);
                text_drawPoint(x+j, y+i, [maroon]1[/maroon], color, alpha>>1);
            }
            [b][blue]break[/blue][/b];
        case 3: [green]//bottom right[/green]
            [b][blue]for[/blue][/b](i=m-1 ; i<size ; i++) {
                text_drawPoint(x+size-i+m-1, y+i, [maroon]1[/maroon], color, alpha>>1);
                [b][blue]for[/blue][/b](j=size-i+m ; j<size ; j++)
                    text_drawPoint(x+j, y+i, [maroon]1[/maroon], color, alpha);
            }
            [b][blue]break[/blue][/b];
    }
}

[green]//public functions[/green]
void text_setFont(Font* font)
{
    used_font = font;
}

Font* text_getActualFont()
{
    [b][blue]return[/blue][/b] used_font;
}

void text_printC(int x, [purple]int[/purple] y, [purple]char[/purple] c, [purple]int[/purple] size, [purple]int[/purple] color)
{
    [purple]int[/purple] i, j, byte_width, alpha;
    char* data;
    [b][blue]if[/blue][/b](c<32 || c>127 || size<1) [b][blue]return[/blue][/b];
    byte_width = ((used_font[b]->[/b]width-1)>>3)+1;
    data = used_font[b]->[/b]data + byte_width * used_font[b]->[/b]height * (c-32);
    alpha = [maroon]32[/maroon] - ((color>>16) % 32);
    color &= [maroon]0[/maroon]xFFFF;
    [b][blue]for[/blue][/b](i=[maroon]0[/maroon] ; i<used_font[b]->[/b]height ; i++) {
        [b][blue]for[/blue][/b](j=[maroon]0[/maroon] ; j<used_font[b]->[/b]width ; j++) {
            [b][blue]if[/blue][/b](data[i*byte_width+(j>>3)] & (128>>(j&7)))
                text_drawPoint(x+j*size, y+i*size, size, color, alpha);
            [b][blue]else[/blue][/b] if(used_font[b]->[/b]flags & ANTIALIASING) { [green]// Antialiasing[/green]
                [b][blue]if[/blue][/b](text_readPix(data, j, i-1, used_font[b]->[/b]width, used_font[b]->[/b]height)) {
                    [b][blue]if[/blue][/b](text_readPix(data, j-1, i, used_font[b]->[/b]width, used_font[b]->[/b]height)) text_antialias(x+j*size, y+i*size, size, color, alpha, [maroon]0[/maroon]);
                    [b][blue]if[/blue][/b](text_readPix(data, j+1, i, used_font[b]->[/b]width, used_font[b]->[/b]height)) text_antialias(x+j*size, y+i*size, size, color, alpha, [maroon]1[/maroon]);
                }
                [b][blue]if[/blue][/b](text_readPix(data, j, i+1, used_font[b]->[/b]width, used_font[b]->[/b]height)) {
                    [b][blue]if[/blue][/b](text_readPix(data, j-1, i, used_font[b]->[/b]width, used_font[b]->[/b]height)) text_antialias(x+j*size, y+i*size, size, color, alpha, [maroon]2[/maroon]);
                    [b][blue]if[/blue][/b](text_readPix(data, j+1, i, used_font[b]->[/b]width, used_font[b]->[/b]height)) text_antialias(x+j*size, y+i*size, size, color, alpha, [maroon]3[/maroon]);
                }
            }
        }
    }
}

void text_print(int x, [purple]int[/purple] y, char* c, [purple]int[/purple] size, [purple]int[/purple] color)
{
    [purple]int[/purple] save_x = x;
    [b][blue]for[/blue][/b]( ; *c ; c++) {
        [b][blue]if[/blue][/b](*c == [gray]'\n'[/gray]) {
            x = save_x;
            y += (used_font[b]->[/b]height + used_font[b]->[/b]height/2) * size;
        } [b][blue]else[/blue][/b] {
            text_printC(x, y, *c, size, color);
            x += size * text_widthC(*c);
        }
    }
}

[purple]int[/purple] text_widthC(char c)
{
    [b][blue]if[/blue][/b](used_font[b]->[/b]flags & MONOSPACE || c==[gray]' '[/gray]) [b][blue]return[/blue][/b] used_font[b]->[/b]width+1;
    [purple]unsigned char[/purple] *data, col=[maroon]0[/maroon];
    [purple]int[/purple] i, j, byte_width, width;
    byte_width = ((used_font[b]->[/b]width-1)>>3)+1;
    width = [maroon]8[/maroon] * byte_width;
    data = used_font[b]->[/b]data + byte_width * used_font[b]->[/b]height * (c-32);
    [b][blue]for[/blue][/b](j=byte_width-1 ; j>=[maroon]0[/maroon] && !col ; j--) {
        col = [maroon]0[/maroon];
        [b][blue]for[/blue][/b](i=[maroon]0[/maroon] ; i<used_font[b]->[/b]height ; i++) {
            col |= data[i*byte_width + j];
        }
        [b][blue]if[/blue][/b](col) {
            [b][blue]while[/blue][/b](!(col&1)) {
                col>>=[maroon]1[/maroon];
                width--;
            }
        } [b][blue]else[/blue][/b] width -= [maroon]8[/maroon];
    }
    [b][blue]return[/blue][/b] width + 1;
}

[purple]int[/purple] text_width(char* c)
{
    [purple]int[/purple] width = [maroon]0[/maroon];
    [b][blue]for[/blue][/b]( ; *c ; c++) width += text_widthC(*c);
    [b][blue]return[/blue][/b] width;
}


[brown]#endif [green]//TEXT[/brown][/green]

[brown]#ifdef ALPHASPRITE[/brown]

void alphaSprite(int x, [purple]int[/purple] y, [purple]int[/purple] width, [purple]int[/purple] height, short* bitmap, short alpha)
{
    short* VRAM = (short*)0xA8000000;
    [purple]int[/purple] x_inc = width;
    [b][blue]if[/blue][/b] (y < 0)
    {
        bitmap -= y * width;
        height += y;
        y = [maroon]0[/maroon];
    }
    [b][blue]if[/blue][/b] (height > 216 - y) height = [maroon]216[/maroon] - y;

    [b][blue]if[/blue][/b] (x < 0)
    {
        bitmap -= x;
        width += x;
        x = [maroon]0[/maroon];
    }
    [b][blue]if[/blue][/b] (width > 128*3 - x) width = [maroon]128[/maroon]*3 - x;

    x_inc -= width;

    [purple]int[/purple] y_index;
    [purple]int[/purple] x_index;
    short * base = y * 128*3 + x + VRAM;
    [b][blue]for[/blue][/b] (y_index = height; y_index > 0; y_index--, base += [maroon]128[/maroon]*3 - width, bitmap += x_inc)
    {
        [b][blue]for[/blue][/b] (x_index = width; x_index > 0; x_index--, base++ , bitmap++ )
        {
            [b][blue]if[/blue][/b] (*bitmap!=alpha && *bitmap!= [maroon]0[/maroon]xffff) *base = *bitmap;
        }
    }
}

[brown]#endif [green]//ALPHASPRITE[/brown][/green]

[brown]#ifdef SPRITE16[/brown]

void CopySpriteMasked(short* bitmap, [purple]int[/purple] x, [purple]int[/purple] y, [purple]int[/purple] width, [purple]int[/purple] height, short mask)
{
    short* VRAM = (short*)0xA8000000;

    [purple]int[/purple] y_index;
    [purple]int[/purple] x_index;
    short * base = y * 128*3 + x + VRAM;
    [b][blue]for[/blue][/b] (y_index = height; y_index > 0; --y_index, base += [maroon]128[/maroon]*3 - width) {
        [b][blue]for[/blue][/b] (x_index = width; x_index > 0; --x_index, ++base, ++bitmap) {
            [b][blue]if[/blue][/b] (*bitmap != mask) *base = *bitmap;
        }
    }
}

[brown]#endif [green]// SPRITE16[/brown][/green]

[brown]#ifdef SPRITE[/brown]

void CopySpriteNbitMasked(const unsigned char* data, [purple]int[/purple] x, [purple]int[/purple] y, [purple]int[/purple] width, [purple]int[/purple] height, const short* palette, short maskColor, [purple]unsigned int[/purple] bitwidth)
{
    short* VRAM = (short*)0xA8000000; [green]//ou  color_t* VRAM = (color_t*) GetVRAMAddress();[/green]
    [purple]int[/purple] offset = [maroon]0[/maroon];
    [purple]int[/purple] availbits ;
    [purple]int[/purple] j,i;
    [purple]unsigned char[/purple] buf;
    short thiss;
    short color;

    VRAM += (128*3*y + x);
    [b][blue]for[/blue][/b](j=y; j<y+height; j++)
    {
        availbits = [maroon]0[/maroon];

        [b][blue]for[/blue][/b](i=x; i<x+width;  i++)
        {
            [b][blue]if[/blue][/b] (!availbits)
            {
                buf = data[offset++];
                availbits = [maroon]8[/maroon];
            }
            thiss = ((short)buf>>(8-bitwidth));
            color = palette[thiss];
            [b][blue]if[/blue][/b](color != maskColor && i >= [maroon]0[/maroon] && i<384)
            {
                *VRAM = color;
            }
            VRAM++;
            buf<=bitwidth;
            availbits-=bitwidth;
        }
        VRAM += (128*3-width);
    }
}


[brown]#endif [green]// SPRITE[/brown][/green]

[brown]#ifdef INT2STR[/brown]

char* int2str(char* c, [purple]int[/purple] n)
{
     [b][blue]if[/blue][/b](n==[maroon]0[/maroon])
     {
         c[0] = [gray]'0'[/gray];
         c[1] = [maroon]0[/maroon];
     }
     [b][blue]else[/blue][/b]
     {
         [purple]int[/purple] i, l=[maroon]0[/maroon];
         [b][blue]for[/blue][/b](i=n ; i ; i/=[maroon]10[/maroon])
             l++;
         c[l] = [maroon]0[/maroon];
         [b][blue]for[/blue][/b](i=n ; i ; i/=[maroon]10[/maroon])
             c[--l] = i%10+[gray]'0'[/gray];
     }
     [b][blue]return[/blue][/b] c;
}

[brown]#endif [green]// INT2STR[/brown][/green]

[brown]#ifdef FPS[/brown]

void setFps(int fpsWish) [green]//1 pour 128, [maroon]2[/maroon] pour 64, [maroon]3[/maroon] pour 42, [maroon]128[/maroon]/fpsWish en fait[/green]
{
      static [purple]unsigned int[/purple] fps = [maroon]0[/maroon], fps_count = [maroon]0[/maroon];

      [b][blue]do[/blue][/b]
      {
          fps = RTC_GetTicks();
      }
      [b][blue]while[/blue][/b](fps < fps_count+fpsWish);
      fps_count = RTC_GetTicks();
}

[brown]#endif [green]// FPS[/brown][/green]



Le .h
Le .h
[green]/*************************************************************/
/** fxCG20Lib - Color graphic Library to fx-CG20 - fx-CG10 **/
/** fxCG20Libis a free software                             **/
/**                                                         **/
/** @author Lancelot                                        **/
/**                                                         **/
/** @file fxCG20Lib.h                                       **/
/** Include header for fxCG20Lib                            **/
/**                                                         **/
/** @date 10-06-2013                                        **/
/*************************************************************/[/green]

[brown]#ifndef fXCG20LIB[/brown]
[brown]#define fXCG20LIB[/brown]

/****************************************************/
/** uncomment [brown]#define of functions you want to use **/[/brown]
/****************************************************/[/green][/b]

[green]// [brown]#define CGL_ALL //Auto define all functions[/brown][/green]

[green]// [brown]#define KEY[/brown][/green]
[green]// [brown]#define LINE[/brown][/green]
[green]// [brown]#define PIXEL[/brown][/green]
[green]// [brown]#define RANDOM[/brown][/green]
[green]// [brown]#define ABS[/brown][/green]
[green]// [brown]#define CIRCLE[/brown][/green]
[green]// [brown]#define TEXT[/brown][/green]
[green]// [brown]#define ALPHASPRITE[/brown][/green]
[green]// [brown]#define SPRITE16[/brown][/green]
[green]// [brown]#define SPRITE[/brown][/green]
[green]// [brown]#define INT2STR[/brown][/green]
[green]// [brown]#define FPS[/brown][/green]

[brown]#endif [green]// fXCG20LIB[/brown][/green]




Calculatrices : Casio 35+ SH4 (modifiée 75) et fx-CG 20 PRIZM
Projets que je soutiens
Des exemples parmi tant d'autres
Pokémon Jade de Dododormeur
Zelda de Smashmaster
Super Geek Brothers de Siapran
Mes Programmes
Mes Programmes
Mes Projets
Mes Projets
ColorLib
Add-ins Jetpack Joyride et Pac-Man sur PRIZM (les 2 non commencés mais en réflexion)
A la recherche des sprites jetpack Joride si quelqu'un les a en couleur
NemhardyHors ligneGrand maître des Traits d'EspritPoints: 1235 Défis: 54 Message

Citer : Posté le 06/10/2013 17:33 | #


Et toutes les prizms ont des SH4, donc pas de soucis de modeles... En revanche pour garantir une meilleure portatibilitée avec les éventuelles mais peu probables futures versions, il serait plus judicieux d'utiliser GetVramAddress que d'initialiser l'adresse à la main non ?

Il faudrait aussi (simple supposition) voir a uniformiser les noms des fonctions : tout ce qui peut être graphique commencerait par "draw" ou autre, surtout pour les différentes fonctions de spriting car ils si t assez varies pour l'instant...

Et peut être inclure le nom des auteurs des grosses fonctions, je pense notamment a pierrotLL ou autres...


N'attendez pas qu'il n'y ait plus de miel : スススススススススススススススススススススススススス養蜂家スススススススススススススススススススススススススススススススススススス蜂家
SmashmasterHors ligneAncien modérateurPoints: 4559 Défis: 253 Message

Citer : Posté le 06/10/2013 21:45 | #


La fonction GetVRAMAdress (trouvé dans les sources de gravityDuck de pierrotll)
Cliquez pour découvrir
Cliquez pour recouvrir
void* GetVRAMAdress()
{
    asm("mov.l syscall_adress, r2\n"
        "mov.l getVRAM, r0\n"
        "jmp @r2\n"
        "nop\n"
        "syscall_adress: .long 0x80020070\n"
        "getVRAM: .long 0x01E6");
}


Ajouté le 06/10/2013 à 21:46 :
Oui Nemhardy, il vaut mieux utiliser GetVramAdress

Ajouté le 06/10/2013 à 21:56 :
Afficher des sprites avec de la transparence
Cliquez pour découvrir
Cliquez pour recouvrir


void CopySpriteNbitMaskedAlpha(const unsigned char* data, int x, int y, int width, int height, const color_t* palette, color_t maskColor, unsigned int bitwidth,int alpha)
{
   color_t* VRAM = (color_t*) GetVRAMAdress();
   VRAM += (LCD_WIDTH_PX*y + x);
   alpha %= 32;
   int i,j;
   int offset = 0;
   unsigned char buf=0;
   for(j=y; j<y+height; j++)
   {
      int availbits = 0;
      for(i=x; i<x+width;  i++)
      {
         if (!availbits)
         {
            buf = data[offset++];
            availbits = 8;
         }
         color_t thiss = ((color_t)buf>>(8-bitwidth));
         color_t color = palette[thiss];
         if(color != maskColor&& i >=0 && i<384)
            *VRAM = ((((color & 0xF81F) * alpha + (*VRAM & 0xF81F) * (32-alpha)) >> 5) & 0xF81F) |
            ((((color & 0x07E0) * alpha + (*VRAM & 0x07E0) * (32-alpha)) >> 5) & 0x07E0);
         VRAM++;
         buf<<=bitwidth;
         availbits-=bitwidth;
      }
      VRAM += (LCD_WIDTH_PX-width);
   }
}



pour la fonction abs() il y a plus court :

unsigned int abs(int i){
     return (i<0?-i:i);
}

TotoyoHors ligneMembre d'honneurPoints: 15908 Défis: 101 Message
LancelotHors ligneMembrePoints: 1274 Défis: 160 Message

Citer : Posté le 07/10/2013 18:48 | #


@Totoyo: je ne sais pas

@Smashmaster: A quoi correspond la fonction GetVramAdress ? où nous en servons nous ?
Calculatrices : Casio 35+ SH4 (modifiée 75) et fx-CG 20 PRIZM
Projets que je soutiens
Des exemples parmi tant d'autres
Pokémon Jade de Dododormeur
Zelda de Smashmaster
Super Geek Brothers de Siapran
Mes Programmes
Mes Programmes
Mes Projets
Mes Projets
ColorLib
Add-ins Jetpack Joyride et Pac-Man sur PRIZM (les 2 non commencés mais en réflexion)
A la recherche des sprites jetpack Joride si quelqu'un les a en couleur
DodormeurHors ligneAncien rédacteurPoints: 3928 Défis: 82 Message

Citer : Posté le 07/10/2013 18:53 | #


ben... dans toutes les fonctions de dessin (c'est pour avoir l'adresse de la vram, le buffer de dessin)
Pokemon !!!!!! => pokemon stadium/battle

mes meilleurs jeux
Cliquer pour enrouler
un jeu avec des niveaux de gris mais compatible SH4 (mais en monochrome pour les SH4) => bomberman
envie de plonger dans la mer pour ramasser des tresors? => ballon sea
envie de sauver l'univers dans un jeu avec une longue durée de vie? => saviors of the future
un add-in addictif avec plein de secret et de trophées => evasion survival
un shmup bien dur et sadique => saviors 2

projets
Cliquer pour enrouler

pokemon
Cliquer pour enrouler



encodage des données de combat (sprite, attaques et nom)
   100%

systeme de combat
   100%

encodage des données de pokemon (niveau d'apprentisage et evolution)
   100%


moteur de la carte
   50%

level design
   1%

finition de pokemon jade
   42%

merci a tout le monde pour son soutien


projets que je soutiens
Cliquer pour enrouler
minecraft de limachi
zelda prizm de smashmaster (en esperant qu'il puisse le finir)
les tests de marmotti
un RPG de dark storm (dont je connais le nom, mais pas vous ) Arcuz !
NemhardyHors ligneGrand maître des Traits d'EspritPoints: 1235 Défis: 54 Message

Citer : Posté le 07/10/2013 19:03 | #


En gros au lieux d'avoir
char* VRAM = (char*)0xA8000000;


Tu auras

char* VRAM = (char*)GetVRAMAdress;


Par exemple

PS : la fonction existe aussi avec deux "d" (GetVRAMAddress())et est définie dans display.h ou truc du style il me semble : l'une d'elle est t-elle meilleure que l'autre ?
N'attendez pas qu'il n'y ait plus de miel : スススススススススススススススススススススススススス養蜂家スススススススススススススススススススススススススススススススススススス蜂家
SmashmasterHors ligneAncien modérateurPoints: 4559 Défis: 253 Message

Citer : Posté le 07/10/2013 20:16 | #


@Totoyo: pas obligatoirement, le nombre peut aussi être un long ou un double (mais pas un char, pour moi la valeur absolue d'un char n'a aucun sens)

unsigned long abs (long i);

NemhardyHors ligneGrand maître des Traits d'EspritPoints: 1235 Défis: 54 Message

Citer : Posté le 07/10/2013 20:52 | #


Petite fonction perso que j'avais faite à mes débuts...
Je l'ai juste adaptée rapido à ce qui existe déjà au niveau de la lib, mais teste quand même au cas où, j'ai adapté ça en live sur n++ mais j'ai ni la calto ni l'émulateur sous la main donc... (surtout pour la version avec canal alpha)

drawFilledCircle
Cliquer pour enrouler
void drawFilledCircle(short x, short y, short rayon, [purple]int[/purple] couleur)
{
    [purple]int[/purple] x1=[maroon]0[/maroon], y1=y-rayon;
    [b][blue]while[/blue][/b] (y1<(y+rayon))
    {
        x1=x-rayon;
        y1++;
        [b][blue]while[/blue][/b] (x1<(x+rayon))
        {
            [b][blue]if[/blue][/b](pow(x1-x, [maroon]2[/maroon]) + pow(y1-y, [maroon]2[/maroon]) < pow(rayon, [maroon]2[/maroon]))
            {
                CL_point(x1, y1, couleur);
            }
            x1++;
        }
    }
}


avec CL_point la fonction qui existe dans la 0.91


drawFilledCircleAlpha
Cliquer pour enrouler
void drawFilledCircleAlpha(short x, short y, short rayon, [purple]int[/purple] couleur, [purple]int[/purple] alpha)
{
    [purple]int[/purple] x1=[maroon]0[/maroon], y1=y-rayon;
    [b][blue]while[/blue][/b] (y1<(y+rayon))
    {
        x1=x-rayon;
        y1++;
        [b][blue]while[/blue][/b] (x1<(x+rayon))
        {
            [b][blue]if[/blue][/b](pow(x1-x, [maroon]2[/maroon]) + pow(y1-y, [maroon]2[/maroon]) < pow(rayon, [maroon]2[/maroon]))
            {
                drawPointAlpha(x1, y1, [maroon]1[/maroon], couleur, alpha);
            }
            x1++;
        }
    }
}


Avec drawPointAlpha() la fonction de pixel avec un canal alpha, il me semble qu'elle n'est pas encore dans la lib, donc à toi de voir quel nom tu lui donnes, ou... enfin, tu vois
Si jamais :
drawPointAlpha
Cliquer pour enrouler
static void drawPointAlpha(int x, [purple]int[/purple] y, [purple]int[/purple] size, [purple]int[/purple] color, [purple]int[/purple] alpha)
{
     [purple]int[/purple] i, j;
     short* vram = (short*)GetVRAMAdress;
     [b][blue]if[/blue][/b](x+size>=LCD_WIDTH_PX || x<0 || y+size>=LCD_HEIGHT_PX || y<0) [b][blue]return[/blue][/b];
     vram += y*LCD_WIDTH_PX + x;
     [b][blue]if[/blue][/b](alpha == [maroon]32[/maroon]) {
         [b][blue]for[/blue][/b](i=size ; i ; i--, vram+=LCD_WIDTH_PX-size) {
             [b][blue]for[/blue][/b](j=size ; j ; j--) {
                 *(vram++) = color;
             }
         }
     } [b][blue]else[/blue][/b] {
         [b][blue]for[/blue][/b](i=size ; i ; i--, vram+=LCD_WIDTH_PX-size) {
             [b][blue]for[/blue][/b](j=size ; j ; j--) {
                 *(vram++) = ((((color & 0xf81f) * alpha + (*vram & 0xf81f) * (32-alpha)) >> 5) & 0xf81f) |
                             ((((color & 0x07e0) * alpha + (*vram & 0x07e0) * (32-alpha)) >> 5) & 0x07e0);
             }
         }
     }
}


Quand je vous disais que c'était pas, mais alors pas optimisé , mais ça peut toujours combler en attendant qu'on regarde mieux ça !
N'attendez pas qu'il n'y ait plus de miel : スススススススススススススススススススススススススス養蜂家スススススススススススススススススススススススススススススススススススス蜂家
SmashmasterHors ligneAncien modérateurPoints: 4559 Défis: 253 Message

Citer : Posté le 07/10/2013 21:28 | #


@Nemhardy: je pense que l'algorithme d'Andres est plus optimisé pour tracer des cercles
NemhardyHors ligneGrand maître des Traits d'EspritPoints: 1235 Défis: 54 Message

Citer : Posté le 07/10/2013 21:58 | #


J'imagine
C'est à dire que tu traces touts les cercles concentriques pour obtenir un disque à la sortie si j'ai bien compris ?
De toute façon ces fonctions n'étaient pas destinées à rester bien longtemps, le temps que mieux soit fait !
Si vous voulez je regarderai à faire ça avec l'algo d'Andres
N'attendez pas qu'il n'y ait plus de miel : スススススススススススススススススススススススススス養蜂家スススススススススススススススススススススススススススススススススススス蜂家
SmashmasterHors ligneAncien modérateurPoints: 4559 Défis: 253 Message

Citer : Posté le 07/10/2013 22:10 | #


Oui c'est ça.

for (i=0;i<rayonDisque;i++)
{
  On trace un cercle de rayon i avec l'algorithme d'Andres
}
L'algorithme est très simple à adapter en C
DodormeurHors ligneAncien rédacteurPoints: 3928 Défis: 82 Message

Citer : Posté le 07/10/2013 22:45 | #


sur monochromeLib, c'est ca

void ML_filled_circle(int x, int y, int radius, ML_Color color)
{
    int plot_x, plot_y, d;

    if(radius < 0) return;
    plot_x = 0;
    plot_y = radius;
    d = 1 - radius;

    ML_horizontal_line(y, x-plot_y, x+plot_y, color);
    while(plot_y > plot_x)
    {
        if(d < 0)
            d += 2*plot_x+3;
        else {
            d += 2*(plot_x-plot_y)+5;
            plot_y--;
            ML_horizontal_line(y+plot_y+1, x-plot_x, x+plot_x, color);
            ML_horizontal_line(y-plot_y-1, x-plot_x, x+plot_x, color);
        }
        plot_x++;
        if(plot_y >= plot_x)
        {
            ML_horizontal_line(y+plot_x, x-plot_y, x+plot_y, color);
            ML_horizontal_line(y-plot_x, x-plot_y, x+plot_y, color);
        }
    }
}


et je pense qu'il s'agit de la meilleure optimisation (en tout cas, c'est celle utilisée par pierrotLL, donc ca doit etre de qualité )
Pokemon !!!!!! => pokemon stadium/battle

mes meilleurs jeux
Cliquer pour enrouler
un jeu avec des niveaux de gris mais compatible SH4 (mais en monochrome pour les SH4) => bomberman
envie de plonger dans la mer pour ramasser des tresors? => ballon sea
envie de sauver l'univers dans un jeu avec une longue durée de vie? => saviors of the future
un add-in addictif avec plein de secret et de trophées => evasion survival
un shmup bien dur et sadique => saviors 2

projets
Cliquer pour enrouler

pokemon
Cliquer pour enrouler



encodage des données de combat (sprite, attaques et nom)
   100%

systeme de combat
   100%

encodage des données de pokemon (niveau d'apprentisage et evolution)
   100%


moteur de la carte
   50%

level design
   1%

finition de pokemon jade
   42%

merci a tout le monde pour son soutien


projets que je soutiens
Cliquer pour enrouler
minecraft de limachi
zelda prizm de smashmaster (en esperant qu'il puisse le finir)
les tests de marmotti
un RPG de dark storm (dont je connais le nom, mais pas vous ) Arcuz !
NemhardyHors ligneGrand maître des Traits d'EspritPoints: 1235 Défis: 54 Message

Citer : Posté le 07/10/2013 23:23 | #


Dodormeur a écrit :
c'est celle utilisée par pierrotLL, donc ca doit etre de qualité


Le raisonnement se tient

Après il faudra fait des tests car la fonction de tracé de ligne que l'on a est peut être pas aussi efficace de celle de ML (il passe par de l'assembleur pour sa fonction de Ligne il me semble non? J ai pas les sources sous la main pour vérifier )

Peut être que sur ML/Graphe 75 et les autres, il sera plus efficace de faire telle chose, et que sur Priam il vaudra mieux faire autre chose... Enfin , c'est juste une petite piste de réflexion absolument pas fondée. Lets test and see !
N'attendez pas qu'il n'y ait plus de miel : スススススススススススススススススススススススススス養蜂家スススススススススススススススススススススススススススススススススススス蜂家
Dark stormHors ligneMembre d'honneurPoints: 10776 Défis: 174 Message

Citer : Posté le 08/10/2013 06:59 | #


PLL utilise Breshenham, donc y'a pas plus optimisé
Après, c'est sur que rien que la fonction de pixel et de ligne en ASM accèlèrent énormément un programme
Finir est souvent bien plus difficile que commencer. — Jack Beauregard
Páranÿe quetë Quendya
DodormeurHors ligneAncien rédacteurPoints: 3928 Défis: 82 Message

Citer : Posté le 08/10/2013 17:03 | #


mais non, monochrome lib n'utilise pas d'asm
Pokemon !!!!!! => pokemon stadium/battle

mes meilleurs jeux
Cliquer pour enrouler
un jeu avec des niveaux de gris mais compatible SH4 (mais en monochrome pour les SH4) => bomberman
envie de plonger dans la mer pour ramasser des tresors? => ballon sea
envie de sauver l'univers dans un jeu avec une longue durée de vie? => saviors of the future
un add-in addictif avec plein de secret et de trophées => evasion survival
un shmup bien dur et sadique => saviors 2

projets
Cliquer pour enrouler

pokemon
Cliquer pour enrouler



encodage des données de combat (sprite, attaques et nom)
   100%

systeme de combat
   100%

encodage des données de pokemon (niveau d'apprentisage et evolution)
   100%


moteur de la carte
   50%

level design
   1%

finition de pokemon jade
   42%

merci a tout le monde pour son soutien


projets que je soutiens
Cliquer pour enrouler
minecraft de limachi
zelda prizm de smashmaster (en esperant qu'il puisse le finir)
les tests de marmotti
un RPG de dark storm (dont je connais le nom, mais pas vous ) Arcuz !
LancelotHors ligneMembrePoints: 1274 Défis: 160 Message

Citer : Posté le 08/10/2013 18:52 | #


Merci à tous de votre soutient.

Je ne trouve pas les fonctions suivantes quelqu'un pourrait me donner les sources?
-Bdisp_SetPoint_VRAM
-RTC_GetTicks



Et dans ce code, Est-ce vraiment important d'avoir 128*3 (Je peux le remplacer par 384 ?)

void CL_alphaSprite(int x, [purple]int[/purple] y, [purple]int[/purple] width, [purple]int[/purple] height, short* bitmap, short alpha)
{
    short* VRAM = (short*)0xA8000000;
    [purple]int[/purple] x_inc = width;
    [b][blue]if[/blue][/b] (y < 0)
    {
        bitmap -= y * width;
        height += y;
        y = [maroon]0[/maroon];
    }
    [b][blue]if[/blue][/b] (height > 216 - y) height = [maroon]216[/maroon] - y;

    [b][blue]if[/blue][/b] (x < 0)
    {
        bitmap -= x;
        width += x;
        x = [maroon]0[/maroon];
    }
    [b][blue]if[/blue][/b] (width > 128*3 - x) width = [maroon]128[/maroon]*3 - x;

    x_inc -= width;

    [purple]int[/purple] y_index;
    [purple]int[/purple] x_index;
    short * base = y * 128*3 + x + VRAM;
    [b][blue]for[/blue][/b] (y_index = height; y_index > 0; y_index--, base += [maroon]128[/maroon]*3 - width, bitmap += x_inc)
    {
        [b][blue]for[/blue][/b] (x_index = width; x_index > 0; x_index--, base++ , bitmap++ )
        {
            [b][blue]if[/blue][/b] (*bitmap!=alpha && *bitmap!= [maroon]0[/maroon]xffff) *base = *bitmap;
        }
    }
}

Calculatrices : Casio 35+ SH4 (modifiée 75) et fx-CG 20 PRIZM
Projets que je soutiens
Des exemples parmi tant d'autres
Pokémon Jade de Dododormeur
Zelda de Smashmaster
Super Geek Brothers de Siapran
Mes Programmes
Mes Programmes
Mes Projets
Mes Projets
ColorLib
Add-ins Jetpack Joyride et Pac-Man sur PRIZM (les 2 non commencés mais en réflexion)
A la recherche des sprites jetpack Joride si quelqu'un les a en couleur
DodormeurHors ligneAncien rédacteurPoints: 3928 Défis: 82 Message

Citer : Posté le 08/10/2013 19:05 | #


ben... c'est les fonctions de base du prizmsdk
Pokemon !!!!!! => pokemon stadium/battle

mes meilleurs jeux
Cliquer pour enrouler
un jeu avec des niveaux de gris mais compatible SH4 (mais en monochrome pour les SH4) => bomberman
envie de plonger dans la mer pour ramasser des tresors? => ballon sea
envie de sauver l'univers dans un jeu avec une longue durée de vie? => saviors of the future
un add-in addictif avec plein de secret et de trophées => evasion survival
un shmup bien dur et sadique => saviors 2

projets
Cliquer pour enrouler

pokemon
Cliquer pour enrouler



encodage des données de combat (sprite, attaques et nom)
   100%

systeme de combat
   100%

encodage des données de pokemon (niveau d'apprentisage et evolution)
   100%


moteur de la carte
   50%

level design
   1%

finition de pokemon jade
   42%

merci a tout le monde pour son soutien


projets que je soutiens
Cliquer pour enrouler
minecraft de limachi
zelda prizm de smashmaster (en esperant qu'il puisse le finir)
les tests de marmotti
un RPG de dark storm (dont je connais le nom, mais pas vous ) Arcuz !
Pages : Précédente1, 2, 3, 4, 5Suivante

Planète Casio v42 © créé par Neuronix et Muelsaco 2004 - 2019 | Il y a 19 connectés | Nous contacter | Qui sommes-nous ? | Licences et remerciements

Planète Casio est un site communautaire non affilié à Casio. Toute reproduction de Planète Casio, même partielle, est interdite.
Les programmes et autres publications présentes sur Planète Casio restent la propriété de leurs auteurs et peuvent être soumis à des licences ou copyrights.
CASIO est une marque déposée par CASIO Computer Co., Ltd