3D->2D - Page 3

-

Montres un coup le source de la chose ...

-

ben montre ton code ti ?!!

-

ok, bon bah.. apres que tu les ai projete a l'ecran.. tu te recupere les deux coords x et y dans l'espace ecran, normalement le z, tu le jette... ms la tu le garde.
ce que tu devrais faire, c'est modifier ton remplisseur pour qu'il texture mappe...
tu les remplis comment tes murs??

l'idee pour de l'affine mapping, c'est d'interpoler les coordonnees U et V dans la texture pour chaque point...
si t'as cette portion de mur:

a
| b
| |
| |
|/ c
d

a:
x = 0
y = 0
z = 10
U = 0
V = 0

b:
x = 15
y = 10
z = 20
U = 31
V = 0

c:
...
...

tu remplis avec des scanlines verticaux, donc tu avance d'un X a chaque scanline.. dc tu prends les X comme reference:
le segment [ab] aura une largeur X de dX = 15 - 0 = 15
la tu calcule les deltas U et V...
dU = Ub - Ua = 31 - 0 = 31
dV = Vb - Va = 0

donc pour chaque X, tu devra incrementer la position du scanline dans la texture de:
Uadd = dU / dX
Vadd = dV / dX

dans le cas de cet exemple: Uadd = 31/15 et Vadd = 0

cd pour remplir, tu fais une boucle du genre
U=Ua;
V=Va;
for (i = 0; i < dX; i++)
{
U+=Uadd;
V+=Vadd;
}

et comme je pense que les V ne changeront pas, tu peux virer tous les calculs ac les V, Vadd, etc.. garder que les U...
et ensuite, dans cette boucle, tu scale le scanline vertical en fct de la hauteur du mur abs(Y1-Y2)
ou Y1 est le Y courant de la partie haute du mur, et Y2 le Y courant de la partie basse du mur...
pour avoir Y1 et Y2, tu utilise le meme systeme d'interpolation que pour la texture, mais cette fois avec Y1add = (Yb-Ya)/dX; Y2add = (Yc-Yd)/dX, tu initialise Y1 a Ya et Y2 a Yd au debut de la boucle, et dans la boucle tu incremente Y1 ac Y1add et Y2 ac Y2 add... ensuite t'as dans la boucle ttes les infos necessaires pour dessiner ton scanline vertical: Y1,Y2 et U
dc en bref ca donne un truc du genre:

U = Ua;
Y1 = Ya;
Y2 = Yd;
dX = Xb - Xa;

Uadd = (Ub - Ua)/dX;
Y1add = (Yb - Ya)/dX;
Y2add = (Yc - Yd)/dX;

for (i = 0; i < dX; i++)
{
U += Uadd;
Y1 += Y1add;
Y2 += Y2add;

scaleVScanline(U, Y1, Y2);
}

et la fct scaleVScanline, ca etire juste entre Y1 et Y2 une colonne de la texture situee en X=U

Orion > je viens de cliquer sur le lien du zip et erreur 404 et en plus g la flemme
putain ça te coute quoi de faire un copier-coller !!!

Orion> ue, et comme ca t'as un truc super rapide, qui bug a merveille, que tu comprends rien a pkoi c fait comme ca et pas autrement, et pour les textures de vark, c'est tout sauf un texture mapping classique...

-

et elle se trouve où la fct scaleVScanline ?
bon sinon je v regarder ça ce soir, au calme parce-que là j'y pige pas bcp plus

Vark> pour le prespective mapping, tu interpole en plus entre les 1/z ...

-

Orion : t'as rien changé aux sources alors fo pas déconner qd même !

sbibi putain arrête avec tes mots compliqués !!! déjà que j'y pige pas grand chose maintenant g mal à la tête !!!!

et pis les U et V c koi comme coordonnées ? u absc et v ordonnée ?

lol, bah scaleVScanline, c un truc alacon du genre: (j'av oublie un param utile la position X a l'ecran de la scanline a dessiner , c'est en fait le compteur de boucle de la boucle de texturing )
scaleVScanline(X,U,Y1,Y2)
{
dY = Y2 - Y1;
Vadd = 32/dY
V = 0;
for (i = Y1; i < Y2; i++)
{
CopyPixel(U,V,X,i); //Xsource,Ysource,Xscreen,Yscreen
V += Vadd;
}

}

bien sur, cela va de soit, avant d'appeler toutes ces fct, tu dois d'abord trier les coords des murs, en fct de leur position..

rha...

vala ta texture:

O----> U
|
|V
V

ok?

ça va mieux

merci sBibi, je te paye à boire

au fait, pour faire un remplissage uniforme, g pensé à une méthode qui me paraît rapide, qu'en penses-tu :

bon on reprends ton mur du haut

je trace le rectangle de côté BC et après je complete les trous avec des lignes verticales


???

-

ue ca pe etre bien
tout depend comment tu remplis ton rectangle et les 2 triangles.. et tout depend aussi de ta routine de lignes horizontales

ben pour le rectangle j'utilise un truc d'extgraph très rapide modifié par mes soins pour être encore plus rapide

et pour les 2 triangles ben g le x de départ, le x d'arrivée, un côté d'ord const dc après ben algo de je c plus quoi : je descends en calculant l'ord à chaque x

c surtt la routine de lignes horizontales ki change bcp...

valà pour le rectangle : void DrawRect(short x0,short x1,short y,void* plane) { typedef union {   struct   {     unsigned char x0,y0,x1,y1;   }xy;   unsigned long l; }SCR_REC; #define ScrRectFill  _rom_call(void,(SCR_RECT*,SCR_RECT*,short),189) #define FULLSCREEN  &(SCR_RECT){{0, 0, 239, 127}} SCR_REC rect; void     (*df)(void*,void*,short); void*    parea; rect.xy.x0 = x0; rect.xy.y0 = 0; rect.xy.x1 = x1; rect.xy.y1 = y-1; parea      = ▭ df         = (void(*)(void*,void*,short))ScrRectFill; PortSet(plane,239, 127); (*df)(parea,FULLSCREEN,A_NORMAL); }

et pour les lignes qd j'en ai besoin : void vline(short y1,short y2,short x,unsigned char *plan) { register char spr= (0x80) >> (x&7); plan+= (y1<<5) - (y1+y1) +(x>>3); y2-=y1; while(y2) {   (*plan)|=spr;   plan+=30;   y2--; } }

heu ben là g que les lignes verticales, les horizontales je les utilise plus depuis que g la fct de rect ...

je disais dc, voilà les lignes : void vline(short y1,short y2,short x,unsigned char *plan) { register char spr= (0x80) >> (x&7); plan+= (y1<<5) - (y1+y1) +(x>>3); y2-=y1; while(y2) {   (*plan)|=spr;   plan+=30;   y2--; } }

heu pour les y c parce-que là j'en ai un fixe mais bon je vais remettre le second (pour l'instant il est défini ds la fct)

erf... pkoi tu remplis pas ac des lignes horiz???
et scrRecFill, c pa forcement un modele de rapidite...

ben ça allait bcp plus vite avec ça qu'avec des lignes horizontales ...

sinon pour les lignes horizontales g ça à ma disposition : #define ADRESSE(x,y) (Plane+((y)<<5)-((y)<<1)+((x)>>3)) void HLine(short x,short x2,short y,unsigned char *Plane) { unsigned char *P2 =ADRESSE(x2,y); *ADRESSE(x,y) ^= 255>>((x-1)&7); *ADRESSE(x2,y) ^= ~(255>>((x2-1)&7)); Plane=ADRESSE(x,y);       while(Plane<P2)      {           Plane++;           *Plane^=255;      } } void HLineByte(short x,short x2,short y,unsigned char *Plane) { unsigned char *P2 =ADRESSE(x2,y); Plane=ADRESSE(x,y);       while(Plane<=P2)      {           *Plane^=255;           Plane++;      } }

ben en C...
fo le faire en asm ca

ben n'hésite pas si tu peux me filer tes fonctions
(lignes vert et hrz bien entendu )

l'asm c des signes sans aucune signification pour moi