Changeset 14073

Timestamp:

11/30/12 15:18:38 (12 years ago)

Author:

bduong

Message:

Updated ISSM Visual drawing a fixed amount of randomly generated triangles. Users can rotate and change value of alpha, which just redraws a bunch of new triangles again.

Location:

issm/trunk-jpl/src/android/ISSM_Visual/src/com/example/issm_visual

Files:

• ISSMVisual.java (modified) (5 diffs)
• MyGLRenderer.java (modified) (1 diff)
• MyGLSurfaceView.java (modified) (1 diff)

issm/trunk-jpl/src/android/ISSM_Visual/src/com/example/issm_visual/ISSMVisual.java

@@ -3 +3 @@
 
 import android.app.Activity;
-import android.content.Context;
-import android.opengl.GLES20;
+import android.content.DialogInterface.OnClickListener;
 import android.opengl.GLSurfaceView;
-import android.opengl.GLSurfaceView.Renderer;
 import android.os.Bundle;
-import android.util.AttributeSet;
 import android.view.Menu;
 import android.view.View;
-import android.view.View.OnClickListener;
 import android.widget.Button;
 import android.widget.FrameLayout;
-import android.widget.RelativeLayout;
 import android.widget.SeekBar;
 import android.widget.SeekBar.OnSeekBarChangeListener;
 import android.widget.TextView;
-import android.widget.Toast;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.nio.FloatBuffer;     
-import java.nio.ShortBuffer;
-import javax.microedition.khronos.egl.EGLConfig;
-import javax.microedition.khronos.opengles.GL10; 
 
 public class ISSMVisual extends Activity implements OnSeekBarChangeListener
 {
         private SeekBar bar;
-    private TextView txtStatus, txtValue;
+    private TextView /*txtStatus,*/ txtValue;
     private GLSurfaceView mGLView;
         private FrameLayout frame;
+        
     @Override
-    public void onCreate(Bundle savedInstanceState) {
+    public void onCreate(Bundle savedInstanceState) 
+    {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_issmvisual);
@@ -40 +30 @@
         bar.setOnSeekBarChangeListener(this); // set seekbar listener
         txtValue = (TextView)findViewById(R.id.value);
-        txtStatus = (TextView)findViewById(R.id.status);
+        Button reset = (Button)findViewById(R.id.button1);
+        reset.setOnClickListener(new View.OnClickListener()
+        {
+            public void onClick(View v) 
+            {
+                frame.removeView(mGLView);
+                mGLView = new MyGLSurfaceView(ISSMVisual.this);
+                frame.addView(mGLView);
+            }
+        });
+        //txtStatus = (TextView)findViewById(R.id.status);
         
         mGLView = new MyGLSurfaceView(this);
@@ -46 +46 @@
         frame.addView(mGLView);
     }
-
-
-        @Override
-    public void onProgressChanged(SeekBar seekBar, int val,
+        public void onProgressChanged(SeekBar seekBar, int val,
                 boolean fromUser) 
     {
         // change progress text label with current Seekbar value
-        txtValue.setText("Value: " + val);
-        txtStatus.setText("Status: changing");
+        txtValue.setText("alpha value = " + val);
+        //txtStatus.setText("Status: changing");
     }
         
-    @Override
-    public void onStartTrackingTouch(SeekBar seekBar) 
+    public void onStartTrackingTouch(SeekBar seekBar) {/*txtStatus.setText("Status: Starting to track touch");*/}
+    
+    public void onStopTrackingTouch(SeekBar seekBar) 
     {
-        txtStatus.setText("Status: Starting to track touch");
-
+        seekBar.setSecondaryProgress(seekBar.getProgress()); // set the shade of the previous value.
+        
+        //txtStatus.setText("Status: Ended tracking touch");
+        frame.removeView(mGLView);
+        mGLView = new MyGLSurfaceView(this);
+        frame.addView(mGLView);
     }
     
     @Override
-    public void onStopTrackingTouch(SeekBar seekBar) 
+    protected void onPause() 
     {
-        seekBar.setSecondaryProgress(seekBar.getProgress()); // set the shade of the previous value.
-        txtStatus.setText("Status: Ended tracking touch");
-    }
-    
-    @Override
-    protected void onPause() {
         super.onPause();
         // The following call pauses the rendering thread.
@@ -82 +78 @@
     
     @Override
-    protected void onResume() {
+    protected void onResume() 
+    {
         super.onResume();
         // The following call resumes a paused rendering thread.
@@ -90 +87 @@
     }
 
-    
     @Override
     public boolean onCreateOptionsMenu(Menu menu) 

issm/trunk-jpl/src/android/ISSM_Visual/src/com/example/issm_visual/MyGLRenderer.java

@@ -25 +25 @@
 import android.opengl.GLES20;
 import android.opengl.GLSurfaceView;
-
-public class MyGLRenderer implements GLSurfaceView.Renderer {
-
-    private Triangle mTriangle1, mTriangle2, mTriangle3;
-
-    @Override
-    public void onSurfaceCreated(GL10 unused, EGLConfig config) {
-
+import android.opengl.Matrix;
+
+public class MyGLRenderer implements GLSurfaceView.Renderer 
+{
+        public volatile float mAngle;
+        
+        /**
+         * Store the model matrix. This matrix is used to move models from object space (where each model can be thought
+         * of being located at the center of the universe) to world space.
+         */
+        private float[][] mModelMatrix;
+        
+        /**
+         * Store the view matrix. This can be thought of as our camera. This matrix transforms world space to eye space;
+         * it positions things relative to our eye.
+         */
+        private float[][] mViewMatrix;
+
+        /** Store the projection matrix. This is used to project the scene onto a 2D viewport. */
+        private float[][] mProjectionMatrix;
+
+        /** Allocate storage for the final combined matrix. This will be passed into the shader program. */
+        private float[][] mMVPMatrix;
+
+        /** This will be used to pass in the transformation matrix. */
+        private int mMatrixHandle;
+        
+    private FloatBuffer[] triangleVert;
+    
+    private float[][] triangleData2DArr;
+    
+    private int mPositionHandle;
+    
+    private int mColorHandle;
+    
+        /** How many bytes per float. */
+    private final int mBytesPerFloat = 4;
+
+    /** How many elements per vertex. */
+    private final int mStrideBytes = 7 * mBytesPerFloat;
+
+    /** Offset of the position data. */
+    private final int mPositionOffset = 0;
+
+    /** Size of the position data in elements. */
+    private final int mPositionDataSize = 3;
+
+    /** Offset of the color data. */
+    private final int mColorOffset = 3;
+
+    /** Size of the color data in elements. */
+    private final int mColorDataSize = 4;       
+
+    public MyGLRenderer(float[][] vertices)
+    {   
+        triangleData2DArr = new float[vertices.length][21];
+        triangleVert = new FloatBuffer[vertices.length];
+        
+        for (int i = 0; i < vertices.length; i++)
+        {
+                for (int j = 0; j < 21; j++)
+                        triangleData2DArr[i][j] = vertices[i][j]; 
+        }
+                        
+            // initialize vertex byte buffer for shape coordinates
+        for (int i = 0; i < vertices.length; i++)
+        {
+                triangleVert[i] = ByteBuffer.allocateDirect(triangleData2DArr[i].length * mBytesPerFloat)
+                                                                                                        .order(ByteOrder.nativeOrder()).asFloatBuffer();
+                triangleVert[i].put(triangleData2DArr[i]).position(0);
+        }
+    }
+    
+    public void onSurfaceCreated(GL10 unused, EGLConfig config) 
+    {
         // Set the background frame color
-        GLES20.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
-
-        mTriangle1 = new Triangle(
-        0.0f,  0.6f, 0.0f,   // top
-       -0.5f, -0.3f, 0.0f,   // bottom left
-        0.5f, -0.3f, 0.0f,
-        0.0f, 0.0f, 1.0f, 1.0f);   // bottom right
-        //mTriangle = new Triangle();
-        
-        mTriangle2 = new Triangle(
-        -0.5f, -0.3f, 0.0f,
-         0.0f, -1.0f, 0.0f,
-         0.5f,  -0.3f, 0.0f,
-         1.0f, 0.0f, 0.0f, 1.0f);
-        
-        mTriangle3 = new Triangle(
-        0.0f,  0.6f, 0.0f,
-        0.5f, -0.3f, 0.0f,
-        1.0f,  0.6f, 0.0f,
-        1.0f, 1.0f, 0.0f, 1.0f);
-    }
-
-    @Override
-    public void onDrawFrame(GL10 unused) {
-
-        // Draw background color
-        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
-
-        // Draw triangle
-        mTriangle1.draw(); 
-        mTriangle2.draw();
-        mTriangle3.draw();
-    }
-
-    @Override
-    public void onSurfaceChanged(GL10 unused, int width, int height) {
+        GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+        
+                // Position the eye behind the origin.
+                final float eyeX = 0.0f;
+                final float eyeY = 0.0f;
+                final float eyeZ = 1.5f;
+
+                // We are looking toward the distance
+                final float lookX = 0.0f;
+                final float lookY = 0.0f;
+                final float lookZ = -5.0f;
+
+                // Set our up vector. This is where our head would be pointing were we holding the camera.
+                final float upX = 0.0f;
+                final float upY = 1.0f;
+                final float upZ = 0.0f;
+
+                // Set the view matrix. This matrix can be said to represent the camera position.
+                // NOTE: In OpenGL 1, a ModelView matrix is used, which is a combination of a model and
+                // view matrix. In OpenGL 2, we can keep track of these matrices separately if we choose.
+                mViewMatrix = new float[triangleVert.length][16];
+                
+                for (int i = 0; i < triangleVert.length; i++)
+                        Matrix.setLookAtM(mViewMatrix[i], 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ);
+        
+                final String vertexShader =
+                                "uniform mat4 u_MVPMatrix;      \n"             // A constant representing the combined model/view/projection matrix.
+                          + "attribute vec4 a_Position;     \n"         // Per-vertex position information we will pass in.
+                          + "attribute vec4 a_Color;        \n"         // Per-vertex color information we will pass in.                          
+                          + "varying vec4 v_Color;          \n"         // This will be passed into the fragment shader.
+                          + "void main()                    \n"         // The entry point for our vertex shader.
+                          + "{                              \n"
+                          + "   v_Color = a_Color;          \n"         // Pass the color through to the fragment shader. 
+                                                                                                                // It will be interpolated across the triangle.
+                          + "   gl_Position = u_MVPMatrix   \n"         // gl_Position is a special variable used to store the final position.
+                          + "               * a_Position;   \n"     // Multiply the vertex by the matrix to get the final point in                                                                                       
+                          + "}                              \n";    // normalized screen coordinates.
+
+                        final String fragmentShader =
+                                "precision mediump float;       \n"             // Set the default precision to medium. We don't need as high of a                                                                                      // precision in the fragment shader.                            
+                          + "varying vec4 v_Color;          \n"         // This is the color from the vertex shader interpolated across the 
+                                                                                                                // triangle per fragment.                         
+                          + "void main()                    \n"         // The entry point for our fragment shader.
+                          + "{                              \n"
+                          + "   gl_FragColor = v_Color;     \n"         // Pass the color directly through the pipeline.                  
+                          + "}                              \n";                                                                                                
+
+           
+        int vertexShaderHandle = GLES20.glCreateShader(GLES20.GL_VERTEX_SHADER);
+                // Pass in the shader source.
+                GLES20.glShaderSource(vertexShaderHandle, vertexShader);
+
+                // Compile the shader.
+                GLES20.glCompileShader(vertexShaderHandle);
+
+                // Get the compilation status.
+                final int[] compileStatus1 = new int[1];
+                GLES20.glGetShaderiv(vertexShaderHandle, GLES20.GL_COMPILE_STATUS, compileStatus1, 0);
+
+                // If the compilation failed, delete the shader.
+                if (compileStatus1[0] == 0) 
+                {                               
+                        GLES20.glDeleteShader(vertexShaderHandle);
+                        vertexShaderHandle = 0;
+                }
+                
+         
+        int fragmentShaderHandle = GLES20.glCreateShader(GLES20.GL_FRAGMENT_SHADER);
+                // Pass in the shader source.
+                GLES20.glShaderSource(fragmentShaderHandle, fragmentShader);
+
+                // Compile the shader.
+                GLES20.glCompileShader(fragmentShaderHandle);
+
+                // Get the compilation status.
+                final int[] compileStatus2 = new int[1];
+                GLES20.glGetShaderiv(fragmentShaderHandle, GLES20.GL_COMPILE_STATUS, compileStatus2, 0);
+
+                // If the compilation failed, delete the shader.
+                if (compileStatus2[0] == 0) 
+                {                               
+                        GLES20.glDeleteShader(fragmentShaderHandle);
+                        fragmentShaderHandle = 0;
+                }
+
+        
+        int mProgram = GLES20.glCreateProgram();
+                // Bind the vertex shader to the program.
+                GLES20.glAttachShader(mProgram, vertexShaderHandle);                    
+
+                // Bind the fragment shader to the program.
+                GLES20.glAttachShader(mProgram, fragmentShaderHandle);
+
+                // Bind attributes
+                GLES20.glBindAttribLocation(mProgram, 0, "a_Position");
+                GLES20.glBindAttribLocation(mProgram, 1, "a_Color");
+
+                // Link the two shaders together into a program.
+                GLES20.glLinkProgram(mProgram);
+
+                // Get the link status.
+                final int[] linkStatus = new int[1];
+                GLES20.glGetProgramiv(mProgram, GLES20.GL_LINK_STATUS, linkStatus, 0);
+
+                // If the link failed, delete the program.
+                if (linkStatus[0] == 0) 
+                {                               
+                        GLES20.glDeleteProgram(mProgram);
+                        mProgram = 0;
+                }
+                
+                for (int i = 0; i < triangleVert.length; i++)
+                {
+                        mMatrixHandle = GLES20.glGetUniformLocation(mProgram, "u_MVPMatrix");        
+                mPositionHandle = GLES20.glGetAttribLocation(mProgram, "a_Position");
+                mColorHandle = GLES20.glGetAttribLocation(mProgram, "a_Color");
+                }
+        
+        // Add program to OpenGL environment
+        GLES20.glUseProgram(mProgram);
+    }
+    
+    public void onSurfaceChanged(GL10 unused, int width, int height) 
+    {
         // Adjust the viewport based on geometry changes,
         // such as screen rotation
         GLES20.glViewport(0, 0, width, height);
-    }
-
-    public static int loadShader(int type, String shaderCode){
-
-        // create a vertex shader type (GLES20.GL_VERTEX_SHADER)
-        // or a fragment shader type (GLES20.GL_FRAGMENT_SHADER)
-        int shader = GLES20.glCreateShader(type);
-
-        // add the source code to the shader and compile it
-        GLES20.glShaderSource(shader, shaderCode);
-        GLES20.glCompileShader(shader);
-
-        return shader;
+        
+                // Create a new perspective projection matrix. The height will stay the same
+                // while the width will vary as per aspect ratio.
+                final float ratio = (float) width / height;
+                
+                mProjectionMatrix = new float[triangleVert.length][16];
+                for (int i = 0; i < triangleVert.length; i++)
+                        Matrix.frustumM(mProjectionMatrix[i], 0, -ratio*1.4f, ratio*1.4f, -1.4f, 1.4f, 1.4f, 14f);
+    }
+    
+    public void onDrawFrame(GL10 glUnused) 
+    {
+        // Draw background color
+        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
+        
+        mModelMatrix = new float[triangleVert.length][16];
+        // Draw the triangle facing straight on.
+        for (int i = 0; i < triangleVert.length; i++)
+                Matrix.setIdentityM(mModelMatrix[i], 0);
+                
+        mMVPMatrix = new float[triangleVert.length][16];
+        draw(triangleVert); 
+
+    }
+
+    private void draw(final FloatBuffer[] aTriangleBuffer)
+    {
+        for (int i = 0; i < aTriangleBuffer.length; i++)
+        {
+                // Pass in the position information
+                aTriangleBuffer[i].position(mPositionOffset);
+                GLES20.glVertexAttribPointer(mPositionHandle, mPositionDataSize, GLES20.GL_FLOAT, false,
+                                                             mStrideBytes, aTriangleBuffer[i]);
+                
+                GLES20.glEnableVertexAttribArray(mPositionHandle);
+             
+                
+                // Pass in the color information
+                aTriangleBuffer[i].position(mColorOffset);
+                GLES20.glVertexAttribPointer(mColorHandle, mColorDataSize, GLES20.GL_FLOAT, false,
+                                                                 mStrideBytes, aTriangleBuffer[i]);
+                
+                GLES20.glEnableVertexAttribArray(mColorHandle);
+                
+                Matrix.setRotateM(mModelMatrix[i], 0, mAngle, 0, 0, -1.0f);
+
+                        // This multiplies the view matrix by the model matrix, and stores the result in the MVP matrix
+                // (which currently contains model * view).
+                Matrix.multiplyMM(mMVPMatrix[i], 0, mViewMatrix[i], 0, mModelMatrix[i], 0);
+                
+                // This multiplies the modelview matrix by the projection matrix, and stores the result in the MVP matrix
+                // (which now contains model * view * projection).
+                Matrix.multiplyMM(mMVPMatrix[i], 0, mProjectionMatrix[i], 0, mMVPMatrix[i], 0);
+                
+                GLES20.glUniformMatrix4fv(mMatrixHandle, 1, false, mMVPMatrix[i], 0);
+                
+                // Draw the triangle
+                GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 3);
+                
+                // Disable vertex array
+                GLES20.glDisableVertexAttribArray(mPositionHandle);
+        }
     }
 
 }
-
-class Triangle 
-{
-
-    private final String vertexShaderCode =
-        "attribute vec4 vPosition;" +
-        "void main() {" +
-        "  gl_Position = vPosition;" +
-        "}";
-
-    private final String fragmentShaderCode =
-        "precision mediump float;" +
-        "uniform vec4 vColor;" +
-        "void main() {" +
-        "  gl_FragColor = vColor;" +
-        "}";
-
-    private final FloatBuffer vertexBuffer;
-    private final int mProgram;
-    private int mPositionHandle;
-    private int mColorHandle;
-
-    // number of coordinates per vertex in this array
-    static final int COORDS_PER_VERTEX = 3;
-    float triangleCoords[] ; /*){ // in counterclockwise order:
-         0.0f,  0.6f, 0.0f,   // top
-        -0.5f, -0.3f, 0.0f,   // bottom left
-         0.5f, -0.3f, 0.0f};  */ // bottom right
-         
-        /* -0.55f, -0.35f, 0.0f,
-         0.0f, -1.2f, 0.0f,
-         0.55f,  -0.35f, 0.0f
-    };*/
-    
-    private final int vertexCount = 9 / COORDS_PER_VERTEX;
-    private final int vertexStride = COORDS_PER_VERTEX * 4; // bytes per vertex
-
-    // Set color with red, green, blue and alpha (opacity) values
-    float color[];
-    //private final FloatBuffer colorBuffer;
-    private final int colorCount = 4/COORDS_PER_VERTEX;
-    
-    public Triangle() 
-    {
-        // initialize vertex byte buffer for shape coordinates
-        ByteBuffer bb = ByteBuffer.allocateDirect(
-                // (number of coordinate values * 4 bytes per float)
-                triangleCoords.length * 4);
-        // use the device hardware's native byte order
-        bb.order(ByteOrder.nativeOrder());
-
-        // create a floating point buffer from the ByteBuffer
-        vertexBuffer = bb.asFloatBuffer();
-        // add the coordinates to the FloatBuffer
-        vertexBuffer.put(triangleCoords);
-        // set the buffer to read the first coordinate
-        vertexBuffer.position(0);
-
-        /*ByteBuffer bb1 = ByteBuffer.allocateDirect(color.length*4);
-        bb1.order(ByteOrder.nativeOrder());
-        colorBuffer = bb1.asFloatBuffer();
-        colorBuffer.put(color);
-        colorBuffer.position(0);*/
-        
-        //GLES20.glEnableVertexAttribArray(1);
-        //GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, colorBuffer);
-        
-        // prepare shaders and OpenGL program
-        int vertexShader = MyGLRenderer.loadShader(GLES20.GL_VERTEX_SHADER,
-                                                   vertexShaderCode);
-        int fragmentShader = MyGLRenderer.loadShader(GLES20.GL_FRAGMENT_SHADER,
-                                                     fragmentShaderCode);
-
-        mProgram = GLES20.glCreateProgram();             // create empty OpenGL Program
-        GLES20.glAttachShader(mProgram, vertexShader);   // add the vertex shader to program
-        GLES20.glAttachShader(mProgram, fragmentShader); // add the fragment shader to program
-        GLES20.glLinkProgram(mProgram);                  // create OpenGL program executables
-    }
-    public Triangle(float x1, float y1, float z1,
-                            float x2, float y2, float z2,
-                            float x3, float y3, float z3,
-                            float c1, float c2, float c3, float c4) 
-    {
-        triangleCoords = new float[9];
-        color = new float[4];
-        triangleCoords[0] = x1;
-        triangleCoords[1] = y1;
-        triangleCoords[2] = z1;
-        triangleCoords[3] = x2;
-        triangleCoords[4] = y2;
-        triangleCoords[5] = z2;
-        triangleCoords[6] = x3;
-        triangleCoords[7] = y3;
-        triangleCoords[8] = z3;
-        color[0] = c1;
-        color[1] = c2;
-        color[2] = c3;
-        color[3] = c4;
-        // initialize vertex byte buffer for shape coordinates
-        ByteBuffer bb = ByteBuffer.allocateDirect(
-                // (number of coordinate values * 4 bytes per float)
-                triangleCoords.length * 4);
-        // use the device hardware's native byte order
-        bb.order(ByteOrder.nativeOrder());
-
-        // create a floating point buffer from the ByteBuffer
-        vertexBuffer = bb.asFloatBuffer();
-        // add the coordinates to the FloatBuffer
-        vertexBuffer.put(triangleCoords);
-        // set the buffer to read the first coordinate
-        vertexBuffer.position(0);
-
-        /*ByteBuffer bb1 = ByteBuffer.allocateDirect(color.length*4);
-        bb1.order(ByteOrder.nativeOrder());
-        colorBuffer = bb1.asFloatBuffer();
-        colorBuffer.put(color);
-        colorBuffer.position(0);*/
-           
-        // prepare shaders and OpenGL program
-        int vertexShader = MyGLRenderer.loadShader(GLES20.GL_VERTEX_SHADER,
-                                                   vertexShaderCode);
-        int fragmentShader = MyGLRenderer.loadShader(GLES20.GL_FRAGMENT_SHADER,
-                                                     fragmentShaderCode);
-
-        mProgram = GLES20.glCreateProgram();             // create empty OpenGL Program
-        GLES20.glAttachShader(mProgram, vertexShader);   // add the vertex shader to program
-        GLES20.glAttachShader(mProgram, fragmentShader); // add the fragment shader to program
-        GLES20.glLinkProgram(mProgram);                  // create OpenGL program executables
-    }
-
-    public void draw() 
-    {
-        // Add program to OpenGL environment
-        GLES20.glUseProgram(mProgram);
-
-        // get handle to vertex shader's vPosition member
-        mPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");
-
-        // Enable a handle to the triangle vertices
-        GLES20.glEnableVertexAttribArray(mPositionHandle);
-
-        // Prepare the triangle coordinate data
-        GLES20.glVertexAttribPointer(mPositionHandle, COORDS_PER_VERTEX,
-                                     GLES20.GL_FLOAT, false,
-                                     vertexStride, vertexBuffer);
-
-        // get handle to fragment shader's vColor member
-        mColorHandle = GLES20.glGetUniformLocation(mProgram, "vColor");
-
-        // Set color for drawing the triangle
-        //GLES20.glUniform4fv(mColorHandle, 0, color, 0);
-        //GLES20.glVertexAttrib4f(0, 0.5f, 0.5f, 0.0f, 1.0f);
-        //GLES20.glVertexAttribPointer(mPositionHandle, 4, GLES20.GL_FLOAT, false, stride, offset)
-        GLES20.glUniform4fv(mColorHandle, 1, color, 0);
-        // Draw the triangle
-        GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vertexCount);
-    }
-}

issm/trunk-jpl/src/android/ISSM_Visual/src/com/example/issm_visual/MyGLSurfaceView.java

@@ -3 +3 @@
 import android.content.Context;
 import android.opengl.GLSurfaceView;
+import android.view.MotionEvent;
 
 
-class MyGLSurfaceView extends GLSurfaceView {
-
-    public MyGLSurfaceView(Context context) {
+class MyGLSurfaceView extends GLSurfaceView 
+{
+        private MyGLRenderer mRend;
+    public MyGLSurfaceView(Context context) 
+    {
         super(context);
 
         // Create an OpenGL ES 2.0 context.
         setEGLContextClientVersion(2);
+        
+        final int NMAX_TRIANGLES = 2000;
+        final int MAX_VERTICES = 21;
+        
+        float f[][] = new float[NMAX_TRIANGLES][MAX_VERTICES];
+        int n, random;
+                for (int i = 0; i < f.length; i++)
+                {
+                        for (int j = 0; j < MAX_VERTICES; j++)
+                        {
+                                if (j == 6 || j == 13 || j == 20) continue;
+                                n = 1;
+                        random = (int)(Math.floor((Math.random()*10)+1));
+                        if (random <= 5) n = -1;
+                        
+                                f[i][j] = (float)(Math.random()*n);
+                        }
+                }
 
+        mRend = new MyGLRenderer(f);
+        
         // Set the Renderer for drawing on the GLSurfaceView
-        setRenderer(new MyGLRenderer());
+        setRenderer(mRend);
 
         // Render the view only when there is a change in the drawing data
         setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
     }
+    
+    private final float TOUCH_SCALE_FACTOR = 180.0f / 320;
+    private float mPreviousX;
+    
+    private float mPreviousY;
+    @Override
+    public boolean onTouchEvent(MotionEvent e) {
+        // MotionEvent reports input details from the touch screen
+        // and other input controls. In this case, you are only
+        // interested in events where the touch position changed.
+
+        float x = e.getX();
+        float y = e.getY();
+
+        switch (e.getAction()) {
+            case MotionEvent.ACTION_MOVE:
+
+                float dx = x - mPreviousX;
+                float dy = y - mPreviousY;
+
+                // reverse direction of rotation above the mid-line
+                if (y > getHeight() / 2) {
+                  dx = dx * -1 ;
+                }
+
+                // reverse direction of rotation to left of the mid-line
+                if (x < getWidth() / 2) {
+                  dy = dy * -1 ;
+                }
+
+                mRend.mAngle += (dx + dy) * TOUCH_SCALE_FACTOR;  // = 180.0f / 320
+                requestRender();
+        }
+
+        mPreviousX = x;
+        mPreviousY = y;
+        return true;
+    }
 }