Accueil Ti-Gen Foire Aux Questions Chat sur le chan #tigcc sur IRC
Liste des membres Rechercher Aide
Bienvenue Invité !   Se connecter             Mes sujets   
Administrer
0 membre(s) et 1 visiteur(s) actif(s) durant les 5 dernières minutes Utilisateurs actifs : Aucun membre + 1 visiteur
Avant de poster sur le forum, il y a des régles de bases à respecter pour une bonne entente et un respect de tous.
Veuillez lire la charte du forum.
  :: Index » Forum Ti68K » Programmation C » stocker des sprites (10 réponse(s))
./POST DE DEPART (post n°0)   Marquer comme non lu.
Xantares Ecrit le: Vendredi 14 juillet 2006 à 22:31 Déconnecté(e)    Voir le profil de Xantares Envoyer un email à Xantares Envoyer un message privé à Xantares  

bonjour

j'ai plusieurs sprites, avec pour chacune 4 exemplaires pour les 4 orientations possibles

je déclare :


typedef unsigned char sprite[8]


(sprites 8 par 8)

j'ai besoin d'un tableau pour les n sprites avec chacunes leur 4 sens :


sprite model[n][4]


je voudrais directement assigner une sprite
alors je fais :

model[1][0]={
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000};

mais là le compilo le prend pas

mais si je déclare une sprite avec

static unsigned char spr1[]={
0b00000000
...
0b00000000};


et que je la copie :

memcpy(model[1][0],spr1,sizeof(sprite));


là ca marche

pourquoi le compilo ne veut pas prendre la premiere affectation ?
    
./Post n°1   Marquer comme non lu.
Onur Ecrit le: Samedi 15 juillet 2006 à 00:20 Déconnecté(e)    Voir le profil de Onur Envoyer un email à Onur Visiter le site WEB de Onur Envoyer un message privé à Onur  


les = { ... } sont utilisés uniquement pour l'initialisation au moment de la déclaration.

Si tu veux faire des agrégats du genre
tableau[2..5] = (4,53,98,42);

il faut faire du Ada.
Je ne veux pas faire quelque chose de bien, je cherche l'excellence:ETP Studio...


et autres projets à finir avant 2010
    
./Post n°2   Marquer comme non lu.
Onur Ecrit le: Samedi 15 juillet 2006 à 00:21 Déconnecté(e)    Voir le profil de Onur Envoyer un email à Onur Visiter le site WEB de Onur Envoyer un message privé à Onur  


en fait, le compilo reserve de la place statique avec ce que tu as mis entre les accolades.
les agrégats en Ada cachent du memcpy derriere.

sinon... tetris?

regarde comment a fait yuri pour les déclarer statiquement et réussir à utiliser un tableau virtuel pour y acceder avec des indices ;)
http://www.ticalc.org/archives/files/fileinfo/192/19239.html
-Edité le Samedi 15 juillet 2006 à 00:25 par Onur-
-Edité le Samedi 15 juillet 2006 à 00:26 par Onur-
Je ne veux pas faire quelque chose de bien, je cherche l'excellence:ETP Studio...


et autres projets à finir avant 2010
    
./Post n°3   Marquer comme non lu.
Jfg Ecrit le: Samedi 15 juillet 2006 à 01:07 Déconnecté(e)    Voir le profil de Jfg Envoyer un email à Jfg Visiter le site WEB de Jfg Envoyer un message privé à Jfg  


Xantares> Dans ton cas, je pense que tu devrais faire un tableau à 3 dimensions:
char tousMesSprites[nombreDeSprites][4][hauteurDesSprites] =
{ { { ... } } };


exemple d'initialisation de tableau de 3 dimensions:

char array3Dimensions[4][3][2] =
{
{{0,0}, {0,0}, {0,0}},
{{0,0}, {0,0}, {0,0}},
{{0,0}, {0,0}, {0,0}},
{{0,0}, {0,0}, {0,0}}
};

pour accéder à un sprite:
char* leSpriteQueJeVeux = tousMesSprites[numéroDuSprite][orientationDuSprite];
-Edité le Samedi 15 juillet 2006 à 01:10 par Jfg-
Kill Mario
    
./Post n°4   Marquer comme non lu.
geogeo Ecrit le: Samedi 15 juillet 2006 à 01:56 Déconnecté(e)    Voir le profil de geogeo Envoyer un email à geogeo Visiter le site WEB de geogeo Envoyer un message privé à geogeo  


des tableaux de pointeurs ça serait pas mieux ?
Webmaster du site.
Programmeur sur TI68K. Arkanoid, Nebulus, GFA-Basic.

Plus d'informations sur GFA-Basic (un langage Basic pour TI68K).
http://www.tigen.org/gfabasic
    
./Post n°5   Marquer comme non lu.
Kevin Kofler Ecrit le: Samedi 15 juillet 2006 à 07:49 Déconnecté(e)    Voir le profil de Kevin Kofler Envoyer un email à Kevin Kofler Visiter le site WEB de Kevin Kofler Envoyer un message privé à Kevin Kofler  


Xantares :
alors je fais :

model[1][0]={
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000};

mais là le compilo le prend pas

Normal, parce que la bonne syntaxe est:
memcpy(model[1}[0],(const unsigned char [n][4]){0b00000000,...},n*4*sizeof(unsigned char));

Mais ce n'est pas une bonne idée d'affecter des sprites comme ça, mieux vaut utiliser des pointeurs, parce que si tu fais des memcpy, tu copies les sprites pour rien!

Donc:
static const unsigned char spr1[]={
0b00000000
...
0b00000000};
const unsigned char (*model)[4]=spr1;

ou si tu veux:
const unsigned char (*model)[4]=(const unsigned char [n][4]){0b00000000,...};
(Les sprites sont constants, donc tu es censé les déclarer const.)
Membre de l'équipe de TIGCC: http://tigcc.ticalc.org
Mainteneur du portage Linux/Unix de TIGCC: http://tigcc.ticalc.org/linux/
Membre de l'équipe de CalcForge: http://www.calcforge.org:70/

Participez à la reprise de Ti-Gen!
    
./Post n°6   Marquer comme non lu.
Xantares Ecrit le: Dimanche 16 juillet 2006 à 09:00 Déconnecté(e)    Voir le profil de Xantares Envoyer un email à Xantares Envoyer un message privé à Xantares  

en fait ce que je voudrais : que une sprite de chaque soit assignée,

puis qu'ensuite les sprites symetyrique calculées

tout en pouvant y acceder par tableaux

pour l'instant ca marche mais je dois recopier les sprites statiques dans cette structure

au démarrage puis calculer les sprites dans les 3 autres sens ce qui fait que le programme est

très lent à démarrer

> jfg : ta solution implique d'initialiser tout le tableau je crois. mais 3/4 des sprites sont calculées après en fait donc ca me fait mettre plein de zeros...

> onur : j'ai essayé de comprendre le code du tetris.
je comprends pas du tout. les pieces sont pas les pieces normales declarées. il plante lorsqu'on essaye de tourner une piece.

-Edité le Dimanche 16 juillet 2006 à 13:51 par Xantares-
    
./Post n°7   Marquer comme non lu.
Onur Ecrit le: Dimanche 16 juillet 2006 à 19:47 Déconnecté(e)    Voir le profil de Onur Envoyer un email à Onur Visiter le site WEB de Onur Envoyer un message privé à Onur  


En fait, il déclare des trucs à la suite:

int  figure0[FIG_H][FIG_H]= {
  {1,1,0,0},
  {1,1,0,0},
  {0,0,0,0},
  {0,0,0,0} };  
int  figure1[FIG_H][FIG_H]= {
  {0,1,1,0},
  {1,1,0,0},
  {0,0,0,0},

(ces données ne sont pas au format que tu veux mais cest pour te montrer la méthode, donc tu peux pas faire de copier-coller)

Lui, il recopie sur un truc fig
copyFig(fig, &figure0[FIG_H*i]);


mais tu ne dois pas faire comme ca, ce n'est pas ce que tu veux (à moins que tu veuilles faire ton calcul de symétrie pendant l'execution), mais tu vois qu'il fait pointer au bon endroit avec l'astuce &figure0[FIG_H*i]);
Donc si toi tu déclares fig, avec
type_de_figure0** fig = &figure0;
...
sprite_actuel=fig[model][tour] ;


cela suppose bien sur que le compilo mette les figure0, figure1, etc.. dans l'ordre, les uns à la suite des ordres.

donc dans ton cas, ca revient à faire:

// remplacer les 0 par les valeurs
sprite model0_orientation1={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
sprite model0_orientation2={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
sprite model0_orientation3={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
sprite model0_orientation4={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
sprite model1_orientation1={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
sprite model1_orientation2={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
sprite model1_orientation3={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};

sprite model[][4]=(sprite**)&orientation1;


note: peut etre un truc du genre sprite* model[4] = .. est mieux, à tester.

edit: bon ca marche pas ce que j'ai écrit, mais cest pas loin, je te post le code correct au retour, je dois sortir là
-Edité le Dimanche 16 juillet 2006 à 20:02 par Onur-
Je ne veux pas faire quelque chose de bien, je cherche l'excellence:ETP Studio...


et autres projets à finir avant 2010
    
./Post n°8   Marquer comme non lu.
Jfg Ecrit le: Dimanche 16 juillet 2006 à 21:01 Déconnecté(e)    Voir le profil de Jfg Envoyer un email à Jfg Visiter le site WEB de Jfg Envoyer un message privé à Jfg  


Xantares :
puis qu'ensuite les sprites symetyrique calculées
tout en pouvant y acceder par tableaux


ah ok.
Du coup, je pense qu'il faudrait commencer par allouer assez de mémoire pour stoquer tout tes sprites dans les 4 directions.
Puis copier tout tes sprites dans le 1er quart de la mémoire allouée
Puis calculer les sprites symétriques verticalement du 1er quart dans le 2e quart
Puis calculer les sprites symétriques horizontalement de la 1ere motiée dans la 2e moitiée

Puis caster le pointeur vers la mémoire allouée en tableau à 3 dimensions pour pouvoir accéder facilement à chaque sprite.
-Edité le Dimanche 16 juillet 2006 à 21:02 par Jfg-
Kill Mario
    
./Post n°9   Marquer comme non lu.
Xantares Ecrit le: Lundi 24 juillet 2006 à 11:49 Déconnecté(e)    Voir le profil de Xantares Envoyer un email à Xantares Envoyer un message privé à Xantares  

oui j'ai finalement fait un peu comme ca :

typedef unsigned char sprite[8];

je reserve un

sprite model[6][4]

puis à l'initialisation je recopie avec des

memcpy(model[0][0],(sprite){
0b11100000,
0b10100000,
0b11100000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000},sizeof(sprite));

puis je les symetrise avec symbin(a,n) qui rend le symetrique binaire de a sur n bits

for(i=0;i<5;i++)
  {
    for(j=0;j<8;j++)
    {
      model[1][j]=symbin(model[i][0][j],;
      model[i][2][j]=model[i][0][7-j];
      model[i][3][j]=symbin(model[i][0][7-j],;
    }
  }

là pas besoin de pointeurs
merci à vous
[i]-Edité le Lundi 24 juillet 2006 à 11:50 par Xantares-
    
./Post n°10   Marquer comme non lu.
Kevin Kofler Ecrit le: Lundi 24 juillet 2006 à 16:37 Déconnecté(e)    Voir le profil de Kevin Kofler Envoyer un email à Kevin Kofler Visiter le site WEB de Kevin Kofler Envoyer un message privé à Kevin Kofler  


Tu es censé mettre (const sprite){...}, pas (sprite){...}. (Sinon, selon le standard C99, le compilateur est obligé de recopier tes données, ce qui est débile vu que le memcpy les recopie une autre fois. TIGCC ne le fait pas actuellement, mais ça pourrait changer un jour.)
Membre de l'équipe de TIGCC: http://tigcc.ticalc.org
Mainteneur du portage Linux/Unix de TIGCC: http://tigcc.ticalc.org/linux/
Membre de l'équipe de CalcForge: http://www.calcforge.org:70/

Participez à la reprise de Ti-Gen!
    
  :: Index » Forum Ti68K » Programmation C » stocker des sprites (10 réponse(s))
Pages : 1/1     « [1] » »|

.Répondre à ce sujet
Les boutons de code
[B]old[I]talic[U]nderline[S]trikethrough[L]ine Flip Hori[Z]ontallyFlip [V]erticallySha[D]ow[G]low[S]poilerCode [G][C]ite
Bullet [L]istList Item [K] Link [H][E]mail[P]icture SmileysHelp
Couleurs :
Saisissez votre message
Activer les smileys
     

Forum de Ti-Gen v3.0 Copyright ©2004 by Geoffrey ANNEHEIM
Webmaster: Kevin KOFLER, Content Admins: list, Server Admins: Tyler CASSIDY and Kevin KOFLER, DNS Admin: squalyl
Page générée en 58.36ms avec 18 requetes