Zeichnen mit paintComponent? Oder anders?

BDG

Aktives Mitglied
Hey Leute, wie kann ich denn einfach Bilder in Java zeichnen?

Ich hab versucht, die Methode "paintComponent" zu überschreiben, aber die wird bei mir nur 1 oder 2 mal ausgeführt und immer random mal, wenn ich das Fenster bewege?!

Ich suche eine Methode die ca. 60 mal die Sekunde ausgeführt wird, mit der ich Texturen an einem Punkt zeichnen kann. Und das Spiel updaten? In C#+XNA gab es einfach "Draw(SpriteBatch s)" und "Update(GameTime g)" :/
Da war das so einfach. Aber wie mach ich das in Java?
 
Spiele Programmierung -> vorwiegend aktiv zeichen.

do holst dir mit getGraphics() den Grafikkontext auf welchem du zeichnen willst und übergibst diesen dann deiner Methode

pseudo code
Java:
public void drawSomething(Graphics g){

 g.drawRect(x,y,width, height);
}

nun kannst du in deiner Draw methode für dein game (also in einem Gameloop) einfach ( hier z.B in einer von Jpanel abgeleiteten klasse)

Java:
private void draw(){
  Graphics g = getGraphics();


  myClass.drawSomething(g);

}

getGraphics() liefert dir hier den Grafikkontext des JPanels ( man könnte hier auch einen beliebiegen anderen Grafikkontext verwenden , z.B ein BufferedImage, auf welchem du dann, über dessen Graphics objekt zeichnen würdest.

nutzen.

Ich hab versucht, die Methode "paintComponent" zu überschreiben, aber die wird bei mir nur 1 oder 2 mal ausgeführt und immer random mal, wenn ich das Fenster bewege?!

Das liegt daran das du keinen einfluss darauf hast wann das Toolkit hier repaint(); ausführt, du könntest höchstens über einen manuellen aufruf von repaint(); darum bitten (ein flag setzen), es ist aber nicht sicher wann genau das toolkit deine anfrage/das repainten abarbeitet.

Hey Leute, wie kann ich denn einfach Bilder in Java zeichnen?

passiv über einen Graphics-kontext einer SWING Komponente :

Java:
BufferedImage image = ImageIO.read(getClass().getResourceAsStream("meinBild.png");

@Override
public void paintComponent(Graphics g){
  super.paintComponent(g);

  g.drawImage(image, 0,0, null);

}
 
Zuletzt bearbeitet:
Und die Methode draw() muss ich dann wo aufrufen? Und ist es notwendig jedes mal "g" neu zu definieren, weil ich dachte der Wert bleibt gleich?
 
Und ist es notwendig jedes mal "g" neu zu definieren, weil ich dachte der Wert bleibt gleich?

- graphics kontext über getGraphics() holen
- zeichnen
- graphics kontext über g.dispose() freigeben

das ganze sollte dann ungefähr so aussehen :

Java:
public class Player{
  
   private Image image; 

public Player(){
    try{
        image = ImageIO.read(getClass().getResourceAsStream("hierBeliebiegenPfadeinfügen.toll"));
    }
    catch(IoException e){
        // hier exeption handling durchführen.
    }
}
 
public void draw(Graphics g){
   g.drawImage(image, x, y, null);  
}
}

diese Methode kannst du dann dazu verwenden um z.B einen Player zu zeichnen, das ganze passiert dann in deiner Game Klasse

Und die Methode draw() muss ich dann wo aufrufen?

in der klasse die das Runnable für deinen Gameloop definiert.
 
Zuletzt bearbeitet:
"die das Runnable für dein Gameloop definiert" - soll was bedeuten? In c# war das einfacher 😛
Wenn ich in der Klasse "Runnable" implementiere, und die Funktion "run()" überschreibe, wann wird die ausgeführt?
Hab da mal "System.out.println("hi");" reingeschrieben, aber meine Konsole bleibt leer beim Debuggen :/
 
Na gut......

also im groben angerissen sollte das ganze ungefähr so aussehen :

Java:
public class Game{
	

	public static void main(String[] args){
		JFrame f = new JFrame("Game");
		f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		f.setContentPane(new Game().new GamePanel());
		f.pack();
		f.setLocationRelativeTo(null);
		f.setVisible(true);
	}
	
	@SuppressWarnings("serial")
	class GamePanel extends JPanel implements Runnable, KeyListener{
		
		final static int WIDTH = 400;
		final static int HEIGHT = 400;
		
		BufferedImage screen;
		
		Thread loop;
		boolean running;
		
		public GamePanel(){
			setPreferredSize(new Dimension(WIDTH, HEIGHT)); 
			setFocusable(true);
			requestFocus();
		}
		
		private void init(){
			screen = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
		
			running = true;
		}
		
		private void update(){}
		private void render(){}
		
		private void draw(){
			Graphics g = getGraphics();
			
			if(g != null){
				g.drawImage(screen, 0, 0, null);
			}
			else{
				System.exit(0);
			}
		}
		
		@Override
		public void addNotify(){
			super.addNotify();
			if(loop == null) {
				addKeyListener(this);
				loop = new Thread(this);
				loop.start();
			}
		}
		
		@Override
		public void run(){
			init();
			while(running){
				update();
				render();
				draw();
				try {
					Thread.sleep(100);
				}
				catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		
		
		@Override
		public void keyPressed(KeyEvent e){}
	
		@Override
		public void keyReleased(KeyEvent e){}
		
		@Override
		public void keyTyped(KeyEvent e){}
	}
}

sicher könnte man hier noch wesentlich OO herangehen, aber im grossen und ganzen sollte es in solch eine Richtung gehen,

Alles was du nun zeichnen möchtest , kannst du in der render Methode machen , dafür holst du dir den Graphics kontext des images (screen)
und übergibst ihn einer beliebigen methode, hier wird dann unter anwendung von double buffering erst auf das image gemalt , und dann das ganze image auf den JPanel, sprich es wird gepuffert, da du nicht direkt auf den Panel malst, um z.B flackern beim neuzeichnen zu unterbinden.

nehmen wir an wir implementieren eine Klasse Player und wollen diesen dann zeichnen, dann sieht das ganze z.B rudimentär so aus

Java:
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;



public class Game{
	

	public static void main(String[] args){
		JFrame f = new JFrame("Game");
		f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		f.setContentPane(new Game().new GamePanel());
		f.pack();
		f.setLocationRelativeTo(null);
		f.setVisible(true);
	}
	
	@SuppressWarnings("serial")
	class GamePanel extends JPanel implements Runnable, KeyListener{
		
		final static int WIDTH = 400;
		final static int HEIGHT = 400;
		
		BufferedImage screen;
		
		Thread loop;
		boolean running;
		
		Player player;
		
		public GamePanel(){
			setPreferredSize(new Dimension(WIDTH, HEIGHT)); 
			setFocusable(true);
			requestFocus();
		}
		
		private void init(){
			screen = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
		
			player = new Player("Spieler 1");
			player.setPosition(50, 50);
			
			running = true;
		}
		
		private void update(){}
		
		private void render(){
			Graphics g = screen.getGraphics();
			
			player.draw(g);
		}
		
		private void draw(){
			Graphics g = getGraphics();
			
			if(g != null){
				g.drawImage(screen, 0, 0, null);
			}
			else{
				System.exit(0);
			}
		}
		
		@Override
		public void addNotify(){
			super.addNotify();
			if(loop == null) {
				addKeyListener(this);
				loop = new Thread(this);
				loop.start();
			}
		}
		
		@Override
		public void run(){
			init();
			while(running){
				update();
				render();
				draw();
				try {
					Thread.sleep(100);
				}
				catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		
		
		@Override
		public void keyPressed(KeyEvent e){}
	
		@Override
		public void keyReleased(KeyEvent e){}
		
		@Override
		public void keyTyped(KeyEvent e){}
	}
	
	class Player{
		
		int x;
		int y;
		String name;
		
		public Player(String s){
			name = s;
		}
		
		public void draw(Graphics g){
			
			g.setColor(Color.RED);
			g.drawString(name, x, y - 15);
			g.fillRect(x, y, 20, 20);
		}
		
		public void setPosition(int x, int y){
			this.x = x;
			this.y = y;
		}
	}
}

 
Zuletzt bearbeitet:
Klassen innerhalb von Klassen? Wusste nichtmal, dass sowas geht :O
Naja, zu deinem Beispiel :
Klappt ja soweit mit dem zeichnen und sonst auch alles gut, aber wenn ich den Spieler bewege, dann wird er sozusagen nur neu erstellt an der Position wo man ihn hinbewegt hat. Also ich hab ihn dann ganz oft auf dem Bild, in einer Reihe.

Und nocheine Frage: Wann wird addNotify aufgerufen?
 
Klassen innerhalb von Klassen? Wusste nichtmal, dass sowas geht :O

Geht ja in C# auch 😉

Klappt ja soweit mit dem zeichnen und sonst auch alles gut, aber wenn ich den Spieler bewege, dann wird er sozusagen nur neu erstellt an der Position wo man ihn hinbewegt hat. Also ich hab ihn dann ganz oft auf dem Bild, in einer Reihe.

Nein es wird nur ein neues Player Objekt erstellt wenn die "init" Methode aufgerufen wird. Diese wird im "run" der Klasse GamePanel nur 1x vor dem Start der GameLoop aufgerufen.
Entweder rufst du die "run"-Methode irgendwo selbst auf oder du startest sehr viele Threads die dann jeweils ein eigenes Player Objekt malen.
 
Is mir schon klar, dass er nicht neu erstellt wird, aber es sieht halt so aus, weil wenn ich ihn 10 Pixel nach rechts bewegen will ist er einmal an der Startposition zu sehen und gleichzeitig 10 pixel weiter rechts. Obwohl er nur an der aktuellen Position gezeichnet werden soll. Also das Bild müsste eigentlich gecleart werden vor jedem zeichnen...
In c# wurde halt nur das gezeichnet was man zeichnen wollte! 😀 ganz einfach! Wenn ich die Position verändere wird er auch nur an der neuen gezeichnet! wie mach ich das hier? 😀
 
Du zeichnest ein Rechteck, bevor du deine anderen Komponenten zeichnest, bin nicht am Rechner, erst morgen wieder, aber auch das wäre sehr rudimentär, Normalerweise zeichnest Du eine Map und einen Hintergrund 😉 Aber um solche Dinge zu simulieren reicht ein einfaches Rechteck

BEVOR du alles andere zeichnest

g.setColor (Color.WHITE);
g.fillRect (0,0, WIDTH, HEIGHT);
 
Zuletzt bearbeitet:
Hey könnte einer von euch mir auch helfen bei einem paintmethoden problem bitte 😳

Ich mach ein paintprogramm in dem man mit einem jmenuitem aussuchen kann was mach zeichnen will(z.B. kreis, rechteck oder bild,..)
natürlich wird immer beim maxi-und minimieren gelöscht so wie ich es mache :/
also wie implementiere ich ein gescheite paintmethode mit repaint() und allem drum un dran
natürlich hab ich es schon selber probiert 😉 funktioniert aber nicht
bitte helft mir
wen ihr mehr code aus dem programm braucht ihr nur sagen 🙂
jp ist das hauptpanel auf dem gezeichnet wird

hier die methode vom jmenuitem

Java:
 public void drawRect() {
        rect.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                form = 1;
                repaint();
            }
        });
    }

mein versuch von einer paintmethode

Java:
    @Override
    public void paintComponent(Graphics g){
        g = jp.getGraphics();
        Random rand = new Random();
        if (form == 1) {
                    if (rainbowOk == 1) {
                        col = new Color(rand.nextInt(256), rand.nextInt(256), rand.nextInt(256));
                        g.setColor(col);
                    } else {
                        g.setColor(col);
                    }
                    g.fillRect(x, y, thick, thick);
                }
    }

und hier der mouselistener um die koordinaten zu bekommen für das programm

Java:
 @Override
            public void mouseDragged(MouseEvent e) {
                x = e.getX();
                y = e.getY();
                Random rand = new Random();
                String str1 = String.format("x:" + x + "y:" + y);
                System.out.println(str1);
                String str = "";
                xyAusgabe.setText(str1);
                repaint();
            }

danke 🙂
 
Und nocheine Frage: Wann wird addNotify aufgerufen?

addNotifiy() wird beim konstruieren des JPanels aufgerufen , deshalb bietet es sich an das erzeugen des Threads und das hinzufügen von eventuellen Listenern an dieser Stelle an .

Hier nochmal die definition der klasse JComponent
public void addNotify()
Notifies this component that it now has a parent component. When this method is invoked, the chain of parent components is set up with KeyboardAction event listeners. This method is called by the toolkit internally and should not be called directly by programs.

ich habe mal Fett markiert warum sich diese stelle anbietet

Hey könnte einer von euch mir auch helfen bei einem paintmethoden problem bitte

ja.....

natürlich wird immer beim maxi-und minimieren gelöscht so wie ich es mache :/

hier wäre die implementierung eines eigenen windowlisteners angebracht, sowie das nutzen einer collection welche die von dir gezeichneten Formen speichert, incl. ort / farbe usw. usw.

dazu würde ich mir ebenfalls eine Klasse schreiben welche diese Informationen enthält. oder wenn die formen nicht komplex sind , nutze einfach shapes

beim minimieren / verschieben des fensters fängst du das event ab und zeichnest alle elemente aus der collection erneut.

EDIT : ohne mir deinen Code genauer angesehen zu haben , würde ich auch hier dazu übergehen aktiv zu zeichnen, und nicht passiv über paintComponent().


um nochmal zu dem leeren des screens zu kommen :

GamePane.java
Java:
private void clearScreen(Graphics g){
	g.fillRect(0, 0, WIDTH * SCALE, HEIGHT * SCALE);
}

und diese rufst du dann z.B hier auf :

Java:
private void render(){
	Graphics2D g = (Graphics2D)image.getGraphics();

	clearScreen(g);  // <<----
		
	for (Entry<Class<? extends WorldObject>, WorldObject> entry : worldObjects.entrySet()) {
		entry.getValue().draw(g);
	}
		
	g.dispose();
	}
 
Zuletzt bearbeitet:

Neue Themen


Zurück
Oben