java.lang.Object
- org.jzy3d.painters.AbstractPainter
- - org.jzy3d.painters.NativeDesktopPainter

All Implemented Interfaces:: IPainter

public class NativeDesktopPainter
extends AbstractPainter
implements IPainter

Field Summary

Fields
Modifier and Type	Field	Description
`protected com.jogamp.opengl.GL`	`gl`
`static int`	`GL_RGBA`
`static int`	`GL_UNSIGNED_BYTE`
`protected com.jogamp.opengl.glu.GLU`	`glu`
`protected com.jogamp.opengl.util.gl2.GLUT`	`glut`

Fields inherited from class org.jzy3d.painters.AbstractPainter
camera, canvas, os, view

Constructor Summary

Constructors
Constructor Description

NativeDesktopPainter()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`Object`	`acquireGL()`	In the context of a multithreaded application, this method allows retrieving the GL context for the calling thread.
`int`	`clipPlaneId(int id)`	Return the GL clip plane ID according to an ID in [0;5]
`void`	`configureGL(Quality quality)`	Apply quality settings as OpenGL commands
`void`	`drawImage(ByteBuffer imageBuffer, int imageWidth, int imageHeight, Coord2d pixelZoom, Coord3d imagePosition)`	A high level and easy way of drawing images (non OpenGL).
`void`	`drawText(Font font, String label, Coord3d position, Color color, float rotation)`	Render 2D text at the given 3D position.
`com.jogamp.opengl.GLContext`	`getCurrentContext(ICanvas canvas)`
`com.jogamp.opengl.GL`	`getCurrentGL(ICanvas canvas)`	Get the current GL context of the canvas and make it current.
`com.jogamp.opengl.GL`	`getGL()`
`com.jogamp.opengl.GL2`	`getGL2()`
`com.jogamp.opengl.glu.GLU`	`getGLU()`
`com.jogamp.opengl.util.gl2.GLUT`	`getGLUT()`
`double[]`	`getModelViewAsDouble()`
`float[]`	`getModelViewAsFloat()`
`protected com.jogamp.opengl.util.awt.TextRenderer`	`getOrCreateTextRenderer(Font font)`
`double[]`	`getProjectionAsDouble()`
`float[]`	`getProjectionAsFloat()`
`int`	`getTextLengthInPixels(int font, String string)`
`int`	`getTextLengthInPixels(Font font, String string)`
`int[]`	`getViewPortAsInt()`
`WindowingToolkit`	`getWindowingToolkit()`
`void`	`glBegin(int type)`
`void`	`glBegin_Line()`
`void`	`glBegin_LineLoop()`
`void`	`glBegin_LineStrip()`
`void`	`glBegin_Point()`
`void`	`glBegin_Polygon()`
`void`	`glBegin_Quad()`
`void`	`glBegin_Triangle()`
`void`	`glBitmap(int width, int height, float xorig, float yorig, float xmove, float ymove, byte[] bitmap, int bitmap_offset)`
`void`	`glBlendFunc(int sfactor, int dfactor)`
`void`	`glCallList(int list)`
`void`	`glClear(int mask)`
`void`	`glClearColor(float red, float green, float blue, float alpha)`
`void`	`glClearColorAndDepthBuffers()`
`void`	`glClearDepth(double d)`
`void`	`glClearStencil(int s)`	glClearStencil specifies the index used by glClear to clear the stencil buffer. s is masked with 2 m - 1 , where m is the number of bits in the stencil buffer.
`void`	`glClipPlane(int plane, double[] equation)`
`void`	`glColor3f(float r, float g, float b)`
`void`	`glColor4f(float r, float g, float b, float a)`
`void`	`glCullFace(int mode)`
`void`	`glCullFace_Front()`
`void`	`glDeleteLists(int list, int range)`
`void`	`glDepthFunc(int func)`
`void`	`glDepthFunc(DepthFunc func)`
`void`	`glDepthRangef(float near, float far)`
`void`	`glDisable(int type)`
`void`	`glDisable_Blend()`
`void`	`glDisable_ClipPlane(int plane)`
`void`	`glDisable_CullFace()`
`void`	`glDisable_DepthTest()`
`void`	`glDisable_Light(int light)`
`void`	`glDisable_Lighting()`
`void`	`glDisable_LineStipple()`
`void`	`glDisable_PolygonOffsetFill()`
`void`	`glDisable_PolygonOffsetLine()`
`void`	`glDisable_Stencil()`
`void`	`glDrawPixels(int width, int height, int format, int type, Buffer pixels)`
`void`	`glEnable(int type)`
`void`	`glEnable_Blend()`
`void`	`glEnable_ClipPlane(int plane)`
`void`	`glEnable_ColorMaterial()`
`void`	`glEnable_CullFace()`
`void`	`glEnable_DepthTest()`
`void`	`glEnable_Light(int light)`
`void`	`glEnable_Lighting()`
`void`	`glEnable_LineStipple()`
`void`	`glEnable_PointSmooth()`
`void`	`glEnable_PolygonOffsetFill()`
`void`	`glEnable_PolygonOffsetLine()`
`void`	`glEnable_Stencil()`
`void`	`glEnd()`
`void`	`glEndList()`
`void`	`glEvalCoord2f(float u, float v)`
`void`	`glFeedbackBuffer(int size, int type, FloatBuffer buffer)`
`void`	`glFlush()`
`void`	`glFrontFace(int mode)`
`void`	`glFrontFace_ClockWise()`
`void`	`glFrustum(double left, double right, double bottom, double top, double zNear, double zFar)`
`int`	`glGenLists(int range)`
`void`	`glGetDoublev(int pname, double[] params, int params_offset)`
`void`	`glGetFloatv(int pname, float[] data, int data_offset)`
`void`	`glGetIntegerv(int pname, int[] data, int data_offset)`
`void`	`glHint(int target, int mode)`
`void`	`glHint_PointSmooth_Nicest()`
`void`	`glInitNames()`
`boolean`	`glIsList(int list)`
`void`	`glLight_Ambiant(int lightId, Color ambiantColor)`
`void`	`glLight_Diffuse(int lightId, Color diffuseColor)`
`void`	`glLight_Position(int lightId, float[] positionZero)`
`void`	`glLight_Shininess(int lightId, float value)`
`void`	`glLight_Specular(int lightId, Color specularColor)`
`void`	`glLightf(int light, int pname, float value)`
`void`	`glLightf(int light, Attenuation.Type attenuationType, float value)`
`void`	`glLightfv(int light, int pname, float[] params, int params_offset)`
`void`	`glLightModel(LightModel model, boolean value)`
`void`	`glLightModel(LightModel model, Color color)`
`void`	`glLightModelfv(int mode, float[] value)`
`void`	`glLightModeli(int mode, int value)`
`void`	`glLineStipple(int factor, short pattern)`
`void`	`glLineWidth(float width)`
`void`	`glLoadIdentity()`
`void`	`glLoadName(int name)`
`void`	`glMap2f(int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, FloatBuffer points)`
`void`	`glMaterial(MaterialProperty material, float[] color, boolean isFront)`
`void`	`glMaterial(MaterialProperty material, Color color, boolean isFront)`
`void`	`glMaterialfv(int face, int pname, float[] params, int params_offset)`
`void`	`glMatrixMode(int mode)`
`void`	`glMatrixMode_ModelView()`
`void`	`glMatrixMode_Projection()`
`void`	`glNewList(int list, int mode)`
`void`	`glNewList(int list, ListMode mode)`
`void`	`glNormal3f(float nx, float ny, float nz)`
`void`	`glOrtho(double left, double right, double bottom, double top, double near_val, double far_val)`
`void`	`glPassThrough(float token)`
`void`	`glPixelStore(PixelStore store, int param)`
`void`	`glPixelStorei(int pname, int param)`
`void`	`glPixelZoom(float xfactor, float yfactor)`
`void`	`glPointSize(float width)`
`void`	`glPolygonMode(int frontOrBack, int fill)`
`void`	`glPolygonMode(PolygonMode mode, PolygonFill fill)`
`void`	`glPolygonOffset(float factor, float units)`
`void`	`glPopMatrix()`
`void`	`glPopName()`
`void`	`glPushMatrix()`	OPEN GL Interface
`void`	`glPushName(int name)`
`void`	`glRasterPos3f(float x, float y, float z)`
`int`	`glRenderMode(int mode)`
`int`	`glRenderMode(RenderMode mode)`
`void`	`glRotatef(float angle, float x, float y, float z)`
`void`	`glScalef(float x, float y, float z)`
`void`	`glSelectBuffer(int size, IntBuffer buffer)`
`void`	`glShadeModel(int mode)`
`void`	`glShadeModel(ColorModel colorModel)`
`void`	`glShadeModel_Flat()`
`void`	`glShadeModel_Smooth()`
`void`	`glStencilFunc(StencilFunc func, int ref, int mask)`	Stenciling, like depth-buffering, enables and disables drawing on a per-pixel basis.
`void`	`glStencilMask(int mask)`	glStencilMask controls the writing of individual bits in the stencil planes.
`void`	`glStencilMask_False()`
`void`	`glStencilMask_True()`
`void`	`glStencilOp(StencilOp fail, StencilOp zfail, StencilOp zpass)`	The glStencilOp(GLenum sfail, GLenum dpfail, GLenum dppass) contains three options of which we can specify for each option what action to take:
`void`	`glTexCoord2f(float s, float t)`
`void`	`glTexEnvf(int target, int pname, float param)`
`void`	`glTexEnvi(int target, int pname, int param)`
`void`	`glTranslatef(float x, float y, float z)`
`void`	`gluCylinder(double base, double top, double height, int slices, int stacks)`
`void`	`gluDisk(double inner, double outer, int slices, int loops)`
`void`	`gluLookAt(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ)`
`void`	`gluOrtho2D(double left, double right, double bottom, double top)`
`void`	`gluPerspective(double fovy, double aspect, double zNear, double zFar)`
`void`	`gluPickMatrix(double x, double y, double delX, double delY, int[] viewport, int viewport_offset)`
`boolean`	`gluProject(float objX, float objY, float objZ, float[] model, int model_offset, float[] proj, int proj_offset, int[] view, int view_offset, float[] winPos, int winPos_offset)`
`void`	`gluSphere(double radius, int slices, int stacks)`
`int`	`glutBitmapLength(int font, String string)`
`void`	`glutBitmapString(int font, String string)`
`void`	`glutBitmapString(Font axisFont, String label, Coord3d p, Color c)`	Render 2D text at the given 3D position using a font as supported by `glutBitmapString(int, String)`.
`void`	`glutSolidCube(float size)`
`void`	`glutSolidSphere(double radius, int slices, int stacks)`
`void`	`glutSolidTeapot(float scale)`
`void`	`glutWireTeapot(float scale)`
`boolean`	`gluUnProject(float winX, float winY, float winZ, float[] model, int model_offset, float[] proj, int proj_offset, int[] view, int view_offset, float[] objPos, int objPos_offset)`
`void`	`glVertex3d(double x, double y, double z)`
`void`	`glVertex3f(float x, float y, float z)`
`void`	`glViewport(int x, int y, int width, int height)`
`protected int`	`lightId(int id)`
`protected int`	`materialProperty(MaterialProperty material)`
`protected int`	`polygonFillValue(PolygonFill mode)`
`protected int`	`polygonModeValue(PolygonMode mode)`
`void`	`releaseGL()`	In the context of a multithreaded application, this method allows releasing the GL context by the calling thread to let other thread use it.
`void`	`setGL(com.jogamp.opengl.GL gl)`
`void`	`setGLU(com.jogamp.opengl.glu.GLU glu)`
`void`	`setGLUT(com.jogamp.opengl.util.gl2.GLUT glut)`
`protected int`	`toInt(StencilOp fail)`

Methods inherited from class org.jzy3d.painters.AbstractPainter
box, clearColor, clip, clip, clipOff, clipOn, color, colorAlphaFactor, colorAlphaOverride, equation, getCamera, getCanvas, getOS, getQuality, getView, isJVMScaleLargerThanNativeScale, isJVMScaleLargerThanNativeScale, material, modelToScreen, modelToScreen, modelToScreen, modelToScreen, modelToScreen, modelToScreen, modelToScreen, normal, raster, screenToModel, setCamera, setCanvas, setView, transform, vertex, vertex, vertex

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.jzy3d.painters.IPainter
box, clearColor, clip, clip, clipOff, clipOn, color, colorAlphaFactor, colorAlphaOverride, getCamera, getCanvas, getOS, getQuality, getView, isJVMScaleLargerThanNativeScale, isJVMScaleLargerThanNativeScale, material, modelToScreen, modelToScreen, modelToScreen, modelToScreen, modelToScreen, modelToScreen, modelToScreen, normal, raster, screenToModel, setCamera, setCanvas, setView, transform, vertex, vertex, vertex

- Field Detail
  - gl
```
protected com.jogamp.opengl.GL gl
```
  - glu
```
protected com.jogamp.opengl.glu.GLU glu
```
  - glut
```
protected com.jogamp.opengl.util.gl2.GLUT glut
```
  - GL_RGBA
```
public static final int GL_RGBA
```
    See Also:
    
    Constant Field Values
  - GL_UNSIGNED_BYTE
```
public static final int GL_UNSIGNED_BYTE
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - NativeDesktopPainter
```
public NativeDesktopPainter()
```
- Method Detail
  - getGL
```
public com.jogamp.opengl.GL getGL()
```
  - getGL2
```
public com.jogamp.opengl.GL2 getGL2()
```
  - setGL
```
public void setGL(com.jogamp.opengl.GL gl)
```
  - getGLU
```
public com.jogamp.opengl.glu.GLU getGLU()
```
  - setGLU
```
public void setGLU(com.jogamp.opengl.glu.GLU glu)
```
  - getGLUT
```
public com.jogamp.opengl.util.gl2.GLUT getGLUT()
```
  - setGLUT
```
public void setGLUT(com.jogamp.opengl.util.gl2.GLUT glut)
```
  - acquireGL
```
public Object acquireGL()
```
    Description copied from interface: IPainter
    
    In the context of a multithreaded application, this method allows retrieving the GL context for the calling thread. Once work is done the caller should call IPainter.releaseGL()
    
    Specified by:
    
    acquireGL in interface IPainter
  - releaseGL
```
public void releaseGL()
```
    Description copied from interface: IPainter
    
    In the context of a multithreaded application, this method allows releasing the GL context by the calling thread to let other thread use it. IPainter.acquireGL()
    
    Specified by:
    
    releaseGL in interface IPainter
  - getCurrentGL
```
public com.jogamp.opengl.GL getCurrentGL(ICanvas canvas)
```
    Get the current GL context of the canvas and make it current. This is usefull when needing to get a GL instance outside of the context of the GLEventListener, e.g. when clicking the frame with mouse.
  - getCurrentContext
```
public com.jogamp.opengl.GLContext getCurrentContext(ICanvas canvas)
```
  - configureGL
```
public void configureGL(Quality quality)
```
    Description copied from interface: IPainter
    
    Apply quality settings as OpenGL commands
    
    Specified by:
    
    configureGL in interface IPainter
  - getWindowingToolkit
```
public WindowingToolkit getWindowingToolkit()
```
    Specified by:
    
    getWindowingToolkit in interface IPainter
    
    Overrides:
    
    getWindowingToolkit in class AbstractPainter
  - getViewPortAsInt
```
public int[] getViewPortAsInt()
```
    Specified by:
    
    getViewPortAsInt in interface IPainter
  - getProjectionAsDouble
```
public double[] getProjectionAsDouble()
```
    Specified by:
    
    getProjectionAsDouble in interface IPainter
  - getProjectionAsFloat
```
public float[] getProjectionAsFloat()
```
    Specified by:
    
    getProjectionAsFloat in interface IPainter
  - getModelViewAsDouble
```
public double[] getModelViewAsDouble()
```
    Specified by:
    
    getModelViewAsDouble in interface IPainter
  - getModelViewAsFloat
```
public float[] getModelViewAsFloat()
```
    Specified by:
    
    getModelViewAsFloat in interface IPainter
  - glPushMatrix
```
public void glPushMatrix()
```
    OPEN GL Interface
    
    Specified by:
    
    glPushMatrix in interface IPainter
  - glPopMatrix
```
public void glPopMatrix()
```
    Specified by:
    
    glPopMatrix in interface IPainter
  - glMatrixMode
```
public void glMatrixMode(int mode)
```
    Specified by:
    
    glMatrixMode in interface IPainter
  - glLoadIdentity
```
public void glLoadIdentity()
```
    Specified by:
    
    glLoadIdentity in interface IPainter
  - glScalef
```
public void glScalef(float x,
                     float y,
                     float z)
```
    Specified by:
    
    glScalef in interface IPainter
  - glTranslatef
```
public void glTranslatef(float x,
                         float y,
                         float z)
```
    Specified by:
    
    glTranslatef in interface IPainter
  - glRotatef
```
public void glRotatef(float angle,
                      float x,
                      float y,
                      float z)
```
    Specified by:
    
    glRotatef in interface IPainter
  - glEnable
```
public void glEnable(int type)
```
    Specified by:
    
    glEnable in interface IPainter
  - glDisable
```
public void glDisable(int type)
```
    Specified by:
    
    glDisable in interface IPainter
  - glPointSize
```
public void glPointSize(float width)
```
    Specified by:
    
    glPointSize in interface IPainter
  - glLineWidth
```
public void glLineWidth(float width)
```
    Specified by:
    
    glLineWidth in interface IPainter
  - glBegin
```
public void glBegin(int type)
```
    Specified by:
    
    glBegin in interface IPainter
  - glColor3f
```
public void glColor3f(float r,
                      float g,
                      float b)
```
    Specified by:
    
    glColor3f in interface IPainter
  - glColor4f
```
public void glColor4f(float r,
                      float g,
                      float b,
                      float a)
```
    Specified by:
    
    glColor4f in interface IPainter
  - glVertex3f
```
public void glVertex3f(float x,
                       float y,
                       float z)
```
    Specified by:
    
    glVertex3f in interface IPainter
  - glVertex3d
```
public void glVertex3d(double x,
                       double y,
                       double z)
```
    Specified by:
    
    glVertex3d in interface IPainter
  - glEnd
```
public void glEnd()
```
    Specified by:
    
    glEnd in interface IPainter
  - glFrontFace
```
public void glFrontFace(int mode)
```
    Specified by:
    
    glFrontFace in interface IPainter
  - glCullFace
```
public void glCullFace(int mode)
```
    Specified by:
    
    glCullFace in interface IPainter
  - glPolygonMode
```
public void glPolygonMode(PolygonMode mode,
                          PolygonFill fill)
```
    Specified by:
    
    glPolygonMode in interface IPainter
  - polygonModeValue
```
protected int polygonModeValue(PolygonMode mode)
```
  - polygonFillValue
```
protected int polygonFillValue(PolygonFill mode)
```
  - glPolygonMode
```
public void glPolygonMode(int frontOrBack,
                          int fill)
```
    Specified by:
    
    glPolygonMode in interface IPainter
  - glPolygonOffset
```
public void glPolygonOffset(float factor,
                            float units)
```
    Specified by:
    
    glPolygonOffset in interface IPainter
  - glLineStipple
```
public void glLineStipple(int factor,
                          short pattern)
```
    Specified by:
    
    glLineStipple in interface IPainter
  - glTexCoord2f
```
public void glTexCoord2f(float s,
                         float t)
```
    Specified by:
    
    glTexCoord2f in interface IPainter
  - glTexEnvf
```
public void glTexEnvf(int target,
                      int pname,
                      float param)
```
    Specified by:
    
    glTexEnvf in interface IPainter
  - glTexEnvi
```
public void glTexEnvi(int target,
                      int pname,
                      int param)
```
    Specified by:
    
    glTexEnvi in interface IPainter
  - glRasterPos3f
```
public void glRasterPos3f(float x,
                          float y,
                          float z)
```
    Specified by:
    
    glRasterPos3f in interface IPainter
  - glDrawPixels
```
public void glDrawPixels(int width,
                         int height,
                         int format,
                         int type,
                         Buffer pixels)
```
    Specified by:
    
    glDrawPixels in interface IPainter
  - glPixelZoom
```
public void glPixelZoom(float xfactor,
                        float yfactor)
```
    Specified by:
    
    glPixelZoom in interface IPainter
  - glPixelStorei
```
public void glPixelStorei(int pname,
                          int param)
```
    Specified by:
    
    glPixelStorei in interface IPainter
  - glPixelStore
```
public void glPixelStore(PixelStore store,
                         int param)
```
    Specified by:
    
    glPixelStore in interface IPainter
  - glBitmap
```
public void glBitmap(int width,
                     int height,
                     float xorig,
                     float yorig,
                     float xmove,
                     float ymove,
                     byte[] bitmap,
                     int bitmap_offset)
```
    Specified by:
    
    glBitmap in interface IPainter
  - drawImage
```
public void drawImage(ByteBuffer imageBuffer,
                      int imageWidth,
                      int imageHeight,
                      Coord2d pixelZoom,
                      Coord3d imagePosition)
```
    Description copied from interface: IPainter
    
    A high level and easy way of drawing images (non OpenGL).
    
    Specified by:
    
    drawImage in interface IPainter
  - glutBitmapString
```
public void glutBitmapString(int font,
                             String string)
```
    Specified by:
    
    glutBitmapString in interface IPainter
  - drawText
```
public void drawText(Font font,
                     String label,
                     Coord3d position,
                     Color color,
                     float rotation)
```
    Render 2D text at the given 3D position. The Font can be any font name and size supported by AWT. Rotation is in radian and is applied at the center of the text to avoid messing up text layout.
    
    Specified by:
    
    drawText in interface IPainter
  - getOrCreateTextRenderer
```
protected com.jogamp.opengl.util.awt.TextRenderer getOrCreateTextRenderer(Font font)
```
  - glutBitmapString
```
public void glutBitmapString(Font axisFont,
                             String label,
                             Coord3d p,
                             Color c)
```
    Render 2D text at the given 3D position using a font as supported by glutBitmapString(int, String).
    
    Specified by:
    
    glutBitmapString in interface IPainter
  - glutBitmapLength
```
public int glutBitmapLength(int font,
                            String string)
```
    Specified by:
    
    glutBitmapLength in interface IPainter
  - getTextLengthInPixels
```
public int getTextLengthInPixels(int font,
                                 String string)
```
    Specified by:
    
    getTextLengthInPixels in interface IPainter
  - getTextLengthInPixels
```
public int getTextLengthInPixels(Font font,
                                 String string)
```
    Specified by:
    
    getTextLengthInPixels in interface IPainter
  - glGenLists
```
public int glGenLists(int range)
```
    Specified by:
    
    glGenLists in interface IPainter
  - glNewList
```
public void glNewList(int list,
                      int mode)
```
    Specified by:
    
    glNewList in interface IPainter
  - glNewList
```
public void glNewList(int list,
                      ListMode mode)
```
    Specified by:
    
    glNewList in interface IPainter
  - glEndList
```
public void glEndList()
```
    Specified by:
    
    glEndList in interface IPainter
  - glCallList
```
public void glCallList(int list)
```
    Specified by:
    
    glCallList in interface IPainter
  - glIsList
```
public boolean glIsList(int list)
```
    Specified by:
    
    glIsList in interface IPainter
  - glDeleteLists
```
public void glDeleteLists(int list,
                          int range)
```
    Specified by:
    
    glDeleteLists in interface IPainter
  - gluDisk
```
public void gluDisk(double inner,
                    double outer,
                    int slices,
                    int loops)
```
    Specified by:
    
    gluDisk in interface IPainter
  - glutSolidSphere
```
public void glutSolidSphere(double radius,
                            int slices,
                            int stacks)
```
    Specified by:
    
    glutSolidSphere in interface IPainter
  - gluSphere
```
public void gluSphere(double radius,
                      int slices,
                      int stacks)
```
    Specified by:
    
    gluSphere in interface IPainter
  - gluCylinder
```
public void gluCylinder(double base,
                        double top,
                        double height,
                        int slices,
                        int stacks)
```
    Specified by:
    
    gluCylinder in interface IPainter
  - glutSolidCube
```
public void glutSolidCube(float size)
```
    Specified by:
    
    glutSolidCube in interface IPainter
  - glutSolidTeapot
```
public void glutSolidTeapot(float scale)
```
    Specified by:
    
    glutSolidTeapot in interface IPainter
  - glutWireTeapot
```
public void glutWireTeapot(float scale)
```
    Specified by:
    
    glutWireTeapot in interface IPainter
  - glFeedbackBuffer
```
public void glFeedbackBuffer(int size,
                             int type,
                             FloatBuffer buffer)
```
    Specified by:
    
    glFeedbackBuffer in interface IPainter
  - glRenderMode
```
public int glRenderMode(int mode)
```
    Specified by:
    
    glRenderMode in interface IPainter
  - glRenderMode
```
public int glRenderMode(RenderMode mode)
```
    Specified by:
    
    glRenderMode in interface IPainter
  - glPassThrough
```
public void glPassThrough(float token)
```
    Specified by:
    
    glPassThrough in interface IPainter
  - glStencilFunc
```
public void glStencilFunc(StencilFunc func,
                          int ref,
                          int mask)
```
    Description copied from interface: IPainter
    Stenciling, like depth-buffering, enables and disables drawing on a per-pixel basis. Stencil planes are first drawn into using GL drawing primitives, then geometry and images are rendered using the stencil planes to mask out portions of the screen. Stenciling is typically used in multipass rendering algorithms to achieve special effects, such as decals, outlining, and constructive solid geometry rendering. The stencil test conditionally eliminates a pixel based on the outcome of a comparison between the reference value and the value in the stencil buffer. To enable and disable the test, call glEnable and glDisable with argument GL_STENCIL_TEST. To specify actions based on the outcome of the stencil test, call glStencilOp or glStencilOpSeparate. There can be two separate sets of func, ref, and mask parameters; one affects back-facing polygons, and the other affects front-facing polygons as well as other non-polygon primitives. glStencilFunc sets both front and back stencil state to the same values. Use glStencilFuncSeparate to set front and back stencil state to different values. func is a symbolic constant that determines the stencil comparison function. It accepts one of eight values, shown in the following list. ref is an integer reference value that is used in the stencil comparison. It is clamped to the range 0 2 n - 1 , where n is the number of bitplanes in the stencil buffer. mask is bitwise ANDed with both the reference value and the stored stencil value, with the ANDed values participating in the comparison. If stencil represents the value stored in the corresponding stencil buffer location, the following list shows the effect of each comparison function that can be specified by func. Only if the comparison succeeds is the pixel passed through to the next stage in the rasterization process (see glStencilOp). All tests treat stencil values as unsigned integers in the range 0 2 n - 1 , where n is the number of bitplanes in the stencil buffer. The following values are accepted by func:
    
    GL_NEVER Always fails.
    GL_LESS Passes if ( ref & mask ) < ( stencil & mask ).
    GL_LEQUAL Passes if ( ref & mask ) <= ( stencil & mask ).
    GL_GREATER Passes if ( ref & mask ) > ( stencil & mask ).
    GL_GEQUAL Passes if ( ref & mask ) >= ( stencil & mask ).
    GL_EQUAL Passes if ( ref & mask ) = ( stencil & mask ).
    GL_NOTEQUAL Passes if ( ref & mask ) != ( stencil & mask ).
    GL_ALWAYS Always passes.
    Specified by:
    
    glStencilFunc in interface IPainter
    
    Parameters:
    
    func - sets the stencil test function that determines whether a fragment passes or is discarded. This test function is applied to the stored stencil value and the glStencilFunc's ref value. Possible options are: GL_NEVER, GL_LESS, GL_LEQUAL, GL_GREATER, GL_GEQUAL, GL_EQUAL, GL_NOTEQUAL and GL_ALWAYS. The semantic meaning of these is similar to the depth buffer's functions.
    
    ref - specifies the reference value for the stencil test. The stencil buffer's content is compared to this value.
    
    mask - specifies a mask that is ANDed with both the reference value and the stored stencil value before the test compares them. Initially set to all 1s.
  - glStencilMask
```
public void glStencilMask(int mask)
```
    Description copied from interface: IPainter
    
    glStencilMask controls the writing of individual bits in the stencil planes. The least significant n bits of mask, where n is the number of bits in the stencil buffer, specify a mask. Where a 1 appears in the mask, it's possible to write to the corresponding bit in the stencil buffer. Where a 0 appears, the corresponding bit is write-protected. Initially, all bits are enabled for writing. There can be two separate mask writemasks; one affects back-facing polygons, and the other affects front-facing polygons as well as other non-polygon primitives. glStencilMask sets both front and back stencil writemasks to the same values. Use glStencilMaskSeparate to set front and back stencil writemasks to different values.
    
    Specified by:
    
    glStencilMask in interface IPainter
  - glStencilMask_True
```
public void glStencilMask_True()
```
    Specified by:
    
    glStencilMask_True in interface IPainter
  - glStencilMask_False
```
public void glStencilMask_False()
```
    Specified by:
    
    glStencilMask_False in interface IPainter
  - glStencilOp
```
public void glStencilOp(StencilOp fail,
                        StencilOp zfail,
                        StencilOp zpass)
```
    Description copied from interface: IPainter
    
    The glStencilOp(GLenum sfail, GLenum dpfail, GLenum dppass) contains three options of which we can specify for each option what action to take:
    Specified by:
    
    glStencilOp in interface IPainter
    
    Parameters:
    
    fail - action to take if the stencil test fails.
    
    zfail - action to take if the stencil test passes, but the depth test fails.
    
    zpass - action to take if both the stencil and the depth test pass. Then for each of the options you can take any of the following actions:
    
    Action : Description
    GL_KEEP : The currently stored stencil value is kept.
    GL_ZERO : The stencil value is set to 0.
    GL_REPLACE : The stencil value is replaced with the reference value set with glStencilFunc.
    GL_INCR : The stencil value is increased by 1 if it is lower than the maximum value.
    GL_INCR_WRAP : Same as GL_INCR, but wraps it back to 0 as soon as the maximum value is exceeded.
    GL_DECR : The stencil value is decreased by 1 if it is higher than the minimum value.
    GL_DECR_WRAP : Same as GL_DECR, but wraps it to the maximum value if it ends up lower than 0.
    GL_INVERT : Bitwise inverts the current stencil buffer value.
  - glClearStencil
```
public void glClearStencil(int s)
```
    Description copied from interface: IPainter
    
    glClearStencil specifies the index used by glClear to clear the stencil buffer. s is masked with 2 m - 1 , where m is the number of bits in the stencil buffer.
    
    Specified by:
    
    glClearStencil in interface IPainter
  - toInt
```
protected int toInt(StencilOp fail)
```
  - glOrtho
```
public void glOrtho(double left,
                    double right,
                    double bottom,
                    double top,
                    double near_val,
                    double far_val)
```
    Specified by:
    
    glOrtho in interface IPainter
  - gluOrtho2D
```
public void gluOrtho2D(double left,
                       double right,
                       double bottom,
                       double top)
```
    Specified by:
    
    gluOrtho2D in interface IPainter
  - gluPerspective
```
public void gluPerspective(double fovy,
                           double aspect,
                           double zNear,
                           double zFar)
```
    Specified by:
    
    gluPerspective in interface IPainter
  - glFrustum
```
public void glFrustum(double left,
                      double right,
                      double bottom,
                      double top,
                      double zNear,
                      double zFar)
```
    Specified by:
    
    glFrustum in interface IPainter
  - gluLookAt
```
public void gluLookAt(float eyeX,
                      float eyeY,
                      float eyeZ,
                      float centerX,
                      float centerY,
                      float centerZ,
                      float upX,
                      float upY,
                      float upZ)
```
    Specified by:
    
    gluLookAt in interface IPainter
  - glViewport
```
public void glViewport(int x,
                       int y,
                       int width,
                       int height)
```
    Specified by:
    
    glViewport in interface IPainter
  - glClipPlane
```
public void glClipPlane(int plane,
                        double[] equation)
```
    Specified by:
    
    glClipPlane in interface IPainter
  - glEnable_ClipPlane
```
public void glEnable_ClipPlane(int plane)
```
    Specified by:
    
    glEnable_ClipPlane in interface IPainter
  - clipPlaneId
```
public int clipPlaneId(int id)
```
    Return the GL clip plane ID according to an ID in [0;5]
    
    Specified by:
    
    clipPlaneId in interface IPainter
  - glDisable_ClipPlane
```
public void glDisable_ClipPlane(int plane)
```
    Specified by:
    
    glDisable_ClipPlane in interface IPainter
  - gluUnProject
```
public boolean gluUnProject(float winX,
                            float winY,
                            float winZ,
                            float[] model,
                            int model_offset,
                            float[] proj,
                            int proj_offset,
                            int[] view,
                            int view_offset,
                            float[] objPos,
                            int objPos_offset)
```
    Specified by:
    
    gluUnProject in interface IPainter
  - gluProject
```
public boolean gluProject(float objX,
                          float objY,
                          float objZ,
                          float[] model,
                          int model_offset,
                          float[] proj,
                          int proj_offset,
                          int[] view,
                          int view_offset,
                          float[] winPos,
                          int winPos_offset)
```
    Specified by:
    
    gluProject in interface IPainter
  - glGetIntegerv
```
public void glGetIntegerv(int pname,
                          int[] data,
                          int data_offset)
```
    Specified by:
    
    glGetIntegerv in interface IPainter
  - glGetDoublev
```
public void glGetDoublev(int pname,
                         double[] params,
                         int params_offset)
```
    Specified by:
    
    glGetDoublev in interface IPainter
  - glGetFloatv
```
public void glGetFloatv(int pname,
                        float[] data,
                        int data_offset)
```
    Specified by:
    
    glGetFloatv in interface IPainter
  - glDepthFunc
```
public void glDepthFunc(int func)
```
    Specified by:
    
    glDepthFunc in interface IPainter
  - glDepthRangef
```
public void glDepthRangef(float near,
                          float far)
```
    Specified by:
    
    glDepthRangef in interface IPainter
  - glBlendFunc
```
public void glBlendFunc(int sfactor,
                        int dfactor)
```
    Specified by:
    
    glBlendFunc in interface IPainter
  - glHint
```
public void glHint(int target,
                   int mode)
```
    Specified by:
    
    glHint in interface IPainter
  - glShadeModel
```
public void glShadeModel(ColorModel colorModel)
```
    Specified by:
    
    glShadeModel in interface IPainter
  - glShadeModel
```
public void glShadeModel(int mode)
```
    Specified by:
    
    glShadeModel in interface IPainter
  - glShadeModel_Smooth
```
public void glShadeModel_Smooth()
```
    Specified by:
    
    glShadeModel_Smooth in interface IPainter
  - glShadeModel_Flat
```
public void glShadeModel_Flat()
```
    Specified by:
    
    glShadeModel_Flat in interface IPainter
  - glMaterialfv
```
public void glMaterialfv(int face,
                         int pname,
                         float[] params,
                         int params_offset)
```
    Specified by:
    
    glMaterialfv in interface IPainter
  - glNormal3f
```
public void glNormal3f(float nx,
                       float ny,
                       float nz)
```
    Specified by:
    
    glNormal3f in interface IPainter
  - glLightModeli
```
public void glLightModeli(int mode,
                          int value)
```
    Specified by:
    
    glLightModeli in interface IPainter
  - glLightModelfv
```
public void glLightModelfv(int mode,
                           float[] value)
```
    Specified by:
    
    glLightModelfv in interface IPainter
  - glLightModel
```
public void glLightModel(LightModel model,
                         boolean value)
```
    Specified by:
    
    glLightModel in interface IPainter
  - glLightModel
```
public void glLightModel(LightModel model,
                         Color color)
```
    Specified by:
    
    glLightModel in interface IPainter
  - glLightf
```
public void glLightf(int light,
                     Attenuation.Type attenuationType,
                     float value)
```
    Specified by:
    
    glLightf in interface IPainter
  - glLightf
```
public void glLightf(int light,
                     int pname,
                     float value)
```
    Specified by:
    
    glLightf in interface IPainter
  - glLightfv
```
public void glLightfv(int light,
                      int pname,
                      float[] params,
                      int params_offset)
```
    Specified by:
    
    glLightfv in interface IPainter
  - glLight_Position
```
public void glLight_Position(int lightId,
                             float[] positionZero)
```
    Specified by:
    
    glLight_Position in interface IPainter
  - glLight_Ambiant
```
public void glLight_Ambiant(int lightId,
                            Color ambiantColor)
```
    Specified by:
    
    glLight_Ambiant in interface IPainter
  - glLight_Diffuse
```
public void glLight_Diffuse(int lightId,
                            Color diffuseColor)
```
    Specified by:
    
    glLight_Diffuse in interface IPainter
  - glLight_Specular
```
public void glLight_Specular(int lightId,
                             Color specularColor)
```
    Specified by:
    
    glLight_Specular in interface IPainter
  - glLight_Shininess
```
public void glLight_Shininess(int lightId,
                              float value)
```
    Specified by:
    
    glLight_Shininess in interface IPainter
  - glEnable_Light
```
public void glEnable_Light(int light)
```
    Specified by:
    
    glEnable_Light in interface IPainter
  - glDisable_Light
```
public void glDisable_Light(int light)
```
    Specified by:
    
    glDisable_Light in interface IPainter
  - lightId
```
protected int lightId(int id)
```
  - glClearColor
```
public void glClearColor(float red,
                         float green,
                         float blue,
                         float alpha)
```
    Specified by:
    
    glClearColor in interface IPainter
  - glClearDepth
```
public void glClearDepth(double d)
```
    Specified by:
    
    glClearDepth in interface IPainter
  - glClear
```
public void glClear(int mask)
```
    Specified by:
    
    glClear in interface IPainter
  - glClearColorAndDepthBuffers
```
public void glClearColorAndDepthBuffers()
```
    Specified by:
    
    glClearColorAndDepthBuffers in interface IPainter
  - glInitNames
```
public void glInitNames()
```
    Specified by:
    
    glInitNames in interface IPainter
  - glLoadName
```
public void glLoadName(int name)
```
    Specified by:
    
    glLoadName in interface IPainter
  - glPushName
```
public void glPushName(int name)
```
    Specified by:
    
    glPushName in interface IPainter
  - glPopName
```
public void glPopName()
```
    Specified by:
    
    glPopName in interface IPainter
  - glSelectBuffer
```
public void glSelectBuffer(int size,
                           IntBuffer buffer)
```
    Specified by:
    
    glSelectBuffer in interface IPainter
  - gluPickMatrix
```
public void gluPickMatrix(double x,
                          double y,
                          double delX,
                          double delY,
                          int[] viewport,
                          int viewport_offset)
```
    Specified by:
    
    gluPickMatrix in interface IPainter
  - glFlush
```
public void glFlush()
```
    Specified by:
    
    glFlush in interface IPainter
  - glEvalCoord2f
```
public void glEvalCoord2f(float u,
                          float v)
```
    Specified by:
    
    glEvalCoord2f in interface IPainter
  - glMap2f
```
public void glMap2f(int target,
                    float u1,
                    float u2,
                    int ustride,
                    int uorder,
                    float v1,
                    float v2,
                    int vstride,
                    int vorder,
                    FloatBuffer points)
```
    Specified by:
    
    glMap2f in interface IPainter
  - glEnable_PolygonOffsetFill
```
public void glEnable_PolygonOffsetFill()
```
    Specified by:
    
    glEnable_PolygonOffsetFill in interface IPainter
  - glDisable_PolygonOffsetFill
```
public void glDisable_PolygonOffsetFill()
```
    Specified by:
    
    glDisable_PolygonOffsetFill in interface IPainter
  - glEnable_PolygonOffsetLine
```
public void glEnable_PolygonOffsetLine()
```
    Specified by:
    
    glEnable_PolygonOffsetLine in interface IPainter
  - glDisable_PolygonOffsetLine
```
public void glDisable_PolygonOffsetLine()
```
    Specified by:
    
    glDisable_PolygonOffsetLine in interface IPainter
  - glEnable_Blend
```
public void glEnable_Blend()
```
    Specified by:
    
    glEnable_Blend in interface IPainter
  - glDisable_Blend
```
public void glDisable_Blend()
```
    Specified by:
    
    glDisable_Blend in interface IPainter
  - glMatrixMode_ModelView
```
public void glMatrixMode_ModelView()
```
    Specified by:
    
    glMatrixMode_ModelView in interface IPainter
  - glMatrixMode_Projection
```
public void glMatrixMode_Projection()
```
    Specified by:
    
    glMatrixMode_Projection in interface IPainter
  - glBegin_Polygon
```
public void glBegin_Polygon()
```
    Specified by:
    
    glBegin_Polygon in interface IPainter
  - glBegin_Quad
```
public void glBegin_Quad()
```
    Specified by:
    
    glBegin_Quad in interface IPainter
  - glBegin_Triangle
```
public void glBegin_Triangle()
```
    Specified by:
    
    glBegin_Triangle in interface IPainter
  - glBegin_Point
```
public void glBegin_Point()
```
    Specified by:
    
    glBegin_Point in interface IPainter
  - glBegin_LineStrip
```
public void glBegin_LineStrip()
```
    Specified by:
    
    glBegin_LineStrip in interface IPainter
  - glBegin_LineLoop
```
public void glBegin_LineLoop()
```
    Specified by:
    
    glBegin_LineLoop in interface IPainter
  - glBegin_Line
```
public void glBegin_Line()
```
    Specified by:
    
    glBegin_Line in interface IPainter
  - glEnable_LineStipple
```
public void glEnable_LineStipple()
```
    Specified by:
    
    glEnable_LineStipple in interface IPainter
  - glDisable_LineStipple
```
public void glDisable_LineStipple()
```
    Specified by:
    
    glDisable_LineStipple in interface IPainter
  - glEnable_CullFace
```
public void glEnable_CullFace()
```
    Specified by:
    
    glEnable_CullFace in interface IPainter
  - glDisable_CullFace
```
public void glDisable_CullFace()
```
    Specified by:
    
    glDisable_CullFace in interface IPainter
  - glFrontFace_ClockWise
```
public void glFrontFace_ClockWise()
```
    Specified by:
    
    glFrontFace_ClockWise in interface IPainter
  - glCullFace_Front
```
public void glCullFace_Front()
```
    Specified by:
    
    glCullFace_Front in interface IPainter
  - glDisable_Lighting
```
public void glDisable_Lighting()
```
    Specified by:
    
    glDisable_Lighting in interface IPainter
  - glEnable_Lighting
```
public void glEnable_Lighting()
```
    Specified by:
    
    glEnable_Lighting in interface IPainter
  - glEnable_ColorMaterial
```
public void glEnable_ColorMaterial()
```
    Specified by:
    
    glEnable_ColorMaterial in interface IPainter
  - glMaterial
```
public void glMaterial(MaterialProperty material,
                       Color color,
                       boolean isFront)
```
    Specified by:
    
    glMaterial in interface IPainter
  - glMaterial
```
public void glMaterial(MaterialProperty material,
                       float[] color,
                       boolean isFront)
```
    Specified by:
    
    glMaterial in interface IPainter
  - materialProperty
```
protected int materialProperty(MaterialProperty material)
```
  - glEnable_PointSmooth
```
public void glEnable_PointSmooth()
```
    Specified by:
    
    glEnable_PointSmooth in interface IPainter
  - glHint_PointSmooth_Nicest
```
public void glHint_PointSmooth_Nicest()
```
    Specified by:
    
    glHint_PointSmooth_Nicest in interface IPainter
  - glDepthFunc
```
public void glDepthFunc(DepthFunc func)
```
    Specified by:
    
    glDepthFunc in interface IPainter
  - glEnable_DepthTest
```
public void glEnable_DepthTest()
```
    Specified by:
    
    glEnable_DepthTest in interface IPainter
  - glDisable_DepthTest
```
public void glDisable_DepthTest()
```
    Specified by:
    
    glDisable_DepthTest in interface IPainter
  - glEnable_Stencil
```
public void glEnable_Stencil()
```
    Specified by:
    
    glEnable_Stencil in interface IPainter
  - glDisable_Stencil
```
public void glDisable_Stencil()
```
    Specified by:
    
    glDisable_Stencil in interface IPainter

Class NativeDesktopPainter

Field Summary

Fields inherited from class org.jzy3d.painters.AbstractPainter

Constructor Summary

Method Summary

Methods inherited from class org.jzy3d.painters.AbstractPainter

Methods inherited from class java.lang.Object

Methods inherited from interface org.jzy3d.painters.IPainter

Field Detail

gl

glu

glut

GL_RGBA

GL_UNSIGNED_BYTE

Constructor Detail

NativeDesktopPainter

Method Detail

getGL

getGL2

setGL

getGLU

setGLU

getGLUT

setGLUT

acquireGL

releaseGL

getCurrentGL

getCurrentContext

configureGL

getWindowingToolkit

getViewPortAsInt

getProjectionAsDouble

getProjectionAsFloat

getModelViewAsDouble

getModelViewAsFloat

glPushMatrix

glPopMatrix

glMatrixMode

glLoadIdentity

glScalef

glTranslatef

glRotatef

glEnable

glDisable

glPointSize

glLineWidth

glBegin

glColor3f

glColor4f

glVertex3f

glVertex3d

glEnd

glFrontFace

glCullFace

glPolygonMode

polygonModeValue

polygonFillValue

glPolygonMode

glPolygonOffset

glLineStipple

glTexCoord2f

glTexEnvf

glTexEnvi

glRasterPos3f

glDrawPixels

glPixelZoom

glPixelStorei

glPixelStore

glBitmap

drawImage

glutBitmapString

drawText

getOrCreateTextRenderer

glutBitmapString

glutBitmapLength

getTextLengthInPixels

getTextLengthInPixels

glGenLists

glNewList

glNewList