开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > J2ME > 查看源码
LightDemoCanvas.java
资源名称：J2ME&Game.rar　[点击查看]
上传用户：gyyuli
上传日期：2013-07-09
资源大小：3050k
文件大小：12k
源码类别：

J2ME

开发平台：

Java

LightDemoCanvas.java：源码内容
  3. import javax.microedition.lcdui.*;
  4. import javax.microedition.lcdui.game.*;
  6. import javax.microedition.m3g.*;
  8. class LightDemoCanvas extends GameCanvas implements Runnable,CommandListener{
  9.   
  10.     private Graphics3D g3d; // Graphics object used to render the world.
  11.     private World world; // This world contains the camera and the pyramidMesh.
  12.     private Camera camera; // the camera in the scene
  13.     private Mesh icosahedronMesh; // the icosahedron in the scene
  14.     private Light light;
  15.     private int lightIndex = 0;
  16.     private javax.microedition.midlet.MIDlet midlet;
  17.     private Image SwitchImage = null;
  18.     private final int SCREEN_WIDTH;
  19.     private final int SCREEN_HEIGHT;
  20.     private Command  AMBIENT_Cmd = new Command("环境光", Command.SCREEN, 1);
  21.     private Command  DIRECTIONAL_Cmd = new Command("镜面光", Command.SCREEN, 1);
  22.     private Command  OMNI_Cmd = new Command("漫射光", Command.SCREEN, 1);
  23.     private Command  SPOT_Cmd = new Command("散射光", Command.SCREEN, 1);
  24.     private Command  EXIT_Cmd = new Command("退出", Command.SCREEN, 1);
  26.     public LightDemoCanvas(javax.microedition.midlet.MIDlet m){
  27.         super(false);
  28.         midlet = m;
  29.         this.addCommand(AMBIENT_Cmd);
  30.         this.addCommand(DIRECTIONAL_Cmd);
  31.         this.addCommand(OMNI_Cmd);
  32.         this.addCommand(SPOT_Cmd);
  33.         this.addCommand(EXIT_Cmd);
  34.         this.setCommandListener(this);
  35.         SCREEN_WIDTH = getWidth();
  36.         SCREEN_HEIGHT = getHeight(); 
  37.         g3d = Graphics3D.getInstance();
  38.         world = new World();
  39.         camera = new Camera();
  40.         world.addChild(camera); // add the camera to the world.
  41.         light = new Light();                    // Create a new light
  42.         light.translate(0.0f, 0.0f, -1.0f); // The light position
  43.         light.setMode(Light.AMBIENT);   // Light Mode
  44.         light.setColor(0x000000);           // The color of the light 'WHITE'
  45.         light.setSpotExponent(10.0f); // splot light concentration 0 to 128
  46.         world.addChild(light);                // Add the light to the world to be rendered.
  47.         // Constructs a perspective projection matrix and sets that as the current projection matrix.
  48.         camera.setPerspective(60.0f, (float)SCREEN_WIDTH / (float)SCREEN_HEIGHT, 0.1f, 50f);
  49.         icosahedronMesh = createIcosahedron(); // create our Icosahedron.
  50.         icosahedronMesh.setTranslation(0.0f, 0.0f, -3.0f); // move the icosahedron 3 units into the screen.
  51.         world.addChild(icosahedronMesh);
  52.         world.setActiveCamera(camera);
  53.         Thread t = new Thread(this);
  54.         t.start();
  55.     }
  56.  
  57.     /*
  58.      * Change the Light Mode to be used.
  59.      */
  60.     public void nextLight(){
  61.         switch(lightIndex){
  62.             case 0:
  63.                 light.setMode(Light.AMBIENT);
  64.                 break;
  65.             case 1:
  66.                 light.setMode(Light.DIRECTIONAL);
  67.                 break;
  68.             case 2:
  69.                 light.setMode(Light.OMNI);
  70.                 break;
  71.             case 3:
  72.                 light.setMode(Light.SPOT);
  73.                 break;
  74.         }
  75.     }
  76.     public void draw3D(Graphics g){
  77.         g.setColor(0x0000FF);
  78.         g.fillRect(0, 0, getWidth(), getHeight());
  79.         try{
  80.             g3d.bindTarget(g); // Binds the given Graphics or mutable Image2D as the rendering target of this Graphics3D
  81.             g3d.render(world); // Render the world
  82.         }finally{
  83.             g3d.releaseTarget();
  84.         }
  85.     }
  86.     private void draw2D(Graphics g){
  87.         g.setColor(0xFFFFFF);
  88.         switch(lightIndex){
  89.             case 0:
  90.                 g.drawString("环境光(Ambient)", 0, 0, 0);
  91.                 break;
  92.             case 1:
  93.                 g.drawString("镜面光(Directional)", 0, 0, 0);
  94.                 break;
  95.             case 2:
  96.                 g.drawString("漫射光(Omni)", 0, 0, 0);
  97.                 break;
  98.             case 3:
  99.                 g.drawString("散射光(Spot)", 0, 0, 0);
  100.                 break;
  101.         }
  102.     }
  103.     public void run() {
  104.         Graphics g = getGraphics();
  105.         while(true){
  106.         icosahedronMesh.postRotate(1.0f, 0.0f, 1.0f, 0.0f);
  107.         light.postRotate(1.0f, 1.0f, 0.0f, 0.0f); //enable this to make the light rotate around it's x-axis
  108.         draw3D(g);
  109.         draw2D(g);
  110.         flushGraphics();
  111.         }
  112.     }
  113.    public void commandAction(Command cmd, Displayable disp) {
  114.         if(cmd == EXIT_Cmd){
  115.          midlet.notifyDestroyed();
  116.         }else if(cmd == AMBIENT_Cmd){
  117.          lightIndex = 0;
  118.          nextLight();
  119.         }else if(cmd == DIRECTIONAL_Cmd){
  120.          lightIndex = 1;
  121.          nextLight();
  122.         }else if(cmd == OMNI_Cmd){
  123.          lightIndex = 2;
  124.          nextLight();
  125.         }else if(cmd == SPOT_Cmd){
  126.          lightIndex = 3;
  127.          nextLight();
  128.         }     
  129.    }    
  130.     private Mesh createIcosahedron(){
  131.         final short X = 525;
  132.         final short Z = 850;
  133.         short[]ORG_POINTS = new short[] {-X, 0, Z,      X, 0, Z,    -X, 0, -Z,      X, 0, -Z,
  134.                                          0, Z, X,      0, Z, -X,    0, -Z, X,      0, -Z, -X,
  135.                                          Z, X, 0,     -Z, X, 0,     Z, -X, 0,     -Z, -X, 0};
  137.         int []ORG_INDICES = new int[] {0,4, 1,        0,9,4,       9,5,4,       4,5,8,      4,8,1,
  138.                                        8,10,1,       8,3,10,     5,3,8,       5,2,3,       2,7,3,
  139.                                        7,10,3,       7,6,10,     7,11,6,     11,0,6,     0,1,6,
  140.                                        6,1,10,       9,0,11,     9,11,2,     9,2,5,       7,2,11};
  143.         short[]POINTS = new short[72*3];
  144.         int []INDICES = new int[80*3+80];
  145.         for(int i=0; i<36; i++){
  146.             POINTS[i] = ORG_POINTS[i];
  147.         }
  148.         for(int i=0; i<60; i++){
  149.             INDICES[i] = ORG_INDICES[i];
  150.         }
  151.         // Start sub deviding
  152.         // every triangle should become 4 triangles.
  153.         VEK v12, v23, v31;
  154.         int pointIndex = 36;
  155.         int numPoints  = 12;
  156.         int indiceIndex = 60;
  157.         for(int i=0; i<60; i+=3){
  158.             VEK v1 = new VEK(POINTS[INDICES[i]*3], POINTS[INDICES[i]*3+1], POINTS[INDICES[i]*3+2]);
  159.             VEK v2 = new VEK(POINTS[INDICES[i+1]*3], POINTS[INDICES[i+1]*3+1], POINTS[INDICES[i+1]*3+2]);
  160.             VEK v3 = new VEK(POINTS[INDICES[i+2]*3], POINTS[INDICES[i+2]*3+1], POINTS[INDICES[i+2]*3+2]);
  161.             v12 = new VEK(v1.X + v2.X, v1.Y + v2.Y, v1.Z+v2.Z);
  162.             v23 = new VEK(v2.X + v3.X, v2.Y + v3.Y, v2.Z+v3.Z);
  163.             v31 = new VEK(v3.X + v1.X, v3.Y + v1.Y, v3.Z+v1.Z);
  164.             v12 = MATH.vekNormalizePoint(v12);
  165.             v23 = MATH.vekNormalizePoint(v23);
  166.             v31 = MATH.vekNormalizePoint(v31);
  167.             // 3 new points
  168.             POINTS[pointIndex] = v12.X;     // numPoints
  169.             POINTS[pointIndex+1] = v12.Y;
  170.             POINTS[pointIndex+2] = v12.Z;
  171.             POINTS[pointIndex+3] = v23.X; // numPoints + 1
  172.             POINTS[pointIndex+4] = v23.Y;
  173.             POINTS[pointIndex+5] = v23.Z;
  174.             POINTS[pointIndex+6] = v31.X; // numPoints + 2
  175.             POINTS[pointIndex+7] = v31.Y;
  176.             POINTS[pointIndex+8] = v31.Z;
  177.             pointIndex+=9;
  178.      
  179.             // 4 new triangles
  180.             INDICES[indiceIndex] = INDICES[i];
  181.             INDICES[indiceIndex+1] = numPoints;
  182.             INDICES[indiceIndex+2] = numPoints+2;
  183.             INDICES[indiceIndex+3] = INDICES[i+1];
  184.             INDICES[indiceIndex+4] = numPoints+1;
  185.             INDICES[indiceIndex+5] = numPoints;
  186.             INDICES[indiceIndex+6] = INDICES[i+2];
  187.             INDICES[indiceIndex+7] = numPoints+2;
  188.             INDICES[indiceIndex+8] = numPoints+1;
  189.             INDICES[indiceIndex+9] = numPoints;
  190.             INDICES[indiceIndex+10] = numPoints+1;
  191.             INDICES[indiceIndex+11] = numPoints+2;
  192.             indiceIndex += 12;
  193.             numPoints +=3;
  194.         }
  195.         // a normal is created for every point.
  196.         short[] NORMALS = new short[POINTS.length];
  197.         VEK a, b, c;
  198.          for(int i=0; i<NORMALS.length; i+=3){
  199.              a = new VEK(POINTS[i], POINTS[i+1], POINTS[i+2]);
  200.              VEK v = MATH.vekNormalizeNormal(a);
  201.              NORMALS[i] = v.X;
  202.              NORMALS[i+1] = v.Y;
  203.              NORMALS[i+2] = v.Z;
  204.          }
  205.         int []LENGTH = new int[100];// {3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3};
  206.         for(int i=0; i<100; i++){
  207.             LENGTH[i] = 3;
  208.         }
  209.         VertexArray POSITION_ARRAY, NORMAL_ARRAY;
  210.         IndexBuffer INDEX_BUFFER;
  211.         // Create a VertexArray to be used by the VertexBuffer
  212.         POSITION_ARRAY = new VertexArray(POINTS.length / 3, 3, 2);
  213.         POSITION_ARRAY.set(0, POINTS.length / 3, POINTS);
  214.         NORMAL_ARRAY = new VertexArray(NORMALS.length / 3, 3, 2);
  215.         NORMAL_ARRAY.set(0, NORMALS.length / 3, NORMALS);
  216.         INDEX_BUFFER = new TriangleStripArray(INDICES, LENGTH);
  218.         // VertexBuffer holds references to VertexArrays that contain the positions, colors, normals, 
  219.         // and texture coordinates for a set of vertices
  220.         VertexBuffer vertexBuffer = new VertexBuffer();
  221.         vertexBuffer.setPositions(POSITION_ARRAY,(1.0f/1000.0f), null);
  222.         vertexBuffer.setNormals(NORMAL_ARRAY);
  223.         
  224.         // Create the 3D object defined as a polygonal surface
  225.         Mesh mesh = new Mesh(vertexBuffer, INDEX_BUFFER, null);
  226.         
  227.         Appearance appearance = new Appearance(); // A set of component objects that define the rendering attributes of a Mesh
  228.         PolygonMode polygonMode = new PolygonMode(); // An Appearance component encapsulating polygon-level attributes
  229.         polygonMode.setPerspectiveCorrectionEnable(true);
  230.         polygonMode.setCulling(PolygonMode.CULL_FRONT); // Use CULL_FRONT for performance
  231.         appearance.setPolygonMode(polygonMode);
  233.         Material material = new Material();
  234.         material.setColor(Material.AMBIENT, 0xFF0000);
  235.         material.setVertexColorTrackingEnable(true);
  236.         appearance.setMaterial(material);
  237.  
  238.         mesh.setAppearance(0, appearance); // Set the appearance to the 3D object        
  240.         return mesh;
  241.     }
  242. }
  244. class VEK{
  245.     public short X;
  246.     public short Y;
  247.     public short Z;
  249.     public VEK(){
  250.         X=Y=Z=0;
  251.     }
  253.     public VEK(int x, int y, int z){
  254.         X = (short)x;
  255.         Y = (short)y;
  256.         Z = (short)z;
  257.     }
  258.     public String toString(){
  259.         return "X=" + X + " Y=" + Y + " Z=" + Z;
  260.     }
  261.     
  262. }
  264. /*
  265.  *  A few extra math methods used to create the Icosahedron
  266.  */
  267. class MATH{
  268.     public static VEK vekCalculateNormal(VEK v1, VEK v2, VEK v3)  // calculate the normal for a triangle
  269.     {
  270.             VEK q = new VEK(v2.X - v1.X, v2.Y- v1.Y, v2.Z -v1.Z);
  271.             VEK p = new VEK(v3.X - v1.X, v3.Y- v1.Y, v3.Z -v1.Z);
  272.             VEK c = new VEK(p.Y*q.Z - p.Z * q.Y, p.Z*q.X - p.X*q.Z, p.X*q.Y - p.Y*q.X);
  273.             return c;
  274.     }
  276.     public static double vekLength(VEK u) // return the length of the vektor
  277.     {
  278.             return Math.sqrt((u.X*u.X) + (u.Y*u.Y) + (u.Z*u.Z));
  279.     }
  280.     
  281.     public static VEK vekNormalizeNormal(VEK u)  // Normalize a NORMAL
  282.     {
  283.             double length = vekLength(u);
  285.             if(length==0){
  286.                     u.X=u.Y=u.Z=0;
  287.                      return u;
  288.             }
  289.             double a, b, c;
  290.             a = u.X / length;
  291.             b = u.Y / length;
  292.             c = u.Z / length;
  293.             a *= 127;
  294.             b *= 127;
  295.             c *= 127;
  296.             u.X = (short)(a);
  297.             u.Y = (short)(b);
  298.             u.Z = (short)(c);
  299.             return u;
  300.     }
  302.     public static VEK vekNormalizePoint(VEK u)  // Normalize a POINT
  303.     {
  304.             double length = vekLength(u);
  306.             if(length==0){
  307.                     u.X=u.Y=u.Z=0;
  308.                      return u;
  309.             }
  310.             double a, b, c;
  311.             a = u.X / length;
  312.             b = u.Y / length;
  313.             c = u.Z / length;
  314.             a *= 1000;
  315.             b *= 1000;
  316.             c *= 1000;
  317.             u.X = (short)(a);
  318.             u.Y = (short)(b);
  319.             u.Z = (short)(c);
  320.             return u;
  321.     }
  322. }