Java - 使用 Graphics.drawImage() 和 2 屏幕缓冲策略绘制许多图像会扭曲和剪切图像

Question

我正在使用循环来调用双缓冲绘画。这与覆盖我唯一的面板的重绘方法一起，旨在将重绘的完全控制传递给我的循环，并且仅在必要时才渲染（即在 GUI 中进行了一些更改）。

这是我的渲染例程：

    Log.write("renderer painting");

    setNeedsRendering(false);

    Graphics g = frame.getBufferStrategy().getDrawGraphics();

    g.setFont(font);
    g.setColor(Color.BLACK);
    g.fillRect(0, 0, window.getWidth(),window.getHeight());

    if(frame != null)
        window.paint(g);

    g.dispose();

    frame.getBufferStrategy().show();

如您所见，它非常标准。我从缓冲区策略中获取 grpahics 对象（初始化为 2），将其设置为黑色并将其传递给“窗口”对象的 Paint 方法。

使用图形对象完成窗口后，我将其处理并调用缓冲区策略上的 show 来显示虚拟缓冲区的内容。

需要注意的是，窗口将图形对象传递给填充窗口的许多其他子组件，而每个子组件又使用图形对象的相同实例在屏幕上绘制某些内容：文本、形状或图像。

当系统运行并渲染大图像时，我的问题开始出现。图像似乎被切割成七块，并在图像应渲染的位置内以不同的偏移量一次又一次地绘制（3-4 次）。请参阅我的附图：

这是原始图像： 替代文本 http://img109.imageshack.us/img109/8308/controller.png< /a>

这是我得到的： 替代文本 http://img258.imageshack.us/img258/3248/probv.png< /a>

请注意，在第二张图片中，我在图片上渲染形状 - 这些形状始终位于正确的位置。

知道为什么会发生这种情况吗？ 如果我将图像保存到文件中，就像它在内存中一样，就在调用 g.drawImage(...) 之前，它与原始图像相同。

Answer 1

呃，你正在使用 Swing 吗？
通常，Swing 自动渲染图像，您无法将其关闭。重绘()
方法越界是因为 Swing 有一个非常复杂的渲染例程
AWT 小部件的方法兼容性和多项优化，包括 仅绘图
必要时！
如果您想使用高速绘图 API，请使用带有 BufferStrategy 的组件
像 JFrame 和 Window 一样，使用

setIgnoreRepaint(false);

要关闭 Swing 渲染，请设置绘图循环并绘制内容本身。
或者您可以使用 JOGL 进行 OpenGL 渲染。你使用的方法似乎完全
与正确的 Java2D 用法不一致。

这里正确的使用：

public final class FastDraw extends JFrame {
  private static final transient double NANO = 1.0e-9;


 private BufferStrategy bs;

 private BufferedImage frontImg;

 private BufferedImage backImg;

 private int PIC_WIDTH,
             PIC_HEIGHT;

  private Timer timer;

  public FastDraw() {
    timer = new Timer(true);
    JMenu menu = new JMenu("Dummy");
    menu.add(new JMenuItem("Display me !"));
    menu.add(new JMenuItem("Display me, too !"));
    JMenuBar menuBar = new JMenuBar();
    menuBar.add(menu);
    setJMenuBar(menuBar);

    setIgnoreRepaint(true);
    setVisible(true);
    addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent evt) {
        super.windowClosing(evt);
        timer.cancel();
        dispose();
        System.exit(0);
      }
    });
    try {
      backImg = javax.imageio.ImageIO.read(new File("MyView"));
      frontImg = javax.imageio.ImageIO.read(new File("MyView"));
    }
    catch (IOException e) {
      System.out.println(e.getMessage());
    }
    PIC_WIDTH = backImg.getWidth();
    PIC_HEIGHT = backImg.getHeight();
    setSize(PIC_WIDTH, PIC_HEIGHT);


    createBufferStrategy(1); // Double buffering
    bs = getBufferStrategy();
    timer.schedule(new Drawer(),0,20);
  }
  public static void main(String[] args) {
    new FastDraw();
  }

  private class Drawer extends TimerTask {

    private VolatileImage img;

    private int count = 0;

    private double time = 0;

    public void run() {
      long begin = System.nanoTime();
      Graphics2D  g  = (Graphics2D) bs.getDrawGraphics();
      GraphicsConfiguration gc = g.getDeviceConfiguration();
      if (img == null)
        img = gc.createCompatibleVolatileImage(PIC_WIDTH, PIC_HEIGHT);
      Graphics2D g2 = img.createGraphics();
      // Zeichenschleife
      do {
        int valStatus = img.validate(gc);
        if (valStatus == VolatileImage.IMAGE_OK)
          g2.drawImage(backImg,0,0,null);
        else {
          g.drawImage(frontImg, 0, 0, null);
        }
        // volatile image is ready
        g.drawImage(img,0,50,null);
        bs.show();
      } while (img.contentsLost());
      time = NANO*(System.nanoTime()-begin);
      count++;
      if (count % 100 == 0)
        System.out.println(1.0/time);
    }
  }