Where We Were

Last Wednesday, 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 before projection is done (so the stack of matrices used to render points in the scene is apply 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

Quiz

Which of the following statements is true:

To make an animation in Android you can set an animation-list as the background resource on an ImageView object of the main layout.
OpenGL ES is a Java-only implementation of OpenGL for embedded systems.
Setting the viewport in which a scene is displayed in not associated with setting the OpenGL matrix mode to GL_PROJECTION.

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);

OpenGL

Outline