IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 Java Discussion :

Projet de simili 3D [suggestions needed]


Sujet :

Java

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre confirmé
    Inscrit en
    Juin 2008
    Messages
    127
    Détails du profil
    Informations forums :
    Inscription : Juin 2008
    Messages : 127
    Par défaut 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.

  2. #2
    Modérateur
    Avatar de nouknouk
    Homme Profil pro
    Inscrit en
    Décembre 2006
    Messages
    1 655
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : France

    Informations forums :
    Inscription : Décembre 2006
    Messages : 1 655
    Par défaut
    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...

  3. #3
    Membre confirmé
    Inscrit en
    Juin 2008
    Messages
    127
    Détails du profil
    Informations forums :
    Inscription : Juin 2008
    Messages : 127
    Par défaut
    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.

  4. #4
    Membre confirmé
    Inscrit en
    Juin 2008
    Messages
    127
    Détails du profil
    Informations forums :
    Inscription : Juin 2008
    Messages : 127
    Par défaut 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 : 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
    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 : 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
    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 : 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
    /**
     * 
     */
    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 : 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
    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.

Discussions similaires

  1. Réponses: 3
    Dernier message: 30/10/2012, 09h29
  2. Suggestion projet linux
    Par neutrall dans le forum Linux
    Réponses: 3
    Dernier message: 15/03/2010, 13h59
  3. Suggestion ou propostion de projet ?
    Par archimed111 dans le forum Sujets
    Réponses: 1
    Dernier message: 27/11/2008, 14h34

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo