¿Girar un rectángulo de Java Graphics2D?

Question

He buscado en todas partes y simplemente no puedo encontrar la respuesta.
¿Cómo giro un rectángulo en java?

Aquí es parte de mi código:

package net.chrypthic.Space; 

import javax.swing.*; 
import java.awt.*; 
import java.awt.event.*; 

public class Space extends JPanel implements ActionListener{ 
    Timer time; 
    public Space() 
    { 
     setVisible(true); 
     setFocusable(true); 
     addMouseMotionListener(new ML()); 
     addMouseListener(new ML()); 
     addKeyListener(new AL()); 
     time=new Timer(5, this); 
     time.start(); 
    } 
    public void paint(Graphics g) 
    { 
     super.paint(g); 
     Graphics2D g2d = (Graphics2D)g; 
     g2d.setColor(Color.WHITE); 
     Rectangle rect2 = new Rectangle(100, 100, 20, 20); 

     g2d.draw(rect2); 
     g2d.fill(rect2); 
    } 
    public void actionPerformed(ActionEvent ae) { 
     repaint(); 
    } 
    public class AL extends KeyAdapter 
    { 
     public void keyPressed(KeyEvent e) { 
     } 

     public void keyReleased(KeyEvent e) { 
     } 
    } 
    public class ML extends MouseAdapter 
    { 
     public void mouseMoved(MouseEvent e) { 
     } 

     public void mousePressed(MouseEvent e){ 
     } 
    } 
} 

Probé g2d.rotate (100D); pero no funcionó. Gracias de antemano.

Aquí está mi código editado:

package net.chrypthic.Space; 
import java.awt.*; 
import java.awt.event.*; 
import javax.swing.*; 

public class Space extends JPanel implements ActionListener{ 
    Timer time; 
    public Space() 
    { 
     setVisible(true); 
     setFocusable(true); 
     setSize(640, 480); 
     setBackground(Color.BLACK); 
     time=new Timer(5, this); 
     time.start(); 
    } 
    public void paintComponent(Graphics g) 
    { 
     super.paintComponent(g); 
     Graphics2D g2d = (Graphics2D)g; 
     Rectangle rect1 = new Rectangle(100, 100, 20, 20); 
     g2d.setColor(Color.WHITE); 
     g2d.translate(rect1.x+(rect1.width/2), rect1.y+(rect1.height/2)); 
     g2d.rotate(Math.toRadians(90)); 
     g2d.draw(rect1); 
     g2d.fill(rect1); 
    } 
    public void actionPerformed(ActionEvent e) 
    { 
     repaint(); 
    } 
} 

Answer 1

Para las imágenes que tienen que utilizar drawImage método de Graphics2D con el pariente AffineTransform.

Por la forma que puede girar Graphics2D sí:

public void paintComponent(Graphics g) 
{ 
    super.paintComponent(g); 
    Graphics2D g2d = (Graphics2D)g; 
    g2d.setColor(Color.WHITE); 
    Rectangle rect2 = new Rectangle(100, 100, 20, 20); 

    g2d.rotate(Math.toRadians(45)); 
    g2d.draw(rect2); 
    g2d.fill(rect2); 
} 

Y por cierto, se debe reemplazar el método paintComponent en lugar de pintura.

Citando JComponent 's API:

Se invoca por oscilación para dibujar componentes. Las aplicaciones no deben invocar la pintura directamente, sino que deben usar el método de repintado para programar el componente para volver a dibujar.

Este método en realidad delega el trabajo de pintar en tres métodos protegidos : paintComponent, paintBorder y paintChildren. Se llaman en el orden indicado para garantizar que los niños aparecen en el parte superior del componente. En general, el componente y sus hijos no deben pintar en el área de insertos asignada al borde. Las subclases pueden anular este método, como siempre. Una subclase que solo quiere especializar el método de pintura del delegado de la interfaz de usuario (UI) debe simplemente anular paintComponent.

Recuerde también que cuando realiza una transformación afín, como una rotación, el objeto gira implícitamente alrededor del origen del eje. Entonces, si su intención es rotarla alrededor de un punto arbitrario, antes de traducirla de nuevo al origen, girarla y luego volver a traducirla al punto deseado.

Answer 2

public void draw(Graphics2D g) { 
    Graphics2D gg = (Graphics2D) g.create(); 
    gg.rotate(angle, rect.x + rect.width/2, rect.y + rect.height/2); 
    gg.drawRect(rect.x, rect.y, rect.width, rect.height); 
    gg.dispose(); 

    gg = (Graphics2D) g.create(); 
    ... other stuff 
} 

Graphics.create() y Graphics.dispose() le permiten guardar los parámetros de transformación actuales (al igual que la fuente actual, accidente cerebrovascular, pintura, etc.), y para restaurarlos después. Es el equivalente a glPushMatrix() y glPopMatrix() en OpenGL.

También puede aplicar una rotación inversa una vez que dibujó el rectángulo para revertir la matriz de transformación a su estado inicial. Sin embargo, las aproximaciones de coma flotante durante las restas pueden conducir a un resultado falso.

Answer 3

El único problema con g2d.rotate es que no lo rota alrededor de un punto específico. En su mayor parte, se equivocará cuando desee su Imagen y luego lo forzará a mover las coordenadas xey de la imagen. No lo usaría, especialmente para un juego. Lo que debes mirar es girar un punto en Java.

Answer 4

Otra forma es mediante el uso de Path2D, con ella se puede girar el camino y no todo el objeto gráfico:

Rectangle r = new Rectangle(x, y, width, height); 
Path2D.Double path = new Path2D.Double(); 
path.append(r, false); 

AffineTransform t = new AffineTransform(); 
t.rotate(angle); 
path.transform(t); 
g2.draw(path);