/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */ /* Part of the Processing project - http://processing.org Copyright (c) 2012-15 The Processing Foundation Copyright (c) 2004-12 Ben Fry and Casey Reas Copyright (c) 2001-04 Massachusetts Institute of Technology This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, version 2.1. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package processing.opengl; import java.awt.Font; import java.awt.FontMetrics; import java.awt.Shape; import java.awt.Toolkit; import java.awt.font.FontRenderContext; import java.awt.font.GlyphVector; import java.awt.geom.PathIterator; import java.io.IOException; import java.net.URL; import java.nio.Buffer; import java.nio.ByteBuffer; import java.nio.FloatBuffer; import java.nio.IntBuffer; import com.jogamp.common.util.VersionNumber; import com.jogamp.opengl.GL; import com.jogamp.opengl.GL2; import com.jogamp.opengl.GL2ES2; import com.jogamp.opengl.GL2ES3; import com.jogamp.opengl.GL2GL3; import com.jogamp.opengl.GL3ES3; import com.jogamp.opengl.GLAutoDrawable; import com.jogamp.opengl.GLCapabilities; import com.jogamp.opengl.GLCapabilitiesImmutable; import com.jogamp.opengl.GLContext; import com.jogamp.opengl.GLDrawable; import com.jogamp.opengl.fixedfunc.GLMatrixFunc; import com.jogamp.opengl.glu.GLU; import com.jogamp.opengl.glu.GLUtessellator; import com.jogamp.opengl.glu.GLUtessellatorCallbackAdapter; import com.jogamp.opengl.util.awt.AWTGLReadBufferUtil; import processing.awt.PImageAWT; import processing.core.PApplet; import processing.core.PGraphics; import processing.core.PImage; import processing.core.PMatrix3D; import processing.core.PSurface; public class PJOGL extends PGL { // OpenGL profile to use (2, 3 or 4) public static int profile = 2; // User-provided icons to override defaults protected static String[] icons = null; // The two windowing toolkits available to use in JOGL: public static final int AWT = 0; // http://jogamp.org/wiki/index.php/Using_JOGL_in_AWT_SWT_and_Swing public static final int NEWT = 1; // http://jogamp.org/jogl/doc/NEWT-Overview.html // ........................................................ // Public members to access the underlying GL objects and context /** Basic GL functionality, common to all profiles */ public GL gl; /** GLU interface **/ public GLU glu; /** The rendering context (holds rendering state info) */ public GLContext context; // ........................................................ // Additional parameters /** Time that the Processing's animation thread will wait for JOGL's rendering * thread to be done with a single frame. */ protected static int DRAW_TIMEOUT_MILLIS = 500; // ........................................................ // Protected JOGL-specific objects needed to access the GL profiles /** The capabilities of the OpenGL rendering surface */ protected GLCapabilitiesImmutable capabilities; /** The rendering surface */ protected GLDrawable drawable; /** GLES2 functionality (shaders, etc) */ protected GL2ES2 gl2; /** GL3 interface */ protected GL2GL3 gl3; /** GL2 desktop functionality (blit framebuffer, map buffer range, * multisampled renderbuffers) */ protected GL2 gl2x; /** GL3ES3 interface */ protected GL3ES3 gl3es3; /** Stores exceptions that ocurred during drawing */ protected Exception drawException; // ........................................................ // Utility arrays to copy projection/modelview matrices to GL protected float[] projMatrix; protected float[] mvMatrix; // ........................................................ // Static initialization for some parameters that need to be different for // JOGL static { MIN_DIRECT_BUFFER_SIZE = 2; INDEX_TYPE = GL.GL_UNSIGNED_SHORT; } /////////////////////////////////////////////////////////////// // Initialization, finalization public PJOGL(PGraphicsOpenGL pg) { super(pg); glu = new GLU(); } public PJOGL(PGraphicsOpenGL pg, PGL.RenderCallback callback) { super(pg, callback); glu = new GLU(); } @Override public Object getNative() { return sketch.getSurface().getNative(); } @Override protected void setFrameRate(float fps) {} @Override protected void initSurface(int antialias) {} @Override protected void reinitSurface() {} @Override protected void registerListeners() {} @Override protected PImage screenshot() { AWTGLReadBufferUtil util = new AWTGLReadBufferUtil(capabilities.getGLProfile(), false); return new PImageAWT(util.readPixelsToBufferedImage​(gl, true)); } static public void setIcon(String... icons) { PJOGL.icons = new String[icons.length]; PApplet.arrayCopy(icons, PJOGL.icons); } /////////////////////////////////////////////////////////////// // Public methods to get/set renderer's properties public void setCaps(GLCapabilities caps) { reqNumSamples = caps.getNumSamples(); capabilities = caps; } public GLCapabilitiesImmutable getCaps() { return capabilities; } public void setFps(float fps) { if (!setFps || targetFps != fps) { if (60 < fps) { // Disables v-sync gl.setSwapInterval(0); } else if (30 < fps) { gl.setSwapInterval(1); } else { gl.setSwapInterval(2); } targetFps = currentFps = fps; setFps = true; } } @Override protected int getDepthBits() { return capabilities.getDepthBits(); } @Override protected int getStencilBits() { return capabilities.getStencilBits(); } @Override protected float getPixelScale() { PSurface surf = sketch.getSurface(); if (surf == null) { return graphics.pixelDensity; } else if (surf instanceof PSurfaceJOGL) { return ((PSurfaceJOGL)surf).getPixelScale(); } else { throw new RuntimeException("Renderer cannot find a JOGL surface"); } } @Override protected void getGL(PGL pgl) { PJOGL pjogl = (PJOGL)pgl; this.drawable = pjogl.drawable; this.context = pjogl.context; this.glContext = pjogl.glContext; setThread(pjogl.glThread); this.gl = pjogl.gl; this.gl2 = pjogl.gl2; this.gl2x = pjogl.gl2x; this.gl3 = pjogl.gl3; this.gl3es3 = pjogl.gl3es3; } public void getGL(GLAutoDrawable glDrawable) { context = glDrawable.getContext(); glContext = context.hashCode(); setThread(Thread.currentThread()); gl = context.getGL(); gl2 = gl.getGL2ES2(); try { gl2x = gl.getGL2(); } catch (com.jogamp.opengl.GLException e) { gl2x = null; } try { gl3 = gl.getGL2GL3(); } catch (com.jogamp.opengl.GLException e) { gl3 = null; } try { gl3es3 = gl.getGL3ES3(); } catch (com.jogamp.opengl.GLException e) { gl3es3 = null; } } @Override protected boolean canDraw() { return true; } @Override protected void requestFocus() {} @Override protected void requestDraw() {} @Override protected void swapBuffers() { PSurfaceJOGL surf = (PSurfaceJOGL)sketch.getSurface(); surf.window.swapBuffers(); } @Override protected void initFBOLayer() { if (0 < sketch.frameCount) { if (isES()) initFBOLayerES(); else initFBOLayerGL(); } } private void initFBOLayerES() { IntBuffer buf = allocateDirectIntBuffer(fboWidth * fboHeight); if (hasReadBuffer()) readBuffer(BACK); readPixelsImpl(0, 0, fboWidth, fboHeight, RGBA, UNSIGNED_BYTE, buf); bindTexture(TEXTURE_2D, glColorTex.get(frontTex)); texSubImage2D(TEXTURE_2D, 0, 0, 0, fboWidth, fboHeight, RGBA, UNSIGNED_BYTE, buf); bindTexture(TEXTURE_2D, glColorTex.get(backTex)); texSubImage2D(TEXTURE_2D, 0, 0, 0, fboWidth, fboHeight, RGBA, UNSIGNED_BYTE, buf); bindTexture(TEXTURE_2D, 0); bindFramebufferImpl(FRAMEBUFFER, 0); } private void initFBOLayerGL() { // Copy the contents of the front and back screen buffers to the textures // of the FBO, so they are properly initialized. Note that the front buffer // of the default framebuffer (the screen) contains the previous frame: // https://www.opengl.org/wiki/Default_Framebuffer // so it is copied to the front texture of the FBO layer: if (pclearColor || 0 < pgeomCount || !sketch.isLooping()) { if (hasReadBuffer()) readBuffer(FRONT); } else { // ...except when the previous frame has not been cleared and nothing was // rendered while looping. In this case the back buffer, which holds the // initial state of the previous frame, still contains the most up-to-date // screen state. readBuffer(BACK); } bindFramebufferImpl(DRAW_FRAMEBUFFER, glColorFbo.get(0)); framebufferTexture2D(FRAMEBUFFER, COLOR_ATTACHMENT0, TEXTURE_2D, glColorTex.get(frontTex), 0); if (hasDrawBuffer()) drawBuffer(COLOR_ATTACHMENT0); blitFramebuffer(0, 0, fboWidth, fboHeight, 0, 0, fboWidth, fboHeight, COLOR_BUFFER_BIT, NEAREST); readBuffer(BACK); bindFramebufferImpl(DRAW_FRAMEBUFFER, glColorFbo.get(0)); framebufferTexture2D(FRAMEBUFFER, COLOR_ATTACHMENT0, TEXTURE_2D, glColorTex.get(backTex), 0); drawBuffer(COLOR_ATTACHMENT0); blitFramebuffer(0, 0, fboWidth, fboHeight, 0, 0, fboWidth, fboHeight, COLOR_BUFFER_BIT, NEAREST); bindFramebufferImpl(FRAMEBUFFER, 0); } @Override protected void beginGL() { PMatrix3D proj = graphics.projection; PMatrix3D mdl = graphics.modelview; if (gl2x != null) { if (projMatrix == null) { projMatrix = new float[16]; } gl2x.glMatrixMode(GLMatrixFunc.GL_PROJECTION); projMatrix[ 0] = proj.m00; projMatrix[ 1] = proj.m10; projMatrix[ 2] = proj.m20; projMatrix[ 3] = proj.m30; projMatrix[ 4] = proj.m01; projMatrix[ 5] = proj.m11; projMatrix[ 6] = proj.m21; projMatrix[ 7] = proj.m31; projMatrix[ 8] = proj.m02; projMatrix[ 9] = proj.m12; projMatrix[10] = proj.m22; projMatrix[11] = proj.m32; projMatrix[12] = proj.m03; projMatrix[13] = proj.m13; projMatrix[14] = proj.m23; projMatrix[15] = proj.m33; gl2x.glLoadMatrixf(projMatrix, 0); if (mvMatrix == null) { mvMatrix = new float[16]; } gl2x.glMatrixMode(GLMatrixFunc.GL_MODELVIEW); mvMatrix[ 0] = mdl.m00; mvMatrix[ 1] = mdl.m10; mvMatrix[ 2] = mdl.m20; mvMatrix[ 3] = mdl.m30; mvMatrix[ 4] = mdl.m01; mvMatrix[ 5] = mdl.m11; mvMatrix[ 6] = mdl.m21; mvMatrix[ 7] = mdl.m31; mvMatrix[ 8] = mdl.m02; mvMatrix[ 9] = mdl.m12; mvMatrix[10] = mdl.m22; mvMatrix[11] = mdl.m32; mvMatrix[12] = mdl.m03; mvMatrix[13] = mdl.m13; mvMatrix[14] = mdl.m23; mvMatrix[15] = mdl.m33; gl2x.glLoadMatrixf(mvMatrix, 0); } } @Override protected boolean hasFBOs() { if (context.hasBasicFBOSupport()) return true; else return super.hasFBOs(); } @Override protected boolean hasShaders() { if (context.hasGLSL()) return true; else return super.hasShaders(); } public void init(GLAutoDrawable glDrawable) { capabilities = glDrawable.getChosenGLCapabilities(); if (!hasFBOs()) { throw new RuntimeException(MISSING_FBO_ERROR); } if (!hasShaders()) { throw new RuntimeException(MISSING_GLSL_ERROR); } } /////////////////////////////////////////////////////////// // Utility functions @Override protected void enableTexturing(int target) { if (target == TEXTURE_2D) { texturingTargets[0] = true; } else if (target == TEXTURE_RECTANGLE) { texturingTargets[1] = true; } } @Override protected void disableTexturing(int target) { if (target == TEXTURE_2D) { texturingTargets[0] = false; } else if (target == TEXTURE_RECTANGLE) { texturingTargets[1] = false; } } /** * Convenience method to get a legit FontMetrics object. Where possible, * override this any renderer subclass so that you're not using what's * returned by getDefaultToolkit() to get your metrics. */ @SuppressWarnings("deprecation") private FontMetrics getFontMetrics(Font font) { // ignore return Toolkit.getDefaultToolkit().getFontMetrics(font); } /** * Convenience method to jump through some Java2D hoops and get an FRC. */ private FontRenderContext getFontRenderContext(Font font) { // ignore return getFontMetrics(font).getFontRenderContext(); } @Override protected int getFontAscent(Object font) { return getFontMetrics((Font) font).getAscent(); } @Override protected int getFontDescent(Object font) { return getFontMetrics((Font) font).getDescent(); } @Override protected int getTextWidth(Object font, char[] buffer, int start, int stop) { // maybe should use one of the newer/fancier functions for this? int length = stop - start; FontMetrics metrics = getFontMetrics((Font) font); return metrics.charsWidth(buffer, start, length); } @Override protected Object getDerivedFont(Object font, float size) { return ((Font) font).deriveFont(size); } @Override protected int getGLSLVersion() { VersionNumber vn = context.getGLSLVersionNumber(); return vn.getMajor() * 100 + vn.getMinor(); } @Override protected String getGLSLVersionSuffix() { VersionNumber vn = context.getGLSLVersionNumber(); if (context.isGLESProfile() && 1 < vn.getMajor()) { return " es"; } else { return ""; } } @Override protected String[] loadVertexShader(String filename) { return loadVertexShader(filename, getGLSLVersion(), getGLSLVersionSuffix()); } @Override protected String[] loadFragmentShader(String filename) { return loadFragmentShader(filename, getGLSLVersion(), getGLSLVersionSuffix()); } @Override protected String[] loadVertexShader(URL url) { return loadVertexShader(url, getGLSLVersion(), getGLSLVersionSuffix()); } @Override protected String[] loadFragmentShader(URL url) { return loadFragmentShader(url, getGLSLVersion(), getGLSLVersionSuffix()); } @Override protected String[] loadFragmentShader(String filename, int version, String versionSuffix) { String[] fragSrc0 = sketch.loadStrings(filename); return preprocessFragmentSource(fragSrc0, version, versionSuffix); } @Override protected String[] loadVertexShader(String filename, int version, String versionSuffix) { String[] vertSrc0 = sketch.loadStrings(filename); return preprocessVertexSource(vertSrc0, version, versionSuffix); } @Override protected String[] loadFragmentShader(URL url, int version, String versionSuffix) { try { String[] fragSrc0 = PApplet.loadStrings(url.openStream()); return preprocessFragmentSource(fragSrc0, version, versionSuffix); } catch (IOException e) { PGraphics.showException("Cannot load fragment shader " + url.getFile()); } return null; } @Override protected String[] loadVertexShader(URL url, int version, String versionSuffix) { try { String[] vertSrc0 = PApplet.loadStrings(url.openStream()); return preprocessVertexSource(vertSrc0, version, versionSuffix); } catch (IOException e) { PGraphics.showException("Cannot load vertex shader " + url.getFile()); } return null; } /////////////////////////////////////////////////////////// // Tessellator @Override protected Tessellator createTessellator(TessellatorCallback callback) { return new Tessellator(callback); } protected static class Tessellator implements PGL.Tessellator { protected GLUtessellator tess; protected TessellatorCallback callback; protected GLUCallback gluCallback; public Tessellator(TessellatorCallback callback) { this.callback = callback; tess = GLU.gluNewTess(); gluCallback = new GLUCallback(); GLU.gluTessCallback(tess, GLU.GLU_TESS_BEGIN, gluCallback); GLU.gluTessCallback(tess, GLU.GLU_TESS_END, gluCallback); GLU.gluTessCallback(tess, GLU.GLU_TESS_VERTEX, gluCallback); GLU.gluTessCallback(tess, GLU.GLU_TESS_COMBINE, gluCallback); GLU.gluTessCallback(tess, GLU.GLU_TESS_ERROR, gluCallback); } @Override public void setCallback(int flag) { GLU.gluTessCallback(tess, flag, gluCallback); } @Override public void setWindingRule(int rule) { setProperty(GLU.GLU_TESS_WINDING_RULE, rule); } public void setProperty(int property, int value) { GLU.gluTessProperty(tess, property, value); } @Override public void beginPolygon() { beginPolygon(null); } @Override public void beginPolygon(Object data) { GLU.gluTessBeginPolygon(tess, data); } @Override public void endPolygon() { GLU.gluTessEndPolygon(tess); } @Override public void beginContour() { GLU.gluTessBeginContour(tess); } @Override public void endContour() { GLU.gluTessEndContour(tess); } @Override public void addVertex(double[] v) { addVertex(v, 0, v); } @Override public void addVertex(double[] v, int n, Object data) { GLU.gluTessVertex(tess, v, n, data); } protected class GLUCallback extends GLUtessellatorCallbackAdapter { @Override public void begin(int type) { callback.begin(type); } @Override public void end() { callback.end(); } @Override public void vertex(Object data) { callback.vertex(data); } @Override public void combine(double[] coords, Object[] data, float[] weight, Object[] outData) { callback.combine(coords, data, weight, outData); } @Override public void error(int errnum) { callback.error(errnum); } } } @Override protected String tessError(int err) { return glu.gluErrorString(err); } /////////////////////////////////////////////////////////// // Font outline static { SHAPE_TEXT_SUPPORTED = true; SEG_MOVETO = PathIterator.SEG_MOVETO; SEG_LINETO = PathIterator.SEG_LINETO; SEG_QUADTO = PathIterator.SEG_QUADTO; SEG_CUBICTO = PathIterator.SEG_CUBICTO; SEG_CLOSE = PathIterator.SEG_CLOSE; } @Override protected FontOutline createFontOutline(char ch, Object font) { return new FontOutline(ch, (Font) font); } protected class FontOutline implements PGL.FontOutline { PathIterator iter; public FontOutline(char ch, Font font) { char[] textArray = new char[] { ch }; FontRenderContext frc = getFontRenderContext(font); GlyphVector gv = font.createGlyphVector(frc, textArray); Shape shp = gv.getOutline(); iter = shp.getPathIterator(null); } @Override public boolean isDone() { return iter.isDone(); } @Override public int currentSegment(float[] coords) { return iter.currentSegment(coords); } @Override public void next() { iter.next(); } } /////////////////////////////////////////////////////////// // Constants static { FALSE = GL.GL_FALSE; TRUE = GL.GL_TRUE; INT = GL2ES2.GL_INT; BYTE = GL.GL_BYTE; SHORT = GL.GL_SHORT; FLOAT = GL.GL_FLOAT; BOOL = GL2ES2.GL_BOOL; UNSIGNED_INT = GL.GL_UNSIGNED_INT; UNSIGNED_BYTE = GL.GL_UNSIGNED_BYTE; UNSIGNED_SHORT = GL.GL_UNSIGNED_SHORT; RGB = GL.GL_RGB; RGBA = GL.GL_RGBA; ALPHA = GL.GL_ALPHA; LUMINANCE = GL.GL_LUMINANCE; LUMINANCE_ALPHA = GL.GL_LUMINANCE_ALPHA; UNSIGNED_SHORT_5_6_5 = GL.GL_UNSIGNED_SHORT_5_6_5; UNSIGNED_SHORT_4_4_4_4 = GL.GL_UNSIGNED_SHORT_4_4_4_4; UNSIGNED_SHORT_5_5_5_1 = GL.GL_UNSIGNED_SHORT_5_5_5_1; RGBA4 = GL.GL_RGBA4; RGB5_A1 = GL.GL_RGB5_A1; RGB565 = GL.GL_RGB565; RGB8 = GL.GL_RGB8; RGBA8 = GL.GL_RGBA8; ALPHA8 = GL.GL_ALPHA8; READ_ONLY = GL2ES3.GL_READ_ONLY; WRITE_ONLY = GL.GL_WRITE_ONLY; READ_WRITE = GL2ES3.GL_READ_WRITE; TESS_WINDING_NONZERO = GLU.GLU_TESS_WINDING_NONZERO; TESS_WINDING_ODD = GLU.GLU_TESS_WINDING_ODD; TESS_EDGE_FLAG = GLU.GLU_TESS_EDGE_FLAG; GENERATE_MIPMAP_HINT = GL.GL_GENERATE_MIPMAP_HINT; FASTEST = GL.GL_FASTEST; NICEST = GL.GL_NICEST; DONT_CARE = GL.GL_DONT_CARE; VENDOR = GL.GL_VENDOR; RENDERER = GL.GL_RENDERER; VERSION = GL.GL_VERSION; EXTENSIONS = GL.GL_EXTENSIONS; SHADING_LANGUAGE_VERSION = GL2ES2.GL_SHADING_LANGUAGE_VERSION; MAX_SAMPLES = GL.GL_MAX_SAMPLES; SAMPLES = GL.GL_SAMPLES; ALIASED_LINE_WIDTH_RANGE = GL.GL_ALIASED_LINE_WIDTH_RANGE; ALIASED_POINT_SIZE_RANGE = GL.GL_ALIASED_POINT_SIZE_RANGE; DEPTH_BITS = GL.GL_DEPTH_BITS; STENCIL_BITS = GL.GL_STENCIL_BITS; CCW = GL.GL_CCW; CW = GL.GL_CW; VIEWPORT = GL.GL_VIEWPORT; ARRAY_BUFFER = GL.GL_ARRAY_BUFFER; ELEMENT_ARRAY_BUFFER = GL.GL_ELEMENT_ARRAY_BUFFER; PIXEL_PACK_BUFFER = GL2ES3.GL_PIXEL_PACK_BUFFER; MAX_VERTEX_ATTRIBS = GL2ES2.GL_MAX_VERTEX_ATTRIBS; STATIC_DRAW = GL.GL_STATIC_DRAW; DYNAMIC_DRAW = GL.GL_DYNAMIC_DRAW; STREAM_DRAW = GL2ES2.GL_STREAM_DRAW; STREAM_READ = GL2ES3.GL_STREAM_READ; BUFFER_SIZE = GL.GL_BUFFER_SIZE; BUFFER_USAGE = GL.GL_BUFFER_USAGE; POINTS = GL.GL_POINTS; LINE_STRIP = GL.GL_LINE_STRIP; LINE_LOOP = GL.GL_LINE_LOOP; LINES = GL.GL_LINES; TRIANGLE_FAN = GL.GL_TRIANGLE_FAN; TRIANGLE_STRIP = GL.GL_TRIANGLE_STRIP; TRIANGLES = GL.GL_TRIANGLES; CULL_FACE = GL.GL_CULL_FACE; FRONT = GL.GL_FRONT; BACK = GL.GL_BACK; FRONT_AND_BACK = GL.GL_FRONT_AND_BACK; POLYGON_OFFSET_FILL = GL.GL_POLYGON_OFFSET_FILL; UNPACK_ALIGNMENT = GL.GL_UNPACK_ALIGNMENT; PACK_ALIGNMENT = GL.GL_PACK_ALIGNMENT; TEXTURE_2D = GL.GL_TEXTURE_2D; TEXTURE_RECTANGLE = GL2GL3.GL_TEXTURE_RECTANGLE; TEXTURE_BINDING_2D = GL.GL_TEXTURE_BINDING_2D; TEXTURE_BINDING_RECTANGLE = GL2GL3.GL_TEXTURE_BINDING_RECTANGLE; MAX_TEXTURE_SIZE = GL.GL_MAX_TEXTURE_SIZE; TEXTURE_MAX_ANISOTROPY = GL.GL_TEXTURE_MAX_ANISOTROPY_EXT; MAX_TEXTURE_MAX_ANISOTROPY = GL.GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT; MAX_VERTEX_TEXTURE_IMAGE_UNITS = GL2ES2.GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS; MAX_TEXTURE_IMAGE_UNITS = GL2ES2.GL_MAX_TEXTURE_IMAGE_UNITS; MAX_COMBINED_TEXTURE_IMAGE_UNITS = GL2ES2.GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS; NUM_COMPRESSED_TEXTURE_FORMATS = GL.GL_NUM_COMPRESSED_TEXTURE_FORMATS; COMPRESSED_TEXTURE_FORMATS = GL.GL_COMPRESSED_TEXTURE_FORMATS; NEAREST = GL.GL_NEAREST; LINEAR = GL.GL_LINEAR; LINEAR_MIPMAP_NEAREST = GL.GL_LINEAR_MIPMAP_NEAREST; LINEAR_MIPMAP_LINEAR = GL.GL_LINEAR_MIPMAP_LINEAR; CLAMP_TO_EDGE = GL.GL_CLAMP_TO_EDGE; REPEAT = GL.GL_REPEAT; TEXTURE0 = GL.GL_TEXTURE0; TEXTURE1 = GL.GL_TEXTURE1; TEXTURE2 = GL.GL_TEXTURE2; TEXTURE3 = GL.GL_TEXTURE3; TEXTURE_MIN_FILTER = GL.GL_TEXTURE_MIN_FILTER; TEXTURE_MAG_FILTER = GL.GL_TEXTURE_MAG_FILTER; TEXTURE_WRAP_S = GL.GL_TEXTURE_WRAP_S; TEXTURE_WRAP_T = GL.GL_TEXTURE_WRAP_T; TEXTURE_WRAP_R = GL2ES2.GL_TEXTURE_WRAP_R; TEXTURE_CUBE_MAP = GL.GL_TEXTURE_CUBE_MAP; TEXTURE_CUBE_MAP_POSITIVE_X = GL.GL_TEXTURE_CUBE_MAP_POSITIVE_X; TEXTURE_CUBE_MAP_POSITIVE_Y = GL.GL_TEXTURE_CUBE_MAP_POSITIVE_Y; TEXTURE_CUBE_MAP_POSITIVE_Z = GL.GL_TEXTURE_CUBE_MAP_POSITIVE_Z; TEXTURE_CUBE_MAP_NEGATIVE_X = GL.GL_TEXTURE_CUBE_MAP_NEGATIVE_X; TEXTURE_CUBE_MAP_NEGATIVE_Y = GL.GL_TEXTURE_CUBE_MAP_NEGATIVE_Y; TEXTURE_CUBE_MAP_NEGATIVE_Z = GL.GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; VERTEX_SHADER = GL2ES2.GL_VERTEX_SHADER; FRAGMENT_SHADER = GL2ES2.GL_FRAGMENT_SHADER; INFO_LOG_LENGTH = GL2ES2.GL_INFO_LOG_LENGTH; SHADER_SOURCE_LENGTH = GL2ES2.GL_SHADER_SOURCE_LENGTH; COMPILE_STATUS = GL2ES2.GL_COMPILE_STATUS; LINK_STATUS = GL2ES2.GL_LINK_STATUS; VALIDATE_STATUS = GL2ES2.GL_VALIDATE_STATUS; SHADER_TYPE = GL2ES2.GL_SHADER_TYPE; DELETE_STATUS = GL2ES2.GL_DELETE_STATUS; FLOAT_VEC2 = GL2ES2.GL_FLOAT_VEC2; FLOAT_VEC3 = GL2ES2.GL_FLOAT_VEC3; FLOAT_VEC4 = GL2ES2.GL_FLOAT_VEC4; FLOAT_MAT2 = GL2ES2.GL_FLOAT_MAT2; FLOAT_MAT3 = GL2ES2.GL_FLOAT_MAT3; FLOAT_MAT4 = GL2ES2.GL_FLOAT_MAT4; INT_VEC2 = GL2ES2.GL_INT_VEC2; INT_VEC3 = GL2ES2.GL_INT_VEC3; INT_VEC4 = GL2ES2.GL_INT_VEC4; BOOL_VEC2 = GL2ES2.GL_BOOL_VEC2; BOOL_VEC3 = GL2ES2.GL_BOOL_VEC3; BOOL_VEC4 = GL2ES2.GL_BOOL_VEC4; SAMPLER_2D = GL2ES2.GL_SAMPLER_2D; SAMPLER_CUBE = GL2ES2.GL_SAMPLER_CUBE; LOW_FLOAT = GL2ES2.GL_LOW_FLOAT; MEDIUM_FLOAT = GL2ES2.GL_MEDIUM_FLOAT; HIGH_FLOAT = GL2ES2.GL_HIGH_FLOAT; LOW_INT = GL2ES2.GL_LOW_INT; MEDIUM_INT = GL2ES2.GL_MEDIUM_INT; HIGH_INT = GL2ES2.GL_HIGH_INT; CURRENT_VERTEX_ATTRIB = GL2ES2.GL_CURRENT_VERTEX_ATTRIB; VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = GL2ES2.GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING; VERTEX_ATTRIB_ARRAY_ENABLED = GL2ES2.GL_VERTEX_ATTRIB_ARRAY_ENABLED; VERTEX_ATTRIB_ARRAY_SIZE = GL2ES2.GL_VERTEX_ATTRIB_ARRAY_SIZE; VERTEX_ATTRIB_ARRAY_STRIDE = GL2ES2.GL_VERTEX_ATTRIB_ARRAY_STRIDE; VERTEX_ATTRIB_ARRAY_TYPE = GL2ES2.GL_VERTEX_ATTRIB_ARRAY_TYPE; VERTEX_ATTRIB_ARRAY_NORMALIZED = GL2ES2.GL_VERTEX_ATTRIB_ARRAY_NORMALIZED; VERTEX_ATTRIB_ARRAY_POINTER = GL2ES2.GL_VERTEX_ATTRIB_ARRAY_POINTER; BLEND = GL.GL_BLEND; ONE = GL.GL_ONE; ZERO = GL.GL_ZERO; SRC_ALPHA = GL.GL_SRC_ALPHA; DST_ALPHA = GL.GL_DST_ALPHA; ONE_MINUS_SRC_ALPHA = GL.GL_ONE_MINUS_SRC_ALPHA; ONE_MINUS_DST_COLOR = GL.GL_ONE_MINUS_DST_COLOR; ONE_MINUS_SRC_COLOR = GL.GL_ONE_MINUS_SRC_COLOR; DST_COLOR = GL.GL_DST_COLOR; SRC_COLOR = GL.GL_SRC_COLOR; SAMPLE_ALPHA_TO_COVERAGE = GL.GL_SAMPLE_ALPHA_TO_COVERAGE; SAMPLE_COVERAGE = GL.GL_SAMPLE_COVERAGE; KEEP = GL.GL_KEEP; REPLACE = GL.GL_REPLACE; INCR = GL.GL_INCR; DECR = GL.GL_DECR; INVERT = GL.GL_INVERT; INCR_WRAP = GL.GL_INCR_WRAP; DECR_WRAP = GL.GL_DECR_WRAP; NEVER = GL.GL_NEVER; ALWAYS = GL.GL_ALWAYS; EQUAL = GL.GL_EQUAL; LESS = GL.GL_LESS; LEQUAL = GL.GL_LEQUAL; GREATER = GL.GL_GREATER; GEQUAL = GL.GL_GEQUAL; NOTEQUAL = GL.GL_NOTEQUAL; FUNC_ADD = GL.GL_FUNC_ADD; FUNC_MIN = GL2ES3.GL_MIN; FUNC_MAX = GL2ES3.GL_MAX; FUNC_REVERSE_SUBTRACT = GL.GL_FUNC_REVERSE_SUBTRACT; FUNC_SUBTRACT = GL.GL_FUNC_SUBTRACT; DITHER = GL.GL_DITHER; CONSTANT_COLOR = GL2ES2.GL_CONSTANT_COLOR; CONSTANT_ALPHA = GL2ES2.GL_CONSTANT_ALPHA; ONE_MINUS_CONSTANT_COLOR = GL2ES2.GL_ONE_MINUS_CONSTANT_COLOR; ONE_MINUS_CONSTANT_ALPHA = GL2ES2.GL_ONE_MINUS_CONSTANT_ALPHA; SRC_ALPHA_SATURATE = GL.GL_SRC_ALPHA_SATURATE; SCISSOR_TEST = GL.GL_SCISSOR_TEST; STENCIL_TEST = GL.GL_STENCIL_TEST; DEPTH_TEST = GL.GL_DEPTH_TEST; DEPTH_WRITEMASK = GL.GL_DEPTH_WRITEMASK; COLOR_BUFFER_BIT = GL.GL_COLOR_BUFFER_BIT; DEPTH_BUFFER_BIT = GL.GL_DEPTH_BUFFER_BIT; STENCIL_BUFFER_BIT = GL.GL_STENCIL_BUFFER_BIT; FRAMEBUFFER = GL.GL_FRAMEBUFFER; COLOR_ATTACHMENT0 = GL.GL_COLOR_ATTACHMENT0; COLOR_ATTACHMENT1 = GL2ES2.GL_COLOR_ATTACHMENT1; COLOR_ATTACHMENT2 = GL2ES2.GL_COLOR_ATTACHMENT2; COLOR_ATTACHMENT3 = GL2ES2.GL_COLOR_ATTACHMENT3; RENDERBUFFER = GL.GL_RENDERBUFFER; DEPTH_ATTACHMENT = GL.GL_DEPTH_ATTACHMENT; STENCIL_ATTACHMENT = GL.GL_STENCIL_ATTACHMENT; READ_FRAMEBUFFER = GL.GL_READ_FRAMEBUFFER; DRAW_FRAMEBUFFER = GL.GL_DRAW_FRAMEBUFFER; RGBA8 = GL.GL_RGBA8; DEPTH24_STENCIL8 = GL.GL_DEPTH24_STENCIL8; DEPTH_COMPONENT = GL2ES2.GL_DEPTH_COMPONENT; DEPTH_COMPONENT16 = GL.GL_DEPTH_COMPONENT16; DEPTH_COMPONENT24 = GL.GL_DEPTH_COMPONENT24; DEPTH_COMPONENT32 = GL.GL_DEPTH_COMPONENT32; STENCIL_INDEX = GL2ES2.GL_STENCIL_INDEX; STENCIL_INDEX1 = GL.GL_STENCIL_INDEX1; STENCIL_INDEX4 = GL.GL_STENCIL_INDEX4; STENCIL_INDEX8 = GL.GL_STENCIL_INDEX8; DEPTH_STENCIL = GL.GL_DEPTH_STENCIL; FRAMEBUFFER_COMPLETE = GL.GL_FRAMEBUFFER_COMPLETE; FRAMEBUFFER_UNDEFINED = GL2ES3.GL_FRAMEBUFFER_UNDEFINED; FRAMEBUFFER_INCOMPLETE_ATTACHMENT = GL.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT; FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = GL.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT; FRAMEBUFFER_INCOMPLETE_DIMENSIONS = GL.GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS; FRAMEBUFFER_INCOMPLETE_FORMATS = GL.GL_FRAMEBUFFER_INCOMPLETE_FORMATS; FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = GL2GL3.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER; FRAMEBUFFER_INCOMPLETE_READ_BUFFER = GL2GL3.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER; FRAMEBUFFER_UNSUPPORTED = GL.GL_FRAMEBUFFER_UNSUPPORTED; FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = GL.GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE; FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = GL3ES3.GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS; FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = GL.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE; FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = GL.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME; FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = GL.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL; FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = GL.GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE; RENDERBUFFER_WIDTH = GL.GL_RENDERBUFFER_WIDTH; RENDERBUFFER_HEIGHT = GL.GL_RENDERBUFFER_HEIGHT; RENDERBUFFER_RED_SIZE = GL.GL_RENDERBUFFER_RED_SIZE; RENDERBUFFER_GREEN_SIZE = GL.GL_RENDERBUFFER_GREEN_SIZE; RENDERBUFFER_BLUE_SIZE = GL.GL_RENDERBUFFER_BLUE_SIZE; RENDERBUFFER_ALPHA_SIZE = GL.GL_RENDERBUFFER_ALPHA_SIZE; RENDERBUFFER_DEPTH_SIZE = GL.GL_RENDERBUFFER_DEPTH_SIZE; RENDERBUFFER_STENCIL_SIZE = GL.GL_RENDERBUFFER_STENCIL_SIZE; RENDERBUFFER_INTERNAL_FORMAT = GL.GL_RENDERBUFFER_INTERNAL_FORMAT; MULTISAMPLE = GL.GL_MULTISAMPLE; LINE_SMOOTH = GL.GL_LINE_SMOOTH; POLYGON_SMOOTH = GL2GL3.GL_POLYGON_SMOOTH; SYNC_GPU_COMMANDS_COMPLETE = GL3ES3.GL_SYNC_GPU_COMMANDS_COMPLETE; ALREADY_SIGNALED = GL3ES3.GL_ALREADY_SIGNALED; CONDITION_SATISFIED = GL3ES3.GL_CONDITION_SATISFIED; } /////////////////////////////////////////////////////////// // Special Functions @Override public void flush() { gl.glFlush(); } @Override public void finish() { gl.glFinish(); } @Override public void hint(int target, int hint) { gl.glHint(target, hint); } /////////////////////////////////////////////////////////// // State and State Requests @Override public void enable(int value) { if (-1 < value) { gl.glEnable(value); } } @Override public void disable(int value) { if (-1 < value) { gl.glDisable(value); } } @Override public void getBooleanv(int value, IntBuffer data) { if (-1 < value) { if (byteBuffer.capacity() < data.capacity()) { byteBuffer = allocateDirectByteBuffer(data.capacity()); } gl.glGetBooleanv(value, byteBuffer); for (int i = 0; i < data.capacity(); i++) { data.put(i, byteBuffer.get(i)); } } else { fillIntBuffer(data, 0, data.capacity() - 1, 0); } } @Override public void getIntegerv(int value, IntBuffer data) { if (-1 < value) { gl.glGetIntegerv(value, data); } else { fillIntBuffer(data, 0, data.capacity() - 1, 0); } } @Override public void getFloatv(int value, FloatBuffer data) { if (-1 < value) { gl.glGetFloatv(value, data); } else { fillFloatBuffer(data, 0, data.capacity() - 1, 0); } } @Override public boolean isEnabled(int value) { return gl.glIsEnabled(value); } @Override public String getString(int name) { if (gl == null) { throw new PGL.GraphicsNotInitializedException("Context not initalized."); } return gl.glGetString(name); } /////////////////////////////////////////////////////////// // Error Handling @Override public int getError() { return gl.glGetError(); } @Override public String errorString(int err) { return glu.gluErrorString(err); } ////////////////////////////////////////////////////////////////////////////// // Buffer Objects @Override public void genBuffers(int n, IntBuffer buffers) { gl.glGenBuffers(n, buffers); } @Override public void deleteBuffers(int n, IntBuffer buffers) { gl.glDeleteBuffers(n, buffers); } @Override public void bindBuffer(int target, int buffer) { gl.glBindBuffer(target, buffer); } @Override public void bufferData(int target, int size, Buffer data, int usage) { gl.glBufferData(target, size, data, usage); } @Override public void bufferSubData(int target, int offset, int size, Buffer data) { gl.glBufferSubData(target, offset, size, data); } @Override public void isBuffer(int buffer) { gl.glIsBuffer(buffer); } @Override public void getBufferParameteriv(int target, int value, IntBuffer data) { gl.glGetBufferParameteriv(target, value, data); } @Override public ByteBuffer mapBuffer(int target, int access) { return gl2.glMapBuffer(target, access); } @Override public ByteBuffer mapBufferRange(int target, int offset, int length, int access) { if (gl2x != null) { return gl2x.glMapBufferRange(target, offset, length, access); } else if (gl3 != null) { return gl3.glMapBufferRange(target, offset, length, access); } else { throw new RuntimeException(String.format(MISSING_GLFUNC_ERROR, "glMapBufferRange()")); } } @Override public void unmapBuffer(int target) { gl2.glUnmapBuffer(target); } ////////////////////////////////////////////////////////////////////////////// // Synchronization @Override public long fenceSync(int condition, int flags) { if (gl3es3 != null) { return gl3es3.glFenceSync(condition, flags); } else { throw new RuntimeException(String.format(MISSING_GLFUNC_ERROR, "fenceSync()")); } } @Override public void deleteSync(long sync) { if (gl3es3 != null) { gl3es3.glDeleteSync(sync); } else { throw new RuntimeException(String.format(MISSING_GLFUNC_ERROR, "deleteSync()")); } } @Override public int clientWaitSync(long sync, int flags, long timeout) { if (gl3es3 != null) { return gl3es3.glClientWaitSync(sync, flags, timeout); } else { throw new RuntimeException(String.format(MISSING_GLFUNC_ERROR, "clientWaitSync()")); } } ////////////////////////////////////////////////////////////////////////////// // Viewport and Clipping @Override public void depthRangef(float n, float f) { gl.glDepthRangef(n, f); } @Override public void viewport(int x, int y, int w, int h) { float scale = getPixelScale(); viewportImpl((int)scale * x, (int)(scale * y), (int)(scale * w), (int)(scale * h)); } @Override protected void viewportImpl(int x, int y, int w, int h) { gl.glViewport(x, y, w, h); } ////////////////////////////////////////////////////////////////////////////// // Reading Pixels @Override protected void readPixelsImpl(int x, int y, int width, int height, int format, int type, Buffer buffer) { gl.glReadPixels(x, y, width, height, format, type, buffer); } @Override protected void readPixelsImpl(int x, int y, int width, int height, int format, int type, long offset) { gl.glReadPixels(x, y, width, height, format, type, 0); } ////////////////////////////////////////////////////////////////////////////// // Vertices @Override public void vertexAttrib1f(int index, float value) { gl2.glVertexAttrib1f(index, value); } @Override public void vertexAttrib2f(int index, float value0, float value1) { gl2.glVertexAttrib2f(index, value0, value1); } @Override public void vertexAttrib3f(int index, float value0, float value1, float value2) { gl2.glVertexAttrib3f(index, value0, value1, value2); } @Override public void vertexAttrib4f(int index, float value0, float value1, float value2, float value3) { gl2.glVertexAttrib4f(index, value0, value1, value2, value3); } @Override public void vertexAttrib1fv(int index, FloatBuffer values) { gl2.glVertexAttrib1fv(index, values); } @Override public void vertexAttrib2fv(int index, FloatBuffer values) { gl2.glVertexAttrib2fv(index, values); } @Override public void vertexAttrib3fv(int index, FloatBuffer values) { gl2.glVertexAttrib3fv(index, values); } @Override public void vertexAttrib4fv(int index, FloatBuffer values) { gl2.glVertexAttrib4fv(index, values); } @Override public void vertexAttribPointer(int index, int size, int type, boolean normalized, int stride, int offset) { gl2.glVertexAttribPointer(index, size, type, normalized, stride, offset); } @Override public void enableVertexAttribArray(int index) { gl2.glEnableVertexAttribArray(index); } @Override public void disableVertexAttribArray(int index) { gl2.glDisableVertexAttribArray(index); } @Override public void drawArraysImpl(int mode, int first, int count) { gl.glDrawArrays(mode, first, count); } @Override public void drawElementsImpl(int mode, int count, int type, int offset) { gl.glDrawElements(mode, count, type, offset); } ////////////////////////////////////////////////////////////////////////////// // Rasterization @Override public void lineWidth(float width) { gl.glLineWidth(width); } @Override public void frontFace(int dir) { gl.glFrontFace(dir); } @Override public void cullFace(int mode) { gl.glCullFace(mode); } @Override public void polygonOffset(float factor, float units) { gl.glPolygonOffset(factor, units); } ////////////////////////////////////////////////////////////////////////////// // Pixel Rectangles @Override public void pixelStorei(int pname, int param) { gl.glPixelStorei(pname, param); } /////////////////////////////////////////////////////////// // Texturing @Override public void texImage2D(int target, int level, int internalFormat, int width, int height, int border, int format, int type, Buffer data) { gl.glTexImage2D(target, level, internalFormat, width, height, border, format, type, data); } @Override public void copyTexImage2D(int target, int level, int internalFormat, int x, int y, int width, int height, int border) { gl.glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border); } @Override public void texSubImage2D(int target, int level, int xOffset, int yOffset, int width, int height, int format, int type, Buffer data) { gl.glTexSubImage2D(target, level, xOffset, yOffset, width, height, format, type, data); } @Override public void copyTexSubImage2D(int target, int level, int xOffset, int yOffset, int x, int y, int width, int height) { gl.glCopyTexSubImage2D(target, level, x, y, xOffset, yOffset, width, height); } @Override public void compressedTexImage2D(int target, int level, int internalFormat, int width, int height, int border, int imageSize, Buffer data) { gl.glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data); } @Override public void compressedTexSubImage2D(int target, int level, int xOffset, int yOffset, int width, int height, int format, int imageSize, Buffer data) { gl.glCompressedTexSubImage2D(target, level, xOffset, yOffset, width, height, format, imageSize, data); } @Override public void texParameteri(int target, int pname, int param) { gl.glTexParameteri(target, pname, param); } @Override public void texParameterf(int target, int pname, float param) { gl.glTexParameterf(target, pname, param); } @Override public void texParameteriv(int target, int pname, IntBuffer params) { gl.glTexParameteriv(target, pname, params); } @Override public void texParameterfv(int target, int pname, FloatBuffer params) { gl.glTexParameterfv(target, pname, params); } @Override public void generateMipmap(int target) { gl.glGenerateMipmap(target); } @Override public void genTextures(int n, IntBuffer textures) { gl.glGenTextures(n, textures); } @Override public void deleteTextures(int n, IntBuffer textures) { gl.glDeleteTextures(n, textures); } @Override public void getTexParameteriv(int target, int pname, IntBuffer params) { gl.glGetTexParameteriv(target, pname, params); } @Override public void getTexParameterfv(int target, int pname, FloatBuffer params) { gl.glGetTexParameterfv(target, pname, params); } @Override public boolean isTexture(int texture) { return gl.glIsTexture(texture); } @Override protected void activeTextureImpl(int texture) { gl.glActiveTexture(texture); } @Override protected void bindTextureImpl(int target, int texture) { gl.glBindTexture(target, texture); } /////////////////////////////////////////////////////////// // Shaders and Programs @Override public int createShader(int type) { return gl2.glCreateShader(type); } @Override public void shaderSource(int shader, String source) { gl2.glShaderSource(shader, 1, new String[] { source }, null, 0); } @Override public void compileShader(int shader) { gl2.glCompileShader(shader); } @Override public void releaseShaderCompiler() { gl2.glReleaseShaderCompiler(); } @Override public void deleteShader(int shader) { gl2.glDeleteShader(shader); } @Override public void shaderBinary(int count, IntBuffer shaders, int binaryFormat, Buffer binary, int length) { gl2.glShaderBinary(count, shaders, binaryFormat, binary, length); } @Override public int createProgram() { return gl2.glCreateProgram(); } @Override public void attachShader(int program, int shader) { gl2.glAttachShader(program, shader); } @Override public void detachShader(int program, int shader) { gl2.glDetachShader(program, shader); } @Override public void linkProgram(int program) { gl2.glLinkProgram(program); } @Override public void useProgram(int program) { gl2.glUseProgram(program); } @Override public void deleteProgram(int program) { gl2.glDeleteProgram(program); } @Override public String getActiveAttrib(int program, int index, IntBuffer size, IntBuffer type) { int[] tmp = {0, 0, 0}; byte[] namebuf = new byte[1024]; gl2.glGetActiveAttrib(program, index, 1024, tmp, 0, tmp, 1, tmp, 2, namebuf, 0); size.put(tmp[1]); type.put(tmp[2]); String name = new String(namebuf, 0, tmp[0]); return name; } @Override public int getAttribLocation(int program, String name) { return gl2.glGetAttribLocation(program, name); } @Override public void bindAttribLocation(int program, int index, String name) { gl2.glBindAttribLocation(program, index, name); } @Override public int getUniformLocation(int program, String name) { return gl2.glGetUniformLocation(program, name); } @Override public String getActiveUniform(int program, int index, IntBuffer size, IntBuffer type) { int[] tmp= {0, 0, 0}; byte[] namebuf = new byte[1024]; gl2.glGetActiveUniform(program, index, 1024, tmp, 0, tmp, 1, tmp, 2, namebuf, 0); size.put(tmp[1]); type.put(tmp[2]); String name = new String(namebuf, 0, tmp[0]); return name; } @Override public void uniform1i(int location, int value) { gl2.glUniform1i(location, value); } @Override public void uniform2i(int location, int value0, int value1) { gl2.glUniform2i(location, value0, value1); } @Override public void uniform3i(int location, int value0, int value1, int value2) { gl2.glUniform3i(location, value0, value1, value2); } @Override public void uniform4i(int location, int value0, int value1, int value2, int value3) { gl2.glUniform4i(location, value0, value1, value2, value3); } @Override public void uniform1f(int location, float value) { gl2.glUniform1f(location, value); } @Override public void uniform2f(int location, float value0, float value1) { gl2.glUniform2f(location, value0, value1); } @Override public void uniform3f(int location, float value0, float value1, float value2) { gl2.glUniform3f(location, value0, value1, value2); } @Override public void uniform4f(int location, float value0, float value1, float value2, float value3) { gl2.glUniform4f(location, value0, value1, value2, value3); } @Override public void uniform1iv(int location, int count, IntBuffer v) { gl2.glUniform1iv(location, count, v); } @Override public void uniform2iv(int location, int count, IntBuffer v) { gl2.glUniform2iv(location, count, v); } @Override public void uniform3iv(int location, int count, IntBuffer v) { gl2.glUniform3iv(location, count, v); } @Override public void uniform4iv(int location, int count, IntBuffer v) { gl2.glUniform4iv(location, count, v); } @Override public void uniform1fv(int location, int count, FloatBuffer v) { gl2.glUniform1fv(location, count, v); } @Override public void uniform2fv(int location, int count, FloatBuffer v) { gl2.glUniform2fv(location, count, v); } @Override public void uniform3fv(int location, int count, FloatBuffer v) { gl2.glUniform3fv(location, count, v); } @Override public void uniform4fv(int location, int count, FloatBuffer v) { gl2.glUniform4fv(location, count, v); } @Override public void uniformMatrix2fv(int location, int count, boolean transpose, FloatBuffer mat) { gl2.glUniformMatrix2fv(location, count, transpose, mat); } @Override public void uniformMatrix3fv(int location, int count, boolean transpose, FloatBuffer mat) { gl2.glUniformMatrix3fv(location, count, transpose, mat); } @Override public void uniformMatrix4fv(int location, int count, boolean transpose, FloatBuffer mat) { gl2.glUniformMatrix4fv(location, count, transpose, mat); } @Override public void validateProgram(int program) { gl2.glValidateProgram(program); } @Override public boolean isShader(int shader) { return gl2.glIsShader(shader); } @Override public void getShaderiv(int shader, int pname, IntBuffer params) { gl2.glGetShaderiv(shader, pname, params); } @Override public void getAttachedShaders(int program, int maxCount, IntBuffer count, IntBuffer shaders) { gl2.glGetAttachedShaders(program, maxCount, count, shaders); } @Override public String getShaderInfoLog(int shader) { int[] val = { 0 }; gl2.glGetShaderiv(shader, GL2ES2.GL_INFO_LOG_LENGTH, val, 0); int length = val[0]; byte[] log = new byte[length]; gl2.glGetShaderInfoLog(shader, length, val, 0, log, 0); return new String(log); } @Override public String getShaderSource(int shader) { int[] len = {0}; byte[] buf = new byte[1024]; gl2.glGetShaderSource(shader, 1024, len, 0, buf, 0); return new String(buf, 0, len[0]); } @Override public void getShaderPrecisionFormat(int shaderType, int precisionType, IntBuffer range, IntBuffer precision) { gl2.glGetShaderPrecisionFormat(shaderType, precisionType, range, precision); } @Override public void getVertexAttribfv(int index, int pname, FloatBuffer params) { gl2.glGetVertexAttribfv(index, pname, params); } @Override public void getVertexAttribiv(int index, int pname, IntBuffer params) { gl2.glGetVertexAttribiv(index, pname, params); } @Override public void getVertexAttribPointerv(int index, int pname, ByteBuffer data) { throw new RuntimeException(String.format(MISSING_GLFUNC_ERROR, "glGetVertexAttribPointerv()")); } @Override public void getUniformfv(int program, int location, FloatBuffer params) { gl2.glGetUniformfv(program, location, params); } @Override public void getUniformiv(int program, int location, IntBuffer params) { gl2.glGetUniformiv(program, location, params); } @Override public boolean isProgram(int program) { return gl2.glIsProgram(program); } @Override public void getProgramiv(int program, int pname, IntBuffer params) { gl2.glGetProgramiv(program, pname, params); } @Override public String getProgramInfoLog(int program) { int[] val = { 0 }; gl2.glGetProgramiv(program, GL2ES2.GL_INFO_LOG_LENGTH, val, 0); int length = val[0]; if (0 < length) { byte[] log = new byte[length]; gl2.glGetProgramInfoLog(program, length, val, 0, log, 0); return new String(log); } else { return "Unknown error"; } } /////////////////////////////////////////////////////////// // Per-Fragment Operations @Override public void scissor(int x, int y, int w, int h) { float scale = getPixelScale(); gl.glScissor((int)scale * x, (int)(scale * y), (int)(scale * w), (int)(scale * h)); // gl.glScissor(x, y, w, h); } @Override public void sampleCoverage(float value, boolean invert) { gl2.glSampleCoverage(value, invert); } @Override public void stencilFunc(int func, int ref, int mask) { gl2.glStencilFunc(func, ref, mask); } @Override public void stencilFuncSeparate(int face, int func, int ref, int mask) { gl2.glStencilFuncSeparate(face, func, ref, mask); } @Override public void stencilOp(int sfail, int dpfail, int dppass) { gl2.glStencilOp(sfail, dpfail, dppass); } @Override public void stencilOpSeparate(int face, int sfail, int dpfail, int dppass) { gl2.glStencilOpSeparate(face, sfail, dpfail, dppass); } @Override public void depthFunc(int func) { gl.glDepthFunc(func); } @Override public void blendEquation(int mode) { gl.glBlendEquation(mode); } @Override public void blendEquationSeparate(int modeRGB, int modeAlpha) { gl.glBlendEquationSeparate(modeRGB, modeAlpha); } @Override public void blendFunc(int src, int dst) { gl.glBlendFunc(src, dst); } @Override public void blendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) { gl.glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); } @Override public void blendColor(float red, float green, float blue, float alpha) { gl2.glBlendColor(red, green, blue, alpha); } // Whole Framebuffer Operations @Override public void colorMask(boolean r, boolean g, boolean b, boolean a) { gl.glColorMask(r, g, b, a); } @Override public void depthMask(boolean mask) { gl.glDepthMask(mask); } @Override public void stencilMask(int mask) { gl.glStencilMask(mask); } @Override public void stencilMaskSeparate(int face, int mask) { gl2.glStencilMaskSeparate(face, mask); } @Override public void clearColor(float r, float g, float b, float a) { gl.glClearColor(r, g, b, a); } @Override public void clearDepth(float d) { gl.glClearDepth(d); } @Override public void clearStencil(int s) { gl.glClearStencil(s); } @Override public void clear(int buf) { gl.glClear(buf); } /////////////////////////////////////////////////////////// // Framebuffers Objects @Override protected void bindFramebufferImpl(int target, int framebuffer) { gl.glBindFramebuffer(target, framebuffer); } @Override public void deleteFramebuffers(int n, IntBuffer framebuffers) { gl.glDeleteFramebuffers(n, framebuffers); } @Override public void genFramebuffers(int n, IntBuffer framebuffers) { gl.glGenFramebuffers(n, framebuffers); } @Override public void bindRenderbuffer(int target, int renderbuffer) { gl.glBindRenderbuffer(target, renderbuffer); } @Override public void deleteRenderbuffers(int n, IntBuffer renderbuffers) { gl.glDeleteRenderbuffers(n, renderbuffers); } @Override public void genRenderbuffers(int n, IntBuffer renderbuffers) { gl.glGenRenderbuffers(n, renderbuffers); } @Override public void renderbufferStorage(int target, int internalFormat, int width, int height) { gl.glRenderbufferStorage(target, internalFormat, width, height); } @Override public void framebufferRenderbuffer(int target, int attachment, int rendbuferfTarget, int renderbuffer) { gl.glFramebufferRenderbuffer(target, attachment, rendbuferfTarget, renderbuffer); } @Override public void framebufferTexture2D(int target, int attachment, int texTarget, int texture, int level) { gl.glFramebufferTexture2D(target, attachment, texTarget, texture, level); } @Override public int checkFramebufferStatus(int target) { return gl.glCheckFramebufferStatus(target); } @Override public boolean isFramebuffer(int framebuffer) { return gl2.glIsFramebuffer(framebuffer); } @Override public void getFramebufferAttachmentParameteriv(int target, int attachment, int pname, IntBuffer params) { gl2.glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); } @Override public boolean isRenderbuffer(int renderbuffer) { return gl2.glIsRenderbuffer(renderbuffer); } @Override public void getRenderbufferParameteriv(int target, int pname, IntBuffer params) { gl2.glGetRenderbufferParameteriv(target, pname, params); } @Override public void blitFramebuffer(int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, int mask, int filter) { if (gl2x != null) { gl2x.glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); } else if (gl3 != null) { gl3.glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); } else if (gl3es3 != null) { gl3es3.glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); } else { throw new RuntimeException(String.format(MISSING_GLFUNC_ERROR, "glBlitFramebuffer()")); } } @Override public void renderbufferStorageMultisample(int target, int samples, int format, int width, int height) { if (gl2x != null) { gl2x.glRenderbufferStorageMultisample(target, samples, format, width, height); } else if (gl3 != null) { gl3.glRenderbufferStorageMultisample(target, samples, format, width, height); } else if (gl3es3 != null) { gl3es3.glRenderbufferStorageMultisample(target, samples, format, width, height); } else { throw new RuntimeException(String.format(MISSING_GLFUNC_ERROR, "glRenderbufferStorageMultisample()")); } } @Override public void readBuffer(int buf) { if (gl2x != null) { gl2x.glReadBuffer(buf); } else if (gl3 != null) { gl3.glReadBuffer(buf); } else if (gl3es3 != null) { gl3es3.glReadBuffer(buf); } else { throw new RuntimeException(String.format(MISSING_GLFUNC_ERROR, "glReadBuffer()")); } } @Override public void drawBuffer(int buf) { if (gl2x != null) { gl2x.glDrawBuffer(buf); } else if (gl3 != null) { gl3.glDrawBuffer(buf); } else if (gl3es3 != null) { IntBuffer intBuffer = IntBuffer.allocate(1); intBuffer.put(buf); intBuffer.rewind(); gl3es3.glDrawBuffers(1, intBuffer); } else { throw new RuntimeException(String.format(MISSING_GLFUNC_ERROR, "glDrawBuffer()")); } } }