nicer gl api

- java class name should suffice as namespace
- also use import static gl instance seems to work now with Gwt
This commit is contained in:
Hannes Janetzek
2014-10-04 06:48:18 +02:00
parent b2008aa086
commit 846d90f9fe
43 changed files with 2839 additions and 1491 deletions

View File

@@ -20,585 +20,585 @@ import java.nio.Buffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import org.oscim.backend.GL20;
import org.oscim.backend.GL;
import android.annotation.SuppressLint;
import android.opengl.GLES20;
@SuppressLint("NewApi")
public class AndroidGL implements GL20 {
public class AndroidGL implements GL {
@Override
public void glAttachShader(int program, int shader) {
public void attachShader(int program, int shader) {
GLES20.glAttachShader(program, shader);
}
@Override
public void glBindAttribLocation(int program, int index, String name) {
public void bindAttribLocation(int program, int index, String name) {
GLES20.glBindAttribLocation(program, index, name);
}
@Override
public void glBindBuffer(int target, int buffer) {
public void bindBuffer(int target, int buffer) {
GLES20.glBindBuffer(target, buffer);
}
@Override
public void glBindFramebuffer(int target, int framebuffer) {
public void bindFramebuffer(int target, int framebuffer) {
GLES20.glBindFramebuffer(target, framebuffer);
}
@Override
public void glBindRenderbuffer(int target, int renderbuffer) {
public void bindRenderbuffer(int target, int renderbuffer) {
GLES20.glBindRenderbuffer(target, renderbuffer);
}
@Override
public void glBlendColor(float red, float green, float blue, float alpha) {
public void blendColor(float red, float green, float blue, float alpha) {
GLES20.glBlendColor(red, green, blue, alpha);
}
@Override
public void glBlendEquation(int mode) {
public void blendEquation(int mode) {
GLES20.glBlendEquation(mode);
}
@Override
public void glBlendEquationSeparate(int modeRGB, int modeAlpha) {
public void blendEquationSeparate(int modeRGB, int modeAlpha) {
GLES20.glBlendEquationSeparate(modeRGB, modeAlpha);
}
@Override
public void glBlendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) {
public void blendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) {
GLES20.glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
}
@Override
public void glBufferData(int target, int size, Buffer data, int usage) {
public void bufferData(int target, int size, Buffer data, int usage) {
GLES20.glBufferData(target, size, data, usage);
}
@Override
public void glBufferSubData(int target, int offset, int size, Buffer data) {
public void bufferSubData(int target, int offset, int size, Buffer data) {
GLES20.glBufferSubData(target, offset, size, data);
}
@Override
public int glCheckFramebufferStatus(int target) {
public int checkFramebufferStatus(int target) {
return GLES20.glCheckFramebufferStatus(target);
}
@Override
public void glCompileShader(int shader) {
public void compileShader(int shader) {
GLES20.glCompileShader(shader);
}
@Override
public int glCreateProgram() {
public int createProgram() {
return GLES20.glCreateProgram();
}
@Override
public int glCreateShader(int type) {
public int createShader(int type) {
return GLES20.glCreateShader(type);
}
@Override
public void glDeleteBuffers(int n, IntBuffer buffers) {
public void deleteBuffers(int n, IntBuffer buffers) {
GLES20.glDeleteBuffers(n, buffers);
}
@Override
public void glDeleteFramebuffers(int n, IntBuffer framebuffers) {
public void deleteFramebuffers(int n, IntBuffer framebuffers) {
GLES20.glDeleteFramebuffers(n, framebuffers);
}
@Override
public void glDeleteProgram(int program) {
public void deleteProgram(int program) {
GLES20.glDeleteProgram(program);
}
@Override
public void glDeleteRenderbuffers(int n, IntBuffer renderbuffers) {
public void deleteRenderbuffers(int n, IntBuffer renderbuffers) {
GLES20.glDeleteRenderbuffers(n, renderbuffers);
}
@Override
public void glDeleteShader(int shader) {
public void deleteShader(int shader) {
GLES20.glDeleteShader(shader);
}
@Override
public void glDetachShader(int program, int shader) {
public void detachShader(int program, int shader) {
GLES20.glDetachShader(program, shader);
}
@Override
public void glDisableVertexAttribArray(int index) {
public void disableVertexAttribArray(int index) {
GLES20.glDisableVertexAttribArray(index);
}
@Override
public void glDrawElements(int mode, int count, int type, int offset) {
public void drawElements(int mode, int count, int type, int offset) {
GLES20.glDrawElements(mode, count, type, offset);
}
@Override
public void glEnableVertexAttribArray(int index) {
public void enableVertexAttribArray(int index) {
GLES20.glEnableVertexAttribArray(index);
}
@Override
public void glFramebufferRenderbuffer(int target, int attachment, int renderbuffertarget,
public void framebufferRenderbuffer(int target, int attachment, int renderbuffertarget,
int renderbuffer) {
GLES20.glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
@Override
public void glFramebufferTexture2D(int target, int attachment, int textarget, int texture,
public void framebufferTexture2D(int target, int attachment, int textarget, int texture,
int level) {
GLES20.glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
@Override
public void glGenBuffers(int n, IntBuffer buffers) {
public void genBuffers(int n, IntBuffer buffers) {
GLES20.glGenBuffers(n, buffers);
}
@Override
public void glGenerateMipmap(int target) {
public void generateMipmap(int target) {
GLES20.glGenerateMipmap(target);
}
@Override
public void glGenFramebuffers(int n, IntBuffer framebuffers) {
public void genFramebuffers(int n, IntBuffer framebuffers) {
GLES20.glGenFramebuffers(n, framebuffers);
}
@Override
public void glGenRenderbuffers(int n, IntBuffer renderbuffers) {
public void genRenderbuffers(int n, IntBuffer renderbuffers) {
GLES20.glGenRenderbuffers(n, renderbuffers);
}
@Override
public String glGetActiveAttrib(int program, int index, IntBuffer size, Buffer type) {
public String getActiveAttrib(int program, int index, IntBuffer size, Buffer type) {
return GLES20.glGetActiveAttrib(program, index, size, (IntBuffer) type);
}
@Override
public String glGetActiveUniform(int program, int index, IntBuffer size, Buffer type) {
public String getActiveUniform(int program, int index, IntBuffer size, Buffer type) {
//return GLES20.glGetActiveUniform(program, index, bufsize, length, size, type, name);
throw new UnsupportedOperationException("missing implementation");
}
@Override
public void glGetAttachedShaders(int program, int maxcount, Buffer count, IntBuffer shaders) {
public void getAttachedShaders(int program, int maxcount, Buffer count, IntBuffer shaders) {
throw new UnsupportedOperationException("missing implementation");
//GLES20.glGetAttachedShaders(program, maxcount, count, shaders);
}
@Override
public int glGetAttribLocation(int program, String name) {
public int getAttribLocation(int program, String name) {
return GLES20.glGetAttribLocation(program, name);
}
@Override
public void glGetBooleanv(int pname, Buffer params) {
public void getBooleanv(int pname, Buffer params) {
throw new UnsupportedOperationException("missing implementation");
//GLES20.glGetBooleanv(pname, params);
}
@Override
public void glGetBufferParameteriv(int target, int pname, IntBuffer params) {
public void getBufferParameteriv(int target, int pname, IntBuffer params) {
GLES20.glGetBufferParameteriv(target, pname, params);
}
@Override
public void glGetFloatv(int pname, FloatBuffer params) {
public void getFloatv(int pname, FloatBuffer params) {
GLES20.glGetFloatv(pname, params);
}
@Override
public void glGetFramebufferAttachmentParameteriv(int target, int attachment, int pname,
public void getFramebufferAttachmentParameteriv(int target, int attachment, int pname,
IntBuffer params) {
GLES20.glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
}
@Override
public void glGetProgramiv(int program, int pname, IntBuffer params) {
public void getProgramiv(int program, int pname, IntBuffer params) {
GLES20.glGetProgramiv(program, pname, params);
}
@Override
public String glGetProgramInfoLog(int program) {
public String getProgramInfoLog(int program) {
return GLES20.glGetProgramInfoLog(program);
}
@Override
public void glGetRenderbufferParameteriv(int target, int pname, IntBuffer params) {
public void getRenderbufferParameteriv(int target, int pname, IntBuffer params) {
GLES20.glGetRenderbufferParameteriv(target, pname, params);
}
@Override
public void glGetShaderiv(int shader, int pname, IntBuffer params) {
public void getShaderiv(int shader, int pname, IntBuffer params) {
GLES20.glGetShaderiv(shader, pname, params);
}
@Override
public String glGetShaderInfoLog(int shader) {
public String getShaderInfoLog(int shader) {
return GLES20.glGetShaderInfoLog(shader);
}
@Override
public void glGetShaderPrecisionFormat(int shadertype, int precisiontype, IntBuffer range,
public void getShaderPrecisionFormat(int shadertype, int precisiontype, IntBuffer range,
IntBuffer precision) {
GLES20.glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
}
@Override
public void glGetShaderSource(int shader, int bufsize, Buffer length, String source) {
public void getShaderSource(int shader, int bufsize, Buffer length, String source) {
throw new UnsupportedOperationException("missing implementation");
}
@Override
public void glGetTexParameterfv(int target, int pname, FloatBuffer params) {
public void getTexParameterfv(int target, int pname, FloatBuffer params) {
GLES20.glGetTexParameterfv(target, pname, params);
}
@Override
public void glGetTexParameteriv(int target, int pname, IntBuffer params) {
public void getTexParameteriv(int target, int pname, IntBuffer params) {
GLES20.glGetTexParameteriv(target, pname, params);
}
@Override
public void glGetUniformfv(int program, int location, FloatBuffer params) {
public void getUniformfv(int program, int location, FloatBuffer params) {
GLES20.glGetUniformfv(program, location, params);
}
@Override
public void glGetUniformiv(int program, int location, IntBuffer params) {
public void getUniformiv(int program, int location, IntBuffer params) {
GLES20.glGetUniformiv(program, location, params);
}
@Override
public int glGetUniformLocation(int program, String name) {
public int getUniformLocation(int program, String name) {
return GLES20.glGetUniformLocation(program, name);
}
@Override
public void glGetVertexAttribfv(int index, int pname, FloatBuffer params) {
public void getVertexAttribfv(int index, int pname, FloatBuffer params) {
GLES20.glGetVertexAttribfv(index, pname, params);
}
@Override
public void glGetVertexAttribiv(int index, int pname, IntBuffer params) {
public void getVertexAttribiv(int index, int pname, IntBuffer params) {
GLES20.glGetVertexAttribiv(index, pname, params);
}
@Override
public void glGetVertexAttribPointerv(int index, int pname, Buffer pointer) {
public void getVertexAttribPointerv(int index, int pname, Buffer pointer) {
//GLES20.glGetVertexAttribPointerv(index, pname, pointer);
throw new UnsupportedOperationException("missing implementation");
}
@Override
public boolean glIsBuffer(int buffer) {
public boolean isBuffer(int buffer) {
return GLES20.glIsBuffer(buffer);
}
@Override
public boolean glIsEnabled(int cap) {
public boolean isEnabled(int cap) {
return GLES20.glIsEnabled(cap);
}
@Override
public boolean glIsFramebuffer(int framebuffer) {
public boolean isFramebuffer(int framebuffer) {
return GLES20.glIsFramebuffer(framebuffer);
}
@Override
public boolean glIsProgram(int program) {
public boolean isProgram(int program) {
return GLES20.glIsProgram(program);
}
@Override
public boolean glIsRenderbuffer(int renderbuffer) {
public boolean isRenderbuffer(int renderbuffer) {
return GLES20.glIsRenderbuffer(renderbuffer);
}
@Override
public boolean glIsShader(int shader) {
public boolean isShader(int shader) {
return GLES20.glIsShader(shader);
}
@Override
public boolean glIsTexture(int texture) {
public boolean isTexture(int texture) {
return GLES20.glIsTexture(texture);
}
@Override
public void glLinkProgram(int program) {
public void linkProgram(int program) {
GLES20.glLinkProgram(program);
}
@Override
public void glReleaseShaderCompiler() {
public void releaseShaderCompiler() {
GLES20.glReleaseShaderCompiler();
}
@Override
public void glRenderbufferStorage(int target, int internalformat, int width, int height) {
public void renderbufferStorage(int target, int internalformat, int width, int height) {
GLES20.glRenderbufferStorage(target, internalformat, width, height);
}
@Override
public void glSampleCoverage(float value, boolean invert) {
public void sampleCoverage(float value, boolean invert) {
GLES20.glSampleCoverage(value, invert);
}
@Override
public void glShaderBinary(int n, IntBuffer shaders, int binaryformat, Buffer binary, int length) {
public void shaderBinary(int n, IntBuffer shaders, int binaryformat, Buffer binary, int length) {
GLES20.glShaderBinary(n, shaders, binaryformat, binary, length);
}
@Override
public void glShaderSource(int shader, String string) {
public void shaderSource(int shader, String string) {
GLES20.glShaderSource(shader, string);
}
@Override
public void glStencilFuncSeparate(int face, int func, int ref, int mask) {
public void stencilFuncSeparate(int face, int func, int ref, int mask) {
GLES20.glStencilFuncSeparate(face, func, ref, mask);
}
@Override
public void glStencilMaskSeparate(int face, int mask) {
public void stencilMaskSeparate(int face, int mask) {
GLES20.glStencilMaskSeparate(face, mask);
}
@Override
public void glStencilOpSeparate(int face, int fail, int zfail, int zpass) {
public void stencilOpSeparate(int face, int fail, int zfail, int zpass) {
GLES20.glStencilOpSeparate(face, fail, zfail, zpass);
}
@Override
public void glTexParameterfv(int target, int pname, FloatBuffer params) {
public void texParameterfv(int target, int pname, FloatBuffer params) {
GLES20.glTexParameterfv(target, pname, params);
}
@Override
public void glTexParameteri(int target, int pname, int param) {
public void texParameteri(int target, int pname, int param) {
GLES20.glTexParameteri(target, pname, param);
}
@Override
public void glTexParameteriv(int target, int pname, IntBuffer params) {
public void texParameteriv(int target, int pname, IntBuffer params) {
GLES20.glTexParameteriv(target, pname, params);
}
@Override
public void glUniform1f(int location, float x) {
public void uniform1f(int location, float x) {
GLES20.glUniform1f(location, x);
}
@Override
public void glUniform1fv(int location, int count, FloatBuffer v) {
public void uniform1fv(int location, int count, FloatBuffer v) {
GLES20.glUniform1fv(location, count, v);
}
@Override
public void glUniform1i(int location, int x) {
public void uniform1i(int location, int x) {
GLES20.glUniform1i(location, x);
}
@Override
public void glUniform1iv(int location, int count, IntBuffer v) {
public void uniform1iv(int location, int count, IntBuffer v) {
GLES20.glUniform1iv(location, count, v);
}
@Override
public void glUniform2f(int location, float x, float y) {
public void uniform2f(int location, float x, float y) {
GLES20.glUniform2f(location, x, y);
}
@Override
public void glUniform2fv(int location, int count, FloatBuffer v) {
public void uniform2fv(int location, int count, FloatBuffer v) {
GLES20.glUniform2fv(location, count, v);
}
@Override
public void glUniform2i(int location, int x, int y) {
public void uniform2i(int location, int x, int y) {
GLES20.glUniform2i(location, x, y);
}
@Override
public void glUniform2iv(int location, int count, IntBuffer v) {
public void uniform2iv(int location, int count, IntBuffer v) {
GLES20.glUniform2iv(location, count, v);
}
@Override
public void glUniform3f(int location, float x, float y, float z) {
public void uniform3f(int location, float x, float y, float z) {
GLES20.glUniform3f(location, x, y, z);
}
@Override
public void glUniform3fv(int location, int count, FloatBuffer v) {
public void uniform3fv(int location, int count, FloatBuffer v) {
GLES20.glUniform3fv(location, count, v);
}
@Override
public void glUniform3i(int location, int x, int y, int z) {
public void uniform3i(int location, int x, int y, int z) {
GLES20.glUniform3i(location, x, y, z);
}
@Override
public void glUniform3iv(int location, int count, IntBuffer v) {
public void uniform3iv(int location, int count, IntBuffer v) {
GLES20.glUniform3iv(location, count, v);
}
@Override
public void glUniform4f(int location, float x, float y, float z, float w) {
public void uniform4f(int location, float x, float y, float z, float w) {
GLES20.glUniform4f(location, x, y, z, w);
}
@Override
public void glUniform4fv(int location, int count, FloatBuffer v) {
public void uniform4fv(int location, int count, FloatBuffer v) {
GLES20.glUniform4fv(location, count, v);
}
@Override
public void glUniform4i(int location, int x, int y, int z, int w) {
public void uniform4i(int location, int x, int y, int z, int w) {
GLES20.glUniform4i(location, x, y, z, w);
}
@Override
public void glUniform4iv(int location, int count, IntBuffer v) {
public void uniform4iv(int location, int count, IntBuffer v) {
GLES20.glUniform4iv(location, count, v);
}
@Override
public void glUniformMatrix2fv(int location, int count, boolean transpose, FloatBuffer value) {
public void uniformMatrix2fv(int location, int count, boolean transpose, FloatBuffer value) {
GLES20.glUniformMatrix2fv(location, count, transpose, value);
}
@Override
public void glUniformMatrix3fv(int location, int count, boolean transpose, FloatBuffer value) {
public void uniformMatrix3fv(int location, int count, boolean transpose, FloatBuffer value) {
GLES20.glUniformMatrix3fv(location, count, transpose, value);
}
@Override
public void glUniformMatrix4fv(int location, int count, boolean transpose, FloatBuffer value) {
public void uniformMatrix4fv(int location, int count, boolean transpose, FloatBuffer value) {
GLES20.glUniformMatrix4fv(location, count, transpose, value);
}
@Override
public void glUseProgram(int program) {
public void useProgram(int program) {
GLES20.glUseProgram(program);
}
@Override
public void glValidateProgram(int program) {
public void validateProgram(int program) {
GLES20.glValidateProgram(program);
}
@Override
public void glVertexAttrib1f(int indx, float x) {
public void vertexAttrib1f(int indx, float x) {
GLES20.glVertexAttrib1f(indx, x);
}
@Override
public void glVertexAttrib1fv(int indx, FloatBuffer values) {
public void vertexAttrib1fv(int indx, FloatBuffer values) {
GLES20.glVertexAttrib1fv(indx, values);
}
@Override
public void glVertexAttrib2f(int indx, float x, float y) {
public void vertexAttrib2f(int indx, float x, float y) {
GLES20.glVertexAttrib2f(indx, x, y);
}
@Override
public void glVertexAttrib2fv(int indx, FloatBuffer values) {
public void vertexAttrib2fv(int indx, FloatBuffer values) {
GLES20.glVertexAttrib2fv(indx, values);
}
@Override
public void glVertexAttrib3f(int indx, float x, float y, float z) {
public void vertexAttrib3f(int indx, float x, float y, float z) {
GLES20.glVertexAttrib3f(indx, x, y, z);
}
@Override
public void glVertexAttrib3fv(int indx, FloatBuffer values) {
public void vertexAttrib3fv(int indx, FloatBuffer values) {
GLES20.glVertexAttrib3fv(indx, values);
}
@Override
public void glVertexAttrib4f(int indx, float x, float y, float z, float w) {
public void vertexAttrib4f(int indx, float x, float y, float z, float w) {
GLES20.glVertexAttrib4f(indx, x, y, z, w);
}
@Override
public void glVertexAttrib4fv(int indx, FloatBuffer values) {
public void vertexAttrib4fv(int indx, FloatBuffer values) {
GLES20.glVertexAttrib4fv(indx, values);
}
@Override
public void glVertexAttribPointer(int indx, int size, int type, boolean normalized, int stride,
public void vertexAttribPointer(int indx, int size, int type, boolean normalized, int stride,
Buffer ptr) {
GLES20.glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
}
@Override
public void glVertexAttribPointer(int indx, int size, int type, boolean normalized, int stride,
public void vertexAttribPointer(int indx, int size, int type, boolean normalized, int stride,
int offset) {
// FIXME check implementation!
GLES20.glVertexAttribPointer(indx, size, type, normalized, stride, offset);
@@ -606,243 +606,244 @@ public class AndroidGL implements GL20 {
}
@Override
public void glActiveTexture(int texture) {
public void activeTexture(int texture) {
GLES20.glActiveTexture(texture);
}
@Override
public void glBindTexture(int target, int texture) {
public void bindTexture(int target, int texture) {
GLES20.glBindTexture(target, texture);
}
@Override
public void glBlendFunc(int sfactor, int dfactor) {
public void blendFunc(int sfactor, int dfactor) {
GLES20.glBlendFunc(sfactor, dfactor);
}
@Override
public void glClear(int mask) {
public void clear(int mask) {
GLES20.glClear(mask);
}
@Override
public void glClearColor(float red, float green, float blue, float alpha) {
public void clearColor(float red, float green, float blue, float alpha) {
GLES20.glClearColor(red, green, blue, alpha);
}
@Override
public void glClearDepthf(float depth) {
public void clearDepthf(float depth) {
GLES20.glClearDepthf(depth);
}
@Override
public void glClearStencil(int s) {
public void clearStencil(int s) {
GLES20.glClearStencil(s);
}
@Override
public void glColorMask(boolean red, boolean green, boolean blue, boolean alpha) {
public void colorMask(boolean red, boolean green, boolean blue, boolean alpha) {
GLES20.glColorMask(red, green, blue, alpha);
}
@Override
public void glCompressedTexImage2D(int target, int level, int internalformat, int width,
public void compressedTexImage2D(int target, int level, int internalformat, int width,
int height, int border, int imageSize, Buffer data) {
throw new UnsupportedOperationException("missing implementation");
}
@Override
public void glCompressedTexSubImage2D(int target, int level, int xoffset, int yoffset,
public void compressedTexSubImage2D(int target, int level, int xoffset, int yoffset,
int width, int height, int format, int imageSize, Buffer data) {
throw new UnsupportedOperationException("missing implementation");
}
@Override
public void glCopyTexImage2D(int target, int level, int internalformat, int x, int y,
public void copyTexImage2D(int target, int level, int internalformat, int x, int y,
int width, int height, int border) {
GLES20.glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}
@Override
public void glCopyTexSubImage2D(int target, int level, int xoffset, int yoffset, int x, int y,
public void copyTexSubImage2D(int target, int level, int xoffset, int yoffset, int x, int y,
int width, int height) {
GLES20.glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
@Override
public void glCullFace(int mode) {
public void cullFace(int mode) {
GLES20.glCullFace(mode);
}
@Override
public void glDeleteTextures(int n, IntBuffer textures) {
public void deleteTextures(int n, IntBuffer textures) {
GLES20.glDeleteTextures(n, textures);
}
@Override
public void glDepthFunc(int func) {
public void depthFunc(int func) {
GLES20.glDepthFunc(func);
}
@Override
public void glDepthMask(boolean flag) {
public void depthMask(boolean flag) {
GLES20.glDepthMask(flag);
}
@Override
public void glDepthRangef(float zNear, float zFar) {
public void depthRangef(float zNear, float zFar) {
GLES20.glDepthRangef(zNear, zFar);
}
@Override
public void glDisable(int cap) {
public void disable(int cap) {
GLES20.glDisable(cap);
}
@Override
public void glDrawArrays(int mode, int first, int count) {
public void drawArrays(int mode, int first, int count) {
GLES20.glDrawArrays(mode, first, count);
}
@Override
public void glDrawElements(int mode, int count, int type, Buffer indices) {
public void drawElements(int mode, int count, int type, Buffer indices) {
GLES20.glDrawElements(mode, count, type, indices);
}
@Override
public void glEnable(int cap) {
public void enable(int cap) {
GLES20.glEnable(cap);
}
@Override
public void glFinish() {
public void finish() {
GLES20.glFinish();
}
@Override
public void glFlush() {
public void flush() {
GLES20.glFlush();
}
@Override
public void glFrontFace(int mode) {
public void frontFace(int mode) {
GLES20.glFrontFace(mode);
}
@Override
public void glGenTextures(int n, IntBuffer textures) {
public void genTextures(int n, IntBuffer textures) {
GLES20.glGenTextures(n, textures);
}
@Override
public int glGetError() {
public int getError() {
return GLES20.glGetError();
}
@Override
public void glGetIntegerv(int pname, IntBuffer params) {
public void getIntegerv(int pname, IntBuffer params) {
GLES20.glGetIntegerv(pname, params);
}
@Override
public String glGetString(int name) {
public String getString(int name) {
return GLES20.glGetString(name);
}
@Override
public void glHint(int target, int mode) {
public void hint(int target, int mode) {
GLES20.glHint(target, mode);
}
@Override
public void glLineWidth(float width) {
public void lineWidth(float width) {
GLES20.glLineWidth(width);
}
@Override
public void glPixelStorei(int pname, int param) {
public void pixelStorei(int pname, int param) {
GLES20.glPixelStorei(pname, param);
}
@Override
public void glPolygonOffset(float factor, float units) {
public void polygonOffset(float factor, float units) {
GLES20.glPolygonOffset(factor, units);
}
@Override
public void glReadPixels(int x, int y, int width, int height, int format, int type,
public void readPixels(int x, int y, int width, int height, int format, int type,
Buffer pixels) {
GLES20.glReadPixels(x, y, width, height, format, type, pixels);
}
@Override
public void glScissor(int x, int y, int width, int height) {
public void scissor(int x, int y, int width, int height) {
GLES20.glScissor(x, y, width, height);
}
@Override
public void glStencilFunc(int func, int ref, int mask) {
public void stencilFunc(int func, int ref, int mask) {
GLES20.glStencilFunc(func, ref, mask);
}
@Override
public void glStencilMask(int mask) {
public void stencilMask(int mask) {
GLES20.glStencilMask(mask);
}
@Override
public void glStencilOp(int fail, int zfail, int zpass) {
public void stencilOp(int fail, int zfail, int zpass) {
GLES20.glStencilOp(fail, zfail, zpass);
}
@Override
public void glTexImage2D(int target, int level, int internalformat, int width, int height,
public void texImage2D(int target, int level, int internalformat, int width, int height,
int border, int format, int type, Buffer pixels) {
GLES20.glTexImage2D(target, level, internalformat, width, height, border, format, type,
pixels);
}
@Override
public void glTexParameterf(int target, int pname, float param) {
public void texParameterf(int target, int pname, float param) {
GLES20.glTexParameterf(target, pname, param);
}
@Override
public void glTexSubImage2D(int target, int level, int xoffset, int yoffset, int width,
public void texSubImage2D(int target, int level, int xoffset, int yoffset, int width,
int height, int format, int type, Buffer pixels) {
GLES20.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
GLES20
.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
}
@Override
public void glViewport(int x, int y, int width, int height) {
public void viewport(int x, int y, int width, int height) {
GLES20.glViewport(x, y, width, height);
}