国产成人免费一区二区60岁,黄色午夜,国产伦精品一区二区三区高清

眾所周知， 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 構建緩沖區（雙緩沖）

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); } }

效果如下：

Java游戲開發中怎樣才能獲得更快的FPS？

更多文章、技術交流、商務合作、聯系博主

微信掃碼或搜索：z360901061

微信掃一掃加我為好友

QQ號聯系： 360901061

您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。

【本文對您有幫助就好】元

2元

5元

10元

20元

自定義