Package jgl

Class GL<ImageType,FontType>

java.lang.Object
jgl.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

  • Field Details

  • Constructor Details

    • GL

      public GL()

  • Method Details

    • setThrowExceptionOnGLError

      public void setThrowExceptionOnGLError(boolean status)

    • getThrowExceptionOnGLError

      public boolean getThrowExceptionOnGLError()

    • getContext

      public gl_context getContext()

    • getPointer

      public gl_pointer getPointer()

    • 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

    • getActualWidth

      public int getActualWidth()
      Return the actual width, which is getDesiredWidth() multiplied by getPixelScaleX()

    • getActualHeight

      public int getActualHeight()
      Return the actual width, which is getDesiredHeight() multiplied by getPixelScaleY()

    • glShadeModel

      public void glShadeModel(int mode)

    • glFlush

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

    • addPixelScaleListener

      public void addPixelScaleListener(GL.PixelScaleListener listener)

    • removePixelScaleListener

      public void removePixelScaleListener(GL.PixelScaleListener listener)

    • getPixelScaleListeners

      public List<GL.PixelScaleListener> getPixelScaleListeners()

    • 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
      invalid @link 
      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
      invalid @link 
      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

      public void glClear(int mask)
      Clears the specified buffers to their current clearing values. The mask argument is the bitwise-ORed combination of a number of values indicating which buffers are to be cleared. The values are GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_STENCIL_BUFFER_BIT, and GL_ACCUM_BUFFER_BIT.
      Parameters:
      mask - the bitwise-ORed of a number of values.
      See Also:

    • 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:

    • 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:

    • 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:

    • 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)