workspace/JuggleMaster/src/com/jm/opengl/JuggleDrawer.java

   1 package com.jm.opengl;\r
   2 \r
   3 import javax.microedition.khronos.opengles.GL10;\r
   4 \r
   5 import android.opengl.GLU;\r
   6 \r
   7 import com.jm.Ball;\r
   8 import com.jm.JmPattern;\r
   9 import com.jm.JuggleView;\r
  10 import com.jm.Juggler;\r
  11 import com.jm.JugglingBalls;\r
  12 import com.jm.utility.JmException;\r
  13 import com.jm.utility.Resource;\r
  14 \r
  15 // JugglerCanvas\82Ì\91ã\82í\82è\r
  16 public class JuggleDrawer {\r
  17         private static final int DENOMINATOR = 1000;\r
  18         private static final int N = 2;\r
  19         \r
  20         private JuggleView view;\r
  21 \r
  22         private int diameter;\r
  23         private int center;\r
  24         private int base = 60;\r
  25         // private int magnification = 400;\r
  26         private int magnification = -1;\r
  27         private int ssHeight;\r
  28 \r
  29         //private JmPattern jp;\r
  30         private Juggler handler;\r
  31         private JugglingBalls balls;\r
  32 \r
  33         private GL10 currentGL10;\r
  34         private PolygonDrawer polygonDrawer = new PolygonDrawer();\r
  35         private float cr = -1;\r
  36         \r
  37 \r
  38         //public JuggleDrawer(JuggleView view, int id) throws JmException {\r
  39         public JuggleDrawer(JuggleView view, JmPattern jp) throws JmException {\r
  40                 this.view = view;\r
  41 \r
  42 //              JmPattern[] list = Dao.getInstance().getFromId(id);\r
  43 //              if (list.length <= 0) {\r
  44 //                      throw new JmException();\r
  45 //              }\r
  46 //              jp = list[0];\r
  47                 handler = new Juggler(this);\r
  48                 handler.start(jp);\r
  49         }\r
  50 \r
  51         public void clear() {\r
  52                 magnification = -1;\r
  53                 currentGL10 = null;\r
  54                 OpenGLGraphics.dispose();\r
  55         }\r
  56 \r
  57         public void setBalls(JugglingBalls balls) {\r
  58                 this.balls = balls;\r
  59         }\r
  60 \r
  61         protected void onDrawInit() {\r
  62                 center = getWidth() / 2;\r
  63                 OpenGLGraphics g = OpenGLGraphics.getInstance();\r
  64                 g.translate(center, getHeight());\r
  65                 ssHeight = Resource.charHeight() + 2;\r
  66 \r
  67                 this.setImageHeight(balls.getYRange());\r
  68                 this.createBalls(handler.getSiteSwap().getNumberOfBalls());\r
  69         }\r
  70 \r
  71         void setImageHeight(int yrange) {\r
  72                 magnification = DENOMINATOR;\r
  73                 int height = getHeight() - ssHeight;\r
  74                 if (yrange > 0) {\r
  75                         magnification = magnification * height / yrange;\r
  76                 }\r
  77                 base = (int) (getHeight() - 55 * magnification / DENOMINATOR);\r
  78         }\r
  79 \r
  80         public void createBalls(int number) {\r
  81                 diameter = translateR(Ball.RADIUS) * 2;\r
  82                 if (diameter < 2) {\r
  83                         diameter = 2;\r
  84                 }\r
  85         }\r
  86 \r
  87         public int getWidth() {\r
  88                 return view.getSurfaceWidth();\r
  89         }\r
  90 \r
  91         public int getHeight() {\r
  92                 return view.getSurfaceHeight();\r
  93         }\r
  94 \r
  95         public void update() {\r
  96                 handler.updateJuggler();\r
  97         }\r
  98 \r
  99         public void draw(GL10 gl) {\r
 100                 if (magnification < 0) {\r
 101                         onDrawInit();\r
 102                 }\r
 103                 gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);\r
 104 \r
 105                 gl.glMatrixMode(GL10.GL_MODELVIEW);\r
 106                 gl.glLoadIdentity();\r
 107 \r
 108                 if (cr < 0){\r
 109                         cr = getHeight() / 2;\r
 110                 }\r
 111                 float hm = (int)cr;\r
 112                 float lm = OpenGLActivityBase.LN * hm / OpenGLActivityBase.HN;\r
 113                 float r = lm;\r
 114                 float cx = Resource.cx;\r
 115                 float cy = Resource.cy;\r
 116 \r
 117                 GLU.gluLookAt(gl,\r
 118                                 (float) (r * Math.sin(cx) * Math.cos(cy)),\r
 119                                 (float) (r * Math.sin(cy)),\r
 120                                 (float) (r * Math.cos(cx) * Math.cos(cy)),\r
 121                                 0, 0, 0,\r
 122                                 (float) (r * Math.sin(cx) * Math.cos(cy)),\r
 123                                 (float) (r * Math.sin(cy)) + 1,\r
 124                                 (float) (r * Math.cos(cx) * Math.cos(cy)));\r
 125                 \r
 126                 currentGL10 = gl;\r
 127                 OpenGLGraphics g = OpenGLGraphics.getInstance();\r
 128                 g.begin(gl);\r
 129                 drawGround(g);\r
 130                 handler.drawJuggler();\r
 131                 g.end(gl);\r
 132         }\r
 133 \r
 134         private void drawGround(OpenGLGraphics g){\r
 135                 int w = this.getWidth();\r
 136                 int h = (int)((-this.getHeight() / 2) * 1.05f);\r
 137                 int z = (int)((h / 10) * 1.5f);\r
 138                 int ww = w / 10;\r
 139                 int n;\r
 140                 int m = 224;\r
 141                 float dn = 0.9f;\r
 142                 int size = 1;\r
 143                 \r
 144                 n = m;\r
 145                 g.drawLine(getGL(), -ww * 5, h, z * 3, ww * 5, h, z * 3, n, n, n, size);\r
 146                 n = (int)(n * dn);\r
 147                 g.drawLine(getGL(), -ww * 5, h, z * 1, ww * 5, h, z * 1, n, n, n, size);\r
 148                 n = (int)(n * dn);\r
 149                 g.drawLine(getGL(), -ww * 5, h, z * -1, ww * 5, h, z * -1, n, n, n, size);\r
 150                 n = (int)(n * dn);\r
 151                 g.drawLine(getGL(), -ww * 5, h, z * -3, ww * 5, h, z * -3, n, n, n, size);\r
 152                 n = (int)(n * dn);\r
 153 \r
 154                 n = m;\r
 155                 g.drawLine(getGL(), -ww * 5, h, -z * 3, -ww * 5, h, z * 3, n, n, n, size);\r
 156                 n = (int)(n * dn);\r
 157                 g.drawLine(getGL(), -ww * 3, h, -z * 3, -ww * 3, h, z * 3, n, n, n, size);\r
 158                 n = (int)(n * dn);\r
 159                 g.drawLine(getGL(), -ww * 1, h, -z * 3, -ww * 1, h, z * 3, n, n, n, size);\r
 160                 n = (int)(n * dn);\r
 161                 g.drawLine(getGL(), -ww * -1, h, -z * 3, -ww * -1, h, z * 3, n, n, n, size);\r
 162                 n = (int)(n * dn);\r
 163                 g.drawLine(getGL(), -ww * -3, h, -z * 3, -ww * -3, h, z * 3, n, n, n, size);\r
 164                 n = (int)(n * dn);\r
 165                 g.drawLine(getGL(), -ww * -5, h, -z * 3, -ww * -5, h, z * 3, n, n, n, size);\r
 166                 n = (int)(n * dn);\r
 167         \r
 168                 polygonDrawer.drawBoard(getGL(), ww * 5, h, -z * 3, ww * -5, h, z * 3, 160, 160, 160, 0);\r
 169         }\r
 170         \r
 171         public void rotate(float vx, float vy, float vr) {\r
 172                 float cx = Resource.cx;\r
 173                 float cy = Resource.cy;\r
 174                 float dy = 0.001f;\r
 175                 \r
 176                 cx -= vx;\r
 177                 if (cx < -(float)Math.PI / 2){\r
 178                         cx = -(float)Math.PI / 2;\r
 179                 }\r
 180                 else if (cx > (float)Math.PI / 2){\r
 181                         cx = (float)Math.PI / 2;\r
 182                 }\r
 183                 \r
 184                 cy += vy;\r
 185                 if (cy < -(float)Math.PI / 2 + dy){\r
 186                         cy = -(float)Math.PI / 2 + dy;\r
 187                 }\r
 188                 else if (cy > (float)Math.PI / 2 - dy){\r
 189                         cy = (float)Math.PI / 2 - dy;\r
 190                 }\r
 191 \r
 192                 if (cr >= 0){\r
 193                         cr -= vr;\r
 194                         int h = getHeight();\r
 195                         if (cr < h / 6){\r
 196                                 cr = h / 6;\r
 197                         }\r
 198                         else if (cr > h * 3){\r
 199                                 cr = h * 3;\r
 200                         }\r
 201                 }\r
 202                 \r
 203                 Resource.cx = cx;\r
 204                 Resource.cy = cy;\r
 205         }\r
 206 \r
 207         private GL10 getGL() {\r
 208                 return currentGL10;\r
 209         }\r
 210 \r
 211         public void drawBall(int i, int x, int y) {\r
 212                 OpenGLGraphics g = OpenGLGraphics.getInstance();\r
 213                 x = translateX(x);\r
 214                 y = translateY(y);\r
 215                 g.drawImage(getGL(), i, x, y, diameter / 2, diameter / 2);\r
 216         }\r
 217 \r
 218         public void drawLine(int x1, int y1, int x2, int y2) {\r
 219                 OpenGLGraphics g = OpenGLGraphics.getInstance();\r
 220                 x1 = translateX(x1);\r
 221                 y1 = translateY(y1);\r
 222                 x2 = translateX(x2);\r
 223                 y2 = translateY(y2);\r
 224                 g.drawLine(getGL(), x1, y1, x2, y2, N);\r
 225         }\r
 226 \r
 227         public void drawCircle(int x, int y, int r) {\r
 228                 OpenGLGraphics g = OpenGLGraphics.getInstance();\r
 229                 x = translateX(x);\r
 230                 y = translateY(y);\r
 231                 r = translateR(r);\r
 232                 g.drawCircle(getGL(), x, y, r, N);\r
 233         }\r
 234 \r
 235         private int translateX(int x) {\r
 236                 if (JmPattern.ifMirror())\r
 237                         x = -x;\r
 238                 return translate(x);\r
 239         }\r
 240 \r
 241         private int translateY(int y) {\r
 242                 return translate(y) + base;\r
 243         }\r
 244 \r
 245         private int translateR(int r) {\r
 246                 return translate(r);\r
 247         }\r
 248 \r
 249         private int translate(int t) {\r
 250                 return t * magnification / DENOMINATOR;\r
 251         }\r
 252 }