Add missing @Override annotations (#617)

vtm-desktop/src/org/oscim/gdx/LwjglGL20.java

@@ -68,54 +68,67 @@ public class LwjglGL20 implements GL {
         return intBuffer;
     }
 
+    @Override
     public void activeTexture(int texture) {
         GL13.glActiveTexture(texture);
     }
 
+    @Override
     public void attachShader(int program, int shader) {
         GL20.glAttachShader(program, shader);
     }
 
+    @Override
     public void bindAttribLocation(int program, int index, String name) {
         GL20.glBindAttribLocation(program, index, name);
     }
 
+    @Override
     public void bindBuffer(int target, int buffer) {
         GL15.glBindBuffer(target, buffer);
     }
 
+    @Override
     public void bindFramebuffer(int target, int framebuffer) {
         EXTFramebufferObject.glBindFramebufferEXT(target, framebuffer);
     }
 
+    @Override
     public void bindRenderbuffer(int target, int renderbuffer) {
         EXTFramebufferObject.glBindRenderbufferEXT(target, renderbuffer);
     }
 
+    @Override
     public void bindTexture(int target, int texture) {
         GL11.glBindTexture(target, texture);
     }
 
+    @Override
     public void blendColor(float red, float green, float blue, float alpha) {
         GL14.glBlendColor(red, green, blue, alpha);
     }
 
+    @Override
     public void blendEquation(int mode) {
         GL14.glBlendEquation(mode);
     }
 
+    @Override
     public void blendEquationSeparate(int modeRGB, int modeAlpha) {
         GL20.glBlendEquationSeparate(modeRGB, modeAlpha);
     }
 
+    @Override
     public void blendFunc(int sfactor, int dfactor) {
         GL11.glBlendFunc(sfactor, dfactor);
     }
 
+    @Override
     public void blendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) {
         GL14.glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
     }
 
+    @Override
     public void bufferData(int target, int size, Buffer data, int usage) {
         if (data == null)
             GL15.glBufferData(target, size, usage);
@@ -131,6 +144,7 @@ public class LwjglGL20 implements GL {
             GL15.glBufferData(target, (ShortBuffer) data, usage);
     }
 
+    @Override
     public void bufferSubData(int target, int offset, int size, Buffer data) {
         if (data == null)
             throw new GdxRuntimeException("Using null for the data not possible, blame LWJGL");
@@ -146,34 +160,42 @@ public class LwjglGL20 implements GL {
             GL15.glBufferSubData(target, offset, (ShortBuffer) data);
     }
 
+    @Override
     public int checkFramebufferStatus(int target) {
         return EXTFramebufferObject.glCheckFramebufferStatusEXT(target);
     }
 
+    @Override
     public void clear(int mask) {
         GL11.glClear(mask);
     }
 
+    @Override
     public void clearColor(float red, float green, float blue, float alpha) {
         GL11.glClearColor(red, green, blue, alpha);
     }
 
+    @Override
     public void clearDepthf(float depth) {
         GL11.glClearDepth(depth);
     }
 
+    @Override
     public void clearStencil(int s) {
         GL11.glClearStencil(s);
     }
 
+    @Override
     public void colorMask(boolean red, boolean green, boolean blue, boolean alpha) {
         GL11.glColorMask(red, green, blue, alpha);
     }
 
+    @Override
     public void compileShader(int shader) {
         GL20.glCompileShader(shader);
     }
 
+    @Override
     public void compressedTexImage2D(int target, int level, int internalformat, int width, int height, int border,
                                      int imageSize, Buffer data) {
         if (data instanceof ByteBuffer) {
@@ -183,31 +205,38 @@ public class LwjglGL20 implements GL {
         }
     }
 
+    @Override
     public void compressedTexSubImage2D(int target, int level, int xoffset, int yoffset, int width, int height, int format,
                                         int imageSize, Buffer data) {
         throw new GdxRuntimeException("not implemented");
     }
 
+    @Override
     public void copyTexImage2D(int target, int level, int internalformat, int x, int y, int width, int height, int border) {
         GL11.glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
     }
 
+    @Override
     public void copyTexSubImage2D(int target, int level, int xoffset, int yoffset, int x, int y, int width, int height) {
         GL11.glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
     }
 
+    @Override
     public int createProgram() {
         return GL20.glCreateProgram();
     }
 
+    @Override
     public int createShader(int type) {
         return GL20.glCreateShader(type);
     }
 
+    @Override
     public void cullFace(int mode) {
         GL11.glCullFace(mode);
     }
 
+    @Override
     public void deleteBuffers(int n, IntBuffer buffers) {
         GL15.glDeleteBuffers(buffers);
     }
@@ -216,6 +245,7 @@ public class LwjglGL20 implements GL {
         GL15.glDeleteBuffers(buffer);
     }
 
+    @Override
     public void deleteFramebuffers(int n, IntBuffer framebuffers) {
         EXTFramebufferObject.glDeleteFramebuffersEXT(framebuffers);
     }
@@ -224,10 +254,12 @@ public class LwjglGL20 implements GL {
         EXTFramebufferObject.glDeleteFramebuffersEXT(framebuffer);
     }
 
+    @Override
     public void deleteProgram(int program) {
         GL20.glDeleteProgram(program);
     }
 
+    @Override
     public void deleteRenderbuffers(int n, IntBuffer renderbuffers) {
         EXTFramebufferObject.glDeleteRenderbuffersEXT(renderbuffers);
     }
@@ -236,10 +268,12 @@ public class LwjglGL20 implements GL {
         EXTFramebufferObject.glDeleteRenderbuffersEXT(renderbuffer);
     }
 
+    @Override
     public void deleteShader(int shader) {
         GL20.glDeleteShader(shader);
     }
 
+    @Override
     public void deleteTextures(int n, IntBuffer textures) {
         GL11.glDeleteTextures(textures);
     }
@@ -248,34 +282,42 @@ public class LwjglGL20 implements GL {
         GL11.glDeleteTextures(texture);
     }
 
+    @Override
     public void depthFunc(int func) {
         GL11.glDepthFunc(func);
     }
 
+    @Override
     public void depthMask(boolean flag) {
         GL11.glDepthMask(flag);
     }
 
+    @Override
     public void depthRangef(float zNear, float zFar) {
         GL11.glDepthRange(zNear, zFar);
     }
 
+    @Override
     public void detachShader(int program, int shader) {
         GL20.glDetachShader(program, shader);
     }
 
+    @Override
     public void disable(int cap) {
         GL11.glDisable(cap);
     }
 
+    @Override
     public void disableVertexAttribArray(int index) {
         GL20.glDisableVertexAttribArray(index);
     }
 
+    @Override
     public void drawArrays(int mode, int first, int count) {
         GL11.glDrawArrays(mode, first, count);
     }
 
+    @Override
     public void drawElements(int mode, int count, int type, Buffer indices) {
         if (indices instanceof ShortBuffer && type == com.badlogic.gdx.graphics.GL20.GL_UNSIGNED_SHORT)
             GL11.glDrawElements(mode, (ShortBuffer) indices);
@@ -288,34 +330,42 @@ public class LwjglGL20 implements GL {
                     + " with this method. Use ShortBuffer or ByteBuffer instead. Blame LWJGL");
     }
 
+    @Override
     public void enable(int cap) {
         GL11.glEnable(cap);
     }
 
+    @Override
     public void enableVertexAttribArray(int index) {
         GL20.glEnableVertexAttribArray(index);
     }
 
+    @Override
     public void finish() {
         GL11.glFinish();
     }
 
+    @Override
     public void flush() {
         GL11.glFlush();
     }
 
+    @Override
     public void framebufferRenderbuffer(int target, int attachment, int renderbuffertarget, int renderbuffer) {
         EXTFramebufferObject.glFramebufferRenderbufferEXT(target, attachment, renderbuffertarget, renderbuffer);
     }
 
+    @Override
     public void framebufferTexture2D(int target, int attachment, int textarget, int texture, int level) {
         EXTFramebufferObject.glFramebufferTexture2DEXT(target, attachment, textarget, texture, level);
     }
 
+    @Override
     public void frontFace(int mode) {
         GL11.glFrontFace(mode);
     }
 
+    @Override
     public void genBuffers(int n, IntBuffer buffers) {
         GL15.glGenBuffers(buffers);
     }
@@ -324,6 +374,7 @@ public class LwjglGL20 implements GL {
         return GL15.glGenBuffers();
     }
 
+    @Override
     public void genFramebuffers(int n, IntBuffer framebuffers) {
         EXTFramebufferObject.glGenFramebuffersEXT(framebuffers);
     }
@@ -332,6 +383,7 @@ public class LwjglGL20 implements GL {
         return EXTFramebufferObject.glGenFramebuffersEXT();
     }
 
+    @Override
     public void genRenderbuffers(int n, IntBuffer renderbuffers) {
         EXTFramebufferObject.glGenRenderbuffersEXT(renderbuffers);
     }
@@ -340,6 +392,7 @@ public class LwjglGL20 implements GL {
         return EXTFramebufferObject.glGenRenderbuffersEXT();
     }
 
+    @Override
     public void genTextures(int n, IntBuffer textures) {
         GL11.glGenTextures(textures);
     }
@@ -348,10 +401,12 @@ public class LwjglGL20 implements GL {
         return GL11.glGenTextures();
     }
 
+    @Override
     public void generateMipmap(int target) {
         EXTFramebufferObject.glGenerateMipmapEXT(target);
     }
 
+    @Override
     public String getActiveAttrib(int program, int index, IntBuffer size, Buffer type) {
         // FIXME this is less than ideal of course...
         IntBuffer typeTmp = BufferUtils.createIntBuffer(2);
@@ -361,6 +416,7 @@ public class LwjglGL20 implements GL {
         return name;
     }
 
+    @Override
     public String getActiveUniform(int program, int index, IntBuffer size, Buffer type) {
         // FIXME this is less than ideal of course...
         IntBuffer typeTmp = BufferUtils.createIntBuffer(2);
@@ -370,38 +426,47 @@ public class LwjglGL20 implements GL {
         return name;
     }
 
+    @Override
     public void getAttachedShaders(int program, int maxcount, Buffer count, IntBuffer shaders) {
         GL20.glGetAttachedShaders(program, (IntBuffer) count, shaders);
     }
 
+    @Override
     public int getAttribLocation(int program, String name) {
         return GL20.glGetAttribLocation(program, name);
     }
 
+    @Override
     public void getBooleanv(int pname, Buffer params) {
         GL11.glGetBoolean(pname, (ByteBuffer) params);
     }
 
+    @Override
     public void getBufferParameteriv(int target, int pname, IntBuffer params) {
         GL15.glGetBufferParameter(target, pname, params);
     }
 
+    @Override
     public int getError() {
         return GL11.glGetError();
     }
 
+    @Override
     public void getFloatv(int pname, FloatBuffer params) {
         GL11.glGetFloat(pname, params);
     }
 
+    @Override
     public void getFramebufferAttachmentParameteriv(int target, int attachment, int pname, IntBuffer params) {
         EXTFramebufferObject.glGetFramebufferAttachmentParameterEXT(target, attachment, pname, params);
     }
 
+    @Override
     public void getIntegerv(int pname, IntBuffer params) {
         GL11.glGetInteger(pname, params);
     }
 
+    @Override
     public String getProgramInfoLog(int program) {
         ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 10);
         buffer.order(ByteOrder.nativeOrder());
@@ -416,14 +481,17 @@ public class LwjglGL20 implements GL {
         return new String(bytes);
     }
 
+    @Override
     public void getProgramiv(int program, int pname, IntBuffer params) {
         GL20.glGetProgram(program, pname, params);
     }
 
+    @Override
     public void getRenderbufferParameteriv(int target, int pname, IntBuffer params) {
         EXTFramebufferObject.glGetRenderbufferParameterEXT(target, pname, params);
     }
 
+    @Override
     public String getShaderInfoLog(int shader) {
         ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 10);
         buffer.order(ByteOrder.nativeOrder());
@@ -438,98 +506,122 @@ public class LwjglGL20 implements GL {
         return new String(bytes);
     }
 
+    @Override
     public void getShaderPrecisionFormat(int shadertype, int precisiontype, IntBuffer range, IntBuffer precision) {
         throw new UnsupportedOperationException("unsupported, won't implement");
     }
 
+    @Override
     public void getShaderiv(int shader, int pname, IntBuffer params) {
         GL20.glGetShader(shader, pname, params);
     }
 
+    @Override
     public String getString(int name) {
         return GL11.glGetString(name);
     }
 
+    @Override
     public void getTexParameterfv(int target, int pname, FloatBuffer params) {
         GL11.glGetTexParameter(target, pname, params);
     }
 
+    @Override
     public void getTexParameteriv(int target, int pname, IntBuffer params) {
         GL11.glGetTexParameter(target, pname, params);
     }
 
+    @Override
     public int getUniformLocation(int program, String name) {
         return GL20.glGetUniformLocation(program, name);
     }
 
+    @Override
     public void getUniformfv(int program, int location, FloatBuffer params) {
         GL20.glGetUniform(program, location, params);
     }
 
+    @Override
     public void getUniformiv(int program, int location, IntBuffer params) {
         GL20.glGetUniform(program, location, params);
     }
 
+    @Override
     public void getVertexAttribPointerv(int index, int pname, Buffer pointer) {
         throw new UnsupportedOperationException("unsupported, won't implement");
     }
 
+    @Override
     public void getVertexAttribfv(int index, int pname, FloatBuffer params) {
         GL20.glGetVertexAttrib(index, pname, params);
     }
 
+    @Override
     public void getVertexAttribiv(int index, int pname, IntBuffer params) {
         GL20.glGetVertexAttrib(index, pname, params);
     }
 
+    @Override
     public void hint(int target, int mode) {
         GL11.glHint(target, mode);
     }
 
+    @Override
     public boolean isBuffer(int buffer) {
         return GL15.glIsBuffer(buffer);
     }
 
+    @Override
     public boolean isEnabled(int cap) {
         return GL11.glIsEnabled(cap);
     }
 
+    @Override
     public boolean isFramebuffer(int framebuffer) {
         return EXTFramebufferObject.glIsFramebufferEXT(framebuffer);
     }
 
+    @Override
     public boolean isProgram(int program) {
         return GL20.glIsProgram(program);
     }
 
+    @Override
     public boolean isRenderbuffer(int renderbuffer) {
         return EXTFramebufferObject.glIsRenderbufferEXT(renderbuffer);
     }
 
+    @Override
     public boolean isShader(int shader) {
         return GL20.glIsShader(shader);
     }
 
+    @Override
     public boolean isTexture(int texture) {
         return GL11.glIsTexture(texture);
     }
 
+    @Override
     public void lineWidth(float width) {
         GL11.glLineWidth(width);
     }
 
+    @Override
     public void linkProgram(int program) {
         GL20.glLinkProgram(program);
     }
 
+    @Override
     public void pixelStorei(int pname, int param) {
         GL11.glPixelStorei(pname, param);
     }
 
+    @Override
     public void polygonOffset(float factor, float units) {
         GL11.glPolygonOffset(factor, units);
     }
 
+    @Override
     public void readPixels(int x, int y, int width, int height, int format, int type, Buffer pixels) {
         if (pixels instanceof ByteBuffer)
             GL11.glReadPixels(x, y, width, height, format, type, (ByteBuffer) pixels);
@@ -544,54 +636,67 @@ public class LwjglGL20 implements GL {
                     + " with this method. Use ByteBuffer, ShortBuffer, IntBuffer or FloatBuffer instead. Blame LWJGL");
     }
 
+    @Override
     public void releaseShaderCompiler() {
         // nothing to do here
     }
 
+    @Override
     public void renderbufferStorage(int target, int internalformat, int width, int height) {
         EXTFramebufferObject.glRenderbufferStorageEXT(target, internalformat, width, height);
     }
 
+    @Override
     public void sampleCoverage(float value, boolean invert) {
         GL13.glSampleCoverage(value, invert);
     }
 
+    @Override
     public void scissor(int x, int y, int width, int height) {
         GL11.glScissor(x, y, width, height);
     }
 
+    @Override
     public void shaderBinary(int n, IntBuffer shaders, int binaryformat, Buffer binary, int length) {
         throw new UnsupportedOperationException("unsupported, won't implement");
     }
 
+    @Override
     public void shaderSource(int shader, String string) {
         GL20.glShaderSource(shader, string);
     }
 
+    @Override
     public void stencilFunc(int func, int ref, int mask) {
         GL11.glStencilFunc(func, ref, mask);
     }
 
+    @Override
     public void stencilFuncSeparate(int face, int func, int ref, int mask) {
         GL20.glStencilFuncSeparate(face, func, ref, mask);
     }
 
+    @Override
     public void stencilMask(int mask) {
         GL11.glStencilMask(mask);
     }
 
+    @Override
     public void stencilMaskSeparate(int face, int mask) {
         GL20.glStencilMaskSeparate(face, mask);
     }
 
+    @Override
     public void stencilOp(int fail, int zfail, int zpass) {
         GL11.glStencilOp(fail, zfail, zpass);
     }
 
+    @Override
     public void stencilOpSeparate(int face, int fail, int zfail, int zpass) {
         GL20.glStencilOpSeparate(face, fail, zfail, zpass);
     }
 
+    @Override
     public void texImage2D(int target, int level, int internalformat, int width, int height, int border, int format, int type,
                            Buffer pixels) {
         if (pixels == null)
@@ -611,22 +716,27 @@ public class LwjglGL20 implements GL {
                     + " with this method. Use ByteBuffer, ShortBuffer, IntBuffer, FloatBuffer or DoubleBuffer instead. Blame LWJGL");
     }
 
+    @Override
     public void texParameterf(int target, int pname, float param) {
         GL11.glTexParameterf(target, pname, param);
     }
 
+    @Override
     public void texParameterfv(int target, int pname, FloatBuffer params) {
         GL11.glTexParameter(target, pname, params);
     }
 
+    @Override
     public void texParameteri(int target, int pname, int param) {
         GL11.glTexParameteri(target, pname, param);
     }
 
+    @Override
     public void texParameteriv(int target, int pname, IntBuffer params) {
         GL11.glTexParameter(target, pname, params);
     }
 
+    @Override
     public void texSubImage2D(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type,
                               Buffer pixels) {
         if (pixels instanceof ByteBuffer)
@@ -644,10 +754,12 @@ public class LwjglGL20 implements GL {
                     + " with this method. Use ByteBuffer, ShortBuffer, IntBuffer, FloatBuffer or DoubleBuffer instead. Blame LWJGL");
     }
 
+    @Override
     public void uniform1f(int location, float x) {
         GL20.glUniform1f(location, x);
     }
 
+    @Override
     public void uniform1fv(int location, int count, FloatBuffer v) {
         GL20.glUniform1(location, v);
     }
@@ -656,10 +768,12 @@ public class LwjglGL20 implements GL {
         GL20.glUniform1(location, toFloatBuffer(v, offset, count));
     }
 
+    @Override
     public void uniform1i(int location, int x) {
         GL20.glUniform1i(location, x);
     }
 
+    @Override
     public void uniform1iv(int location, int count, IntBuffer v) {
         GL20.glUniform1(location, v);
     }
@@ -668,10 +782,12 @@ public class LwjglGL20 implements GL {
         GL20.glUniform1(location, toIntBuffer(v, offset, count));
     }
 
+    @Override
     public void uniform2f(int location, float x, float y) {
         GL20.glUniform2f(location, x, y);
     }
 
+    @Override
     public void uniform2fv(int location, int count, FloatBuffer v) {
         GL20.glUniform2(location, v);
     }
@@ -680,10 +796,12 @@ public class LwjglGL20 implements GL {
         GL20.glUniform2(location, toFloatBuffer(v, offset, count << 1));
     }
 
+    @Override
     public void uniform2i(int location, int x, int y) {
         GL20.glUniform2i(location, x, y);
     }
 
+    @Override
     public void uniform2iv(int location, int count, IntBuffer v) {
         GL20.glUniform2(location, v);
     }
@@ -692,10 +810,12 @@ public class LwjglGL20 implements GL {
         GL20.glUniform2(location, toIntBuffer(v, offset, count << 1));
     }
 
+    @Override
     public void uniform3f(int location, float x, float y, float z) {
         GL20.glUniform3f(location, x, y, z);
     }
 
+    @Override
     public void uniform3fv(int location, int count, FloatBuffer v) {
         GL20.glUniform3(location, v);
     }
@@ -704,10 +824,12 @@ public class LwjglGL20 implements GL {
         GL20.glUniform3(location, toFloatBuffer(v, offset, count * 3));
     }
 
+    @Override
     public void uniform3i(int location, int x, int y, int z) {
         GL20.glUniform3i(location, x, y, z);
     }
 
+    @Override
     public void uniform3iv(int location, int count, IntBuffer v) {
         GL20.glUniform3(location, v);
     }
@@ -716,10 +838,12 @@ public class LwjglGL20 implements GL {
         GL20.glUniform3(location, toIntBuffer(v, offset, count * 3));
     }
 
+    @Override
     public void uniform4f(int location, float x, float y, float z, float w) {
         GL20.glUniform4f(location, x, y, z, w);
     }
 
+    @Override
     public void uniform4fv(int location, int count, FloatBuffer v) {
         GL20.glUniform4(location, v);
     }
@@ -728,10 +852,12 @@ public class LwjglGL20 implements GL {
         GL20.glUniform4(location, toFloatBuffer(v, offset, count << 2));
     }
 
+    @Override
     public void uniform4i(int location, int x, int y, int z, int w) {
         GL20.glUniform4i(location, x, y, z, w);
     }
 
+    @Override
     public void uniform4iv(int location, int count, IntBuffer v) {
         GL20.glUniform4(location, v);
     }
@@ -740,6 +866,7 @@ public class LwjglGL20 implements GL {
         GL20.glUniform4(location, toIntBuffer(v, offset, count << 2));
     }
 
+    @Override
     public void uniformMatrix2fv(int location, int count, boolean transpose, FloatBuffer value) {
         GL20.glUniformMatrix2(location, transpose, value);
     }
@@ -748,6 +875,7 @@ public class LwjglGL20 implements GL {
         GL20.glUniformMatrix2(location, transpose, toFloatBuffer(value, offset, count << 2));
     }
 
+    @Override
     public void uniformMatrix3fv(int location, int count, boolean transpose, FloatBuffer value) {
         GL20.glUniformMatrix3(location, transpose, value);
     }
@@ -756,6 +884,7 @@ public class LwjglGL20 implements GL {
         GL20.glUniformMatrix3(location, transpose, toFloatBuffer(value, offset, count * 9));
     }
 
+    @Override
     public void uniformMatrix4fv(int location, int count, boolean transpose, FloatBuffer value) {
         GL20.glUniformMatrix4(location, transpose, value);
     }
@@ -764,46 +893,57 @@ public class LwjglGL20 implements GL {
         GL20.glUniformMatrix4(location, transpose, toFloatBuffer(value, offset, count << 4));
     }
 
+    @Override
     public void useProgram(int program) {
         GL20.glUseProgram(program);
     }
 
+    @Override
     public void validateProgram(int program) {
         GL20.glValidateProgram(program);
     }
 
+    @Override
     public void vertexAttrib1f(int indx, float x) {
         GL20.glVertexAttrib1f(indx, x);
     }
 
+    @Override
     public void vertexAttrib1fv(int indx, FloatBuffer values) {
         GL20.glVertexAttrib1f(indx, values.get());
     }
 
+    @Override
     public void vertexAttrib2f(int indx, float x, float y) {
         GL20.glVertexAttrib2f(indx, x, y);
     }
 
+    @Override
     public void vertexAttrib2fv(int indx, FloatBuffer values) {
         GL20.glVertexAttrib2f(indx, values.get(), values.get());
     }
 
+    @Override
     public void vertexAttrib3f(int indx, float x, float y, float z) {
         GL20.glVertexAttrib3f(indx, x, y, z);
     }
 
+    @Override
     public void vertexAttrib3fv(int indx, FloatBuffer values) {
         GL20.glVertexAttrib3f(indx, values.get(), values.get(), values.get());
     }
 
+    @Override
     public void vertexAttrib4f(int indx, float x, float y, float z, float w) {
         GL20.glVertexAttrib4f(indx, x, y, z, w);
     }
 
+    @Override
     public void vertexAttrib4fv(int indx, FloatBuffer values) {
         GL20.glVertexAttrib4f(indx, values.get(), values.get(), values.get(), values.get());
     }
 
+    @Override
     public void vertexAttribPointer(int indx, int size, int type, boolean normalized, int stride, Buffer buffer) {
         if (buffer instanceof ByteBuffer) {
             if (type == BYTE)
@@ -834,18 +974,22 @@ public class LwjglGL20 implements GL {
                     + " with this method. Use ByteBuffer instead. Blame LWJGL");
     }
 
+    @Override
     public void viewport(int x, int y, int width, int height) {
         GL11.glViewport(x, y, width, height);
     }
 
+    @Override
     public void drawElements(int mode, int count, int type, int indices) {
         GL11.glDrawElements(mode, count, type, indices);
     }
 
+    @Override
     public void vertexAttribPointer(int indx, int size, int type, boolean normalized, int stride, int ptr) {
         GL20.glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
     }
 
+    @Override
     public void getShaderSource(int shader, int bufsize, Buffer length, String source) {
     }
 }