FileDocCategorySizeDatePackage
MatrixTrackingGL.javaAPI DocAndroid 1.5 API32536Wed May 06 22:41:08 BST 2009com.example.android.apis.graphics.spritetext

MatrixTrackingGL

public class MatrixTrackingGL extends Object implements javax.microedition.khronos.opengles.GL11, javax.microedition.khronos.opengles.GL, javax.microedition.khronos.opengles.GL10, javax.microedition.khronos.opengles.GL11Ext, javax.microedition.khronos.opengles.GL10Ext
Allows retrieving the current matrix even if the current OpenGL ES driver does not support retrieving the current matrix. Note: the actual matrix may differ from the retrieved matrix, due to differences in the way the math is implemented by GLMatrixWrapper as compared to the way the math is implemented by the OpenGL ES driver.

Fields Summary
private javax.microedition.khronos.opengles.GL10
mgl
private javax.microedition.khronos.opengles.GL10Ext
mgl10Ext
private javax.microedition.khronos.opengles.GL11
mgl11
private javax.microedition.khronos.opengles.GL11Ext
mgl11Ext
private int
mMatrixMode
private MatrixStack
mCurrent
private MatrixStack
mModelView
private MatrixStack
mTexture
private MatrixStack
mProjection
private static final boolean
_check
ByteBuffer
mByteBuffer
FloatBuffer
mFloatBuffer
float[]
mCheckA
float[]
mCheckB
Constructors Summary
public MatrixTrackingGL(javax.microedition.khronos.opengles.GL gl)


       
        mgl = (GL10) gl;
        if (gl instanceof GL10Ext) {
            mgl10Ext = (GL10Ext) gl;
        }
        if (gl instanceof GL11) {
            mgl11 = (GL11) gl;
        }
        if (gl instanceof GL11Ext) {
            mgl11Ext = (GL11Ext) gl;
        }
        mModelView = new MatrixStack();
        mProjection = new MatrixStack();
        mTexture = new MatrixStack();
        mCurrent = mModelView;
        mMatrixMode = GL10.GL_MODELVIEW;
Methods Summary
private voidcheck()

        int oesMode;
        switch (mMatrixMode) {
        case GL_MODELVIEW:
            oesMode = GL11.GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES;
            break;
        case GL_PROJECTION:
            oesMode = GL11.GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES;
            break;
        case GL_TEXTURE:
            oesMode = GL11.GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES;
            break;
        default:
            throw new IllegalArgumentException("Unknown matrix mode");
        }

        if ( mByteBuffer == null) {
            mCheckA = new float[16];
            mCheckB = new float[16];
            mByteBuffer = ByteBuffer.allocateDirect(64);
            mByteBuffer.order(ByteOrder.nativeOrder());
            mFloatBuffer = mByteBuffer.asFloatBuffer();
        }
        mgl.glGetIntegerv(oesMode, mByteBuffer.asIntBuffer());
        for(int i = 0; i < 16; i++) {
            mCheckB[i] = mFloatBuffer.get(i);
        }
        mCurrent.getMatrix(mCheckA, 0);

        boolean fail = false;
        for(int i = 0; i < 16; i++) {
            if (mCheckA[i] != mCheckB[i]) {
                Log.d("GLMatWrap", "i:" + i + " a:" + mCheckA[i]
                + " a:" + mCheckB[i]);
                fail = true;
            }
        }
        if (fail) {
            throw new IllegalArgumentException("Matrix math difference.");
        }
public voidgetMatrix(float[] m, int offset)
Get the current matrix

        mCurrent.getMatrix(m, offset);
public intgetMatrixMode()
Get the current matrix mode

        return mMatrixMode;
public voidglActiveTexture(int texture)

        mgl.glActiveTexture(texture);
public voidglAlphaFunc(int func, float ref)

        mgl.glAlphaFunc(func, ref);
public voidglAlphaFuncx(int func, int ref)

        mgl.glAlphaFuncx(func, ref);
public voidglBindBuffer(int target, int buffer)

        throw new UnsupportedOperationException();
public voidglBindTexture(int target, int texture)

        mgl.glBindTexture(target, texture);
public voidglBlendFunc(int sfactor, int dfactor)

        mgl.glBlendFunc(sfactor, dfactor);
public voidglBufferData(int target, int size, java.nio.Buffer data, int usage)

        throw new UnsupportedOperationException();
public voidglBufferSubData(int target, int offset, int size, java.nio.Buffer data)

        throw new UnsupportedOperationException();
public voidglClear(int mask)

        mgl.glClear(mask);
public voidglClearColor(float red, float green, float blue, float alpha)

        mgl.glClearColor(red, green, blue, alpha);
public voidglClearColorx(int red, int green, int blue, int alpha)

        mgl.glClearColorx(red, green, blue, alpha);
public voidglClearDepthf(float depth)

        mgl.glClearDepthf(depth);
public voidglClearDepthx(int depth)

        mgl.glClearDepthx(depth);
public voidglClearStencil(int s)

        mgl.glClearStencil(s);
public voidglClientActiveTexture(int texture)

        mgl.glClientActiveTexture(texture);
public voidglClipPlanef(int plane, float[] equation, int offset)

        mgl11.glClipPlanef(plane, equation, offset);
public voidglClipPlanef(int plane, java.nio.FloatBuffer equation)

        mgl11.glClipPlanef(plane, equation);
public voidglClipPlanex(int plane, int[] equation, int offset)

        mgl11.glClipPlanex(plane, equation, offset);
public voidglClipPlanex(int plane, java.nio.IntBuffer equation)

        mgl11.glClipPlanex(plane, equation);
public voidglColor4f(float red, float green, float blue, float alpha)

        mgl.glColor4f(red, green, blue, alpha);
public voidglColor4ub(byte red, byte green, byte blue, byte alpha)

        throw new UnsupportedOperationException();
public voidglColor4x(int red, int green, int blue, int alpha)

        mgl.glColor4x(red, green, blue, alpha);
public voidglColorMask(boolean red, boolean green, boolean blue, boolean alpha)

        mgl.glColorMask(red, green, blue, alpha);
public voidglColorPointer(int size, int type, int stride, java.nio.Buffer pointer)

        mgl.glColorPointer(size, type, stride, pointer);
public voidglColorPointer(int size, int type, int stride, int offset)

        throw new UnsupportedOperationException();
public voidglCompressedTexImage2D(int target, int level, int internalformat, int width, int height, int border, int imageSize, java.nio.Buffer data)

        mgl.glCompressedTexImage2D(target, level, internalformat, width,
                height, border, imageSize, data);
public voidglCompressedTexSubImage2D(int target, int level, int xoffset, int yoffset, int width, int height, int format, int imageSize, java.nio.Buffer data)

        mgl.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width,
                height, format, imageSize, data);
public voidglCopyTexImage2D(int target, int level, int internalformat, int x, int y, int width, int height, int border)

        mgl.glCopyTexImage2D(target, level, internalformat, x, y, width,
                height, border);
public voidglCopyTexSubImage2D(int target, int level, int xoffset, int yoffset, int x, int y, int width, int height)

        mgl.glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width,
                height);
public voidglCullFace(int mode)

        mgl.glCullFace(mode);
public voidglCurrentPaletteMatrixOES(int matrixpaletteindex)

        throw new UnsupportedOperationException();
public voidglDeleteBuffers(int n, int[] buffers, int offset)

        throw new UnsupportedOperationException();
public voidglDeleteBuffers(int n, java.nio.IntBuffer buffers)

        throw new UnsupportedOperationException();
public voidglDeleteTextures(int n, int[] textures, int offset)

        mgl.glDeleteTextures(n, textures, offset);
public voidglDeleteTextures(int n, java.nio.IntBuffer textures)

        mgl.glDeleteTextures(n, textures);
public voidglDepthFunc(int func)

        mgl.glDepthFunc(func);
public voidglDepthMask(boolean flag)

        mgl.glDepthMask(flag);
public voidglDepthRangef(float near, float far)

        mgl.glDepthRangef(near, far);
public voidglDepthRangex(int near, int far)

        mgl.glDepthRangex(near, far);
public voidglDisable(int cap)

        mgl.glDisable(cap);
public voidglDisableClientState(int array)

        mgl.glDisableClientState(array);
public voidglDrawArrays(int mode, int first, int count)

        mgl.glDrawArrays(mode, first, count);
public voidglDrawElements(int mode, int count, int type, int offset)

        throw new UnsupportedOperationException();
public voidglDrawElements(int mode, int count, int type, java.nio.Buffer indices)

        mgl.glDrawElements(mode, count, type, indices);
public voidglDrawTexfOES(float x, float y, float z, float width, float height)

        mgl11Ext.glDrawTexfOES(x, y, z, width, height);
public voidglDrawTexfvOES(float[] coords, int offset)

        mgl11Ext.glDrawTexfvOES(coords, offset);
public voidglDrawTexfvOES(java.nio.FloatBuffer coords)

        mgl11Ext.glDrawTexfvOES(coords);
public voidglDrawTexiOES(int x, int y, int z, int width, int height)

        mgl11Ext.glDrawTexiOES(x, y, z, width, height);
public voidglDrawTexivOES(int[] coords, int offset)

        mgl11Ext.glDrawTexivOES(coords, offset);
public voidglDrawTexivOES(java.nio.IntBuffer coords)

        mgl11Ext.glDrawTexivOES(coords);
public voidglDrawTexsOES(short x, short y, short z, short width, short height)

        mgl11Ext.glDrawTexsOES(x, y, z, width, height);
public voidglDrawTexsvOES(short[] coords, int offset)

        mgl11Ext.glDrawTexsvOES(coords, offset);
public voidglDrawTexsvOES(java.nio.ShortBuffer coords)

        mgl11Ext.glDrawTexsvOES(coords);
public voidglDrawTexxOES(int x, int y, int z, int width, int height)

        mgl11Ext.glDrawTexxOES(x, y, z, width, height);
public voidglDrawTexxvOES(int[] coords, int offset)

        mgl11Ext.glDrawTexxvOES(coords, offset);
public voidglDrawTexxvOES(java.nio.IntBuffer coords)

        mgl11Ext.glDrawTexxvOES(coords);
public voidglEnable(int cap)

        mgl.glEnable(cap);
public voidglEnableClientState(int array)

        mgl.glEnableClientState(array);
public voidglFinish()

        mgl.glFinish();
public voidglFlush()

        mgl.glFlush();
public voidglFogf(int pname, float param)

        mgl.glFogf(pname, param);
public voidglFogfv(int pname, float[] params, int offset)

        mgl.glFogfv(pname, params, offset);
public voidglFogfv(int pname, java.nio.FloatBuffer params)

        mgl.glFogfv(pname, params);
public voidglFogx(int pname, int param)

        mgl.glFogx(pname, param);
public voidglFogxv(int pname, int[] params, int offset)

        mgl.glFogxv(pname, params, offset);
public voidglFogxv(int pname, java.nio.IntBuffer params)

        mgl.glFogxv(pname, params);
public voidglFrontFace(int mode)

        mgl.glFrontFace(mode);
public voidglFrustumf(float left, float right, float bottom, float top, float near, float far)

        mCurrent.glFrustumf(left, right, bottom, top, near, far);
        mgl.glFrustumf(left, right, bottom, top, near, far);
        if ( _check) check();
public voidglFrustumx(int left, int right, int bottom, int top, int near, int far)

        mCurrent.glFrustumx(left, right, bottom, top, near, far);
        mgl.glFrustumx(left, right, bottom, top, near, far);
        if ( _check) check();
public voidglGenBuffers(int n, int[] buffers, int offset)

        throw new UnsupportedOperationException();
public voidglGenBuffers(int n, java.nio.IntBuffer buffers)

        throw new UnsupportedOperationException();
public voidglGenTextures(int n, int[] textures, int offset)

        mgl.glGenTextures(n, textures, offset);
public voidglGenTextures(int n, java.nio.IntBuffer textures)

        mgl.glGenTextures(n, textures);
public voidglGetBooleanv(int pname, boolean[] params, int offset)

        throw new UnsupportedOperationException();
public voidglGetBooleanv(int pname, java.nio.IntBuffer params)

        throw new UnsupportedOperationException();
public voidglGetBufferParameteriv(int target, int pname, int[] params, int offset)

        throw new UnsupportedOperationException();
public voidglGetBufferParameteriv(int target, int pname, java.nio.IntBuffer params)

        throw new UnsupportedOperationException();
public voidglGetClipPlanef(int pname, float[] eqn, int offset)

        throw new UnsupportedOperationException();
public voidglGetClipPlanef(int pname, java.nio.FloatBuffer eqn)

        throw new UnsupportedOperationException();
public voidglGetClipPlanex(int pname, int[] eqn, int offset)

        throw new UnsupportedOperationException();
public voidglGetClipPlanex(int pname, java.nio.IntBuffer eqn)

        throw new UnsupportedOperationException();
public intglGetError()

        int result = mgl.glGetError();
        return result;
public voidglGetFixedv(int pname, int[] params, int offset)

        throw new UnsupportedOperationException();
public voidglGetFixedv(int pname, java.nio.IntBuffer params)

        throw new UnsupportedOperationException();
public voidglGetFloatv(int pname, float[] params, int offset)

        throw new UnsupportedOperationException();
public voidglGetFloatv(int pname, java.nio.FloatBuffer params)

        throw new UnsupportedOperationException();
public voidglGetIntegerv(int pname, int[] params, int offset)

        mgl.glGetIntegerv(pname, params, offset);
public voidglGetIntegerv(int pname, java.nio.IntBuffer params)

        mgl.glGetIntegerv(pname, params);
public voidglGetLightfv(int light, int pname, float[] params, int offset)

        throw new UnsupportedOperationException();
public voidglGetLightfv(int light, int pname, java.nio.FloatBuffer params)

        throw new UnsupportedOperationException();
public voidglGetLightxv(int light, int pname, int[] params, int offset)

        throw new UnsupportedOperationException();
public voidglGetLightxv(int light, int pname, java.nio.IntBuffer params)

        throw new UnsupportedOperationException();
public voidglGetMaterialfv(int face, int pname, float[] params, int offset)

        throw new UnsupportedOperationException();
public voidglGetMaterialfv(int face, int pname, java.nio.FloatBuffer params)

        throw new UnsupportedOperationException();
public voidglGetMaterialxv(int face, int pname, int[] params, int offset)

        throw new UnsupportedOperationException();
public voidglGetMaterialxv(int face, int pname, java.nio.IntBuffer params)

        throw new UnsupportedOperationException();
public voidglGetPointerv(int pname, java.nio.Buffer[] params)

        throw new UnsupportedOperationException();
public java.lang.StringglGetString(int name)

        String result = mgl.glGetString(name);
        return result;
public voidglGetTexEnviv(int env, int pname, int[] params, int offset)

        throw new UnsupportedOperationException();
public voidglGetTexEnviv(int env, int pname, java.nio.IntBuffer params)

        throw new UnsupportedOperationException();
public voidglGetTexEnvxv(int env, int pname, int[] params, int offset)

        throw new UnsupportedOperationException();
public voidglGetTexEnvxv(int env, int pname, java.nio.IntBuffer params)

        throw new UnsupportedOperationException();
public voidglGetTexParameterfv(int target, int pname, float[] params, int offset)

        throw new UnsupportedOperationException();
public voidglGetTexParameterfv(int target, int pname, java.nio.FloatBuffer params)

        throw new UnsupportedOperationException();
public voidglGetTexParameteriv(int target, int pname, int[] params, int offset)

        throw new UnsupportedOperationException();
public voidglGetTexParameteriv(int target, int pname, java.nio.IntBuffer params)

        throw new UnsupportedOperationException();
public voidglGetTexParameterxv(int target, int pname, int[] params, int offset)

        throw new UnsupportedOperationException();
public voidglGetTexParameterxv(int target, int pname, java.nio.IntBuffer params)

        throw new UnsupportedOperationException();
public voidglHint(int target, int mode)

        mgl.glHint(target, mode);
public booleanglIsBuffer(int buffer)

        throw new UnsupportedOperationException();
public booleanglIsEnabled(int cap)

        throw new UnsupportedOperationException();
public booleanglIsTexture(int texture)

        throw new UnsupportedOperationException();
public voidglLightModelf(int pname, float param)

        mgl.glLightModelf(pname, param);
public voidglLightModelfv(int pname, float[] params, int offset)

        mgl.glLightModelfv(pname, params, offset);
public voidglLightModelfv(int pname, java.nio.FloatBuffer params)

        mgl.glLightModelfv(pname, params);
public voidglLightModelx(int pname, int param)

        mgl.glLightModelx(pname, param);
public voidglLightModelxv(int pname, int[] params, int offset)

        mgl.glLightModelxv(pname, params, offset);
public voidglLightModelxv(int pname, java.nio.IntBuffer params)

        mgl.glLightModelxv(pname, params);
public voidglLightf(int light, int pname, float param)

        mgl.glLightf(light, pname, param);
public voidglLightfv(int light, int pname, float[] params, int offset)

        mgl.glLightfv(light, pname, params, offset);
public voidglLightfv(int light, int pname, java.nio.FloatBuffer params)

        mgl.glLightfv(light, pname, params);
public voidglLightx(int light, int pname, int param)

        mgl.glLightx(light, pname, param);
public voidglLightxv(int light, int pname, int[] params, int offset)

        mgl.glLightxv(light, pname, params, offset);
public voidglLightxv(int light, int pname, java.nio.IntBuffer params)

        mgl.glLightxv(light, pname, params);
public voidglLineWidth(float width)

        mgl.glLineWidth(width);
public voidglLineWidthx(int width)

        mgl.glLineWidthx(width);
public voidglLoadIdentity()

        mCurrent.glLoadIdentity();
        mgl.glLoadIdentity();
        if ( _check) check();
public voidglLoadMatrixf(float[] m, int offset)

        mCurrent.glLoadMatrixf(m, offset);
        mgl.glLoadMatrixf(m, offset);
        if ( _check) check();
public voidglLoadMatrixf(java.nio.FloatBuffer m)

        int position = m.position();
        mCurrent.glLoadMatrixf(m);
        m.position(position);
        mgl.glLoadMatrixf(m);
        if ( _check) check();
public voidglLoadMatrixx(int[] m, int offset)

        mCurrent.glLoadMatrixx(m, offset);
        mgl.glLoadMatrixx(m, offset);
        if ( _check) check();
public voidglLoadMatrixx(java.nio.IntBuffer m)

        int position = m.position();
        mCurrent.glLoadMatrixx(m);
        m.position(position);
        mgl.glLoadMatrixx(m);
        if ( _check) check();
public voidglLoadPaletteFromModelViewMatrixOES()

        throw new UnsupportedOperationException();
public voidglLogicOp(int opcode)

        mgl.glLogicOp(opcode);
public voidglMaterialf(int face, int pname, float param)

        mgl.glMaterialf(face, pname, param);
public voidglMaterialfv(int face, int pname, float[] params, int offset)

        mgl.glMaterialfv(face, pname, params, offset);
public voidglMaterialfv(int face, int pname, java.nio.FloatBuffer params)

        mgl.glMaterialfv(face, pname, params);
public voidglMaterialx(int face, int pname, int param)

        mgl.glMaterialx(face, pname, param);
public voidglMaterialxv(int face, int pname, int[] params, int offset)

        mgl.glMaterialxv(face, pname, params, offset);
public voidglMaterialxv(int face, int pname, java.nio.IntBuffer params)

        mgl.glMaterialxv(face, pname, params);
public voidglMatrixIndexPointerOES(int size, int type, int stride, java.nio.Buffer pointer)

        throw new UnsupportedOperationException();
public voidglMatrixIndexPointerOES(int size, int type, int stride, int offset)

        throw new UnsupportedOperationException();
public voidglMatrixMode(int mode)

        switch (mode) {
        case GL10.GL_MODELVIEW:
            mCurrent = mModelView;
            break;
        case GL10.GL_TEXTURE:
            mCurrent = mTexture;
            break;
        case GL10.GL_PROJECTION:
            mCurrent = mProjection;
            break;
        default:
            throw new IllegalArgumentException("Unknown matrix mode: " + mode);
        }
        mgl.glMatrixMode(mode);
        mMatrixMode = mode;
        if ( _check) check();
public voidglMultMatrixf(float[] m, int offset)

        mCurrent.glMultMatrixf(m, offset);
        mgl.glMultMatrixf(m, offset);
        if ( _check) check();
public voidglMultMatrixf(java.nio.FloatBuffer m)

        int position = m.position();
        mCurrent.glMultMatrixf(m);
        m.position(position);
        mgl.glMultMatrixf(m);
        if ( _check) check();
public voidglMultMatrixx(int[] m, int offset)

        mCurrent.glMultMatrixx(m, offset);
        mgl.glMultMatrixx(m, offset);
        if ( _check) check();
public voidglMultMatrixx(java.nio.IntBuffer m)

        int position = m.position();
        mCurrent.glMultMatrixx(m);
        m.position(position);
        mgl.glMultMatrixx(m);
        if ( _check) check();
public voidglMultiTexCoord4f(int target, float s, float t, float r, float q)

        mgl.glMultiTexCoord4f(target, s, t, r, q);
public voidglMultiTexCoord4x(int target, int s, int t, int r, int q)

        mgl.glMultiTexCoord4x(target, s, t, r, q);
public voidglNormal3f(float nx, float ny, float nz)

        mgl.glNormal3f(nx, ny, nz);
public voidglNormal3x(int nx, int ny, int nz)

        mgl.glNormal3x(nx, ny, nz);
public voidglNormalPointer(int type, int stride, int offset)

        throw new UnsupportedOperationException();
public voidglNormalPointer(int type, int stride, java.nio.Buffer pointer)

        mgl.glNormalPointer(type, stride, pointer);
public voidglOrthof(float left, float right, float bottom, float top, float near, float far)

        mCurrent.glOrthof(left, right, bottom, top, near, far);
        mgl.glOrthof(left, right, bottom, top, near, far);
        if ( _check) check();
public voidglOrthox(int left, int right, int bottom, int top, int near, int far)

        mCurrent.glOrthox(left, right, bottom, top, near, far);
        mgl.glOrthox(left, right, bottom, top, near, far);
        if ( _check) check();
public voidglPixelStorei(int pname, int param)

        mgl.glPixelStorei(pname, param);
public voidglPointParameterf(int pname, float param)

        throw new UnsupportedOperationException();
public voidglPointParameterfv(int pname, float[] params, int offset)

        throw new UnsupportedOperationException();
public voidglPointParameterfv(int pname, java.nio.FloatBuffer params)

        throw new UnsupportedOperationException();
public voidglPointParameterx(int pname, int param)

        throw new UnsupportedOperationException();
public voidglPointParameterxv(int pname, int[] params, int offset)

        throw new UnsupportedOperationException();
public voidglPointParameterxv(int pname, java.nio.IntBuffer params)

        throw new UnsupportedOperationException();
public voidglPointSize(float size)

        mgl.glPointSize(size);
public voidglPointSizePointerOES(int type, int stride, java.nio.Buffer pointer)

        throw new UnsupportedOperationException();
public voidglPointSizex(int size)

        mgl.glPointSizex(size);
public voidglPolygonOffset(float factor, float units)

        mgl.glPolygonOffset(factor, units);
public voidglPolygonOffsetx(int factor, int units)

        mgl.glPolygonOffsetx(factor, units);
public voidglPopMatrix()

        mCurrent.glPopMatrix();
        mgl.glPopMatrix();
        if ( _check) check();
public voidglPushMatrix()

        mCurrent.glPushMatrix();
        mgl.glPushMatrix();
        if ( _check) check();
public intglQueryMatrixxOES(int[] mantissa, int mantissaOffset, int[] exponent, int exponentOffset)

        return mgl10Ext.glQueryMatrixxOES(mantissa, mantissaOffset,
            exponent, exponentOffset);
public intglQueryMatrixxOES(java.nio.IntBuffer mantissa, java.nio.IntBuffer exponent)

        return mgl10Ext.glQueryMatrixxOES(mantissa, exponent);
public voidglReadPixels(int x, int y, int width, int height, int format, int type, java.nio.Buffer pixels)

        mgl.glReadPixels(x, y, width, height, format, type, pixels);
public voidglRotatef(float angle, float x, float y, float z)

        mCurrent.glRotatef(angle, x, y, z);
        mgl.glRotatef(angle, x, y, z);
        if ( _check) check();
public voidglRotatex(int angle, int x, int y, int z)

        mCurrent.glRotatex(angle, x, y, z);
        mgl.glRotatex(angle, x, y, z);
        if ( _check) check();
public voidglSampleCoverage(float value, boolean invert)

        mgl.glSampleCoverage(value, invert);
public voidglSampleCoveragex(int value, boolean invert)

        mgl.glSampleCoveragex(value, invert);
public voidglScalef(float x, float y, float z)

        mCurrent.glScalef(x, y, z);
        mgl.glScalef(x, y, z);
        if ( _check) check();
public voidglScalex(int x, int y, int z)

        mCurrent.glScalex(x, y, z);
        mgl.glScalex(x, y, z);
        if ( _check) check();
public voidglScissor(int x, int y, int width, int height)

        mgl.glScissor(x, y, width, height);
public voidglShadeModel(int mode)

        mgl.glShadeModel(mode);
public voidglStencilFunc(int func, int ref, int mask)

        mgl.glStencilFunc(func, ref, mask);
public voidglStencilMask(int mask)

        mgl.glStencilMask(mask);
public voidglStencilOp(int fail, int zfail, int zpass)

        mgl.glStencilOp(fail, zfail, zpass);
public voidglTexCoordPointer(int size, int type, int stride, java.nio.Buffer pointer)

        mgl.glTexCoordPointer(size, type, stride, pointer);
public voidglTexCoordPointer(int size, int type, int stride, int offset)

        throw new UnsupportedOperationException();
public voidglTexEnvf(int target, int pname, float param)

        mgl.glTexEnvf(target, pname, param);
public voidglTexEnvfv(int target, int pname, float[] params, int offset)

        mgl.glTexEnvfv(target, pname, params, offset);
public voidglTexEnvfv(int target, int pname, java.nio.FloatBuffer params)

        mgl.glTexEnvfv(target, pname, params);
public voidglTexEnvi(int target, int pname, int param)

        throw new UnsupportedOperationException();
public voidglTexEnviv(int target, int pname, int[] params, int offset)

        throw new UnsupportedOperationException();
public voidglTexEnviv(int target, int pname, java.nio.IntBuffer params)

        throw new UnsupportedOperationException();
public voidglTexEnvx(int target, int pname, int param)

        mgl.glTexEnvx(target, pname, param);
public voidglTexEnvxv(int target, int pname, int[] params, int offset)

        mgl.glTexEnvxv(target, pname, params, offset);
public voidglTexEnvxv(int target, int pname, java.nio.IntBuffer params)

        mgl.glTexEnvxv(target, pname, params);
public voidglTexImage2D(int target, int level, int internalformat, int width, int height, int border, int format, int type, java.nio.Buffer pixels)

        mgl.glTexImage2D(target, level, internalformat, width, height, border,
                format, type, pixels);
public voidglTexParameterf(int target, int pname, float param)

        mgl.glTexParameterf(target, pname, param);
public voidglTexParameterfv(int target, int pname, float[] params, int offset)

        throw new UnsupportedOperationException();
public voidglTexParameterfv(int target, int pname, java.nio.FloatBuffer params)

        throw new UnsupportedOperationException();
public voidglTexParameteri(int target, int pname, int param)

        throw new UnsupportedOperationException();
public voidglTexParameteriv(int target, int pname, int[] params, int offset)

        mgl11.glTexParameteriv(target, pname, params, offset);
public voidglTexParameteriv(int target, int pname, java.nio.IntBuffer params)

        mgl11.glTexParameteriv(target, pname, params);
public voidglTexParameterx(int target, int pname, int param)

        mgl.glTexParameterx(target, pname, param);
public voidglTexParameterxv(int target, int pname, int[] params, int offset)

        throw new UnsupportedOperationException();
public voidglTexParameterxv(int target, int pname, java.nio.IntBuffer params)

        throw new UnsupportedOperationException();
public voidglTexSubImage2D(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, java.nio.Buffer pixels)

        mgl.glTexSubImage2D(target, level, xoffset, yoffset, width, height,
                format, type, pixels);
public voidglTranslatef(float x, float y, float z)

        mCurrent.glTranslatef(x, y, z);
        mgl.glTranslatef(x, y, z);
        if ( _check) check();
public voidglTranslatex(int x, int y, int z)

        mCurrent.glTranslatex(x, y, z);
        mgl.glTranslatex(x, y, z);
        if ( _check) check();
public voidglVertexPointer(int size, int type, int stride, java.nio.Buffer pointer)

        mgl.glVertexPointer(size, type, stride, pointer);
public voidglVertexPointer(int size, int type, int stride, int offset)

        throw new UnsupportedOperationException();
public voidglViewport(int x, int y, int width, int height)

        mgl.glViewport(x, y, width, height);
public voidglWeightPointerOES(int size, int type, int stride, java.nio.Buffer pointer)

        throw new UnsupportedOperationException();
public voidglWeightPointerOES(int size, int type, int stride, int offset)

        throw new UnsupportedOperationException();