Overview | Package | Class | Tree | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## de.grogra.imp3d.gl
Class GLDisplay

    java.lang.Object
      de.grogra.imp.awt.ViewComponentAdapter
          de.grogra.imp3d.gl.GLDisplay

All Implemented Interfaces:
  ViewComponent, RenderState, ComponentWrapper, Selectable, Disposable, java.awt.image.ImageObserver, java.lang.Runnable, java.util.EventListener, javax.media.opengl.GLEventListener

    public class GLDisplay

extends ViewComponentAdapter
implements javax.media.opengl.GLEventListener, RenderState, java.awt.image.ImageObserver, Selectable

This class is responsible for drawing all visible objects in the GroIMP3D editor. It uses OpenGL to provide hardware accelerated drawing. To access OpenGL, the library JOGL has to be installed. JOGL is available from: https://jogl.dev.java.net/ Download the jogl.jar (contains the Java API for JOGL) and the jogl-natives-*.jar (contains the native library for your system). When starting GroIMP, make sure that the jogl.jar is in your classpath and the libraries (.dll or .so) from the jogl-natives-*.jar are in your search path for system libraries. Making those files available can be done by calling GroIMP like this: \code (linux version) javaw -cp core.jar:jogl.jar -Djava.library.path=/usr/lib/jogl de.grogra.pf.boot.Main (windows version) javaw -cp core.jar;jogl.jar -Djava.library.path=c:\java\jogl de.grogra.pf.boot.Main \endcode OpenGL acts as a state machine. To provide a consistent state for every drawing function, some rules were created. There are state variables that are expected to have a certain value when a drawing function is entered. Those state variables are: - MatrixMode set to GL_MODELVIEW - ShadeModel set to GL_SMOOTH - GL_DEPTH_TEST enabled - GL_LIGHTING enabled - GL_TEXTURE_2D disabled - GL_CULL_FACE enabled - GL_COLOR_MATERIAL enabled - ColorMaterial is set to GL_FRONT_AND_BACK and GL_AMBIENT_AND_DIFFUSE - GL_NORMALIZE is enabled - PolygonMode is set to GL_FRONT_AND_BACK and GL_LINE - GL_ALPHA_TEST enabled - AlphaFunc set to GL_GREATER and 0.1f - GL_LIGHT_MODEL_TWO_SIDE is set to 0 If a drawing function changes some of those state variables, it has to reset them to their previous value upon return. Other state variables are not expected to have a defined value when a drawing function is called. Those state variables are: - all texture related state for TEXTURE UNIT 0 - the contents of the matrices MODELVIEW and TEXTURE All state variables not mentioned above should be reset to their default value as defined by OpenGL when they were changed. This class also provides an implementation of LOD (level of detail). For now lod is only applied to the sphere and frustum primitives. While the sphere uses the lod to select the appropriate display list, the frustum uses it to calculate the number of generated segments when drawing.

Author:
  nmi

Field Summary
`protected int` | `dlSupershape` Display list number for supershapes.
`Pool` | `pool`
`static Type` | `RENDER_MODE`

Fields inherited from class de.grogra.imp.awt.ViewComponentAdapter
`DISPOSED, DISPOSING, RENDERED_IMAGE, RENDERING, REPAINT_MASK`

Fields inherited from interface de.grogra.imp3d.RenderState
`CURRENT_HIGHLIGHT`

Fields inherited from interface java.awt.image.ImageObserver
`ABORT, ALLBITS, ERROR, FRAMEBITS, HEIGHT, PROPERTIES, SOMEBITS, WIDTH`

Fields inherited from interface de.grogra.imp.ViewComponent
`ALL, CHANGED, MIN_USER_FLAG, SCENE, SELECTION, TOOLS`

Constructor Summary
`GLDisplay()`

Method Summary
`void` | `display(javax.media.opengl.GLAutoDrawable d)`
`void` | `displayChanged(javax.media.opengl.GLAutoDrawable d, boolean modeChanged, boolean deviceChanged)`
`void` | `dispose()`
`void` | `drawBox(float halfWidth, float halfLength, float height, Shader s, int highlight, Matrix4d t)` Draw a box from -axis to +axis using the transformation matrix t.
`void` | `drawFrustum(float length, float baseRadius, float topRadius, boolean baseClosed, boolean topClosed, float scaleV, Shader s, int highlight, Matrix4d t)` Can be used to draw cylinders and the like.
`void` | `drawLine(Tuple3f origin, Tuple3f end, Tuple3f color, int highlight, Matrix4d t)` Connect the two points with a line and apply the transformation matrix.
`void` | `drawParallelogram(float length, Vector3f axis, float scaleU, float scaleV, Shader s, int highlight, Matrix4d t)`
`void` | `drawPlane(Shader s, int highlight, Matrix4d t)` Draw an x/y plane.
`void` | `drawPoint(Tuple3f origin, int pixelSize, Tuple3f color, int highlight, Matrix4d t)` Draw a single point with the specified pixel size and color.
`void` | `drawPointCloud(float[] locations, float pointSize, Tuple3f color, int highlight, Matrix4d t)` Draw a set of points.
`void` | `drawPolygons(Polygonizable pz, java.lang.Object obj, boolean asNode, Shader s, int highlight, Matrix4d t)`
`void` | `drawRectangle(int x, int y, int w, int h, Tuple3f color)` Draw a rectangle from (x/y) to (x+w/y+h) with the specified color.
`void` | `drawSphere(float radius, Shader s, int highlight, Matrix4d t)` Draw a sphere with the specified radius around the origin (0/0/0).
`void` | `drawString(int x, int y, java.lang.String text, java.awt.Font font, Tuple3f color)` Draw a string with the selected font and color at location (x/y).
`void` | `drawSupershape(float a, float b, float m1, float n11, float n12, float n13, float m2, float n21, float n22, float n23, Shader s, int highlight, Matrix4d t)` Draw a supershape around the origin (0/0/0).
`protected int` | `drawWithDisplayList(int index, javax.media.opengl.GL gl, int levels, float lod)`
`float` | `estimateScaleAt(Tuple3f point)`
`float` | `estimateScaleAt(Tuple3f point, Matrix4d t)` Returns the size of an object of size 1.0 (in object coordinates) on the screen (in pixels).
`void` | `fillRectangle(int x, int y, int w, int h, Tuple3f color)` Draw a filled rectangle from (x/y) to (x+w/y+h) with the specified color.
`java.lang.Object` | `getComponent()`
`int` | `getCurrentHighlight()`
`Shader` | `getCurrentShader()`
`protected java.awt.image.ImageObserver` | `getObserverForRenderer()` Returns an observer which receives the information about the rendered image from a `Renderer`.
`Pool` | `getPool()`
`View3D` | `getView3D()`
`boolean` | `getWindowPos(Tuple3f origin, Tuple2f out)` Computes the window coordinates in pixels of a location in the current object coordinates.
`boolean` | `imageUpdate(java.awt.Image img, int infoflags, int x, int y, int width, int height)` This class implements the ImageObserver interface to be notified about changes of the background image.
`void` | `init(javax.media.opengl.GLAutoDrawable d)` Initialise opengl state and set default values.
`protected void` | `initRender(int flags)` Performs initialization tasks in preparation for rendering.
`void` | `initView(View view, EventListener listener)` Initializes this component.
`protected void` | `invokeRender(int flags)` Invoked to perform rendering.
`static boolean` | `isExtensionSupported(javax.media.opengl.GL gl, java.lang.String extension)`
`void` | `makeSnapshot(ObjectConsumer<? super java.awt.image.RenderedImage> callback)` Instructs the view component to create a snapshot.
`protected void` | `optionValueChanged(java.lang.String name, java.lang.Object value)`
`protected void` | `render(int flags)` Render the scene graph.
`void` | `reshape(javax.media.opengl.GLAutoDrawable d, int x, int y, int w, int h)`

Methods inherited from class de.grogra.imp.awt.ViewComponentAdapter
`checkRepaint, checkRepaintWrapException, disposeRenderer, getColor, getColor, getFactory, getFontMetrics, getGlobalLOD, getIntColor, getInterruptedException, getOption, getRenderGraphState, getView, initFactory, installListeners, invokeRenderSync, render, render, renderUninterruptibly, repaint, run, toSelection, uninstallListeners`

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

Methods inherited from interface de.grogra.imp3d.RenderState
`getFontMetrics, getRenderGraphState`

Methods inherited from interface de.grogra.pf.ui.edit.Selectable
`toSelection`

Field Detail

### dlSupershape

    protected int dlSupershape

  Display list number for supershapes. There will be display lists generated for numbers dlSupershape to (dlSupershape + LOD_LEVELS - 1). A value of 0 for dlSupershape means, that no display list is available.

### pool

    public final Pool pool

### RENDER_MODE

    public static final Type RENDER_MODE

Constructor Detail

### GLDisplay

    public GLDisplay()

Method Detail

### display

    public void display(javax.media.opengl.GLAutoDrawable d)

  Specified by:
    `display` in interface `javax.media.opengl.GLEventListener`

### displayChanged

    public void displayChanged(javax.media.opengl.GLAutoDrawable d,
                               boolean modeChanged,
                               boolean deviceChanged)

  Specified by:
    `displayChanged` in interface `javax.media.opengl.GLEventListener`

### dispose

    public void dispose()

  Specified by:
    `dispose` in interface `Disposable`
  Overrides:
    `dispose` in class `ViewComponentAdapter`

### drawBox

    public void drawBox(float halfWidth,
                        float halfLength,
                        float height,
                        Shader s,
                        int highlight,
                        Matrix4d t)

  Draw a box from -axis to +axis using the transformation matrix t.

  Specified by:
    `drawBox` in interface `RenderState`
  Parameters:
    `axis` - defines size of box

### drawFrustum

    public void drawFrustum(float length,
                            float baseRadius,
                            float topRadius,
                            boolean baseClosed,
                            boolean topClosed,
                            float scaleV,
                            Shader s,
                            int highlight,
                            Matrix4d t)

  Can be used to draw cylinders and the like. The frustum has a cirle at the top and bottom, which are connected with a surface. The center of the bottom circle is (0/0/0), the center of the top circle is axis. Both circles are parallel to the x/y plane.

  Specified by:
    `drawFrustum` in interface `RenderState`

### drawLine

    public void drawLine(Tuple3f origin,
                         Tuple3f end,
                         Tuple3f color,
                         int highlight,
                         Matrix4d t)

  Connect the two points with a line and apply the transformation matrix.

  Specified by:
    `drawLine` in interface `RenderState`

### drawParallelogram

    public void drawParallelogram(float length,
                                  Vector3f axis,
                                  float scaleU,
                                  float scaleV,
                                  Shader s,
                                  int highlight,
                                  Matrix4d t)

  Specified by:
    `drawParallelogram` in interface `RenderState`

### drawPlane

    public void drawPlane(Shader s,
                          int highlight,
                          Matrix4d t)

  Draw an x/y plane.

  Specified by:
    `drawPlane` in interface `RenderState`

### drawPoint

    public void drawPoint(Tuple3f origin,
                          int pixelSize,
                          Tuple3f color,
                          int highlight,
                          Matrix4d t)

  Draw a single point with the specified pixel size and color. Although OpenGL provides a function to draw points, the point is represented by a sphere, because some graphics cards/drivers seem to have problems setting the size for the point.

  Specified by:
    `drawPoint` in interface `RenderState`
  Parameters:
    `pixelSize` - size of point on screen in pixels

### drawPointCloud

    public void drawPointCloud(float[] locations,
                               float pointSize,
                               Tuple3f color,
                               int highlight,
                               Matrix4d t)

  Description copied from interface: `RenderState`
  Draw a set of points. The array locations contains a sequence of points given as triples of floats for x, y and z position of each point. If the same reference for the array location is passed in the implementation might assume that the contents of the array are the same as well. This is necessary for GLDisplay, for instance, to ensure a performant implementation. The class PointCloud ensures that this is the case.

  Specified by:
    `drawPointCloud` in interface `RenderState`
  Parameters:
    `locations` - array containing a sequence (x,y,z) of points
    `pointSize` - size of the point on screen
    `color` - color of the point
    `t` - transformation of the point cloud

### drawPolygons

    public void drawPolygons(Polygonizable pz,
                             java.lang.Object obj,
                             boolean asNode,
                             Shader s,
                             int highlight,
                             Matrix4d t)

  Specified by:
    `drawPolygons` in interface `RenderState`

### drawRectangle

    public void drawRectangle(int x,
                              int y,
                              int w,
                              int h,
                              Tuple3f color)

  Draw a rectangle from (x/y) to (x+w/y+h) with the specified color.

  Specified by:
    `drawRectangle` in interface `RenderState`

### drawSphere

    public void drawSphere(float radius,
                           Shader s,
                           int highlight,
                           Matrix4d t)

  Draw a sphere with the specified radius around the origin (0/0/0).

  Specified by:
    `drawSphere` in interface `RenderState`

### drawString

    public void drawString(int x,
                           int y,
                           java.lang.String text,
                           java.awt.Font font,
                           Tuple3f color)

  Draw a string with the selected font and color at location (x/y).

  Specified by:
    `drawString` in interface `RenderState`

### drawSupershape

    public void drawSupershape(float a,
                               float b,
                               float m1,
                               float n11,
                               float n12,
                               float n13,
                               float m2,
                               float n21,
                               float n22,
                               float n23,
                               Shader s,
                               int highlight,
                               Matrix4d t)

  Draw a supershape around the origin (0/0/0). An implementation of Johan Gielis's Superformula which was published in the American Journal of Botany 90(3): 333–338. 2003. INVITED SPECIAL PAPER A GENERIC GEOMETRIC TRANSFORMATION THAT UNIFIES A WIDE RANGE OF NATURAL AND ABSTRACT SHAPES

  Specified by:
    `drawSupershape` in interface `RenderState`
  Parameters:
    `a,` - b length of curves
    `m,` - n shape parameters
    `shader` -
    `highlight` -
    `t` - transformation of the point cloud

### drawWithDisplayList

    protected int drawWithDisplayList(int index,
                                      javax.media.opengl.GL gl,
                                      int levels,
                                      float lod)

### estimateScaleAt

    public float estimateScaleAt(Tuple3f point)

  Specified by:
    `estimateScaleAt` in interface `RenderState`

### estimateScaleAt

    public float estimateScaleAt(Tuple3f point,
                                 Matrix4d t)

  Returns the size of an object of size 1.0 (in object coordinates) on the screen (in pixels).

  Parameters:
    `point` -
    `t` -
  Returns:

### fillRectangle

    public void fillRectangle(int x,
                              int y,
                              int w,
                              int h,
                              Tuple3f color)

  Draw a filled rectangle from (x/y) to (x+w/y+h) with the specified color.

  Specified by:
    `fillRectangle` in interface `RenderState`

### getComponent

    public java.lang.Object getComponent()

  Specified by:
    `getComponent` in interface `ComponentWrapper`

### getCurrentHighlight

    public int getCurrentHighlight()

  Specified by:
    `getCurrentHighlight` in interface `RenderState`

### getCurrentShader

    public Shader getCurrentShader()

  Specified by:
    `getCurrentShader` in interface `RenderState`

### getObserverForRenderer

    protected java.awt.image.ImageObserver getObserverForRenderer()

  Description copied from class: `ViewComponentAdapter`
  Returns an observer which receives the information about the rendered image from a `Renderer`. The returned observer has to manage the drawing of the (partially) rendered image on the view component.

  Specified by:
    `getObserverForRenderer` in class `ViewComponentAdapter`
  Returns:
    an observer receiving the image, or `null` if this is not supported by this component

### getPool

    public Pool getPool()

  Specified by:
    `getPool` in interface `RenderState`

### getView3D

    public View3D getView3D()

### getWindowPos

    public boolean getWindowPos(Tuple3f origin,
                                Tuple2f out)

  Description copied from interface: `RenderState`
  Computes the window coordinates in pixels of a location in the current object coordinates.

  Specified by:
    `getWindowPos` in interface `RenderState`
  Parameters:
    `origin` - a location in local object coordinates
    `out` - the computed window coordinates are placed in here
  Returns:
    `true` iff the window coordinates are valid (i.e., the location is in the clipping region)

### imageUpdate

    public boolean imageUpdate(java.awt.Image img,
                               int infoflags,
                               int x,
                               int y,
                               int width,
                               int height)

  This class implements the ImageObserver interface to be notified about changes of the background image.

  Specified by:
    `imageUpdate` in interface `java.awt.image.ImageObserver`

### init

    public void init(javax.media.opengl.GLAutoDrawable d)

  Initialise opengl state and set default values. All functions can assume those values being set upon call (i.e. MatrixMode as GL_MODELVIEW). If a function changes any of those values, it has to restore its state before calling another function or exiting.

  Specified by:
    `init` in interface `javax.media.opengl.GLEventListener`

### initRender

    protected void initRender(int flags)

  Description copied from class: `ViewComponentAdapter`
  Performs initialization tasks in preparation for rendering. This method is invoked by `ViewComponentAdapter.run()` in this `ViewComponent`'s own thread.

  Specified by:
    `initRender` in class `ViewComponentAdapter`
  Parameters:
    `flags` - combination of bit masks

### initView

    public void initView(View view,
                         EventListener listener)

  Description copied from interface: `ViewComponent`
  Initializes this component. This method sets the `view` within which this view component is used to display the graph. It also sets an event listener. this has to be informed of mouse and keys events within the view component by implementations of this method.

  Specified by:
    `initView` in interface `ViewComponent`
  Overrides:
    `initView` in class `ViewComponentAdapter`
  Parameters:
    `view` - the containing view
    `listener` - mouse and key events will be reported to this listener

### invokeRender

    protected void invokeRender(int flags)

  Description copied from class: `ViewComponentAdapter`
  Invoked to perform rendering. This method is invoked by `ViewComponentAdapter.run()` in this `ViewComponent`'s own thread. Its sole task is to invoke `ViewComponentAdapter.invokeRenderSync(int)` in the rendering thread (which may be this `ViewComponent`'s thread, the AWT-thread, or another thread, depending on the implementation) in a write-protected context. The invocation has to be synchronously, i.e., if it is in another thread, the current thread has to wait until `ViewComponentAdapter.invokeRenderSync(int)` has completed.

  Specified by:
    `invokeRender` in class `ViewComponentAdapter`
  Parameters:
    `flags` - the flags to pass to `ViewComponentAdapter.invokeRenderSync(int)`

### isExtensionSupported

    public static boolean isExtensionSupported(javax.media.opengl.GL gl,
                                               java.lang.String extension)

### makeSnapshot

    public void makeSnapshot(ObjectConsumer<? super java.awt.image.RenderedImage> callback)

  Description copied from interface: `ViewComponent`
  Instructs the view component to create a snapshot. The created snapshot has to be delivered to the provided `callback` as an instance of `RenderedImage`. This may happen asynchronously, i.e., in an arbitrary thread.

  Specified by:
    `makeSnapshot` in interface `ViewComponent`
  Parameters:
    `callback` - callback which asynchronously receives the snapshot

### optionValueChanged

    protected void optionValueChanged(java.lang.String name,
                                      java.lang.Object value)

  Overrides:
    `optionValueChanged` in class `ViewComponentAdapter`

### render

    protected void render(int flags)
                   throws java.lang.InterruptedException

  Render the scene graph. This function will traverse the scene graph and render all objects of it. These steps are performed:
  1. get GL
  2. if GL changed, delete textures
  3. clear the frame buffer
  4. draw background image (i.e. from povray)
  5. clear depth buffer
  6. set projection matrix
  7. check if the scene graph changed since last render, than remember that and perform an update of the light sources
  8. walk graph first time, visit every object, update lights if necessary
  9. if lights have changed, draw the scene again
  10. walk graph second time, visit highlighted objects
  11. disable lighting and depth buffer
  12. walk graph third time, visit tools (i.e. arrows to move objects)
  13. enable lighting and depth buffer

  Specified by:
    `render` in class `ViewComponentAdapter`
  Parameters:
    `flags` - combination of bit masks
  Throws:
    `java.lang.InterruptedException` - if the rendering has been interrupted

### reshape

    public void reshape(javax.media.opengl.GLAutoDrawable d,
                        int x,
                        int y,
                        int w,
                        int h)

  Specified by:
    `reshape` in interface `javax.media.opengl.GLEventListener`

Overview | Package | Class | Tree | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD