为什么当我移动鼠标时，我的自定义Swing组件重绘速度会更快？(Java)

Why does my custom Swing component repaint faster when I move the mouse? (Java)(为什么当我移动鼠标时，我的自定义Swing组件重绘速度会更快？(Java))

问题描述

我正在尝试用Java和Swing制作2D游戏，但窗口刷新太慢。但如果我移动鼠标或按键，窗口会以应有的速度刷新！

这是一个GIF，显示只有在我移动鼠标时窗口才会快速刷新。

为什么窗口刷新如此缓慢？为什么鼠标和键盘会影响其刷新率？如果可能，如何使其始终快速刷新？

背景信息

我使用javax.swing.Timer每隔1/25秒更新一次游戏状态，之后调用游戏面板上的repaint()重新绘制场景。

我知道计时器可能不会总是精确延迟1/25秒。

我还理解调用reaint()只会请求尽快重新绘制窗口，而不会立即重新绘制窗口。

我的显卡不支持OpenGL 2+或硬件加速的3D图形，这就是我不使用libgdx或JME进行游戏开发的原因。

系统信息

• 操作系统：Linux Mint 19 Tara
• JDK版本：OpenJDK 11.0.4
• 显卡：英特尔公司82945G/GZ

研究

This Stack Overflow user描述了我遇到的相同问题，但据报道，作者通过在单独的计时器上重复调用reaint()解决了该问题。我试过了，确实使窗口刷新快了一些，但即使这样也比我想要的要慢。在这种情况下，在窗口上摆动鼠标仍可提高刷新率。因此，这篇帖子似乎并没有真正解决问题。

Another Stack Overflow user也遇到了这个问题，但他们在游戏循环中使用的是连续的While循环，而不是计时器。显然，该用户通过在While循环中使用Thread.sleep()解决了这个问题。但是，我的代码使用计时器来实现延迟，所以我不知道Thread.sleep()如何解决我的问题，甚至不知道我会把它放在哪里。

我已经通读了Painting with AWT and Swing以确定我是否误解了重新绘制的概念，但该文档中的任何内容都没有为我阐明这个问题。每当游戏更新时，我都会调用reaint()，并且只有在进行鼠标或键盘输入时，窗口才会快速刷新。

我已经在网上搜索了几天，试图找到答案，但似乎没有什么帮助！

代码

import java.awt.Graphics;
import java.awt.Dimension;
import java.awt.Color;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.Timer;

class Game {
        public static final int screenWidth = 160;
        public static final int screenHeight = 140;

        /**
         * Create and show the GUI.
         */
        private static void createAndShowGUI() {
                /* Create the GUI. */
                JFrame frame = new JFrame("Example");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setResizable(false);
                frame.getContentPane().add(new GamePanel());
                frame.pack();

                /* Show the GUI. */
                frame.setVisible(true);
        }

        /**
         * Run the game.
         *
         * @param args  the list of command-line arguments
         */
        public static void main(String[] args) {
                /* Schedule the GUI to be created on the EDT. */
                SwingUtilities.invokeLater(() -> createAndShowGUI());
        }

}

/**
 * A GamePanel widget updates and shows the game scene.
 */
class GamePanel extends JPanel {
        private Square square;

        /**
         * Create a game panel and start its update-and-draw cycle
         */
        public GamePanel() {
                super();

                /* Set the size of the game screen. */
                setPreferredSize(
                        new Dimension(
                                Game.screenWidth,
                                Game.screenHeight));

                /* Create the square in the game world. */
                square = new Square(0, 0, 32, 32, Square.Direction.LEFT);

                /* Update the scene every 40 milliseconds. */
                Timer timer = new Timer(40, (e) -> updateScene());
                timer.start();
        }

        /**
         * Paint the game scene using a graphics context.
         *
         * @param g  the graphics context
         */
        @Override
        protected void paintComponent(Graphics g) {
                super.paintComponent(g);

                /* Clear the screen. */
                g.setColor(Color.WHITE);
                g.fillRect(0, 0, Game.screenWidth, Game.screenHeight);

                /* Draw all objects in the scene. */
                square.draw(g);
        }

        /**
         * Update the game state.
         */
        private void updateScene() {
                /* Update all objects in the scene. */
                square.update();

                /* Request the scene to be repainted. */
                repaint();
        }

}

/**
 * A Square is a game object which looks like a square.
 */
class Square {
        public static enum Direction { LEFT, RIGHT };

        private int x;
        private int y;
        private int width;
        private int height;
        private Direction direction;

        /**
         * Create a square game object.
         *
         * @param x          the square's x position
         * @param y          the square's y position
         * @param width      the square's width (in pixels)
         * @param height     the square's height (in pixels)
         * @param direction  the square's direction of movement
         */
        public Square(int x,
                      int y,
                      int width,
                      int height,
                      Direction direction) {
                this.x = x;
                this.y = y;
                this.width = width;
                this.height = height;
                this.direction = direction;
        }

        /**
         * Draw the square using a graphics context.
         *
         * @param g  the graphics context
         */
        public void draw(Graphics g) {
                g.setColor(Color.RED);
                g.fillRect(x, y, width, height);
                g.setColor(Color.BLACK);
                g.drawRect(x, y, width, height);
        }

        /**
         * Update the square's state.
         *
         * The square slides horizontally
         * until it reaches the edge of the screen,
         * at which point it begins sliding in the
         * opposite direction.
         *
         * This should be called once per frame.
         */
        public void update() {
                if (direction == Direction.LEFT) {
                        x--;

                        if (x <= 0) {
                                direction = Direction.RIGHT;
                        }
                } else if (direction == Direction.RIGHT) {
                        x++;

                        if (x + width >= Game.screenWidth) {
                                direction = Direction.LEFT;
                        }
                }
        }
}

推荐答案

我猜您可能无法通过enabling OpenGL解决问题，因为您的GPU不支持它，一个可能愚蠢的解决方法可能是在每个计时器的迭代中手动触发一种事件。

/* Update the scene every 40 milliseconds. */
final Robot robot = new Robot();
Timer timer = new Timer(40, (e) -> {
    robot.mouseRelease(0); //some event
    updateScene();
});
timer.start();

(在Swing应用程序中，您唯一可以Thread.sleep()的地方是SwingWorker'sdoInBackground方法内部。如果在EDT中调用它，整个GUI将冻结，因为无法发生事件。)

这篇关于为什么当我移动鼠标时，我的自定义Swing组件重绘速度会更快？(Java)的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持编程学习网！