Posté le 26/11/2011 18:16
). 
)
Planète Casio v4.3 © créé par Neuronix et Muelsaco 2004 - 2024 | Il y a 237 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
Citer : Posté le 05/05/2012 22:08 | #
Salut,
J'ai quelques questions concernant l'utilisation de la VRAM sur Prizm.
En effet sur les calculatrices monochromes c'est simple à comprendre, mais comment mettre de la couleur dans la VRAM de la Prizm.
Aussi est-ce nos fonctions graphiques persos sont plus rapides que les syscalls.
Et si on écrit des fonctions en assembleur, est-ce qu'elle seront plus rapides ? Pourquoi car les syscalls sont aussi en assembleur ?
Escape prison
Bloxorz
Free wheel
QR code
Nombre en or
RayCasting Engine
Mario Party
Zelda
et Planète Casio
Citer : Posté le 05/05/2012 22:31 | #
Grosso merdo, un short (16 bits) revient à un pixel de la structure suivante:
RRRRRVVVVVVBBBBB
5R-6V-5B
Ce, qui simplifie de loin les fonctions de sprites: il s'agit juste de copier des shorts aux bons endroits sans se soucier d'y décalage.
Demain je publierai les fonctions graphiques que j'ai faites
Citer : Posté le 05/05/2012 22:40 | #
Demain je publierai les fonctions graphiques que j'ai faites
Cool, celles que j'ai intégré à PRGM2 sont encore trop lentes, et ne prennent pas en compte toutes les couleurs.
Escape prison
Bloxorz
Free wheel
QR code
Nombre en or
RayCasting Engine
Mario Party
Zelda
et Planète Casio
Citer : Posté le 05/05/2012 22:43 | #
La Prizm a un écran 16 bits (16 bits par pixels, RGB 5:6:5). La VRAM créée par l'OS fait 384*216 pixels (le premier est en haut à gauche).
Mais l'écran physique fait 396*224 pixels.
Quelques fonctions pour accéder au LCD
Un exemple de VRAM2DD
Quelques exemples de fonctions utilisant tout ça
Pour ce qui est de la vitesse de tes fonctions, la meilleure solution pour comparer est de faire des benchmark (calculer avec RTC_GetTicks le temps que prend ta fonction appelée quelques millions de fois).
Quelque soit le langage compilé dans lequel tu écris ton programme, il sera toujours traduit en langage machine. Ce n'est pas le langage qui fait la vitesse, mais l'optimisation du code. Les compilateurs C d'aujourd'hui sont très forts pour ça, mais en écrivant ton code en asm tu peux t'assurer toi même de son optimisation finale. Mais rappelons-le, le plus important pour la vitesse d'exécution est l'algorithme en lui même, l'optimisation n'apporte que peu.
Citer : Posté le 05/05/2012 22:49 | #
Y'a mes sources dans bust-a-move!
Citer : Posté le 06/05/2012 00:04 | #
Tu utilise l'écran physique de 396*224 ?
Escape prison
Bloxorz
Free wheel
QR code
Nombre en or
RayCasting Engine
Mario Party
Zelda
et Planète Casio
Citer : Posté le 06/05/2012 09:39 | #
Pas encore, pour cela, j'uploaderai, si j peux, les routines. En attendant, je te suggère d'alle vers cemetech, section prizm, useful routines.
Attention: ça demande un buffer de la taille que tu veux, et d'ex trois trucs bonus!
Dans prizm.ld, on peut changer la taille Max de la ram et la rom au moment de la compilation:
Ram: 500k est un chiffre secure
ROM: 1250k
Voilà, vous ne devriez plus avoir de problèmes de mémoire, sauf pour l'allocation dynamique qui dépend de la heap et pas de la ram
Ajouté le 06/05/2012 à 09:52 :
#include \"txt_spr_loader.h\"
#include \"macros.h\"
void CopySprite(const char* data, int x, int y, int width, int height) {
char* VRAM = (char*)0xA8000000;
int j;
VRAM += 2*(LCD_WIDTH_PX*y + x);
for(j=y; j<y+height; j++) {
memcpy(VRAM,data,2*width);
VRAM += 2*LCD_WIDTH_PX;
data += 2*width;
}
}
void CopySprite_Palette(const unsigned char* data, const unsigned short* palette, int x, int y, int width, int height)
{
unsigned short* VRAM = (unsigned short*)VRAM_ADRESS;
int i,j;
unsigned short* ptr = VRAM + y*LCD_WIDTH_PX + x;
for(j=0; j<height; j++) {
for(i = 0; i < width; i++)
{
*ptr = palette[*(data++)];
ptr++;
}
ptr += LCD_WIDTH_PX-width;
}
}
void CopySprite_Palette_Alpha_Nibbles(const unsigned char* data, const unsigned short* palette, int x, int y, int width, int height)
{
unsigned short* VRAM = (unsigned short*)VRAM_ADRESS;
unsigned short* ptr = VRAM + y*LCD_WIDTH_PX + x;
int i,j;
unsigned char nibble;
for(j=0; j<height; j++) {
for(i = 0; i < width; i+=2)
{
nibble = (*data)>>4;
if(nibble) //First Index is taken as alpha
*ptr = palette[nibble];
nibble = (*data) %16;
if(nibble)
*(ptr+1) = palette[nibble];
ptr+=2;
data++;
}
ptr += LCD_WIDTH_PX-width;
}
}
void Print_custom(unsigned char* spr, int x, int y)
{
int i;
unsigned char spr_buf[54];
unsigned short spr_pal[3];
for(i=0;spr[i ];i++)
{
if(spr[i ] == \' \') continue;
load_txt_spr(spr[i ], spr_buf, spr_pal);
CopySprite_Palette_Alpha_Nibbles(spr_buf, spr_pal, x+6*i, y, LETTER_WIDTH, LETTER_HEIGHT);
}
}
void set_Pixel(int x, int y, unsigned short color)
{
unsigned short* VRAM = (unsigned short*)VRAM_ADRESS;
if(x<LCD_WIDTH_PX && x > 0 && y < LCD_WIDTH_PX && y > 0)
VRAM[LCD_WIDTH_PX * y + x] = color;
}
unsigned short get_Pixel(int x, int y)
{
unsigned short* VRAM = (unsigned short*)VRAM_ADRESS;
if(x<LCD_WIDTH_PX && x > 0 && y < LCD_WIDTH_PX && y > 0)
return VRAM[LCD_WIDTH_PX * y + x];
}
void Circle(int xi, int yi, int r, unsigned short color)
{
int x = 0;
int y = r;
int d = r - 1;
while(y>=x)
{
set_Pixel( x+xi, y+yi, color);
set_Pixel( y+xi, x+yi, color);
set_Pixel( -x+xi, y+yi, color);
set_Pixel( -y+xi, x+yi, color);
set_Pixel( x+xi, -y+yi, color);
set_Pixel( y+xi, -x+yi, color);
set_Pixel( -x+xi, -y+yi, color);
set_Pixel( -y+xi, -x+yi, color);
if(d >= 2*x)
{
d -= 2*x+1;
x++;
}
else if (d <= 2*(r-y))
{
d += 2*y-1;
y--;
}
else
{
d += 2*(y-x-1);
y--;
x++;
}
}
}
void Filled_Circle(int xi, int yi, int r, unsigned short color)
{
int x = 0;
int y = r;
int d = r - 1;
while(y>=x)
{
/* set_Pixel( x+xi, y+yi, color);
set_Pixel( -x+xi, y+yi, color);
*/
Horizontal_Line(x+xi,-x+xi,y+yi,color);
/* set_Pixel( y+xi, x+yi, color);
set_Pixel( -y+xi, x+yi, color);
*/
Horizontal_Line(y+xi,-y+xi,x+yi,color);
/* set_Pixel( x+xi, -y+yi, color);
set_Pixel( -x+xi, -y+yi, color);
*/
Horizontal_Line(x+xi,-x+xi,-y+yi, color);
/* set_Pixel( -y+xi, -x+yi, color);
set_Pixel( y+xi, -x+yi, color);
*/
Horizontal_Line(y+xi,-y+xi, -x+yi, color);
if(d >= 2*x)
{
d -= 2*x+1;
x++;
}
else if (d <= 2*(r-y))
{
d += 2*y-1;
y--;
}
else
{
d += 2*(y-x-1);
y--;
x++;
}
}
}
void Vertical_Line(int x, int y1, int y2, unsigned short color)
{
unsigned short* VRAM = (unsigned short*)VRAM_ADRESS;
int i;
int yi = max(min(y1,y2),0);
int yf = min(max(y1,y2),LCD_HEIGHT_PX);
if(x < 0 || x > LCD_WIDTH_PX) return;
for(i=yi; i <= yf; i++)
VRAM[LCD_WIDTH_PX*i + x] = color;
}
void Horizontal_Line(int x1, int x2, int y, unsigned short color)
{
unsigned short* VRAM = (unsigned short*)VRAM_ADRESS;
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;
}
void Line(int xi, int yi, int xf, int yf, unsigned short color)
{
int dx,dy,i,xinc,yinc,cumul,x,y;
x = xi;
y = yi;
dx = xf - xi;
if(!dx)
{
Vertical_Line(xi, yi,yf,color);
return;
}
dy = yf - yi;
if(!dy)
{
Horizontal_Line(xi,xf,yi,color);
return;
}
xinc = ( dx > 0 ) ? 1 : -1;
yinc = ( dy > 0 ) ? 1 : -1;
dx = abs(dx);
dy = abs(dy);
set_Pixel( x, y, color);
if ( dx > dy )
{
cumul = dx >>1; // dy/2
for ( i = 1; i <= dx; i++ )
{
x += xinc;
cumul += dy;
if (cumul >= dx)
{
cumul -= dx;
y += yinc;
}
set_Pixel( x, y, color);
}
}
else
{
cumul = dy >>2;// dy/2
for ( i = 1; i <= dy; i++ )
{
y += yinc;
cumul += dx;
if ( cumul >= dy )
{
cumul -= dy;
x += xinc;
}
set_Pixel( x, y, color);
}
}
}
void Filled_Rectangle( int xi, int yi, int xi2, int yi2, unsigned short color)
{
unsigned short* VRAM = (unsigned short*)VRAM_ADRESS;
int i,j;
int x = max(0,min(xi,xi2));
int x2 = min( LCD_WIDTH_PX,max(xi,xi2));
int y = max(0,min(yi,yi2));
int y2 = min( LCD_WIDTH_PX,max(yi,yi2));
VRAM += LCD_WIDTH_PX*y + x;
for(j = min(y,y2); j < max(y,y2); j++) {
for(i=min(x,x2); i<max(x,x2); i++) {
*(VRAM++) = color;
}
VRAM += LCD_WIDTH_PX-(x2-x);
}
}
void Rectangle(int xi, int yi, int xf, int yf, int stroke, unsigned short color)
{
int i;
for(i=0;i<stroke; i++)
{
Vertical_Line(xi+i,yi,yf,color);
Vertical_Line(xf-i,yi,yf,color);
Horizontal_Line(xi,yf+i,yi+i,color);
Horizontal_Line(xi,yf-i,yf-i,color);
}
}
void draw_box(int xi, int yi, int xi2, int yi2, unsigned char mode)
{
unsigned short* VRAM = (unsigned short*)VRAM_ADRESS;
int i,j;
int x = max(0,min(xi,xi2));
int x2 = min( LCD_WIDTH_PX,max(xi,xi2));
int y = max(0,min(yi,yi2));
int y2 = min( LCD_WIDTH_PX,max(yi,yi2));
if(x2-x <16 || y2-y < 16) return;
}
Citer : Posté le 06/05/2012 13:10 | #
T'aurais pas une petite fonction pour lire (puis afficher) un bitmap 24 bits. Merci !
Escape prison
Bloxorz
Free wheel
QR code
Nombre en or
RayCasting Engine
Mario Party
Zelda
et Planète Casio
Citer : Posté le 06/05/2012 13:30 | #
NOpe, sorry, faut voir dans les sources de l’utilitaire de pierrot
Citer : Posté le 06/05/2012 15:20 | #
Il est préférable de stocker des bitmaps 16 bits dans l'exécutable, et de faire la conversion avant, pour ne pas ralentir (ni alourdir) inutilement le programme.
Citer : Posté le 06/05/2012 19:50 | #
@ Eyeron : Et c'est toi qui disait à Veb d'utilisé un spoiler pour un aussi ''long'' code ?
Citer : Posté le 06/05/2012 19:53 | #
J'étais sur ipod, arriver à mettre ce code a été un exploit, kay?
Citer : Posté le 06/05/2012 20:00 | #
J'étais sur ipod, arriver à mettre ce code a été un exploit, kay?
Vu comme ça, évidemment, ça parrait plus normal
Citer : Posté le 06/05/2012 20:05 | #
Je te dis pas comment il ramait quand j'ai ajouté la ligne après le code...