Android高级进阶十二 在Android上使用3D 引擎(JPCT-AE)构建立方体

最新版本：Android高级进阶十二 在Android上使用3D 引擎(JPCT-AE)构建立方体

         上面好多文章都是介绍使用Android原生opengl接口的，使用起来很是麻烦，代码量冗余臃肿，所以walfred设想是否有几款封装好了的“新引擎”，当然还最好是开源的，在Android 开源3D游戏引擎调研一 中，我们找到了不少优秀的引擎，今天我们就开始使用JPCT-AE，并且做一个使用JPCT-AE构建立方体的实例，算是入门篇，这个虽然比较简单好用，但是我还是建议你先看完基本的opengl操作，之后再使用JPCT-AE就如鱼得水了。

        这个例子的效果图如下：

        因为已经假设你有一些opengl操作，我这边把所有的代码都加上了注释，所以看起来是很方便的。

Java代码

 package org.ourunix.android.jpctcube;

 import java.lang.reflect.Field;

 import javax.microedition.khronos.egl.EGLConfig;
 import javax.microedition.khronos.opengles.GL10;

 import com.threed.jpct.Camera;
 import com.threed.jpct.FrameBuffer;
 import com.threed.jpct.Light;
 import com.threed.jpct.Logger;
 import com.threed.jpct.Object3D;
 import com.threed.jpct.Primitives;
 import com.threed.jpct.RGBColor;
 import com.threed.jpct.SimpleVector;
 import com.threed.jpct.Texture;
 import com.threed.jpct.TextureManager;
 import com.threed.jpct.World;
 import com.threed.jpct.util.MemoryHelper;

 import android.app.Activity;
 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.opengl.GLSurfaceView;
 import android.opengl.GLSurfaceView.Renderer;
 import android.os.Bundle;
 import android.view.MotionEvent;

 public class JPCTCubeActivity extends Activity {
     /** Called when the activity is first created. */
     private Context mContext;

     // 这是和一般的opengl一样，定义一个glview
     GLSurfaceView mGLSurfaceView;

     // 这是和一般的opengl一样，定义一个渲染类mGlRenderer
     GlRenderer mGlRenderer;

     private static JPCTCubeActivity master;

     // 当JPCT渲染背景时FrameBuffer类提供了一个缓冲,它的结果本质上是一个能显示或者修改甚至能进行更多后处理的图片。
     private FrameBuffer fb;

     // World类是JPCT时最重要的一个类，它好像胶水一样把事物"粘"起来。它包含的对象和光线定义了JPCT的场景
     private World world;

     // 类似java.awt.*中的Color类
     private RGBColor backColor = new RGBColor(50, 50, 100);

     private float rotateX = 0;
     private float rotateY = 0;

     //x轴方向坐标
     private float xpos = -1;

     //y轴方向坐标
     private float ypos = -1;

     // Object3D类是一个三维对象,千万不要傻呼呼的认为它与java.lang.Object类似。
     // 一个Object3D对象作为一个实例被添加到在渲染的World对象中。Object3D在World
     // 中一次添加一个实例 ，他们可能被联系起作为孩子/父母来在他们中建立一个制度.
     // 人体模型当然也能应用在以上的规则中。他们常常不加到一个World实例中，而是
     // 绑定到其它对象中(人体模型或非人体模型)。有些方法 在这个类中需要一个实例
     // 添加到一个World实例中(用World.addObject()方法可以实现)。
     private Object3D cube;

     // 每秒帧数
 //  private int fps = 0;

     // 光照类
     private Light sun;

     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         // Logger类是jPCT中一个普通的用于打印和存储消息，错误和警告的日志类。
         // 每一个JPCT生成的消息将被加入到这个类的队列中
         Logger.log("onCreate");

         // 如果本类对象不为NULL,将从Object中所有属性装入该类
         if (master != null) {
             copy(master);
         }

         // 上下文
         mContext = this;

         // 这是和一般的opengl一样，定义一个glview
         mGLSurfaceView = new GLSurfaceView(this);

         // 这是和一般的opengl一样，定义一个渲染类mGlRenderer
         mGlRenderer = new GlRenderer();

         mGLSurfaceView.setRenderer(mGlRenderer);

         setContentView(mGLSurfaceView);

     }

     @Override
     protected void onStart() {
         // TODO Auto-generated method stub
         Logger.log("onStart");
         super.onStart();
     }

     @Override
     protected void onRestart() {
         // TODO Auto-generated method stub
         Logger.log("onRestart");
         super.onRestart();
     }

     @Override
     protected void onPause() {
         // TODO Auto-generated method stub
         Logger.log("onPause");
         super.onPause();
         mGLSurfaceView.onPause();
     }


     @Override
     protected void onResume() {
         // TODO Auto-generated method stub
         Logger.log("onResume");
         super.onResume();
         mGLSurfaceView.onResume();
     }

     @Override
     protected void onStop() {
         // TODO Auto-generated method stub
         Logger.log("onStop");
         super.onStop();
     }


     @Override
     protected void onDestroy() {
         // TODO Auto-generated method stub
         Logger.log("onDestroy");
         super.onDestroy();
     }

     private void copy(Object src) {
         // TODO Auto-generated method stub
         try {
             // 打印日志
             Logger.log("Copying data from master Activity!");
             // 返回一个数组，其中包含目前这个类的的所有字段的Filed对象
             Field[] fs = src.getClass().getDeclaredFields();
             // 遍历fs数组
             for (Field f : fs) {
                 // 尝试设置无障碍标志的值。标志设置为false将使访问检查，设置为true，将其禁用。
                 f.setAccessible(true);
                 // 将取到的值全部装入当前类中
                 f.set(this, f.get(src));
             }
         } catch (Exception e) {
             // 抛出运行时异常
             throw new RuntimeException(e);
         }
     }

     @Override
     public boolean onTouchEvent(MotionEvent me) {
         // TODO Auto-generated method stub

         // 按键开始
         if (me.getAction() == MotionEvent.ACTION_DOWN) {
             // 保存按下的初始x,y位置于xpos,ypos中
             xpos = me.getX();
             ypos = me.getY();
             return true;
         }
         // 按键结束
         if (me.getAction() == MotionEvent.ACTION_UP) {
             // 设置x,y及旋转角度为初始值
             xpos = -1;
             ypos = -1;
             rotateX = 0;
             rotateY = 0;
             return true;
         }

         if (me.getAction() == MotionEvent.ACTION_MOVE) {
             // 计算x,y偏移位置及x,y轴上的旋转角度
             float xd = me.getX() - xpos;
             float yd = me.getY() - ypos;

             xpos = me.getX();
             ypos = me.getY();

             rotateX = xd / -100f;
             rotateY = yd / -100f;
             return true;
         }

         // 每Move一下休眠毫秒
         try {
             Thread.sleep(15);
         } catch (Exception e) {
             // No need for this...
         }
         return super.onTouchEvent(me);
     }
     public class GlRenderer implements Renderer {

         // 停止旗语
         private boolean stop = false;

         // 停止方法
         public void setStop() {
             stop = true;
         }

         @Override
         public void onDrawFrame(GL10 gl) {
             // TODO Auto-generated method stub
             if (!stop) {
                 // 如果rotateX不为0,向Y轴旋转rotateX角度
                 if (rotateX != 0) {
                     // 旋转物体的绕Y旋转
                     cube.rotateY(rotateX);
                     // 将rotateX置0
                     rotateX = 0;
                 }

                 if (rotateY != 0) {
                     // 旋转物体的旋转围绕x由给定角度宽（弧度，逆时针为正值）轴矩阵,应用到对象下一次渲染时。
                     cube.rotateX(rotateY);
                     // 将rotateY置0
                     rotateY = 0;
                 }

                 // 用给定的颜色(backColor)清除FrameBuffer
                 fb.clear(backColor);

                 // 变换和灯光所有多边形
                 world.renderScene(fb);

                 // 绘制
                 world.draw(fb);

                 // 渲染图像显示
                 fb.display();
             }else {
                 if (fb != null) {
                     fb.dispose();
                     fb = null;
                 }
             }
         }

         @Override
         public void onSurfaceChanged(GL10 gl, int width, int height) {
             // TODO Auto-generated method stub
             // 如果FrameBuffer不为NULL,释放fb所占资源
             if (fb != null) {
                 fb.dispose();
             }

             // 创建一个宽度为w,高为h的FrameBuffer
             fb = new FrameBuffer(gl, width, height);

             // 如果master为空
             if (master == null) {

                 // 实例化World对象
                 world = new World();

                 // 设置了环境光源强度。负:整个场景会变暗;正:将照亮了一切。
                 world.setAmbientLight(20, 20, 20);

                 // 在World中创建一个新的光源
                 sun = new Light(world);

                 // 创建一个纹理
                 Bitmap image = BitmapFactory.decodeResource(mContext
                         .getResources(), R.drawable.img);
                 Texture texture = new Texture(image);

                 // 纹理的名字
                 String textureName = "texture";

                 // TextureManager.getInstance()取得一个Texturemanager对象
                 // addTexture(textureName,texture)添加一个纹理
                 TextureManager.getInstance().addTexture(textureName, texture);

                 // Object3D对象开始了:-)

                 // Primitives提供了一些基本的三维物体，假如你为了测试而生成一些对象或为
                 // 其它目的使用这些类将很明智，因为它即快速又简单，不需要载入和编辑。
                 // 调用public static Object3D getCube(float scale) scale:角度
                 // 返回一个立方体
                 cube = Primitives.getCube(10);

                 // 以纹理的方式给对象所有面"包装"上纹理
                 cube.calcTextureWrapSpherical();

                 // 给对象设置纹理
                 cube.setTexture(textureName);

                 // 除非你想在事后再用PolygonManager修改,否则释放那些不再需要数据的内存
                 cube.strip();

                 // 初始化一些基本的对象是几乎所有进一步处理所需的过程。
                 // 如果对象是"准备渲染"(装载，纹理分配，安置，渲染模式设置，
                 // 动画和顶点控制器分配),那么build()必须被调用，
                 cube.build();

                 // 将Object3D对象添加到world集合
                 world.addObject(cube);

                 // 该Camera代表了Camera/viewer在当前场景的位置和方向，它也包含了当前视野的有关信息
                 // 你应该记住Camera的旋转矩阵实际上是应用在World中的对象的一个旋转矩阵。
                 // 这一点很重要，当选择了Camera的旋转角度，一个Camera(虚拟)围绕w旋转和通过围绕World围绕w旋转、
                 // 将起到相同的效果，因此，考虑到旋转角度，World围绕camera时，camera的视角是静态的。假如你不喜欢
                 // 这种习惯，你可以使用rotateCamera()方法
                 Camera cam = world.getCamera();

                 // 以50有速度向后移动Camera（相对于目前的方向）
                 cam.moveCamera(Camera.CAMERA_MOVEOUT, 50);

                 // cub.getTransformedCenter()返回对象的中心
                 // cam.lookAt(SimpleVector lookAt))
                 // 旋转这样camera以至于它看起来是在给定的world-space 的位置
                 cam.lookAt(cube.getTransformedCenter());

                 // SimpleVector是一个代表三维矢量的基础类，几乎每一个矢量都
                 // 是用SimpleVector或者至少是一个SimpleVector变体构成的(有时由于
                 // 某些原因比如性能可能会用(float x,float y,float z)之类)。
                 SimpleVector simpleVector = new SimpleVector();

                 // 将当前SimpleVector的x,y,z值设为给定的SimpleVector(cube.getTransformedCenter())的值
                 simpleVector.set(cube.getTransformedCenter());

                 // Y方向上减去100
                 simpleVector.y -= 100;

                 // Z方向上减去100
                 simpleVector.z -= 100;

                 // 设置光源位置
                 sun.setPosition(simpleVector);

                 // 强制GC和finalization工作来试图去释放一些内存，同时将当时的内存写入日志，
                 // 这样可以避免动画不连贯的情况，然而，它仅仅是减少这种情况发生的机率
                 MemoryHelper.compact();

                 // 如果master为空,使用日志记录且设master为HelloWorld本身
                 if (master == null) {
                     // Logger.log("Saving master Activity!");
                     master = JPCTCubeActivity.this;
                 }
             }

         }

         @Override
         public void onSurfaceCreated(GL10 gl, EGLConfig config) {
             // TODO Auto-generated method stub

         }

     }
 }

        源码下载： Android高级进阶十二 Android3D引擎(JPCT-AE)构建立方体源码