Discussion :

[Pecose]

Bien le bonjour à tous.

J'ai commencer à faire un petit moteur graphique pour gérer la lumière dans un jeu 2D.
Ce petit bout de code marche bien mais trop lentement.
Surement que ma façon de le concevoir n'est pas la bonne.
Voila comment il est fait:

1- Je créé un objet World qui contient:

Code :

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

1
2
protected static Graphics2D calqueLum;
protected static BufferedImage bufferedCalqueLum;

Puis je le lance avec:

Code :

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

1
2
3
4
public void Start(){
bufferedCalqueLum = new BufferedImage(Frame.frameWidth, Frame.frameHeight, BufferedImage.TYPE_INT_ARGB );
calqueLum = bufferedCalqueLum.createGraphics();
}

2- Je créé un objet Light qui hérite de World.
Avec sa méthode AddLight je dessine dans "calqueLum" un cercle avec des triangles dont la couleur opaque au centre devient translucide en s'évasant.

3- Et pour finir, dans World.DisplayLight() j'inverse l'alpha de tout les pixels avec:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public void DisplayLight(){
	for(int x = 0, y = 0; x < bufferedCalqueLum.getWidth(); x++){ for(; y < bufferedCalqueLum.getHeight(); y++){
			Color nuitColor = new Color(bufferedCalqueLum.getRGB(x, y), true);
			Color rgba = new Color(nuitColor.getRed(), nuitColor.getGreen(), nuitColor.getBlue(), (255 - nuitColor.getAlpha()));
	        	bufferedCalqueLum.setRGB(x, y, rgba.getRGB());
        } y = 0; }
 
	Image imagecalqueLum = Toolkit.getDefaultToolkit().createImage(bufferedCalqueLum.getSource());
	Panel.feuille.drawImage(imagecalqueLum, 0, 0, null);
 
	calqueLum.dispose();
}

Sachant que bufferedCalqueLum.getHeight() vaut 1080 et que bufferedCalqueLum.getWidth() vaut 1920 sa fait beaucoup de pixels.
Du coup il me faudrait surement une autre idée.

Merci de votre aide.

[tchize_]

bon, déjà getPixel / setPixel ce n'est pas le plus performant pour modifier le contenu d'une image. Il vaut mieux accéder directement au tableau de int via les Raster, et ca nécessite que tu te perde un peu dans la javadoc

ensuite, pourquoi tu t'emmerde à aller inverser la valeur de alpha? Pourquoi ne pas simplement changer ta formule de composition quand tu utilisera cette image? C'est bien plus performant de dire au composite de faire
(srccolor * dstalpha) + (dstcolor * (1-dstalpha))
plutôt que de lui dire de faire
(srccolor * (1-dstalpha)) + (dstcolor * dstalpha) et en plus d'inverser manuellement l'alpha sur l'image dst.


Selon moi donc, ton problème de base est que tu simplifie trop ton système (préparer tes données sources en les modifiant régulièrement) plutôt que de faire te reposer sur ce qui existe (formule de compositing) qui à complexifier tes données (ajout d'un flag pour savoir si oui ou non le alpha est inversé)

[Pecose]

Pour l'histoire de l'alpha, (si c'est bien ca que tu veux dire) je ne peut pas coller mon cercle sur un fond noir parce que je veux rendre le fond en question transparent, donc ca ne peut pas marcher a moins de créé une autre BufferedImage qui contient le ou les cercles et de comparer les pixels de chaque BufferedImage, ce qui prend encore plus de resources (A moins que tu ai une autre idée).

Ensuite pour l'utilisation du Raster si tu peut m'aiguiller stp, parce que j'ai mis trois semaines a comprendre comment fonctionnes les BufferedImage...
J'ai trouver ca:

Code :

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

1
2
3
BufferedImage image = myImage;//or whatever
Raster ras=image.getData();
DataBuffer data=ras.getDataBuffer();

Et maintenant j'en fait quoi?

[tchize_]

Pour l'histoire de l'alpha, (si c'est bien ca que tu veux dire) je ne peut pas coller mon cercle sur un fond noir parce que je veux rendre le fond en question transparent, donc ca ne peut pas marcher a moins de créé une autre BufferedImage qui contient le ou les cercles et de comparer les pixels de chaque BufferedImage, ce qui prend encore plus de resources (A moins que tu ai une autre idée).

Vu que je ne comprends pas ce que tu fais, je peux pas t'aider. Ma remarque était juste que, inverser l'alpha dans une image (ce que tu fais) et souvent inutile car il suffit d'inverser l'algo utilisant, plus tard, cet alpha.

Code :

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

1
2
3
BufferedImage image = myImage;//or whatever
Raster ras=image.getData();
DataBuffer data=ras.getDataBuffer();

Et maintenant j'en fait quoi?

Tu typecast en ByteDataBuffer/IntegerDataBuffer/ autre suivant ce que t'as retourné le BufferedImage, mais vu que t'es parti sur un INT_ARGB, il y a des chances que ce soit du integer. Enfin, il y a des méthodes sur ces sous classes pour accéder au tableau de int formant l'image, qu'il suffit de modifier directement, si je ne dis pas de bêtise.

Tu peux aussi utiliser getSamples / setSamples sur WritableRaster, mais je ne sais pas laquelle des deux méthodes est la plus rapide.

[Pecose]

Ca s'appelle DataBufferInt / DataBufferByte au cas ou tu cherche.
Par contre j'ai rien trouver d'utile, mais si tu as un moyen moins lourd que le mien d'inverser l'alpha de mon image je suis preneur.
Parce que j'ai strictement rien trouver sur l'algo d'on tu parle.

[tchize_]

ben c'est ton algo que j'aimerais voir. Là tu inverse le alpha sur une image, mais je suppose que tu fais quelque chose de cette image, à la fin

[Pecose]

Je l'affiche.
En fait cette image c'est un calque que je colle par dessus les objets "tables, chaises, sols ect..." de mon jv.
Dans un premier temps je dessine des rond de couleur "mes lumière" et ensuite j'inverse l'alpha de l'image.
du coup tout les pixels vierges deviennent noir et les autre deviennent transparent.

Et la lumière fut.

[tchize_]

Dans ce cas là, l'idéal, ce serait de calculer la lumière directement dans le bon sens, plutot que de devoir recourir à une inversion par la suite.

Sinon, tu peux essayer de jouer avec Graphics2D.setComposite et les différentes formule de Alphacompsite pour voir si une ne donne pas les résultats que tu veux.

[Pecose]

J'ai tester AlphaComposite, et depuis hier, je tourne ça dans tout les sens.
Il n'y a pas moyen de faire ce que je veux.
Là je sèche.

AlphaComposite permet de superposer des images en passent en alpha certaines parties de la source ou de la destination.
Le problème c'est que j'ai besoin d'additionner les couleurs de mes lumières.
Avec AlphaComposite quand j'en affiche une j'en efface une autre ou j'affiche par dessus.

J'ai essayer d'afficher les lumières dans un BufferedImage (là l'addition ca marche), puis d'afficher ce BufferedImage sur le BufferedImage principal avec AlphaComposite.
Sauf qu'un BufferedImage ca ne mesure pas que "les lumière" mais en l'occurrence tout l'écran.
Du coup même si j'utilise AlphaComposite, b'en ca affiche par dessus et ca supprime ce qu'il y a en dessous.

Au secours.

[Pecose]

J'ai trouver un truc :Blend.Mode
Sur cette page: http://download.java.net/javadesktop...lend.Mode.html

Mais alors là j'ai grandement besoin d'aide pour m'aider a l'utiliser.
Je ne sais pas par ou commencer.

[Pecose]

Encore un truc que j'ai trouver sur le BlendMode:

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
public enum BlendMode
extends java.lang.Enum<BlendMode>
A blending mode defines the manner in which the inputs of a Blend effect are composited together or how a Node is blended into the background of a scene.
import javafx.scene.*;
import javafx.scene.effect.*;
import javafx.scene.paint.*;
import javafx.scene.shape.*;
 
Rectangle r = new Rectangle();
r.setX(50);
r.setY(50);
r.setWidth(50);
r.setHeight(50);
r.setFill(Color.BLUE);
 
Circle c = new Circle();
c.setFill(Color.rgb(255, 0, 0, 0.5));
c.setCenterX(50);
c.setCenterY(50);
c.setRadius(25);
c.setBlendMode(BlendMode.MULTIPLY);
 
Group g = new Group();
g.getChildren().add(r);
g.getChildren().add(c);

Là, ce qui chie, c'est les import et le .setBlendMode() qui n'existent pas.

[tchize_]

C'et du javafx. Très bien pour faire des application graphique, mais c'est du javafx, pas du java de base

Je suis désolé, pour les Raster, je peux juste te guider vers la javadoc, je vois que c'est plus rapide dans plusieurs outils que j'utilise, bien plus que des setPixel, mais je ne connais pas assez.
Pour le apha composite, visiblement, ce n'est pas utilisable dans ton cas vu tes essaie, donc une voie de garage :/

[dinobogan]

Lorsque j'ai à travailler directement sur les pixels, j'utilise un java.awt.image.PixelGrabber. Il permet de faire un lien entre un tableau de pixel et une image.
Lorsque tu modifies ton tableau de pixels, l'image est directement modifiée.
Tu n'as plus à utiliser les setRGB et getRGB de BufferedImage.

[sinok]

Tiens, pour mieux comprendre les différents blends modes fournis par Java2D de base, et en récupérer tout un paquet de supplémentaires (type Multiply & cie), je te redirige vers le blog de Romain Guy qui en avait implémenté un paquet à l'époque.

http://www.curious-creature.org/2006...es-for-java2d/

[Pecose]

Merci Sinok,
J'ai essayer le BlendComposite qui donne a peut de choses près ce que j'attend tout en ne resolvent absolument pas mon problème de base qui est que ca rame la mort.
Si quelqu'un a une idée merci.

[sinok]

Truc tout bête, mais gères tu le clipping lors de tes repaints (cf Graphics2D.getClipBounds et la version à quatre paramètres de repaint).

Secondement, pourquoi ne pas déporter les opération de génération des images dans un thread séparé et ne faire que switcher les images (notion de double/triple buffer) dans le thread dédié au dessin.

[Pecose]

Heuuuuuu.
Désolé j'ai rien compris, je vais faire des recherches là dessus.
Si jamais tu as un tuto a me conseiller...
Merci pour l'info.

[sinok]

En ce qui concerne les ClipsBounds, le but est de ne mettre à jour que la partie des graphics qui a bougé, cela évite de réaliser trop d'opérations simultanées dans ton gui.
Dans les faits, tu identifie la région qui doit être modifiée (enfin, le rectangle y correspondant) et tu appelles la version de la méthode repaint qui possède quatres paramètres qui définissent le secteur à repeindre.
Et dans ton paintComponent, tu fais appel à la méthode getClipBounds qui définit la partie des graphics qui doit être modifiée, ceci afin d'éviter de repeindre l'intégralité du composant.

Pour l'autre partie, l'idée est de pré générer les images qui seront affichées sur ton écran dans un thread séparé, et que l'EDT ne fasse que dessiner ces images sur la frame à intervalle régulier (notions de double buffering, triple buffering)

[Pecose]

J'ai réussi, en gros je fait un cercle dans un a Area avec RadialGradientPaint:
Apres je fait des polygones que je lum.substract() pour faire les ombres.
Et ça marche.
Merci de votre aide.
Merci Sinok, tes conseilles m'ont mener a d'autres problèmes dont je parlerai surement dans une autre discussion.