Discussion :

[Paphytos]

Bonjour,

Je développe des jeux vidéo en Java depuis quelques années et aujourd'hui je passe à OpenGL. J'ai hésité entre LWGJL et JOGL et ai finalement choisis le second pour sont côté objets.

J'aimerais dessiner les textures de mon jeux avec OpenGL, mais j'ai des difficulté à utilisé ce nouvel outils. Je voudrais charger une image, la mettre en tampon dans la carte graphique et l'utiliser quand j'en ai besoin. J'ai écumé les le net pour trouver un exemple de base de ce code dans un programme en fonctionnement mais je n'ai rien trouvé.
La plupart des tutoriels sur OpenGL présupposent qu'on sait déjà depuis longtemps comme afficher une bête image 2D ou alors s’appuient sur une autre librairie ou un autre langage.

Auriez vous un bout de code à m'indiquer ou à me filer ?

Petite précision, ce code ci ;
(Tex encapsule la bufferedImage ainsi que la texture)

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
	public void drawTexture(Tex t, int xx, int yy, int width, int height) {
		//if(t == null) return;
		setColor(255, 255, 255);
		//drawRect(xx, yy, width, height);
 
		gl.glColor4f(r, g, b, a);
 
		yy = (-yy)+h-height;
		xx--;
 
		Texture tex = t.getTexture();
 
		if(tex == null) return;
 
		gl.glBindTexture(GL2.GL_TEXTURE_2D, tex.getTextureObject());
		tex.enable(gl);
 
		gl.glBegin(GL2.GL_QUADS);
		setColor(255, 255, 255);
		gl.glTexCoord2f(0, 1);
		gl.glVertex2f(xx, yy);
 
		gl.glTexCoord2f(1, 1);
		gl.glVertex2f(xx+width, yy);
 
		gl.glTexCoord2f(1, 0);
		gl.glVertex2f(xx+width, yy+height);
 
		gl.glTexCoord2f(0, 0);
		gl.glVertex2f(xx, yy+height);
		gl.glEnd();
		gl.glFlush();
 
		gl.glBindTexture(GL2.GL_TEXTURE_2D, 0);
	}

Le jeux ram beaucoup, et je sais que mon morceau de code n'est pas au top, je suis sur qu'il y à une meilleure façon de faire.

Merci

[LittleWhite]

Bonjour,

Si le Texture tex = t.getTexture(); provoque le chargement de la texture (à partir du disque), alors il devient évident que cela rame.
De plus, vous utilisez du OpenGL 1.X, qui est maintenant obsolète (toutefois, cela n'explique pas les ralentissements).

[Paphytos]

Voici la méthode getTexture ;

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
public Texture getTexture() {
		if(buf == null) 
			return null;
 
		if(texture == null) 
			texture = AWTTextureIO.newTexture(Game.glcanvas.getGLProfile(), buf, true);
 
		return texture;
	}

Mais finalement je suis passé à LWJGL 3, y à un peut plus de documentation et d'explications, bien que le contexte statique soit rebutant.

[EliasF00F]

Bonjour,
Que ce soit LWJGL ou JOGL, je pense que le code de la partie OpenGL doit être presque identique. Il y a un exemple en C, mais c'est assez compréhensible. J'ai appris les bases de OpenGL du tutorial qui est vraiment bon:
https://www.opengl-tutorial.org/fr/b...textured-cube/

[Paphytos]

Le code entre JOGL et LWJGL est quasiment identique, à de rares exception près, et c'est sur ce dernier point que j'ai bloqué.

Avec LWJGL j'ai réussis à faire ce que je voulais, à savoir charger une texture dans la carte graphique et la dessiner via un id ;

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

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
	public static Texture load(BufferedImage buf) {
		int w = buf.getWidth();
		int h = buf.getHeight();
 
		System.err.println(w + "," + h + "    " + buf.getType() + "   " + buf);
 
		int[] pixels = new int[w * h];
		buf.getRGB(0, 0, w, h, pixels, 0, w);
 
		ByteBuffer buffer = BufferUtils.createByteBuffer(w * h * 4);
 
		for(int y = 0; y < h; y++) {
			for(int x = 0; x < w; x++) {
				if(x + y * w >= pixels.length) break;
 
				int i = pixels[x + y * w];
 
				buffer.put((byte) ((i >> 16) & 0xFF));
				buffer.put((byte) ((i >> 8) & 0xFF));
				buffer.put((byte) ((i) & 0xFF));
				buffer.put((byte) ((i >> 24) & 0xFF));
			}
		}
 
		buffer.flip();
 
		int id = glGenTextures();
 
		glBindTexture(GL_TEXTURE_2D, id);
 
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
 
		Texture t = new Texture(w, h, id);
 
		return t;
	}

et ;

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
	public static void render(Texture t, int x, int y, int w, int h) {
		glBindTexture(GL_TEXTURE_2D, t.id);
 
		glBegin(GL_QUADS);
			glColor4f(1f, 1f, 1f, 1f);
			glTexCoord2f(0, 0); glVertex2f(x, y);
			glTexCoord2f(1, 0); glVertex2f(x + w, y);
			glTexCoord2f(1, 1); glVertex2f(x + w, y + h);
			glTexCoord2f(0, 1); glVertex2f(x, y + h);
		glEnd();
 
		glBindTexture(GL_TEXTURE_2D, 0);
	}

Si jamais ce code peut servir...

Maintenant j'avance sur monde programme et le sujet est résolu !

[dragonjoker59]

Salut !

Débuter OpenGL (API en obsolescence) par une version qui est obsolète depuis 20 ans, je trouve ça inutile, quand même.
Tu ne vas rien connaître de l'utilisation efficace d'OpenGL (sans parler des API modernes), et tu vas être vite limité par le pipeline fixe.

Suis un cours d'OpenGL moderne, à part le fait qu'ils soient en C ou en C++, les concepts OpenGL abordés seront valables en Java (quelle que soit la lib utilisée).