如何使用LGame中的LTexturePack（移值到其它环境也行……）

如何使用LGame中的LTexturePack（移值到其它环境也行……）

分类： JAVA游戏开发 JAVA应用 2011-11-23 00:11  1422人阅读  评论(8)  收藏  举报

修正声明：

借写本例的机会，刚刚修正了某个【小】BUG。问题点在于LTexturePack的其中一个draw函数，本来在分图时需传入dx1,dy1,dx2,dy2,sx1,sy1,sx2,sy2等八个数值，结果小弟在接值时脑子进水，误将sx1,sx2,sy1,sy2写“扎堆”了（写错就是上述样子）……因为这是取图参数，即从sx1,sy1坐标开始取图，取到sx2,sy2的位置中止，弄错以后取出图立马变毕加索油画～所以小弟刚才将LGame-0.3.2-release这个包重新发了一遍，如果有用到LTexturePack的话请重新下载，抱歉抱歉（另外还改了3处问题）……

下载地址：http://loon-simple.googlecode.com/files/LGame-0.3.2-release.7z

关于TexturePack：

LGame中提供的LTexturePack类，是一个专门用于整合图像资源的辅助用类，它的最大作用是将许多零碎的图片画零为整，从而减少不必要的资源损耗。另一方面来讲，由于减少了渲染用纹理数量，避免了反复与图形系统交互，使用LTexturePack的速度通常会比单独使用零散LTexture为高。

最简单的使用方式：

[java]  view plain copy

1. package org.loon.test;  
2.   
3. import org.loon.framework.javase.game.GameScene;  
4. import org.loon.framework.javase.game.action.sprite.Arrow;  
5. import org.loon.framework.javase.game.core.graphics.Screen;  
6. import org.loon.framework.javase.game.core.graphics.opengl.GLEx;  
7. import org.loon.framework.javase.game.core.graphics.opengl.LTexturePack;  
8. import org.loon.framework.javase.game.core.input.LTouch;  
9. import org.loon.framework.javase.game.core.input.LTransition;  
10. import org.loon.framework.javase.game.core.timer.LTimerContext;  
11.   
12. public class LTexturePackTest extends Screen {  
13.   
14.     LTexturePack imagePack;  
15.   
16.     Arrow arrow;  
17.   
18.     /** 
19.      * 无Transition效果。 
20.      *  
21.      * PS:目前LGame设定为，如果首个Screen没有加载特效，将强制运行一个随机特效。 但是，返回Empty则不进行加载。 
22.      */  
23.     public LTransition onTransition() {  
24.         return LTransition.newEmpty();  
25.     }  
26.   
27.     public void onLoad() {  
28.   
29.         imagePack = new LTexturePack();  
30.   
31.         // 加载小图到LTexturePack  
32.         imagePack.putImage("assets/h_a.png");  
33.         imagePack.putImage("assets/h_b.png");  
34.         imagePack.putImage("assets/h_c.png");  
35.   
36.         imagePack.putImage("assets/e_a.png");  
37.         imagePack.putImage("assets/e_b.png");  
38.         imagePack.putImage("assets/e_c.png");  
39.   
40.         // 宣布所有图像加载完毕(如果调用此函数，则释放所有已加载的资源，仅保留一块主纹理)  
41.         imagePack.packed();  
42.     }  
43.   
44.     public void alter(LTimerContext timer) {  
45.   
46.     }  
47.   
48.     public void draw(GLEx g) {  
49.         if (isOnLoadComplete()) {  
50.             int size = 32;  
51.   
52.             // 当执行glBegin后，将在GLEx触发一个渲染批处理事件，仅在执行glEnd后提交  
53.             // 渲染内容到窗体。如果不调用此函数，则LTexturePack依旧可以执行，但是效率  
54.             // 可能会受到一定影响（每次渲染都单独提交）。  
55.             imagePack.glBegin();  
56.   
57.             // LTexturePack中的数据可以按照索引加载  
58.             imagePack.draw(0, 32, size);  
59.             // 也可以按照文件名加载  
60.             imagePack.draw("assets/h_b.png", 32, size += 32);  
61.             imagePack.draw(2, 32, size += 32);  
62.   
63.             size = 32;  
64.             imagePack.draw(3, 256, size);  
65.             imagePack.draw(4, 256, size += 32);  
66.             imagePack.draw(5, 256, size += 32);  
67.   
68.             // 提交渲染结果到游戏画面  
69.             imagePack.glEnd();  
70.             // 实例化一个动态箭头精灵  
71.             if (arrow == null) {  
72.                 arrow = new Arrow(212, 212, 188, 188);  
73.                 add(arrow);  
74.             }  
75.             // 显示实际纹理  
76.             g.drawTexture(imagePack.getTexture(), 32, size + 50);  
77.             g.drawString("Texture", 235, size + 124);  
78.         }  
79.     }  
80.   
81.     public void touchDown(LTouch e) {  
82.   
83.     }  
84.   
85.     public void touchDrag(LTouch e) {  
86.   
87.     }  
88.   
89.     public void touchMove(LTouch e) {  
90.   
91.     }  
92.   
93.     public void touchUp(LTouch e) {  
94.   
95.     }  
96.   
97.     public void dispose() {  
98.         if (imagePack != null) {  
99.             imagePack.dispose();  
100.             imagePack = null;  
101.         }  
102.     }  
103.   
104.     public static void main(String[] args) {  
105.         GameScene game = new GameScene("LTexturePackTest", 480, 320);  
106.         game.setShowFPS(true);  
107.         game.setShowLogo(false);  
108.         game.setScreen(new LTexturePackTest());  
109.         game.showScreen();  
110.     }  
111.   
112. }  

这时大家可以看到，在上述画面中，其实只有游戏中箭头指出的地方才是真正的纹理。而其余细分处，仅是大图纹理中的一部分罢了，然而在用户眼中，这些又有什么不同呢？不过，我们所能节省出的图像资源，却是非常巨大的。

当然，如果载入的是连续画面，那么仅仅能得到原画根本没用，不过没关系，我们也可以继续细分出我们满意的画面（上图具体代码和下例重复，故不再赘述）。

图像移动：

[java]  view plain copy

1. package org.loon.test;  
2.   
3. import org.loon.framework.javase.game.GameScene;  
4. import org.loon.framework.javase.game.action.collision.Gravity;  
5. import org.loon.framework.javase.game.action.collision.GravityHandler;  
6. import org.loon.framework.javase.game.action.sprite.Bind;  
7. import org.loon.framework.javase.game.action.sprite.effect.SmashEffect;  
8. import org.loon.framework.javase.game.core.geom.RectBox;  
9. import org.loon.framework.javase.game.core.graphics.Screen;  
10. import org.loon.framework.javase.game.core.graphics.opengl.GLColor;  
11. import org.loon.framework.javase.game.core.graphics.opengl.GLEx;  
12. import org.loon.framework.javase.game.core.graphics.opengl.LTexturePack;  
13. import org.loon.framework.javase.game.core.input.LTouch;  
14. import org.loon.framework.javase.game.core.input.LTransition;  
15. import org.loon.framework.javase.game.core.timer.LTimer;  
16. import org.loon.framework.javase.game.core.timer.LTimerContext;  
17.   
18. public class LTexturePackTest extends Screen {  
19.   
20.     SmashEffect smashEffect = new SmashEffect();  
21.   
22.     // 显示用精灵大小  
23.     final int show_size = 64;  
24.   
25.     // 实际精灵大小  
26.     final int really_size = 24;  
27.   
28.     LTexturePack imagePack;  
29.   
30.     /** 
31.      * 建立一个移动对象，用以管理LTexturePack中图像的移动 
32.      */  
33.     public class Move {  
34.   
35.         RectBox rect = new RectBox(0, 0, show_size, show_size);  
36.   
37.         LTimer timer = new LTimer(150);  
38.   
39.         int id;  
40.   
41.         float x, y;  
42.   
43.         int action = 1;  
44.   
45.         int type = -1;  
46.   
47.         public void setX(float x) {  
48.             this.x = x;  
49.             rect.setX(x);  
50.         }  
51.   
52.         public void setY(float y) {  
53.             this.y = y;  
54.             rect.setY(y);  
55.         }  
56.   
57.         public float getX() {  
58.             return x;  
59.         }  
60.   
61.         public float getY() {  
62.             return y;  
63.         }  
64.   
65.         public boolean intersects(Move m) {  
66.             return rect.intersects(m.rect);  
67.         }  
68.   
69.         public void update() {  
70.             if (timer.action(elapsedTime)) {  
71.                 action++;  
72.                 if (action > 4) {  
73.                     action = 1;  
74.                 }  
75.             }  
76.         }  
77.   
78.     }  
79.   
80.     /** 
81.      * 无Transition效果。 
82.      *  
83.      * PS:目前LGame设定为，如果首个Screen没有加载特效，将强制运行一个随机特效。 但是，返回Empty则不进行加载。 
84.      */  
85.     public LTransition onTransition() {  
86.         return LTransition.newEmpty();  
87.     }  
88.   
89.     public void onLoad() {  
90.   
91.         imagePack = new LTexturePack();  
92.   
93.         // 加载小图到LTexturePack  
94.         int heroId = imagePack.putImage("assets/h_a.png");  
95.         int enemyId = imagePack.putImage("assets/e_a.png");  
96.   
97.         // 宣布所有图像加载完毕(如果调用此函数，则释放所有已加载的资源，仅保留一块主纹理)  
98.         imagePack.packed();  
99.   
100.         final Move moveHero = new Move();  
101.         moveHero.id = heroId;  
102.         moveHero.x = 0;  
103.         moveHero.y = 128;  
104.         moveHero.type = 0;  
105.   
106.         final Move moveEnemy = new Move();  
107.         moveEnemy.id = enemyId;  
108.         moveEnemy.x = getWidth() - show_size;  
109.         moveEnemy.y = 128;  
110.         moveEnemy.type = 1;  
111.   
112.         /** 
113.          * 获得一个内置的重力管理器 
114.          *  
115.          * PS: 所有具备setX、setY函数的公有类（必须公有，否则反射不到……），都可以被GravityHandler绑定 
116.          */  
117.         final GravityHandler gravityHandler = getGravityHandler();  
118.   
119.         // 用重力控制器将moveHero对象打包，并且向右方匀速移动(速度100)  
120.         Gravity g1 = new Gravity(moveHero);  
121.         g1.setVelocityX(100);  
122.   
123.         // 用重力控制器将moveHero对象打包，并且向左方匀速移动(速度100)  
124.         Gravity g2 = new Gravity(moveEnemy);  
125.         g2.setVelocityX(-100);  
126.   
127.         // 添加重力干预  
128.         gravityHandler.add(g1);  
129.         gravityHandler.add(g2);  
130.   
131.         // 构建重力监控  
132.         GravityHandler.Update update = new GravityHandler.Update() {  
133.   
134.             public void action(Gravity g, float x, float y) {  
135.                 // 让当前重力控制触边实效（具体到本例，人物也将消失）  
136.                 if (x < 0) {  
137.                     gravityHandler.remove(g);  
138.                 }  
139.                 if (x > getWidth() - show_size) {  
140.                     gravityHandler.remove(g);  
141.                 }  
142.             }  
143.   
144.         };  
145.         // 添加监控(每次Gravity对象坐标发生变更时生效)  
146.         gravityHandler.onUpdate(update);  
147.   
148.     }  
149.   
150.     public void alter(LTimerContext timer) {  
151.   
152.         smashEffect.update(timer.getTimeSinceLastUpdate());  
153.     }  
154.   
155.     public void draw(GLEx g) {  
156.         if (isOnLoadComplete()) {  
157.   
158.             smashEffect.draw(g);  
159.             // 当执行glBegin后，将在GLEx触发一个渲染批处理事件，仅在执行glEnd后提交  
160.             // 渲染内容到窗体。如果不调用此函数，则LTexturePack依旧可以执行，但是效率  
161.             // 可能会受到一定影响（每次渲染都单独提交）。  
162.             imagePack.glBegin();  
163.   
164.             // 获得重力控制器(如果绑定为Sprite,Actor,LComponent等对象则不必额外处理显示步骤,  
165.             // 此处图像已统一打包入LTexturePack较为特殊)  
166.             GravityHandler gravityHandler = getGravityHandler();  
167.             // 获得重力实例数量  
168.             int size = gravityHandler.getCount();  
169.             // 保存上一个Move实例  
170.             Move first = null;  
171.             for (int i = 0; i < size; i++) {  
172.                 // 获得实例  
173.                 Gravity gravity = gravityHandler.get(i);  
174.                 Bind bind = gravity.getBind();  
175.                 // 反射回绑定的对象  
176.                 Move o = (Move) bind.ref();  
177.                 // 判定两个图像的移动位置是否发生了碰撞（这里使用了比较流氓（就俩，省了-_-）的方式，实际应该建立一个精灵预警区，  
178.                 // 然后搜索该区域内是否存在精灵，有的话再让移动中精灵与该精灵进行碰撞比较）  
179.                 if (first != null && first.intersects(o)) {  
180.                     // 碰撞后象征性的显示一个粉碎特效  
181.                     if (first.action != 5) {  
182.                         smashEffect.createSmallExplosionEffect(getHalfWidth(),  
183.                                 getHalfHeight());  
184.                     }  
185.                     o.action = 5;  
186.                     first.action = 5;  
187.                     g.setColor(GLColor.red);  
188.                 }  
189.                 switch (o.type) {  
190.                 case 0:  
191.                     imagePack.draw(o.id, o.x, o.y, show_size, show_size,  
192.                             (o.action - 1) * really_size, 0, o.action  
193.                                     * really_size, really_size);  
194.                     break;  
195.                 case 1:  
196.                     imagePack.draw(o.id, o.x, o.y, show_size, show_size,  
197.                             o.action * really_size, 0, (o.action - 1)  
198.                                     * really_size, really_size);  
199.                     break;  
200.                 }  
201.                 first = o;  
202.                 o.update();  
203.             }  
204.             // 提交渲染结果到游戏画面  
205.             imagePack.glEnd();  
206.         }  
207.     }  
208.   
209.     public void touchDown(LTouch e) {  
210.   
211.     }  
212.   
213.     public void touchDrag(LTouch e) {  
214.   
215.     }  
216.   
217.     public void touchMove(LTouch e) {  
218.   
219.     }  
220.   
221.     public void touchUp(LTouch e) {  
222.   
223.     }  
224.   
225.     public void dispose() {  
226.         if (imagePack != null) {  
227.             imagePack.dispose();  
228.             imagePack = null;  
229.         }  
230.     }  
231.   
232.     public static void main(String[] args) {  
233.         GameScene game = new GameScene("LTexturePackTest", 480, 320);  
234.         game.setShowFPS(true);  
235.         game.setShowLogo(false);  
236.         game.setScreen(new LTexturePackTest());  
237.         game.showScreen();  
238.     }  
239.   
240. }  

让LTexturePack中的两个精灵进行单挑

多个图像移动：

[java]  view plain copy

1. package org.loon.test;  
2.   
3. import java.util.ArrayList;  
4.   
5. import org.loon.framework.javase.game.GameScene;  
6. import org.loon.framework.javase.game.action.collision.Gravity;  
7. import org.loon.framework.javase.game.action.collision.GravityHandler;  
8. import org.loon.framework.javase.game.core.LSystem;  
9. import org.loon.framework.javase.game.core.geom.RectBox;  
10. import org.loon.framework.javase.game.core.graphics.Screen;  
11. import org.loon.framework.javase.game.core.graphics.opengl.GLEx;  
12. import org.loon.framework.javase.game.core.graphics.opengl.LTexturePack;  
13. import org.loon.framework.javase.game.core.input.LTouch;  
14. import org.loon.framework.javase.game.core.input.LTransition;  
15. import org.loon.framework.javase.game.core.timer.LTimer;  
16. import org.loon.framework.javase.game.core.timer.LTimerContext;  
17.   
18. public class LTexturePackTest extends Screen {  
19.   
20.     ArrayList<Move> moveList;  
21.   
22.     // 显示用精灵大小  
23.     final int show_size = 64;  
24.   
25.     // 实际精灵大小  
26.     final int really_size = 24;  
27.   
28.     LTexturePack imagePack;  
29.   
30.     /** 
31.      * 建立一个移动对象，用以管理LTexturePack中图像的移动 
32.      */  
33.     public class Move {  
34.   
35.         RectBox rect = new RectBox(0, 0, show_size, show_size);  
36.   
37.         LTimer timer = new LTimer(150);  
38.   
39.         int id;  
40.   
41.         float x, y;  
42.   
43.         int action = 1;  
44.   
45.         int type = -1;  
46.   
47.         public Move(int id, int type, float x, float y) {  
48.             this.id = id;  
49.             this.type = type;  
50.             this.x = x;  
51.             this.y = y;  
52.         }  
53.   
54.         public void setX(float x) {  
55.             this.x = x;  
56.             rect.setX(x);  
57.         }  
58.   
59.         public void setY(float y) {  
60.             this.y = y;  
61.             rect.setY(y);  
62.         }  
63.   
64.         public float getX() {  
65.             return x;  
66.         }  
67.   
68.         public float getY() {  
69.             return y;  
70.         }  
71.   
72.         public boolean intersects(Move m) {  
73.             return rect.intersects(m.rect);  
74.         }  
75.   
76.         public void update() {  
77.             if (timer.action(elapsedTime)) {  
78.                 action++;  
79.                 if (action > 4) {  
80.                     action = 1;  
81.                 }  
82.             }  
83.         }  
84.   
85.     }  
86.   
87.     public LTransition onTransition() {  
88.         return LTransition.newCrossRandom();  
89.     }  
90.   
91.     public void onLoad() {  
92.   
93.         imagePack = new LTexturePack();  
94.   
95.         // 加载小图到LTexturePack  
96.         int heroImgId = imagePack.putImage("assets/h_a.png");  
97.         int enemyImgId = imagePack.putImage("assets/e_a.png");  
98.   
99.         // 宣布所有图像加载完毕(如果调用此函数，则释放所有已加载的资源，仅保留一块主纹理;如果不调用此函数，  
100.         // LTexturePack将允许动态增减图像，但是已加载的小图资源不会自动释放(可手动释放，或者dispose全部清空))  
101.         imagePack.packed();  
102.   
103.         // 构建一个Move集合，用以控制图像移动与显示  
104.         this.moveList = new ArrayList<Move>(10);  
105.   
106.         moveList.add(new Move(heroImgId, 0, 0, 32));  
107.         moveList.add(new Move(heroImgId, 0, 0, 136));  
108.         moveList.add(new Move(heroImgId, 0, 0, 220));  
109.   
110.         moveList.add(new Move(enemyImgId, 1, getWidth() - show_size, 32));  
111.         moveList.add(new Move(enemyImgId, 1, getWidth() - show_size, 136));  
112.         moveList.add(new Move(enemyImgId, 1, getWidth() - show_size, 220));  
113.   
114.         /** 
115.          * 获得一个内置的重力管理器 
116.          *  
117.          * PS: 所有具备setX、setY函数的公有类（必须公有，否则反射不到……），都可以被GravityHandler绑定 
118.          */  
119.         final GravityHandler gravityHandler = getGravityHandler();  
120.   
121.         // 批量载入重力控制  
122.         for (Move m : moveList) {  
123.             Gravity g = new Gravity(m);  
124.             if (m.type == 0) {  
125.                 g.setVelocityX(LSystem.getRandom(50, 80));  
126.             } else if (m.type == 1) {  
127.                 g.setVelocityX(-LSystem.getRandom(50, 100));  
128.             }  
129.             gravityHandler.add(g);  
130.         }  
131.   
132.         // 构建重力监控  
133.         GravityHandler.Update update = new GravityHandler.Update() {  
134.   
135.             public void action(Gravity g, float x, float y) {  
136.                 synchronized (moveList) {  
137.                     Move src = (Move) g.getBind().ref();  
138.                     // 仅让我方与敌人产生碰撞  
139.                     if (src.type == 0 && src.action != 5) {  
140.                         for (Move obj : moveList) {  
141.                             if (src.type != obj.type && !src.equals(obj)  
142.                                     && src.intersects(obj)) {  
143.                                 src.action = 5;  
144.                                 obj.action = 6;  
145.                             }  
146.                         }  
147.                     }  
148.                     if (src.action < 5) {  
149.                         // 让移动有一定几率上下浮动(比较贴近真实行走)  
150.                         g.setVelocityY(LSystem.getRandom(-100, 100));  
151.                     } else {  
152.                         // 打人或挨打时不能上下浮动  
153.                         g.setVelocityY(0);  
154.                     }  
155.                     // 让当前重力控制触边实效(更上例不同，此方式仅暂停重力控制，而非删除，这意味着可以唤醒)  
156.                     if (x < 0) {  
157.                         g.setEnabled(false);  
158.                     }  
159.                     if (x > getWidth() - show_size) {  
160.                         g.setEnabled(false);  
161.                     }  
162.                 }  
163.             }  
164.   
165.         };  
166.         // 添加监控(每次Gravity对象坐标发生变更时生效)  
167.         gravityHandler.onUpdate(update);  
168.   
169.     }  
170.   
171.     public void alter(LTimerContext timer) {  
172.   
173.     }  
174.   
175.     public void draw(GLEx g) {  
176.         if (isOnLoadComplete()) {  
177.             synchronized (moveList) {  
178.                 // 当执行glBegin后，将在GLEx触发一个渲染批处理事件，仅在执行glEnd后提交  
179.                 // 渲染内容到窗体。如果不调用此函数，则LTexturePack依旧可以执行，但是效率  
180.                 // 可能会受到一定影响（每次渲染都单独提交）。  
181.                 imagePack.glBegin();  
182.   
183.                 for (Move o : moveList) {  
184.                     switch (o.type) {  
185.                     case 0:  
186.                         imagePack.draw(o.id, o.x, o.y, show_size, show_size,  
187.                                 (o.action - 1) * really_size, 0, o.action  
188.                                         * really_size, really_size);  
189.                         break;  
190.                     case 1:  
191.                         imagePack.draw(o.id, o.x, o.y, show_size, show_size,  
192.                                 o.action * really_size, 0, (o.action - 1)  
193.                                         * really_size, really_size);  
194.                         break;  
195.                     }  
196.                     o.update();  
197.                 }  
198.   
199.                 // 提交渲染结果到游戏画面  
200.                 imagePack.glEnd();  
201.             }  
202.   
203.         }  
204.     }  
205.   
206.     public void touchDown(LTouch e) {  
207.   
208.     }  
209.   
210.     public void touchDrag(LTouch e) {  
211.   
212.     }  
213.   
214.     public void touchMove(LTouch e) {  
215.   
216.     }  
217.   
218.     public void touchUp(LTouch e) {  
219.   
220.     }  
221.   
222.     public void dispose() {  
223.         if (imagePack != null) {  
224.             imagePack.dispose();  
225.             imagePack = null;  
226.         }  
227.     }  
228.   
229.     public static void main(String[] args) {  
230.         GameScene game = new GameScene("LTexturePackTest", 480, 320);  
231.         game.setShowFPS(true);  
232.         game.setShowLogo(false);  
233.         game.setScreen(new LTexturePackTest());  
234.         game.showScreen();  
235.     }  
236.   
237. }  

让单独纹理中的多个精灵进行混战

——————————

除了动态加载小图为统一纹理外，LTexturePack工具也允许根据XML设定来分解单独的大图为指定格式小图。

以上例为准，当我们执行下列代码：

System.out.println(imagePack.toString());

将可以在控制台见到如下输出：

<?xml version="1.0" standalone="yes" ?>
<pack file="null">
<block id="0" name="assets/h_a.png" left="0" top="0" right="144" bottom="24"/>
<block id="1" name="assets/e_a.png" left="0" top="24" right="144" bottom="48"/>
</pack>

这一输出，其实就是LTexturePack工具的XML文档解析格式。如果有单独的复合素材图（所有小图合成一张大图的那种），只要我们构建一个符合上述格式的XML文档，就能直接导入LTexturePack中使用。具体来说，<pack file="null">这项必须存在，其中file需要填写为素材图所在路径；id、left、top、right、bottom这五项也必须存在，否则无法定位和获取小图；name项如果想根据name取小图时必须存在，如果无此要求可不填。

另外，在LAE和LSE包中并无此工具类及类似工具存在。原因在于，使用LTexturePack工具虽然可以有效的节约图像资源，可惜调用方法不够直观，与LAE和LSE包的Easy特性并不相符。而且在Bitmap分图时，效率损耗要大于Texture，虽然能节约一定的显存空间，却会使本就不快的Canvas绘图变得更慢。因此，没有为LAE和LSE包提供相关扩展。

____________________

示例中用到了一些MD版梦幻模拟战的素材，资源在此(用什么图原理都一样)：

http://115.com/file/dnr4wd6b#


临时想到的一些杂项：

1、关于LGame屏幕设置：

LGame默认提供有的Activity子类LGameAndroid2DActivity，只要继承该类的Activity就可以获得onMain、onGamePaused、onGameResumed三个接口。通常来说，在onMain中就足以完成我们所有的游戏初始化设置。

下面是一个最典型的基本设置：

[java]  view plain copy

1. public void onMain() {  
2. // 横屏，全屏显示  
3. this.initialization(true,LMode.Fill);  
4. // 不显示logo  
5. this.setShowLogo(false);  
6. // 显示实际fps  
7. this.setShowFPS(true);  
8. // 注入游戏Screen  
9. this.setScreen(new MyScreen());  
10. // 显示画面  
11. this.showScreen();  
12. }  

如果我们设置initialization(true)，这时游戏屏幕为横屏显示，而initialization(false)为竖屏显示，在布尔值后还可追加一项LMode，通过该类可以设定屏幕的显示方式，如全屏、自适屏、默认大小等等。而在调用initialization之前，我们可以调用maxScreen函数设定默认的屏幕大小，屏幕缩放以此作为依据，如果不进行设置，则默认游戏屏幕大小为480x320。

2、怎样提高游戏速度：

单以效率论，除了能起到缓存（或跳过冗余步骤）的模块外，绝大多数Java类在游戏开发中只能起到减速作用，游戏模块越多，意味着速度被放缓的可能性也就越大。所以游戏引擎也并不一定在所有场景都是快速的，因使用者不同，引擎即可能成为游戏加速的工具，也可能沦为游戏减速的利器。

仅以小弟愚见，提高速度的最简便诀窍在于——“能够执行一次的地方，就绝不给他第二次执行的机会”，真能做到这样，足矣。

cping1982原文: http://blog.csdn.net/cping1982/article/details/7002541