/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */

/*

Part of the Processing project - http://processing.org

Copyright (c) 2013-15 The Processing Foundation

Copyright (c) 2004-12 Ben Fry and Casey Reas

Copyright (c) 2001-04 Massachusetts Institute of Technology

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General

Public License along with this library; if not, write to the

Free Software Foundation, Inc., 59 Temple Place, Suite 330,

Boston, MA 02111-1307 USA

*/

package processing.core;

// Used for color conversion functions

import java.awt.Color;

// Used for the 'image' object that's been here forever

import java.awt.Font;

import java.awt.Image;

import java.io.File;

import java.io.InputStream;

import java.util.Map;

import java.util.HashMap;

import java.util.WeakHashMap;

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

import java.util.concurrent.RejectedExecutionException;

import java.util.concurrent.TimeUnit;

import processing.opengl.PGL;

import processing.opengl.PShader;

/**

* ( begin auto-generated from PGraphics.xml )

*

* Main graphics and rendering context, as well as the base API

* implementation for processing "core". Use this class if you need to draw

* into an off-screen graphics buffer. A PGraphics object can be

* constructed with the <b>createGraphics()</b> function. The

* <b>beginDraw()</b> and <b>endDraw()</b> methods (see above example) are

* necessary to set up the buffer and to finalize it. The fields and

* methods for this class are extensive. For a complete list, visit the <a

* href="http://processing.googlecode.com/svn/trunk/processing/build/javadoc/core/">developer's reference.</a>

*

* ( end auto-generated )

*

* <h3>Advanced</h3>

* Main graphics and rendering context, as well as the base API implementation.

*

* <h2>Subclassing and initializing PGraphics objects</h2>

* Starting in release 0149, subclasses of PGraphics are handled differently.

* The constructor for subclasses takes no parameters, instead a series of

* functions are called by the hosting PApplet to specify its attributes.

* <ul>

* <li>setParent(PApplet) - is called to specify the parent PApplet.

* <li>setPrimary(boolean) - called with true if this PGraphics will be the

* primary drawing surface used by the sketch, or false if not.

* <li>setPath(String) - called when the renderer needs a filename or output

* path, such as with the PDF or DXF renderers.

* <li>setSize(int, int) - this is called last, at which point it's safe for

* the renderer to complete its initialization routine.

* </ul>

* The functions were broken out because of the growing number of parameters

* such as these that might be used by a renderer, yet with the exception of

* setSize(), it's not clear which will be necessary. So while the size could

* be passed in to the constructor instead of a setSize() function, a function

* would still be needed that would notify the renderer that it was time to

* finish its initialization. Thus, setSize() simply does both.

*

* <h2>Know your rights: public vs. private methods</h2>

* Methods that are protected are often subclassed by other renderers, however

* they are not set 'public' because they shouldn't be part of the user-facing

* public API accessible from PApplet. That is, we don't want sketches calling

* textModeCheck() or vertexTexture() directly.

*

* <h2>Handling warnings and exceptions</h2>

* Methods that are unavailable generally show a warning, unless their lack of

* availability will soon cause another exception. For instance, if a method

* like getMatrix() returns null because it is unavailable, an exception will

* be thrown stating that the method is unavailable, rather than waiting for

* the NullPointerException that will occur when the sketch tries to use that

* method. As of release 0149, warnings will only be shown once, and exceptions

* have been changed to warnings where possible.

*

* <h2>Using xxxxImpl() for subclassing smoothness</h2>

* The xxxImpl() methods are generally renderer-specific handling for some

* subset if tasks for a particular function (vague enough for you?) For

* instance, imageImpl() handles drawing an image whose x/y/w/h and u/v coords

* have been specified, and screen placement (independent of imageMode) has

* been determined. There's no point in all renderers implementing the

* <tt>if (imageMode == BLAH)</tt> placement/sizing logic, so that's handled

* by PGraphics, which then calls imageImpl() once all that is figured out.

*

* <h2>His brother PImage</h2>

* PGraphics subclasses PImage so that it can be drawn and manipulated in a

* similar fashion. As such, many methods are inherited from PGraphics,

* though many are unavailable: for instance, resize() is not likely to be

* implemented; the same goes for mask(), depending on the situation.

*

* <h2>What's in PGraphics, what ain't</h2>

* For the benefit of subclasses, as much as possible has been placed inside

* PGraphics. For instance, bezier interpolation code and implementations of

* the strokeCap() method (that simply sets the strokeCap variable) are

* handled here. Features that will vary widely between renderers are located

* inside the subclasses themselves. For instance, all matrix handling code

* is per-renderer: Java 2D uses its own AffineTransform, P2D uses a PMatrix2D,

* and PGraphics3D needs to keep continually update forward and reverse

* transformations. A proper (future) OpenGL implementation will have all its

* matrix madness handled by the card. Lighting also falls under this

* category, however the base material property settings (emissive, specular,

* et al.) are handled in PGraphics because they use the standard colorMode()

* logic. Subclasses should override methods like emissiveFromCalc(), which

* is a point where a valid color has been defined internally, and can be

* applied in some manner based on the calcXxxx values.

*

* <h2>What's in the PGraphics documentation, what ain't</h2>

* Some things are noted here, some things are not. For public API, always

* refer to the <a href="http://processing.org/reference">reference</A>

* on Processing.org for proper explanations. <b>No attempt has been made to

* keep the javadoc up to date or complete.</b> It's an enormous task for

* which we simply do not have the time. That is, it's not something that

* to be done once&mdash;it's a matter of keeping the multiple references

* synchronized (to say nothing of the translation issues), while targeting

* them for their separate audiences. Ouch.

*

* We're working right now on synchronizing the two references, so the website reference

* is generated from the javadoc comments. Yay.

*

* @webref rendering

* @instanceName graphics any object of the type PGraphics

* @usage Web &amp; Application

* @see PApplet#createGraphics(int, int, String)

*/

public class PGraphics extends PImage implements PConstants {

// /// Canvas object that covers rendering this graphics on screen.

// public Canvas canvas;

// ........................................................

// width and height are already inherited from PImage

// /// width minus one (useful for many calculations)

// protected int width1;

//

// /// height minus one (useful for many calculations)

// protected int height1;

/// width * height (useful for many calculations)

public int pixelCount;

// /// true if smoothing is enabled (read-only)

// public boolean smooth;

/// the anti-aliasing level for renderers that support it

public int smooth;

// ........................................................

/// true if defaults() has been called a first time

protected boolean settingsInited;

/// true if settings should be re-applied on next beginDraw()

protected boolean reapplySettings;

/// set to a PGraphics object being used inside a beginRaw/endRaw() block

protected PGraphics raw;

// ........................................................

/** path to the file being saved for this renderer (if any) */

protected String path;

/**

* True if this is the main graphics context for a sketch.

* False for offscreen buffers retrieved via createGraphics().

*/

protected boolean primaryGraphics;

// // TODO nervous about leaving this here since it seems likely to create

// // back-references where we don't want them

// protected PSurface surface;

// ........................................................

/**

* Array of hint[] items. These are hacks to get around various

* temporary workarounds inside the environment.

* <p/>

* Note that this array cannot be static, as a hint() may result in a

* runtime change specific to a renderer. For instance, calling

* hint(DISABLE_DEPTH_TEST) has to call glDisable() right away on an

* instance of PGraphicsOpenGL.

* <p/>

* The hints[] array is allocated early on because it might

* be used inside beginDraw(), allocate(), etc.

*/

protected boolean[] hints = new boolean[HINT_COUNT];

// ........................................................

/**

* Storage for renderer-specific image data. In 1.x, renderers wrote cache

* data into the image object. In 2.x, the renderer has a weak-referenced

* map that points at any of the images it has worked on already. When the

* images go out of scope, they will be properly garbage collected.

*/

protected WeakHashMap<PImage, Object> cacheMap =

new WeakHashMap<PImage, Object>();

////////////////////////////////////////////////////////////

// Vertex fields, moved from PConstants (after 2.0a8) because they're too

// general to show up in all sketches as defined variables.

// X, Y and Z are still stored in PConstants because of their general

// usefulness, and that X we'll always want to be 0, etc.

static public final int R = 3; // actual rgb, after lighting

static public final int G = 4; // fill stored here, transform in place

static public final int B = 5; // TODO don't do that anymore (?)

static public final int A = 6;

static public final int U = 7; // texture

static public final int V = 8;

static public final int NX = 9; // normal

static public final int NY = 10;

static public final int NZ = 11;

static public final int EDGE = 12;

// stroke

/** stroke argb values */

static public final int SR = 13;

static public final int SG = 14;

static public final int SB = 15;

static public final int SA = 16;

/** stroke weight */

static public final int SW = 17;

// transformations (2D and 3D)

static public final int TX = 18; // transformed xyzw

static public final int TY = 19;

static public final int TZ = 20;

static public final int VX = 21; // view space coords

static public final int VY = 22;

static public final int VZ = 23;

static public final int VW = 24;

// material properties

// Ambient color (usually to be kept the same as diffuse)

// fill(_) sets both ambient and diffuse.

static public final int AR = 25;

static public final int AG = 26;

static public final int AB = 27;

// Diffuse is shared with fill.

static public final int DR = 3; // TODO needs to not be shared, this is a material property

static public final int DG = 4;

static public final int DB = 5;

static public final int DA = 6;

// specular (by default kept white)

static public final int SPR = 28;

static public final int SPG = 29;

static public final int SPB = 30;

static public final int SHINE = 31;

// emissive (by default kept black)

static public final int ER = 32;

static public final int EG = 33;

static public final int EB = 34;

// has this vertex been lit yet

static public final int BEEN_LIT = 35;

// has this vertex been assigned a normal yet

static public final int HAS_NORMAL = 36;

static public final int VERTEX_FIELD_COUNT = 37;

////////////////////////////////////////////////////////////

// STYLE PROPERTIES

// Also inherits imageMode() and smooth() (among others) from PImage.

/** The current colorMode */

public int colorMode; // = RGB;

/** Max value for red (or hue) set by colorMode */

public float colorModeX; // = 255;

/** Max value for green (or saturation) set by colorMode */

public float colorModeY; // = 255;

/** Max value for blue (or value) set by colorMode */

public float colorModeZ; // = 255;

/** Max value for alpha set by colorMode */

public float colorModeA; // = 255;

/** True if colors are not in the range 0..1 */

boolean colorModeScale; // = true;

/** True if colorMode(RGB, 255) */

boolean colorModeDefault; // = true;

// ........................................................

// Tint color for images

/**

* True if tint() is enabled (read-only).

*

* Using tint/tintColor seems a better option for naming than

* tintEnabled/tint because the latter seems ugly, even though

* g.tint as the actual color seems a little more intuitive,

* it's just that g.tintEnabled is even more unintuitive.

* Same goes for fill and stroke, et al.

*/

public boolean tint;

/** tint that was last set (read-only) */

public int tintColor;

protected boolean tintAlpha;

protected float tintR, tintG, tintB, tintA;

protected int tintRi, tintGi, tintBi, tintAi;

// ........................................................

// Fill color

/** true if fill() is enabled, (read-only) */

public boolean fill;

/** fill that was last set (read-only) */

public int fillColor = 0xffFFFFFF;

protected boolean fillAlpha;

protected float fillR, fillG, fillB, fillA;

protected int fillRi, fillGi, fillBi, fillAi;

// ........................................................

// Stroke color

/** true if stroke() is enabled, (read-only) */

public boolean stroke;

/** stroke that was last set (read-only) */

public int strokeColor = 0xff000000;

protected boolean strokeAlpha;

protected float strokeR, strokeG, strokeB, strokeA;

protected int strokeRi, strokeGi, strokeBi, strokeAi;

// ........................................................

// Additional stroke properties

static protected final float DEFAULT_STROKE_WEIGHT = 1;

static protected final int DEFAULT_STROKE_JOIN = MITER;

static protected final int DEFAULT_STROKE_CAP = ROUND;

/**

* Last value set by strokeWeight() (read-only). This has a default

* setting, rather than fighting with renderers about whether that

* renderer supports thick lines.

*/

public float strokeWeight = DEFAULT_STROKE_WEIGHT;

/**

* Set by strokeJoin() (read-only). This has a default setting

* so that strokeJoin() need not be called by defaults,

* because subclasses may not implement it (i.e. PGraphicsGL)

*/

public int strokeJoin = DEFAULT_STROKE_JOIN;

/**

* Set by strokeCap() (read-only). This has a default setting

* so that strokeCap() need not be called by defaults,

* because subclasses may not implement it (i.e. PGraphicsGL)

*/

public int strokeCap = DEFAULT_STROKE_CAP;

// ........................................................

// Shape placement properties

// imageMode() is inherited from PImage

/** The current rect mode (read-only) */

public int rectMode;

/** The current ellipse mode (read-only) */

public int ellipseMode;

/** The current shape alignment mode (read-only) */

public int shapeMode;

/** The current image alignment (read-only) */

public int imageMode = CORNER;

// ........................................................

// Text and font properties

/** The current text font (read-only) */

public PFont textFont;

/** The current text align (read-only) */

public int textAlign = LEFT;

/** The current vertical text alignment (read-only) */

public int textAlignY = BASELINE;

/** The current text mode (read-only) */

public int textMode = MODEL;

/** The current text size (read-only) */

public float textSize;

/** The current text leading (read-only) */

public float textLeading;

static final protected String ERROR_TEXTFONT_NULL_PFONT =

"A null PFont was passed to textFont()";

// ........................................................

// Material properties

// PMaterial material;

// PMaterial[] materialStack;

// int materialStackPointer;

public int ambientColor;

public float ambientR, ambientG, ambientB;

public boolean setAmbient;

public int specularColor;

public float specularR, specularG, specularB;

public int emissiveColor;

public float emissiveR, emissiveG, emissiveB;

public float shininess;

// Style stack

static final int STYLE_STACK_DEPTH = 64;

PStyle[] styleStack = new PStyle[STYLE_STACK_DEPTH];

int styleStackDepth;

////////////////////////////////////////////////////////////

/** Last background color that was set, zero if an image */

public int backgroundColor = 0xffCCCCCC;

protected boolean backgroundAlpha;

protected float backgroundR, backgroundG, backgroundB, backgroundA;

protected int backgroundRi, backgroundGi, backgroundBi, backgroundAi;

static final protected String ERROR_BACKGROUND_IMAGE_SIZE =

"background image must be the same size as your application";

static final protected String ERROR_BACKGROUND_IMAGE_FORMAT =

"background images should be RGB or ARGB";

/** The current blending mode. */

protected int blendMode;

// ........................................................

/**

* Current model-view matrix transformation of the form m[row][column],

* which is a "column vector" (as opposed to "row vector") matrix.

*/

// PMatrix matrix;

// public float m00, m01, m02, m03;

// public float m10, m11, m12, m13;

// public float m20, m21, m22, m23;

// public float m30, m31, m32, m33;

// static final int MATRIX_STACK_DEPTH = 32;

// float[][] matrixStack = new float[MATRIX_STACK_DEPTH][16];

// float[][] matrixInvStack = new float[MATRIX_STACK_DEPTH][16];

// int matrixStackDepth;

static final protected int MATRIX_STACK_DEPTH = 32;

static final protected String ERROR_PUSHMATRIX_OVERFLOW =

"Too many calls to pushMatrix().";

static final protected String ERROR_PUSHMATRIX_UNDERFLOW =

"Too many calls to popMatrix(), and not enough to pushMatrix().";

// ........................................................

/**

* Java AWT Image object associated with this renderer. For the 1.0 version

* of P2D and P3D, this was associated with their MemoryImageSource.

* For PGraphicsJava2D, it will be the offscreen drawing buffer.

*/

public Image image;

/** Surface object that we're talking to */

protected PSurface surface;

// ........................................................

// internal color for setting/calculating

protected float calcR, calcG, calcB, calcA;

protected int calcRi, calcGi, calcBi, calcAi;

protected int calcColor;

protected boolean calcAlpha;

/** The last RGB value converted to HSB */

int cacheHsbKey;

/** Result of the last conversion to HSB */

float[] cacheHsbValue = new float[3];

// ........................................................

/**

* Type of shape passed to beginShape(),

* zero if no shape is currently being drawn.

*/

protected int shape;

// vertices

public static final int DEFAULT_VERTICES = 512;

protected float vertices[][] =

new float[DEFAULT_VERTICES][VERTEX_FIELD_COUNT];

protected int vertexCount; // total number of vertices

// ........................................................

protected boolean bezierInited = false;

public int bezierDetail = 20;

// used by both curve and bezier, so just init here

protected PMatrix3D bezierBasisMatrix =

new PMatrix3D(-1, 3, -3, 1,

3, -6, 3, 0,

-3, 3, 0, 0,

1, 0, 0, 0);

//protected PMatrix3D bezierForwardMatrix;

protected PMatrix3D bezierDrawMatrix;

// ........................................................

protected boolean curveInited = false;

public int curveDetail = 20;

public float curveTightness = 0;

// catmull-rom basis matrix, perhaps with optional s parameter

protected PMatrix3D curveBasisMatrix;

protected PMatrix3D curveDrawMatrix;

protected PMatrix3D bezierBasisInverse;

protected PMatrix3D curveToBezierMatrix;

// ........................................................

// spline vertices

protected float curveVertices[][];

protected int curveVertexCount;

// ........................................................

// precalculate sin/cos lookup tables [toxi]

// circle resolution is determined from the actual used radii

// passed to ellipse() method. this will automatically take any

// scale transformations into account too

// [toxi 031031]

// changed table's precision to 0.5 degree steps

// introduced new vars for more flexible code

static final protected float sinLUT[];

static final protected float cosLUT[];

static final protected float SINCOS_PRECISION = 0.5f;

static final protected int SINCOS_LENGTH = (int) (360f / SINCOS_PRECISION);

static {

sinLUT = new float[SINCOS_LENGTH];

cosLUT = new float[SINCOS_LENGTH];

for (int i = 0; i < SINCOS_LENGTH; i++) {

sinLUT[i] = (float) Math.sin(i * DEG_TO_RAD * SINCOS_PRECISION);

cosLUT[i] = (float) Math.cos(i * DEG_TO_RAD * SINCOS_PRECISION);

}

}

// ........................................................

/** The current font if a Java version of it is installed */

//protected Font textFontNative;

/** Metrics for the current native Java font */

//protected FontMetrics textFontNativeMetrics;

// /** Last text position, because text often mixed on lines together */

// protected float textX, textY, textZ;

/**

* Internal buffer used by the text() functions

* because the String object is slow

*/

protected char[] textBuffer = new char[8 * 1024];

protected char[] textWidthBuffer = new char[8 * 1024];

protected int textBreakCount;

protected int[] textBreakStart;

protected int[] textBreakStop;

// ........................................................

public boolean edge = true;

// ........................................................

/// normal calculated per triangle

static protected final int NORMAL_MODE_AUTO = 0;

/// one normal manually specified per shape

static protected final int NORMAL_MODE_SHAPE = 1;

/// normals specified for each shape vertex

static protected final int NORMAL_MODE_VERTEX = 2;

/// Current mode for normals, one of AUTO, SHAPE, or VERTEX

protected int normalMode;

/// Keep track of how many calls to normal, to determine the mode.

//protected int normalCount;

protected boolean autoNormal;

/** Current normal vector. */

public float normalX, normalY, normalZ;

// ........................................................

/**

* Sets whether texture coordinates passed to

* vertex() calls will be based on coordinates that are

* based on the IMAGE or NORMALIZED.

*/

public int textureMode = IMAGE;

/**

* Current horizontal coordinate for texture, will always

* be between 0 and 1, even if using textureMode(IMAGE).

*/

public float textureU;

/** Current vertical coordinate for texture, see above. */

public float textureV;

/** Current image being used as a texture */

public PImage textureImage;

// ........................................................

// [toxi031031] new & faster sphere code w/ support flexible resolutions

// will be set by sphereDetail() or 1st call to sphere()

protected float sphereX[], sphereY[], sphereZ[];

/// Number of U steps (aka "theta") around longitudinally spanning 2*pi

public int sphereDetailU = 0;

/// Number of V steps (aka "phi") along latitudinally top-to-bottom spanning pi

public int sphereDetailV = 0;

//////////////////////////////////////////////////////////////

// INTERNAL

// Most renderers will only override the default implementation of one or

// two of the setXxxx() methods, so they're broken out here since the

// default implementations for each are simple, obvious, and common.

// They're also separate to avoid a monolithic and fragile constructor.

public PGraphics() {

// In 3.1.2, giving up on the async image saving as the default

hints[DISABLE_ASYNC_SAVEFRAME] = true;

}

public void setParent(PApplet parent) { // ignore

this.parent = parent;

// Some renderers (OpenGL) need to know what smoothing level will be used

// before the rendering surface is even created.

smooth = parent.sketchSmooth();

pixelDensity = parent.sketchPixelDensity();

}

/**

* Set (or unset) this as the main drawing surface. Meaning that it can

* safely be set to opaque (and given a default gray background), or anything

* else that goes along with that.

*/

public void setPrimary(boolean primary) { // ignore

this.primaryGraphics = primary;

// base images must be opaque (for performance and general

// headache reasons.. argh, a semi-transparent opengl surface?)

// use createGraphics() if you want a transparent surface.

if (primaryGraphics) {

format = RGB;

}

}

public void setPath(String path) { // ignore

this.path = path;

}

// public void setQuality(int samples) { // ignore

// this.quality = samples;

// }

/**

* The final step in setting up a renderer, set its size of this renderer.

* This was formerly handled by the constructor, but instead it's been broken

* out so that setParent/setPrimary/setPath can be handled differently.

*

* Important: this is ignored by the Methods task because otherwise it will

* override setSize() in PApplet/Applet/Component, which will 1) not call

* super.setSize(), and 2) will cause the renderer to be resized from the

* event thread (EDT), causing a nasty crash as it collides with the

* animation thread.

*/

public void setSize(int w, int h) { // ignore

width = w;

height = h;

/** {@link PImage.pixelFactor} set in {@link PImage#PImage()} */

pixelWidth = width * pixelDensity;

pixelHeight = height * pixelDensity;

// if (surface != null) {

// allocate();

// }

// reapplySettings();

reapplySettings = true;

}

// public void setSmooth(int level) {

// this.smooth = level;

// }

// /**

// * Allocate memory or an image buffer for this renderer.

// */

// protected void allocate() { }

/**

* Handle any takedown for this graphics context.

* <p>

* This is called when a sketch is shut down and this renderer was

* specified using the size() command, or inside endRecord() and

* endRaw(), in order to shut things off.

*/

public void dispose() { // ignore

if (primaryGraphics && asyncImageSaver != null) {

asyncImageSaver.dispose();

asyncImageSaver = null;

}

}

public PSurface createSurface() { // ignore

return surface = new PSurfaceNone(this);

}

//////////////////////////////////////////////////////////////

// IMAGE METADATA FOR THIS RENDERER

/**

* Store data of some kind for the renderer that requires extra metadata of

* some kind. Usually this is a renderer-specific representation of the

* image data, for instance a BufferedImage with tint() settings applied for

* PGraphicsJava2D, or resized image data and OpenGL texture indices for

* PGraphicsOpenGL.

* @param image The image to be stored

* @param storage The metadata required by the renderer

*/

public void setCache(PImage image, Object storage) { // ignore

cacheMap.put(image, storage);

}

/**

* Get cache storage data for the specified renderer. Because each renderer

* will cache data in different formats, it's necessary to store cache data

* keyed by the renderer object. Otherwise, attempting to draw the same

* image to both a PGraphicsJava2D and a PGraphicsOpenGL will cause errors.

* @return metadata stored for the specified renderer

*/

public Object getCache(PImage image) { // ignore

return cacheMap.get(image);

}

/**

* Remove information associated with this renderer from the cache, if any.

* @param image The image whose cache data should be removed

*/

public void removeCache(PImage image) { // ignore

cacheMap.remove(image);

}

//////////////////////////////////////////////////////////////

// FRAME

// /**

// * Some renderers have requirements re: when they are ready to draw.

// */

// public boolean canDraw() { // ignore

// return true;

// }

// removing because renderers will have their own animation threads and

// can handle this however they wish

// /**

// * Try to draw, or put a draw request on the queue.

// */

// public void requestDraw() { // ignore

// parent.handleDraw();

// }

/**

* ( begin auto-generated from PGraphics_beginDraw.xml )

*

* Sets the default properties for a PGraphics object. It should be called

* before anything is drawn into the object.

*

* ( end auto-generated )

* <h3>Advanced</h3>

* When creating your own PGraphics, you should call this before

* drawing anything.

*

* @webref pgraphics:method

* @brief Sets the default properties for a PGraphics object

*/

public void beginDraw() { // ignore

}

/**

* ( begin auto-generated from PGraphics_endDraw.xml )

*

* Finalizes the rendering of a PGraphics object so that it can be shown on screen.

*

* ( end auto-generated )

* <h3>Advanced</h3>

* <p/>

* When creating your own PGraphics, you should call this when

* you're finished drawing.

*

* @webref pgraphics:method

* @brief Finalizes the rendering of a PGraphics object

*/

public void endDraw() { // ignore

}

public PGL beginPGL() {

showMethodWarning("beginGL");

return null;

}

public void endPGL() {

showMethodWarning("endGL");

}

public void flush() {

// no-op, mostly for P3D to write sorted stuff

}

protected void checkSettings() {

if (!settingsInited) defaultSettings();

if (reapplySettings) reapplySettings();

}

/**

* Set engine's default values. This has to be called by PApplet,

* somewhere inside setup() or draw() because it talks to the

* graphics buffer, meaning that for subclasses like OpenGL, there

* needs to be a valid graphics context to mess with otherwise

* you'll get some good crashing action.

*

* This is currently called by checkSettings(), during beginDraw().

*/

protected void defaultSettings() { // ignore

// System.out.println("PGraphics.defaultSettings() " + width + " " + height);

// //smooth(); // 2.0a5

// if (quality > 0) { // 2.0a5

// smooth();

// } else {

// noSmooth();

// }

colorMode(RGB, 255);

fill(255);

stroke(0);

// as of 0178, no longer relying on local versions of the variables

// being set, because subclasses may need to take extra action.

strokeWeight(DEFAULT_STROKE_WEIGHT);

strokeJoin(DEFAULT_STROKE_JOIN);

strokeCap(DEFAULT_STROKE_CAP);

// init shape stuff

shape = 0;

rectMode(CORNER);

ellipseMode(DIAMETER);

autoNormal = true;

// no current font

textFont = null;

textSize = 12;

textLeading = 14;

textAlign = LEFT;

textMode = MODEL;

// if this fella is associated with an applet, then clear its background.

// if it's been created by someone else through createGraphics,

// they have to call background() themselves, otherwise everything gets

// a gray background (when just a transparent surface or an empty pdf

// is what's desired).

// this background() call is for the Java 2D and OpenGL renderers.

if (primaryGraphics) {

//System.out.println("main drawing surface bg " + getClass().getName());

background(backgroundColor);

}

blendMode(BLEND);

settingsInited = true;