Tous | Basic Casio | C/C++/ASM | LuaFX | Graphisme | Transferts | Logiciels | Diverses astuces

Calculatrice
Toutes
Graphs 35 à 100
Graph 25
Graphs 75/85/95 (SD)
Graph 100(+)
Classpad 300/330 (+)
Fx-CG 10/20
Fx-CP 400

Retour à la liste des tutoriels
Tutoriel Casio : Liste des meilleures fonctions
Tutoriel rédigé le : 2013-10-06 10:59  par Lancelot  Catégorie : C/C++/ASM  Calculatrice : Fx-CG 10/20

Discutez de ce tutoriel sur le forum >> Voir le sujet dédié (81 commentaires)

Liste des meilleures fonctions

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;
    int row, col, word, bit;
    row = basic_keycode%10;
    col = basic_keycode/10-1;
    word = row>>1;
    bit = col + 8*(row&1);
    return (0 ≠ (keyboard_register[word] & 1<<bit));
}


Le .h
#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




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, int y, int size, int color, int alpha)
{
    int i, j;
    short* vram = VRAM;
    if(x+size≥LCD_WIDTH_PX || x<0 || y+size≥LCD_HEIGHT_PX || y<0) return;
    vram += y*LCD_WIDTH_PX + x;
    if(alpha == 32) {
        for(i=size ; i ; i--, vram+=LCD_WIDTH_PX-size) {
            for(j=size ; j ; j--) {
                *(vram++) = color;
            }
        }
    } else {
        for(i=size ; i ; i--, vram+=LCD_WIDTH_PX-size) {
            for(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();
     return *(VRAM + (y * LCD_WIDTH_PX) + x);
}

Afficher une ligne
void line(int x1, int y1, int x2, int y2, short color)
{
    int 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 );
    if(dx > dy)
    {
        cumul = dx / 2;
        for(i=1 ; i<dx ; i++)
        {
            x += sx;
            cumul += dy;
            if(cumul > dx)
            {
                cumul -= dx;
                y += sy;
            }
            Bdisp_SetPoint_VRAM( x, y,(int)  color );
        }
    }
    else
    {
        cumul = dy / 2;
        for(i=1 ; i<dy ; i++)
        {
            y += sy;
            cumul += dx;
            if(cumul > dy)
            {
                cumul -= dy;
                x += sx;
            }
            Bdisp_SetPoint_VRAM(x, y,(int) color);
        }
    }
}

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

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

   while(y < x)
   {
     if(er > 0)
     {
       x--;
       erX += 2;
       er += erX;
     }
     y++;
     erY += 2;
     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

#define VRAM 0xA8000000

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

   drawPoint(x0, y0 + rayon, 1, couleur, alpha);
   drawPoint(x0, y0 - rayon, 1, couleur, alpha);
   drawPoint(x0 + rayon, y0, 1, couleur, alpha);
   drawPoint(x0 - rayon, y0, 1, couleur, alpha);

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

static void drawPoint(int x, int y, int size, int color, int alpha)
{
     int i, j;
     short* vram = VRAM;
     if(x+size≥LCD_WIDTH_PX || x<0 || y+size≥LCD_HEIGHT_PX || y<0) return;
     vram += y*LCD_WIDTH_PX + x;
     if(alpha == 32) {
         for(i=size ; i ; i--, vram+=LCD_WIDTH_PX-size) {
             for(j=size ; j ; j--) {
                 *(vram++) = color;
             }
         }
     } else {
         for(i=size ; i ; i--, vram+=LCD_WIDTH_PX-size) {
             for(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, int y0, int rayon, int couleur)
{
     int k;
     int x,y,d;
     for (k=0; k ≤ rayon; k++)
     {
         x = 0;
         y = k;
         d = k - 1;
         while (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);
             if (d ≥ 2*x)
             {          
                 d -=2*x+1;
                 x++;
             }
             else if (d < 2*(k-y))
             {
                 d += 2*y-1;
                 y--;
             }
             else
             {
                 d += 2*(y-x-1);
                 y--;
                 x++;
             }
         }
     }
}

Tracer un rectangle rempli
void CL_Filled_Rectangle( int xi, int yi, int xi2, int yi2, unsigned short color)
{
         unsigned short* VRAM = GetVRAMAdress();
         int i,j;
         const int x = max(0,min(xi,xi2));
         const int x2 = min( LCD_WIDTH_PX,max(xi,xi2));
        
         const int y = max(0,min(yi,yi2));
         const int y2 = min( LCD_WIDTH_PX,max(yi,yi2));
        
         const int xm = max(x,x2);
         const int ym = max(y,y2);
        
         const int xe = x2-x+1;
        
         VRAM += LCD_WIDTH_PX*y + x;
         for(j = min(y,y2); j ≤ ym; j++) {
                 for(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;
     for(i = 0; i < (points*2); i+=2)
     {
         if(i < (points*2)-4)
         {
             line(xy[i ], xy[i+1], xy[i+2], xy[i+3], color);
         } else
         {
             line(xy[i ], xy[i+1], xy[0], xy[1], color);
         }
     }
}

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

static void Filled_polygon_quicksord(int* t, int p, int r) //from MonochromeLib by PierrotLL
{
     int q;
     if(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 int *x, const int *y, int nb_vertices, unsigned short color) //from MonochromeLib by PierrotLL
{
     int i, j, dx, dy, ymin, ymax;
     int *cut_in_line, nb_cut;
     if(nb_vertices < 3) return;
     cut_in_line = malloc(nb_vertices*sizeof(int));
     if(!cut_in_line) return;
     ymin = ymax = y[0];
     for(i=1 ; i<nb_vertices ; i++)
     {
         if(y[i ] < ymin) ymin = y[i ];
         if(y[i ] > ymax) ymax = y[i ];
     }
     for(i=ymin ; i≤ymax ; i++)
     {
         nb_cut = 0;
         for(j=0 ; j<nb_vertices ; j++)
         {
             if((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]);
                 if(dy)
                 {
                     dx = x[(j+1)%nb_vertices]-x[j];
                     cut_in_line[nb_cut] = x[j] + /*random*/(abs(i-y[j]+sgn(i-y[j])/2)*dx/dy);
                     nb_cut++;
                 }
             }
         }
         Filled_polygon_quicksord(cut_in_line, 0, nb_cut-1);
         j = 0;
         while(j<nb_cut-2 && cut_in_line[j]==cut_in_line[j+1]) j++;
         while(j < nb_cut)
         {
             if(j == nb_cut-1) Horizontal_Line(cut_in_line[j-1]+1, cut_in_line[j], i, color);
             else
             {
                 dx = 1;
                 while(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);
}

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


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

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

void text_print(int x, int y, char* c, int size, int color)
{
    int save_x = x;
    for( ; *c ; c++) {
        if(*c == '\n') {
            x = save_x;
            y += (used_fontheight + used_fontheight/2) * size;
        } else {
            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, int x, int y, int width, int height, const color_t* palette, color_t maskColor, unsigned int bitwidth,int alpha)
{
    color_t* VRAM = (color_t*) GetVRAMAdress();
    VRAM += (LCD_WIDTH_PX*y + x);
    alpha %= 32;
    int i,j;
    int offset = 0;
    unsigned char buf=0;
    for(j=y; j<y+height; j++)
    {
       int availbits = 0;
       for(i=x; i<x+width;  i++)
       {
          if (!availbits)
          {
             buf = data[offset++];
             availbits = 8;
          }
          color_t thiss = ((color_t)buf>>(8-bitwidth));
          color_t color = palette[thiss];
          if(color ≠ maskColor&& i ≥0 && i<384)
             *VRAM = ((((color & 0xF81F) * alpha + (*VRAM & 0xF81F) * (32-alpha)) >> 5) & 0xF81F) |
             ((((color & 0x07E0) * alpha + (*VRAM & 0x07E0) * (32-alpha)) >> 5) & 0x07E0);
          VRAM++;
          buf<≤bitwidth;
          availbits-=bitwidth;
       }
       VRAM += (LCD_WIDTH_PX-width);
    }
}



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

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

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

Réglage des fps
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();
}




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


:!: ColorLib regroupe toutes ses fonctions :!:


Discutez de ce tutoriel sur le forum >> Voir le sujet dédié (81 commentaires)

Publicité et partenaires
Casio Education
Casio éducation

TI-Planet
Casiopeia
Casiopeia
CasioFan, la communauté ClassPad
CasioFan
CodeWalrus
CodeWalrus

Planète Casio v42 © créé par Neuronix et Muelsaco 2004 - 2015 | Il y a 65 connectés | Nous contacter | Qui sommes-nous ? | Licences et remerciements
Rugby Manager | Jeu de basket | Jeu de handball | Jeu de tennis | Nova Raider | Réparation téléphone | Soccer Rush | Tasty Tale

Planète Casio est un site communautaire indépendant, géré bénévolement et n'est donc pas affilié à Casio | Toute reproduction de Planète Casio, même partielle, est interdite
Les fichiers, programmes et autres publications présents sur Planète Casio restent la propriété de leurs auteurs respectifs et peuvent être soumis à des licences ou des copyrights.
CASIO est une marque déposée par CASIO Computer Co., Ltd