Projet de simili 3D [suggestions needed]

Fin du Projet de simili 3D [corrections et objections needed]

Bonjour,

Je réalise un jeu et comme il s'agit d'un jeu style jeu-de figurine, je voulais afficher le plateau de jeu en 3D dans un JPanel.

J'ai feuilleté la partie de mon bouquin de référence sur Java3D en me disant que finalement c'était super simple. Problème : Il semble qu'utiliser java3d dans un .jar oblige à quelques gymnastiques pour que l'application soit utilisable à la fois sous linux, mac et windows, si l'utilisateur n'a pas lui même installé chez lui java3D.

Du coup, comme en plus, je n'ai qu'une représentation 2D de mes figurines, je me suis dis que j'allais utiliser mon habituel paintComponent avec un algorithme traduisant en 2D, des coordonnées x,y,z en calculant une ligne d'horizon, des lignes de fuites etc...

En utilisant une sorte d'HashMap <Coordon3D,Image>, je peux dessiner dans mon composant l'ensemble des images, du fond vers le premier plan. Je peux même ajouter toute une série de méthodes pour ajouter, supprimer, déplacer les images dans le plan.

Au final je me dis que c'est tellement utile pour plein de choses que j'en ferai bien un composant de référence dans mes projets, et pourquoi pas une source que je pourrais humblement soumettre à la communauté de developpez.net.

3 questions préalables :
- Ai-je bien compris, et est-ce bien si difficile d'introduire du Java3D dans un projet qui se veut multi plateforme ? (Compte tenu de mes maigres connaissance)

- Ne suis-je pas en train de vouloir réinventer l'eau chaude, est-ce qu'il existe déjà des classes qui effectuent le même travail ?

- Enfin, si vous me suivez toujours jusque là. Est-ce que vous avez des idées, suggestions, de classes que je pourrais utiliser pour ce mini-projet, et/ou de méthodes et de classes que j'aurai à créer ?

Je dis pas ça pour que quelqu'un fasse à ma place, bien au contraire, je serai ravi de créer un projet pour la communauté, en me forçant pour une fois à travailler de façon la plus générique possible et en respectant toutes les convention.

A bientôt. Merci de votre aide.

salut,

faisant suite à ton autre post:

Amha, il me semble que tu devrais plutôt opter pour l'utilisation d'un 'vrai' moteur 3D plutôt que perdre du temps a réinventer la roue.

Les 'problèmes' à régler pour pouvoir faire tourner un moteur 3D sur différentes plateformes (win, linux, mac) sans intervention de l'utilisateur final existent, même si j'ai cru comprendre (à vérifier) qu'effectivement Java3D n'est pas le moteur le plus simple à "packager".
Amha, tu perdras moins de temps à régler lesdits problèmes plutôt que le temps que tu passeras à implémenter tes algos 3D.

Quelques pistes:
- le moteur JMonkeyEngine, qui a déjà fait ses preuves pour le développement de jeux multi-plateformes ... et même les distribuer via Java WebStart (ex: Bang Howdy, NordGame). Il y a également un "starting guide" pour débuter.

- il existe également des moteurs 3D proposant un rendu 'full software'. Bien que leur performances soit moindres (car pas d'accélération GPU), leur avantage est de proposer une implémentation 'full java', donc complètement multi-plateformes (et du coup intégrable même dans une applet non signée). Jpct est un bon exemple. Ce dernier permet même de passer dynamiquement d'un rendu 'software' à un rendu 'hardware' via LWJGL.

A toi de voir...

Super, je vais regarder ça dès que possible, merci bien.

Après, ce que je recherche est loin d'être de la vraie 3D vue que je dispose pas de vrais objets 3D, mais simplement d'images que je souhaite positionner comme si elle se trouvaient vraiment sur une table.

En fait, pour résumer mon projet, c'est plutôt de créer un compositeur d'image. Je pourrais positionner moi même mes images (premier plan par dessus le fond, celles qui sont loin, plus petites, etc...) sauf que je préfère apprendre à mon programme à le faire tout seul avec seulement des coordonnées pour qu'il puisse le refaire la prochaine fois tout seul !

Enfin bon, c'est aussi un peu pour m'amuser, mais je vais regarder si il y a des solutions plus simples.

Merci de ton aide.

Pour le moment ça fonctionne

Bon, ça avait pas passionné les foules mon affaire, mais j'ai quand même réalisé ce projet.

Voici le résultat. J'ai essayé à peu près propre pour que ce soit montrable, mais bon j'ai encore des progrès à faire.

Le but était de pouvoir demander au programme d'organiser et d'afficher les images selon des coordonnées 3D. (L'image plus proche cache celles de derrière, celle de derrière apparait plus petite que celle de devant, elle est décallée en fonction de la perspective etc...)

J'ai utilisé les seules formules
X.2D = X.3D * ( focale/ focale+ Z.3D)
Y.2D = Y.3D * ( focale/ focale+ Z.3D)

J'ai décomposé en 4 classes :
Objet3D (qui stocke coordonnées 3D et image)

Code:

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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
package model;
 
import java.awt.Image;
import java.util.Observable;
 
/***
* Cette classe stocke les valeurs x, y et z ainsi que l'Image d'un objet destiné à la 3D.
*/
 
public class Objet3D extends Observable implements Comparable<Objet3D> {
 
private int x;
private int y;
private int z;
private Image image;
 
/**
 * taux correspond au ratio entre taille d'affichage et taille de l'image
 * En dessous de 1, l'image à l'écran apparait plus petite que l'original
 * En dessus de 1, l'image à l'écran apparait plus grosse que l'original
 */
private float taux = 1;
 
//définit et garde en mémoire le point d'ancrage de l'image
public static final int FIRST_LINE_START = 1;
public static final int FIRST_LINE_CENTER = 2;
public static final int FIRST_LINE_END = 3;
public static final int LINE_START = 4;
public static final int LINE_CENTER = 5;
public static final int LINE_END = 6;
public static final int LAST_LINE_START = 7;
public static final int LAST_LINE_CENTER = 8;
public static final int LAST_LINE_END = 9;
 
private int pointAncrage = FIRST_LINE_START;
 
public Objet3D (int x, int y, int z, Image im){
this.x = x;
this.y = y;
this.z = z;
image = im;
}
 
//setters
public void setX (int x){
this.x = x;
setChanged();
notifyObservers(x);
}
 
 
public void setY (int y){
this.y = y;
setChanged();
notifyObservers(y);
}
 
public void setZ (int z){
this.z = z;
setChanged();
notifyObservers(z);
}
 
public void setXY (int x, int y){
this.x = x;
this.y = y;
setChanged();
notifyObservers(x);
}
 
public void setXZ (int x, int z){
this.x = x;
this.z = z;
setChanged();
notifyObservers(x);
}
 
public void setYZ (int y, int z){
this.z = z;
this.y = y;
setChanged();
notifyObservers(y);
}
 
public void setXYZ (int x, int y, int z){
this.x = x;
this.y = y;
this.z = z;
setChanged();
notifyObservers(x);
}
 
public void setImage (Image im){
image = im;
notifyObservers(image);
}
 
public void setPointAncrage (int s){
pointAncrage = s;
notifyObservers(pointAncrage);
}
 
//getters
public int getLocX (){
switch (pointAncrage)	{
	case FIRST_LINE_START : 
	case LAST_LINE_START :
	case LINE_START :
		return x;
	case FIRST_LINE_CENTER :
	case LINE_CENTER :
	case LAST_LINE_CENTER :
		return x - (int)(image.getWidth(null)*taux/2);
	case FIRST_LINE_END :
	case LINE_END :
	case LAST_LINE_END :
		return x - (int)(image.getWidth(null)*taux);
	default :
		return x;
	}
 
}
 
public int getLocY (){
	switch (pointAncrage)	{
	case FIRST_LINE_CENTER :
	case FIRST_LINE_END :
	case FIRST_LINE_START :
		return y;
	case LINE_END :
	case LINE_CENTER :
	case LINE_START :
		return y - (int)(image.getHeight(null)*taux/2);
	case LAST_LINE_START :
	case LAST_LINE_CENTER :
	case LAST_LINE_END :
		return y - (int)(image.getHeight(null)*taux);
	default :
		return y;
}
}
 
public int getX(){
	return x;
}
 
public int getY(){
	return y;
}
 
public int getZ (){
return z;
}
 
public Image getImage(){
return image;
}
 
/*
*modifie la valeur x à partir d'une valeur de décalage reçue en parametres
*/
public void modifieX(int decalX){
setX(x+decalX);
}
 
public void modifieY(int decalY){
setY(y+decalY);
}
 
public void modifieZ(int decalZ){
setZ(z+decalZ);
}
 
public void modifieXY(int decalX, int decalY){
setXY(x+decalX,y+decalY);
}
 
public void modifieXZ(int decalX, int decalZ){
setXZ(x+decalX, z+decalZ);
}
 
public void modifieYZ(int decalY, int decalZ){
setYZ(y+decalY, z+decalZ);
}
 
public void modifieXYZ(int decalX, int decalY, int decalZ){
setXYZ(x+decalX, y+decalY, z+decalZ);
}
 
/**
 * @return hauteur de l'image selon le taux choisi
 */
public int getHauteur() {
		return (int)(image.getHeight(null)*taux);
}
 
	/**
         * @return largeur de l'image selon le taux choisi
         */
	public int getLargeur() {
		return (int)(image.getWidth(null)*taux);
	}
 
	/**
         * @param taux taux à définir
         */
	public void setTaux(float taux) {
		this.taux = taux;
		notifyObservers(taux);
	}
 
	/* (non-Javadoc)
	 * @see java.lang.Comparable#compareTo(java.lang.Object)
	 */
	public int compareTo(Objet3D c) {
		if (c==this) return 0;
		// si l'objet reçu en argument est plus 'profond' il est considéré comme inférieur à this
		if (z<c.getZ()) return 1;
		else if (z>c.getZ()) return -1;
		else {
			if (x<c.getX()) return 1;
			else if (x>c.getX()) return -1;
			else {
				if (y<c.getY()) return 1;
				else if (y>c.getY()) return -1;
				else {
					if (getLargeur()<c.getLargeur()) return 1;
					else if (getLargeur()>c.getLargeur()) return -1;
					else {
						if (getHauteur()<c.getHauteur()) return 1;
						else if (getHauteur()>c.getHauteur()) return -1;
					}
				}
			}
		}
		return 0;
	}
 
}

RépertoireSimili3D qui garde en mémoire l'ensemble des Objets3D à afficher

Code:

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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
package model;
 
import java.awt.Rectangle;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Observable;
import java.util.Observer;
import java.util.Set;
import java.util.TreeMap;
 
import javax.swing.SwingUtilities;
 
import vue.Simili3D;
 
/**
 * Cette class garde en mémoire l'ensemble des objets3D présents dans une scène Simili3D
 * @author emmanuel
 *
 */
public class RepertoireSimili3D extends TreeMap<Objet3D,Rectangle> implements
		Observer {
 
	/**
         * 
         */
	private static final long serialVersionUID = 1L;
 
	//il s'agit de la distance focale, distance 'virtuelle' entre l'oeil et l'écran,
	//sa valeur modifie les perspectives
	private float distance;
 
	//il s'agit d'une zone de la scène que l'on souhaite toujours visible même en l'absence d'objet
	private Rectangle rectangleMini;
 
	//la scène
	private Simili3D simili3D;
 
	//c'est le rectangle contenant l'ensemble des objets visibles + le rectangleMini
	private Rectangle rectangleCompletCache;
 
	//marges
	private int margeY = 20;
	private int margeX= 20;
 
	/**
         * @param distance distance focale
         * @param margeX
         * @param margeY
         */
	public RepertoireSimili3D(int distance, int margeX, int margeY) {
		this.distance = distance;
		this.margeX = margeX;
		this.margeY = margeY;
		simili3D = new Simili3D(this);
	}
 
	/**
         * @param distance distance focale
         */
	public RepertoireSimili3D(int distance) {
		this.distance = distance;
		simili3D = new Simili3D(this);
	}
 
	/**Cette méthode ajoute l'objet3D au répertoire en créant un rectangle correspondant
         * @param co
         * @return
         */
	public Rectangle ajouterObjet3D(Objet3D co) {
		co.addObserver(this);
		rectangleCompletCache=null;
		return put(co, fabriquerRectangle(co));
	}
 
	/**
         * Cette méthode crée et renvoi un rectangle 2D correspondant à l'objet 3D reçu en paramètre
         * @param co
         * @return rectangle 2D
         */
	private Rectangle fabriquerRectangle(Objet3D co) {
		Rectangle rec = new Rectangle();
		return modifierRectangle(co, rec);
	}
 
	/**
         * 
         * Cette méthode modifie le rectangle recu en paramètre pour le faire correspondre à l'objet 3D également reçu en paramètres
         * @param objet Objet 3D
         * @param rec rectangle d'affichage à modifier
         * @return
         */
	private Rectangle modifierRectangle (Objet3D objet, Rectangle rec){
		float taux = distance / (distance + objet.getZ());
		rec.x = (int)(objet.getLocX() * taux);//+horizonX;
		rec.y = -(int)(objet.getLocY() * taux);//+horizonY;
		rec.width = (int)(objet.getLargeur()*taux);
		rec.height = (int)(objet.getHauteur()*taux);
		return rec;
	}
 
	/**
         * supprime l'objet3D reçu en paramètre (équivalent de remove mais avec la suppression de l'observance en plus)
         * @param objet
         */
	public void supprimerObjet3D(Objet3D objet){
		objet.deleteObserver(this);
		rectangleCompletCache=null;
		super.remove(objet);
	}
 
	/* Utiliser de préférence ajouterObjet3D
	 * (non-Javadoc)
	 * @see java.util.HashMap#put(java.lang.Object, java.lang.Object)
	 */
	@Override
	@Deprecated
	public Rectangle put(Objet3D arg0, Rectangle arg1) {
		return super.put(arg0, arg1);
	}
 
	/* 
	 * Utiliser de préférence supprimerObjet3D
	 * (non-Javadoc)
	 * @see java.util.HashMap#remove(java.lang.Object)
	 */
	@Override
	@Deprecated 
	public Rectangle remove(Object arg0) {
		return super.remove(arg0);
	}
 
	/* Si l'un des objet3D est actualisé, modifier son rectangle et actualiser la vue
	 * (non-Javadoc)
	 * @see java.util.Observer#update(java.util.Observable, java.lang.Object)
	 */
	public void update(Observable co, Object arg1) {
		if (co instanceof Objet3D){
			Objet3D c = (Objet3D)co;
			rectangleCompletCache=null;
			super.put (c, modifierRectangle(c, get(c)));
		}
 
		SwingUtilities.invokeLater(new Runnable() {
			  public void run() {
			      simili3D.repaint();
			  }
			}) ;
	}
 
	/**
         * @return distance
         */
	public float getDistance() {
		return distance;
	}
 
	/**
         * @param distance distance à définir
         */
	public void setDistance(float distance) {
		this.distance = distance;
	}
 
 
 
	/**
         * s'il ne l'a pas déjà en mémoire, crée et renvoi le rectangleComplet
         * @return
         */
	public Rectangle getRectangleComplet(){
		if (rectangleCompletCache ==  null){
			rectangleCompletCache = getRectangleMini() ;
			for (Rectangle c : values()){
				rectangleCompletCache.add(c);
			}
		}
 
		return rectangleCompletCache;
	}
 
	/**
         * Cette méthode renvoie le rectangle de vue minimum s'il a été défini
         * sinon il renvoie le rectangle du premier élément trouvé dans la liste.
         * @return rectangleMini
         */
	public Rectangle getRectangleMini() {
		if (rectangleMini==null){
			for (Objet3D c : keySet()){
				Rectangle rect = (Rectangle) get(c).clone();
				return rect;
			}
			return new Rectangle(0,0,0,0);
		}
		else return (Rectangle)rectangleMini.clone();
	}
 
	/**
         * @param rectangleMini rectangleMini à définir
         */
	public void setRectangleMini(Rectangle rectangleMini) {
		this.rectangleMini = rectangleMini;
	}
 
	/**
         * @return margeX
         */
	public int getMargeX() {
		return margeX;
	}
 
	/**
         * @return margeY
         */
	public int getMargeY() {
		return margeY;
	}
 
	/**
         * @param margeX margeX à définir
         */
	public void setMargeX(int margeX) {
		this.margeX = margeX;
	}
 
	/**
         * @param margeY margeY à définir
         */
	public void setMargeY(int margeY) {
		this.margeY = margeY;
	}
 
}

PanelSimili3D, qui est juste un jscrollpane

Code:

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
/**
 * 
 */
package vue;
 
import java.awt.Component;
 
import javax.swing.JScrollPane;
 
import model.RepertoireSimili3D;
 
 
/**
 * Cette classe est le JScrollPane destiné à recevoir un Simili3D.
 * Il pourra à l'envi être dérivé pour ajout de fonctions
 * @author emmanuel
 *
 */
public class PanelSimili3D extends JScrollPane {
 
	/**
         * 
         */
	public PanelSimili3D(RepertoireSimili3D rep) {
		super(new Simili3D(rep));
		setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
		setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
 
	}
 
 
}

Enfin Simili3D, qui est la scène, la feuille de dessin si vous préférez

Code:

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
package vue;
 
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Insets;
import java.awt.Rectangle;
 
import javax.swing.JComponent;
 
import model.Objet3D;
import model.RepertoireSimili3D;
 
/**
 * Cette classe est la scène qui affiche l'ensemble des objets3D contenus dans un
 * répertoireSimili3D reçu en argument.
 */
public class Simili3D extends JComponent {
 
 
	private static final long serialVersionUID = 1L;
 
	private RepertoireSimili3D repertoireImage;
 
	public Simili3D(RepertoireSimili3D rep) {
		repertoireImage = rep;
	}
 
	@Override
	protected void paintComponent(Graphics g) {
		Graphics2D g2D = (Graphics2D)g.create();
		Rectangle rectangleComplet = repertoireImage.getRectangleComplet();
		g2D.translate(-rectangleComplet.x+repertoireImage.getMargeX(),
				getHeight()-rectangleComplet.y-rectangleComplet.height-repertoireImage.getMargeY());
		//g2D.scale(1, -1);
 
		for (Objet3D c : repertoireImage.keySet()){
			Image i = c.getImage();
			Rectangle r = repertoireImage.get(c);
			g2D.drawImage(i, r.x, r.y, r.width, r.height, null);
		}
 
		/*
		 * Grille de test, à supprimer en production
		 */
		for (int i = -1000; i< 1001 ; i+=50){
			g2D.drawLine(-1000, i, 1000, i);
			g2D.drawLine(i, 1000, i, -1000);
		}
		g2D.setColor(Color.red);
		g2D.drawLine(-1000, 0, 1000, 0);
		g2D.drawLine(0, 1000, 0, -1000);
 
		g2D.dispose();
	}
 
	/* (non-Javadoc)
	 * @see javax.swing.JComponent#getPreferredSize()
	 */
	@Override
	public Dimension getPreferredSize() {
		if (isPreferredSizeSet()) {
			return super.getPreferredSize();
		}
		else {
			Insets insets = getInsets();
			Rectangle r = repertoireImage.getRectangleComplet();
			return new Dimension ((int)r.getWidth()+insets.left+insets.right+repertoireImage.getMargeX()*2,
					(int)r.getHeight()+insets.bottom+insets.top+repertoireImage.getMargeY()*2);
		}
 
	}
 
}

Voilà, merci à ceux qui ont lu jusque là. C'est réutilisable et améliorable.
D'ailleurs, je suis preneur de tout conseil qui pourrait me faire progresser. De toute suggestion pour ajouter des fonctionnalités.
Il y a deux trois passages dont je suis pas fier, parce que c'est crade. Mais ça fonctionne. Je vais pouvoir continuer mon jeu, et les suivants en toute simplicité à présent.