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

1, 2, 3, 4, 5 – Suivante

Dodormeur Hors ligne Ancien rédacteur Points: 3965 Défis: 84 Message

Citer : Posté le 05/10/2013 18:47 | # | Fichier joint

c'est pas une mauvaise idée, voila quelques fonctions par-ci par la

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 05/10/2013 18:56 | #

Merci de ta participation Mais je n'ai pas bien compris le fonctionnement des fonction suivante :

Cliquez pour découvrir

Cliquez pour recouvrir

int sgn(double d){
    [purple]float[/purple] eps = [maroon]0[/maroon].000005;
    [b][blue]return[/blue][/b] d<-eps?-1:d>eps;
}

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;
}
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;
        }
    }
}
[b][green]/*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;
        }
    }
}*/[/green][/b]

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

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 05/10/2013 19:08 | #

Superbe idée !
Malheureusement je ne pourrais pas trop aider, étant donné que je commence juste à comprendre le fonctionnement de le VRAM et à peine des syscalls...
Je regarderai quand même si je n'ai pas quelques petites fonctions toutes bêtes qui traiteraient.

Sinon, ça serait génial que la communauté de programmeurs sur Prizm s'agrandisse !

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

Lancelot Hors ligne Membre Points: 1274 Défis: 160 Message

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

C'est le but : les attirer en montrant que c'est facile

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 05/10/2013 19:17 | #

Je viens de penser qu'i l serait aussi possible de proposer une sorte de lib regroupant les diverses fonctions qui apparaîtront ici, en uniformisant bien les noms des fonctions et en les documentant bien! Ça pourrait être sympa non ?

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

Dodormeur Hors ligne Ancien rédacteur Points: 3965 Défis: 84 Message

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

pour sgn, moi non plus

mais c'est utiliser par monochromelib

(et je pense pour la derivée)

int2str ben te transforme un entier en une chaine de caractere (pour l'afficher )

CopySpriteMasked(short* bitmap, int x, int y, int width, int height, short mask) t'affiche un sprite (en 16 bit) en X,Y avec un masque de transparence d'une couleur definie

opySpriteNbitMasked(const unsigned char* data, int x, int y, int width, int height, const short* palette, short maskColor, unsigned int bitwidth)fait la meme chose, mais permet de choisir le nombre de bit

et voila

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 05/10/2013 19:33 | #

Ok merci des précisions et alphaSprite(int x, int y, int width, int height, short* bitmap, short alpha)
il fait quoi lui ?

@Nemhardy: C'est ce que je pensait faire à terme d'avoir trouver les fonctions les plus intéressantes

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 05/10/2013 19:34 | #

je pense qu'il affiche un sprite 16 bit avec de la transparence (de 0 a 255), mais je ne l'ai jamais reelement utilisé, c'est pour cela qu'il est en commentaire

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 05/10/2013 19:44 | #

Tiens voila la fonction de PierrotLL (c'est pas grave si c'est pas de nous ?) pour savoir si une touche est pressée ou pas :

Là

Cliquer pour enrouler

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

Avec en argument le code "Basic" (un getkey dans le menu prgm) de la touche et 10 pour Ac/On

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

Dodormeur Hors ligne Ancien rédacteur Points: 3965 Défis: 84 Message

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

et voila le .h de cette fonction

#ifndef _KEY
#define _KEY

int key_down(int basic_keycode);

/***************/
/** Key codes **/
/***************/
#define K_F1    79
#define K_F2    69
#define K_F3    59
#define K_F4    49
#define K_F5    39
#define K_F6    29

#define K_SHIFT 78
#define K_OPTN  68
#define K_VARS  58
#define K_MENU  48
#define K_LEFT  38
#define K_UP    28

#define K_ALPHA 77
#define K_SQR   67
#define K_EXPO  57
#define K_EXIT  47
#define K_DOWN  37
#define K_RIGHT 27

#define K_THETA 76
#define K_LOG   66
#define K_LN    56
#define K_SIN   46
#define K_COS   36
#define K_TAN   26

#define K_FRAC  75
#define K_FD    65
#define K_LPAR  55
#define K_RPAR  45
#define K_COMMA 35
#define K_STORE 25

#define K_7     74
#define K_8     64
#define K_9     54
#define K_DEL   34

#define K_4     73
#define K_5     63
#define K_6     53
#define K_MULT  43
#define K_DIV   33

#define K_1     72
#define K_2     62
#define K_3     52
#define K_PLUS  42
#define K_MINUS 32

#define K_0     71
#define K_DOT   61
#define K_EXP   51
#define K_NEG   41
#define K_EXE   31

#define K_AC    10

#endif //_KEY

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 !

Dodormeur Hors ligne Ancien rédacteur Points: 3965 Défis: 84 Message

Citer : Posté le 05/10/2013 19:51 | # | Fichier joint

et comme je suis gentil, je rajoute une fonction d'affichage de texte (toujours de pierrotLL)

les fonctions setFont et getActualFont ne sont pas utiles, mais textPrint permet d'afficher une chaine de caractere en XY, avec comme message c, dans la taille size, avec la couleur color

Ajouté le 05/10/2013 à 19:53 :
(la taille est equivalente au zoom je crois, donc 1 = taille normale)

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 05/10/2013 20:14 | #

Merci je met à jour rapidement

Ajouté le 05/10/2013 à 20:31 :
Voilà pour cette mise a jour

Edit 300 points

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 05/10/2013 20:47 | #

Afficher un point avec un canal alpha est t-il vraiment utile ?
Un simple

void point([purple]int[/purple] 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];
}

ne serait t-il pas plus optimisé et suffisant pour les cas les plus courants ?
La constante LCD_WIDTH_PX est définie entre autres dans <display.h>

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

Lancelot Hors ligne Membre Points: 1274 Défis: 160 Message

Citer : Posté le 05/10/2013 20:55 | #

Ok merci ça marche

Ajouté le 05/10/2013 à 21:06 :
Est-ce que plusieurs bons programmeurs pourraient vérifier si les codes sont bons ?

N'hésitez pas à continuer d'exposez ici vos plus belles découvertes !
Je pense à Smashmaster qui programme Zelda. Il aura surement de bons tuyaux à nous passer

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 05/10/2013 21:12 | #

une fonction qui regle les fps (utile quand le nombre d'ennemi/objet est variable)

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

    do
    {
        fps = RTC_GetTicks();
    }
    while(fps < fps_count+fpsWish);
    fps_count = RTC_GetTicks();
}

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 06/10/2013 10:36 | #

Il serait en fait peut-être plus judicieux d'appeler la fonction pour "allumer" un pixel pixelOn ou pixel, car c'est plus un pixel qu'un point qu'elle affiche.

Sinon, je viens juste d'adapter cette fonction pour qu'elle marche sur la calto (elle utilise la fonction qui s'appelle "point" pour l'instant, mais il faut voir ,si il y a modification du nom

)

traceCercle

Cliquer pour enrouler

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

Penser à inclure color.h pour les couleurs.

J'ai fait ça vite fait ce matin, après il faut voir si elle peut s'optimiser plus...

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

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

Citer : Posté le 06/10/2013 11:05 | #

Ajouté à la liste des meilleurs tutoriels de programmation.

Bon courage pour la mise à jour

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

<<<
>>> Random Youtube Video

<<<

Lancelot Hors ligne Membre Points: 1274 Défis: 160 Message

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

Merci

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

Dark storm Hors ligne Labélisateur Points: 11641 Défis: 176 Message

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

Quelqu'un est chaud pour faire une ColorLib (comme MonochromeLib) pour la Prizm ?

Finir est souvent bien plus difficile que commencer. — Jack Beauregard

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

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 dix 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 125 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