Java 类android.opengl.GLES10 实例源码

@Override
            protected void loadOnCreate() {
//                GL_RENDERER = glGetString(GLES10.GL_RENDERER);
//                GL_VERSION = glGetString(GLES10.GL_VERSION);
//                GL_VENDOR = glGetString(GLES10.GL_VENDOR);
                GL_MAX_TEXTURE_SIZE = glGetIntegerv(GLES10.GL_MAX_TEXTURE_SIZE);
//                GL_MAX_TEXTURE_UNITS = glGetIntegerv(GLES10.GL_MAX_TEXTURE_UNITS);
//                GL_MAX_LIGHTS = glGetIntegerv(GLES10.GL_MAX_LIGHTS);
//                GL_SUBPIXEL_BITS = glGetIntegerv(GLES10.GL_SUBPIXEL_BITS);
//                GL_MAX_ELEMENTS_VERTICES = glGetIntegerv(GLES10.GL_MAX_ELEMENTS_VERTICES);
//                GL_MAX_ELEMENTS_INDICES = glGetIntegerv(GLES10.GL_MAX_ELEMENTS_INDICES);
//                GL_MAX_MODELVIEW_STACK_DEPTH = glGetIntegerv(GLES10.GL_MAX_MODELVIEW_STACK_DEPTH);
//                GL_MAX_PROJECTION_STACK_DEPTH = glGetIntegerv(GLES10.GL_MAX_PROJECTION_STACK_DEPTH);
//                GL_MAX_TEXTURE_STACK_DEPTH = glGetIntegerv(GLES10.GL_MAX_TEXTURE_STACK_DEPTH);
//                GL_DEPTH_BITS = glGetIntegerv(GLES10.GL_DEPTH_BITS);
//                GL_STENCIL_BITS = glGetIntegerv(GLES10.GL_STENCIL_BITS);
                GL_EXTENSIONS = glGetString(GLES10.GL_EXTENSIONS);
//                GL_MAX_VIEWPORT_DIMS = glGetIntegerv(GLES10.GL_MAX_VIEWPORT_DIMS, 2);
            }

private static void addExtensionsForConfig(EGL10 egl10, EGLDisplay egldisplay, EGLConfig eglconfig, int ai[], int ai1[], Set<String> set) {
    EGLContext eglContext = egl10.eglCreateContext(egldisplay, eglconfig, EGL10.EGL_NO_CONTEXT, ai1);
    if (eglContext == EGL10.EGL_NO_CONTEXT) {
        return;
    }
    javax.microedition.khronos.egl.EGLSurface eglSurface = egl10.eglCreatePbufferSurface(egldisplay, eglconfig, ai);
    if (eglSurface == EGL10.EGL_NO_SURFACE) {
        egl10.eglDestroyContext(egldisplay, eglContext);
    } else {
        egl10.eglMakeCurrent(egldisplay, eglSurface, eglSurface, eglContext);
        String s = GLES10.glGetString(7939);
        if (!TextUtils.isEmpty(s)) {
            String as[] = s.split(" ");
            int i = as.length;
            for (int j = 0; j < i; j++) {
                set.add(as[j]);
            }
        }
        egl10.eglMakeCurrent(egldisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
        egl10.eglDestroySurface(egldisplay, eglSurface);
        egl10.eglDestroyContext(egldisplay, eglContext);
    }
}

/**
 * Writes GL version info to the log.
 */
@SuppressLint("InlinedApi")
public static void logVersionInfo() {
    Log.i(TAG, "vendor  : " + GLES10.glGetString(GLES10.GL_VENDOR));
    Log.i(TAG, "renderer: " + GLES10.glGetString(GLES10.GL_RENDERER));
    Log.i(TAG, "version : " + GLES10.glGetString(GLES10.GL_VERSION));

    if (BuildCheck.isAndroid4_3()) {
        final int[] values = new int[1];
        GLES30.glGetIntegerv(GLES30.GL_MAJOR_VERSION, values, 0);
        final int majorVersion = values[0];
        GLES30.glGetIntegerv(GLES30.GL_MINOR_VERSION, values, 0);
        final int minorVersion = values[0];
        if (GLES30.glGetError() == GLES30.GL_NO_ERROR) {
            Log.i(TAG, "version: " + majorVersion + "." + minorVersion);
        }
    }
}

/**
 * Return an error string from a GL or GLU error code.
 *
 * @param error - a GL or GLU error code.
 * @return the error string for the input error code, or NULL if the input
 *         was not a valid GL or GLU error code.
 */
public static String gluErrorString(final int error) {
    switch (error) {
    case GLES10.GL_NO_ERROR:
        return "no error";
    case GLES10.GL_INVALID_ENUM:
        return "invalid enum";
    case GLES10.GL_INVALID_VALUE:
        return "invalid value";
    case GLES10.GL_INVALID_OPERATION:
        return "invalid operation";
    case GLES10.GL_STACK_OVERFLOW:
        return "stack overflow";
    case GLES10.GL_STACK_UNDERFLOW:
        return "stack underflow";
    case GLES10.GL_OUT_OF_MEMORY:
        return "out of memory";
    default:
        return null;
    }
}

@Override
    public void draw(final int texId, final float[] tex_matrix, final int offset) {
        // FIXME Matrixを適用
        GLES10.glEnableClientState(GLES10.GL_VERTEX_ARRAY);
        pVertex.position(0);
        GLES10.glVertexPointer(2, GLES10.GL_FLOAT, VERTEX_SZ, pVertex);
//--------------------------------------------------------------------------------
        GLES10.glEnableClientState(GLES10.GL_TEXTURE_COORD_ARRAY);
        pTexCoord.position(0);
        GLES10.glTexCoordPointer(VERTEX_NUM, GLES10.GL_FLOAT, VERTEX_SZ, pTexCoord);
        GLES10.glActiveTexture(GLES10.GL_TEXTURE0);
        GLES10.glBindTexture(mTexTarget, texId);
//--------------------------------------------------------------------------------
        GLES10.glDrawArrays(GLES10.GL_TRIANGLE_STRIP, 0, VERTEX_NUM);
//--------------------------------------------------------------------------------
        GLES10.glBindTexture(mTexTarget, 0);
        GLES10.glDisableClientState(GLES10.GL_TEXTURE_COORD_ARRAY);
//--------------------------------------------------------------------------------
        GLES10.glDisableClientState(GLES10.GL_VERTEX_ARRAY);
    }

public String getContents() {
    StringBuilder sb = new StringBuilder();
    Formatter f = new Formatter(sb, Locale.US);
    String vendor = GLES10.glGetString(GLES10.GL_VENDOR);
    if (vendor == null) {
        f.format("!!! Please tap on another tab and then tap back on this tab. !!!\n\n");
    }
    f.format("vendor: %s\n", vendor);
    f.format("version: %s\n", GLES10.glGetString(GLES10.GL_VERSION));
    String extensions = GLES10.glGetString(GLES10.GL_EXTENSIONS);
    if (extensions == null) {
        extensions = "";
    }
    f.format("extensions: %s\n", extensions.replaceAll(" ", "\n"));
    return sb.toString();
}

private static void addExtensionsForConfig(EGL10 egl10, EGLDisplay egldisplay, EGLConfig eglconfig, int ai[], int ai1[], Set<String> set) {
    EGLContext eglContext = egl10.eglCreateContext(egldisplay, eglconfig, EGL10.EGL_NO_CONTEXT, ai1);
    if (eglContext == EGL10.EGL_NO_CONTEXT) {
        return;
    }
    javax.microedition.khronos.egl.EGLSurface eglSurface = egl10.eglCreatePbufferSurface(egldisplay, eglconfig, ai);
    if (eglSurface == EGL10.EGL_NO_SURFACE) {
        egl10.eglDestroyContext(egldisplay, eglContext);
    } else {
        egl10.eglMakeCurrent(egldisplay, eglSurface, eglSurface, eglContext);
        String s = GLES10.glGetString(7939);
        if (!TextUtils.isEmpty(s)) {
            String as[] = s.split(" ");
            int i = as.length;
            for (int j = 0; j < i; j++) {
                set.add(as[j]);
            }
        }
        egl10.eglMakeCurrent(egldisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
        egl10.eglDestroySurface(egldisplay, eglSurface);
        egl10.eglDestroyContext(egldisplay, eglContext);
    }
}

@Override
    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
        super.onSurfaceCreated(gl,config);
//        batch = new SpriteBatch();
//        img = new Texture("world.png");

        GLES10.glClearColor(0.0f, 0.0f, 0.0f, 0.f);

        // Create the GLText
        glText = new GLText( gl, context.getAssets() );

        // Load the font from file (set size + padding), creates the texture
        // NOTE: after a successful call to this the font is ready for rendering!
        glText.load( "Roboto-Regular.ttf", 14, 2, 2 );  // Create Font (Height: 14 Pixels / X+Y Padding 2 Pixels)

    }

private static void addExtensionsForConfig(EGL10 paramEGL10, EGLDisplay paramEGLDisplay, EGLConfig paramEGLConfig, int[] paramArrayOfInt1, int[] paramArrayOfInt2, Set<String> paramSet)
{
  EGLContext localEGLContext = paramEGL10.eglCreateContext(paramEGLDisplay, paramEGLConfig, EGL10.EGL_NO_CONTEXT, paramArrayOfInt2);
  if (localEGLContext == EGL10.EGL_NO_CONTEXT) {
    return;
  }
  EGLSurface localEGLSurface = paramEGL10.eglCreatePbufferSurface(paramEGLDisplay, paramEGLConfig, paramArrayOfInt1);
  if (localEGLSurface == EGL10.EGL_NO_SURFACE)
  {
    paramEGL10.eglDestroyContext(paramEGLDisplay, localEGLContext);
    return;
  }
  paramEGL10.eglMakeCurrent(paramEGLDisplay, localEGLSurface, localEGLSurface, localEGLContext);
  String str = GLES10.glGetString(7939);
  if (!TextUtils.isEmpty(str))
  {
    String[] arrayOfString = str.split(" ");
    int i = arrayOfString.length;
    for (int j = 0; j < i; j++) {
      paramSet.add(arrayOfString[j]);
    }
  }
  paramEGL10.eglMakeCurrent(paramEGLDisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
  paramEGL10.eglDestroySurface(paramEGLDisplay, localEGLSurface);
  paramEGL10.eglDestroyContext(paramEGLDisplay, localEGLContext);
}

@Override
protected void loadOnCreate() {
    GL_RENDERER = glGetString(GLES10.GL_RENDERER);
    GL_VERSION = glGetString(GLES10.GL_VERSION);
    GL_VENDOR = glGetString(GLES10.GL_VENDOR);
    GL_MAX_TEXTURE_SIZE = glGetIntegerv(GLES10.GL_MAX_TEXTURE_SIZE);
    GL_MAX_TEXTURE_UNITS = glGetIntegerv(GLES10.GL_MAX_TEXTURE_UNITS);
    GL_MAX_LIGHTS = glGetIntegerv(GLES10.GL_MAX_LIGHTS);
    GL_SUBPIXEL_BITS = glGetIntegerv(GLES10.GL_SUBPIXEL_BITS);
    GL_MAX_ELEMENTS_VERTICES = glGetIntegerv(GLES10.GL_MAX_ELEMENTS_VERTICES);
    GL_MAX_ELEMENTS_INDICES = glGetIntegerv(GLES10.GL_MAX_ELEMENTS_INDICES);
    GL_MAX_MODELVIEW_STACK_DEPTH = glGetIntegerv(GLES10.GL_MAX_MODELVIEW_STACK_DEPTH);
    GL_MAX_PROJECTION_STACK_DEPTH = glGetIntegerv(GLES10.GL_MAX_PROJECTION_STACK_DEPTH);
    GL_MAX_TEXTURE_STACK_DEPTH = glGetIntegerv(GLES10.GL_MAX_TEXTURE_STACK_DEPTH);
    GL_DEPTH_BITS = glGetIntegerv(GLES10.GL_DEPTH_BITS);
    GL_STENCIL_BITS = glGetIntegerv(GLES10.GL_STENCIL_BITS);
    GL_EXTENSIONS = glGetString(GLES10.GL_EXTENSIONS);
    GL_MAX_VIEWPORT_DIMS = glGetIntegerv(GLES10.GL_MAX_VIEWPORT_DIMS, 2);
}

@Override
protected void loadOnCreate() {
    GL_RENDERER = glGetString(GLES10.GL_RENDERER);
    GL_VERSION = glGetString(GLES10.GL_VERSION);
    GL_VENDOR = glGetString(GLES10.GL_VENDOR);
    /*GL_MAX_TEXTURE_SIZE = glGetIntegerv(GLES10.GL_MAX_TEXTURE_SIZE);
    GL_MAX_TEXTURE_UNITS = glGetIntegerv(GLES10.GL_MAX_TEXTURE_UNITS);
    GL_MAX_LIGHTS = glGetIntegerv(GLES10.GL_MAX_LIGHTS);
    GL_SUBPIXEL_BITS = glGetIntegerv(GLES10.GL_SUBPIXEL_BITS);
    GL_MAX_ELEMENTS_VERTICES = glGetIntegerv(GLES10.GL_MAX_ELEMENTS_VERTICES);
    GL_MAX_ELEMENTS_INDICES = glGetIntegerv(GLES10.GL_MAX_ELEMENTS_INDICES);
    GL_MAX_MODELVIEW_STACK_DEPTH = glGetIntegerv(GLES10.GL_MAX_MODELVIEW_STACK_DEPTH);
    GL_MAX_PROJECTION_STACK_DEPTH = glGetIntegerv(GLES10.GL_MAX_PROJECTION_STACK_DEPTH);
    GL_MAX_TEXTURE_STACK_DEPTH = glGetIntegerv(GLES10.GL_MAX_TEXTURE_STACK_DEPTH);
    GL_DEPTH_BITS = glGetIntegerv(GLES10.GL_DEPTH_BITS);
    GL_STENCIL_BITS = glGetIntegerv(GLES10.GL_STENCIL_BITS);
    GL_EXTENSIONS = glGetString(GLES10.GL_EXTENSIONS);
    GL_MAX_VIEWPORT_DIMS = glGetIntegerv(GLES10.GL_MAX_VIEWPORT_DIMS, 2);*/
}

public void load(GL10 gl) {
    int width = 128;
    int height = 128;
    Buffer image = createImage(width, height);
    ETC1Util.ETC1Texture etc1Texture = ETC1Util.compressTexture(image, width, height, 3, 3 * width);
    if (USE_STREAM_IO) {
        // Test the ETC1Util APIs for reading and writing compressed textures to I/O streams.
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ETC1Util.writeTexture(etc1Texture, bos);
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ETC1Util.loadTexture(GLES10.GL_TEXTURE_2D, 0, 0,
                    GLES10.GL_RGB, GLES10.GL_UNSIGNED_SHORT_5_6_5, bis);
        } catch (IOException e) {
            Log.w(TAG, "Could not load texture: " + e);
        }
    } else {
        ETC1Util.loadTexture(GLES10.GL_TEXTURE_2D, 0, 0,
                GLES10.GL_RGB, GLES10.GL_UNSIGNED_SHORT_5_6_5, etc1Texture);
    }
}

public void load(GL10 gl) {
    int width = 128;
    int height = 128;
    Buffer image = createImage(width, height);
    ETC1Util.ETC1Texture etc1Texture = ETC1Util.compressTexture(image, width, height, 3, 3 * width);
    if (USE_STREAM_IO) {
        // Test the ETC1Util APIs for reading and writing compressed textures to I/O streams.
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ETC1Util.writeTexture(etc1Texture, bos);
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ETC1Util.loadTexture(GLES10.GL_TEXTURE_2D, 0, 0,
                    GLES10.GL_RGB, GLES10.GL_UNSIGNED_SHORT_5_6_5, bis);
        } catch (IOException e) {
            Log.w(TAG, "Could not load texture: " + e);
        }
    } else {
        ETC1Util.loadTexture(GLES10.GL_TEXTURE_2D, 0, 0,
                GLES10.GL_RGB, GLES10.GL_UNSIGNED_SHORT_5_6_5, etc1Texture);
    }
}

/**
 * Check if ETC1 texture compression is supported by the active OpenGL ES context.
 * @return true if the active OpenGL ES context supports ETC1 texture compression.
 */
public static boolean isETC1Supported() {
    int[] results = new int[20];
    GLES10.glGetIntegerv(GLES10.GL_NUM_COMPRESSED_TEXTURE_FORMATS, results, 0);
    int numFormats = results[0];
    if (numFormats > results.length) {
        results = new int[numFormats];
    }
    GLES10.glGetIntegerv(GLES10.GL_COMPRESSED_TEXTURE_FORMATS, results, 0);
    for (int i = 0; i < numFormats; i++) {
        if (results[i] == JavaETC1.ETC1_RGB8_OES) {
            return true;
        }
    }
    return false;
}

/**
 * Check if ETC1 texture compression is supported by the active OpenGL ES context.
 * @return true if the active OpenGL ES context supports ETC1 texture compression.
 */
public static boolean isETC1Supported() {
    int[] results = new int[20];
    GLES10.glGetIntegerv(GLES10.GL_NUM_COMPRESSED_TEXTURE_FORMATS, results, 0);
    int numFormats = results[0];
    if (numFormats > results.length) {
        results = new int[numFormats];
    }
    GLES10.glGetIntegerv(GLES10.GL_COMPRESSED_TEXTURE_FORMATS, results, 0);
    for (int i = 0; i < numFormats; i++) {
        if (results[i] == RsETC1.ETC1_RGB8_OES) {
            return true;
        }
    }
    return false;
}

@Override
public void drawQuadWithTexture(TextureHandle textureid, float[] geometry) {
    if (quadEleementBuffer == null) {
        generateQuadElementBuffer();
    }
    quadEleementBuffer.position(0);
    glBindTexture(textureid);

    FloatBuffer buffer = generateTemporaryFloatBuffer(geometry);

    GLES10.glVertexPointer(3, GLES10.GL_FLOAT, 5 * 4, buffer);
    FloatBuffer texbuffer = reuseableBufferDuplicate;
    texbuffer.position(3);
    GLES10.glTexCoordPointer(2, GLES10.GL_FLOAT, 5 * 4, texbuffer);

    GLES10.glDrawElements(GLES10.GL_TRIANGLES, 6, GLES10.GL_UNSIGNED_BYTE,
            quadEleementBuffer);
}

@Override
public void drawTrianglesWithTextureColored(TextureHandle textureid, float[] geometry) {
    glBindTexture(textureid);

    GLES10.glEnableClientState(GLES10.GL_COLOR_ARRAY);

    FloatBuffer buffer = generateTemporaryFloatBuffer(geometry);

    GLES10.glVertexPointer(3, GLES10.GL_FLOAT, 9 * 4, buffer);
    FloatBuffer texbuffer = reuseableBufferDuplicate;
    texbuffer.position(3);
    GLES10.glTexCoordPointer(2, GLES10.GL_FLOAT, 9 * 4, texbuffer);
    FloatBuffer colorbuffer = buffer.duplicate(); // we need it selden enogh
                                                    // to allocate a new one.
    colorbuffer.position(5);
    GLES10.glColorPointer(4, GLES10.GL_FLOAT, 9 * 4, colorbuffer);

    GLES10.glDrawArrays(GLES10.GL_TRIANGLES, 0, geometry.length / 9);
    GLES10.glDisableClientState(GLES10.GL_COLOR_ARRAY);
}

@Override
public void drawTrianglesWithTextureColored(TextureHandle textureid,
        ByteBuffer byteBuffer, int currentTriangles) {
    glBindTexture(textureid);

    GLES10.glEnableClientState(GLES10.GL_COLOR_ARRAY);

    GLES10.glVertexPointer(3, GLES10.GL_FLOAT, 6 * 4, byteBuffer);
    ByteBuffer texbuffer = byteBuffer.duplicate();
    texbuffer.position(3 * 4);
    GLES10.glTexCoordPointer(2, GLES10.GL_FLOAT, 6 * 4, texbuffer);
    ByteBuffer colorbuffer = byteBuffer.duplicate(); // we need it selden
                                                        // enogh
                                                        // to allocate a new
                                                        // one.
    colorbuffer.position(5 * 4);
    GLES10.glColorPointer(4, GLES10.GL_UNSIGNED_BYTE, 6 * 4, colorbuffer);

    GLES10.glDrawArrays(GLES10.GL_TRIANGLES, 0, currentTriangles * 3);
    GLES10.glDisableClientState(GLES10.GL_COLOR_ARRAY);

}

@Override
public TextureHandle generateTexture(int width, int height, ShortBuffer data) {
    // 1 byte aligned.
    GLES10.glPixelStorei(GLES10.GL_UNPACK_ALIGNMENT, 1);

    TextureHandle texture = genTextureIndex();
    if (texture == null) {
        return null;
    }

    glBindTexture(texture);
    GLES10.glTexImage2D(GLES10.GL_TEXTURE_2D, 0, GLES10.GL_RGBA, width,
            height, 0, GLES10.GL_RGBA, GLES10.GL_UNSIGNED_SHORT_5_5_5_1,
            data);

    setTextureParameters();
    return texture;
}

public TextureHandle generateTextureAlpha(int width, int height) {
    // 1 byte aligned.
    GLES10.glPixelStorei(GLES10.GL_UNPACK_ALIGNMENT, 1);

    TextureHandle texture = genTextureIndex();
    if (texture == null) {
        return null;
    }

    ByteBuffer data = ByteBuffer.allocateDirect(width * height);
    while (data.hasRemaining()) {
        data.put((byte) 0);
    }
    data.rewind();

    glBindTexture(texture);
    GLES10.glTexImage2D(GLES10.GL_TEXTURE_2D, 0, GLES10.GL_ALPHA, width,
            height, 0, GLES10.GL_ALPHA, GLES10.GL_UNSIGNED_BYTE, data);

    setTextureParameters();
    return texture;
}

@Override
public void drawQuadWithTexture(TextureHandle textureid, GeometryHandle geometryindex) {
    if (quadEleementBuffer == null) {
        generateQuadElementBuffer();
    }
    quadEleementBuffer.position(0);

    glBindTexture(textureid);

    GLES11.glBindBuffer(GLES11.GL_ARRAY_BUFFER, geometryindex.getInternalId());
    GLES11.glVertexPointer(3, GLES10.GL_FLOAT, 5 * 4, 0);
    GLES11.glTexCoordPointer(2, GLES10.GL_FLOAT, 5 * 4, 3 * 4);

    GLES11.glDrawElements(GLES10.GL_TRIANGLES, 6, GLES10.GL_UNSIGNED_BYTE,
            quadEleementBuffer);

    GLES11.glBindBuffer(GLES11.GL_ARRAY_BUFFER, 0);
}

public void reinit(int width, int height) {
    GLES10.glMatrixMode(GLES10.GL_PROJECTION);
    GLES10.glLoadIdentity();
    GLES10.glMatrixMode(GLES10.GL_MODELVIEW);
    GLES10.glLoadIdentity();

    GLES10.glScalef(2f / width, 2f / height, -.5f);
    // TODO: do not scale depth by 0.

    GLES10.glTranslatef(-width / 2, -height / 2, .25f);

    GLES10.glEnableClientState(GLES10.GL_VERTEX_ARRAY);
    GLES10.glEnableClientState(GLES10.GL_TEXTURE_COORD_ARRAY);

    GLES10.glAlphaFunc(GLES10.GL_GREATER, 0.1f);
    GLES10.glEnable(GLES10.GL_ALPHA_TEST);
    GLES10.glEnable(GLES10.GL_BLEND);
    GLES10.glBlendFunc(GLES10.GL_SRC_ALPHA, GLES10.GL_ONE_MINUS_SRC_ALPHA);

    GLES10.glDepthFunc(GLES10.GL_LEQUAL);
    GLES10.glEnable(GLES10.GL_DEPTH_TEST);

    GLES10.glEnable(GLES10.GL_TEXTURE_2D);
}

public static int getSupportedMaxPictureSize() {
    int[] array = new int[1];
    GLES10.glGetIntegerv(GLES10.GL_MAX_TEXTURE_SIZE, array, 0);

    if (array[0] == 0) {
        GLES11.glGetIntegerv(GLES11.GL_MAX_TEXTURE_SIZE, array, 0);

        if (array[0] == 0) {
            GLES20.glGetIntegerv(GLES20.GL_MAX_TEXTURE_SIZE, array, 0);

            if (array[0] == 0) {
                GLES30.glGetIntegerv(GLES30.GL_MAX_TEXTURE_SIZE, array, 0);
            }
        }
    }

    return array[0] != 0 ? array[0] : 2048;
}

private static void addExtensionsForConfig(EGL10 egl10, EGLDisplay egldisplay, EGLConfig eglconfig, int ai[],
                                           int ai1[], Set<String> set) {
    EGLContext eglcontext = egl10.eglCreateContext(egldisplay, eglconfig, EGL10.EGL_NO_CONTEXT, ai1);
    if (eglcontext != EGL10.EGL_NO_CONTEXT) {
        javax.microedition.khronos.egl.EGLSurface eglsurface =
                egl10.eglCreatePbufferSurface(egldisplay, eglconfig, ai);
        if (eglsurface == EGL10.EGL_NO_SURFACE) {
            egl10.eglDestroyContext(egldisplay, eglcontext);
        } else {
            egl10.eglMakeCurrent(egldisplay, eglsurface, eglsurface, eglcontext);
            String s = GLES10.glGetString(7939);
            if (s != null && !s.isEmpty()) {
                String as[] = s.split(" ");
                int i = as.length;
                for (int j = 0; j < i; j++) {
                    set.add(as[j]);
                }

            }
            egl10.eglMakeCurrent(egldisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
            egl10.eglDestroySurface(egldisplay, eglsurface);
            egl10.eglDestroyContext(egldisplay, eglcontext);
        }
    }
}

/**
 * 
 * @param config
 */
    public void onSurfaceCreatedGLES20(EGLConfig config) {


//      textureIndex = loadTexture( context , R.drawable.tex );

        GLES20.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
        GLES20.glClearDepthf(1.0f);
        GLES20.glEnable(GLES10.GL_DEPTH_TEST);
        GLES20.glDepthFunc(GLES10.GL_LEQUAL);
        GLES20.glHint(GLES10.GL_PERSPECTIVE_CORRECTION_HINT, GLES10.GL_FASTEST);

        int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode);
        int fragmentShader = loadShader(GLES20.GL_FRAGMENT_SHADER,
                fragmentShaderCode);

        mProgram = GLES20.glCreateProgram();
        GLES20.glAttachShader(mProgram, vertexShader);
        GLES20.glAttachShader(mProgram, fragmentShader);
        GLES20.glLinkProgram(mProgram);

        maPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");
        colorHandle = GLES20.glGetAttribLocation(mProgram, "a_color");

    }

@Override
public void onSurfaceChanged(GL10 gl, int width, int height) {

    if (GLESVersion == 1) {

        if (height == 0) {
            height = 1;
        }

        glViewport(0, 0, width, height);
        glMatrixMode(GLES10.GL_PROJECTION);
        glLoadIdentity();

        GLU.gluPerspective(gl, 45.0f, (float) width / (float) height, 0.1f,
                1024.0f);

        glMatrixMode(GLES10.GL_MODELVIEW);
        glLoadIdentity();

    } else {
        onSurfaceChangedGLES20(width, height);
    }
}

public void load(GL10 gl) {
    int width = 128;
    int height = 128;
    Buffer image = createImage(width, height);
    ETC1Util.ETC1Texture etc1Texture = ETC1Util.compressTexture(image, width, height, 3, 3 * width);
    if (USE_STREAM_IO) {
        // Test the ETC1Util APIs for reading and writing compressed textures to I/O streams.
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ETC1Util.writeTexture(etc1Texture, bos);
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ETC1Util.loadTexture(GLES10.GL_TEXTURE_2D, 0, 0,
                    GLES10.GL_RGB, GLES10.GL_UNSIGNED_SHORT_5_6_5, bis);
        } catch (IOException e) {
            Log.w(TAG, "Could not load texture: " + e);
        }
    } else {
        ETC1Util.loadTexture(GLES10.GL_TEXTURE_2D, 0, 0,
                GLES10.GL_RGB, GLES10.GL_UNSIGNED_SHORT_5_6_5, etc1Texture);
    }
}

public void load(GL10 gl) {
    int width = 128;
    int height = 128;
    Buffer image = createImage(width, height);
    ETC1Util.ETC1Texture etc1Texture = ETC1Util.compressTexture(image, width, height, 3, 3 * width);
    if (USE_STREAM_IO) {
        // Test the ETC1Util APIs for reading and writing compressed textures to I/O streams.
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ETC1Util.writeTexture(etc1Texture, bos);
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ETC1Util.loadTexture(GLES10.GL_TEXTURE_2D, 0, 0,
                    GLES10.GL_RGB, GLES10.GL_UNSIGNED_SHORT_5_6_5, bis);
        } catch (IOException e) {
            Log.w(TAG, "Could not load texture: " + e);
        }
    } else {
        ETC1Util.loadTexture(GLES10.GL_TEXTURE_2D, 0, 0,
                GLES10.GL_RGB, GLES10.GL_UNSIGNED_SHORT_5_6_5, etc1Texture);
    }
}

public void load(GL10 gl) {
    int width = 128;
    int height = 128;
    Buffer image = createImage(width, height);
    ETC1Util.ETC1Texture etc1Texture = ETC1Util.compressTexture(image, width, height, 3, 3 * width);
    if (USE_STREAM_IO) {
        // Test the ETC1Util APIs for reading and writing compressed textures to I/O streams.
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ETC1Util.writeTexture(etc1Texture, bos);
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ETC1Util.loadTexture(GLES10.GL_TEXTURE_2D, 0, 0,
                    GLES10.GL_RGB, GLES10.GL_UNSIGNED_SHORT_5_6_5, bis);
        } catch (IOException e) {
            Log.w(TAG, "Could not load texture: " + e);
        }
    } else {
        ETC1Util.loadTexture(GLES10.GL_TEXTURE_2D, 0, 0,
                GLES10.GL_RGB, GLES10.GL_UNSIGNED_SHORT_5_6_5, etc1Texture);
    }
}

public void load(GL10 gl) {
    int width = 128;
    int height = 128;
    Buffer image = createImage(width, height);
    ETC1Util.ETC1Texture etc1Texture = ETC1Util.compressTexture(image, width, height, 3, 3 * width);
    if (USE_STREAM_IO) {
        // Test the ETC1Util APIs for reading and writing compressed textures to I/O streams.
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ETC1Util.writeTexture(etc1Texture, bos);
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ETC1Util.loadTexture(GLES10.GL_TEXTURE_2D, 0, 0,
                    GLES10.GL_RGB, GLES10.GL_UNSIGNED_SHORT_5_6_5, bis);
        } catch (IOException e) {
            Log.w(TAG, "Could not load texture: " + e);
        }
    } else {
        ETC1Util.loadTexture(GLES10.GL_TEXTURE_2D, 0, 0,
                GLES10.GL_RGB, GLES10.GL_UNSIGNED_SHORT_5_6_5, etc1Texture);
    }
}

public static final int getTextureSize() {
    if (textureSize > 0) {
        return textureSize;
    }

    int[] params = new int[1];
    GLES10.glGetIntegerv(GLES10.GL_MAX_TEXTURE_SIZE, params, 0);
    textureSize = params[0];

    return textureSize;     
}

public static final int getTextureSize() {
    if (textureSize > 0) {
        return textureSize;
    }

    int[] params = new int[1];
    GLES10.glGetIntegerv(GLES10.GL_MAX_TEXTURE_SIZE, params, 0);
    textureSize = params[0];

    return textureSize;
}

public static final int getTextureSize() {
    if (textureSize > 0) {
        return textureSize;
    }

    int[] params = new int[1];
    GLES10.glGetIntegerv(GLES10.GL_MAX_TEXTURE_SIZE, params, 0);
    textureSize = params[0];

    return textureSize;     
}

@Override
public void makeCurrent() {
    mEglBase.makeCurrent(mEglSurface);
    if (mEglBase.getGlVersion() >= 2) {
        GLES20.glViewport(0, 0,
            mEglBase.getSurfaceWidth(mEglSurface),
            mEglBase.getSurfaceHeight(mEglSurface));
    } else {
        GLES10.glViewport(0, 0,
            mEglBase.getSurfaceWidth(mEglSurface),
            mEglBase.getSurfaceHeight(mEglSurface));
    }
}

/**
     * OpenGL|ESのエラーをチェックしてlogCatに出力する
     * @param op
     */
    public static void checkGlError(final String op) {
        final int error = GLES10.glGetError();
        if (error != GLES10.GL_NO_ERROR) {
            final String msg = op + ": glError 0x" + Integer.toHexString(error);
            Log.e(TAG, msg);
            new Throwable(msg).printStackTrace();
//          if (DEBUG) {
//              throw new RuntimeException(msg);
//          }
        }
    }

/**
     * テクスチャ名を生成
     * @param texTarget
     * @param texUnit テクスチャユニット, GL_TEXTURE0...GL_TEXTURE31
     * @param min_filter テクスチャの補間方法を指定, GL_LINEARとかGL_NEAREST
     * @param mag_filter テクスチャの補間方法を指定, GL_LINEARとかGL_NEAREST
     * @param wrap テクスチャのクランプ方法, GL_CLAMP_TO_EDGE
     * @return
     */
    public static int initTex(final int texTarget, final int texUnit, final int min_filter, final int mag_filter, final int wrap) {
//      if (DEBUG) Log.v(TAG, "initTex:target=" + texTarget);
        final int[] tex = new int[1];
        GLES10.glActiveTexture(texUnit);
        GLES10.glGenTextures(1, tex, 0);
        GLES10.glBindTexture(texTarget, tex[0]);
        GLES10.glTexParameterx(texTarget, GLES10.GL_TEXTURE_WRAP_S, wrap);
        GLES10.glTexParameterx(texTarget, GLES10.GL_TEXTURE_WRAP_T, wrap);
        GLES10.glTexParameterx(texTarget, GLES10.GL_TEXTURE_MIN_FILTER, min_filter);
        GLES10.glTexParameterx(texTarget, GLES10.GL_TEXTURE_MAG_FILTER, mag_filter);
        return tex[0];
    }

public static int loadTextureFromResource(final Context context, final int resId) {
    // Create an empty, mutable bitmap
    final Bitmap bitmap = Bitmap.createBitmap(256, 256, Bitmap.Config.ARGB_8888);
    // get a canvas to paint over the bitmap
    final Canvas canvas = new Canvas(bitmap);
    canvas.drawARGB(0,0,255,0);

    // get a background image from resources
    // note the image format must match the bitmap format
    final Drawable background = context.getResources().getDrawable(resId);
    background.setBounds(0, 0, 256, 256);
    background.draw(canvas); // draw the background to our bitmap

    final int[] textures = new int[1];

    //Generate one texture pointer...
    GLES10.glGenTextures(1, textures, 0);
    //...and bind it to our array
    GLES10.glBindTexture(GLES10.GL_TEXTURE_2D, textures[0]);

    //Create Nearest Filtered Texture
    GLES10.glTexParameterx(GLES10.GL_TEXTURE_2D, GLES10.GL_TEXTURE_MIN_FILTER, GLES10.GL_NEAREST);
    GLES10.glTexParameterx(GLES10.GL_TEXTURE_2D, GLES10.GL_TEXTURE_MAG_FILTER, GLES10.GL_LINEAR);

    //Different possible texture parameters, e.g. GLES10.GL_CLAMP_TO_EDGE
    GLES10.glTexParameterx(GLES10.GL_TEXTURE_2D, GLES10.GL_TEXTURE_WRAP_S, GLES10.GL_REPEAT);
    GLES10.glTexParameterx(GLES10.GL_TEXTURE_2D, GLES10.GL_TEXTURE_WRAP_T, GLES10.GL_REPEAT);

    //Use the Android GLUtils to specify a two-dimensional texture image from our bitmap
    GLUtils.texImage2D(GLES10.GL_TEXTURE_2D, 0, bitmap, 0);
    //Clean up
    bitmap.recycle();

    return textures[0];
}

public static int createTextureWithTextContent (final String text) {
    // Create an empty, mutable bitmap
    final Bitmap bitmap = Bitmap.createBitmap(256, 256, Bitmap.Config.ARGB_8888);
    // get a canvas to paint over the bitmap
    final Canvas canvas = new Canvas(bitmap);
    canvas.drawARGB(0,0,255,0);

    // Draw the text
    final Paint textPaint = new Paint();
    textPaint.setTextSize(32);
    textPaint.setAntiAlias(true);
    textPaint.setARGB(0xff, 0xff, 0xff, 0xff);
    // draw the text centered
    canvas.drawText(text, 16, 112, textPaint);

    final int texture = initTex(GLES10.GL_TEXTURE_2D, GLES10.GL_TEXTURE0, GLES10.GL_NEAREST, GLES10.GL_LINEAR, GLES10.GL_REPEAT);

    // Alpha blending
    // GLES10.glEnable(GLES10.GL_BLEND);
    // GLES10.glBlendFunc(GLES10.GL_SRC_ALPHA, GLES10.GL_ONE_MINUS_SRC_ALPHA);

    // Use the Android GLUtils to specify a two-dimensional texture image from our bitmap
    GLUtils.texImage2D(GLES10.GL_TEXTURE_2D, 0, bitmap, 0);
    // Clean up
    bitmap.recycle();

    return texture;
}

/**
 * Map object coordinates into window coordinates. gluProject transforms the
 * specified object coordinates into window coordinates using model, proj,
 * and view. The result is stored in win.
 * <p>
 * Note that you can use the OES_matrix_get extension, if present, to get
 * the current modelView and projection matrices.
 *
 * @param objX object coordinates X
 * @param objY object coordinates Y
 * @param objZ object coordinates Z
 * @param model the current modelview matrix
 * @param modelOffset the offset into the model array where the modelview
 *        maxtrix data starts.
 * @param project the current projection matrix
 * @param projectOffset the offset into the project array where the project
 *        matrix data starts.
 * @param view the current view, {x, y, width, height}
 * @param viewOffset the offset into the view array where the view vector
 *        data starts.
 * @param win the output vector {winX, winY, winZ}, that returns the
 *        computed window coordinates.
 * @param winOffset the offset into the win array where the win vector data
 *        starts.
 * @return A return value of GL_TRUE indicates success, a return value of
 *         GL_FALSE indicates failure.
 */
public static int gluProject(final float objX, final float objY, final float objZ,
    final float[] model, final int modelOffset, final float[] project, final int projectOffset,
    final int[] view, final int viewOffset, final float[] win, final int winOffset) {

    final float[] scratch = sScratch;
    synchronized (scratch) {
        final int M_OFFSET = 0; // 0..15
        final int V_OFFSET = 16; // 16..19
        final int V2_OFFSET = 20; // 20..23
        Matrix.multiplyMM(scratch, M_OFFSET, project, projectOffset, model, modelOffset);

        scratch[V_OFFSET + 0] = objX;
        scratch[V_OFFSET + 1] = objY;
        scratch[V_OFFSET + 2] = objZ;
        scratch[V_OFFSET + 3] = 1.0f;

        Matrix.multiplyMV(scratch, V2_OFFSET, scratch, M_OFFSET, scratch, V_OFFSET);

        final float w = scratch[V2_OFFSET + 3];
        if (w == 0.0f) {
            return GLES10.GL_FALSE;
        }

        final float rw = 1.0f / w;

        win[winOffset] = view[viewOffset]
            + view[viewOffset + 2]
            * (scratch[V2_OFFSET + 0] * rw + 1.0f)
            * 0.5f;
        win[winOffset + 1] =
            view[viewOffset + 1] + view[viewOffset + 3]
            * (scratch[V2_OFFSET + 1] * rw + 1.0f) * 0.5f;
        win[winOffset + 2] = (scratch[V2_OFFSET + 2] * rw + 1.0f) * 0.5f;
    }

    return GL10.GL_TRUE;
}

/**
     * コンストラクタ
     * @param width テクスチャサイズ
     * @param height テクスチャサイズ
     * @param filter_param  テクスチャの補間方法を指定 GL_LINEARとかGL_NEAREST
     */
    public GLTexture(final int width, final int height, final int filter_param) {
//      if (DEBUG) Log.v(TAG, String.format("コンストラクタ(%d,%d)", width, height));
        // テクスチャに使うビットマップは縦横サイズが2の乗数でないとダメ。
        // 更に、ミップマップするなら正方形でないとダメ
        // 指定したwidth/heightと同じか大きい2の乗数にする
        int w = 32;
        for (; w < width; w <<= 1);
        int h = 32;
        for (; h < height; h <<= 1);
        if (mTexWidth != w || mTexHeight != h) {
            mTexWidth = w;
            mTexHeight = h;
        }
//      if (DEBUG) Log.v(TAG, String.format("texSize(%d,%d)", mTexWidth, mTexHeight));
        mTextureId = GLHelper.initTex(mTextureTarget, filter_param);
        // テクスチャのメモリ領域を確保する
        GLES10.glTexImage2D(mTextureTarget,
            0,                          // ミップマップレベル0(ミップマップしない)
            GLES10.GL_RGBA,             // 内部フォーマット
            mTexWidth, mTexHeight,      // サイズ
            0,                          // 境界幅
            GLES10.GL_RGBA,             // 引き渡すデータのフォーマット
            GLES10.GL_UNSIGNED_BYTE,        // データの型
            null);                      // ピクセルデータ無し
        // テクスチャ変換行列を初期化
        Matrix.setIdentityM(mTexMatrix, 0);
        mTexMatrix[0] = width / (float)mTexWidth;
        mTexMatrix[5] = height / (float)mTexHeight;
//      if (DEBUG) Log.v(TAG, "GLTexture:id=" + mTextureId);
    }