PShapeOpenGL

java.lang.Object
- processing.core.PShape
- - processing.opengl.PShapeOpenGL

All Implemented Interfaces:

PConstants
```
public class PShapeOpenGL
extends PShape
```
This class holds a 3D model composed of vertices, normals, colors (per vertex) and texture coordinates (also per vertex). All this data is stored in Vertex Buffer Objects (VBO) in GPU memory for very fast access. OBJ loading implemented using code from Saito's OBJLoader library: http://code.google.com/p/saitoobjloader/ and OBJReader from Ahmet Kizilay http://www.openprocessing.org/visuals/?visualID=191 By Andres Colubri Other formats to consider: AMF: http://en.wikipedia.org/wiki/Additive_Manufacturing_File_Format STL: http://en.wikipedia.org/wiki/STL_(file_format) OFF: http://people.sc.fsu.edu/~jburkardt/data/off/off.html(file_format) DXF: http://en.wikipedia.org/wiki/AutoCAD_DXF

Field Summary

Fields
Modifier and Type Field and Description

static int DIRECTION

int glUsage

static int NORMAL

static int OFFSET

static int POSITION

static int TEXCOORD
- Fields inherited from class processing.core.PShape
  colorMode, colorModeA, colorModeX, colorModeY, colorModeZ, depth, GEOMETRY, height, INSIDE_BEGIN_END_ERROR, NO_SUCH_VERTEX_ERROR, NO_VERTICES_ERROR, NOT_A_SIMPLE_VERTEX, OUTSIDE_BEGIN_END_ERROR, PATH, PER_VERTEX_UNSUPPORTED, PRIMITIVE, width
- Fields inherited from interface processing.core.PConstants
  ADD, ALPHA, ALT, AMBIENT, ARC, ARGB, ARROW, BACKSPACE, BASELINE, BEVEL, BEZIER_VERTEX, BLEND, BLUR, BOTTOM, BOX, BREAK, BURN, CENTER, CHATTER, CHORD, CLAMP, CLOSE, CODED, COMPLAINT, CONTROL, CORNER, CORNERS, CROSS, CURVE_VERTEX, CUSTOM, DARKEST, DEG_TO_RAD, DELETE, DIAMETER, DIFFERENCE, DILATE, DIRECTIONAL, DISABLE_ASYNC_SAVEFRAME, DISABLE_BUFFER_READING, DISABLE_DEPTH_MASK, DISABLE_DEPTH_SORT, DISABLE_DEPTH_TEST, DISABLE_KEY_REPEAT, DISABLE_NATIVE_FONTS, DISABLE_OPENGL_ERRORS, DISABLE_OPTIMIZED_STROKE, DISABLE_STROKE_PERSPECTIVE, DISABLE_STROKE_PURE, DISABLE_TEXTURE_MIPMAPS, DODGE, DOWN, DXF, ELLIPSE, ENABLE_ASYNC_SAVEFRAME, ENABLE_BUFFER_READING, ENABLE_DEPTH_MASK, ENABLE_DEPTH_SORT, ENABLE_DEPTH_TEST, ENABLE_KEY_REPEAT, ENABLE_NATIVE_FONTS, ENABLE_OPENGL_ERRORS, ENABLE_OPTIMIZED_STROKE, ENABLE_STROKE_PERSPECTIVE, ENABLE_STROKE_PURE, ENABLE_TEXTURE_MIPMAPS, ENTER, EPSILON, ERODE, ESC, EXCLUSION, FX2D, GIF, GRAY, GROUP, HALF_PI, HAND, HARD_LIGHT, HINT_COUNT, HSB, IMAGE, INVERT, JAVA2D, JPEG, LANDSCAPE, LEFT, LIGHTEST, LINE, LINE_LOOP, LINE_STRIP, LINES, LINUX, MACOSX, MAX_FLOAT, MAX_INT, MIN_FLOAT, MIN_INT, MITER, MODEL, MODELVIEW, MOVE, MULTIPLY, OPAQUE, OPEN, OPENGL, ORTHOGRAPHIC, OTHER, OVERLAY, P2D, P3D, PDF, PERSPECTIVE, PI, PIE, platformNames, POINT, POINTS, POLYGON, PORTRAIT, POSTERIZE, PROBLEM, PROJECT, PROJECTION, QUAD, QUAD_BEZIER_VERTEX, QUAD_STRIP, QUADRATIC_VERTEX, QUADS, QUARTER_PI, RAD_TO_DEG, RADIUS, RECT, REPEAT, REPLACE, RETURN, RGB, RIGHT, ROUND, SCREEN, SHAPE, SHIFT, SOFT_LIGHT, SPAN, SPHERE, SPOT, SQUARE, SUBTRACT, SVG, TAB, TARGA, TAU, TEXT, THIRD_PI, THRESHOLD, TIFF, TOP, TRIANGLE, TRIANGLE_FAN, TRIANGLE_STRIP, TRIANGLES, TWO_PI, UP, VERTEX, WAIT, WHITESPACE, WINDOWS, X, Y, Z

Fields
Modifier and Type	Field and Description
`static int`	`DIRECTION`
`int`	`glUsage`
`static int`	`NORMAL`
`static int`	`OFFSET`
`static int`	`POSITION`
`static int`	`TEXCOORD`

Constructor Summary

Constructors
Constructor and Description
`PShapeOpenGL(PGraphicsOpenGL pg, int family)`
`PShapeOpenGL(PGraphicsOpenGL pg, int kind, float... p)` Create a shape from the PRIMITIVE family, using this kind and these params

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addChild(PShape who)`
`void`	`addChild(PShape who, int idx)`
`void`	`applyMatrix(float n00, float n01, float n02, float n10, float n11, float n12)`
`void`	`applyMatrix(float n00, float n01, float n02, float n03, float n10, float n11, float n12, float n13, float n20, float n21, float n22, float n23, float n30, float n31, float n32, float n33)`
`void`	`applyMatrix(PMatrix2D source)`
`void`	`attrib(java.lang.String name, boolean... values)`
`void`	`attrib(java.lang.String name, float... values)`
`void`	`attrib(java.lang.String name, int... values)`
`void`	`attribColor(java.lang.String name, int color)`
`void`	`attribNormal(java.lang.String name, float nx, float ny, float nz)`
`void`	`attribPosition(java.lang.String name, float x, float y, float z)`
`void`	`bezierDetail(int detail)`
`void`	`bezierVertex(float x2, float y2, float x3, float y3, float x4, float y4)`
`void`	`bezierVertex(float x2, float y2, float z2, float x3, float y3, float z3, float x4, float y4, float z4)`
`boolean`	`contains(float x, float y)` Return true if this x, y coordinate is part of this shape.
`static void`	`copyGroup(PGraphicsOpenGL pg, PShape src, PShape dest)`
`static PShapeOpenGL`	`createShape(PGraphicsOpenGL pg, PShape src)`
`void`	`curveDetail(int detail)`
`void`	`curveTightness(float tightness)`
`void`	`curveVertex(float x, float y)`
`void`	`curveVertex(float x, float y, float z)`
`void`	`disableStyle()` ( begin auto-generated from PShape_disableStyle.xml ) Disables the shape's style data and uses Processing's current styles.
`void`	`draw(PGraphics g)` Called by the following (the shape() command adds the g) PShape s = loadShape("blah.svg"); shape(s);
`void`	`enableStyle()` ( begin auto-generated from PShape_enableStyle.xml ) Enables the shape's style data and ignores Processing's current styles.
`void`	`endShape(int mode)`
`int`	`getAmbient(int index)`
`float`	`getDepth()` Get the depth of the shape area (not necessarily the shape boundary).
`int`	`getEmissive(int index)`
`int`	`getFill(int index)`
`float`	`getHeight()` Get the height of the drawing area (not necessarily the shape boundary).
`PVector`	`getNormal(int index, PVector vec)`
`float`	`getNormalX(int index)`
`float`	`getNormalY(int index)`
`float`	`getNormalZ(int index)`
`float`	`getShininess(int index)`
`int`	`getSpecular(int index)`
`int`	`getStroke(int index)`
`float`	`getStrokeWeight(int index)`
`PShape`	`getTessellation()`
`float[]`	`getTessellation(int kind, int data)`
`float`	`getTextureU(int index)`
`float`	`getTextureV(int index)`
`int`	`getTint(int index)`
`PVector`	`getVertex(int index, PVector vec)`
`int`	`getVertexCode(int index)` One of VERTEX, BEZIER_VERTEX, CURVE_VERTEX, or BREAK.
`int`	`getVertexCodeCount()`
`int[]`	`getVertexCodes()`
`int`	`getVertexCount()`
`float`	`getVertexX(int index)`
`float`	`getVertexY(int index)`
`float`	`getVertexZ(int index)`
`float`	`getWidth()` Get the width of the drawing area (not necessarily the shape boundary).
`void`	`normal(float nx, float ny, float nz)`
`void`	`quadraticVertex(float cx, float cy, float x3, float y3)`
`void`	`quadraticVertex(float cx, float cy, float cz, float x3, float y3, float z3)`
`void`	`removeChild(int idx)` Remove the child shape with index idx.
`void`	`resetMatrix()` ( begin auto-generated from PShape_resetMatrix.xml ) Replaces the current matrix of a shape with the identity matrix.
`void`	`rotate(float angle)` ( begin auto-generated from PShape_rotate.xml ) Rotates a shape the amount specified by the angle parameter.
`void`	`rotate(float angle, float v0, float v1, float v2)`
`void`	`rotateX(float angle)` ( begin auto-generated from PShape_rotateX.xml ) Rotates a shape around the x-axis the amount specified by the angle parameter.
`void`	`rotateY(float angle)` ( begin auto-generated from PShape_rotateY.xml ) Rotates a shape around the y-axis the amount specified by the angle parameter.
`void`	`rotateZ(float angle)` ( begin auto-generated from PShape_rotateZ.xml ) Rotates a shape around the z-axis the amount specified by the angle parameter.
`void`	`scale(float s)` ( begin auto-generated from PShape_scale.xml ) Increases or decreases the size of a shape by expanding and contracting vertices.
`void`	`scale(float x, float y)`
`void`	`scale(float x, float y, float z)`
`void`	`setAmbient(int ambient)`
`void`	`setAmbient(int index, int ambient)`
`void`	`setAttrib(java.lang.String name, int index, boolean... values)`
`void`	`setAttrib(java.lang.String name, int index, float... values)`
`void`	`setAttrib(java.lang.String name, int index, int... values)`
`void`	`setEmissive(int emissive)`
`void`	`setEmissive(int index, int emissive)`
`void`	`setFill(boolean fill)`
`void`	`setFill(int fill)` ( begin auto-generated from PShape_setFill.xml ) The setFill() method defines the fill color of a PShape.
`void`	`setFill(int index, int fill)`
`void`	`setNormal(int index, float nx, float ny, float nz)`
`void`	`setParams(float[] source)`
`void`	`setPath(int vcount, float[][] verts, int ccount, int[] codes)`
`void`	`setShininess(float shininess)`
`void`	`setShininess(int index, float shine)`
`void`	`setSpecular(int specular)`
`void`	`setSpecular(int index, int specular)`
`void`	`setStroke(boolean stroke)`
`void`	`setStroke(int stroke)` ( begin auto-generated from PShape_setStroke.xml ) The setStroke() method defines the outline color of a PShape.
`void`	`setStroke(int index, int stroke)`
`void`	`setStrokeCap(int cap)`
`void`	`setStrokeJoin(int join)`
`void`	`setStrokeWeight(float weight)`
`void`	`setStrokeWeight(int index, float weight)`
`void`	`setTexture(PImage tex)`
`void`	`setTextureMode(int mode)`
`void`	`setTextureUV(int index, float u, float v)`
`void`	`setTint(boolean tint)`
`void`	`setTint(int tint)`
`void`	`setTint(int index, int tint)`
`void`	`setVertex(int index, float x, float y)`
`void`	`setVertex(int index, float x, float y, float z)`
`void`	`setVertex(int index, PVector vec)`
`void`	`solid(boolean solid)`
`void`	`translate(float tx, float ty)` ( begin auto-generated from PShape_translate.xml ) Specifies an amount to displace the shape.
`void`	`translate(float tx, float ty, float tz)`
`void`	`vertex(float x, float y)`
`void`	`vertex(float x, float y, float z)`
`void`	`vertex(float x, float y, float u, float v)`
`void`	`vertex(float x, float y, float z, float u, float v)`

Methods inherited from class processing.core.PShape
addName, ambient, ambient, ambient, applyMatrix, applyMatrix, beginContour, beginShape, beginShape, colorMode, colorMode, colorMode, colorMode, emissive, emissive, emissive, endContour, endShape, fill, fill, fill, fill, fill, fill, findChild, getChild, getChild, getChildCount, getChildIndex, getChildren, getFamily, getKind, getName, getNormal, getParam, getParams, getParams, getParent, getVertex, is2D, is3D, isClosed, isVisible, noFill, noStroke, noTexture, noTint, set3D, setFamily, setKind, setName, setPath, setVisible, shininess, specular, specular, specular, stroke, stroke, stroke, stroke, stroke, stroke, strokeCap, strokeJoin, strokeWeight, texture, textureMode, tint, tint, tint, tint, tint, tint

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

- Field Detail
  - POSITION
```
public static final int POSITION
```
    See Also:
    
    Constant Field Values
  - NORMAL
```
public static final int NORMAL
```
    See Also:
    
    Constant Field Values
  - TEXCOORD
```
public static final int TEXCOORD
```
    See Also:
    
    Constant Field Values
  - DIRECTION
```
public static final int DIRECTION
```
    See Also:
    
    Constant Field Values
  - OFFSET
```
public static final int OFFSET
```
    See Also:
    
    Constant Field Values
  - glUsage
```
public int glUsage
```
- Constructor Detail
  - PShapeOpenGL
```
public PShapeOpenGL(PGraphicsOpenGL pg,
                    int family)
```
  - PShapeOpenGL
```
public PShapeOpenGL(PGraphicsOpenGL pg,
                    int kind,
                    float... p)
```
    Create a shape from the PRIMITIVE family, using this kind and these params
- Method Detail
  - addChild
```
public void addChild(PShape who)
```
    Overrides:
    
    addChild in class PShape
    
    Parameters:
    
    who - any variable of type PShape
    
    See Also:
    
    PShape.getChild(int)
  - addChild
```
public void addChild(PShape who,
                     int idx)
```
    Overrides:
    
    addChild in class PShape
    
    idx - the layer position in which to insert the new child
  - removeChild
```
public void removeChild(int idx)
```
    Description copied from class: PShape
    
    Remove the child shape with index idx.
    
    Overrides:
    
    removeChild in class PShape
  - createShape
```
public static PShapeOpenGL createShape(PGraphicsOpenGL pg,
                                       PShape src)
```
  - copyGroup
```
public static void copyGroup(PGraphicsOpenGL pg,
                             PShape src,
                             PShape dest)
```
  - getWidth
```
public float getWidth()
```
    Description copied from class: PShape
    
    Get the width of the drawing area (not necessarily the shape boundary).
    
    Overrides:
    
    getWidth in class PShape
  - getHeight
```
public float getHeight()
```
    Description copied from class: PShape
    
    Get the height of the drawing area (not necessarily the shape boundary).
    
    Overrides:
    
    getHeight in class PShape
  - getDepth
```
public float getDepth()
```
    Description copied from class: PShape
    
    Get the depth of the shape area (not necessarily the shape boundary). Only makes sense for 3D PShape subclasses, such as PShape3D.
    
    Overrides:
    
    getDepth in class PShape
  - setTextureMode
```
public void setTextureMode(int mode)
```
    Overrides:
    
    setTextureMode in class PShape
  - setTexture
```
public void setTexture(PImage tex)
```
    Overrides:
    
    setTexture in class PShape
  - solid
```
public void solid(boolean solid)
```
  - vertex
```
public void vertex(float x,
                   float y)
```
    Overrides:
    
    vertex in class PShape
  - vertex
```
public void vertex(float x,
                   float y,
                   float u,
                   float v)
```
    Overrides:
    
    vertex in class PShape
  - vertex
```
public void vertex(float x,
                   float y,
                   float z)
```
    Overrides:
    
    vertex in class PShape
  - vertex
```
public void vertex(float x,
                   float y,
                   float z,
                   float u,
                   float v)
```
    Overrides:
    
    vertex in class PShape
  - normal
```
public void normal(float nx,
                   float ny,
                   float nz)
```
    Overrides:
    
    normal in class PShape
  - attribPosition
```
public void attribPosition(java.lang.String name,
                           float x,
                           float y,
                           float z)
```
    Overrides:
    
    attribPosition in class PShape
  - attribNormal
```
public void attribNormal(java.lang.String name,
                         float nx,
                         float ny,
                         float nz)
```
    Overrides:
    
    attribNormal in class PShape
  - attribColor
```
public void attribColor(java.lang.String name,
                        int color)
```
    Overrides:
    
    attribColor in class PShape
  - attrib
```
public void attrib(java.lang.String name,
                   float... values)
```
    Overrides:
    
    attrib in class PShape
  - attrib
```
public void attrib(java.lang.String name,
                   int... values)
```
    Overrides:
    
    attrib in class PShape
  - attrib
```
public void attrib(java.lang.String name,
                   boolean... values)
```
    Overrides:
    
    attrib in class PShape
  - endShape
```
public void endShape(int mode)
```
    Overrides:
    
    endShape in class PShape
  - setParams
```
public void setParams(float[] source)
```
  - setPath
```
public void setPath(int vcount,
                    float[][] verts,
                    int ccount,
                    int[] codes)
```
  - translate
```
public void translate(float tx,
                      float ty)
```
    Description copied from class: PShape
    
    ( begin auto-generated from PShape_translate.xml ) Specifies an amount to displace the shape. The x parameter specifies left/right translation, the y parameter specifies up/down translation, and the z parameter specifies translations toward/away from the screen. Subsequent calls to the method accumulates the effect. For example, calling translate(50, 0) and then translate(20, 0) is the same as translate(70, 0). This transformation is applied directly to the shape, it's not refreshed each time draw() is run.
    
    Using this method with the z parameter requires using the P3D parameter in combination with size. ( end auto-generated )
    
    Overrides:
    
    translate in class PShape
    
    Parameters:
    
    tx - left/right translation
    
    ty - up/down translation
    
    See Also:
    
    PShape.rotate(float), PShape.scale(float), PShape.resetMatrix()
  - translate
```
public void translate(float tx,
                      float ty,
                      float tz)
```
    Overrides:
    
    translate in class PShape
    
    tz - forward/back translation
  - rotate
```
public void rotate(float angle)
```
    Description copied from class: PShape
    
    ( begin auto-generated from PShape_rotate.xml ) Rotates a shape the amount specified by the angle parameter. Angles should be specified in radians (values from 0 to TWO_PI) or converted to radians with the radians() method.
    
    Shapes are always rotated around the upper-left corner of their bounding box. Positive numbers rotate objects in a clockwise direction. Transformations apply to everything that happens after and subsequent calls to the method accumulates the effect. For example, calling rotate(HALF_PI) and then rotate(HALF_PI) is the same as rotate(PI). This transformation is applied directly to the shape, it's not refreshed each time draw() is run. ( end auto-generated )
    
    Overrides:
    
    rotate in class PShape
    
    Parameters:
    
    angle - angle of rotation specified in radians
    
    See Also:
    
    PShape.rotateX(float), PShape.rotateY(float), PShape.rotateZ(float), PShape.scale(float), PShape.translate(float, float), PShape.resetMatrix()
  - rotateX
```
public void rotateX(float angle)
```
    Description copied from class: PShape
    
    ( begin auto-generated from PShape_rotateX.xml ) Rotates a shape around the x-axis the amount specified by the angle parameter. Angles should be specified in radians (values from 0 to TWO_PI) or converted to radians with the radians() method.
    
    Shapes are always rotated around the upper-left corner of their bounding box. Positive numbers rotate objects in a clockwise direction. Subsequent calls to the method accumulates the effect. For example, calling rotateX(HALF_PI) and then rotateX(HALF_PI) is the same as rotateX(PI). This transformation is applied directly to the shape, it's not refreshed each time draw() is run.
    
    This method requires a 3D renderer. You need to use P3D as a third parameter for the size() function as shown in the example above. ( end auto-generated )
    
    Overrides:
    
    rotateX in class PShape
    
    Parameters:
    
    angle - angle of rotation specified in radians
    
    See Also:
    
    PShape.rotate(float), PShape.rotateY(float), PShape.rotateZ(float), PShape.scale(float), PShape.translate(float, float), PShape.resetMatrix()
  - rotateY
```
public void rotateY(float angle)
```
    Description copied from class: PShape
    
    ( begin auto-generated from PShape_rotateY.xml ) Rotates a shape around the y-axis the amount specified by the angle parameter. Angles should be specified in radians (values from 0 to TWO_PI) or converted to radians with the radians() method.
    
    Shapes are always rotated around the upper-left corner of their bounding box. Positive numbers rotate objects in a clockwise direction. Subsequent calls to the method accumulates the effect. For example, calling rotateY(HALF_PI) and then rotateY(HALF_PI) is the same as rotateY(PI). This transformation is applied directly to the shape, it's not refreshed each time draw() is run.
    
    This method requires a 3D renderer. You need to use P3D as a third parameter for the size() function as shown in the example above. ( end auto-generated )
    
    Overrides:
    
    rotateY in class PShape
    
    Parameters:
    
    angle - angle of rotation specified in radians
    
    See Also:
    
    PShape.rotate(float), PShape.rotateX(float), PShape.rotateZ(float), PShape.scale(float), PShape.translate(float, float), PShape.resetMatrix()
  - rotateZ
```
public void rotateZ(float angle)
```
    Description copied from class: PShape
    
    ( begin auto-generated from PShape_rotateZ.xml ) Rotates a shape around the z-axis the amount specified by the angle parameter. Angles should be specified in radians (values from 0 to TWO_PI) or converted to radians with the radians() method.
    
    Shapes are always rotated around the upper-left corner of their bounding box. Positive numbers rotate objects in a clockwise direction. Subsequent calls to the method accumulates the effect. For example, calling rotateZ(HALF_PI) and then rotateZ(HALF_PI) is the same as rotateZ(PI). This transformation is applied directly to the shape, it's not refreshed each time draw() is run.
    
    This method requires a 3D renderer. You need to use P3D as a third parameter for the size() function as shown in the example above. ( end auto-generated )
    
    Overrides:
    
    rotateZ in class PShape
    
    Parameters:
    
    angle - angle of rotation specified in radians
    
    See Also:
    
    PShape.rotate(float), PShape.rotateX(float), PShape.rotateY(float), PShape.scale(float), PShape.translate(float, float), PShape.resetMatrix()
  - rotate
```
public void rotate(float angle,
                   float v0,
                   float v1,
                   float v2)
```
    Overrides:
    
    rotate in class PShape
  - scale
```
public void scale(float s)
```
    Description copied from class: PShape
    
    ( begin auto-generated from PShape_scale.xml ) Increases or decreases the size of a shape by expanding and contracting vertices. Shapes always scale from the relative origin of their bounding box. Scale values are specified as decimal percentages. For example, the method call scale(2.0) increases the dimension of a shape by 200%. Subsequent calls to the method multiply the effect. For example, calling scale(2.0) and then scale(1.5) is the same as scale(3.0). This transformation is applied directly to the shape, it's not refreshed each time draw() is run.
    
    Using this method with the z parameter requires using the P3D parameter in combination with size. ( end auto-generated )
    
    Overrides:
    
    scale in class PShape
    
    Parameters:
    
    s - percentate to scale the object
    
    See Also:
    
    PShape.rotate(float), PShape.translate(float, float), PShape.resetMatrix()
  - scale
```
public void scale(float x,
                  float y)
```
    Overrides:
    
    scale in class PShape
  - scale
```
public void scale(float x,
                  float y,
                  float z)
```
    Overrides:
    
    scale in class PShape
    
    Parameters:
    
    x - percentage to scale the object in the x-axis
    
    y - percentage to scale the object in the y-axis
    
    z - percentage to scale the object in the z-axis
  - applyMatrix
```
public void applyMatrix(PMatrix2D source)
```
    Overrides:
    
    applyMatrix in class PShape
  - applyMatrix
```
public void applyMatrix(float n00,
                        float n01,
                        float n02,
                        float n10,
                        float n11,
                        float n12)
```
    Overrides:
    
    applyMatrix in class PShape
  - applyMatrix
```
public void applyMatrix(float n00,
                        float n01,
                        float n02,
                        float n03,
                        float n10,
                        float n11,
                        float n12,
                        float n13,
                        float n20,
                        float n21,
                        float n22,
                        float n23,
                        float n30,
                        float n31,
                        float n32,
                        float n33)
```
    Overrides:
    
    applyMatrix in class PShape
  - resetMatrix
```
public void resetMatrix()
```
    Description copied from class: PShape
    
    ( begin auto-generated from PShape_resetMatrix.xml ) Replaces the current matrix of a shape with the identity matrix. The equivalent function in OpenGL is glLoadIdentity(). ( end auto-generated )
    
    Overrides:
    
    resetMatrix in class PShape
    
    See Also:
    
    PShape.rotate(float), PShape.scale(float), PShape.translate(float, float)
  - bezierDetail
```
public void bezierDetail(int detail)
```
    Overrides:
    
    bezierDetail in class PShape
  - bezierVertex
```
public void bezierVertex(float x2,
                         float y2,
                         float x3,
                         float y3,
                         float x4,
                         float y4)
```
    Overrides:
    
    bezierVertex in class PShape
  - bezierVertex
```
public void bezierVertex(float x2,
                         float y2,
                         float z2,
                         float x3,
                         float y3,
                         float z3,
                         float x4,
                         float y4,
                         float z4)
```
    Overrides:
    
    bezierVertex in class PShape
  - quadraticVertex
```
public void quadraticVertex(float cx,
                            float cy,
                            float x3,
                            float y3)
```
    Overrides:
    
    quadraticVertex in class PShape
  - quadraticVertex
```
public void quadraticVertex(float cx,
                            float cy,
                            float cz,
                            float x3,
                            float y3,
                            float z3)
```
    Overrides:
    
    quadraticVertex in class PShape
  - curveDetail
```
public void curveDetail(int detail)
```
    Overrides:
    
    curveDetail in class PShape
  - curveTightness
```
public void curveTightness(float tightness)
```
    Overrides:
    
    curveTightness in class PShape
  - curveVertex
```
public void curveVertex(float x,
                        float y)
```
    Overrides:
    
    curveVertex in class PShape
  - curveVertex
```
public void curveVertex(float x,
                        float y,
                        float z)
```
    Overrides:
    
    curveVertex in class PShape
  - getVertexCount
```
public int getVertexCount()
```
    Overrides:
    
    getVertexCount in class PShape
    
    See Also:
    
    PShape.getVertex(int), PShape.setVertex(int, float, float)
  - getVertex
```
public PVector getVertex(int index,
                         PVector vec)
```
    Overrides:
    
    getVertex in class PShape
    
    vec - PVector to assign the data to
  - getVertexX
```
public float getVertexX(int index)
```
    Overrides:
    
    getVertexX in class PShape
  - getVertexY
```
public float getVertexY(int index)
```
    Overrides:
    
    getVertexY in class PShape
  - getVertexZ
```
public float getVertexZ(int index)
```
    Overrides:
    
    getVertexZ in class PShape
  - setVertex
```
public void setVertex(int index,
                      float x,
                      float y)
```
    Overrides:
    
    setVertex in class PShape
    
    Parameters:
    
    index - the location of the vertex
    
    x - the x value for the vertex
    
    y - the y value for the vertex
    
    See Also:
    
    PShape.getVertex(int), PShape.getVertexCount()
  - setVertex
```
public void setVertex(int index,
                      float x,
                      float y,
                      float z)
```
    Overrides:
    
    setVertex in class PShape
    
    z - the z value for the vertex
  - setVertex
```
public void setVertex(int index,
                      PVector vec)
```
    Overrides:
    
    setVertex in class PShape
    
    vec - the PVector to define the x, y, z coordinates
  - getNormal
```
public PVector getNormal(int index,
                         PVector vec)
```
    Overrides:
    
    getNormal in class PShape
  - getNormalX
```
public float getNormalX(int index)
```
    Overrides:
    
    getNormalX in class PShape
  - getNormalY
```
public float getNormalY(int index)
```
    Overrides:
    
    getNormalY in class PShape
  - getNormalZ
```
public float getNormalZ(int index)
```
    Overrides:
    
    getNormalZ in class PShape
  - setNormal
```
public void setNormal(int index,
                      float nx,
                      float ny,
                      float nz)
```
    Overrides:
    
    setNormal in class PShape
  - setAttrib
```
public void setAttrib(java.lang.String name,
                      int index,
                      float... values)
```
    Overrides:
    
    setAttrib in class PShape
  - setAttrib
```
public void setAttrib(java.lang.String name,
                      int index,
                      int... values)
```
    Overrides:
    
    setAttrib in class PShape
  - setAttrib
```
public void setAttrib(java.lang.String name,
                      int index,
                      boolean... values)
```
    Overrides:
    
    setAttrib in class PShape
  - getTextureU
```
public float getTextureU(int index)
```
    Overrides:
    
    getTextureU in class PShape
  - getTextureV
```
public float getTextureV(int index)
```
    Overrides:
    
    getTextureV in class PShape
  - setTextureUV
```
public void setTextureUV(int index,
                         float u,
                         float v)
```
    Overrides:
    
    setTextureUV in class PShape
  - getFill
```
public int getFill(int index)
```
    Overrides:
    
    getFill in class PShape
  - setFill
```
public void setFill(boolean fill)
```
    Overrides:
    
    setFill in class PShape
  - setFill
```
public void setFill(int fill)
```
    Description copied from class: PShape
    
    ( begin auto-generated from PShape_setFill.xml ) The setFill() method defines the fill color of a PShape. This method is used after shapes are created or when a shape is defined explicitly (e.g. createShape(RECT, 20, 20, 80, 80)) as shown in the above example. When a shape is created with beginShape() and endShape(), its attributes may be changed with fill() and stroke() within beginShape() and endShape(). However, after the shape is created, only the setFill() method can define a new fill value for the PShape. ( end auto-generated )
    
    Overrides:
    
    setFill in class PShape
  - setFill
```
public void setFill(int index,
                    int fill)
```
    Overrides:
    
    setFill in class PShape
  - getTint
```
public int getTint(int index)
```
    Overrides:
    
    getTint in class PShape
  - setTint
```
public void setTint(boolean tint)
```
    Overrides:
    
    setTint in class PShape
  - setTint
```
public void setTint(int tint)
```
    Overrides:
    
    setTint in class PShape
  - setTint
```
public void setTint(int index,
                    int tint)
```
    Overrides:
    
    setTint in class PShape
  - getStroke
```
public int getStroke(int index)
```
    Overrides:
    
    getStroke in class PShape
  - setStroke
```
public void setStroke(boolean stroke)
```
    Overrides:
    
    setStroke in class PShape
  - setStroke
```
public void setStroke(int stroke)
```
    Description copied from class: PShape
    
    ( begin auto-generated from PShape_setStroke.xml ) The setStroke() method defines the outline color of a PShape. This method is used after shapes are created or when a shape is defined explicitly (e.g. createShape(RECT, 20, 20, 80, 80)) as shown in the above example. When a shape is created with beginShape() and endShape(), its attributes may be changed with fill() and stroke() within beginShape() and endShape(). However, after the shape is created, only the setStroke() method can define a new stroke value for the PShape. ( end auto-generated )
    
    Overrides:
    
    setStroke in class PShape
  - setStroke
```
public void setStroke(int index,
                      int stroke)
```
    Overrides:
    
    setStroke in class PShape
  - getStrokeWeight
```
public float getStrokeWeight(int index)
```
    Overrides:
    
    getStrokeWeight in class PShape
  - setStrokeWeight
```
public void setStrokeWeight(float weight)
```
    Overrides:
    
    setStrokeWeight in class PShape
  - setStrokeWeight
```
public void setStrokeWeight(int index,
                            float weight)
```
    Overrides:
    
    setStrokeWeight in class PShape
  - setStrokeJoin
```
public void setStrokeJoin(int join)
```
    Overrides:
    
    setStrokeJoin in class PShape
  - setStrokeCap
```
public void setStrokeCap(int cap)
```
    Overrides:
    
    setStrokeCap in class PShape
  - getAmbient
```
public int getAmbient(int index)
```
    Overrides:
    
    getAmbient in class PShape
  - setAmbient
```
public void setAmbient(int ambient)
```
    Overrides:
    
    setAmbient in class PShape
  - setAmbient
```
public void setAmbient(int index,
                       int ambient)
```
    Overrides:
    
    setAmbient in class PShape
  - getSpecular
```
public int getSpecular(int index)
```
    Overrides:
    
    getSpecular in class PShape
  - setSpecular
```
public void setSpecular(int specular)
```
    Overrides:
    
    setSpecular in class PShape
  - setSpecular
```
public void setSpecular(int index,
                        int specular)
```
    Overrides:
    
    setSpecular in class PShape
  - getEmissive
```
public int getEmissive(int index)
```
    Overrides:
    
    getEmissive in class PShape
  - setEmissive
```
public void setEmissive(int emissive)
```
    Overrides:
    
    setEmissive in class PShape
  - setEmissive
```
public void setEmissive(int index,
                        int emissive)
```
    Overrides:
    
    setEmissive in class PShape
  - getShininess
```
public float getShininess(int index)
```
    Overrides:
    
    getShininess in class PShape
  - setShininess
```
public void setShininess(float shininess)
```
    Overrides:
    
    setShininess in class PShape
  - setShininess
```
public void setShininess(int index,
                         float shine)
```
    Overrides:
    
    setShininess in class PShape
  - getVertexCodes
```
public int[] getVertexCodes()
```
    Overrides:
    
    getVertexCodes in class PShape
  - getVertexCodeCount
```
public int getVertexCodeCount()
```
    Overrides:
    
    getVertexCodeCount in class PShape
  - getVertexCode
```
public int getVertexCode(int index)
```
    One of VERTEX, BEZIER_VERTEX, CURVE_VERTEX, or BREAK.
    
    Overrides:
    
    getVertexCode in class PShape
  - getTessellation
```
public PShape getTessellation()
```
    Overrides:
    
    getTessellation in class PShape
  - getTessellation
```
public float[] getTessellation(int kind,
                               int data)
```
  - contains
```
public boolean contains(float x,
                        float y)
```
    Description copied from class: PShape
    
    Return true if this x, y coordinate is part of this shape. Only works with PATH shapes or GROUP shapes that contain other GROUPs or PATHs.
    
    Overrides:
    
    contains in class PShape
  - disableStyle
```
public void disableStyle()
```
    Description copied from class: PShape
    
    ( begin auto-generated from PShape_disableStyle.xml ) Disables the shape's style data and uses Processing's current styles. Styles include attributes such as colors, stroke weight, and stroke joints. ( end auto-generated )
    Advanced
    Overrides this shape's style information and uses PGraphics styles and colors. Identical to ignoreStyles(true). Also disables styles for all child shapes.
    
    Overrides:
    
    disableStyle in class PShape
    
    See Also:
    
    PShape.enableStyle()
  - enableStyle
```
public void enableStyle()
```
    Description copied from class: PShape
    
    ( begin auto-generated from PShape_enableStyle.xml ) Enables the shape's style data and ignores Processing's current styles. Styles include attributes such as colors, stroke weight, and stroke joints. ( end auto-generated )
    
    Overrides:
    
    enableStyle in class PShape
    
    See Also:
    
    PShape.disableStyle()
  - draw
```
public void draw(PGraphics g)
```
    Description copied from class: PShape
    
    Called by the following (the shape() command adds the g) PShape s = loadShape("blah.svg"); shape(s);
    
    Overrides:
    
    draw in class PShape

Class PShapeOpenGL

Field Summary

Fields inherited from class processing.core.PShape

Fields inherited from interface processing.core.PConstants

Constructor Summary

Method Summary

Methods inherited from class processing.core.PShape

Methods inherited from class java.lang.Object

Field Detail

POSITION

NORMAL

TEXCOORD

DIRECTION

OFFSET

glUsage

Constructor Detail

PShapeOpenGL

PShapeOpenGL

Method Detail

addChild

addChild

removeChild

createShape

copyGroup

getWidth

getHeight

getDepth

setTextureMode

setTexture

solid

vertex

vertex

vertex

vertex

normal

attribPosition

attribNormal

attribColor

attrib

attrib

attrib

endShape

setParams

setPath

translate

translate

rotate

rotateX

rotateY

rotateZ

rotate

scale

scale

scale

applyMatrix

applyMatrix

applyMatrix

resetMatrix

bezierDetail

bezierVertex

bezierVertex

quadraticVertex

quadraticVertex

curveDetail

curveTightness

curveVertex

curveVertex

getVertexCount

getVertex

getVertexX

getVertexY

getVertexZ

setVertex

setVertex

setVertex

getNormal

getNormalX

getNormalY

getNormalZ

setNormal