Forum Casio - [fx-CG 20] Liste des meilleures fonctions par Lancelot

Forum Casio - Autres questions

Index du Forum » Autres questions » [fx-CG 20] Liste des meilleures fonctions

Lancelot Hors ligne Membre Points: 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

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

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

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

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

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

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

[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

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

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

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

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

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

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)

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

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

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

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

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

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

Précédente – 1, 2, 3, 4, 5 – Suivante

Lancelot Hors ligne Membre Points: 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

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

Flappy Bird
Pac-Man
Pac-Man Color
Meta Ball

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

Alphacreator Hors ligne Membre Points: 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)

Dodormeur Hors ligne Ancien rédacteur Points: 3965 Défis: 84 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

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 !

Lancelot Hors ligne Membre Points: 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

[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

[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

Flappy Bird
Pac-Man
Pac-Man Color
Meta Ball

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

Nemhardy Hors ligne Grand maître des Traits d'Esprit Points: 1243 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...

Conseil de lecture : https://en.wikipedia.org/wiki/Berners_Street_hoax

Smashmaster Hors ligne Ancien modérateur Points: 4561 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);
}

Sprite Coder - codeur de sprite pour la cg-20 et g75/85/95,

Totoyo Hors ligne Membre d'honneur Points: 16102 Défis: 102 Message

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

Pour la fonction absolue, le nombre doit obligatoirement être un int ?

<<< >>> Teste mon générateur de mots nouveaux

<<<
>>> Random Youtube Video

<<<

Lancelot Hors ligne Membre Points: 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

Flappy Bird
Pac-Man
Pac-Man Color
Meta Ball

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

Dodormeur Hors ligne Ancien rédacteur Points: 3965 Défis: 84 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

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

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 !

Nemhardy Hors ligne Grand maître des Traits d'Esprit Points: 1243 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 ?

Conseil de lecture : https://en.wikipedia.org/wiki/Berners_Street_hoax

Smashmaster Hors ligne Ancien modérateur Points: 4561 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);

Sprite Coder - codeur de sprite pour la cg-20 et g75/85/95,

Nemhardy Hors ligne Grand maître des Traits d'Esprit Points: 1243 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 !

Conseil de lecture : https://en.wikipedia.org/wiki/Berners_Street_hoax

Smashmaster Hors ligne Ancien modérateur Points: 4561 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

Sprite Coder - codeur de sprite pour la cg-20 et g75/85/95,

Nemhardy Hors ligne Grand maître des Traits d'Esprit Points: 1243 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

Conseil de lecture : https://en.wikipedia.org/wiki/Berners_Street_hoax

Smashmaster Hors ligne Ancien modérateur Points: 4561 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

Sprite Coder - codeur de sprite pour la cg-20 et g75/85/95,

Dodormeur Hors ligne Ancien rédacteur Points: 3965 Défis: 84 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

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

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 !

Nemhardy Hors ligne Grand maître des Traits d'Esprit Points: 1243 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 !

Conseil de lecture : https://en.wikipedia.org/wiki/Berners_Street_hoax

Dark storm Hors ligne Labélisateur Points: 11641 Défis: 176 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

Dodormeur Hors ligne Ancien rédacteur Points: 3965 Défis: 84 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

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

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 !

Lancelot Hors ligne Membre Points: 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

Flappy Bird
Pac-Man
Pac-Man Color
Meta Ball

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

Dodormeur Hors ligne Ancien rédacteur Points: 3965 Défis: 84 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

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

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 !

Précédente – 1, 2, 3, 4, 5 – Suivante

Nom d'utilisateur

Adresse email

Message

Ajouter un spoiler(texte affichable/masquable par un clic)

Nom du lien (facultatif): Adresse du lien:

Adresse de l'image: Alignement de l'image: Normal Flottante à gauche Centrée Flottante à droite Redimensionnement de l'image (en pixel): Largeur : Hauteur :

Adresse de la vidéo:

Pseudo du profil: Afficher la liste des membres

Auteur de la citation (faculatif):

Texte de déroulage du spoiler (modification faculative): Texte d'enroulage du spoiler (modification faculative):

Titre de la barre de progression: Pourcentage de la barre de progression entre 1 et 100:

→ ⇒ √ Σ ∫ ≠ ≥ ≤ π θ ◢ ± α β γ δ Δ σ ≈ ∞ ∈ λ

Fichier joint

Me prévenir par email lorsqu'une réponse est postée

Combien font six plus cinq ?

Veuillez donner la réponse en chiffre

Vous devez activer le Javascript dans votre navigateur pour pouvoir valider ce formulaire.

Si vous n'avez pas volontairement désactivé cette fonctionnalité de votre navigateur, il s'agit probablement d'un bug : contactez l'équipe de Planète Casio.

Planète Casio v4.3 © créé par Neuronix et Muelsaco 2004 - 2024 | Il y a 38 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