src/com/replica/replicaisland/TextureLibrary.java - platform/external/replicaisland - Git at Google

 /*
  * Copyright (C) 2010 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.replica.replicaisland;

 import java.io.IOException;
 import java.io.InputStream;

 import javax.microedition.khronos.opengles.GL10;
 import javax.microedition.khronos.opengles.GL11;
 import javax.microedition.khronos.opengles.GL11Ext;

 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.opengl.GLU;
 import android.opengl.GLUtils;

 /**
  * The Texture Library manages all textures in the game.  Textures are pooled and handed out to
  * requesting parties via allocateTexture().  However, the texture data itself is not immediately
  * loaded at that time; it may have already been loaded or it may be loaded in the future via
  * a call to loadTexture() or loadAllTextures().  This allows Texture objects to be dispersed to
  * various game systems and while the texture data itself is streamed in or loaded as necessary.
  */
 public class TextureLibrary extends BaseObject {
     // Textures are stored in a simple hash.  This class implements its own array-based hash rather
     // than using HashMap for performance.
     Texture[] mTextureHash;
     int[] mTextureNameWorkspace;
     int[] mCropWorkspace;
     static final int DEFAULT_SIZE = 512;
     static BitmapFactory.Options sBitmapOptions  = new BitmapFactory.Options();

     public TextureLibrary() {
         super();
         mTextureHash = new Texture[DEFAULT_SIZE];
         for (int x = 0; x < mTextureHash.length; x++) {
             mTextureHash[x] = new Texture();
         }

         mTextureNameWorkspace = new int[1];
         mCropWorkspace = new int[4];

         sBitmapOptions.inPreferredConfig = Bitmap.Config.RGB_565;
     }

     @Override
     public void reset() {
         removeAll();
     }

     /**
      * Creates a Texture object that is mapped to the passed resource id.  If a texture has already
      * been allocated for this id, the previously allocated Texture object is returned.
      * @param resourceID
      * @return
      */
     public Texture allocateTexture(int resourceID) {
         Texture texture = getTextureByResource(resourceID);
         if (texture == null) {
             texture = addTexture(resourceID, -1, 0, 0);
         }

         return texture;
     }

     /** Loads a single texture into memory.  Does nothing if the texture is already loaded. */
     public Texture loadTexture(Context context, GL10 gl, int resourceID) {
         Texture texture = allocateTexture(resourceID);
         texture = loadBitmap(context, gl, texture);
         return texture;
     }

     /** Loads all unloaded textures into OpenGL memory.  Already-loaded textures are ignored. */
     public void loadAll(Context context, GL10 gl) {
         for (int x = 0; x < mTextureHash.length; x++) {
             if (mTextureHash[x].resource != -1 && mTextureHash[x].loaded == false) {
                 loadBitmap(context, gl, mTextureHash[x]);
             }
         }
     }

     /** Flushes all textures from OpenGL memory */
     public void deleteAll(GL10 gl) {
         for (int x = 0; x < mTextureHash.length; x++) {
             if (mTextureHash[x].resource != -1 && mTextureHash[x].loaded) {
             	assert mTextureHash[x].name != -1;
                 mTextureNameWorkspace[0] = mTextureHash[x].name;
                 mTextureHash[x].name = -1;
                 mTextureHash[x].loaded = false;
                 gl.glDeleteTextures(1, mTextureNameWorkspace, 0);
                 int error = gl.glGetError();
                 if (error != GL10.GL_NO_ERROR) {
                     DebugLog.d("Texture Delete", "GLError: " + error + " (" + GLU.gluErrorString(error) + "): " + mTextureHash[x].resource);
                 }

                 assert error == GL10.GL_NO_ERROR;
             }
         }
     }

     /** Marks all textures as unloaded */
     public void invalidateAll() {
         for (int x = 0; x < mTextureHash.length; x++) {
             if (mTextureHash[x].resource != -1 && mTextureHash[x].loaded) {
                 mTextureHash[x].name = -1;
                 mTextureHash[x].loaded = false;
             }
         }
     }

     /** Loads a bitmap into OpenGL and sets up the common parameters for 2D texture maps. */
     protected Texture loadBitmap(Context context, GL10 gl, Texture texture) {
         assert gl != null;
         assert context != null;
         assert texture != null;
         if (texture.loaded == false && texture.resource != -1) {
             gl.glGenTextures(1, mTextureNameWorkspace, 0);

             int error = gl.glGetError();
             if (error != GL10.GL_NO_ERROR) {
                 DebugLog.d("Texture Load 1", "GLError: " + error + " (" + GLU.gluErrorString(error) + "): " + texture.resource);
             }

             assert error == GL10.GL_NO_ERROR;

             int textureName = mTextureNameWorkspace[0];

             gl.glBindTexture(GL10.GL_TEXTURE_2D, textureName);

             error = gl.glGetError();
             if (error != GL10.GL_NO_ERROR) {
                 DebugLog.d("Texture Load 2", "GLError: " + error + " (" + GLU.gluErrorString(error) + "): " + texture.resource);
             }

             assert error == GL10.GL_NO_ERROR;

             gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_NEAREST);
             gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);

             gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S, GL10.GL_CLAMP_TO_EDGE);
             gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T, GL10.GL_CLAMP_TO_EDGE);

             gl.glTexEnvf(GL10.GL_TEXTURE_ENV, GL10.GL_TEXTURE_ENV_MODE, GL10.GL_MODULATE); //GL10.GL_REPLACE);

             InputStream is = context.getResources().openRawResource(texture.resource);
             Bitmap bitmap;
             try {
                 bitmap = BitmapFactory.decodeStream(is);
             } finally {
                 try {
                     is.close();
                 } catch (IOException e) {
                 	e.printStackTrace();
                     // Ignore.
                 }
             }

             GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap, 0);

             error = gl.glGetError();
             if (error != GL10.GL_NO_ERROR) {
                 DebugLog.d("Texture Load 3", "GLError: " + error + " (" + GLU.gluErrorString(error) + "): " + texture.resource);
             }

             assert error == GL10.GL_NO_ERROR;

             mCropWorkspace[0] = 0;
             mCropWorkspace[1] = bitmap.getHeight();
             mCropWorkspace[2] = bitmap.getWidth();
             mCropWorkspace[3] = -bitmap.getHeight();

             ((GL11) gl).glTexParameteriv(GL10.GL_TEXTURE_2D, GL11Ext.GL_TEXTURE_CROP_RECT_OES,
                             mCropWorkspace, 0);

             texture.name = textureName;
             texture.width = bitmap.getWidth();
             texture.height = bitmap.getHeight();

             bitmap.recycle();

             error = gl.glGetError();
             if (error != GL10.GL_NO_ERROR) {
                 DebugLog.d("Texture Load 4", "GLError: " + error + " (" + GLU.gluErrorString(error) + "): " + texture.resource);
             }

             assert error == GL10.GL_NO_ERROR;

             texture.loaded = true;

         }

         return texture;
     }

     public boolean isTextureLoaded(int resourceID) {
         return getTextureByResource(resourceID) != null;
     }

     /**
      * Returns the texture associated with the passed Android resource ID.
      * @param resourceID The resource ID of a bitmap defined in R.java.
      * @return An associated Texture object, or null if there is no associated
      *  texture in the library.
      */
     public Texture getTextureByResource(int resourceID) {
         int index = getHashIndex(resourceID);
         int realIndex = findFirstKey(index, resourceID);
         Texture texture = null;
         if (realIndex != -1) {
             texture = mTextureHash[realIndex];
         }
         return texture;
     }

     private int getHashIndex(int id) {
         return id % mTextureHash.length;
     }

     /**
      * Locates the texture in the hash.  This hash uses a simple linear probe chaining mechanism:
      * if the hash slot is occupied by some other entry, the next empty array index is used.
      * This is O(n) for the worst case (every slot is a cache miss) but the average case is
      * constant time.
      * @param startIndex
      * @param key
      * @return
      */
     private int findFirstKey(int startIndex, int key) {
         int index = -1;
         for (int x = 0; x < mTextureHash.length; x++) {
             final int actualIndex = (startIndex + x) % mTextureHash.length;
             if (mTextureHash[actualIndex].resource == key) {
                 index = actualIndex;
                 break;
             } else if (mTextureHash[actualIndex].resource == -1) {
                 break;
             }
         }
         return index;
     }

     /** Inserts a texture into the hash */
     protected Texture addTexture(int id, int name, int width, int height) {
         int index = findFirstKey(getHashIndex(id), -1);
         Texture texture = null;
         assert index != -1;

         if (index != -1) {
             mTextureHash[index].resource = id;
             mTextureHash[index].name = name;
             mTextureHash[index].width = width;
             mTextureHash[index].height = height;
             texture = mTextureHash[index];
         }

         return texture;
     }

     public void removeAll() {
         for (int x = 0; x < mTextureHash.length; x++) {
             mTextureHash[x].reset();
         }
     }

 }
	/*
	* Copyright (C) 2010 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.replica.replicaisland;

	import java.io.IOException;
	import java.io.InputStream;

	import javax.microedition.khronos.opengles.GL10;
	import javax.microedition.khronos.opengles.GL11;
	import javax.microedition.khronos.opengles.GL11Ext;

	import android.content.Context;
	import android.graphics.Bitmap;
	import android.graphics.BitmapFactory;
	import android.opengl.GLU;
	import android.opengl.GLUtils;

	/**
	* The Texture Library manages all textures in the game. Textures are pooled and handed out to
	* requesting parties via allocateTexture(). However, the texture data itself is not immediately
	* loaded at that time; it may have already been loaded or it may be loaded in the future via
	* a call to loadTexture() or loadAllTextures(). This allows Texture objects to be dispersed to
	* various game systems and while the texture data itself is streamed in or loaded as necessary.
	*/
	public class TextureLibrary extends BaseObject {
	// Textures are stored in a simple hash. This class implements its own array-based hash rather
	// than using HashMap for performance.
	Texture[] mTextureHash;
	int[] mTextureNameWorkspace;
	int[] mCropWorkspace;
	static final int DEFAULT_SIZE = 512;
	static BitmapFactory.Options sBitmapOptions = new BitmapFactory.Options();

	public TextureLibrary() {
	super();
	mTextureHash = new Texture[DEFAULT_SIZE];
	for (int x = 0; x < mTextureHash.length; x++) {
	mTextureHash[x] = new Texture();
	}

	mTextureNameWorkspace = new int[1];
	mCropWorkspace = new int[4];

	sBitmapOptions.inPreferredConfig = Bitmap.Config.RGB_565;
	}

	@Override
	public void reset() {
	removeAll();
	}

	/**
	* Creates a Texture object that is mapped to the passed resource id. If a texture has already
	* been allocated for this id, the previously allocated Texture object is returned.
	* @param resourceID
	* @return
	*/
	public Texture allocateTexture(int resourceID) {
	Texture texture = getTextureByResource(resourceID);
	if (texture == null) {
	texture = addTexture(resourceID, -1, 0, 0);
	}

	return texture;
	}

	/** Loads a single texture into memory. Does nothing if the texture is already loaded. */
	public Texture loadTexture(Context context, GL10 gl, int resourceID) {
	Texture texture = allocateTexture(resourceID);
	texture = loadBitmap(context, gl, texture);
	return texture;
	}

	/** Loads all unloaded textures into OpenGL memory. Already-loaded textures are ignored. */
	public void loadAll(Context context, GL10 gl) {
	for (int x = 0; x < mTextureHash.length; x++) {
	if (mTextureHash[x].resource != -1 && mTextureHash[x].loaded == false) {
	loadBitmap(context, gl, mTextureHash[x]);
	}
	}
	}

	/** Flushes all textures from OpenGL memory */
	public void deleteAll(GL10 gl) {
	for (int x = 0; x < mTextureHash.length; x++) {
	if (mTextureHash[x].resource != -1 && mTextureHash[x].loaded) {
	assert mTextureHash[x].name != -1;
	mTextureNameWorkspace[0] = mTextureHash[x].name;
	mTextureHash[x].name = -1;
	mTextureHash[x].loaded = false;
	gl.glDeleteTextures(1, mTextureNameWorkspace, 0);
	int error = gl.glGetError();
	if (error != GL10.GL_NO_ERROR) {
	DebugLog.d("Texture Delete", "GLError: " + error + " (" + GLU.gluErrorString(error) + "): " + mTextureHash[x].resource);
	}

	assert error == GL10.GL_NO_ERROR;
	}
	}
	}

	/** Marks all textures as unloaded */
	public void invalidateAll() {
	for (int x = 0; x < mTextureHash.length; x++) {
	if (mTextureHash[x].resource != -1 && mTextureHash[x].loaded) {
	mTextureHash[x].name = -1;
	mTextureHash[x].loaded = false;
	}
	}
	}

	/** Loads a bitmap into OpenGL and sets up the common parameters for 2D texture maps. */
	protected Texture loadBitmap(Context context, GL10 gl, Texture texture) {
	assert gl != null;
	assert context != null;
	assert texture != null;
	if (texture.loaded == false && texture.resource != -1) {
	gl.glGenTextures(1, mTextureNameWorkspace, 0);

	int error = gl.glGetError();
	if (error != GL10.GL_NO_ERROR) {
	DebugLog.d("Texture Load 1", "GLError: " + error + " (" + GLU.gluErrorString(error) + "): " + texture.resource);
	}

	assert error == GL10.GL_NO_ERROR;

	int textureName = mTextureNameWorkspace[0];

	gl.glBindTexture(GL10.GL_TEXTURE_2D, textureName);

	error = gl.glGetError();
	if (error != GL10.GL_NO_ERROR) {
	DebugLog.d("Texture Load 2", "GLError: " + error + " (" + GLU.gluErrorString(error) + "): " + texture.resource);
	}

	assert error == GL10.GL_NO_ERROR;

	gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_NEAREST);
	gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);

	gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S, GL10.GL_CLAMP_TO_EDGE);
	gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T, GL10.GL_CLAMP_TO_EDGE);

	gl.glTexEnvf(GL10.GL_TEXTURE_ENV, GL10.GL_TEXTURE_ENV_MODE, GL10.GL_MODULATE); //GL10.GL_REPLACE);

	InputStream is = context.getResources().openRawResource(texture.resource);
	Bitmap bitmap;
	try {
	bitmap = BitmapFactory.decodeStream(is);
	} finally {
	try {
	is.close();
	} catch (IOException e) {
	e.printStackTrace();
	// Ignore.
	}
	}

	GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap, 0);

	error = gl.glGetError();
	if (error != GL10.GL_NO_ERROR) {
	DebugLog.d("Texture Load 3", "GLError: " + error + " (" + GLU.gluErrorString(error) + "): " + texture.resource);
	}

	assert error == GL10.GL_NO_ERROR;

	mCropWorkspace[0] = 0;
	mCropWorkspace[1] = bitmap.getHeight();
	mCropWorkspace[2] = bitmap.getWidth();
	mCropWorkspace[3] = -bitmap.getHeight();

	((GL11) gl).glTexParameteriv(GL10.GL_TEXTURE_2D, GL11Ext.GL_TEXTURE_CROP_RECT_OES,
	mCropWorkspace, 0);

	texture.name = textureName;
	texture.width = bitmap.getWidth();
	texture.height = bitmap.getHeight();

	bitmap.recycle();

	error = gl.glGetError();
	if (error != GL10.GL_NO_ERROR) {
	DebugLog.d("Texture Load 4", "GLError: " + error + " (" + GLU.gluErrorString(error) + "): " + texture.resource);
	}

	assert error == GL10.GL_NO_ERROR;

	texture.loaded = true;

	}

	return texture;
	}

	public boolean isTextureLoaded(int resourceID) {
	return getTextureByResource(resourceID) != null;
	}

	/**
	* Returns the texture associated with the passed Android resource ID.
	* @param resourceID The resource ID of a bitmap defined in R.java.
	* @return An associated Texture object, or null if there is no associated
	* texture in the library.
	*/
	public Texture getTextureByResource(int resourceID) {
	int index = getHashIndex(resourceID);
	int realIndex = findFirstKey(index, resourceID);
	Texture texture = null;
	if (realIndex != -1) {
	texture = mTextureHash[realIndex];
	}
	return texture;
	}

	private int getHashIndex(int id) {
	return id % mTextureHash.length;
	}

	/**
	* Locates the texture in the hash. This hash uses a simple linear probe chaining mechanism:
	* if the hash slot is occupied by some other entry, the next empty array index is used.
	* This is O(n) for the worst case (every slot is a cache miss) but the average case is
	* constant time.
	* @param startIndex
	* @param key
	* @return
	*/
	private int findFirstKey(int startIndex, int key) {
	int index = -1;
	for (int x = 0; x < mTextureHash.length; x++) {
	final int actualIndex = (startIndex + x) % mTextureHash.length;
	if (mTextureHash[actualIndex].resource == key) {
	index = actualIndex;
	break;
	} else if (mTextureHash[actualIndex].resource == -1) {
	break;
	}
	}
	return index;
	}

	/** Inserts a texture into the hash */
	protected Texture addTexture(int id, int name, int width, int height) {
	int index = findFirstKey(getHashIndex(id), -1);
	Texture texture = null;
	assert index != -1;

	if (index != -1) {
	mTextureHash[index].resource = id;
	mTextureHash[index].name = name;
	mTextureHash[index].width = width;
	mTextureHash[index].height = height;
	texture = mTextureHash[index];
	}

	return texture;
	}

	public void removeAll() {
	for (int x = 0; x < mTextureHash.length; x++) {
	mTextureHash[x].reset();
	}
	}

	}