BufferedImage 为什么这行得通？

Question

我要post代码。它不是太复杂或太长。我只是不明白为什么会这样。

在下面的代码中，图像在 render 方法中渲染，但它不会在游戏循环中更新。我不知道图像是如何更新的。代码运行，输出显示不断变化的移动颜色。我看到 tick 方法更新了 pixels[] 数组，但即使在循环之外，像素也被设置为等于图像中的数据。如何改变 pixels[] 改变形象。请帮助我理解这种关系。

如果我 post 有误，我深表歉意。 我进行了搜索，但大多数人似乎都遇到了它不起作用的问题。我的工作正常。我只需要明白为什么。图像未在 tick 方法中更新。像素是。那么为什么图像会发生变化，就好像它以某种方式连接到 pixels[]???

我的代码如下：

package com.channelsplace.game;

import java.awt.BorderLayout;
import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.image.BufferStrategy;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferInt;

import javax.swing.JFrame;

import com.channelsplace.game.gfx.SpriteSheet;

public class Game extends Canvas implements Runnable
{
    private boolean running;
    private static final long serialVersionUID = 1L;
    public static final int WIDTH = 160;
    public static final int HEIGHT = WIDTH / 12*9;
    public static final int SCALE = 3;
    public static final String NAME = "Game";
    private JFrame frame;
    public int tickCount = 0;
/**********************************************************************
The next two lines are part of what I don't get.
below this you'll see a tick method that updates the pixels array
and a render method that renders image. but no overt flow of information 
from pixels to image.
**********************************************************************/ 
private BufferedImage image = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
    private int[] pixels = ((DataBufferInt) image.getRaster().getDataBuffer()).getData();
    private SpriteSheet spriteSheet = new SpriteSheet("/sprite_sheet.png");

    public Game()
    {
        setMinimumSize(new Dimension(WIDTH * SCALE, HEIGHT * SCALE));
        setMaximumSize(new Dimension(WIDTH * SCALE, HEIGHT * SCALE));
        setPreferredSize(new Dimension(WIDTH * SCALE, HEIGHT * SCALE));
        frame = new JFrame(NAME);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLayout(new BorderLayout());
        frame.add(this, BorderLayout.CENTER);
        frame.pack();
        frame.setResizable(false);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);

    }

    public synchronized void start()
    {
        running = true;
        new Thread(this).start();
    }
    public synchronized void stop()
    {
        running = false;
    }

    public void run() 
    {
        long lastTime = System.nanoTime();
        double nsPerTick = 1000000000D/60D;
        int ticks = 0;
        int frames = 0;
        long lastTimer = System.currentTimeMillis();
        double delta = 0;
        boolean shouldRender = true;        
        while(running)
        {
            long now = System.nanoTime();
            delta += (now - lastTime) / nsPerTick;
            lastTime = now;

            if (delta >= 1)             
            {
                ticks++;
                tick();
                delta -= 1;
                shouldRender = true;
            }

            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (shouldRender)
            {
                frames++;
                render();
                shouldRender = false;
            }


            if (System.currentTimeMillis()-lastTimer>=1000)
            {
                lastTimer += 1000;
                System.out.println(frames+" , "+ticks);
                frames = 0;
                ticks = 0;
            }
        }

    }

    public void tick()
    {
        tickCount++;
        for (int i = 0; i < pixels.length; i++)
        {
            pixels[i] = i + tickCount;
        }
    }

    public void render()
    {
        BufferStrategy bs = getBufferStrategy();
        if (bs == null)
        {
            createBufferStrategy(3);
            return;
        }
        Graphics g = bs.getDrawGraphics();
        g.drawImage(image, 0, 0, getWidth(), getHeight(),null);
        g.dispose();
        bs.show();

    }
    public static void main(String[] args) 
    {
        new Game().start();

    }
}

//thanks for reading

Answer 1

but it does not get updated in the game loop.

image确实在游戏循环中得到更新：

public void tick()
{
    tickCount++;
    for (int i = 0; i < pixels.length; i++)
    {
        // where the image gets updated
        // pixels[i] = i + tickCount; // <-- it does exactly the same as the alternative below
        image.setRBG(i/WIDTH, i%WIDTH, i + tickCount);
    }
}

Sounds obvious but pixels[] is an int[] as declared and not part of image.

我明白了困惑所在。

什么是图像？图像只是一些像素，存储在 int 数组 pixels[].

中

假设您创建了一个 20x30 大小的 BufferedImage，它在内部创建了一个大小为 20*30 或 600 的 int 数组。数组中的每个 int 代表 1 个像素，在 RGB 颜色模型中，即，每个 int 值都是 3 个分量 R(Red)/G(Green)/B(Blue) 的组合。每个组件占用 int 的 8 位（32 位）。如果支持，其余 8 位可用于 Alpha 通道（透明度）。

(如果你看BufferedImage的源码，它不会自己创建int数组，它使用RasterWriter，它使用DataBuffer，这是实现细节, 我会把它去掉以避免更多的混乱。)

BufferedImage 提供了多种方法来访问（即 read/write）数组中的值。

在tick()中直接写入数组pixels[]，也可以调用方法setRGB(x, y, rgb)写入数组，无论哪种方式，修改的都是同一个数组, 所谓 "image".

在render()中，它绘制"image"，即，它从图像中包含的数组中读取值，并在屏幕上绘制像素。

希望这更清楚一些。

Answer 2

谢谢大家。我终于想通了，当创建pixels[]时，它指向图像的数据。我认为它是一个单独的 int[] 并且在创建 pixels[] 的地方，数据正在使用“=”复制到它。但事实并非如此。它指向图像中的数据。这不是深拷贝。像素和图像数据共享相同的内存地址。感谢您的耐心等待。频道

BufferedImage 为什么这行得通？

BufferedImage why does this work?

java

bufferedimage

render

jframe