processing.opengl

## Class 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
    --- | ---
    `int` | `glLineAttrib`
    `int` | `glLineColor`
    `int` | `glLineIndex`
    `int` | `glLineVertex`
    `int` | `glPointAttrib`
    `int` | `glPointColor`
    `int` | `glPointIndex`
    `int` | `glPointVertex`
    `int` | `glPolyAmbient`
    `int` | `glPolyColor`
    `int` | `glPolyEmissive`
    `int` | `glPolyIndex`
    `int` | `glPolyNormal`
    `int` | `glPolyShininess`
    `int` | `glPolySpecular`
    `int` | `glPolyTexcoord`
    `int` | `glPolyVertex`

    - ### Fields inherited from class processing.core.PShape

      `colorMode, colorModeA, colorModeX, colorModeY, colorModeZ, depth, GEOMETRY, height, INSIDE_BEGIN_END_ERROR, OUTSIDE_BEGIN_END_ERROR, PATH, 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_DEPTH_MASK, DISABLE_DEPTH_SORT, DISABLE_DEPTH_TEST, DISABLE_NATIVE_FONTS, DISABLE_OPENGL_ERRORS, DISABLE_OPTIMIZED_STROKE, DISABLE_RETINA_PIXELS, DISABLE_STROKE_PERSPECTIVE, DISABLE_STROKE_PURE, DISABLE_TEXTURE_MIPMAPS, DODGE, DOWN, DXF, ELLIPSE, ENABLE_DEPTH_MASK, ENABLE_DEPTH_SORT, ENABLE_DEPTH_TEST, ENABLE_NATIVE_FONTS, ENABLE_OPENGL_ERRORS, ENABLE_OPTIMIZED_STROKE, ENABLE_RETINA_PIXELS, ENABLE_STROKE_PERSPECTIVE, ENABLE_STROKE_PURE, ENABLE_TEXTURE_MIPMAPS, ENTER, EPSILON, ERODE, ERROR_BACKGROUND_IMAGE_FORMAT, ERROR_BACKGROUND_IMAGE_SIZE, ERROR_PUSHMATRIX_OVERFLOW, ERROR_PUSHMATRIX_UNDERFLOW, ERROR_TEXTFONT_NULL_PFONT, ESC, EXCLUSION, 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, NORMAL, 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, SPHERE, SPOT, SQUARE, SUBTRACT, 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`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `PShapeOpenGL(PApplet parent, int family)`

  - ### Method Summary

    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` | `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)`
    `static void` | `copyGroup2D(PApplet parent, PShape src, PShape dest)`
    `static void` | `copyGroup3D(PApplet parent, PShape src, PShape dest)`
    `static PShapeOpenGL` | `createShape2D(PApplet parent, PShape src)`
    `static PShapeOpenGL` | `createShape3D(PApplet parent, 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()`
    `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` | `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` | `setEmissive(int emissive)`
    `void` | `setEmissive(int index, int emissive)`
    `void` | `setFill(boolean fill)`
    `void` | `setFill(int fill)`
    `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)`
    `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, drawImpl, 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, is3D, isClosed, isVisible, noFill, noStroke, noTexture, noTint, 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

    - #### glPolyVertex

          public int glPolyVertex

    - #### glPolyColor

          public int glPolyColor

    - #### glPolyNormal

          public int glPolyNormal

    - #### glPolyTexcoord

          public int glPolyTexcoord

    - #### glPolyAmbient

          public int glPolyAmbient

    - #### glPolySpecular

          public int glPolySpecular

    - #### glPolyEmissive

          public int glPolyEmissive

    - #### glPolyShininess

          public int glPolyShininess

    - #### glPolyIndex

          public int glPolyIndex

    - #### glLineVertex

          public int glLineVertex

    - #### glLineColor

          public int glLineColor

    - #### glLineAttrib

          public int glLineAttrib

    - #### glLineIndex

          public int glLineIndex

    - #### glPointVertex

          public int glPointVertex

    - #### glPointColor

          public int glPointColor

    - #### glPointAttrib

          public int glPointAttrib

    - #### glPointIndex

          public int glPointIndex

  - ### Constructor Detail

    - #### PShapeOpenGL

          public PShapeOpenGL(PApplet parent,
                      int family)

  - ### 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`

    - #### createShape3D

          public static PShapeOpenGL createShape3D(PApplet parent,
                                   PShape src)

    - #### createShape2D

          public static PShapeOpenGL createShape2D(PApplet parent,
                                   PShape src)

    - #### copyGroup3D

          public static void copyGroup3D(PApplet parent,
                         PShape src,
                         PShape dest)

    - #### copyGroup2D

          public static void copyGroup2D(PApplet parent,
                         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`

    - #### 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`
      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`

    - #### 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`

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

      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)

      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`

    - #### contains

          public boolean contains(float x,
                         float y)

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

    - #### 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`