Java究竟怎么玩？

眾所周知，Java應用的運行速度雖然不慢，卻也談不上快，以最新的JRE1.6表現來說，至多也就是優勝于一些純粹的解釋型語言，距離C/C++等編譯型的執行效率還有一定差距。

 

平心而論，如果我們使用Java去制作一些簡單的桌面應用，那么目前Java組件的繪圖速度勉強還能接受；但如果用Java來進行游戲開發，尤其是制作一些需要高FPS才能滿足的動態效果，就必須利用技術手段對其加以優化，解決其繪圖效率問題，其它才有的談。

 

什么是FPS？

 

這里所說的FPS，并非指射擊游戲，而是指俗稱的“幀率”（Frames per Second，縮寫：FPS）或“赫茲”（Hz）。筆者在以前的博文中曾給出過專門的解釋及Java實現示例，此處不再贅述。

 

受到人類眼球的生理結構制約，通常情況下只要我們所見畫面高于每秒16幀，就會認為畫面是連貫的，生物學上稱此現象為視覺暫留，這也就是為什么電影膠片是一格一格拍攝出來，然而我們卻認為它是連續的一段。當然，所謂的16幀也只是一個中值，并非放之四海而皆準，根據具體視覺對象不同，幀率的具體標準會有所變化。在最壞情況下，動畫不低于每秒12幀，現代電影不低于24幀，動作游戲不低于30幀，在人眼中的畫面才是連續不間斷的。

 

總之，FPS數值越高則畫面流暢度便越高，越低則越顯停滯，要提高Java游戲運行效率，那么焦點就必然要集中在如何提高程序的FPS之上。

 

我們該從什么地方入手，才能提高FPS？

 

Java繪圖最終要通過native，這是地球人都知道的事情。這意味著除非我們學習SWT重寫本地圖形接口，否則顯示部分我們無法干涉；這樣便決定了我們對FPS的優化必然要集中在本地圖形系統調用之前，而非之后。也就是說，提高Java應用的FPS，還要老生常談的從Image與Graphics及其相關子類入手。

 

那么，對這些盡人皆知的Java繪圖組件，我們究竟能改進那些部分呢？

 

我在不久前發布的博文《Java游戲開發中應始終堅持的10項基本原則》中，曾經就如何構建一個高效的Java游戲發表過一些見解，其中第7點“始終雙緩沖游戲圖像”，它不但是解決Java圖像閃爍問題的關鍵所在，而且同樣是提高Java游戲幀率的制勝法寶之一。是的，Java繪圖機能的優化與改進，關鍵就在于如何對其緩沖區域進行優化處理。

 

下面，我將展示三種不同的Java緩沖繪圖方式。

 

1、采用BufferedImage對象進行緩沖

 

   這種方法是最簡單，同時也是最常用的雙緩沖構建方式，也就是構建一個BufferedImage緩沖當前繪圖，所有Graphics操作在其上進行，僅在需要時才將貼圖paint于窗體之上，使用上再簡單不過，但效率如何呢？文章進行到此處時尚不得而知。

 

2、采用BufferStrategy構建緩沖區

 

使用BufferStrategy構建緩沖能夠獲得系統所提供的硬件加速，Java系統會根據本地環境選擇最適合的BufferStrategy。要創建 BufferStrategy ，需要使用 createBufferStrategy() 方法告訴系統你所期望的緩沖區數目（通常使用雙緩沖，也就是填入“2”），并使用 getDrawGraphics() 方法在緩沖區之間進行交換，該方法返回下一個要使用的緩沖區。BufferStrategy最大的缺點與優點都在于其受本地圖形環境影響，既不會出現很快的圖形環境跑出很慢的FPS，也別指望很慢的圖形環境跑出很快的FPS。

 

3、完全在BufferedImage的DataBuffer中進行圖像處理

 

每個BufferedImage都有一個與之對應得WritableRaster對象（getRaster方法獲得），通過它我們獲得指定BufferedImage的DataBuffer（getDataBuffer方法獲得），與方法1類似，我們同樣構建一個BufferedImage緩沖當前所有繪圖，所有操作都在其上進行，僅在需要時才將貼圖paint于窗體之上。但區別在于，由于DataBuffer可以轉化為描述BufferedImage象素點的int[]，byte[]或short[]等數組集合，因此我們不再使用Java提供的Graphics對象，而是直接操作像素點進行所有繪圖的實現。 但是，這樣進行數組操作會快嗎？

 

現在我們為其各自構建三個示例，盡量以比較趨同的處理流程構建，分別測算三種方法的具體效率。

 

（PS：寫完才突然想起，這臺2002年買的電腦實在不適合測試FPS（-_-|||），較新機型的FPS至少能達到此測試結果的2倍以上，特此聲明……）

 

（PS：以下圖像素材源自成都漢森信息技術有限公司首頁，特此聲明）

 

以下開始將分別對三種方法分別進行繪制1名角色、繪制100名角色、繪制1000名角色的簡單FPS繪圖效率測算。

 

一、采用BufferedImage對象進行緩沖

 

源碼如下：

 

1、DoubleBufferGameFrame.Java

 

package test1; import java.awt.Dimension; import java.awt.Frame; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; /** * @author chenpeng * @email：ceponline@yahoo.com.cn */ public class DoubleBufferGameFrame extends Frame implements Runnable { /** * */ private static final long serialVersionUID = 1L; private int width = 480; private int height = 360; private DoubleBufferCanvas canvas = null; public DoubleBufferGameFrame() { super("AWT標準Graphics2D使用測試"); this.setPreferredSize(new Dimension(width + 5, height + 25)); this.requestFocus(); this.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); canvas = new DoubleBufferCanvas(); this.add(canvas); this.pack(); this.setResizable(false); this.setLocationRelativeTo(null); this.setIgnoreRepaint(true); Thread thread = new Thread(this); thread.start(); } public void run() { for (;;) { canvas.drawScreen(); } } public static void main(String[] args) { DoubleBufferGameFrame frm = new DoubleBufferGameFrame(); frm.setVisible(true); } }

 

2、DoubleBufferCanvas.Java

 

package test1; import java.awt.Canvas; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Image; import java.awt.image.BufferedImage; import java.util.Random; public class DoubleBufferCanvas extends Canvas { /** * */ private static final long serialVersionUID = 1L; private boolean isFPS = true; private boolean initFlag; private int frames = 0; private long totalTime = 0; private long curTime = System.currentTimeMillis(); private long lastTime = curTime; private Random rand = new Random(); private int fps; private Image backImage = ImageUtils.loadImage("back.gif"); private Image hero_idle_0 = ImageUtils.loadImage("idle0_0.png",true); private BufferedImage bufferImage; private Graphics2D graphics2D; public DoubleBufferCanvas() { } public void update(Graphics g) { paint(g); } public void paint(Graphics g) { if (initFlag) { graphics2D.drawImage(backImage, 0, 0, null); for (int i = 0; i < 1000; ++i) { int x = rand.nextInt(480); int y = rand.nextInt(360); graphics2D.drawImage(hero_idle_0, x-100, y-100, null); } graphics2D.drawString(("當前FPS:" + fps).intern(), 15, 15); g.drawImage(bufferImage, 0, 0, null); g.dispose(); } } private synchronized void initializtion() { bufferImage = ImageUtils.createImage(getWidth(), getHeight(), true); graphics2D = bufferImage.createGraphics(); initFlag = true; } public synchronized void drawScreen() { getGraphics2D(); repaint(); if (isFPS) { lastTime = curTime; curTime = System.currentTimeMillis(); totalTime += curTime - lastTime; if (totalTime > 1000) { totalTime -= 1000; fps = frames; frames = 0; } ++frames; } Thread.yield(); } public synchronized Graphics2D getGraphics2D() { if (!initFlag) { initializtion(); } return graphics2D; } }

 

 

場景圖1、角色圖1、 FPS 60 - 70

 

場景圖1、角色圖100 、FPS 20 - 25

場景圖1、角色圖1000、 FPS 13 - 17

 

二、采用BufferStrategy構建緩沖區（雙緩沖）

 

1、BufferStrategyGameFrame.java

 

package test1; import java.awt.Dimension; import java.awt.Frame; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; /** * @author chenpeng * @email：ceponline@yahoo.com.cn */ public class BufferStrategyGameFrame extends Frame implements Runnable { /** * */ private static final long serialVersionUID = 1L; private BufferStrategyCanvas canvas = null; private int width = 480; private int height = 360; public BufferStrategyGameFrame() { super("AWT標準Graphics2D(BufferStrategy)使用測試"); this.setPreferredSize(new Dimension(width + 5, height + 25)); this.requestFocus(); this.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); canvas = new BufferStrategyCanvas(); this.add(canvas); this.pack(); this.setResizable(false); this.setLocationRelativeTo(null); this.setIgnoreRepaint(true); Thread thread = new Thread(this); thread.start(); } public void run() { for (;;) { canvas.drawScreen(); } } public static void main(String[] args) { BufferStrategyGameFrame frm = new BufferStrategyGameFrame(); frm.setVisible(true); } } 

 

 

2、BufferStrategyCanvas.java

 

package test1; import java.awt.Canvas; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.GraphicsConfiguration; import java.awt.GraphicsDevice; import java.awt.GraphicsEnvironment; import java.awt.Image; import java.awt.image.BufferStrategy; import java.awt.image.BufferedImage; import java.util.Random; public class BufferStrategyCanvas extends Canvas { /** * */ private static final long serialVersionUID = 1L; private boolean isFPS = true; private boolean initFlag; private int frames = 0; private long totalTime = 0; private long curTime = System.currentTimeMillis(); private long lastTime = curTime; private Random rand = new Random(); private int fps; private Image backImage = ImageUtils.loadImage("back.gif"); private Image hero_idle_0 = ImageUtils.loadImage("idle0_0.png", true); private BufferedImage screenImage; final static GraphicsEnvironment environment = GraphicsEnvironment .getLocalGraphicsEnvironment(); final static GraphicsDevice graphicsDevice = environment .getDefaultScreenDevice(); final static GraphicsConfiguration graphicsConfiguration = graphicsDevice .getDefaultConfiguration(); private Graphics canvasGraphics = null; private BufferStrategy bufferImage; private Graphics2D graphics2d; public BufferStrategyCanvas() { } public void createBufferGraphics() { createBufferStrategy(2); bufferImage = getBufferStrategy(); screenImage = graphicsConfiguration.createCompatibleImage(getWidth(), getHeight()); graphics2d = screenImage.createGraphics(); } public synchronized void paintScreen() { if (initFlag) { graphics2d.drawImage(backImage, 0, 0, null); for (int i = 0; i < 1000; ++i) { int x = rand.nextInt(480); int y = rand.nextInt(360); graphics2d.drawImage(hero_idle_0, x - 100, y - 100, null); } graphics2d.drawString(("當前FPS:" + fps).intern(), 15, 15); canvasGraphics = bufferImage.getDrawGraphics(); canvasGraphics.drawImage(screenImage, 0, 0, null); bufferImage.show(); canvasGraphics.dispose(); } } private synchronized void initializtion() { createBufferGraphics(); initFlag = true; } public synchronized void drawScreen() { loadGraphics(); paintScreen(); if (isFPS) { lastTime = curTime; curTime = System.currentTimeMillis(); totalTime += curTime - lastTime; if (totalTime > 1000) { totalTime -= 1000; fps = frames; frames = 0; } ++frames; } Thread.yield(); } public synchronized Graphics2D loadGraphics() { if (!initFlag) { initializtion(); } return graphics2d; } }

 

場景圖1、角色圖1 、FPS 80 - 90

場景圖1、角色圖100、 FPS 25 - 35

場景圖1、角色圖1000、 FPS 3 - 6

 

三、完全在BufferedImage的DataBuffer中進行圖像處理

 

實際上在Java網游海盜時代、Java網游暗影世界等等網絡游戲、還有netbaens以及其它種種不算慢的Java應用中，都存在大量使用DataBuffer進行的圖像渲染；但在使用方式上，卻只有暗影使用的JGnet引擎與常用的Image與Graphics搭配模式較為接近，所以此示例使用了JGnet的部分代碼構建。

 

（PS：實際上漢森的JGnet客戶端引擎目前并未開源，此部分代碼得自其主頁homepage.jar的反編譯，是前天我看csdn的CTO欄目專訪漢森老總后去其首頁發現的；視頻中說JGnet有部分代碼準備開源，我估計應該是homepage.jar里這部分，因為沒有混淆且功能較少，其網站地址http://www.handseeing.com，純Applet站點）。

 

為給不愿反編譯的看客提供方便，這里我稍微對JGnet進行一點分析（即homepage.jar中的那部分）。

 

就代碼來看，JGnet中所有UI繼承自GUIWidget（GUIWidget繼承自Container），所有JGnet產生的GUI組件也都應當繼承它。JGnet提供了一個GUIRoot為底層面板，所有GUIWidget衍生組件都應附著于GUIRoot之上，另外該引擎提供有AbstractGameClient、ClientContext接口及相關實現用以調度相關組件，JGnet的GUIRoot載體可以使用Applet或者Frame。

 

JGnet中大部分資源采用zip打包，當然也可以讀取單圖，JGnet資源加載依賴于其提供的ImageFactory類，ImageFactory的操作可分為如下兩步：

 

第一步是addArchive，進行此步驟時指定的zip資源會被加載，其后將read圖像資源為ShortBufferImage，再根據zip中該資源對應路徑緩存到daff.utill包自備的HashMap中。

 

第二步是getImage，即獲得指定路徑的ShortBufferImage對象，此步驟以緩存優先，如果獲得失敗會嘗試調用loadImage方法再次加載，并緩存到daff包自備的HashMap對象中。其中loadImage方法會根據后綴判定加載的資源類型，其中jpg、gif或者png后綴文件會調用daff包中提供的AwtImageLoader類轉化為ShortBufferImage，而非此后綴文件會直接按照ShortBufferImage格式進行加載。

 

JGnet的圖像繪制主要使用其內部提供的ShortBufferImage及ShortBufferGraphics以及相關衍生類。ShortBufferImage是一個抽象類，沒有父類，所有JGnet中圖形資源都將表現為ShortBufferImage，繪制ShortBufferImage需要使用daff.gui包提供的專用畫布ShortBufferGraphics，實際上ShortBufferGraphics是一個針對于ShortBufferImage的象素渲染器，內部以short數組形式保存有一個空白BufferedImage的DataBuffer，所有繪制基于其上。

 

同大多數網游一樣，JGnet中大量使用自定義圖形格式(后綴.img)，其解釋與轉化通過CompressedImage類得以完成，由于自定義格式通常能更簡潔的聲明圖像中各元素關系，所以JGnet處理其自定義格式資源會比加載普通圖像資源更快。

 

JGnet會根據環境的不同會采用MsJvmGraphics或SunJvmGraphics兩套繪圖組件（皆繼承自ShortBufferGraphics），據此我們可以初步斷定其運行環境上兼容微軟jvm，也就是最低可運行于JRE1.1之上。

 

講解結束，下面我以JGnet進行針對DataBuffer進行渲染的FPS測試（對其某些細節進行了使用習慣上的擴展）。

 

 

 

1、DataBufferGameFrame.java

 

package test1; import java.awt.Dimension; import java.awt.Frame; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; /** * @author chenpeng * @email：ceponline@yahoo.com.cn */ public class DataBufferGameFrame extends Frame implements Runnable { /** * */ private static final long serialVersionUID = 1L; private DataBufferCanvas canvas = null; private int width = 480; private int height = 360; public DataBufferGameFrame() { super("JGnet中ShortBufferGraphics使用測試"); this.setPreferredSize(new Dimension(width + 5, height + 25)); this.requestFocus(); this.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); canvas = new DataBufferCanvas(); this.add(canvas); this.pack(); this.setResizable(false); this.setLocationRelativeTo(null); this.setIgnoreRepaint(true); Thread thread = new Thread(this); thread.start(); } public void run() { for (;;) { canvas.drawScreen(); } } public static void main(String[] args) { DataBufferGameFrame frm = new DataBufferGameFrame(); frm.setVisible(true); } }

2、DataBufferCanvas.java

package test1; import impl.gui.SunJvmGraphics; import java.awt.*; import java.util.Random; import daff.gui.ImageFactory; import daff.gui.ShortBufferFont; import daff.gui.ShortBufferGraphics; import daff.gui.ShortBufferImage; public class DataBufferCanvas extends Canvas { /** * */ private static final long serialVersionUID = 1L; private boolean isFPS = true; private ShortBufferGraphics shortBufferGraphics; private MyColor color = new MyColor(255, 255, 255); private ShortBufferFont font; private boolean initFlag; private static ImageFactory factory = new ImageFactory(20); private int frames = 0; private long totalTime = 0; private long curTime = System.currentTimeMillis(); private long lastTime = curTime; private Random rand = new Random(); private int fps; private ShortBufferImage hero_idle_0 = factory .getImage("image/hero/idle/idle0_0.img"); private ShortBufferImage backImage = factory.getImage("back.gif"); static { factory.addArchive("pack/hero.zip"); } public DataBufferCanvas() { } public void update(Graphics g) { paint(g); } public void paint(Graphics g) { if (initFlag) { shortBufferGraphics.drawImage(backImage, 0, 0); for (int i = 0; i < 1000; ++i) { int x = rand.nextInt(480); int y = rand.nextInt(360); shortBufferGraphics.drawImage(hero_idle_0, x - 100, y - 100); } shortBufferGraphics.drawString(font, color, ("當前FPS:" + fps) .intern(), 15, 15); shortBufferGraphics.drawTo(g, 0, 0); g.dispose(); } } private synchronized void initializtion() { shortBufferGraphics = (ShortBufferGraphics) new SunJvmGraphics(); shortBufferGraphics.createGraphics(getWidth(), getHeight(), this); font = new ShortBufferFont("Dialog", 0, 12, this); initFlag = true; } public synchronized void drawScreen() { loadGraphics().reset(); repaint(); if (isFPS) { lastTime = curTime; curTime = System.currentTimeMillis(); totalTime += curTime - lastTime; if (totalTime > 1000) { totalTime -= 1000; fps = frames; frames = 0; } ++frames; } Thread.yield(); } public synchronized ShortBufferGraphics loadGraphics() { if (!initFlag) { initializtion(); } return shortBufferGraphics; } }

 

場景圖1、角色圖1 、FPS 140 - 160

場景圖1、角色圖100 、FPS 115 - 125

場景圖1、角色圖1000 、FPS 55 - 70

 

通過簡單比較后我們可以發現，Graphics繪圖無論在直接BufferedImage雙緩沖或者利用BufferStrategy以換取硬件加速的前提下，都無法與使用DataBuffer直接進行像素繪圖的ShortBufferGraphics相比，BufferStrategy在繪制千人時更出現了令筆者整個人都斯巴達了的4幀|||，即使在測試中筆者改BufferedImage為VolatileImage也收效甚微，在配置較高的微機上應當會有些許改善，但用戶使用機型卻并非我們所能控制的。

 

由于JGnet中直接獲得圖像DataBuffer的short[]形式，并以此進行圖像繪制，所以 ShortBufferImage及ShortBufferGraphics稱得上是一組先天的Java圖形緩沖對象，就效率上講，使用ShortBufferGraphics繪圖獲得的FPS明顯高于使用Graphics2D繪圖，這是數組操作先天性的效率優勢所決定的。但缺點在于，ShortBufferImage及ShortBufferGraphics其并非直接繼承自Image與Graphics，兩者間函數不能完全對應，有些常用方法尚待實現，很多常用方法尚需ShortBufferGraphics使用者自行解決。

 

單就效率而言，應該說采取DataBuffer進行緩沖繪圖明顯優于單純利用BufferStrategy或者BufferedImage獲得Graphics后進行繪圖。

 

總體上看，如果我們追求最高FPS，則使用BufferedImage產生DataBuffer進行象素處理是最為高效的，與方法二混用后效率還將更高，但遺憾的是目前缺少相關開源組件，可用資源上略顯不足，有待相關公司或者個人提供，另外我們也可以考慮功能混用，即主體部分使用DataBuffer渲染，未實現部分以Graphics補足，但這肯定會對運行效率產生影響。

 

由于JGnet目前屬于閉源項目，所以我無法公開其任何代碼實現。為此我自制了一個非常簡單的DataBuffer中圖像處理類SimpleIntBufferImage，以供各位看客參考。

 

SimpleIntBufferImage.java源碼如下：

 

package test1; import java.awt.image.BufferedImage; import java.awt.image.DataBufferInt; import java.awt.image.PixelGrabber; import java.io.File; import java.io.IOException; import javax.imageio.ImageIO; /** * Copyright 2008 - 2009 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. * * @project loonframework * @author chenpeng * @email：ceponline@yahoo.com.cn * @version 0.1 */ public class SimpleIntBufferImage { private BufferedImage bufferImage; private int width; private int height; final private int[] pixels; final private int[] clear; public SimpleIntBufferImage(final String fileName) { try { BufferedImage tmpImage = ImageIO.read(new File(fileName)); width = tmpImage.getWidth(null); height = tmpImage.getHeight(null); clear = new int[width * height]; bufferImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB); pixels = ((DataBufferInt) bufferImage.getRaster().getDataBuffer()) .getData(); PixelGrabber pgr = new PixelGrabber(tmpImage, 0, 0, width, height, pixels, 0, width); try { pgr.grabPixels(); } catch (InterruptedException ex) { } } catch (IOException ex) { throw new RuntimeException(ex); } } /** * 清空pixels數據 * */ public void clearImage() { System.arraycopy(clear, 0, pixels, 0, clear.length); } /** * 刪除指定顏色 * * @param rgbs */ public void clearRGBs(final int[] rgbs) { for (int i = 0; i < pixels.length; i++) { int npixel = (255 << 24) + (rgbs[0] << 16) + (rgbs[1] << 8) + rgbs[2]; if (pixels[i] == npixel) { pixels[i] = 0; } } } /** * 轉換當前貼圖為灰白位圖 * */ public void convertToGray() { for (int i = 0; i < pixels.length; i++) { pixels[i] = colorToGray(pixels[i]); } } /** * 轉換當前貼圖為異色(反色)位圖 * */ public void convertToXor() { for (int i = 0; i < pixels.length; i++) { pixels[i] = colorToXor(pixels[i]); } } /** * 獲得r,g,b * * @param pixel * @return */ private int[] getRGBs(final int pixel) { int[] rgbs = new int[3]; rgbs[0] = (pixel >> 16) & 0xff; rgbs[1] = (pixel >> 8) & 0xff; rgbs[2] = (pixel) & 0xff; return rgbs; } /** * 轉換指定像素為灰白 * * @param pixel * @return */ private int colorToGray(final int pixel) { int[] rgbs = getRGBs(pixel); int value = (int) (0.299 * rgbs[0] + 0.587 * rgbs[1] + 0.114 * rgbs[2]); int npixel = (255 << 24) + (value << 16) + (value << 8) + value; return npixel; } /** * 異或指定像素 * * @param pixel * @return */ private int colorToXor(final int pixel) { int[] rgbs = getRGBs(pixel); int r = rgbs[0] ^ 0xff; int g = rgbs[1] ^ 0xff; int b = rgbs[2] ^ 0xff; int npixel = (255 << 24) + (r << 16) + (g << 8) + b; return npixel; } /** * copy指定貼圖于本身位圖之上 * * @param simpleImage * @param left * @param top */ public void copyImage(final SimpleIntBufferImage simpleImage, final int left, final int top) { int[] src = simpleImage.getPixels(); int srcWidth = simpleImage.getWidth(); int srcHeight = simpleImage.getHeight(); for (int x = 0, x1 = left; x < srcWidth && x < width && x1 < width; x++, x1++) { for (int y = 0, y1 = top; y < srcHeight && x < height && y1 < height; y++, y1++) { int npixels = src[x + y * srcWidth]; if (npixels != -16777216) { pixels[x1 + y1 * width] = npixels; } } } } /** * 截取指定范圍內像素點數組 * * @param x * @param y * @param w * @param h * @return */ public int[] getSubPixels(final int x, final int y, final int w, final int h) { int[] pixels = new int[2 + w * h]; pixels[0] = w; pixels[1] = h; if (pixels == null) { return null; } for (int i = 0; i < h; i++) { for (int j = 0; j < w; j++) { pixels[2 + x + j + (y + i) * w] = getPixel(x + j, y + i); } } return pixels; } /** * 截取指定范圍內像素點 * * @param x * @param y * @return */ public int getPixel(final int x, final int y) { return pixels[x + y * width]; } public int[] getPixels() { return pixels; } public BufferedImage getBufferedImage() { return bufferImage; } public int getHeight() { return height; } public void setHeight(int height) { this.height = height; } public int getWidth() { return width; } public void setWidth(int width) { this.width = width; } }

 

簡單應用：

 

package test1; import java.awt.Color; import java.awt.Dimension; import java.awt.Frame; import java.awt.Graphics; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; /** * * Copyright 2008 - 2009 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. * * @project loonframework * @author chenpeng * @email：ceponline@yahoo.com.cn * @version 0.1 */ public class Sample extends Frame implements Runnable{ /** * */ private static final long serialVersionUID = 1L; private SimpleIntBufferImage simple1 = new SimpleIntBufferImage("back.gif"); private SimpleIntBufferImage simple2 = new SimpleIntBufferImage( "idle0_0.png"); private int width = 480; private int height = 360; public Sample() { super("自制SimpleIntBufferImage示例"); this.setBackground(Color.black); simple1.convertToXor(); simple1.convertToXor(); this.setPreferredSize(new Dimension(width, height)); this.requestFocus(); this.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); this.pack(); this.setResizable(false); this.setLocationRelativeTo(null); this.setIgnoreRepaint(true); Thread thread = new Thread(this); thread.start(); } public void run() { for(;;){ repaint(); try { Thread.sleep(20L); } catch (InterruptedException e) { } } } public void update(Graphics g) { paint(g); } public void paint(Graphics g) { simple1.copyImage(simple2,15,50); g.drawImage(simple1.getBufferedImage(), 0, 0, null); } public static void main(String[] args) { Sample frm = new Sample(); frm.setVisible(true); } }

 

效果如下：