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

Legolas Hors ligne Ancien rédacteur Points: 3266 Défis: 104 Message

Citer : Posté le 01/04/2015 15:52 | #

Salut, je ne peux utiliser aucune fonction sans bug à la compilation, sauf TEXT qui ne fonctionne pas (mais qui ne fait pas crasher la compil').
Voici mon code example.c :

[brown]#include <display_syscalls.h>[/brown]
[brown]#include <keyboard_syscalls.h>[/brown]
[brown]#include <ColorLib.h>[/brown]

void main(void) {
    [purple]int[/purple] key;
    line(10,[maroon]10[/maroon],[maroon]20[/maroon],[maroon]20[/maroon], [maroon]1[/maroon]);
    [b][blue]while[/blue][/b] (!key_down(78))
    {
        [purple]int[/purple] a=[maroon]0[/maroon];
    }

    [b][blue]while[/blue][/b] (1) {
            Bdisp_AllClr_VRAM();
            GetKey(&key);
        switch (key) {
        }
    }

    [b][blue]return[/blue][/b];
}

Et j'ai inclus ColorLib dans le dossier include du PrizmSDK. Cela génère des .o et des .d, et me donne un joli "undefined reference to..." à chaque fonction.

Auriez-vous une idée ? Je dois compiler le ColorLib.c pointé par ColorLib.h en même temps ? En ce cas, comment puis-je faire puisque la compilation, en ligne de commande, se passe grâce à Maxe.bat qui pointe sur un Maxe.exe ? Merci par avance.

Ajouté le 02/04/2015 à 13:37 :
Du coup, personne ne sait comment compiler plusieurs fichiers .c en même temps ?

Mes programmes

Cacher les programmes

Wanted numbers
Pong400
PierrePaCiseaux (CP400)
Les Triangles

Mes défis

Cacher les défis

PGCD
Menu
ASCII
Nombres premiers

-florian66- Hors ligne Ancien rédacteur Points: 2384 Défis: 20 Message

Citer : Posté le 02/04/2015 16:20 | #

mais tu met les headers et ça compile le reste il n'y a pas besoin de passer par gcc

In Arch, I trust ! And you ?

Legolas Hors ligne Ancien rédacteur Points: 3266 Défis: 104 Message

Citer : Posté le 02/04/2015 16:21 | #

Ok, alors je ne comprend pas pourquoi les fonctions de ColorLib ne fonctionnent pas du tout.

Mes programmes

Cacher les programmes

Wanted numbers
Pong400
PierrePaCiseaux (CP400)
Les Triangles

Mes défis

Cacher les défis

PGCD
Menu
ASCII
Nombres premiers

-florian66- Hors ligne Ancien rédacteur Points: 2384 Défis: 20 Message

Citer : Posté le 02/04/2015 16:23 | #

je suis pas sur mon PC ce soir je t'envois le projet complet

et tu compilera avec sinon j'utilise WinSDK

et ça va vachement bien

In Arch, I trust ! And you ?

Legolas Hors ligne Ancien rédacteur Points: 3266 Défis: 104 Message

Citer : Posté le 02/04/2015 16:24 | #

Ma version de WinSDK ne compile pas non plus (ni pour g3a, ni g1a).

Mes programmes

Cacher les programmes

Wanted numbers
Pong400
PierrePaCiseaux (CP400)
Les Triangles

Mes défis

Cacher les défis

PGCD
Menu
ASCII
Nombres premiers

-florian66- Hors ligne Ancien rédacteur Points: 2384 Défis: 20 Message

Citer : Posté le 02/04/2015 16:25 | #

je te renvoie alors une autre version par MP

In Arch, I trust ! And you ?

Legolas Hors ligne Ancien rédacteur Points: 3266 Défis: 104 Message

Citer : Posté le 14/04/2015 19:35 | #

J'ai un petit problème : le compilateur me dit "error : conflicting type for 'int2str' " avec ce code, dont la fonction fait partie du topic principal :

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

[green]//[brown]#define LCD_WIDTH_PX 384 #define LCD_HEIGHT_PX 216[/brown][/green]
[green]//Carrées de 26*26 + 3 pixels en haut et en bas + 2 pixels de trait[/green]

void main(void)
{
    [purple]int[/purple] key;
    [purple]int[/purple] increment=[maroon]0[/maroon];
    char* chat;
    char* sortie;
    Bdisp_EnableColor(1);
    Trace();

    [b][blue]while[/blue][/b](1)
    {
        [b][blue]if[/blue][/b](keydown(47))
            {
                [b][blue]break[/blue][/b];
            }
        CL_text_print(5, [maroon]5[/maroon], increment, [maroon]2[/maroon], [maroon]1[/maroon]);
        Bdisp_PutDisp_DD();
        increment++;
        sortie = int2str(chat, increment);
    }
    [b][blue]return[/blue][/b];
}

void Trace()
{
    CL_Line(83,[maroon]213[/maroon],[maroon]253[/maroon],[maroon]213[/maroon], [maroon]0[/maroon]x8B4513);
    CL_Line(83,[maroon]4[/maroon],[maroon]253[/maroon],[maroon]4[/maroon], [maroon]0[/maroon]x8B4513);
    CL_Line(83,[maroon]213[/maroon],[maroon]83[/maroon],[maroon]4[/maroon], [maroon]0[/maroon]x8B4513);
    CL_Line(253,[maroon]213[/maroon],[maroon]253[/maroon],[maroon]4[/maroon], [maroon]0[/maroon]x8B4513);
    CL_Filled_Rectangle(84,[maroon]212[/maroon],[maroon]254[/maroon],[maroon]5[/maroon], [maroon]0[/maroon]x000000);
    Bdisp_PutDisp_DD();
}

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;
}

Quelqu'un aurait-il une idée ?

Mes programmes

Cacher les programmes

Wanted numbers
Pong400
PierrePaCiseaux (CP400)
Les Triangles

Mes défis

Cacher les défis

PGCD
Menu
ASCII
Nombres premiers

Lephenixnoir Hors ligne Administrateur Points: 24670 Défis: 170 Message

Citer : Posté le 16/04/2015 08:10 | #

Ceci étant dit, il faut savoir que la fonction renvoie le paramètre, à savoir chat (et que donc tu copies la valeur) et qu'elle part du principe que de la mémoire a été allouée. Donc dans ton cas faut soit passer par malloc() soit utiliser un tableau statique.

Pour l'information, si l'adresse que tu donne en paramètre est déjà stockée, ignore la valeur de retour. Elle est faite pour simplifier les cas comme :

char *ptr = malloc(10);
int2str(ptr, 734);

en :

char *ptr = int2str(malloc(10), 734);

Mon graphe (11 Avril): ((Rogue Life || HH2) ; PythonExtra ; serial gint ; Boson X ; passe gint 3 ; ...) || (shoutbox v5 ; v5)

Legolas Hors ligne Ancien rédacteur Points: 3266 Défis: 104 Message

Citer : Posté le 16/04/2015 08:15 | #

Merci je verrai quand je serai sur ordinateur.

Ajouté le 08/09/2015 à 17:09 :
Dites, je sais que c'est un peu hors-sujet, mais n'auriez-vous pas quelque part le filtre pour "selected.bmp" à mettre au "unselected.bmp" ? Je l'avais mais je ne le retrouve plus.

Mes programmes

Cacher les programmes

Wanted numbers
Pong400
PierrePaCiseaux (CP400)
Les Triangles

Mes défis

Cacher les défis

PGCD
Menu
ASCII
Nombres premiers

Nemhardy Hors ligne Grand maître des Traits d'Esprit Points: 1243 Défis: 54 Message

Citer : Posté le 08/09/2015 17:23 | #

Ben en gros c'est juste mettre le fond en noir non ? Enfin, si ta question est dans l'autre sens, tu auras sans doute la réponse ici : https://www.cemetech.net/forum/viewtopic.php?t=6211

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

Legolas Hors ligne Ancien rédacteur Points: 3266 Défis: 104 Message

Citer : Posté le 08/09/2015 17:29 | #

Nemhardy a écrit :
Ben en gros c'est juste mettre le fond en noir non ? Enfin, si ta question est dans l'autre sens, tu auras sans doute la réponse ici : https://www.cemetech.net/forum/viewtopic.php?t=6211

Merci beaucoup !

Mes programmes

Cacher les programmes

Wanted numbers
Pong400
PierrePaCiseaux (CP400)
Les Triangles

Mes défis

Cacher les défis

PGCD
Menu
ASCII
Nombres premiers

Aragorn Hors ligne Membre Points: 807 Défis: 5 Message

Citer : Posté le 04/06/2016 22:12 | #

Dans la fonction "random(int seed, int value)", à quoi correspond le "seed" ?

Mes Programmes

Cliquer pour enrouler

The Legend of CASIO - Basic Quest ( Basic )

Notes ( logiciel qui calcule votre moyenne, basic )

Professeur Layton ( jeu d'énigme en C )

Mario & Sonic Rush ( jeu de course 3D en C )

Projets

Cliquer pour enrouler

Zelda Ancestral Relics ( projet en C )

Projets que je soutient

Cliquer pour enrouler

Pokémon jade de Dodormeur

Jetpack Joyride de Drakalex007

Arcuz de Dark Storm

Casion de Az et Darkysun

Un jeu de course en 3D pour calculatrice :
http://www.planet-casio.com/Fr/programmes/voir_un_programme_casio.php?showid=2773&page=1.

Lephenixnoir Hors ligne Administrateur Points: 24670 Défis: 170 Message

Citer : Posté le 04/06/2016 22:58 | #

C'est pour initialiser le tirage au début de l'exécution. Tu le fais une seule fois, puis tu indiques 0 par la suite.
Si tu mets toujours le même seed, tu auras toujours les mêmes séquences de nombres. En général on utilise la valeur de retour de getTicks() ou autre valeur réellement aléatoire.

Mon graphe (11 Avril): ((Rogue Life || HH2) ; PythonExtra ; serial gint ; Boson X ; passe gint 3 ; ...) || (shoutbox v5 ; v5)

Aragorn Hors ligne Membre Points: 807 Défis: 5 Message

Citer : Posté le 05/06/2016 11:57 | #

Merci beaucoup.

Du coup, si je met "random(1;6);", cela me renverra un nombre entre 0 et 5.

Mes Programmes

Cliquer pour enrouler

The Legend of CASIO - Basic Quest ( Basic )

Notes ( logiciel qui calcule votre moyenne, basic )

Professeur Layton ( jeu d'énigme en C )

Mario & Sonic Rush ( jeu de course 3D en C )

Projets

Cliquer pour enrouler

Zelda Ancestral Relics ( projet en C )

Projets que je soutient

Cliquer pour enrouler

Pokémon jade de Dodormeur

Jetpack Joyride de Drakalex007

Arcuz de Dark Storm

Casion de Az et Darkysun

Un jeu de course en 3D pour calculatrice :
http://www.planet-casio.com/Fr/programmes/voir_un_programme_casio.php?showid=2773&page=1.

Lephenixnoir Hors ligne Administrateur Points: 24670 Défis: 170 Message

Citer : Posté le 05/06/2016 13:41 | #

N'interprète pas mal le paramètre, hein. « random(_, x) » renvoie un nombre aléatoire entre 0 et x - 1, inclus, quel que soit le premier paramètre. Faut juste indiquer un première paramètre différent de 0 la première fois (et juste la première fois. Si tu rechanges la graine à chaque fois, tu auras des résultats assez pauvres).

Mon graphe (11 Avril): ((Rogue Life || HH2) ; PythonExtra ; serial gint ; Boson X ; passe gint 3 ; ...) || (shoutbox v5 ; v5)

Alex BasicC Hors ligne Ancien modérateur Points: 1734 Défis: 83 Message

Citer : Posté le 18/08/2016 10:09 | #

J'ai vu qu'une où deux des fonctions présentées possédaient la fonction : pow.
Or je suis dans l’impossibilité d'utiliser cette fonction ainsi que sqrt :

[coderay.o: In function '_norme':
ray.c:(.text+0x5c0): undefined reference to '_sqrt'][/code]

En effet je ne trouve pas de lib math.h dans les lib fournie, est ce que vous savez quel lib utiliser ?

Lephenixnoir Hors ligne Administrateur Points: 24670 Défis: 170 Message

Citer : Posté le 18/08/2016 12:39 | #

Tu tombes mal, il n'y a pas de lib standard pour tout ce qui est programmation Prizm (du moins, pour autant que je le sache). J'ai personnellement un bon paquet de trucs courants codés à la main (string, sprintf(), alloca() par exemple) mais pas de fonctions mathématiques.

Dur de calculer ça du coup. La fonction pow() est triviale à implémenter (en exponentiation rapide par exemple), pour sqrt() c'est plus subtil. Tu peux exploiter un développement limité à certains endroits, la méthode des tangentes de Newton ailleurs, par exemple. Si tu veux normaliser les vecteurs tu peux calculer rapidement l'inverse de la racine carrée (un classique) :
Fast inverse square root - Wikipédia

Sinon tu as d'autres méthodes détaillées dans cet article (à commencer par la méthode de Newton) :
Methods of computing square roots - Wikipédia

Mon graphe (11 Avril): ((Rogue Life || HH2) ; PythonExtra ; serial gint ; Boson X ; passe gint 3 ; ...) || (shoutbox v5 ; v5)

Alex BasicC Hors ligne Ancien modérateur Points: 1734 Défis: 83 Message

Citer : Posté le 18/08/2016 12:46 | #

Ah j'avais bien peur que ça arrive :/
Bon, je vais tout implémenter à la main (puis si j'ai le temps je ferais une lib math pour la prizm)

Lephenixnoir Hors ligne Administrateur Points: 24670 Défis: 170 Message

Citer : Posté le 18/08/2016 12:52 | # | Fichier joint

Excepté math, la gestion des flux de stdio, les fonctions de conversion de stdlib et des fonctions de string, j'ai à peu près tout sous la main. Je te mets le fichier si ça peut t'aider... ar -t te donnera la liste des symboles qui y sont définis.

Mon graphe (11 Avril): ((Rogue Life || HH2) ; PythonExtra ; serial gint ; Boson X ; passe gint 3 ; ...) || (shoutbox v5 ; v5)

Nemhardy Hors ligne Grand maître des Traits d'Esprit Points: 1243 Défis: 54 Message

Citer : Posté le 18/08/2016 13:09 | #

Si tu utilises le sdk pour Windows (vu que tu parles «des libs fournies» je suppose que c'est le cas), normalement il suffit de linker la bibliothèque mathématique dispo en rajoutant -lm aux options de linkage dans le makefile, il me semble bien que par défaut c'est suffisant.

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

Alex BasicC Hors ligne Ancien modérateur Points: 1734 Défis: 83 Message

Citer : Posté le 18/08/2016 14:00 | #

Merci Lephenixnoir

@Nemhardy : j'avais essayé et il me sortait une autre erreur :/ la lib n'existe vraiment pas dans le sdk

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 huit plus huit ?

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 77 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