/*
* 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();
}
}
}
|