com.jogamp.opengl.util

## Class ImmModeSink

- java.lang.Object
- - com.jogamp.opengl.util.ImmModeSink

-     public class ImmModeSink
      extends Object

  Immediate mode sink, implementing OpenGL fixed function subset of immediate mode operations, i.e.

         glBegin();
           glVertex3f(1f, 1f, 1f);
           glColor4f(1f, 1f, 1f, 1f);
           ...
         glEnd();

  Implementation buffers all vertex, colors, normal and texture-coord elements in their respective buffers to be either rendered directly via `glEnd(GL)` or to be added to an internal display list via `glEnd(gl, false)` for deferred rendering via `draw(GL, boolean)`.

  ##### Buffer storage and it's creation via `createFixed(..)` and `createGLSL(..)`

  If unsure whether colors, normals and textures will be used, simply add them with an expected component count. This implementation will only render buffers which are being filled.
  The buffer growing implementation will only grow the exceeded buffers, unused buffers are not resized.

  Note: Optional types, i.e. color, must be either not used or used w/ the same element count as vertex, etc. This is a semantic constraint, same as in the original OpenGL spec.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static int` | `GL_POLYGON`
    `static int` | `GL_QUAD_STRIP`
    `static int` | `GL_QUADS`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static ImmModeSink` | `createFixed(int initialElementCount, int vComps, int vDataType, int cComps, int cDataType, int nComps, int nDataType, int tComps, int tDataType, int glBufferUsage)` Uses a GL2ES1, or ES2 fixed function emulation immediate mode sink
    `static ImmModeSink` | `createGLSL(int initialElementCount, int vComps, int vDataType, int cComps, int cDataType, int nComps, int nDataType, int tComps, int tDataType, int glBufferUsage, int shaderProgram)` Uses a GL2ES2 GLSL shader immediate mode sink, utilizing the given shader-program.
    `static ImmModeSink` | `createGLSL(int initialElementCount, int vComps, int vDataType, int cComps, int cDataType, int nComps, int nDataType, int tComps, int tDataType, int glBufferUsage, ShaderState st)` Uses a GL2ES2 GLSL shader immediate mode sink, utilizing the given ShaderState.
    `void` | `destroy(GL gl)`
    `void` | `draw(GL gl, boolean disableBufferAfterDraw)`
    `void` | `draw(GL gl, Buffer indices, boolean disableBufferAfterDraw)`
    `int` | `getResizeElementCount()` Returns the additional element count if buffer resize is required.
    `boolean` | `getUseVBO()`
    `void` | `glBegin(int mode)`
    `void` | `glColor3b(byte x, byte y, byte z)`
    `void` | `glColor3f(float x, float y, float z)`
    `void` | `glColor3s(short x, short y, short z)`
    `void` | `glColor3ub(byte x, byte y, byte z)`
    `void` | `glColor4b(byte x, byte y, byte z, byte a)`
    `void` | `glColor4f(float x, float y, float z, float a)`
    `void` | `glColor4s(short x, short y, short z, short a)`
    `void` | `glColor4ub(byte x, byte y, byte z, byte a)`
    `void` | `glColorv(Buffer v)`
    `void` | `glEnd(GL gl)`
    `void` | `glEnd(GL gl, boolean immediateDraw)`
    `void` | `glEnd(GL gl, Buffer indices)`
    `void` | `glNormal3b(byte x, byte y, byte z)`
    `void` | `glNormal3f(float x, float y, float z)`
    `void` | `glNormal3s(short x, short y, short z)`
    `void` | `glNormalv(Buffer v)`
    `void` | `glTexCoord2b(byte x, byte y)`
    `void` | `glTexCoord2f(float x, float y)`
    `void` | `glTexCoord2s(short x, short y)`
    `void` | `glTexCoord3b(byte x, byte y, byte z)`
    `void` | `glTexCoord3f(float x, float y, float z)`
    `void` | `glTexCoord3s(short x, short y, short z)`
    `void` | `glTexCoordv(Buffer v)`
    `void` | `glVertex2b(byte x, byte y)`
    `void` | `glVertex2f(float x, float y)`
    `void` | `glVertex2s(short x, short y)`
    `void` | `glVertex3b(byte x, byte y, byte z)`
    `void` | `glVertex3f(float x, float y, float z)`
    `void` | `glVertex3s(short x, short y, short z)`
    `void` | `glVertexv(Buffer v)`
    `void` | `reset()`
    `void` | `reset(GL gl)`
    `void` | `setResizeElementCount(int v)` Sets the additional element count if buffer resize is required, defaults to `initialElementCount` of factory method.
    `String` | `toString()`

    - ### Methods inherited from class java.lang.Object

      `equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### GL_QUADS

          public static final int GL_QUADS

      See Also:
        Constant Field Values

    - #### GL_QUAD_STRIP

          public static final int GL_QUAD_STRIP

      See Also:
        Constant Field Values

    - #### GL_POLYGON

          public static final int GL_POLYGON

      See Also:
        Constant Field Values

  - ### Method Detail

    - #### createFixed

          public static ImmModeSink createFixed(int initialElementCount,
                                int vComps,
                                int vDataType,
                                int cComps,
                                int cDataType,
                                int nComps,
                                int nDataType,
                                int tComps,
                                int tDataType,
                                int glBufferUsage)

      Uses a GL2ES1, or ES2 fixed function emulation immediate mode sink

      See buffer storage details.

      Parameters:
        `initialElementCount` - initial buffer size, if subsequent mutable operations are about to exceed the buffer size, the buffer will grow about the initial size.
        `vComps` - mandatory vertex component count, should be 2, 3 or 4.
        `vDataType` - mandatory vertex data type, e.g. `GL.GL_FLOAT`
        `cComps` - optional color component count, may be 0, 3 or 4
        `cDataType` - optional color data type, e.g. `GL.GL_FLOAT`
        `nComps` - optional normal component count, may be 0, 3 or 4
        `nDataType` - optional normal data type, e.g. `GL.GL_FLOAT`
        `tComps` - optional texture-coordinate component count, may be 0, 2 or 3
        `tDataType` - optional texture-coordinate data type, e.g. `GL.GL_FLOAT`
        `glBufferUsage` - VBO `usage` parameter for `GL.glBufferData(int, long, Buffer, int)`, e.g. `GL.GL_STATIC_DRAW`, set to `0` for no VBO usage

    - #### createGLSL

          public static ImmModeSink createGLSL(int initialElementCount,
                               int vComps,
                               int vDataType,
                               int cComps,
                               int cDataType,
                               int nComps,
                               int nDataType,
                               int tComps,
                               int tDataType,
                               int glBufferUsage,
                               ShaderState st)

      Uses a GL2ES2 GLSL shader immediate mode sink, utilizing the given ShaderState.

      See buffer storage details.

      Parameters:
        `initialElementCount` - initial buffer size, if subsequent mutable operations are about to exceed the buffer size, the buffer will grow about the initial size.
        `vComps` - mandatory vertex component count, should be 2, 3 or 4.
        `vDataType` - mandatory vertex data type, e.g. `GL.GL_FLOAT`
        `cComps` - optional color component count, may be 0, 3 or 4
        `cDataType` - optional color data type, e.g. `GL.GL_FLOAT`
        `nComps` - optional normal component count, may be 0, 3 or 4
        `nDataType` - optional normal data type, e.g. `GL.GL_FLOAT`
        `tComps` - optional texture-coordinate component count, may be 0, 2 or 3
        `tDataType` - optional texture-coordinate data type, e.g. `GL.GL_FLOAT`
        `glBufferUsage` - VBO `usage` parameter for `GL.glBufferData(int, long, Buffer, int)`, e.g. `GL.GL_STATIC_DRAW`, set to `0` for no VBO usage
        `st` - ShaderState to locate the vertex attributes
      See Also:
        `draw(GL, boolean)`, `ShaderState.useProgram(GL2ES2, boolean)`, `com.jogamp.opengl.util.glsl.ShaderState#getCurrentShaderState()`

    - #### createGLSL

          public static ImmModeSink createGLSL(int initialElementCount,
                               int vComps,
                               int vDataType,
                               int cComps,
                               int cDataType,
                               int nComps,
                               int nDataType,
                               int tComps,
                               int tDataType,
                               int glBufferUsage,
                               int shaderProgram)

      Uses a GL2ES2 GLSL shader immediate mode sink, utilizing the given shader-program.

      See buffer storage details.

      Parameters:
        `initialElementCount` - initial buffer size, if subsequent mutable operations are about to exceed the buffer size, the buffer will grow about the initial size.
        `vComps` - mandatory vertex component count, should be 2, 3 or 4.
        `vDataType` - mandatory vertex data type, e.g. `GL.GL_FLOAT`
        `cComps` - optional color component count, may be 0, 3 or 4
        `cDataType` - optional color data type, e.g. `GL.GL_FLOAT`
        `nComps` - optional normal component count, may be 0, 3 or 4
        `nDataType` - optional normal data type, e.g. `GL.GL_FLOAT`
        `tComps` - optional texture-coordinate component count, may be 0, 2 or 3
        `tDataType` - optional texture-coordinate data type, e.g. `GL.GL_FLOAT`
        `glBufferUsage` - VBO `usage` parameter for `GL.glBufferData(int, long, Buffer, int)`, e.g. `GL.GL_STATIC_DRAW`, set to `0` for no VBO usage
        `shaderProgram` - shader-program name to locate the vertex attributes
      See Also:
        `draw(GL, boolean)`, `ShaderState.useProgram(GL2ES2, boolean)`, `com.jogamp.opengl.util.glsl.ShaderState#getCurrentShaderState()`

    - #### destroy

          public void destroy(GL gl)

    - #### reset

          public void reset()

    - #### reset

          public void reset(GL gl)

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### draw

          public void draw(GL gl,
                  boolean disableBufferAfterDraw)

    - #### draw

          public void draw(GL gl,
                  Buffer indices,
                  boolean disableBufferAfterDraw)

    - #### glBegin

          public void glBegin(int mode)

    - #### glEnd

          public final void glEnd(GL gl)

    - #### glEnd

          public void glEnd(GL gl,
                   boolean immediateDraw)

    - #### glEnd

          public final void glEnd(GL gl,
                   Buffer indices)

    - #### glVertexv

          public void glVertexv(Buffer v)

    - #### glNormalv

          public void glNormalv(Buffer v)

    - #### glColorv

          public void glColorv(Buffer v)

    - #### glTexCoordv

          public void glTexCoordv(Buffer v)

    - #### glVertex2f

          public final void glVertex2f(float x,
                        float y)

    - #### glVertex3f

          public final void glVertex3f(float x,
                        float y,
                        float z)

    - #### glNormal3f

          public final void glNormal3f(float x,
                        float y,
                        float z)

    - #### glColor3f

          public final void glColor3f(float x,
                       float y,
                       float z)

    - #### glColor4f

          public final void glColor4f(float x,
                       float y,
                       float z,
                       float a)

    - #### glTexCoord2f

          public final void glTexCoord2f(float x,
                          float y)

    - #### glTexCoord3f

          public final void glTexCoord3f(float x,
                          float y,
                          float z)

    - #### glVertex2s

          public final void glVertex2s(short x,
                        short y)

    - #### glVertex3s

          public final void glVertex3s(short x,
                        short y,
                        short z)

    - #### glNormal3s

          public final void glNormal3s(short x,
                        short y,
                        short z)

    - #### glColor3s

          public final void glColor3s(short x,
                       short y,
                       short z)

    - #### glColor4s

          public final void glColor4s(short x,
                       short y,
                       short z,
                       short a)

    - #### glTexCoord2s

          public final void glTexCoord2s(short x,
                          short y)

    - #### glTexCoord3s

          public final void glTexCoord3s(short x,
                          short y,
                          short z)

    - #### glVertex2b

          public final void glVertex2b(byte x,
                        byte y)

    - #### glVertex3b

          public final void glVertex3b(byte x,
                        byte y,
                        byte z)

    - #### glNormal3b

          public final void glNormal3b(byte x,
                        byte y,
                        byte z)

    - #### glColor3b

          public final void glColor3b(byte x,
                       byte y,
                       byte z)

    - #### glColor3ub

          public final void glColor3ub(byte x,
                        byte y,
                        byte z)

    - #### glColor4b

          public final void glColor4b(byte x,
                       byte y,
                       byte z,
                       byte a)

    - #### glColor4ub

          public final void glColor4ub(byte x,
                        byte y,
                        byte z,
                        byte a)

    - #### glTexCoord2b

          public final void glTexCoord2b(byte x,
                          byte y)

    - #### glTexCoord3b

          public final void glTexCoord3b(byte x,
                          byte y,
                          byte z)

    - #### getUseVBO

          public boolean getUseVBO()

    - #### getResizeElementCount

          public int getResizeElementCount()

      Returns the additional element count if buffer resize is required.
      See Also:
        `setResizeElementCount(int)`

    - #### setResizeElementCount

          public void setResizeElementCount(int v)

      Sets the additional element count if buffer resize is required, defaults to `initialElementCount` of factory method.
      See Also:
        `createFixed(int, int, int, int, int, int, int, int, int, int)`, `createGLSL(int, int, int, int, int, int, int, int, int, int, ShaderState)`

Copyright 2010 JogAmp Community.