Giga-Nova > ou alors fait un algo de zoom qui grossit tes tiles
Pour la couleur de pixels, regarde dans mon programme de promenade, j´utilise ma fonction GetPixel que tu trouveras dans futils.cpp
N´oublie pas de faire un "lock" de l´image avant.

Tu peux aussi regarder mes tutos §2.3 Acces aux pixels

le lock c´est pour lire les pixel un à un si j´ai bien compris ?

pour l´algorithme qui grossit les tuiles => la flemme ^^
Puis mon niveau en math n´est que de 2nd => 1ere S s´annonce dure dure a ce qu´il parait, alors moi et les algo :/

le lock n´est pas nécessaire si ton image est stocké en VRAM, le lock va seulement transférer ton image en RAM pour qu´elle soit modifiable puis quand tu unlock il va la retransférer en VRAM.

">> pour l´algorithme qui grossit les tuiles => la flemme ^^"

alors regarde SDL_gfx, tu as des algos de zoom

">> Puis mon niveau en math n´est que de 2nd => 1ere S s´annonce dure dure a ce qu´il parait, alors moi et les algo :/"

rien à voir, j´ai pas fait de bac scientifique et pourtant je suis capable des algos de maths de niveaux Terminal S voir plus.

oui mais moi je suis un peu jeune pour des algos de tS.

Je sais que le niveau en math n´a rien avoir avec le fait de programmer, mais quand on programme on est souvent amener a faire des math ce qui augmente donc un peu notre niveau ^^´

Fvirtman >>
La fonction GetPixel
p renvoi a un nombre de bits pour chaque pixel (x;y) jusqu´a ce qu´il n´y ait plus de pixel a lire sur l´image ?

La Fonction PutPixel

renvoi a la couleur du pixel ?

Je suis désolé d´embêter avec toutes mes question mais je ne comprend pas très bien

"oui mais moi je suis un peu jeune pour des algos de tS."

Pas besoin d´être bon, SDL_gfx, te donne les fonctions déjà toute faite, que tu as simplement à utiliser sur l´image à zoomer. Regarde un peu

"Je sais que le niveau en math n´a rien avoir avec le fait de programmer, mais quand on programme on est souvent amener a faire des math ce qui augmente donc un peu notre niveau ^^´"

Les maths pour du developpement 2D reste assez limité, de plus la plus part du temps c´est pas des maths mais de la logique/physique ce qui est différent.

Tu devrais poser un peu plus les choses sur papier et réfléchir à comment faire. Au pire tu peux venir sur le chan IRC de JV pour qu´on t´aide (irc.jeuxvideo.com/cdj) -> Pub mais chut !!

GetPixel renvoie un Unsigned Long qui est la couleur du pixel courant que tu lis.

Exemple: unsigned long pixel = PhotoDeCul.GetPixel(10, 10);

dans pixel tu auras une grosse valeur sur 32bits (si ton image est en 32 bits), si c´était du blanc tu auras la valeur "1677215" car 0xFFFFFF c´est sa valeur en hexa par exemple.

PutPixel va remplacer un pixel dans l´image courrant.

Exemple : PhotodeCul.PutPixel(10, 10, 0xFF0000);

on va mettre du rouge (0xFF0000) au pixel qui est à la position 10X 10Y.

Giga-Nova > non, tu t´égares

La fonction getPixel prend une SDL_Surface s et des parametre i,j :
Tu dis quel pixel i,j tu veux sur la surface s.

ça te renvoie un unsigned long : une variable de 4 octets.
Cette variable de 4 octets représente ton pixel.
Je te conseille de travailler en 24 ou en 32 bits de profondeur de pixels (donc en 3 ou 4 octets par pixels)
Ensuite, il faut décortiquer ce ulong si tu veux récupérer le rouge, le vert et le bleu.
C´est ce que font mes petites fonctions PR(pour le rouge), PG(vert), PB(bleu)

Normalement donc, avec tout ça, tu peux extraire le pixel i,j que tu veux, et l´analyser

La fonction PutPixel fait l´inverse : tu lui donnes la surface, le i,j, et un ulong, et elle écrit le pixel sur l´image (si tu veux dessiner dessus par exemple) : donc dans ton cas, ne t´en sers pas

• si tu n´es pas familier avec le codage des pixels, regarde ma page théorique suivante :

http://perso.numericable.fr/~fvirtman/info/deim/index.html
et lis toute la partie 2D

Tu verras ainsi mieux ce que tu fais

keepsmile > Tu fais un algo de detection de "blanc" sur une "PhotodeCul"

Mais loool !! !! Tu essaie de faire un prog de detection du fait que le mec a "déja fini"

Fvirtman >> J´ai jeté un coup d´oeil, interessan pour l´explication des images 256couleurs, 16 bits 24 et 32.

De toute façon j´initialise toujours en 32, mais je me demandais si avec des .png (24 bits) je crois) sdl ne faisait pas un travail supplémentaire pour les afficher en 32 ?

keepsmile

le 0x remplace donc le # pour l´hexa, je savais pas ^^´ maintenant si . La valeur qui renvoi le unsigned long est donc un chiffre.
Comment savoir quel couleur est-ce donc ?

?? rapport avec l´hexa sachant que (d´apres mes cours de mpi xD) ca va de 0 a 15 a partir de 10 ce sont des lettres de A a F)

L´hexa est idéal pour bien séparer les octets. (c´est juste une histoire de représentation)

En effet, imgine que tu aies 245 de rouge, 152 de vert, 14 de bleu : le ulong associé sera :
245 * 256^2 + 125 * 256 + 14 = 16056320 + 32000 + 14 = 16088334

Ce dernier nombre n´est pas du tout parlant : et ne te montre pas du premier coup d´oeil les 245,152,14 que tu attends

Alors qu´en hexa : 245 -> F5, 152 -> 98, 14 -> E
le ulong associé est F5980E -> tu lis les couleurs plus facilement.

L´hexa est une éciture adaptée pour le binaire, car un chiffre hexa fait exactement 4 bits, alors qu´un chiffre décimale fait, on va dire, entre 3 et 4 bits...

plus simple en effet. ^^

j´ai déjà vu ça en cours ^^ mais de façon plus superficielle.

F != 255 ?

sinon
est-ce-que cette double boucle for me permettra de lire tous les pixels parce que j´ai vu que tu commençais a -1 mais moi je ne vois pas la grande utilité ?

for (int x = 0; x < level->w; x++)
{
for (int y = 0; y < level->h; y++)
{
GetPixel(level, x, y);
FonctionRenvoiTileCorrepondantaValeurPix

}
}

• • j´ai vu que tu avais "simplifié" les couleurs des pix en PR PV PB (PA pixel Alpha ?)

0 ne devrais pas correspondre au noir ?

F = 15
FF = 255

0 ne devrais pas correspondre au noir
--> 0 = 00 00 00 = 0 de rouge, 0 de vert, 0 de bleu = noir
En effet !

Mais apres, avec le meme principe tu peux tester d´autres couleurs ! Moi, comme j´avais juste un tile mur et un tile sol dans mon exemple, j´ai juste testé si c´était noir ou pas : c´est un raccourci

Ton for est tres bon

Pour ma part, je suis parti de -1 jusqu´a X+1, mais pas de façon absolue pour l´image (sinon ça plante), mais depuis le fenetrage de scrolling sur lequel je suis :
En fait, pour mon scrolling, je dessine un peu plus que le cadre : si tu imagine la fenetre de rendu, je dessine un peu a gauche, un peu en haut, en bas, a droite... De cette façon, meme si j´ai des tiles coupés par le bord de l´écran, je les dessine quand meme.
Bien sur, je dis que si le pixel de l´image calculé est -1, alors je mets 0 : sinon, ça plante.

en réfléchissant 5 minutes je me suis aperçu que j´avais mis x et y dans le même for (je partais don en diagonale xD)

Pour ton exemple en effet tu dois dessiner plus loin car tu a 4 directions a gérer, pour ma part je n´en ai que 2 ^^´

je commence doucement car après un prototype de pong dont les collisions étaient douteuses ^^´ c´est un de mes premier jeu stable pour l´instant parce que je n´ai pa encor géré les collisions justement..

Concrètement GetPixel(surface,x,y); va me renvoyer quoi ?
Car je dois encore coder l´affichage des tuiles
et j´aimerais savoir ce que je dois assigner dans ma fonction "aficherlestuiles"

Uint32 VERT = {0,255,0} // on a le droit ?

du genre if(valeurrenvoyerparGetPixel = VERT)

blitsuface(letilecorespondan,NULL,background,posit
ion(int x et int y)

Ps: je supose qu´il faut multiplier les int par 16 pour donner la bonne position aux tuiles sinon elle seront décalés seulement de 1 pixel..

J´ai codé cette fonction en essayant de comprendre le code de Fvirtman

void AfficherMap(SDL_Surface* surface)
{
ulong pix;

for (int i = 0; i < level->w; i++)
{
for (int j = 0; j < level->h; j++)
{
pix = GetPixel(level, i, j);

loc_tuile.x = i * WTILE;
loc_tuile.y = j * HTILE;

if(pix == 0)
SDL_BlitSurface(ground[0] , NULL, backgroundforplay, &loc_tuile);

}
}
}

Mais je ne sais pa quelle valeur pix me retourne

par exemple si j´ai un pixel noir normalement pix = 0
mais quand j´inclue la fonction dans ma boucle principale aucun tile n´apparait même en enlevant le background et en appliquant direct sur le screen

PS: H et WTILE sont définies a 16

Ptite question a propos des pointeurs : que veut dire exactement * et & . J´ai aussi assez mal compris a quoi servent les pointeurs exactement.

Pour les &, quand tu le mets devant une variable, tu renvoies l´adresse et non la valeur :
printf("L´adresse de la variable age est : %p", &age);
pour le *, il sert justement aux pointeurs. Et eux ils servent beaucoup, par exemple si tu dois faire une fonction qui renvoies deux valeurs, en faisant des pointeurs ça fonctionnera, tandis qu´en mettant les vraies valeurs ça ne fonctionnera pas.

Si tu crées une variable de cette manière :

int i = 0;

&i représente l´adresse de i en mémoire. Un pointeur, comme son nom l´indique, pointe sur une variable. Donc tu crées un pointeur (attention, il doit être du même type que la variable qu´il pointe) de cette manière :

int *pi; // crée un pointeur sur int, autrement un pointeur qui va pointer sur des variables de type int uniquement

• pi = &i; // initialise le pointeur avec l´adresse de i (le & peut servir dans le cas des références aussi mais pas la peine de te compliquer la tête avec ça, comprends déjà les pointeurs)

Donc, et c´est là qu´il faut bien lire, si ta variable i a pour valeur 0, ton pointeur pi lui, a pour valeur L´ADRESSE de i. * sert à "déréférencer" le pointeur, c´est à dire, en gros, à le faire pointeur sur la valeur de i (c´est pas tout à fait ça mais tu verras les nuances dans la pratique).
Ainsi, si tu veux modifier la valeur de i via pi, il faut écrire *pi += 2 (et donc i = 2), si tu écris pi = 2, tu vas faire pointer ton pointeur vers la case mémoire qui a l´adresse n°2 et qui sait ce que ça peut donner... ?

L´utilité ? Grande question que se posent tous les débutants je crois ^^ Tu la verras surtout en pratiquant, dès fois tu te rendras compte que seul un pointeur peut te sauver la vie ou, accessoirement, débloquer ton programme
En gros, compile ce code et exécute-le, tu comprendras :

http://rafb.net/p/d8we1K15.html

pi = &i

ou alors

• pi = i;

mais surtout pas

• pi = &i;

Car *pi est l´entier pointé par pi, c´est donc un int (tout comme i), alors que pi est un pointeur vers un entier (tout comme &i).

Beuh ?
T´es sûr ?
J´ai toujours fait comme ça et j´ai eu aucun problème... D´ailleurs je viens de vérifier sur le tuto du SdZ et il présente bien comme ça.

long age = 10;
long *pointeurSurAge = &age;

http://www.siteduzero.com/tuto-3-3828-1-a-l-assaut-des-pointeurs.html#ss_part_3