Texture compression support added

Changes
-------------
### TextureInfo class ###
Several fields and their getters and setters have been added to support extra information needed when using compressed textures:
```java
protected CompressionType mCompressionType;
protected int mInternalFormat;
protected ByteBuffer mBuffer;
```

### TextureManager class ###
Several enumerations added in `TextureManager`:

* `CompressionType` : Determines the type of compression to use.
  * `NONE` : Use uncompressed bitmaps
  * `ETC1` : Use Ericsson texture compression
  * `ATC` : Use AMD texture compression
  * `PVRTC` : Use PowerVR texture compression
  * __ADDED: Jan 15, 2013__ `DXT1` : Use S3 DXT1 texture compression
  * __ADDED: Jan 15, 2013__ `THREEDC` : Use ATI 3Dc texture compression
* __EDIT: Jan 15, 2013__ ~~PaletteConfig~~ : ~~Currently unused but will be used for [paletted texture compression](http://developer.android.com/guide/topics/manifest/supports-gl-texture-element.html)~~ Renamed to `PaletteFormat` for consistency in naming
  * See [OpenGL ES extension specification](http://www.opengl.org/registry/specs/OES/OES_compressed_paletted_texture.txt) for possible formats
* `AtcFormat` : Determine the alpha transparency format in AMD texture compression scheme
  * `RGB` : No alpha transparency
  * `RGBA_EXPLICIT` : Explicit alpha transparency - most people will use this type
  * `RGBA_INTERPOLATED` : Interpolated alpha transparency
* `PvrtcFormat` : Determine whether alpha transparency will be used and whether to use 2 bytes per pixel or 4 bytes per pixel
  * `RGB_2BPP` : 2 bytes per pixel with no alpha channel
  * `RGB_4BPP` : 4 bytes per pixel with no alpha channel
  * `RGBA_2BPP` : 2 bytes per pixel with alpha channel
  * `RGBA_4BPP` : 4 bytes per pixel with alpha channel
* __ADDED: Jan 15, 2013__ `Dxt1Format` : Determine whether alpha transparency will be used
  * `RGB` : w/o alpha
  * `RGBA` : w/ alpha
* __ADDED: Jan 15, 2013__ `ThreeDcFormat` : Determine whether X or XY format will be used

Underlying `addTexture` method has been modified in `TextureManager` class to add support for compressed textures. Two arguments, `compressionType` and `compressionFormat` have been added. The method without the two arguments is still available for backwards compatibility. Omitting the compression arguments just adds uncompressed texture.

When `compressionType` is specified to anything other than `NONE`, __automatic mipmap generation is disabled__. This is due to limitations in OpenGL ES 2.0 itself. [Lance Armstrong loses a testicle every time you automatically generate a mipmap from compressed textures](http://stackoverflow.com/questions/12646796/loading-compressed-texture-etc1-in-android).

```java
public TextureInfo addTexture(ByteBuffer buffer, Bitmap texture, int width, int height, TextureType textureType, Config bitmapConfig, boolean mipmap, boolean recycle, boolean isExistingTexture, WrapType wrapType, FilterType filterType, CompressionType compressionType, int compressionFormat) {
    ...
        if(mipmap && compressionType == CompressionType.NONE){
            if(filterType==FilterType.LINEAR)
                GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR_MIPMAP_LINEAR);
            else
                GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST_MIPMAP_NEAREST);				
        } else {
            if(filterType==FilterType.LINEAR)
                GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);
            else
                GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST);
        }
    ...
    if(mipmap && compressionType == CompressionType.NONE)
        GLES20.glGenerateMipmap(GLES20.GL_TEXTURE_2D);
    ...
}
```

Several methods have been added each respective to compression types:
* ```addEtc1Texture``` : Shortcut methods for adding ETC1 textures
* ```addAtcTexture``` : Shortcut methods for adding ATC textures
* ```addPvrtcTexture``` : Shortcut methods for adding PowerVR textures
* __EDIT: Jan 15, 2013__ ```addDxt1Texture``` : Shortcut methods for adding S3 DXT1 textures
* __EDIT: Jan 15, 2013__ ```addPalettedTexture``` : Shortcut methods for adding paletted textures
* __EDIT: Jan 15, 2013__ ```add3dcTexture``` : Shortcut methods for adding 3Dc textures

To Do
---------
While ETC1 support is complete and can be used right away, there are still few more things to accomplish:
* ~~Add support for remaining texture compression methods listed [here](http://developer.android.com/guide/topics/manifest/supports-gl-texture-element.html).~~
All texture compression support has now been added!
* Add utility classes for compression schemes other than ETC1 similar to `android.opengl.ETC1Util` to help load ATC and PowerVR textures more easily.

Example
-------------
### Example 1
##### Loading ETC1 Compressed PKM Texture
Addressing issue #254, the following example demonstrates loading a PKM texture with graceful fallback to PNG images.

First, generate a PKM texture from any image sources. [Mali Texture Compression Tool](http://malideveloper.arm.com/develop-for-mali/mali-gpu-texture-compression-tool/) by ARM is an excellent tool to compress images to ETC1 based PKM/KTX files as well as one of the easiest tools to use.

Then, add the texture file in the `res/raw` folder and your uncompressed image file in `res/drawable-nodpi` folder. The latter bitmap is used as a graceful fallback in case the compressed texture fails to load for any reason.

The example below assumes you have a file name compressedimage.pkm in your `res/raw` folder and the uncompressedimage.png in your `res/drawables-nodpi` folder.

```java
public class Renderer extends RajawaliRenderer {
    protected Plane mPlane;

    public Renderer(Context context) {
        super(context);
        setCamera(new Camera2D());
        setFramerate(60);
    }

    @Override
    public void initScene() {
        mPlane = new Plane();
        TextureInfo texture = mTextureManager.addEtc1Texture(mContext.getResources().openRawResource(R.raw.compressedimage), BitmapFactory.decodeResource(mContext.getResources(), R.drawable.uncompressedimage));
        mPlane.setMaterial(new SimpleMaterial());
        mPlane.addTexture(texture);
        addChild(mPlane);
    }
}
```

Using ETC1 texture gives you performance boost for free. You should see at least around 10-15 fps by using ETC1 texture over PNG. Maximum compression ratio is around 6 to 1. An uncompressed 2048x1024 bitmap takes up 6 MB in graphics memory whereas ETC1 compresses this down to 1 MB. This frees up memory bandwidth and improves fillrate. BAM! Free lunch (well almost... it comes at the cost of image quality).

### Example 2
##### Dynamically Compress and Load Uncompressed Image Bitmap as ETC1 Texture
__NEW: Jan 16, 2013__ I committed a new change in TextureManager that allows you to add a bitmap as an ETC1 texture. The method dynamically encodes the bitmap into ETC1 format. 

This means you don't have to use external tools to compress ETC1 textures anymore. It could also cut down on the size of your APK package since you only have to include just the bitmap images (PNG, JPEG, etc) instead of adding in PKG/KTX files as well. __This all comes at a cost though!__

__WARNING :__ While you may be able to cut down on size of your distribution and conveniently use existing images without using external texture compression tools, it will significantly increase the load time of your textures! Only use this method for small textures and use it sparingly. In fact, it's probably best to use this method for dynamically compressing texture atlases where you only need to compress the texture atlas once.

Without further ado, here's an example.
```java
public class Renderer extends RajawaliRenderer {
    protected Plane mPlane;

    public Renderer(Context context) {
        super(context);
        setCamera(new Camera2D());
        setFramerate(60);
    }

    @Override
    public void initScene() {
        mPlane = new Plane();
        TextureInfo texture = mTextureManager.addEtc1Texture(BitmapFactory.decodeResource(mContext.getResources(), R.drawable.uncompressedimage), TextureType.DIFFUSE);
        mPlane.setMaterial(new SimpleMaterial());
        mPlane.addTexture(texture);
        addChild(mPlane);
    }
}
```

Encoding a 2048x1024 texture using ETC1 fast compression method still takes several seconds on a desktop PC. You'll be doing this compression on-the-fly on a _mobile_ processor. Use it wisely.

**Resources**
* Excellent blog post about why you should say yes to texture compression: 
http://androidworks-kea.blogspot.kr/2012/05/developers-notes-about-opengl-es.html
* Intel article on different texture compression schemes on Android:
http://software.intel.com/en-us/articles/android-texture-compression
* Where to find constant values for some of the OpenGL ES 2.0 extensions:
http://www.khronos.org/registry/gles/api/2.0/gl2ext.h

Questions regarding design decisions I mentioned at #310 is no longer an issue. =) 

-- Andrew