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).

[Paphytos]

Pourrais tu m'en dire plus ? Quel est la façon optimal de dessiner un jeux 2D avec la carte graphique avec Java ? Cites les noms, que je puisse faire mes recherches.

En fait j'ai codé un mmo 2D de gestion de communauté, il est presque terminé, j'ai une deadline pour le distribuer cette année. J'ai un environnement 2D top down, à l'écran y à rien de fous niveau visuel, y aura bien quelques effets mais il jeux marchait déjà assez bien avec swing. J'ai besoin d'utiliser spécialement de l'OpenGL dernier cri pour distribuer normalement le jeux ou es-ce que ce que j'ai la sera distribuable ?

[Paphytos]

Salut !
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).

J'ai commencé ton tutoriel moderne. C'est pas les concepts qu'il me manque, mais le code qui me permets de les utiliser avec LWJGL...

Par exemple, je vois ceci :

Code java :

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

1
2
3
4
5
6
Vector3f Vertices[3];
Vertices[0] = Vector3f(-1.0f, -1.0f, 0.0f);
Vertices[1] = Vector3f(1.0f, -1.0f, 0.0f);
Vertices[2] = Vector3f(0.0f, 1.0f, 0.0f);
 
glDrawArrays(GL_TRIANGLES, 0, 3);

Je fais quoi de ça ? Je comprends sans aucuns soucis le concepts, par contre je ne sais à aucuns moment quand mes vertices sont passée à la carte graphique ni comment les utiliser concrètement.

Dans mon code actuel l'équivalent que j'ai c'est ça ;

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
43
44
45
46
47
48
// Vertices, the order is not important.
        float[] vertices = {
                150, 150,    // Left top         ID: 0
                200, 150,   // Left bottom      ID: 1
                200, 200,    // Right bottom     ID: 2
                150, 201      // Right left       ID: 3
        };
        // Sending data to OpenGL requires the usage of (flipped) byte buffers
        FloatBuffer verticesBuffer = BufferUtils.createFloatBuffer(vertices.length);
        verticesBuffer.put(vertices);
        verticesBuffer.flip();
 
        // OpenGL expects to draw vertices in counter clockwise order by default
        byte[] indices = {
                // Left bottom triangle
                0, 1, 2,
                // Right top triangle
                2, 3, 0
        };
        indicesCount = indices.length;
        ByteBuffer indicesBuffer = BufferUtils.createByteBuffer(indicesCount);
        indicesBuffer.put(indices);
        indicesBuffer.flip();
 
        // Create a new Vertex Array Object in memory and select it (bind)
        // A VAO can have up to 16 attributes (VBO's) assigned to it by default
        vaio = GL30.glGenVertexArrays();
        GL30.glBindVertexArray(vaio);
 
        // Create a new Vertex Buffer Object in memory and select it (bind)
        // A VBO is a collection of Vectors which in this case resemble the location of each vertex.
        vbo = GL15.glGenBuffers();
        GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbo);
        GL15.glBufferData(GL15.GL_ARRAY_BUFFER, verticesBuffer, GL15.GL_STATIC_DRAW);
        // Put the VBO in the attributes list at index 0
        GL20.glVertexAttribPointer(0, 2, GL11.GL_FLOAT, false, 0, 0);
        // Deselect (bind to 0) the VBO
        GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
 
        // Deselect (bind to 0) the VAO
        GL30.glBindVertexArray(0);
 
        // Create a new VBO for the indices and select it (bind)
        vbo = GL15.glGenBuffers();
        GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, vbo);
        GL15.glBufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, indicesBuffer, GL15.GL_STATIC_DRAW);
        // Deselect (bind to 0) the VBO
        GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);

et je le dessine la

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
// Bind to the VAO that has all the information about the vertices
        GL30.glBindVertexArray(vaio);
        GL20.glEnableVertexAttribArray(0);
 
        // Bind to the index VBO that has all the information about the order of the vertices
        GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, vbo);
 
        // Draw the vertices
        glColor4f(1f, 0f, 1f, 1f);
        GL11.glDrawElements(GL11.GL_LINE_LOOP, indicesCount, GL11.GL_UNSIGNED_BYTE, 0);
 
        // Put everything back to default (deselect)
        GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
        GL20.glDisableVertexAttribArray(0);
        GL30.glBindVertexArray(0);

Y à vraiment un soucis de clarté d'information pour quelqu'un désirant se lancer dans l'OpenGL. Partout je lis que les codes sont quasiment les mêmes dans touts langages/libs, quand je fais des recherches sur LWJGL on me redirige facilement vers des tutos pour tout les langages sauf que ça n'a rien à voir. Un tutoriel qui commence par l'utilisation de GLUT alors qu'il n'est pas présent dans LWJGL je ne sais pas quoi en faire.

[Kannagi]

Par exemple, je vois ceci :

Code java :

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

1
2
3
4
5
6
Vector3f Vertices[3];
Vertices[0] = Vector3f(-1.0f, -1.0f, 0.0f);
Vertices[1] = Vector3f(1.0f, -1.0f, 0.0f);
Vertices[2] = Vector3f(0.0f, 1.0f, 0.0f);
 
glDrawArrays(GL_TRIANGLES, 0, 3);

Je fais quoi de ça ? Je comprends sans aucuns soucis le concepts, par contre je ne sais à aucuns moment quand mes vertices sont passée à la carte graphique ni comment les utiliser concrètement.

Bon aussi le code n'est pas complet !
Il manque le code d'envoie a la CG :p

Y à vraiment un soucis de clarté d'information pour quelqu'un désirant se lancer dans l'OpenGL. Partout je lis que les codes sont quasiment les mêmes dans touts langages/libs, quand je fais des recherches sur LWJGL on me redirige facilement vers des tutos pour tout les langages sauf que ça n'a rien à voir. Un tutoriel qui commence par l'utilisation de GLUT alors qu'il n'est pas présent dans LWJGL je ne sais pas quoi en faire.

Ben GLUT c'est pour ouvrir une fenêtre , il faut savoir que en C ou C++ , il y'a rien dans la lib stantard pour la GUI dans ton cas , c'est inutile

Sinon pour répondre sur ton autre topic ,LWJGL comporte tout simplement OpenGL 1 ,2 ,3 (voir 4) tout simplement , pour ça que tu peux faire de l'ancien OpenGL.

Tu utilise quel tuto ?
parce qu'il ya celui là : https://jeux.developpez.com/tutoriels/OpenGL-ogldev/

[dragonjoker59]

Tu as posté deux snippets de code du chapitre 3 du tutoriel, en les mettant dans le même code...
Ce n'est pas le cas dans le tutoriel, ils sont bien séparés, et ce sont des changements par rapport à la version précédente du code, qui provient du tutoriel 2, qui contient lui le code d'initialisation et d'envoi à la carte graphique.
C'est un tutoriel fait pour être suivi étape par étape...

[Paphytos]

De quoi parles tu ? Les deux passages de code que j'ai collé ne sont pas à la suite dans mon code, ce sont deux fonctions distinct, l'une pour instancier le VBO et l'autre pour le dessiner. Tu parlais bien de ça ?

Donc voilà, GLUT ne me sert à rien et les codes sont incomplet. J'utilises aucuns tutoriel en particulier, je fouille partout en cherchant quelque choses de claire et je tente de composer avec ce que j'en comprends.

Le tutoriel que tu m'as passé j'étais déjà tombé dessus plusieurs fois, y à rien d’intéressant pour moi dedans. Pas que le tuto soit inintéressant, mais les chapitre qui concernent mes besoins n'apporte que la logique général de loin, et pas ce qu'il me faut en détails.

J'ai besoin de pouvoir dessiner plusieurs formes, que ça soit des lignes, des polygone, des texture 2d, les référencer comme il faut et les dessiner d'un seul tenant en faisant un appel à la carte graphique. Tout est restant sur un opengl compatible avec les cartes graphique normal (la mienne par exemple ne supporte pas au dealas d'opengl 3.3).

Pour l'instant les seuls endroit ou je trouve des réponses claire à ce que je cherche c'est sur les jeux open source qui utilisent lwjgl.

[Kannagi]

Ben ces tutos sont bien suffisant et assez complets en détails ensuite...