Where We Were

Last Monday, we described the basics of how to set up OpenGL ES on Android using a subclass of SurfaceView which we manually added as the content view of our Activity.
We had this SurfaceView implement SurfaceHolder.Callback to handle creation, destruction, and changes to our surface.
surfaceCreated() was used to create and start a subclass of Thread in which we did our drawing. surfaceDestroyed() was used to stop this thread.
The requestExitAndWait method of our thread subclass was used to make sure everything with regard to the thread was properly disposed of before rejoining the surfaceDestroyed method of our View.
The run() method of our thread initializes the display and the context for OpenGL drawing, it then creates a GL10 object, calls init(), and has a while(!done) loop in which a the drawFrame() method is repeatedly called.
When "done" becomes true, run() makes sure our display and context are shut down.
init() sets up the viewport and the perspective which says how 3D objects in our scene will be projected onto the 2D display.
drawFrame() switches the matrix mode into MODEL_VIEW which is used to manipulate the 3D scene before projection is done (so the stack of matrices used to render points in the scene applies the model's matrices followed by the matrices given in init).
We then rendered into our 3D scene triangles strips representing a cube.

Defining Lighting and Cube Material

The next thing we are going to do is look at how to specify light sources which light our 3D Scene.
3D Graphics libraries typically support three kinds of lighting:
- Ambient -- a general glow that a light contributes to the entire scene. A little ambient light allows one to pick out details which may be in shadowed objects.
- Diffuse -- Soft directional lighting, as you might get from a fluorescent panel. The intensity depends on where the light source is, but light bouncing off it bounces in random directions.
- Specular -- Like diffuse lighting, this kind of lighting is directional, but it also has the additional property that the reflections are direction. This kind of lighting can be used to created shiny highlights on an object.

We will construct our scene with ambient and diffuse lighting by modifying our thread init() method as follow:

float lightAmbient[] = new float[]{ 0.2f, 0.2f, 0.2f, 1};
float lightDiffuse[] = new float[]{ 1, 1, 1, 1};
float[] lightPos = new float[] {1, 1, 1, 1};
		
gl.glEnable(GL10.GL_LIGHTING);
gl.glEnable(GL10.GL_LIGHT0);
		
gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_AMBIENT, lightAmbient, 0);
gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_DIFFUSE, lightDiffuse, 0);
gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_POSITION, lightPos, 0);

Next we specify what the material the cube is made out of. i.e., How it responds to lighting of the given kind for each of the x, y, z directions:

float matAmbient[] = new float[]{1, 1, 1, 1};
float matDiffuse[] = new float[]{1, 1, 1, 1};
		
gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_AMBIENT, matAmbient, 0);
gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_DIFFUSE, matDiffuse, 0);

Screenshot After Lighting

Screenshot showing how lighting effect the way our cube looked

Making the Cube Rotate

Next we animate our cube by applying a rotation based on the number of milli-seconds since our Activity started.
To do this we create a new field in our thread:
```
private long startTime;
```

We then modify init() so it has:

   startTime = System.currentTimeMillis();

Finally, we modify drawFrame() to include the lines:

long elapsed = System.currentTimeMillis() - startTime;
gl.glRotatef(elapsed*(30f/1000f), 0, 1, 0);
gl.glRotatef(elapsed*(15f/1000f), 1, 0, 0);

Screenshot During Rotation

Screenshot showing the cube mid-rotation

Applying Texture

Next we look at applying a 2D texture to each of the faces of the cube.
We could use this to display text in a scene by coming up with png files containing the letters and projecting these on triangle strips representing squares in our scene.
We first add a field to our GLCube:
```
private final IntBuffer mTextureBuffer;
```
used to store our texture info.

Next we add to the constructor of GLCube:

int texCoords[] = {
//Front
0, one, one, one, 0, 0, one, 0,
//Back
one, one, one, 0, 0, one, 0, 0,
//Left
one, one, one, 0, 0, one, 0, 0,
//Right
one, one, one, 0, 0, one, 0, 0,
//Top
one, 0, 0, 0, one, one, 0, one,
//Bottom	
0, 0, 0, one, one, 0, one, one				
};
		
ByteBuffer tbb = ByteBuffer.allocateDirect(texCoords.length * 4);
tbb.order(ByteOrder.nativeOrder());
mTextureBuffer = tbb.asIntBuffer();
mTextureBuffer.put(texCoords);
mTextureBuffer.position(0);

Texture Mapping Continued

We next add three static methods, one to load the texture, one to extract the texture from a Bitmap source, one to load our ByteBuffer:

static void loadTexture(GL10 gl, Context context, int resource)
{
   Bitmap bmp = BitmapFactory.decodeResource(
      context.getResources(), resource);
		
   ByteBuffer bb = extract(bmp);
		
   load(gl, bb, bmp.getWidth(), bmp.getHeight());
}
	
static ByteBuffer extract(Bitmap bmp)
{
   ByteBuffer bb = ByteBuffer.allocateDirect(bmp.getHeight() * bmp.getWidth() * 4);
   bb.order(ByteOrder.BIG_ENDIAN);
   IntBuffer ib = bb.asIntBuffer();
	   
   // Convert ARGB ->RGBA
	   
   for(int y = bmp.getHeight() - 1; y > -1; y--)
   {
      for(int x =0; x < bmp.getWidth(); x++)
      {
         int pix = bmp.getPixel(x, bmp.getHeight() -y - 1);
         int alpha = ((pix >>24) & 0xFF);
         int red = ((pix >> 16) & 0xFF);
         int green = ((pix >> 8) & 0xFF);
         int blue = ((pix) & 0xFF);
		  
         ib.put(red << 24 | green << 16 | blue << 8 | alpha);
         } 
   }
   bb.position(0);
   return bb;
}
	
static void load(GL10 gl, ByteBuffer bb, int width, int height)
{
   int[] tmp_tex = new int[1];
   gl.glGenTextures(1, tmp_tex, 0);
   int tex = tmp_tex[0];
		
   //Load it up
   gl.glBindTexture(GL10.GL_TEXTURE_2D, tex);
   gl.glTexImage2D(GL10.GL_TEXTURE_2D, 0, GL10.GL_RGBA, 
      width, height, 0, GL10.GL_RGBA, GL10.GL_UNSIGNED_BYTE, bb);
   gl.glTexParameterx(GL10.GL_TEXTURE_2D, 
      GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_LINEAR);
   gl.glTexParameterx(GL10.GL_TEXTURE_2D, 
      GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
}

Finishing Texture Map

Finally, we add the following line to GLCube.java's draw method

   gl.glTexCoordPointer(2, GL10.GL_FIXED, 0, mTextureBuffer);

And we specify the png file to use in our threads init() method:

gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
gl.glEnable(GL10.GL_TEXTURE_2D);
		
GLCube.loadTexture(gl, view.getContext(), R.drawable.myphoto);

Screenshot With Texture Map

Screenshot showing the cube with my face as a texture

Using OpenGL and other UI Controls

We next demonstrate that it is completely fine to use OpenGL with other UI controls. For instance, we could do the following in our onCreate method:

public void onCreate(Bundle savedInstanceState) 
{
    super.onCreate(savedInstanceState);
    LinearLayout ll= new LinearLayout(this);
    ll.setOrientation(LinearLayout.VERTICAL);
    Button button = new Button(this);
    button.setText("hello");
    

    AlertDialog.Builder builder = new AlertDialog.Builder(this);
    builder.setMessage("Here is an alert")
          .setCancelable(true);

    alertDialog = builder.create();
    alertDialog.setButton("OK", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int which) {
          return;
     } });
    
    button.setOnClickListener(new OnClickListener() {
        public void onClick(View v) {
                alertDialog.show();
    }
    });
    ll.addView(button); 
    GLView glview = new GLView(this);
    ll.addView(glview);
    setContentView(ll);
}

GPS

For the homework you need to test GPS, you can actually test GPS in the emulator
To do this you need to make sure the AVD you made has GPS enabled.
When you create an AVD you can add hardware properties and one of these is the GPS support (another is accelerometer support)
To make a project using location services you have to edit your manifest file to say you need these permissions:
```
<uses-permission 
        android:name="android.permission.ACCESS_FINE_LOCATION" />
```
To send the emulator coordinate you can telnet into the port number of your emulator
```
telnet localhost 5554
```
You can then send longitude and latitude information with commands like:
```
geo fix -10.5 23.4
```

LocationManager

The LocationManager can be used to get the location service.
Assuming your Activity has a LocationManager field locationManager, you could get the location service in your onCreate method with a line like:
```
locationManager = (LocationManager) getSystemService(LOCATION_SERVICE);
```

Typically, one would want to set up that who should receive location updates (whoever does must implement LocationListener) in the onResume method of Activity (called after onStart) and cancel these update requests in onPause. Code to do this might look like:

protected void onResume() 
{
    /*
     * Add LocationListener and request updates every 1000ms or 10m
     * Notice in this case we are saying this Activity implements LocationListener
     */
    locationManager.requestLocationUpdates(
        LocationManager.GPS_PROVIDER, 1000, 10f, this);
    super.onResume();
}
protected void onPause() 
{
    locationManager.removeUpdates(this);
    super.onPause();
}

LocationListener

As a last step to using GPS, we need to implement LocationListener (which we are having our Activity do).
This involves implementing the methods: onLocationChanged, onProviderDisabled, onProviderEnabled, and onStatusChanged.

For example, one could do:

public void onProviderDisabled(String provider) 
{
    Log.v("GPS", "Disabled");

    Intent intent = new Intent(
        android.provider.Settings.ACTION_LOCATION_SOURCE_SETTINGS);
    startActivity(intent);

}

public void onProviderEnabled(String provider) 
{
    Log.v("GPS", "Enabled");	
}

public void onStatusChanged(String provider, int status, Bundle extras) 
{
    switch (status) 
    {
        case LocationProvider.OUT_OF_SERVICE:
            Log.v("GPS", "Status Changed: Out of Service");
        break;
        
        case LocationProvider.TEMPORARILY_UNAVAILABLE:
            Log.v("GPS", "Status Changed: Temporarily Unavailable");
        break;
        case LocationProvider.AVAILABLE:
            Log.v("GPS", "Status Changed: Available");
        break;
    }

}

In onLocation one gets as parameter a Location object which has getLongitude and getLatitude methods.

More OpenGL

Outline