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

/*

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

Copyright (c) 2004-10 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 version 2.1 as published by the Free Software Foundation.

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;

import java.util.HashMap;

import java.util.WeakHashMap;

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.RejectedExecutionException;

import java.util.concurrent.TimeUnit;

import processing.opengl.PGL;

import processing.opengl.PShader;

import android.graphics.Bitmap;

import android.graphics.Color;

/**

* 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.

*/

public class PGraphics extends PImage implements PConstants {

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

// 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 int smooth;

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

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

protected boolean settingsInited;

/// 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 drawing surface for a particular sketch.

* This would be set to false for an offscreen buffer or if it were

* created any other way than size(). When this is set, the listeners

* are also added to the sketch.

*/

protected boolean primaryGraphics;

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

/**

* 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;

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

// 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;

/** 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 int MATRIX_STACK_DEPTH = 32;

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

// 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

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 = null;

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

// [toxi031031] new & faster sphere code w/ support flexibile 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

/**

* Constructor for the PGraphics object. Use this to ensure that

* the defaults get set properly. In a subclass, use this(w, h)

* as the first line of a subclass' constructor to properly set

* the internal fields and defaults.

*/

public PGraphics() {

}

public void setParent(PApplet parent) { // ignore

this.parent = parent;

}

/**

* 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 setFrameRate(float framerate) { // ignore

}

/**

* 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 that this is ignored by preproc.pl 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;

width1 = width - 1;

height1 = height - 1;

allocate();

reapplySettings();

}

/**

* Allocate memory for this renderer. Generally will need to be implemented

* for all renderers.

*/

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

}

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

// 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 renderer The PGraphics renderer associated to the image

* @param storage The metadata required by the renderer

*/

public void setCache(PImage image, Object storage) {

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.

* @param renderer The PGraphics renderer associated to the image

* @return metadata stored for the specified renderer

*/

public Object getCache(PImage image) {

return cacheMap.get(image);

}

/**

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

* @param renderer The PGraphics renderer whose cache data should be removed

*/

public void removeCache(PImage image) {

cacheMap.remove(image);

}

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

// FRAME

/**

* Handle grabbing the focus from the parent applet. Other renderers can

* override this if handling needs to be different.

*/

public void requestFocus() { // ignore

}

/**

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

*/

public boolean canDraw() { // ignore

return true;

}

/**

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

*/

public void requestDraw() { // ignore

}

/**

* Prepares the PGraphics for drawing.

* <p/>

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

* drawing anything.

*/

public void beginDraw() { // ignore

}

/**

* This will finalize rendering so that it can be shown on-screen.

* <p/>

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

* you're finished drawing.

*/

public void endDraw() { // ignore

}

public void flush() {

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

}

public PGL beginPGL() {

showMethodWarning("beginPGL");

return null;

}

public void endPGL() {

showMethodWarning("endPGL");

}

protected void checkSettings() {

if (!settingsInited) defaultSettings();

}

/**

* 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

smooth(); // 2.0a5

colorMode(RGB, 255);

fill(255);

stroke(0);

// added for 0178 for subclasses that need them

strokeWeight(DEFAULT_STROKE_WEIGHT);

strokeJoin(DEFAULT_STROKE_JOIN);

strokeCap(DEFAULT_STROKE_CAP);

// init shape stuff

shape = 0;

// init matrices (must do before lights)

//matrixStackDepth = 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;

// defaultSettings() overlaps reapplySettings(), don't do both

//reapplySettings = false;

}

/**

* Re-apply current settings. Some methods, such as textFont(), require that

* their methods be called (rather than simply setting the textFont variable)

* because they affect the graphics context, or they require parameters from

* the context (e.g. getting native fonts for text).

*

* This will only be called from an allocate(), which is only called from

* size(), which is safely called from inside beginDraw(). And it cannot be

* called before defaultSettings(), so we should be safe.

*/

protected void reapplySettings() {

// System.out.println("attempting reapplySettings()");

if (!settingsInited) return; // if this is the initial setup, no need to reapply

// System.out.println(" doing reapplySettings");

// new Exception().printStackTrace(System.out);

colorMode(colorMode, colorModeX, colorModeY, colorModeZ);

if (fill) {

// PApplet.println(" fill " + PApplet.hex(fillColor));

fill(fillColor);

} else {

noFill();

}

if (stroke) {

stroke(strokeColor);

// The if() statements should be handled inside the functions,

// otherwise an actual reset/revert won't work properly.

//if (strokeWeight != DEFAULT_STROKE_WEIGHT) {

strokeWeight(strokeWeight);

//}

// if (strokeCap != DEFAULT_STROKE_CAP) {

strokeCap(strokeCap);

// }

// if (strokeJoin != DEFAULT_STROKE_JOIN) {

strokeJoin(strokeJoin);

// }

} else {

noStroke();

}

if (tint) {

tint(tintColor);

} else {

noTint();

}

// if (smooth) {

// smooth();

// } else {

// // Don't bother setting this, cuz it'll anger P3D.

// noSmooth();

// }

if (textFont != null) {

// System.out.println(" textFont in reapply is " + textFont);

// textFont() resets the leading, so save it in case it's changed

float saveLeading = textLeading;

textFont(textFont, textSize);

textLeading(saveLeading);

}

textMode(textMode);

textAlign(textAlign, textAlignY);

background(backgroundColor);

blendMode(blendMode);

//reapplySettings = false;

}

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

// HINTS

/**

* Enable a hint option.

* <P>

* For the most part, hints are temporary api quirks,

* for which a proper api hasn't been properly worked out.

* for instance SMOOTH_IMAGES existed because smooth()

* wasn't yet implemented, but it will soon go away.

* <P>

* They also exist for obscure features in the graphics

* engine, like enabling/disabling single pixel lines

* that ignore the zbuffer, the way they do in alphabot.

* <P>

* Current hint options:

* <UL>

* <LI><TT>DISABLE_DEPTH_TEST</TT> -

* turns off the z-buffer in the P3D or OPENGL renderers.

* </UL>

*/

public void hint(int which) {

if (which > 0) {

hints[which] = true;

} else {

hints[-which] = false;

}

}

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

// VERTEX SHAPES

/**

* Start a new shape of type POLYGON

*/