Package jgl

Class GL<ImageType,​FontType>

  • Direct Known Subclasses:
    GL, GL
    public abstract class GL<ImageType,​FontType>
extends Object
    GL is the main class of jGL 2.4.
    Version:
    0.9, 14 May 2003
    Author:
    Robin Bing-Yu Chen

    • Constructor Detail

      • GL

        public GL()

    • Method Detail

      • setThrowExceptionOnGLError

        public void setThrowExceptionOnGLError​(boolean status)

      • getThrowExceptionOnGLError

        public boolean getThrowExceptionOnGLError()

      • getPixelScaleX

        public double getPixelScaleX()

      • getPixelScaleY

        public double getPixelScaleY()

      • getStartX

        public int getStartX()

      • getStartY

        public int getStartY()

      • getDesiredWidth

        public int getDesiredWidth()
        Return the width configured for this GL

      • getDesiredHeight

        public int getDesiredHeight()
        Return the height configured for this GL

      • glShadeModel

        public void glShadeModel​(int mode)

      • glFlush

        public abstract void glFlush()
        Creates a new ImageType based on the current color buffer.

      • firePixelScaleChanged

        protected void firePixelScaleChanged​(double pixelScaleX,
                                     double pixelScaleY)

      • setPixelScaleX

        public void setPixelScaleX​(double pixelScaleX)

      • setPixelScaleY

        public void setPixelScaleY​(double pixelScaleY)

      • resetPixelScale

        protected void resetPixelScale()
        Reset pixel scale to (1,1)

      • checkColorBuffer

        protected void checkColorBuffer()
        Print statistics about color buffer content for debugging.

      • getShiftHorizontally

        public int getShiftHorizontally()

      • setShiftHorizontally

        public void setShiftHorizontally​(int shiftHorizontally)
        Allows shifting the image of the 3d scene and all images that have been append with appendImageToDraw(Object)
        Parameters:
        shift - to the right if value is positive, to the left if the value is negative.

      • isClearBackgroundWithG2d

        public boolean isClearBackgroundWithG2d()

      • setClearBackgroundWithG2d

        public void setClearBackgroundWithG2d​(boolean clearBackgroundWithG2d)
        If true, will clear the background with a rectangle colored with the current GL clear color.

      • isUseOSFontRendering

        public boolean isUseOSFontRendering()

      • setUseOSFontRendering

        public void setUseOSFontRendering​(boolean useOSFontRendering)
        If true, will use the OS for font rendering of all texts that have been append with appendTextToDraw(Object, String, int, int) otherwise use a JVM based font rendering.

      • isAutoAdaptToHiDPI

        public boolean isAutoAdaptToHiDPI()

      • setAutoAdaptToHiDPI

        public void setAutoAdaptToHiDPI​(boolean autoAdaptToHiDPI)
        If true, will consider pixel resolution of an HiDPI device to render chart with a better look. Texts render smaller as the font size is given in pixel. To avoid this, either use bigger font size or disable HiDPI adaptation.

      • appendImageToDraw

        public void appendImageToDraw​(ImageType image)

      • appendImageToDraw

        public void appendImageToDraw​(ImageType image,
                              int x,
                              int y)

      • appendImageToDraw

        public void appendImageToDraw​(ImageType image,
                              int x,
                              int y,
                              GL.ImageLayer layer)

      • getRenderedImage

        public abstract ImageType getRenderedImage()

      • clearImagesBuffer

        public void clearImagesBuffer()

      • appendTextToDraw

        public void appendTextToDraw​(FontType font,
                             String string,
                             int x,
                             int y)
        To be called by GLUT#glutBitmapString(Object, String, float, float) to append text to a list of text to render at glFlush() step.

      • appendTextToDraw

        public void appendTextToDraw​(FontType font,
                             String string,
                             int x,
                             int y,
                             float r,
                             float g,
                             float b,
                             float rotate)
        To be called by GLUT#glutBitmapString(Object, String, float, float) to append text to a list of text to render at glFlush() step.

      • clearTextToDraw

        public void clearTextToDraw()

      • glClearColor

        public void glClearColor​(float red,
                         float green,
                         float blue,
                         float alpha)
        Sets the clear value for the color buffers in RGBA mode. Each of the specified components is clamped to [0,1] and converted to fixed-point.
        Parameters:
        red - the red component.
        green - the green component.
        blue - the blue component.
        alpha - the alpha component.
        See Also:
        glClear(int)

      • glColorMask

        public void glColorMask​(boolean red,
                        boolean green,
                        boolean blue,
                        boolean alpha)
        GLvoid glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )

      • glBlendFunc

        public void glBlendFunc​(int sfactor,
                        int dfactor)
        GLvoid glBlendFunc (GLenum sfactor, GLenum dfactor)

      • glCullFace

        public void glCullFace​(int mode)
        GLvoid glCullFace (GLenum mode)

      • glFrontFace

        public void glFrontFace​(int mode)
        GLvoid glFrontFace (GLenum mode)

      • glPointSize

        public void glPointSize​(float size)
        Sets the width in pixels for rendered points. size must be greater than 0.0 and by default is 1.0.
        Parameters:
        size - the width or diameter of a point.

      • glLineWidth

        public void glLineWidth​(float width)
        Sets the width in pixels for rendered lines. width must be greater than 0.0 and by default is 1.0.
        Parameters:
        width - the width of a line.

      • glLineStipple

        public void glLineStipple​(int factor,
                          short pattern)
        Sets the current stippling patterm for lines. The pattern argument is a 16-bit series of 0s and 1s, and it's repeated as necessary to stipple a given line. A 1 indicates that drawing occurs, and 0 that it does not, on a pixel-by-pixel basis, beginning with the low-order bits of the pattern. The pattern can be stretched out by using factor, which multiplies each subseries of consecutive 1s and 0s.
        Parameters:
        factor - the count.
        pattern - pattern.
        See Also:
        GL_LINE_STIPPLE

      • glPolygonMode

        public void glPolygonMode​(int face,
                          int mode)
        GLvoid glPolygonMode (GLenum face, GLenum mode )

      • glPolygonStipple

        public void glPolygonStipple​(byte[] mask)
        Defines the current stipple pattern for filled polygons. The argument mask is a 32x32 bitmap that's interpreted as a mask of 0s and 1s. Where a 1 appears, the corresponding pixel in the polygon is drawn, and where a 0 appears, nothing is drawn.
        Parameters:
        mask - the mask bitmap.
        See Also:
        GL_POLYGON_STIPPLE

      • glClipPlane

        public void glClipPlane​(int plane,
                        double[] equation)
        GLvoid glClipPlane (GLenum plane, const GLdouble *equation)

      • glGetClipPlane

        public void glGetClipPlane​(int plane,
                           double[] equation)
        GLvoid glGetClipPlane (GLenum plane, GLdouble *equation)

      • glEnable

        public void glEnable​(int cap)
        GLvoid glEnable (GLenum cap)

      • glDisable

        public void glDisable​(int cap)
        GLvoid glDisable (GLenum cap)

      • glIsEnabled

        public boolean glIsEnabled​(int cap)
        GLboolean glIsEnabled (GLenum cap)

      • glGetBooleanv

        public void glGetBooleanv​(int pname,
                          boolean[] params)
        GLvoid glGetBooleanv (GLenum pname, GLboolean *params)

      • glGetDoublev

        public void glGetDoublev​(int pname,
                         double[] params)
        GLvoid glGetDoublev (GLenum pname, GLdouble *params)

      • glGetFloatv

        public void glGetFloatv​(int pname,
                        float[] params)
        GLvoid glGetFloatv (GLenum pname, GLfloat *params)

      • glGetIntegerv

        public void glGetIntegerv​(int pname,
                          int[] params)
        GLvoid glGetIntegerv (GLenum pname, GLint *params)

      • glPushAttrib

        public void glPushAttrib​(int mask)
        GLvoid glPushAttrib (GLbitfield mask)

      • glPopAttrib

        public void glPopAttrib()
        GLvoid glPopAttrib (GLvoid)

      • glRenderMode

        public int glRenderMode​(int mode)
        GLint glRenderMode (GLenum mode)

      • glGetString

        public String glGetString​(int name)
        const GLubyte *glGetString (GLenum name)

      • glClearDepth

        public void glClearDepth​(double depth)
        Sets the window z value. The depth is a floating point value that is clamped to the range [0,1] and converted to fixed-point.
        Parameters:
        depth - the window z value.
        See Also:
        glClear(int)

      • glDepthFunc

        public void glDepthFunc​(int func)
        GLvoid glDepthFunc (GLenum func)

      • glDepthMask

        public void glDepthMask​(boolean flag)
        GLvoid glDepthMask (GLboolean flag)

      • glDepthRange

        public void glDepthRange​(double near_val,
                         double far_val)
        GLvoid glDepthRange (GLclampd near_val, GLclampd far_val)

      • glMatrixMode

        public void glMatrixMode​(int mode)
        GLvoid glMatrixMode (GLenum mode)

      • glOrtho

        public void glOrtho​(double left,
                    double right,
                    double bottom,
                    double top,
                    double near_val,
                    double far_val)
        GLvoid glOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val)

      • glFrustum

        public void glFrustum​(double left,
                      double right,
                      double bottom,
                      double top,
                      double near_val,
                      double far_val)
        GLvoid glFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val)

      • glViewport

        public void glViewport​(int x,
                       int y,
                       int width,
                       int height)
        GLvoid glViewport (GLint x, GLint y, GLsizei width, GLsizei height);

      • applyViewport

        public void applyViewport()
        Apply viewport according to the latest known expected width/height and the latest known pixel scales.

      • glPushMatrix

        public void glPushMatrix()
        GLvoid glPushMatrix (GLvoid)

      • glPopMatrix

        public void glPopMatrix()
        GLvoid glPopMatrix (GLvoid)

      • glLoadIdentity

        public void glLoadIdentity()
        GLvoid glLoadIdentity (GLvoid)

      • glLoadMatrixd

        public void glLoadMatrixd​(double[] m)
        GLvoid glLoadMatrixd (const GLdouble *m)

      • glLoadMatrixf

        public void glLoadMatrixf​(float[] m)
        GLvoid glLoadMatrixf (const GLfloat *m)

      • glMultMatrixd

        public void glMultMatrixd​(double[] m)
        GLvoid glMultMatrixd (const GLdouble *m)

      • glMultMatrixf

        public void glMultMatrixf​(float[] m)
        GLvoid glMultMatrixf (const GLfloat *m)

      • glRotated

        public void glRotated​(double angle,
                      double x,
                      double y,
                      double z)
        GLvoid glRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z)

      • glRotatef

        public void glRotatef​(float angle,
                      float x,
                      float y,
                      float z)
        GLvoid glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z)

      • glScaled

        public void glScaled​(double x,
                     double y,
                     double z)
        GLvoid glScaled (GLdouble x, GLdouble y, GLdouble z)

      • glScalef

        public void glScalef​(float x,
                     float y,
                     float z)
        GLvoid glScalef (GLfloat x, GLfloat y, GLfloat z)

      • glTranslated

        public void glTranslated​(double x,
                         double y,
                         double z)
        GLvoid glTranslated (GLdouble x, GLdouble y, GLdouble z)

      • glTranslatef

        public void glTranslatef​(float x,
                         float y,
                         float z)
        GLvoid glTranslatef (GLfloat x, GLfloat y, GLfloat z)

      • glIsList

        public boolean glIsList​(int list)
        GLboolean glIsList (GLuint list)

      • glDeleteLists

        public void glDeleteLists​(int list,
                          int range)
        GLvoid glDeleteLists (GLuint list, GLsizei range)

      • glGenLists

        public int glGenLists​(int range)
        GLuint glGenLists (GLsizei range)

      • glNewList

        public void glNewList​(int list,
                      int mode)
        GLvoid glNewList (GLuint list, GLenum mode)

      • glEndList

        public void glEndList()
        GLvoid glEndList (GLvoid)

      • glCallList

        public void glCallList​(int list)
        GLvoid glCallList (GLuint list)

      • glCallLists

        public void glCallLists​(int n,
                        int type,
                        byte[] lists)
        GLvoid glCallLists (sizei n, GLenum type, const GLvoid *lists)

      • glListBase

        public void glListBase​(int base)
        GLvoid glListBase (GLuint base)

      • glBegin

        public void glBegin​(int mode)
        GLvoid glBegin (GLenum mode)

      • glEnd

        public void glEnd()
        GLvoid glEnd (GLvoid)

      • glVertex2d

        public void glVertex2d​(double x,
                       double y)
        GLvoid glVertex2d (GLdouble x, GLdouble y)

      • glVertex2f

        public void glVertex2f​(float x,
                       float y)
        GLvoid glVertex2f (GLfloat x, GLfloat y)

      • glVertex2i

        public void glVertex2i​(int x,
                       int y)
        GLvoid glVertex2i (GLint x, GLint y)

      • glVertex2s

        public void glVertex2s​(short x,
                       short y)
        GLvoid glVertex2s (GLshort x, GLshort y)

      • glVertex3d

        public void glVertex3d​(double x,
                       double y,
                       double z)
        GLvoid glVertex3d (GLdouble x, GLdouble y, GLdouble z)

      • glVertex3f

        public void glVertex3f​(float x,
                       float y,
                       float z)
        GLvoid glVertex3f (GLfloat x, GLfloat y, GLfloat z)

      • glVertex3i

        public void glVertex3i​(int x,
                       int y,
                       int z)
        GLvoid glVertex3i (GLint x, GLint y, GLint z)

      • glVertex3s

        public void glVertex3s​(short x,
                       short y,
                       short z)
        GLvoid glVertex3s (GLshort x, GLshort y, GLshort z)

      • glVertex4d

        public void glVertex4d​(double x,
                       double y,
                       double z,
                       double w)
        GLvoid glVertex4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w)

      • glVertex4f

        public void glVertex4f​(float x,
                       float y,
                       float z,
                       float w)
        GLvoid glVertex4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w)

      • glVertex4i

        public void glVertex4i​(int x,
                       int y,
                       int z,
                       int w)
        GLvoid glVertex4i (GLint x, GLint y, GLint z, GLint w)

      • glVertex4s

        public void glVertex4s​(short x,
                       short y,
                       short z,
                       short w)
        GLvoid glVertex4s (GLshort x, GLshort y, GLshort z, GLshort w)

      • glVertex2dv

        public void glVertex2dv​(double[] v)
        GLvoid glVertex2dv (GLdouble *v)

      • glVertex2fv

        public void glVertex2fv​(float[] v)
        GLvoid glVertex2fv (GLfloat *v)

      • glVertex2iv

        public void glVertex2iv​(int[] v)
        GLvoid glVertex2iv (GLint *v)

      • glVertex2sv

        public void glVertex2sv​(short[] v)
        GLvoid glVertex2sv (GLshort *v)

      • glVertex3dv

        public void glVertex3dv​(double[] v)
        GLvoid glVertex3dv (GLdouble *v)

      • glVertex3fv

        public void glVertex3fv​(float[] v)
        GLvoid glVertex3fv (GLfloat *v)

      • glVertex3iv

        public void glVertex3iv​(int[] v)
        GLvoid glVertex3iv (GLint *v)

      • glVertex3sv

        public void glVertex3sv​(short[] v)
        GLvoid glVertex3sv (GLshort *v)

      • glVertex4dv

        public void glVertex4dv​(double[] v)
        GLvoid glVertex4dv (GLdouble *v)

      • glVertex4fv

        public void glVertex4fv​(float[] v)
        GLvoid glVertex4fv (GLfloat *v)

      • glVertex4iv

        public void glVertex4iv​(int[] v)
        GLvoid glVertex4iv (GLint *v)

      • glVertex4sv

        public void glVertex4sv​(short[] v)
        GLvoid glVertex4sv (GLshort *v)

      • glNormal3b

        public void glNormal3b​(byte x,
                       byte y,
                       byte z)
        GLvoid glNormal3b (GLbyte x, GLbyte y, GLbyte z)

      • glNormal3d

        public void glNormal3d​(double x,
                       double y,
                       double z)
        GLvoid glNormal3d (GLdouble x, GLdouble y, GLdouble z)

      • glNormal3f

        public void glNormal3f​(float x,
                       float y,
                       float z)
        GLvoid glNormal3f (GLfloat x, GLfloat y, GLfloat z)

      • glNormal3i

        public void glNormal3i​(int x,
                       int y,
                       int z)
        GLvoid glNormal3i (GLint x, GLint y, GLint z)

      • glNormal3s

        public void glNormal3s​(short x,
                       short y,
                       short z)
        GLvoid glNormal3s (GLshort x, GLshort y, GLshort z)

      • glNormal3bv

        public void glNormal3bv​(byte[] v)
        GLvoid glNormal3bv (GLbyte *v)

      • glNormal3dv

        public void glNormal3dv​(double[] v)
        GLvoid glNormal3dv (GLdouble *v)

      • glNormal3fv

        public void glNormal3fv​(float[] v)
        GLvoid glNormal3fv (GLfloat *v)

      • glNormal3iv

        public void glNormal3iv​(int[] v)
        GLvoid glNormal3iv (GLint *v)

      • glNormal3sv

        public void glNormal3sv​(short[] v)
        GLvoid glNormal3sv (GLshort *v)

      • glIndexd

        public void glIndexd​(double c)
        GLvoid glIndexd (GLdouble c)

      • glIndexf

        public void glIndexf​(float c)
        GLvoid glIndexf (GLfloat c)

      • glIndexi

        public void glIndexi​(int c)
        GLvoid glIndexi (GLint c)

      • glIndexs

        public void glIndexs​(short c)
        GLvoid glIndexs (GLshort c)

      • glIndexub

        public void glIndexub​(byte c)
        GLvoid glIndexub (GLubyte c)

      • glIndexdv

        public void glIndexdv​(double[] c)
        GLvoid glIndexdv (GLdouble *c)

      • glIndexfv

        public void glIndexfv​(float[] c)
        GLvoid glIndexfv (GLfloat *c)

      • glIndexiv

        public void glIndexiv​(int[] c)
        GLvoid glIndexiv (GLint *c)

      • glIndexsv

        public void glIndexsv​(short[] c)
        GLvoid glIndexsv (GLshort *c)

      • glIndexubv

        public void glIndexubv​(byte[] c)
        GLvoid glIndexubv (GLubyte *c)

      • glColor3b

        public void glColor3b​(byte red,
                      byte green,
                      byte blue)
        GLvoid glColor3b (GLbyte red, GLbyte green, GLbyte blue)

      • glColor3d

        public void glColor3d​(double red,
                      double green,
                      double blue)
        GLvoid glColor3d (GLdouble red, GLdouble green, GLdouble blue)

      • glColor3f

        public void glColor3f​(float red,
                      float green,
                      float blue)
        GLvoid glColor3f (GLfloat red, GLfloat green, GLfloat blue)

      • glColor3i

        public void glColor3i​(int red,
                      int green,
                      int blue)
        GLvoid glColor3i (GLint red, GLint green, GLint blue)

      • glColor3s

        public void glColor3s​(short red,
                      short green,
                      short blue)
        GLvoid glColor3s (GLshort red, GLshort green, GLshort blue)

      • glColor3ub

        public void glColor3ub​(byte red,
                       byte green,
                       byte blue)
        GLvoid glColor3ub (GLubyte red, GLubyte green, GLubyte blue)

      • glColor3ui

        public void glColor3ui​(int red,
                       int green,
                       int blue)
        GLvoid glColor3ui (GLuint red, GLuint green, GLuint blue)

      • glColor3us

        public void glColor3us​(short red,
                       short green,
                       short blue)
        GLvoid glColor3us (GLushort red, GLushort green, GLushort blue)

      • glColor4b

        public void glColor4b​(byte red,
                      byte green,
                      byte blue,
                      byte alpha)
        GLvoid glColor4b (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)

      • glColor4d

        public void glColor4d​(double red,
                      double green,
                      double blue,
                      double alpha)
        GLvoid glColor4d (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)

      • glColor4f

        public void glColor4f​(float red,
                      float green,
                      float blue,
                      float alpha)
        GLvoid glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)

      • glColor4i

        public void glColor4i​(int red,
                      int green,
                      int blue,
                      int alpha)
        GLvoid glColor4i (GLint red, GLint green, GLint blue, GLint alpha)

      • glColor4s

        public void glColor4s​(short red,
                      short green,
                      short blue,
                      short alpha)
        GLvoid glColor4s (GLshort red, GLshort green, GLshort blue, GLshort alpha)

      • glColor4ub

        public void glColor4ub​(byte red,
                       byte green,
                       byte blue,
                       byte alpha)
        GLvoid glColor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)

      • glColor4ui

        public void glColor4ui​(int red,
                       int green,
                       int blue,
                       int alpha)
        GLvoid glColor4ui (GLuint red, GLuint green, GLuint blue, GLuint alpha)

      • glColor4us

        public void glColor4us​(short red,
                       short green,
                       short blue,
                       short alpha)
        GLvoid glColor4us (GLushort red, GLushort green, GLushort blue, GLushort alpha)

      • glColor3bv

        public void glColor3bv​(byte[] v)
        GLvoid glColor3bv (GLbyte *v)

      • glColor3dv

        public void glColor3dv​(double[] v)
        GLvoid glColor3dv (GLdouble *v)

      • glColor3fv

        public void glColor3fv​(float[] v)
        GLvoid glColor3fv (GLfloat *v)

      • glColor3iv

        public void glColor3iv​(int[] v)
        GLvoid glColor3iv (GLint *v)

      • glColor3sv

        public void glColor3sv​(short[] v)
        GLvoid glColor3sv (GLshort *v)

      • glColor3ubv

        public void glColor3ubv​(byte[] v)
        GLvoid glColor3ubv (GLubyte *v)

      • glColor3uiv

        public void glColor3uiv​(int[] v)
        GLvoid glColor3uiv (GLuint *v)

      • glColor3usv

        public void glColor3usv​(short[] v)
        GLvoid glColor3usv (GLushort *v)

      • glColor4bv

        public void glColor4bv​(byte[] v)
        GLvoid glColor4bv (GLbyte *v)

      • glColor4dv

        public void glColor4dv​(double[] v)
        GLvoid glColor4dv (GLdouble *v)

      • glColor4fv

        public void glColor4fv​(float[] v)
        GLvoid glColor4fv (GLfloat *v)

      • glColor4iv

        public void glColor4iv​(int[] v)
        GLvoid glColor4iv (GLint *v)

      • glColor4sv

        public void glColor4sv​(short[] v)
        GLvoid glColor4sv (GLshort *v)

      • glColor4ubv

        public void glColor4ubv​(byte[] v)
        GLvoid glColor4ubv (GLubyte *v)

      • glColor4uiv

        public void glColor4uiv​(int[] v)
        GLvoid glColor4uiv (GLuint *v)

      • glColor4usv

        public void glColor4usv​(short[] v)
        GLvoid glColor4usv (GLushort *v)

      • glTexCoord1d

        public void glTexCoord1d​(double s)
        GLvoid glTexCoord1d (GLdouble s)

      • glTexCoord1f

        public void glTexCoord1f​(float s)
        GLvoid glTexCoord1f (GLfloat s)

      • glTexCoord1i

        public void glTexCoord1i​(int s)
        GLvoid glTexCoord1i (GLint s)

      • glTexCoord1s

        public void glTexCoord1s​(short s)
        GLvoid glTexCoord1s (GLshort s)

      • glTexCoord2d

        public void glTexCoord2d​(double s,
                         double t)
        GLvoid glTexCoord2d (GLdouble s, GLdouble t)

      • glTexCoord2f

        public void glTexCoord2f​(float s,
                         float t)
        GLvoid glTexCoord2f (GLfloat s, GLfloat t)

      • glTexCoord2i

        public void glTexCoord2i​(int s,
                         int t)
        GLvoid glTexCoord2i (GLint s, GLint t)

      • glTexCoord2s

        public void glTexCoord2s​(short s,
                         short t)
        GLvoid glTexCoord2s (GLshort s, GLshort t)

      • glTexCoord3d

        public void glTexCoord3d​(double s,
                         double t,
                         double r)
        GLvoid glTexCoord3d (GLdouble s, GLdouble t, GLdouble r)

      • glTexCoord3f

        public void glTexCoord3f​(float s,
                         float t,
                         float r)
        GLvoid glTexCoord3f (GLfloat s, GLfloat t, GLfloat r)

      • glTexCoord3i

        public void glTexCoord3i​(int s,
                         int t,
                         int r)
        GLvoid glTexCoord3i (GLint s, GLint t, GLint r)

      • glTexCoord3s

        public void glTexCoord3s​(short s,
                         short t,
                         short r)
        GLvoid glTexCoord3s (GLshort s, GLshort t, GLshort r)

      • glTexCoord4d

        public void glTexCoord4d​(double s,
                         double t,
                         double r,
                         double q)
        GLvoid glTexCoord4d (GLdouble s, GLdouble t, GLdouble r, GLdouble q)

      • glTexCoord4f

        public void glTexCoord4f​(float s,
                         float t,
                         float r,
                         float q)
        GLvoid glTexCoord4f (GLfloat s, GLfloat t, GLfloat r, GLfloat q)

      • glTexCoord4i

        public void glTexCoord4i​(int s,
                         int t,
                         int r,
                         int q)
        GLvoid glTexCoord4i (GLint s, GLint t, GLint r, GLint q )

      • glTexCoord4s

        public void glTexCoord4s​(short s,
                         short t,
                         short r,
                         short q)
        GLvoid glTexCoord4s (GLshort s, GLshort t, GLshort r, GLshort q)

      • glTexCoord1dv

        public void glTexCoord1dv​(double[] v)
        GLvoid glTexCoord1dv (const GLdouble *v)

      • glTexCoord1fv

        public void glTexCoord1fv​(float[] v)
        GLvoid glTexCoord1fv (const GLfloat *v)

      • glTexCoord1iv

        public void glTexCoord1iv​(int[] v)
        GLvoid glTexCoord1iv (const GLint *v)

      • glTexCoord1sv

        public void glTexCoord1sv​(short[] v)
        GLvoid glTexCoord1sv (const GLshort *v)

      • glTexCoord2dv

        public void glTexCoord2dv​(double[] v)
        GLvoid glTexCoord2dv (const GLdouble *v)

      • glTexCoord2fv

        public void glTexCoord2fv​(float[] v)
        GLvoid glTexCoord2fv (const GLfloat *v)

      • glTexCoord2iv

        public void glTexCoord2iv​(int[] v)
        GLvoid glTexCoord2iv (const GLint *v)

      • glTexCoord2sv

        public void glTexCoord2sv​(short[] v)
        GLvoid glTexCoord2sv (const GLshort *v)

      • glTexCoord3dv

        public void glTexCoord3dv​(double[] v)
        GLvoid glTexCoord3dv (const GLdouble *v)

      • glTexCoord3fv

        public void glTexCoord3fv​(float[] v)
        GLvoid glTexCoord3fv (const GLfloat *v)

      • glTexCoord3iv

        public void glTexCoord3iv​(int[] v)
        GLvoid glTexCoord3iv (const GLint *v)

      • glTexCoord3sv

        public void glTexCoord3sv​(short[] v)
        GLvoid glTexCoord3sv (const GLshort *v)

      • glTexCoord4dv

        public void glTexCoord4dv​(double[] v)
        GLvoid glTexCoord4dv (const GLdouble *v)

      • glTexCoord4fv

        public void glTexCoord4fv​(float[] v)
        GLvoid glTexCoord4fv (const GLfloat *v)

      • glTexCoord4iv

        public void glTexCoord4iv​(int[] v)
        GLvoid glTexCoord4iv (const GLint *v)

      • glTexCoord4sv

        public void glTexCoord4sv​(short[] v)
        GLvoid glTexCoord4sv (const GLshort *v)

      • glRasterPos2d

        public void glRasterPos2d​(double x,
                          double y)
        GLvoid glRasterPos2d (GLdouble x, GLdouble y)

      • glRasterPos2f

        public void glRasterPos2f​(float x,
                          float y)
        GLvoid glRasterPos2f (GLfloat x, GLfloat y)

      • glRasterPos2i

        public void glRasterPos2i​(int x,
                          int y)
        GLvoid glRasterPos2i (GLint x, GLint y)

      • glRectd

        public void glRectd​(double x1,
                    double y1,
                    double x2,
                    double y2)
        GLvoid glRectd (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)

      • glRectf

        public void glRectf​(float x1,
                    float y1,
                    float x2,
                    float y2)
        GLvoid glRectf (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)

      • glRecti

        public void glRecti​(int x1,
                    int y1,
                    int x2,
                    int y2)
        GLvoid glRecti (GLint x1, GLint y1, GLint x2, GLint y2)

      • glRects

        public void glRects​(short x1,
                    short y1,
                    short x2,
                    short y2)
        GLvoid glRects (GLshort x1, GLshort y1, GLshort x2, GLshort y2)

      • glRectdv

        public void glRectdv​(double[] v1,
                     double[] v2)
        GLvoid glRectdv (GLdouble *v1, GLdouble *v2)

      • glRectfv

        public void glRectfv​(float[] v1,
                     float[] v2)
        GLvoid glRectfv (GLfloat *v1, GLfloat *v2)

      • glRectiv

        public void glRectiv​(int[] v1,
                     int[] v2)
        GLvoid glRectiv (GLint *v1, GLint *v2)

      • glRectsv

        public void glRectsv​(short[] v1,
                     short[] v2)
        GLvoid glRectsv (GLshort *v1, GLshort *v2)

      • glLightf

        public void glLightf​(int light,
                     int pname,
                     float param)
        GLvoid glLightf (GLenum light, GLenum pname, GLfloat param)

      • glLighti

        public void glLighti​(int light,
                     int pname,
                     int param)
        GLvoid glLighti (GLenum light, GLenum pname, GLint param)

      • glLightfv

        public void glLightfv​(int light,
                      int pname,
                      float[] params)
        GLvoid glLightfv (GLenum light, GLenum pname, const GLfloat *params)

      • glLightiv

        public void glLightiv​(int light,
                      int pname,
                      int[] params)
        GLvoid glLightiv (GLenum light, GLenum pname, const GLint *params)

      • glGetLightfv

        public void glGetLightfv​(int light,
                         int pname,
                         float[] params)
        GLvoid glGetLightfv (GLenum light, GLenum pname, GLfloat *params)

      • glGetLightiv

        public void glGetLightiv​(int light,
                         int pname,
                         int[] params)
        GLvoid glGetLightiv (GLenum light, GLenum pname, GLint *params)

      • glLightModelf

        public void glLightModelf​(int pname,
                          float param)
        GLvoid glLightModelf (GLenum pname, GLfloat param)

      • glLightModelf

        public void glLightModelf​(int pname,
                          boolean param)

      • glLightModeli

        public void glLightModeli​(int pname,
                          int param)
        GLvoid glLightModeli (GLenum pname, GLint param)

      • glLightModeli

        public void glLightModeli​(int pname,
                          boolean param)

      • glLightModelfv

        public void glLightModelfv​(int pname,
                           float[] params)
        GLvoid glLightModelfv (GLenum pname, const GLfloat *params)

      • glLightModelfv

        public void glLightModelfv​(int pname,
                           boolean[] param)

      • glLightModeliv

        public void glLightModeliv​(int pname,
                           int[] params)
        GLvoid glLightModeliv (GLenum pname, const GLint *params)

      • glLightModeliv

        public void glLightModeliv​(int pname,
                           boolean[] param)

      • glMaterialf

        public void glMaterialf​(int face,
                        int pname,
                        float param)
        GLvoid glMaterialf (GLenum face, GLenum pname, GLfloat param)

      • glMateriali

        public void glMateriali​(int face,
                        int pname,
                        int param)
        GLvoid glMateriali (GLenum face, GLenum pname, GLint param)

      • glMaterialfv

        public void glMaterialfv​(int face,
                         int pname,
                         float[] params)
        GLvoid glMaterialfv (GLenum face, GLenum pname, const GLfloat *params)

      • glMaterialiv

        public void glMaterialiv​(int face,
                         int pname,
                         int[] params)
        GLvoid glMaterialiv (GLenum face, GLenum pname, const GLint *params)

      • glGetMaterialfv

        public void glGetMaterialfv​(int face,
                            int pname,
                            float[] params)
        GLvoid glGetMaterialfv (GLenum face, GLenum pname, GLfloat *params)

      • glGetMaterialiv

        public void glGetMaterialiv​(int face,
                            int pname,
                            int[] params)
        GLvoid glGetMaterialiv (GLenum face, GLenum pname, GLint *params)

      • glColorMaterial

        public void glColorMaterial​(int face,
                            int mode)
        GLvoid glColorMaterial (GLenum face, GLenum mode)

      • glPixelStoref

        public void glPixelStoref​(int pname,
                          float param)
        GLvoid glPixelStoref (GLenum pname, GLfloat param)

      • glPixelStorei

        public void glPixelStorei​(int pname,
                          int param)
        GLvoid glPixelStorei (GLenum pname, GLint param)

      • glPixelTransferf

        public void glPixelTransferf​(int pname,
                             float param)
        GLvoid glPixelTransferf (GLenum pname, GLfloat param)

      • glPixelTransferi

        public void glPixelTransferi​(int pname,
                             int param)
        GLvoid glPixelTransferi (GLenum pname, GLint param)

      • glReadPixels

        public void glReadPixels​(int x,
                         int y,
                         int width,
                         int height,
                         int format,
                         int type,
                         Object pixels)
        GLvoid glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)

      • glDrawPixels

        public void glDrawPixels​(int width,
                         int height,
                         int format,
                         int type,
                         Object pixels)
        GLvoid glDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)

      • glCopyPixels

        public void glCopyPixels​(int x,
                         int y,
                         int width,
                         int height,
                         int type)
        GLvoid glCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)

      • glStencilFunc

        public void glStencilFunc​(int func,
                          int ref,
                          int mask)
        GLvoid glStencilFunc (GLenum func, GLint ref, GLuint mask);

      • glStencilMask

        public void glStencilMask​(int mask)
        GLvoid glStencilMask (GLuint mask);

      • glStencilOp

        public void glStencilOp​(int fail,
                        int zfail,
                        int zpass)
        GLvoid glStencilOp (GLenum fail, GLenum zfail, GLenum zpass);

      • glClearStencil

        public void glClearStencil​(int s)
        GLvoid glClearStencil (GLint s);

      • glTexGenf

        public void glTexGenf​(int coord,
                      int pname,
                      double param)
        GLvoid glTexGend (GLenum coord, GLenum pname, GLdouble param);

      • glTexGenf

        public void glTexGenf​(int coord,
                      int pname,
                      float param)
        GLvoid glTexGenf (GLenum coord, GLenum pname, GLfloat param);

      • glTexGeni

        public void glTexGeni​(int coord,
                      int pname,
                      int param)
        GLvoid glTexGeni (GLenum coord, GLenum pname, GLint param);

      • glTexGendv

        public void glTexGendv​(int coord,
                       int pname,
                       double[] params)
        GLvoid glTexGendv (GLenum coord, GLenum pname, const GLdouble *params);

      • glTexGenfv

        public void glTexGenfv​(int coord,
                       int pname,
                       float[] params)
        GLvoid glTexGenfv (GLenum coord, GLenum pname, const GLfloat *params);

      • glTexGeniv

        public void glTexGeniv​(int coord,
                       int pname,
                       int[] params)
        GLvoid glTexGeniv (GLenum coord, GLenum pname, const GLint *params);

      • glGetTexGendv

        public void glGetTexGendv​(int coord,
                          int pname,
                          double[] params)
        GLvoid glGetTexGendv (GLenum coord, GLenum pname, GLdouble *params);

      • glGetTexGenfv

        public void glGetTexGenfv​(int coord,
                          int pname,
                          float[] params)
        GLvoid glGetTexGenfv (GLenum coord, GLenum pname, GLfloat *params);

      • glGetTexGeniv

        public void glGetTexGeniv​(int coord,
                          int pname,
                          int[] params)
        GLvoid glGetTexGeniv (GLenum coord, GLenum pname, GLint *params);

      • glTexEnvf

        public void glTexEnvf​(int target,
                      int pname,
                      float param)
        GLvoid glTexEnvf (GLenum target, GLenum pname, GLfloat param);

      • glTexEnvi

        public void glTexEnvi​(int target,
                      int pname,
                      int param)
        GLvoid glTexEnvi (GLenum target, GLenum pname, GLint param);

      • glTexEnvfv

        public void glTexEnvfv​(int target,
                       int pname,
                       float[] params)
        GLvoid glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params);

      • glTexEnviv

        public void glTexEnviv​(int target,
                       int pname,
                       int[] params)
        GLvoid glTexEnviv (GLenum target, GLenum pname, const GLint *params);

      • glGetTexEnviv

        public void glGetTexEnviv​(int target,
                          int pname,
                          int[] params)
        GLvoid glGetTexEnviv (GLenum target, GLenum pname, GLint *params);

      • glGetTexEnviv

        public void glGetTexEnviv​(int target,
                          int pname,
                          float[] params)
        GLvoid glGetTexEnvfv (GLenum target, GLenum pname, GLfloat *params);

      • glTexParameterf

        public void glTexParameterf​(int target,
                            int pname,
                            float param)
        GLvoid glTexParameterf (GLenum target, GLenum pname, GLfloat param)

      • glTexParameteri

        public void glTexParameteri​(int target,
                            int pname,
                            int param)
        GLvoid glTexParameteri (GLenum target, GLenum pname, GLint param)

      • glTexParameterfv

        public void glTexParameterfv​(int target,
                             int pname,
                             float[] params)
        GLvoid glTexParameterfv (GLenum target, GLenum pname, const GLfloat *params)

      • glTexParameteriv

        public void glTexParameteriv​(int target,
                             int pname,
                             int[] params)
        GLvoid glTexParameteriv (GLenum target, GLenum pname, const GLint *params)

      • glTexImage1D

        public void glTexImage1D​(int target,
                         int level,
                         int components,
                         int width,
                         int border,
                         int format,
                         int type,
                         Object pixels)
        GLvoid glTexImage1D (GLenum target, GLint level, GLint components, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)

      • glTexImage2D

        public void glTexImage2D​(int target,
                         int level,
                         int components,
                         int width,
                         int height,
                         int border,
                         int format,
                         int type,
                         Object pixels)
        GLvoid glTexImage2D (GLenum target, GLint level, GLint components, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)

      • glTexImage3D

        public void glTexImage3D​(int target,
                         int level,
                         int components,
                         int width,
                         int height,
                         int depth,
                         int border,
                         int format,
                         int type,
                         Object pixels)
        GLvoid glTexImage3D (GLenum target, GLint level, GLint components, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)

      • glGetTexImage

        public void glGetTexImage​(int target,
                          int level,
                          int format,
                          int type,
                          Object pixels)
        GLvoid glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)

      • glGenTextures

        public void glGenTextures​(int n,
                          int[] textures)
        GLvoid glGenTextures (GLsizei n, GLuint *textures)

      • glDeleteTextures

        public void glDeleteTextures​(int n,
                             int[] textures)
        GLvoid glDeleteTextures (GLsizei n, GLuint *textures)

      • glBindTexture

        public void glBindTexture​(int target,
                          int texture)
        GLvoid glBindTexture (GLenum target, GLuint texture)

      • glPrioritizeTextures

        public void glPrioritizeTextures​(int n,
                                 int[] textures,
                                 float[] priorities)
        GLvoid glPrioritizeTextures (GLsizei n, const GLuint *textures, const GLclampf *priorities)

      • glAreTexturesResident

        public boolean glAreTexturesResident​(int n,
                                     int[] textures,
                                     boolean[] residences)
        GLboolean glAreTexturesResident (GLsizei n, const GLuint *textures, GLboolean *residences)

      • glIsTexture

        public boolean glIsTexture​(int texture)
        GLboolean glIsTexture (GLuint texture)

      • glTexSubImage1D

        public void glTexSubImage1D​(int target,
                            int level,
                            int xoffset,
                            int width,
                            int format,
                            int type,
                            Object pixels)
        GLvoid glTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)

      • glTexSubImage2D

        public void glTexSubImage2D​(int target,
                            int level,
                            int xoffset,
                            int yoffset,
                            int width,
                            int height,
                            int format,
                            int type,
                            Object pixels)
        GLvoid glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)

      • glTexSubImage3D

        public void glTexSubImage3D​(int target,
                            int level,
                            int xoffset,
                            int yoffset,
                            int zoffset,
                            int width,
                            int height,
                            int depth,
                            int format,
                            int type,
                            Object pixels)
        GLvoid glTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)

      • glCopyTexImage1D

        public void glCopyTexImage1D​(int target,
                             int level,
                             int internalformat,
                             int x,
                             int y,
                             int width,
                             int border)
        GLvoid glCopyTexImage1D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)

      • glCopyTexImage2D

        public void glCopyTexImage2D​(int target,
                             int level,
                             int internalformat,
                             int x,
                             int y,
                             int width,
                             int height,
                             int border)
        GLvoid glCopyTexImage2D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)

      • glCopyTexSubImage1D

        public void glCopyTexSubImage1D​(int target,
                                int level,
                                int xoffset,
                                int yoffset,
                                int x,
                                int y,
                                int width)
        GLvoid glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)

      • glCopyTexSubImage2D

        public void glCopyTexSubImage2D​(int target,
                                int level,
                                int xoffset,
                                int yoffset,
                                int x,
                                int y,
                                int width,
                                int height)
        GLvoid glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)

      • glCopyTexSubImage3D

        public void glCopyTexSubImage3D​(int target,
                                int level,
                                int xoffset,
                                int yoffset,
                                int zoffset,
                                int x,
                                int y,
                                int width,
                                int height)
        GLvoid glCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)

      • glMap1d

        public void glMap1d​(int target,
                    double u1,
                    double u2,
                    int stride,
                    int order,
                    double[][] points)
        GLvoid glMap1d (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)

      • glMap1f

        public void glMap1f​(int target,
                    float u1,
                    float u2,
                    int stride,
                    int order,
                    float[][] points)
        GLvoid glMap1f (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)

      • glMap2d

        public void glMap2d​(int target,
                    double u1,
                    double u2,
                    int ustride,
                    int uorder,
                    double v1,
                    double v2,
                    int vstride,
                    int vorder,
                    double[][][] points)
        GLvoid glMap2d (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)

      • glMap2f

        public void glMap2f​(int target,
                    float u1,
                    float u2,
                    int ustride,
                    int uorder,
                    float v1,
                    float v2,
                    int vstride,
                    int vorder,
                    float[][][] points)
        GLvoid glMap2f (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)

      • glEvalCoord1d

        public void glEvalCoord1d​(double u)
        GLvoid glEvalCoord1d (GLdouble u)

      • glEvalCoord1f

        public void glEvalCoord1f​(float u)
        GLvoid glEvalCoord1f (GLfloat u)

      • glEvalCoord1dv

        public void glEvalCoord1dv​(double[] u)
        GLvoid glEvalCoord1dv (const GLdouble *u)

      • glEvalCoord1fv

        public void glEvalCoord1fv​(float[] u)
        GLvoid glEvalCoord1fv (const GLfloat *u)

      • glEvalCoord2d

        public void glEvalCoord2d​(double u,
                          double v)
        GLvoid glEvalCoord2d (GLdouble u, GLdouble v)

      • glEvalCoord2f

        public void glEvalCoord2f​(float u,
                          float v)
        GLvoid glEvalCoord2f (GLfloat u, GLfloat v)

      • glEvalCoord2dv

        public void glEvalCoord2dv​(double[] u)
        GLvoid glEvalCoord2dv (const GLdouble *u)

      • glEvalCoord2fv

        public void glEvalCoord2fv​(float[] u)
        GLvoid glEvalCoord2fv (const GLfloat *u)

      • glMapGrid1d

        public void glMapGrid1d​(int un,
                        double u1,
                        double u2)
        GLvoid glMapGrid1d (GLint un, GLdouble u1, GLdouble u2)

      • glMapGrid1f

        public void glMapGrid1f​(int un,
                        float u1,
                        float u2)
        GLvoid glMapGrid1f (GLint un, GLfloat u1, GLfloat u2)

      • glMapGrid2d

        public void glMapGrid2d​(int un,
                        double u1,
                        double u2,
                        int vn,
                        double v1,
                        double v2)
        GLvoid glMapGrid2d (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)

      • glMapGrid2f

        public void glMapGrid2f​(int un,
                        float u1,
                        float u2,
                        int vn,
                        float v1,
                        float v2)
        GLvoid glMapGrid2f (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)

      • glEvalPoint1

        public void glEvalPoint1​(int i)
        GLvoid glEvalPoint1 (GLint i)

      • glEvalPoint2

        public void glEvalPoint2​(int i,
                         int j)
        GLvoid glEvalPoint2 (GLint i, GLint j)

      • glEvalMesh1

        public void glEvalMesh1​(int mode,
                        int p1,
                        int p2)
        GLvoid glEvalMesh1 (GLenum mode, GLint p1, GLint p2)

      • glEvalMesh2

        public void glEvalMesh2​(int mode,
                        int p1,
                        int p2,
                        int q1,
                        int q2)
        GLvoid glEvalMesh2 (GLenum mode, GLint p1, GLint p2, GLint q1, GLint q2 )

      • glFeedbackBuffer

        public void glFeedbackBuffer​(int size,
                             int type,
                             float[] buffer)
        GLvoid glFeedbackBuffer (GLsizei size, GLenum type, GLfloat *buffer)

      • glPassThrough

        public void glPassThrough​(float token)
        GLvoid glPassThrough (GLfloat token)

      • glSelectBuffer

        public void glSelectBuffer​(int size,
                           int[] buffer)
        GLvoid glSelectBuffer (GLsizei size, GLuint *buffer)

      • glInitNames

        public void glInitNames()
        GLvoid glInitNames (GLvoid)

      • glLoadName

        public void glLoadName​(int name)
        GLvoid glLoadName (GLuint name)

      • glPushName

        public void glPushName​(int name)
        GLvoid glPushName (GLuint name)

      • glPopName

        public void glPopName()
        GLvoid glPopName (GLvoid)