码迷，mamicode.com
首页 > 移动开发 > 详细

Android游戏引擎AndEngine入门讲解

时间：2014-09-25 13:42:50      阅读：244      评论：0      收藏：0      [点我收藏+]

标签：android游戏引擎   游戏引擎   andengine   android开发服务   

AndEngine是一款基于OpenGL ES技术的2D游戏引擎，可以运行在Android1.6及以上版本的系统中。拥有更多的游戏组件与扩展功能，在默认情况下已经可以支持中文。

bubuko.com,布布扣

虽然AndEngine作为游戏引擎在功能上较libGDX更为丰富和人性化，但相比libGDX的绘图渲染机能却逊色不少。libGDX有较为完善的OpenGLES环境适应性，而AndEngine在这方面的投入明显不足。所以你是否选择AndEngine，需要从实际出发，多做几次真机测试才好下决定，下面小编将逐步讲解AndEngine引擎的基础信息。

AndEngine引擎基础构成~

bubuko.com,布布扣

如何使用AndEngine~

*AndEngine基本运行原理

解读AndEngine源码，才了解到AndEngine除了采用低耦合、高内聚架构策略细分引擎模块，使用OpenGLES进行游戏渲染之外，还以双线程方式分别驱动绘图和事务更新。事实上，它将游戏画面和游戏业务分为两组逻辑，并行跑在同级互斥线程中。

具体来说，其绘图线程位于AndEngine提供的GLSurfaceView内部类GLThread（AndEngine的org.anddev.andengine.opengl.view包下）通过GLSurfaceView子类，即AndEngine提供的RenderSurfaceView类调用重载的onDrawFrame函数加以渲染，业务线程在Engine类的内部类UpdateThread中，AndEngine始终以while(true)这样的死循环方式快速执行其中的onTickUpdate函数，所有AndEngine提供的游戏业务最终都会由此函数调用及执行。

而当AndEngine进行游戏绘图时，游戏业务线程将通过wait方式锁定，当游戏业务处理时，也会以同样的手段锁定绘图线程，二者间具体交互的关系将由Engine类中的State子类控制，由此保证游戏画面和游戏业务的同步。

可能是考虑到持续双线程运行电量消耗大的原因，AndEngine默认情况下要求用户启动PowerManager进行电源管理，故需要 权限支持，否则会初始化时Log会提示缺少相关配置，建议你在AndroidManifest.xml中添加权限。

注：无此权限不影响运行，只会在Log有警告信息，且耗电较大。

*AndEngine基本运行流程

由于Activity是专门提供给安卓使用的2D游戏引擎，作为启动类的Activity是必不可少的，至少应该对BaseGameActivity做如下继承

01     public class Main extends BaseGameActivity {  
02         public void onLoadComplete() {  
03               
04         }  
05         public Engine onLoadEngine() {  
06             return null;  
07         }  
08         public void onLoadResources() {  
09               
10         }  
11         public Scene onLoadScene() {  
12             return null;  
13         }    
14     }

其中四个重载函数启动顺序如下：

onLoadEngine->onLoadResources->onLoadScene->onLoadComplete 

AndEngine会首先加载Engine类实例通知系统游戏引擎的基本运行方式，然后加载游戏资源，其次加载游戏场景实例，最后通过onLoadComplete通知用户加载完毕，并进行善后工作。

由于BaseGameActivity类重载了父类Activity的onResume与onPause函数以保证自身的正常运行，所以不建议在继承 BaseGameActivity时再次重载上述函数（如果重载的话，不要忘记super调用），推荐直接重载AndEngine提供的 onGamePaused和onGameResumed实现同等功能。

*AndEngine基本运行方式

以上介绍的AndEngine基本运行机制和运行流程，然而仅仅这样，AndEngine还是无法实现实际运行的，因为Engine与Scene都没有获得具体实现。如果我们想在屏幕上显示当前应用FPS数，至少需要做出如下改动才能满足最为基本的AndEngine应用：

01     public class Main extends BaseGameActivity {  
02         private static final int CAMERA_WIDTH = 320;  
03         private static final int CAMERA_HEIGHT = 480;  
04         private Camera andCamera;  
05         private Texture myFontTexture;  
06         private Font myFont;  
07         public void onLoadComplete() {  
08         }  
09         public Engine onLoadEngine() {  
10             // 构建摄像机  
11             this.andCamera = new Camera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);  
12             // 构建Engine，全屏显示，手机方向为竖屏，按比例拉伸  
13             return new Engine(new EngineOptions(true, ScreenOrientation.PORTRAIT,  
14                     new RatioResolutionPolicy(CAMERA_WIDTH, CAMERA_HEIGHT),  
15                     this.andCamera));  
16         }  
17         public void onLoadResources() {  
18             // 构建一个纹理用以显示文字  
19             this.myFontTexture = new Texture(256, 256, TextureOptions.DEFAULT);  
20             // 构建字体  
21             this.myFont = new Font(this.myFontTexture, Typeface.create(  
22                     Typeface.DEFAULT, Typeface.BOLD), 32, true, Color.WHITE);  
23             // 注入相关纹理及字体  
24             this.mEngine.getTextureManager().loadTexture(this.myFontTexture);  
25             this.mEngine.getFontManager().loadFont(this.myFont);  
26         }  
27         public Scene onLoadScene() {  
28             // 构建场景，允许的最大Layer数量为1  
29             final Scene scene = new Scene(1);  
30             // 使用可以变更内容的ChangeableText显示FPS(它的父类Text不允许改变显示内容)，位置在15,5,  
31             // 字体为myFont中所规定的，最多允许显示5个字符(设置能显示几个字符，实际就能显示几个，  
32             // AndEngine不能自动扩充，不填以初始化时输入的字符数计算……)  
33             final ChangeableText text = new ChangeableText(5, 5, this.myFont,  
34                     "0.0", 5);  
35             // 注册FPS监听  
36             this.mEngine.registerUpdateHandler(new FPSLogger() {  
37                 protected void onHandleAverageDurationElapsed(final float pFPS) {  
38                     super.onHandleAverageDurationElapsed(pFPS);  
39                     // 传递内容到ChangeableText  
40                     text.setText("" + pFPS);  
41                 }  
42             });  
43             // 将ChangeableText注入场景  
44             scene.attachChild(text);  
45             // 构建场景，可容纳图层数为1  
46             return scene;  
47         }  
48     }

效果图：

bubuko.com,布布扣

事实上BaseGameActivity并非AndEngine提供的唯一Activity，其UI包下有以SplashScene场景作为特效启动的 BaseSplashActivity类，以及通过重载getLayoutID与getRenderSurfaceViewID这两个抽象函数，调用指定布局与视图的LayoutGameActivity类。不过除了上述特点，它们与BaseGameActivity就再无区别了。

如何使用AndEngine常用功能~

*AndEngine的IUpdateHandler接口

IUpdateHandler类是AndEngine中使用非常频率的组件之一，其本身就是一个接口，内部有onUpdate以及reset两个函数等待实现，几乎所有AndEngine应用都必然会看到它的身影，它也是AndEngine添加具体业务到游戏业务线程中的主要方法之一。

具体的讲，所有通过AndEngine中registerUpdateHandler函数注册的IUpdateHandler，都会被保存到一个叫做 UpdateHandlerList的IUpdateHandler接口集合中。虽然UpdateHandlerList本身也是一个 IUpdateHandler接口的实现，但基本只存在于Engine及Scene类中，并只供Engine类中的 onTickUpdate函数调用（Scene类中虽有独立的UpdateHandlerList，但事实上它依旧只被Engine中的 onTickUpdate执行）。每当AndEngine业务线程循环onTickUpdate这个Engine内部方法时，都会调用 UpdateHandlerList中存在的所有IUpdateHandler，直到注销相关的IUpdateHandler实例为止。

另外，与UpdateHandlerList集合类作用类似的还有RunnableHandler类，该类同样是IUpdateHandler的具体实现， 它的作用在于保存并执行一次标准Runnable（每次业务循环后都会清空RunnableHandler的内部数据），该类在AndEngine业务线程中的执行时机略早于UpdateHandlerList，我们可以通过RunnableHandler类中的postRunnable函数，或Engine类中的runOnUpdateThread函数添加Runnable到该集合。

*AndEngine的Async方法

一般情况下，AndEngine的资源加载会在构建Engine之后，调用onLoadResources函数时进行同步加载，但是如果一次性加载资源太多，可能会面临一个问题，那就是Android系统将自动关闭长期无响应的UI。所以一旦采取同步执行的加载策略，数据量过大时就有可能将我们的APK卡死。此时， 就需要异步加载策略来解决问题，而AndEngine也确实提供给我们这样的异步加载方式。

具体来说，AndEngine对 Android系统自带的AsyncTask类进行了适当封装（具体封装在BaseActivity类中，该类为BaseGameActivity的父类，AndEngine由此类开始实际继承Activity，但BaseGameActivity的主要功能并不在此类），只要通过doAsync或者 doProgressAsync函数就可以调用，实现代码如下所示：

01     public class Main extends BaseGameActivity {  
02         private static final int CAMERA_WIDTH = 320;  
03         private static final int CAMERA_HEIGHT = 480;  
04         private Camera andCamera;  
05         public void onLoadComplete() {  
06         }  
07         public Engine onLoadEngine() {  
08             // 构建摄像机  
09             this.andCamera = new Camera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);  
10             // 构建Engine，全屏显示，手机方向为竖屏，按比例拉伸  
11             return new Engine(new EngineOptions(true, ScreenOrientation.PORTRAIT,  
12                     new RatioResolutionPolicy(CAMERA_WIDTH, CAMERA_HEIGHT),  
13                     this.andCamera));  
14         }  
15         public void onLoadResources() {  
16             // 运行一个异步加载，设定内部ProgressDialog标题为资源索引test1对应的字符，内容为test2对应的资源  
17             this.doAsync(R.string.test1, R.string.test2, new Callable() {  
18                 // 希望AndEngine异步加载的数据  
19                 public Void call() throws Exception {  
20                     for (int i = 0; i < Integer.MAX_VALUE; i++) {  
21                     }  
22                     return null;  
23                 }  
24                 // 当加载完成后回调，可在此进行一些加载完毕的事后处理  
25             }, new org.anddev.andengine.util.Callback() {  
26                 public void onCallback(final Void pCallbackValue) {  
27                     Log.d("Callback", "over");  
28                 }  
29             });  
30         }  
31         public Scene onLoadScene() {  
32             // 构建场景，允许的最大Layer数量为1  
33             final Scene scene = new Scene(1);  
34             return scene;  
35         }  
36     }

效果图：

bubuko.com,布布扣

*AndEngine中的精灵调用

精灵类，是任何游戏引擎无法回避的关键性组件之一，常常被用来表示一个游戏中角色或者特定画面要素。如此重要AndEngine当然也不能缺少，其精灵类的基本使用方法如下所示：

01 public class Main extends BaseGameActivity {  
02     private static final int CAMERA_WIDTH = 320;  
03     private static final int CAMERA_HEIGHT = 480;  
04     private Camera andCamera;  
05     private TextureRegion myTextureRegion;  
06     public void onLoadComplete() {  
07     }  
08     public Engine onLoadEngine() {  
09         // 构建摄像机  
10         this.andCamera = new Camera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);  
11         // 构建Engine，全屏显示，手机方向为竖屏，按比例拉伸  
12         return new Engine(new EngineOptions(true, ScreenOrientation.PORTRAIT,  
13                 new RatioResolutionPolicy(CAMERA_WIDTH, CAMERA_HEIGHT),  
14                 this.andCamera));  
15     }  
16     public void onLoadResources() {  
17         //构建纹理  
18         Texture myTexture = new Texture(64, 64, TextureOptions.DEFAULT);  
19         //加载指定路径纹理到myTextureRegion  
20         this.myTextureRegion = TextureRegionFactory.createFromAsset(myTexture,  
21                 this, "Ball.png", 0, 0);  
22         //载入纹理到TextureManager  
23         this.getEngine().getTextureManager().loadTextures(myTexture);  
24     }  
25     public Scene onLoadScene() {  
26         // 构建场景，允许的最大Layer数量为1  
27         final Scene scene = new Scene(1);  
28         // 以myTextureRegion构建Sprite(TextureRegion内部有Texture的引用，AndEngine在构建Sprite时一起加载了)，到坐标55,55  
29         Sprite sprite = new Sprite(55, 55, myTextureRegion);  
30         // 添加精灵  
31         scene.attachChild(sprite);  
32         return scene;  
33     }  
34 }

*AndEngine的精灵动画

在大多数的游戏开发中，仅仅有精灵类存在是不足够的，我们往往还需要让精灵作出绚丽的效果以吸引用户眼球，而这些效果在AndEngine中，统一通过它所提供的各个Modifier类进行实现。具体调用代码如下所示：

01     public class Main extends BaseGameActivity {  
02         private static final int CAMERA_WIDTH = 320;  
03         private static final int CAMERA_HEIGHT = 480;  
04         private Camera andCamera;  
05         private TextureRegion myTextureRegion;  
06         public void onLoadComplete() {  
07         }  
08         public Engine onLoadEngine() {  
09             // 构建摄像机  
10             this.andCamera = new Camera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);  
11             // 构建Engine，全屏显示，手机方向为竖屏，按比例拉伸  
12             return new Engine(new EngineOptions(true, ScreenOrientation.PORTRAIT,  
13                     new RatioResolutionPolicy(CAMERA_WIDTH, CAMERA_HEIGHT),  
14                     this.andCamera));  
15         }  
16         public void onLoadResources() {  
17             // 构建纹理  
18             Texture myTexture = new Texture(64, 64, TextureOptions.DEFAULT);  
19             // 加载指定路径纹理到myTextureRegion  
20             this.myTextureRegion = TextureRegionFactory.createFromAsset(myTexture,  
21                     this, "Ball.png", 0, 0);  
22             // 载入纹理到TextureManager  
23             this.getEngine().getTextureManager().loadTextures(myTexture);  
24         }  
25         public Scene onLoadScene() {  
26             // 在Log中显示FPS数  
27             getEngine().registerUpdateHandler(new FPSLogger());  
28             // 构建场景，允许的最大Layer数量为1  
29             final Scene scene = new Scene(1);  
30             // 获得相对中心坐标  
31             final int centerX = (CAMERA_WIDTH - this.myTextureRegion.getWidth()) / 2;  
32             final int centerY = (CAMERA_HEIGHT - this.myTextureRegion.getHeight()) / 2;  
33             // 以myTextureRegion构建Sprite(TextureRegion内部有Texture的引用，AndEngine在构建Sprite时一起加载了)，到屏幕中心  
34             final Sprite sprite = new Sprite(centerX, centerY, this.myTextureRegion);  
35             // 添加精灵  
36             scene.attachChild(sprite);  
37             // 制作一组动作序列，首先10秒内不断顺时针旋转360度，而后10秒内不断逆时针旋转360度  
38             SequenceEntityModifier ballAction = new SequenceEntityModifier(  
39                     new RotationModifier(10, 0, 360), new RotationModifier(10, 360,  
40                             0));  
41             // 注册动作序列到精灵  
42             sprite.registerEntityModifier(ballAction);  
43             return scene;  
44         }  
45     }

效果图：

bubuko.com,布布扣

AndEngine的常用模块介绍~

以下仅为AndEngine核心模块简单介绍：

Engine：

Engine是AndEngine的核心所在，它对AndEngine引擎中Camera、Scene等重要组件进行了统一管理，但必须和BaseGameActivity合作使用，利用EngineOptions类可以对其进行必要的参数配置。

BaseGameActivity:

如果你想正常使用AndEngine，那么当前Activity就必须继承自BaseGameActivity或其子类，否则你连初始化Engine也无法做到。虽然它还有父类BaseActivity，但BaseActivity只提供了一些异步加载方法而无关AndEngine的主体实现。因此，BaseGameActivity就是实际上的AndEngine最基础用类。

IResolutionPolicy: 

IResolutionPolicy 是一个接口类，其中只规定了onMeasure函数的实现格式。事实上，AndEngine中所有该类具体实现的作用与标准View中的 onMeasure函数几乎一致，也会被标准View中的onMeasure函数重载调用（具体调用在AndEngine的 RenderSurfaceView类当中）。且除BaseResolutionPolicy外，所有AndEngine的 IResolutionPolicy实现也都调用了View的setMeasuredDimensionProxy函数。

在 AndEngine的org.anddev.andengine.engine.options.resolutionpolicy包下有一组 IResolutionPolicy接口的具体实现，分别为BaseResolutionPolicy（除了会校验一下屏幕大小外，什么也不做）、 FillResolutionPolicy（拉伸游戏画面为全屏填充，视摄像机大小不同，会有不同程度变形）、 FixedResolutionPolicy（强行规定游戏画面为固定大小，此设置不会自动适应屏幕大 小），RatioResolutionPolicy（按比例修正画面大小，以适应屏幕大小），RelativeResolutionPolicy（根据构建RelativeResolutionPolicy时的缩放参数，缩放游戏屏幕为指定比例）。

最后，所有IResolutionPolicy的实现类，都要随着EngineOptions于初试化时传递给Engine实例才起作用。

Camera: 

该类即我们常说的游戏摄像机，在AndEngine的Camera有两种作用，一是用以调节屏幕的显示区域，二是利用HUD类实际绘制游戏屏幕于手机之上。

Scene: 

场景容器，作用类似于LGame中的Screen，能够将某一特定场景作为游戏模块进行调用，我们可以利用它来切换当前游戏的画面与触摸屏监听，切换方法是利用Engine.setScene。

Entity: 

Entity 是IEntity接口的具体实现，也是AndEngine中无论Scene、Layer、Sprite(这个继承关系比较远，中间隔了 BaseRectangle、RectangularShape、GLShape、Shape等上级类，不过追溯源头始终继承自Entity)的统一父类，通过Entity我们可以让AndEngine中场景，或场景中某精灵实现统一效果的缩放、旋转、变色等操作。

Texture: 

Texture 是AndEngine所提供的纹理用类，但Texture本身并没有提供加载图片的方法，必须通过 TextureRegionFactory类（更准确的说，依赖它内部封装的TextureRegion、BuildableTexture等类）与之合作才可以加载纹理。除此之外，AndEngine要求所加载纹理（图片）大小必须为2的整数次幂。

TextureRegion: 

TextureRegion 的父类是抽象类BaseTextureRegion，主要功能也被封装在BaseTextureRegion类当中，AndEngine提供了 TextureRegionFactory这个工厂类用以简化构建TextureRegion的流程。单就TextureRegion来讲，它的作用似乎 就是让系统知道如何剪切一个纹理，并返回一个这样的纹理给你。

然而，事实上AndEngine中只有TextureRegion才更接近于通常意义上的Texture。或者说，只有TextureRegion + Texture时，我们才能较为完整的使用AndEngine纹理功能。严肃的讲，AndEngine中的Texture有很多功能必须靠 TextureRegion最终完成，比如AndEngine中的Sprite必须加载TextureRegion才能使用Texture，而不是直接调 用Texture，TMXTiledMap中读取指定瓦片返回的也是TextureRegion，而非直接的Texture（进行画面渲染时 AndEngine内部会调用TextureRegion中的Texture引用，但也只允许如此调用），应该说，AndEngine中见Texture 几乎必见TextureRegion，二者无法分离，缺一不可。

TextureOptions：

在AndEngine中，TextureRegionFactory类决定纹理的加载路径，Texture类作为承载纹理的实体对象，而TextureOptions类决定了纹理的渲染方式。

也即是说，OpenGLES将以何种方式显示纹理图像，都由TextureOptions类所决定。在当前最新版本的AndEngine中，默认提供了：

1、NEAREST（Nearest滤波，实现上依赖GL_NEAREST做不光滑过滤，纹理环绕模式为GL_CLAMP_TO_EDGE，显示速度快画质差）

2、BILINEAR（双线性插值，实现上依赖GL_LINEAR做线性滤波，纹理环绕模式为GL_CLAMP_TO_EDGE，显示速度慢画质佳）

3、REPEATING（与NEAREST同为Nearest滤波,但纹理环绕模式为GL_REPEAT，会自动填充纹理上的空白区域，显示速度较快画质差）

4、REPEATING_BILINEAR（与BILINEAR同为双线性插值，但纹理环绕模式为GL_REPEAT，会自动填充纹理上的空白区域，显示速度很慢画质佳(低端机跑此模式异常悲剧，高端机尚可)）

5、NEAREST_PREMULTIPLYALPHA（所有[PREMULTIPLYALPHA]结尾的TextureOptions与其它同名类差别仅在于是否支持根据Alpha值设置透明纹理）

6、BILINEAR_PREMULTIPLYALPHA

7、REPEATING_PREMULTIPLYALPHA

8、REPEATING_BILINEAR_PREMULTIPLYALPHA等静态对象。

以上TextureOptions实例都可以通过“TextureOptions.XXXXXX”的方式进行引用并设置给Texture。事实上，除了AndEngine提供的Texture渲染模式，我们也可以按照规则自行构建需要的TextureOptions。

比如构建一个混插的TextureOptions： 

new TextureOptions(GL10.GL_LINEAR_MIPMAP_LINEAR, GL10.GL_LINEAR_MIPMAP_NEAREST, GL10.GL_REPEAT, GL10.GL_REPEAT, GL10.GL_MODULATE, true); 

另外，TextureOptions默认还有DEFAULT模式，不 过该模式实际引用为NEAREST_PREMULTIPLYALPHA，也就是纹理低画质但支持Alpha。如果您想要兼容低端机，则建议不要使用含有 【BILINEAR】字样的AndEngine加载大图，而应直接使用TextureOptions.DEFAULT或 TextureOptions.NEAREST_PREMULTIPLYALPHA；因为BILINEAR模式对硬件要求较高，如果以此模式将较大纹理放 到低端机上渲染，速度很可能无法保证。但是，假如你的游戏只针对高端机用户便无需介怀了。

以上内容参考自DevStore

Android游戏引擎AndEngine入门讲解

标签：android游戏引擎   游戏引擎   andengine   android开发服务   

原文地址：http://blog.csdn.net/c1782746138/article/details/39547977
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！