Bonjour à tous,

Je suis de moins en moins sur les sites Amiga, désolé, en plus je programme de moins en moins, sauf pour la création de routine, je n'aurais pas le temps de créer des jeux complet ou des utilitaires complet :-( ... Pas pour le moment en tous cas. Mais, je me libère un peut de temps pour coder des routines sympa, histoire de pas perdre la main.

Donc, voici mon Problème, je fais appel aux programmeurs de talent en 3D. Je cherche a créer une routine pour générer une map 3D style Zeewolf, si je me rappel bien, c'est un assemblage de carré (ou de triangle). J'ai déjà une routine 3D (merci Mr Thellier) pour hollywood. Mais savez vous ou je peux trouver un code source simple (a comprendre) pour créer une Map 3D en 3D vectorielle, pas de gouraud, pas d'effet de lumière ou quoi d'autre que se soit, du 3D vectorielle simple... En fait, je cherche a créer un moteur 3D pour lequel (plus tard) je pourrais créer des petits jeux style No second prize, Zeewolf, etc... L'IA, c'est bon, je connais pas mal de combine pour les shoots, course de voiture/véhicule, plate forme, c'est assez simple, mais pour le moment, je cherche juste des moteur 3D et 2D.

Si vous avez des sources ou des idées, se serait sympa de me les mettre sur se file de discussion.

ATTENTION: Je ne coderais pas un jeux complet, juste des routine, dont évidement, je donnerais les sources pour que mes collègues hollywoodiens puissent en profiter.

Merci d'avance a tous.

Biz

Quelques exemples, pas forcément utilisables tels quels mais ça peut peut-être aidé :
http://lodbook.com/source/
http://www.andreavb.com/forum/database/index.php?action=showmod&mod=165
http://www-cs-students.stanford.edu/~amitp/game-programming/polygon-map-generation/

@elwood
Très sympas tes liens.

@artblink
Malheureusement, je crains que si tu veux faire une version moderne d'un moteur graphique à la zeewolf, et les liens de Elwood sont un bon point de départ, Hollywood n'est pas adapté et bien trop lent :-(

Merci elwood, sympa le deuxième lien car il y a plein d'autre source en VB :=!

@Seblam:

Hollywood n'est pas si lent que sa... Depuis la version Infinity, le double buffer en hard est excellent pour créer des moteurs 2D a l'aide de Brosse (Brush()), le gain est impressionnant.

Il est aujourd'hui possible de créer un shoot, par exemple, avec scrolling parallaxe+ effet de transparence (avec la transparence, on peut bidouiller un effet de lumière basique mais sympa) et le tous en 640x480. Bon oui, sa vaux pas grand chose face aux jeux PC en 1800x1800, mais sa peut être amusant.

J'ai l'impression que beaucoup de monde se base sur les programme créé avec Hollywood, mais pour "tra?ner" sur le forum hollywood, très peux cherche l'optimisation, juste que sa fonctionne. Automatiquement, il est difficile de se rendre compte de se que peux générer un programme créé avec Hollywood en terme de vitesse. Mon scrolling multidirectionnel avec la voiture est plutôt très fluide... Non? avec l'effet de transparence sur le compteur, la rotation en temps réelle de la voiture et le tous en 640x480 et SANS l'accélération Hard de Infinity. D'ailleurs le dernier moteur ne profite pas d'accélération car je créer des brush a partir d'une autre brush et l'accélération Hard ne fonctionne qu'AVEC des brush charger et non créer depuis le programme, sa bloque sans prévenir l'accélération hard... Dommage qu'il n'y ai pas l'affichage de l'erreur.

Se qui compte avant tous avec Hollywood, c'est de créer, même des pales copie de moteurs vieux de plus de 20 ans... Créer moi même... c'est Fun ;-)

Hello

je dirai que le plus simple c'est de faire ça comme un jeu d'échec vu de coté=
Tu fais un tableau genre tab1[100][100]
Pour chaque case tu stocke un numéro d'objet 3D à afficher
Genre si c'est 1 t'affiche une porte,2 un mur etc...
tu fais un 2 éme tableau de même taille ou tu stocke les coordonnées x y z des cases de l'échiquier
for(m=0;m<100;m++)
for(n=0;n<100;n++)
{
tab2[m][n].x=(n-50)*20;
tab2[m][n].y=0;
tab2[m][n].z=(m-50)*20;
}
Note: je fais -50 pour que le tableau soit centré à 0 0
et je multiplie par 20 (par exemple) = dimension des cases de l'échiquier

Tu transforme ce tableau (les x y z) selon le point de vue de l'observateur (genre rotation en Y)
Ensuite tu affiche tout les objets dont les cases sont dans l'écran
cad 0<=x ,x<640 ,0<=y,y<480
en transformant ces objets de la même manière (genre rotation en Y)
à leur position x y z respectives

Voilà l'idée


Alain

Salut Alain,

C'est se que j'ai fait, un tableau (comme pour un scroll 2D). Par contre, j'utilise juste un carré pour faire le sol (je veux juste faire le sol), hors, à l'affichage, les carrés sont tous identique, les cotés des carré se sont pas confondues, mais se croisent, j'ai l'impression qu'il me manque un point, ou une coordonnée vers laquelle tous les carrés (ou triangle) formant le sol soit orienté... pour formé un sol 3D lisse

J'ai même créé un tableau de niveau (l'élévation du sol.. pour faire des petites pentes ;-) ), sa par contre, sa fonctionne pas trop mal, enfin, je crois :-p

Je vais bidouiller... la source VB est bien, mais pas sûr que se soit adaptable sur hollywood, ou plutôt, j'ai pas encore trouvé :-D

Il faut que t'applique ta transformation (rotation selon y) a tes "carrés" et aussi ta transformation de perspective

Voici une partie de code qui vient de Aminet/cow3D

je t'explique qques notions de 3D "appliquer une transformation" veut dire multiplier des vecteur par une matrice
des vecteurs sont une liste de valeurs x y z
une matrice est un tableau [4][4] de float

Dans ce qui suit tu a par exemple SetMry() qui crée une matrice de rotation selon y (axe vertical)
SetMry s'appuye sur SetRot() qui crée une matrice Mr de rotation quelconque
(on comprend aisément que faire une Mr selon x ou y ou z va se ressembler)

Après tu a TransformP() qui "applique une transformation" dans le cas général
cad multiplie ta matrice Mry et tes points x y z dans ton cas

mais pour le cas simple d'une Mry il vaut mieux utiliser YrotateP() qui en enlevant
toutes les multiplications par 1 ou 0 de TransformP() simplifie la formule

Ensuite tu a ProjectP qui met tes points x y z à l'échelle de l'écran
cad les centre et les multiplie par la taille de l'écran
ceci car généralement en 3D on travaille sur des valeurs "normalisées" pour x y z s'étalant en -1.0 et + 1.0
donc il faut les redimensionner/centrer pour avoir des coordonnées en pixels

dans ton cas il faudrait en plus appliquer une perspective cad réduire x et y selon z. Or z qui est la profondeur vaut 0 au niveau de l'écran et 1 à l'horizon
donc faire (J'ai pas de listing sous la main) plutot qque chose comme ça (avec persp une valeur de perpective à déterminer selon l'effet voulu)

NLOOP(Pnb)
{
x=P->x;y=P->y;z=P->z;
if(z==0.0) z=0.0001; /* evite division par 0*/
P->x= persp*x*sizex/z+sizex;
P->y= persp*y*sizey/z+sizey;
P->z= z*sizez+sizez;
P++;
}




/*=================================================================*/
void SetMrot(float *M,float R ,UBYTE a,UBYTE b,UBYTE c,UBYTE d)
{ /* define a rotation matrix */
float Pi =3.1416;
WORD n;
if(M==NULL) return;
M[0]=M[5]=M[10]=M[15]= 1.0; M[1]=M[2]=M[3]=M[4]=M[6]=M[7]=M[8]=M[9]=M[11]=M[12]=M[13]=M[14]=0.0;
if(R==0.0) return;
if(R>=360.0)
{n=R/360.0; R=R-n*360.0;}
if(R<0.0)
{n=1+R/360.0;R=R-n*360.0;}
R= R / 180.0 * Pi;
M[a] = (float)cos(R);
M[b] = M[a];
M[c] = (float)sin(R);
M[d] = -M[c];
}
/*=================================================================*/
void SetMrx(float *M,float x) /* define X rotation matrix */
{ SetMrot(M,x,5,10,6,9); }
/*=================================================================*/
void SetMry(float *M,float y) /* define Y rotation matrix */
{ SetMrot(M,y,10,0,8,2); }
/*=================================================================*/
void SetMrz(float *M,float z) /* define Z rotation matrix */
{ SetMrot(M,z,0,5,1,4); }
/*=================================================================*/
void TransformP(register float *M,struct point3D *P,LONG Pnb)
{ /* transform points with a given matrix */
register float x;
register float y;
register float z;
register LONG n;

NLOOP(Pnb)
{
x=P->x;y=P->y;z=P->z;
P->x= M[0]*x + M[4]*y+ M[8] *z+ M[12];
P->y= M[1]*x + M[5]*y+ M[9] *z+ M[13];
P->z= M[2]*x + M[6]*y+ M[10]*z+ M[14];
P++;
}
}
/*=================================================================*/
void YrotateP(register float *M,struct point3D *P,LONG Pnb)
{ /* y rotate points with a given matrix : optimized TransformP() */
register float x;
register float z;
register float m0 =M[0];
register float m8 =M[8];
register float m2 =M[2];
register float m10=M[10];
register LONG n;

NLOOP(Pnb)
{
x=P->x;z=P->z;
P->x= m0*x + m8 *z;
P->z= m2*x + m10*z;
P++;
}
}
/*=================================================================*/
void ProjectP(struct point3D *P,LONG Pnb)
{ /* project points to screen-coordinates */
register float x;
register float y;
register float z;
register float sizex=LARGE/2.0;
register float sizey=HIGH /2.0;
register float sizez=1.0/2.0;
register LONG n;

NLOOP(Pnb)
{
x=P->x;y=P->y;z=P->z;
P->x= x*sizex+sizex;
P->y= y*sizey+sizey;
P->z= z*sizez+sizez;
P++;
}
}

Salut Alain,

Merci, mais il faut que j'analyse ton code... :-D :-D :-D :-D :-D

Oula .... sa claque comme dirait l'autre, laisse moi le temps d'analyser, je te fais un code la dessus et je le post.

Merci merci l'ami ;-) :-o