我正在编写一个简单的游戏，我想将我的帧速率限制在 60 fps 而不让循环吃掉我的 cpu。我该怎么做？
问问题
58756 次
10 回答
31
您可以阅读游戏循环文章。在尝试实现任何东西之前，首先了解游戏循环的不同方法非常重要。
于 2009-04-21T06:05:28.100 回答
12
我接受了@cherouvim 发布的游戏循环文章，我采用了“最佳”策略并尝试为 java Runnable 重写它，似乎对我有用
double interpolation = 0;
final int TICKS_PER_SECOND = 25;
final int SKIP_TICKS = 1000 / TICKS_PER_SECOND;
final int MAX_FRAMESKIP = 5;
@Override
public void run() {
double next_game_tick = System.currentTimeMillis();
int loops;
while (true) {
loops = 0;
while (System.currentTimeMillis() > next_game_tick
&& loops < MAX_FRAMESKIP) {
update_game();
next_game_tick += SKIP_TICKS;
loops++;
}
interpolation = (System.currentTimeMillis() + SKIP_TICKS - next_game_tick
/ (double) SKIP_TICKS);
display_game(interpolation);
}
}
于 2013-01-20T03:42:58.270 回答
5
简单的答案是将 java.util.Timer 设置为每 17 毫秒触发一次，并在计时器事件中完成您的工作。
于 2009-04-21T06:59:58.187 回答
4
以下是我在 C++ 中的做法……我相信你可以适应它。
void capFrameRate(double fps) {
static double start = 0, diff, wait;
wait = 1 / fps;
diff = glfwGetTime() - start;
if (diff < wait) {
glfwSleep(wait - diff);
}
start = glfwGetTime();
}
capFrameRate(60)每个循环只需调用一次。它会休眠，因此不会浪费宝贵的周期。glfwGetTime()返回程序启动后的时间（以秒为单位）...我相信您可以在 Java 中的某个地方找到等价物。
于 2009-04-21T07:20:18.327 回答
3
这是使用 Swing 并在不使用 Timer 的情况下获得相当准确的 FPS 的提示。
首先不要在事件调度线程中运行游戏循环，它应该在自己的线程中运行，做艰苦的工作，而不是妨碍 UI。
显示游戏的 Swing 组件应该绘制自己覆盖此方法：
@Override
public void paintComponent(Graphics g){
// draw stuff
}
问题是游戏循环不知道事件调度程序线程何时真正开始执行绘制动作，因为在游戏循环中我们只调用了 component.repaint() ，它只请求稍后可能发生的绘制。
使用等待/通知，您可以让重绘方法等到请求的绘制发生，然后继续。
这是来自https://github.com/davidmoten/game-exploration的完整工作代码，它使用上述方法在 JFrame 上简单地移动字符串：
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.Image;
import javax.swing.JFrame;
import javax.swing.JPanel;
/**
* Self contained demo swing game for stackoverflow frame rate question.
*
* @author dave
*
*/
public class MyGame {
private static final long REFRESH_INTERVAL_MS = 17;
private final Object redrawLock = new Object();
private Component component;
private volatile boolean keepGoing = true;
private Image imageBuffer;
public void start(Component component) {
this.component = component;
imageBuffer = component.createImage(component.getWidth(),
component.getHeight());
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
runGameLoop();
}
});
thread.start();
}
public void stop() {
keepGoing = false;
}
private void runGameLoop() {
// update the game repeatedly
while (keepGoing) {
long durationMs = redraw();
try {
Thread.sleep(Math.max(0, REFRESH_INTERVAL_MS - durationMs));
} catch (InterruptedException e) {
}
}
}
private long redraw() {
long t = System.currentTimeMillis();
// At this point perform changes to the model that the component will
// redraw
updateModel();
// draw the model state to a buffered image which will get
// painted by component.paint().
drawModelToImageBuffer();
// asynchronously signals the paint to happen in the awt event
// dispatcher thread
component.repaint();
// use a lock here that is only released once the paintComponent
// has happened so that we know exactly when the paint was completed and
// thus know how long to pause till the next redraw.
waitForPaint();
// return time taken to do redraw in ms
return System.currentTimeMillis() - t;
}
private void updateModel() {
// do stuff here to the model based on time
}
private void drawModelToImageBuffer() {
drawModel(imageBuffer.getGraphics());
}
private int x = 50;
private int y = 50;
private void drawModel(Graphics g) {
g.setColor(component.getBackground());
g.fillRect(0, 0, component.getWidth(), component.getHeight());
g.setColor(component.getForeground());
g.drawString("Hi", x++, y++);
}
private void waitForPaint() {
try {
synchronized (redrawLock) {
redrawLock.wait();
}
} catch (InterruptedException e) {
}
}
private void resume() {
synchronized (redrawLock) {
redrawLock.notify();
}
}
public void paint(Graphics g) {
// paint the buffered image to the graphics
g.drawImage(imageBuffer, 0, 0, component);
// resume the game loop
resume();
}
public static class MyComponent extends JPanel {
private final MyGame game;
public MyComponent(MyGame game) {
this.game = game;
}
@Override
protected void paintComponent(Graphics g) {
game.paint(g);
}
}
public static void main(String[] args) {
java.awt.EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
MyGame game = new MyGame();
MyComponent component = new MyComponent(game);
JFrame frame = new JFrame();
// put the component in a frame
frame.setTitle("Demo");
frame.setSize(800, 600);
frame.setLayout(new BorderLayout());
frame.getContentPane().add(component, BorderLayout.CENTER);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
game.start(component);
}
});
}
}
于 2013-09-07T03:37:38.870 回答
2
这里已经有很多很好的信息，但我想分享我在这些解决方案中遇到的一个问题，以及解决方案。如果尽管有所有这些解决方案，您的游戏/窗口似乎跳过（尤其是在 X11 下），请尝试Toolkit.getDefaultToolkit().sync()每帧调用一次。
于 2015-03-25T13:04:18.903 回答
2
计时器对于控制 Java 中的 FPS 不准确。我已经找到了二手货。您将需要实现自己的计时器或进行有限制的实时 FPS。但不要使用 Timer，因为它不是 100% 准确的，因此无法正确执行任务。
于 2011-04-19T03:37:39.487 回答
0
在 java 中，您可以System.currentTimeMillis()获取以毫秒为单位的时间，而不是glfwGetTime().
Thread.sleep(time in milliseconds)让线程等待以防您不知道，并且它必须在一个try块内。
于 2009-11-04T01:36:36.450 回答
0
我所做的只是继续循环，并跟踪我上次制作动画的时间。如果已经至少 17 毫秒，则通过动画序列。
这样我可以检查任何用户输入，并根据需要打开/关闭音符。
但是，这是在一个帮助教孩子音乐的程序中，我的应用程序占用了电脑，因为它是全屏的，所以它不能很好地与其他人一起玩。
于 2009-11-04T01:46:11.827 回答
0
如果您使用 Java Swing 实现 60 fps 的最简单方法是像这样设置 javax.swing.Timer，这是制作游戏的常用方法：
public static int DELAY = 1000/60;
Timer timer = new Timer(DELAY,new ActionListener() {
public void actionPerformed(ActionEvent event)
{
updateModel();
repaintScreen();
}
});
在您的代码中的某处，您必须将此计时器设置为重复并启动它：
timer.setRepeats(true);
timer.start();
每秒有 1000 毫秒，通过将其除以您的 fps (60) 并设置具有此延迟的计时器（1000/60 = 16 毫秒向下舍入），您将获得一个固定的帧速率。我说“有点”，因为这在很大程度上取决于您在上面的 updateModel() 和 repaintScreen() 调用中所做的事情。
要获得更可预测的结果，请尝试在计时器中对两个调用进行计时，并确保它们在 16 毫秒内完成以保持 60 fps。通过内存的智能预分配、对象重用和其他事情，您还可以减少垃圾收集器的影响。但这是另一个问题。
于 2010-08-31T07:06:11.550 回答