Aller au menu - Aller au contenu

Icône La 3D

Avatar
Avatar
Par Avatar PODS et Avatar Gambit2099 et Avatar Gautier Berthou (snake_48)
Mise à jour : 14/10/2009
Difficulté : Intermédiaire Intermédiaire
282 visites depuis 7 jours, classé 354/786
Vous ne pensiez tout de même pas en rester à la 2D ! Nous allons donc voir comment créer un jeu en 3D ^^ .
Vous devez avoir acquis les 5 premiers chapitre de Créez des programmes en 3D avec OpenGL (de Kayl) car nous utiliserons des fonctions d'OpenGL.
Retour en haut
Sommaire du tutoriel :
Icône du chapitre
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Les bases

PALib ne gère pas la 3D. Il faudra donc passer par une bibliothèque utilisée par PALib mais de plus bas niveau (en tout cas, la 3D est de haut niveau, mais pas le reste ^^ ), la libnds. La 3D ne peut être utilisée uniquement sur l'écran tactile. Il faut tout d'abord initialiser OpenGL avec void glInit(); . Ensuite, on va définir notre caméra en plein écran avec void glViewport(uint8 x1, uint8 y1, uint8 x2, uint8 y2); , nous allons tout le temps l'utiliser comme ceci :
Code : C
1
glViewport(0,0,255,191);

Puis il faut définir une couleur de rafraichissement opaque avec void glClearColor(uint8 r, uint8 g, uint8 b, uint8 a); où r, g, b et a correspondent aux valeurs RGBA de la couleur (31 est la valeur maximale). Donc, si on veut que le fond soit noir (et opaque), il faudra écrire :
Code : C
1
glClearColor(0,0,0,31);

Puis, on définit la perspective (exactement pareil qu'OpenGL sur ordinateur) :
Code : C
1
2
3
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(70,(double)256/192,0.1,1000);

Et là, si vous voulez que votre scène ait un rendu, il faut écrire cette ligne :
Code : C
1
glPolyFmt(POLY_ALPHA(31) | POLY_CULL_NONE );

Dans la boucle, l'écran exécute automatiquement le clear, donc nous n'avons pas besoin de le mettre.
Alors nous n'avons plus qu'à mettre :
Code : C
1
2
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();

Et à définir la position, la trajectoire et la verticale de la caméra comme sur ordinateur avec :
Code : C
1
void gluLookAt(float eyex, float eyey, float eyez,float lookAtx, float lookAty, float lookAtz, float upx, float upy, float upz);


Vous pouvez ensuite programmer la scène comme bon vous chante, les fonctions étant les mêmes que sur ordinateur.
La libnds ne prend pas en compte les fonctions ayant le suffixe "d" (prenant des doubles comme argument), il faudra donc utiliser les fonctions ayant le suffixe "f" (flottants). Et le suffixe "ub" a été remplacé par le suffixe "b".
Il faut faire attention aussi à une chose : la couleur donnée à glClearColor est constituée de valeurs comprises entre 0 et 31 inclus, alors que la couleur donnée aux autres fonctions comme glColor3b est constituée de valeurs comprises entre 0 et 255 inclus.

Pour afficher la scène il faut faire :
Code : C
1
glFlush(0);

Et il ne reste qu'à mettre PA_WaitForVBL :) !
Voici un code d'exemple (dessin trouvé dans le tuto de Kayl) :
Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#include <PA9.h>

#define LARGEUR_ECRAN 256
#define HAUTEUR_ECRAN 192

int main(int argc, char ** argv)
{
	int i=0;
	
	PA_Init();
	PA_InitVBL();
	
	videoSetMode(MODE_0_3D);
	
	glInit();
	
	glViewport(0,0,LARGEUR_ECRAN-1,HAUTEUR_ECRAN-1);
	
	glClearColor(0,0,0,31);
	
	glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(70,(double)LARGEUR_ECRAN/HAUTEUR_ECRAN,.1,1000);
    
    glPolyFmt(POLY_ALPHA(31) | POLY_CULL_NONE );
	
	while(1)
	{
		glMatrixMode( GL_MODELVIEW );
		glLoadIdentity( );

		gluLookAt(3,4,2,0,0,0,0,0,1);
		
		glRotatef(i,0,0,1);

	    glBegin(GL_QUADS);

		    glColor3b(255,0,0); //face rouge
		    glVertex3f(1,1,1);
		    glVertex3f(1,1,-1);
		    glVertex3f(-1,1,-1);
		    glVertex3f(-1,1,1);

		    glColor3b(0,255,0); //face verte
		    glVertex3f(1,-1,1);
		    glVertex3f(1,-1,-1);
		    glVertex3f(1,1,-1);
		    glVertex3f(1,1,1);

		    glColor3b(0,0,255); //face bleue
		    glVertex3f(-1,-1,1);
		    glVertex3f(-1,-1,-1);
		    glVertex3f(1,-1,-1);
		    glVertex3f(1,-1,1);

		    glColor3b(255,255,0); //face jaune
		    glVertex3f(-1,1,1);
		    glVertex3f(-1,1,-1);
		    glVertex3f(-1,-1,-1);
		    glVertex3f(-1,-1,1);

		    glColor3b(0,255,255); //face cyan
		    glVertex3f(1,1,-1);
		    glVertex3f(1,-1,-1);
		    glVertex3f(-1,-1,-1);
		    glVertex3f(-1,1,-1);
			
		    glColor3b(255,0,255); //face magenta
		    glVertex3f(1,-1,1);
		    glVertex3f(1,1,1);
		    glVertex3f(-1,1,1);
		    glVertex3f(-1,-1,1);

		glEnd();

		i++;
		i%=360;

		glFlush(0);
		PA_WaitForVBL();
	}
	return 0;
}

Et vous obtenez un beu cube multicolore qui tourne sur son axe Z ^^ .

Les quadriques ne sont pas implémentées avec la libnds, il faudra donc les coder vous-même :) .
Retour en haut

Les textures

Alors là, les choses se compliquent (j'ai passé une semaine à jouer aux 7 erreurs pour trouver comment créer une texture :-° ).

Créer la texture



Nous allons commencer par créer un dossier "data" dans le dossier de votre projet, c'est-à-dire là où se trouve build.bat.
Ensuite, il faut télécharger le logiciel Gimp.

Si vous ne voulez pas télécharger un logiciel aussi lourd et gourmand que Gimp, tournez-vous plutôt vers XnView... L'interface est presque la même pour ce qui est du tuto.


Une fois installé, lancez-le et faites Ctrl+N (nouveau). Définissez le format de l'image à 128x128. Cliquez sur "Options avancées", choisissez 72,000 pour la résolution X et Y. Mettez "Couleur RVB" pour "Espace de couleurs" et "Blanc" pour "Remplir avec".

Image utilisateur

Faites votre dessin, puis faites Image -> Mode -> Couleurs Indexées :
Image utilisateur
Un fenêtre apparaît alors. Cochez "Générer une palette optimale", et mettez 255 à "Nombre maximal de couleurs" :
Image utilisateur
Il ne vous reste plus, ensuite, qu'à enregistrer l'image dans le dossier data, en mettant l'extension .pcx à votre fichier.

Charger la texture



Sachez que la mémoire graphique de la DS s'exprime, entre autres, par des VRAM.
Nous allons donc initialiser le système de textures avec :
Code : C
1
vramSetMainBanks(VRAM_A_TEXTURE,VRAM_B_TEXTURE,VRAM_C_LCD,VRAM_D_LCD);

Comme ça, les VRAM A et B sont déclarées en mode texture, et les C et D sont normales. Vous pouvez y aller en tatonnant ^^ . Si certaines textures ne s'affichent pas, c'est qu'il n'y a pas assez de mémoire texture, donc vous pouvez initialiser d'autres VRAM en mode texture.
Puis, on active le système de textures :
Code : C
1
glEnable(GL_TEXTURE_2D);

Et maintenant, on va charger la texture (ellse s'appelle tex_1.pcx).
Mais il faut définir une taille. Les constantes se trouvent dans l'énumération GL_TEXTURE_SIZE_ENUM. Cette-dernière contient (liste complète) :
  • TEXTURE_SIZE_8
  • TEXTURE_SIZE_16
  • TEXTURE_SIZE_32
  • TEXTURE_SIZE_64
  • TEXTURE_SIZE_128
  • TEXTURE_SIZE_256
  • TEXTURE_SIZE_512
  • TEXTURE_SIZE_1024

Il faudra fournir d'abord la largeur, puis la hauteur. Ici, nos textures ne sont que des carrés de 128*128 ; donc nous mettrons deux fois TEXTURE_SIZE_128.
Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
#include "tex_1.h"
int texture; // Contiendra notre texture
sImage pcx; // Représente l'image
loadPCX((u8*)tex_1, &pcx); // On charge l'image
image8to16(&pcx); // Obligatoire sinon un rendu bizarre :)
// On alloue de la mémoire pour la texture
glGenTextures(1, &texture);
glBindTexture(0, texture);
// On crée la texture
glTexImage2D(0, 0, GL_RGB, TEXTURE_SIZE_128 , TEXTURE_SIZE_128, 0, TEXGEN_TEXCOORD, pcx.image.data8);
imageDestroy(&pcx); // On détruit l'image (mais pas la texture :p )

Remarquez que le header est le nom du fichier sans ".pcx", et à la place on a l'extension ".h". La variable contenant l'image est le nom du fichier sans ".pcx".


Ensuite, pour définir la texture courante, on fait :
Code : C
1
glBindTexture(GL_TEXTURE_2D, texture);

Et pour appliquer des coordonnées d'une texture sur un sommet, il suffit de faire :
Code : C
1
glTexCoord2f(x,y);  glVertex3f(x1,y1,z);


Bonne nouvelle, j'ai créé une fonction toute simple qui retourne une texture :
Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
int chargerTexture(const u8 *tex,GL_TEXTURE_SIZE_ENUM width,GL_TEXTURE_SIZE_ENUM height)
{
    sImage pcx;
    int texture;
    loadPCX((u8*)tex, &pcx);
    image8to16(&pcx);
    glGenTextures(1, &texture);
    glBindTexture(0, texture);
    glTexImage2D(0, 0, GL_RGB, width , height, 0, TEXGEN_TEXCOORD, pcx.image.data8);
    imageDestroy(&pcx);
    return texture;
}

Voici comment elle s'utilise :
Code : C
1
2
#include "tex_1.h" // La texture
int texture=chargerTexture(tex_1,TEXTURE_SIZE_128,TEXTURE_SIZE_128);


Voici un pack de textures que j'ai programmé pour le cube (les textures sont donc censées être parfaites :) ) : télécharger le pack.
Et un code pour vous montrer que c'est facile :
Code : C
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
#include <PA9.h>

#include "tex_1.h"
#include "tex_2.h"
#include "tex_3.h"
#include "tex_4.h"
#include "tex_5.h"
#include "tex_6.h"

#define LARGEUR_ECRAN 256
#define HAUTEUR_ECRAN 192

int chargerTexture(const u8 *tex,GL_TEXTURE_SIZE_ENUM width,GL_TEXTURE_SIZE_ENUM height);

int main(int argc, char ** argv)
{
	int x1=0,x2=0,y1=0,y2=0,c=0;
	int texture[6];
	float rotationX=0.,rotationZ=0.;
	
	PA_Init();
	PA_InitVBL();
	
	videoSetMode(MODE_0_3D);
	vramSetMainBanks(VRAM_A_TEXTURE,VRAM_B_TEXTURE,VRAM_C_LCD,VRAM_D_LCD);
	
	glInit();
	
	glEnable(GL_TEXTURE_2D);
	
	glViewport(0,0,LARGEUR_ECRAN-1,HAUTEUR_ECRAN-1);
	
	glClearColor(0,0,0,31);
	
	texture[0]=chargerTexture(tex_1,TEXTURE_SIZE_128,TEXTURE_SIZE_128);
	texture[1]=chargerTexture(tex_2,TEXTURE_SIZE_128,TEXTURE_SIZE_128);
	texture[2]=chargerTexture(tex_3,TEXTURE_SIZE_128,TEXTURE_SIZE_128);
	texture[3]=chargerTexture(tex_4,TEXTURE_SIZE_128,TEXTURE_SIZE_128);
	texture[4]=chargerTexture(tex_5,TEXTURE_SIZE_128,TEXTURE_SIZE_128);
	texture[5]=chargerTexture(tex_6,TEXTURE_SIZE_128,TEXTURE_SIZE_128);

	glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(70,(double)LARGEUR_ECRAN/HAUTEUR_ECRAN,.1,1000);
    
    glPolyFmt(POLY_ALPHA(31) | POLY_CULL_NONE );
	
	while(1)
	{
		glMatrixMode( GL_MODELVIEW );
		glLoadIdentity( );

		gluLookAt(3,4,2,0,0,0,0,0,1);
		
		glRotatef(rotationX,1,0,0);
		glRotatef(rotationZ,0,0,1);
		
		glColor3b(255,255,255);
		
		glBindTexture(GL_TEXTURE_2D, texture[0]);

	    glBegin(GL_QUADS);
		    glTexCoord2f(0,0);glVertex3f(1,1,1);
		    glTexCoord2f(0,1);glVertex3f(1,1,-1);
		    glTexCoord2f(1,1);glVertex3f(-1,1,-1);
		    glTexCoord2f(1,0);glVertex3f(-1,1,1);
		glEnd();
		
		glBindTexture(GL_TEXTURE_2D, texture[1]);
		
		glBegin(GL_QUADS);
		    glTexCoord2f(0,0);glVertex3f(1,-1,1);
		    glTexCoord2f(0,1);glVertex3f(1,-1,-1);
		    glTexCoord2f(1,1);glVertex3f(1,1,-1);
		    glTexCoord2f(1,0);glVertex3f(1,1,1);
		glEnd();
		
		glBindTexture(GL_TEXTURE_2D, texture[5]);
		
		glBegin(GL_QUADS);
		    glTexCoord2f(0,0);glVertex3f(-1,-1,1);
		    glTexCoord2f(0,1);glVertex3f(-1,-1,-1);
		    glTexCoord2f(1,1);glVertex3f(1,-1,-1);
		    glTexCoord2f(1,0);glVertex3f(1,-1,1);
		glEnd();
		
		glBindTexture(GL_TEXTURE_2D, texture[4]);
		
		glBegin(GL_QUADS);
		    glTexCoord2f(0,0);glVertex3f(-1,1,1);
		    glTexCoord2f(0,1);glVertex3f(-1,1,-1);
		    glTexCoord2f(1,1);glVertex3f(-1,-1,-1);
		    glTexCoord2f(1,0);glVertex3f(-1,-1,1);
		glEnd();
		
		glBindTexture(GL_TEXTURE_2D, texture[2]);
		
		glBegin(GL_QUADS);
		    glTexCoord2f(0,0);glVertex3f(1,1,-1);
		    glTexCoord2f(0,1);glVertex3f(1,-1,-1);
		    glTexCoord2f(1,1);glVertex3f(-1,-1,-1);
		    glTexCoord2f(1,0);glVertex3f(-1,1,-1);
		glEnd();
		
		glBindTexture(GL_TEXTURE_2D, texture[3]);
		
		glBegin(GL_QUADS);
		    glTexCoord2f(0,0);glVertex3f(1,-1,1);
		    glTexCoord2f(0,1);glVertex3f(1,1,1);
		    glTexCoord2f(1,1);glVertex3f(-1,1,1);
		    glTexCoord2f(1,0);glVertex3f(-1,-1,1);
		glEnd();
		
		if(Stylus.Held)
		{
			if(!(c%2))
			{
				x1=Stylus.X;
				y1=Stylus.Y;
			}
			else
			{
				x2=Stylus.X;
				y2=Stylus.Y;
				rotationZ+=x1-x2;
				rotationX+=(y2-y1)*LARGEUR_ECRAN/HAUTEUR_ECRAN;
			}
			c++;
		}
		else if(Stylus.Released)
			c=0;
		glFlush(0);
		PA_WaitForVBL();
	}
	return 0;
}

int chargerTexture(const u8 *tex,GL_TEXTURE_SIZE_ENUM width,GL_TEXTURE_SIZE_ENUM height)
{
    sImage pcx;
    int texture;
    loadPCX((u8*)tex, &pcx);
    image8to16(&pcx);
    glGenTextures(1, &texture);
    glBindTexture(0, texture);
    glTexImage2D(0, 0, GL_RGB, width , height, 0, TEXGEN_TEXCOORD, pcx.image.data8);
    imageDestroy(&pcx);
    return texture;
}


Pour cet exemple, il n'y avait que 6 textures. Mais pour vos futures créations, vous aurez sûrement besoin de plus de textures. Donc il faudra investir dans l'UV-Mapping (image ou groupe d'images regroupant toutes les textures).
Retour en haut

Charger des modèles

Le fait de coder point par point vous fait fuir ? Nous allons voir ici comment charger des fichiers .obj.


Charger des modèles de façon statique



J'ai développé un logiciel (dont le fonctionnement peut-être comparé avec PAGfx) qui code votre fichier .obj en fichiers .h et .cpp. Ne vous arrêtez pas à l'extension, le code que les fichiers contiennent est compatible C et C++... Pour le télécharger c'est ici. Son petit nom est Obj2NDS. Etonnant, non ;) ?

Le logiciel a ses limites : il n'exporte pas les normales, seule une texture est acceptée, et les matériaux autres que texture (couleurs, etc.) sont ignorés...


Comment ça fonctionne ?


Pour simplifier les explications, nous allons partir du principe que nous avons un fichier cube.obj (en bleu ce qui change en fonction du nom du fichier .obj).
Lancez le programme. Suivez les instructions (pour les tailles, ce sont celles qui correspondent à TEXTURE_SIZE_XXX). Ensuite vous aurez deux fichiers (cubeOBJ.cpp et cubeOBJ.h) dans le dossier du logiciel. Il faut les copier dans votre dossier source. Puis, comme pour les programmes précédents, il faut créer un dossier data et y mettre votre texture (n'oubliez pas qu'elle doit être au format .pcx et doit contenir 255 couleurs).
Dans votre fichier main, il faut inclure le fichier cubeOBJcpp.
Ce n'est pas tout, il faut initialiser la texture du modèle en faisant un appel à la fonction : Citation
void initTexCube();

Enfin, pour dessiner votre modèle, il faut faire un appel à la fonction :
Citation
void dessinerCube();


Même si vous avez écrit "cube" en minuscules, pour les fonctions d'initialisation et de dessin du cube, l'initiale sera en majuscule (ce n'est pas une faute d'inattention de ma part ^^ ).



Charger des modèles de façon dynamique



Ici, nous allons voir utiliser une petite lib que j'ai programmée qui charge votre fichier .obj dynamiquement. Pour commencer, il faut la télécharger ici. Puis, on extrait les deux fichiers dans le dossier source. Enfin, on inclut le header comme ceci :
Code : C
1
#include "OBJlib.h"
(le fichier .c sera inclu lors de la compilation, automatiquement).

Nous allons créer une variable qui contiendra notre modèle comme ceci :
Code : C
1
MeshObj obj;

Puis on charge le modèle avec int charger_obj(MeshObj *modele,char *nom,int largeur,int hauteur); , où modele est la variable qui recevra le modèle, nom le nom du fichier, largeur et hauteur les constante de OpenGL TEXTURE_SIZE_XXX.
En reprenant notre exemple, nous avons un code du genre :
Code : C
1
charger_obj(&obj,"modele.obj",TEXTURE_SIZE_128,TEXTURE_SIZE_128);


Enfin, pour dessiner votre modèle, il faudra appeler void draw_model(MeshObj *modele); .
Cette fonction ne fait que dessiner votre modèle, vous pouvez donc appliquer des modifications de matrice (changement d'échelle, translation, rotation, etc.).

Voilà, bonne modélisation ;) !
Retour en haut
Voilà, alors maintenant faites-moi de beaux jeux en 3D !
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Partager

Retour en haut
12 commentaires pour "La 3D"
Note moyenne : 3.57 / 4 (65 votes)
Pseudo Commentaire
Hors ligne jojo1000 # Posté le 26/10/2010 à 15:07:06

bonjour, voilà j'ai le méme problème que xem.
A la compilation la commande windows indique: expected declaration specifier... patati patata before GL_TEXTURE_SIZE_ENUM
et je n'arrive pas à faire fonctionner le code
Hors ligne redwarp # Posté le 02/11/2010 à 22:33:27

#jojo1000
Je viens d'avoir le même problème. Le problème vient du fichier VideoGL.h
(dans ton dossier devkitpro/libnds/include/nds/arm9/videoGL.h)
Remplace
Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
enum GL_TEXTURE_SIZE_ENUM  {
	TEXTURE_SIZE_8    = 0, /*!< 8 texels */
	TEXTURE_SIZE_16   = 1, /*!< 16 texels */ 
	TEXTURE_SIZE_32   = 2, /*!< 32 texels */
	TEXTURE_SIZE_64   = 3, /*!< 64 texels */
	TEXTURE_SIZE_128  = 4, /*!< 128 texels */
	TEXTURE_SIZE_256  = 5, /*!< 256 texels */
	TEXTURE_SIZE_512  = 6, /*!< 512 texels */
	TEXTURE_SIZE_1024 = 7  /*!< 1024 texels */
};

par
Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
typedef enum  {
	TEXTURE_SIZE_8    = 0, /*!< 8 texels */
	TEXTURE_SIZE_16   = 1, /*!< 16 texels */ 
	TEXTURE_SIZE_32   = 2, /*!< 32 texels */
	TEXTURE_SIZE_64   = 3, /*!< 64 texels */
	TEXTURE_SIZE_128  = 4, /*!< 128 texels */
	TEXTURE_SIZE_256  = 5, /*!< 256 texels */
	TEXTURE_SIZE_512  = 6, /*!< 512 texels */
	TEXTURE_SIZE_1024 = 7  /*!< 1024 texels */
}GL_TEXTURE_SIZE_ENUM;

et ça devrait faire l'affaire !
Hors ligne Aire-One # Posté le 26/04/2012 à 20:19:43
<(¤v¤)>

Avis : Très bon

Trés bon chapitre !
Mais dommage que mégaupload ai fermé... Pas moyen d'avoir ce logiciel prometteur autrement ?
Reflets d'acide, la saga MP3 culte !
N'hésitez pas à me contacter
C: SDL, FMOD, (PAlib)
C++: PAlib, Qt, OpenGL
Batch (Makefile)
(xHTML/CSS + (PHP, Javascipt) occasionnellement :-° )
 
Hors ligne snake_48 # Posté le 26/04/2012 à 22:10:03
Il me manque un bit.
Avatar

Études : INSA Lyon

 Erf désolé je ne sais pas ce que j'en ai fait (en plus je ne suis pas sur l'ordi avec lequel je l'ai développé). Je sais que je me suis basé sur mon loader dont la dernière version online se trouve dans mon tuto. Il suffira d'adapter quelques fonctions pour que ça fonctionne sur DS mais c'est le même principe.
Programmez sur votre Wii ! | Programmez sur votre Nintendo DS ! | Charger des fichiers .OBJ | Introduction au scripting avec Python
Création d'un moteur physique (en cours)
Code Lyoko Strategy Game Coder
Langages connus : AS3, Batch, C, C++, HTML, Java, Javascript, PHP, Python.
Programme sur : PC, Nintendo DS, Wii.
o----}=========>
 
Hors ligne Aire-One # Posté le 27/04/2012 à 21:08:44
<(¤v¤)>

Avis : Très bon

Ok ça marche comme ça, je vais me débrouiller !
Trés bonne idée de lib ça et le tuto semble être bien expliqué, je devrais pas y passer trop de temps ;)

Merci à toi !


EDIT:
Merci aussi pour cette réponse trés rapide :magicien: !
Reflets d'acide, la saga MP3 culte !
N'hésitez pas à me contacter
C: SDL, FMOD, (PAlib)
C++: PAlib, Qt, OpenGL
Batch (Makefile)
(xHTML/CSS + (PHP, Javascipt) occasionnellement :-° )
 

Voir tous les commentaires