javax.media.j3d.J3DGraphics2DImpl Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of java3d-core Show documentation
Show all versions of java3d-core Show documentation
Java3D Core And Java3D Util Libraries
The newest version!
/*
* Copyright 1999-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code 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 General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
*/
package javax.media.j3d;
import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Composite;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.Image;
import java.awt.Paint;
import java.awt.Point;
import java.awt.Polygon;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.RenderingHints.Key;
import java.awt.Shape;
import java.awt.Stroke;
import java.awt.font.FontRenderContext;
import java.awt.font.GlyphVector;
import java.awt.font.TextLayout;
import java.awt.geom.AffineTransform;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.awt.image.BufferedImageOp;
import java.awt.image.ColorModel;
import java.awt.image.DataBufferByte;
import java.awt.image.DataBufferInt;
import java.awt.image.ImageObserver;
import java.awt.image.RenderedImage;
import java.awt.image.WritableRaster;
import java.awt.image.renderable.RenderableImage;
import java.text.AttributedCharacterIterator;
import java.util.Map;
/**
* Implementation class for J3DGraphics2D
*/
final class J3DGraphics2DImpl extends J3DGraphics2D {
private boolean hasBeenDisposed = false;
private Graphics2D offScreenGraphics2D;
private BufferedImage g3dImage = null;
private byte[] data = null;
private boolean isFlushed = true;
private Canvas3D canvas3d;
private int width, height;
private int texWidth, texHeight;
private int xmin, ymin, xmax, ymax;
private Object extentLock = new Object();
private boolean abgr;
private boolean initTexMap = false;
private boolean strokeSet=false;
private Point2D.Float ptSrc = new Point2D.Float();
private Point2D.Float ptDst1 = new Point2D.Float();
private Point2D.Float ptDst2 = new Point2D.Float();
private Color xOrModeColor = null;
private volatile boolean initCtx = false;
private volatile boolean threadWaiting = false;
static final Color blackTransparent = new Color(0,0,0,0);
int objectId = -1;
// Package scope contructor
J3DGraphics2DImpl(Canvas3D c) {
canvas3d = c;
synchronized (VirtualUniverse.mc.contextCreationLock) {
if (c.ctx == null) {
// create a dummy bufferImage
width = 1;
height = 1;
g3dImage = new BufferedImage(width, height,
BufferedImage.TYPE_INT_ARGB);
offScreenGraphics2D = g3dImage.createGraphics();
} else {
init();
}
}
}
// This is invoke from Renderer callback when the first
// time createContext() finish which set
// canvas3d.extensionSupported correctly.
void init() {
// if ABGR extension is supported, we want to use
// TYPE_4BYTE_ABGR to make a fast copy
if (!initCtx) {
abgr = ((canvas3d.extensionsSupported & Canvas3D.EXT_ABGR) != 0);
width = canvas3d.getWidth();
height = canvas3d.getHeight();
initTexMap = false;
if (width <= 0) {
width = 1;
}
if (height <= 0) {
height = 1;
}
synchronized (extentLock) {
xmax = width;
ymax = height;
xmin = 0;
ymin = 0;
}
g3dImage = new BufferedImage(width, height,
(abgr ? BufferedImage.TYPE_4BYTE_ABGR:
BufferedImage.TYPE_INT_ARGB));
offScreenGraphics2D = g3dImage.createGraphics();
clearOffScreen();
if (!abgr) {
data = new byte[width*height*4];
}
// should be the last flag to set
initCtx = true;
}
}
/**
* Flushes all previously executed rendering operations to the
* drawing buffer for this 2D graphics object.
*
* @param wait flag indicating whether or not to wait for the
* rendering to be complete before returning from this call.
*/
@Override
public void flush(boolean waiting) {
if (hasBeenDisposed) {
throw new IllegalStateException(J3dI18N.getString("J3DGraphics2D0"));
}
if (!isFlushed) {
// Composite g3dImage into Canvas3D
if (Thread.currentThread() == canvas3d.screen.renderer) {
if (!initCtx) {
return;
}
doFlush();
} else {
if (!initCtx) {
if (waiting &&
(canvas3d.pendingView != null) &&
canvas3d.pendingView.activeStatus) {
// wait until Renderer init() this context
while (!initCtx) {
MasterControl.threadYield();
}
} else {
return;
}
}
// Behavior Scheduler or other threads
// XXXX: may not be legal for behaviorScheduler
// May cause deadlock if it is in behaviorScheduler
// and we wait for Renderer to finish
boolean renderRun = (Thread.currentThread() !=
canvas3d.view.universe.behaviorScheduler);
// This must put before sendRenderMessage()
threadWaiting = true;
sendRenderMessage(renderRun, GraphicsContext3D.FLUSH2D, null,
null, null);
if (waiting) {
// It is possible that thread got notify BEFORE
// the following runMonitor invoke.
runMonitor(J3dThread.WAIT);
}
}
isFlushed = true;
}
}
// copy the data into a byte buffer that will be passed to opengl
void doFlush() {
assert !hasBeenDisposed;
// clip to offscreen buffer size
if (canvas3d.ctx == null) {
canvas3d.getGraphicsContext3D().doClear();
}
synchronized (extentLock) {
if (xmin < 0) {
xmin = 0;
}
if (xmax > width) {
xmax = width;
}
if (ymin < 0) {
ymin = 0;
}
if (ymax > height) {
ymax = height;
}
if ((xmax - xmin > 0) &&
(ymax - ymin > 0)) {
if (abgr) {
data = ((DataBufferByte)g3dImage.getRaster().getDataBuffer()).getData();
} else {
copyImage(g3dImage, data, width, height, xmin, ymin, xmax, ymax);
}
copyDataToCanvas(0, 0, xmin, ymin, xmax, ymax, width, height);
} else {
runMonitor(J3dThread.NOTIFY);
}
// this define an empty region
xmax = 0;
ymax = 0;
xmin = width;
ymin = height;
}
}
// borrowed from ImageComponentRetained since ImageComponent2D
// seems to do stuff we don't need to
final void copyImage(BufferedImage bi, byte[] image,
int width, int height,
int x1, int y1, int x2, int y2) {
assert !hasBeenDisposed;
int biType = bi.getType();
int w, h, i, j;
int row, rowBegin, rowInc, dstBegin;
dstBegin = 0;
rowInc = 1;
rowBegin = 0;
// convert format to RGBA for underlying OGL use
if ((biType == BufferedImage.TYPE_INT_ARGB) ||
(biType == BufferedImage.TYPE_INT_RGB)) {
// optimized cases
rowBegin = y1;
int colBegin = x1;
int[] intData =
((DataBufferInt)bi.getRaster().getDataBuffer()).getData();
int rowOffset = rowInc * width;
int intPixel;
rowBegin = rowBegin*width + colBegin;
dstBegin = rowBegin*4;
if (biType == BufferedImage.TYPE_INT_ARGB) {
for (h = y1; h < y2; h++) {
i = rowBegin;
j = dstBegin;
for (w = x1; w < x2; w++, i++) {
intPixel = intData[i];
image[j++] = (byte)((intPixel >> 16) & 0xff);
image[j++] = (byte)((intPixel >> 8) & 0xff);
image[j++] = (byte)(intPixel & 0xff);
image[j++] = (byte)((intPixel >> 24) & 0xff);
}
rowBegin += rowOffset;
dstBegin += (rowOffset*4);
}
} else {
for (h = y1; h < y2; h++) {
i = rowBegin;
j = dstBegin;
for (w = x1; w < x2; w++, i++) {
intPixel = intData[i];
image[j++] = (byte)((intPixel >> 16) & 0xff);
image[j++] = (byte)((intPixel >> 8) & 0xff);
image[j++] = (byte)(intPixel & 0xff);
image[j++] = (byte)255;
}
rowBegin += rowOffset;
dstBegin += (rowOffset*4);
}
}
} else {
// non-optimized cases
WritableRaster ras = bi.getRaster();
ColorModel cm = bi.getColorModel();
Object pixel = ImageComponentRetained.getDataElementBuffer(ras);
j = (y1*width + x1)*4;
for (h = y1; h < y2; h++) {
i = j;
for (w = x1; w < x2; w++) {
ras.getDataElements(w, h, pixel);
image[j++] = (byte)cm.getRed(pixel);
image[j++] = (byte)cm.getGreen(pixel);
image[j++] = (byte)cm.getBlue(pixel);
image[j++] = (byte)cm.getAlpha(pixel);
}
j = i+ width*4;
}
}
}
void sendRenderMessage(boolean renderRun, int command,
Object arg1, Object arg2, Object arg3) {
// send a message to the request renderer
J3dMessage renderMessage = new J3dMessage();
renderMessage.threads = J3dThread.RENDER_THREAD;
renderMessage.type = J3dMessage.RENDER_IMMEDIATE;
renderMessage.universe = null;
renderMessage.view = null;
renderMessage.args[0] = canvas3d;
renderMessage.args[1] = new Integer(command);
renderMessage.args[2] = arg1;
renderMessage.args[3] = arg2;
renderMessage.args[4] = arg3;
while (!canvas3d.view.inRenderThreadData) {
// wait until the renderer thread data in added in
// MC:RenderThreadData array ready to receive message
MasterControl.threadYield();
}
canvas3d.screen.renderer.rendererStructure.addMessage(renderMessage);
if (renderRun) {
// notify mc that there is work to do
VirtualUniverse.mc.sendRunMessage(canvas3d.view, J3dThread.RENDER_THREAD);
} else {
// notify mc that there is work for the request renderer
VirtualUniverse.mc.setWorkForRequestRenderer();
}
}
final void validate() {
validate(0, 0, width, height);
}
void validate(float x1, float y1, float x2, float y2,
AffineTransform xform) {
float t;
if (xform == null) {
validate(x1, y1, x2, y2);
} else {
ptSrc.x = x1;
ptSrc.y = y1;
xform.transform(ptSrc, ptDst1);
ptSrc.x = x2;
ptSrc.y = y2;
xform.transform(ptSrc, ptDst2);
if (ptDst1.x > ptDst2.x) {
t = ptDst1.x;
ptDst1.x = ptDst2.x;
ptDst2.x = t;
}
if (ptDst1.y > ptDst2.y) {
t = ptDst1.y;
ptDst1.y = ptDst2.y;
ptDst2.y = t;
}
// take care of numerical error by adding 1
validate(ptDst1.x-1, ptDst1.y-1, ptDst2.x+1, ptDst2.y+1);
}
}
void validate(float x1, float y1, float x2, float y2) {
boolean doResize = false;
isFlushed = false;
synchronized(canvas3d) {
if (initCtx && canvas3d.resizeGraphics2D) {
doResize = true;
canvas3d.resizeGraphics2D = false;
}
}
if (doResize) {
synchronized (VirtualUniverse.mc.contextCreationLock) {
Graphics2D oldOffScreenGraphics2D = offScreenGraphics2D;
initCtx = false;
init();
copyGraphics2D(oldOffScreenGraphics2D);
}
} else {
AffineTransform tr = getTransform();
ptSrc.x = x1;
ptSrc.y = y1;
tr.transform(ptSrc, ptDst1);
ptSrc.x = x2;
ptSrc.y = y2;
tr.transform(ptSrc, ptDst2);
synchronized (extentLock) {
if (ptDst1.x < xmin) {
xmin = (int) ptDst1.x;
}
if (ptDst1.y < ymin) {
ymin = (int) ptDst1.y;
}
if (ptDst2.x > xmax) {
xmax = (int) ptDst2.x;
}
if (ptDst2.y > ymax) {
ymax = (int) ptDst2.y;
}
}
}
}
void copyGraphics2D(Graphics2D oldg) {
// restore the original setting of Graphics2D when resizing the windows
setColor(oldg.getColor());
setFont(oldg.getFont());
setClip(oldg.getClip());
setComposite(oldg.getComposite());
setTransform(oldg.getTransform());
setPaint(oldg.getPaint());
setStroke(oldg.getStroke());
if (xOrModeColor != null) {
setXORMode(xOrModeColor);
}
}
// Implementation of Graphics2D methods
@Override
public final void clip(Shape s) {
offScreenGraphics2D.clip(s);
}
@Override
public FontMetrics getFontMetrics() {
return offScreenGraphics2D.getFontMetrics();
}
@Override
public Rectangle getClipBounds(Rectangle r) {
return offScreenGraphics2D.getClipBounds(r);
}
@Override
public Rectangle getClipRect() {
return offScreenGraphics2D.getClipRect();
}
@Override
public String toString() {
return offScreenGraphics2D.toString();
}
@Override
public final AffineTransform getTransform() {
return offScreenGraphics2D.getTransform();
}
@Override
public final Color getColor() {
return offScreenGraphics2D.getColor();
}
@Override
public final Composite getComposite() {
return offScreenGraphics2D.getComposite();
}
@Override
public final Font getFont() {
return offScreenGraphics2D.getFont();
}
@Override
public final FontMetrics getFontMetrics(Font f) {
return offScreenGraphics2D.getFontMetrics(f);
}
@Override
public final FontRenderContext getFontRenderContext() {
return offScreenGraphics2D.getFontRenderContext();
}
@Override
public final GraphicsConfiguration getDeviceConfiguration() {
return offScreenGraphics2D.getDeviceConfiguration();
}
@Override
public final Object getRenderingHint(Key hintKey) {
return offScreenGraphics2D.getRenderingHint(hintKey);
}
@Override
public final Paint getPaint() {
return offScreenGraphics2D.getPaint();
}
@Override
public final Rectangle getClipBounds() {
return offScreenGraphics2D.getClipBounds();
}
@Override
public final RenderingHints getRenderingHints() {
return offScreenGraphics2D.getRenderingHints();
}
@Override
public final Shape getClip() {
return offScreenGraphics2D.getClip();
}
@Override
public final Stroke getStroke() {
return offScreenGraphics2D.getStroke();
}
@Override
public final boolean drawImage(Image img, AffineTransform xform,
ImageObserver obs) {
validate(0, 0, img.getWidth(obs), img.getHeight(obs), xform);
return offScreenGraphics2D.drawImage(img, xform, obs);
}
@Override
public final void drawImage(BufferedImage img, BufferedImageOp op,
int x, int y) {
if (op != null) {
img = op.filter(img, null);
}
validate(x, y, x+img.getWidth(), y+img.getHeight());
offScreenGraphics2D.drawImage(img, null, x, y);
}
@Override
public final boolean drawImage(Image img,
int x, int y,
ImageObserver observer) {
validate(x, y,
x + img.getWidth(observer),
y + img.getWidth(observer));
return offScreenGraphics2D.drawImage(img, x, y, observer);
}
@Override
public final boolean drawImage(Image img, int x, int y,
int width, int height,
ImageObserver observer) {
validate(x, y, x+width, y+height);
return offScreenGraphics2D.drawImage(img, x, y, width, height,
observer);
}
@Override
public final boolean drawImage(Image img, int x, int y,
int width, int height,
Color bgcolor,
ImageObserver observer) {
validate(x, y, x+width, y+height);
return offScreenGraphics2D.drawImage(img, x, y, width, height, bgcolor,
observer);
}
public final void drawImage(BufferedImage img,
int dx1, int dy1, int dx2, int dy2,
int sx1, int sy1, int sx2, int sy2,
ImageObserver observer) {
validate(dx1, dy1, dx2, dy2);
offScreenGraphics2D.drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1,
sx2, sy2, observer);
}
@Override
public final boolean drawImage(Image img,
int dx1, int dy1, int dx2, int dy2,
int sx1, int sy1, int sx2, int sy2,
ImageObserver observer) {
validate(dx1, dy1, dx2, dy2);
return offScreenGraphics2D.drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1,
sx2, sy2, observer);
}
@Override
public final boolean drawImage(Image img,
int dx1, int dy1, int dx2, int dy2,
int sx1, int sy1, int sx2, int sy2,
Color bgcolor,
ImageObserver observer) {
validate(dx1, dy1, dx2, dy2);
return offScreenGraphics2D.drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1,
sx2, sy2, bgcolor, observer);
}
@Override
public final boolean drawImage(Image img, int x, int y,
Color bgcolor,
ImageObserver observer) {
validate(x, y, x+img.getWidth(observer), y+img.getHeight(observer));
return offScreenGraphics2D.drawImage(img, x, y, bgcolor, observer);
}
@Override
public final boolean hit(Rectangle rect, Shape s, boolean onStroke) {
return offScreenGraphics2D.hit(rect, s, onStroke);
}
@Override
public final void addRenderingHints(Map hints) {
offScreenGraphics2D.addRenderingHints(hints);
}
@Override
public final void clipRect(int x, int y, int width, int height) {
offScreenGraphics2D.clipRect(x, y, width, height);
}
@Override
public final void copyArea(int x, int y, int width, int height,
int dx, int dy) {
validate(x+dx, y+dy, x+dx+width, y+dy+height);
offScreenGraphics2D.copyArea(x, y, width, height, dx, dy);
}
@Override
public final void draw(Shape s) {
Rectangle rect = s.getBounds();
validate(rect.x, rect.y,
rect.x + rect.width,
rect.y + rect.height);
offScreenGraphics2D.draw(s);
}
@Override
public final void drawArc(int x, int y, int width, int height,
int startAngle, int arcAngle) {
// XXXX: call validate with bounding box of primitive
validate();
offScreenGraphics2D.drawArc(x, y, width, height, startAngle, arcAngle);
}
@Override
public final void drawGlyphVector(GlyphVector g, float x, float y) {
// XXXX: call validate with bounding box of primitive
validate();
offScreenGraphics2D.drawGlyphVector(g, x, y);
}
@Override
public final void drawLine(int x1, int y1, int x2, int y2) {
int minx, miny, maxx, maxy;
if (!strokeSet) {
if (x1 > x2) {
minx = x2;
maxx = x1;
} else {
minx = x1;
maxx = x2;
}
if (y1 > y2) {
miny = y2;
maxy = y1;
} else {
miny = y1;
maxy = y2;
}
validate(minx, miny, maxx, maxy);
} else {
// XXXX: call validate with bounding box of primitive
// XXXX: Need to consider Stroke width
validate();
}
offScreenGraphics2D.drawLine(x1, y1, x2, y2);
}
@Override
public final void drawOval(int x, int y, int width, int height) {
// XXXX: call validate with bounding box of primitive
validate();
offScreenGraphics2D.drawOval(x, y, width, height);
}
@Override
public final void drawPolygon(int xPoints[], int yPoints[],
int nPoints) {
// XXXX: call validate with bounding box of primitive
validate();
offScreenGraphics2D.drawPolygon(xPoints, yPoints, nPoints);
}
@Override
public final void drawPolyline(int xPoints[], int yPoints[],
int nPoints) {
// XXXX: call validate with bounding box of primitive
validate();
offScreenGraphics2D.drawPolyline(xPoints, yPoints, nPoints);
}
@Override
public final void drawRenderableImage(RenderableImage img,
AffineTransform xform) {
validate(0, 0, img.getWidth(), img.getHeight(), xform);
offScreenGraphics2D.drawRenderableImage(img, xform);
}
@Override
public final void drawRenderedImage(RenderedImage img,
AffineTransform xform) {
validate(0, 0, img.getWidth(), img.getHeight(), xform);
offScreenGraphics2D.drawRenderedImage(img, xform);
}
@Override
public final void drawRoundRect(int x, int y, int width, int height,
int arcWidth, int arcHeight) {
// XXXX: call validate with bounding box of primitive
validate();
offScreenGraphics2D.drawRoundRect(x, y, width, height, arcWidth,
arcHeight);
}
@Override
public final void drawString(AttributedCharacterIterator iterator,
int x, int y) {
// XXXX: call validate with bounding box of primitive
validate();
offScreenGraphics2D.drawString(iterator, x, y);
}
@Override
public final void drawString(AttributedCharacterIterator iterator,
float x, float y) {
// XXXX: call validate with bounding box of primitive
validate();
offScreenGraphics2D.drawString(iterator, x, y);
}
@Override
public final void drawString(String s, float x, float y) {
TextLayout layout = new TextLayout(s, getFont(),
getFontRenderContext());
Rectangle2D bounds = layout.getBounds();
float x1 = (float) bounds.getX();
float y1 = (float) bounds.getY();
validate(x1+x, y1+y,
x1 + x + (float) bounds.getWidth(),
y1 + y + (float) bounds.getHeight());
offScreenGraphics2D.drawString(s, x, y);
}
@Override
public final void drawString(String s, int x, int y) {
drawString(s, (float) x, (float) y);
}
@Override
public final void fill(Shape s) {
Rectangle rect = s.getBounds();
validate(rect.x, rect.y, rect.x + rect.width, rect.y + rect.height);
offScreenGraphics2D.fill(s);
}
@Override
public final void fillArc(int x, int y, int width, int height,
int startAngle, int arcAngle) {
// XXXX: call validate with bounding box of primitive
validate();
offScreenGraphics2D.fillArc(x, y, width, height, startAngle, arcAngle);
}
@Override
public final void fillOval(int x, int y, int width, int height) {
// XXXX: call validate with bounding box of primitive
validate();
offScreenGraphics2D.fillOval(x, y, width, height);
}
@Override
public final void fillRoundRect(int x, int y, int width, int height,
int arcWidth, int arcHeight) {
// XXXX: call validate with bounding box of primitive
validate();
offScreenGraphics2D.fillRoundRect(x, y, width, height, arcWidth,
arcHeight);
}
@Override
public final void rotate(double theta) {
offScreenGraphics2D.rotate(theta);
}
@Override
public final void rotate(double theta, double x, double y) {
offScreenGraphics2D.rotate(theta, x, y);
}
@Override
public final void scale(double sx, double sy) {
offScreenGraphics2D.scale(sx, sy);
}
@Override
public final void setClip(Shape clip) {
offScreenGraphics2D.setClip(clip);
}
@Override
public final void setClip(int x, int y, int width, int height) {
offScreenGraphics2D.setClip(x, y, width, height);
}
@Override
public final void setColor(Color c) {
offScreenGraphics2D.setColor(c);
}
@Override
public final void setComposite(Composite comp) {
offScreenGraphics2D.setComposite(comp);
}
@Override
public final void setFont(Font font) {
offScreenGraphics2D.setFont(font);
}
@Override
public final void setPaint( Paint paint ) {
offScreenGraphics2D.setPaint(paint);
}
@Override
public final void setPaintMode() {
xOrModeColor = null;
offScreenGraphics2D.setPaintMode();
}
@Override
public final void setRenderingHint(Key hintKey, Object hintValue) {
offScreenGraphics2D.setRenderingHint(hintKey, hintValue);
}
@Override
public final void setRenderingHints(Map hints) {
offScreenGraphics2D.setRenderingHints(hints);
}
@Override
public final void setStroke(Stroke s) {
strokeSet = (s != null);
offScreenGraphics2D.setStroke(s);
}
@Override
public final void setTransform(AffineTransform Tx) {
offScreenGraphics2D.setTransform(Tx);
}
@Override
public final void setXORMode(Color c1) {
xOrModeColor = c1;
offScreenGraphics2D.setXORMode(c1);
}
@Override
public final void shear(double shx, double shy) {
offScreenGraphics2D.shear(shx, shy);
}
@Override
public final void transform(AffineTransform Tx) {
offScreenGraphics2D.transform(Tx);
}
@Override
public final void translate(double tx, double ty) {
offScreenGraphics2D.translate(tx, ty);
}
@Override
public final void translate(int x, int y) {
offScreenGraphics2D.translate(x, y);
}
@Override
public boolean hitClip(int x, int y, int width, int height) {
return offScreenGraphics2D.hitClip(x, y, width, height);
}
@Override
public void draw3DRect(int x, int y, int width, int height,
boolean raised) {
// XXXX: call validate with bounding box of primitive
validate();
offScreenGraphics2D.draw3DRect(x, y, width, height, raised);
}
@Override
public void drawBytes(byte data[], int offset, int length, int x, int y) {
// XXXX: call validate with bounding box of primitive
validate();
offScreenGraphics2D.drawBytes(data, offset, length, x, y);
}
@Override
public void drawChars(char data[], int offset, int length, int x, int y) {
// XXXX: call validate with bounding box of primitive
validate();
offScreenGraphics2D.drawChars(data, offset, length, x, y);
}
@Override
public void drawPolygon(Polygon p) {
// XXXX: call validate with bounding box of primitive
validate();
offScreenGraphics2D.drawPolygon(p);
}
@Override
public void drawRect(int x, int y, int width, int height) {
// XXXX: call validate with bounding box of primitive
// XXXX: need to consider Stroke width
validate();
offScreenGraphics2D.drawRect(x, y, width, height);
}
@Override
public void fill3DRect(int x, int y, int width, int height,
boolean raised) {
// XXXX: call validate with bounding box of primitive
// XXXX: need to consider Stroke width
validate();
offScreenGraphics2D.fill3DRect(x, y, width, height, raised);
}
@Override
public void fillPolygon(Polygon p) {
// XXXX: call validate with bounding box of primitive
validate();
offScreenGraphics2D.fillPolygon(p);
}
@Override
public final void fillPolygon(int xPoints[], int yPoints[],
int nPoints) {
// XXXX: call validate with bounding box of primitive
validate();
offScreenGraphics2D.fillPolygon(xPoints, yPoints, nPoints);
}
@Override
public final void fillRect(int x, int y, int width, int height) {
// XXXX: call validate with bounding box of primitive
validate();
offScreenGraphics2D.fillRect(x, y, width, height);
}
// Issue 121 - release all resources, mark as disposed
@Override
public void dispose() {
// Issue 583 - do nothing if graphics has already been disposed
if (hasBeenDisposed) {
return;
}
if (Thread.currentThread() == canvas3d.screen.renderer) {
doDispose();
} else {
// Behavior Scheduler or other threads
// XXXX: may not be legal for behaviorScheduler
// May cause deadlock if it is in behaviorScheduler
// and we wait for Renderer to finish
boolean renderRun = (Thread.currentThread() !=
canvas3d.view.universe.behaviorScheduler);
sendRenderMessage(renderRun, GraphicsContext3D.DISPOSE2D,
null, null, null);
}
}
public void doDispose() {
if (hasBeenDisposed) {
return;
}
if (objectId != -1) {
Canvas3D.freeTexture(canvas3d.ctx, objectId);
objectId = -1;
}
// Dispose of the underlying Graphics2D
offScreenGraphics2D.dispose();
// Mark as disposed
hasBeenDisposed = true;
// Issue 583 - set graphics2D field to null so it will get recreated
canvas3d.graphics2D = null;
}
@Override
public void drawAndFlushImage(BufferedImage img, int x, int y,
ImageObserver observer) {
if (hasBeenDisposed) {
throw new IllegalStateException(J3dI18N.getString("J3DGraphics2D0"));
}
if (!(initCtx && abgr &&
(img.getType() == BufferedImage.TYPE_4BYTE_ABGR))) {
drawImage(img, x, y, observer);
flush(false);
return;
}
if (Thread.currentThread() == canvas3d.screen.renderer) {
doDrawAndFlushImage(img, x, y, observer);
} else {
// Behavior Scheduler or other threads
// XXXX: may not be legal for behaviorScheduler
// May cause deadlock if it is in behaviorScheduler
// and we wait for Renderer to finish
boolean renderRun = (Thread.currentThread() !=
canvas3d.view.universe.behaviorScheduler);
sendRenderMessage(renderRun, GraphicsContext3D.DRAWANDFLUSH2D,
img, new Point(x, y), observer);
}
}
void doDrawAndFlushImage(BufferedImage img, int x, int y,
ImageObserver observer) {
assert !hasBeenDisposed;
int imgWidth = img.getWidth(observer);
int imgHeight = img.getHeight(observer);
int px, py, x1, y1, x2, y2;
if (canvas3d.ctx == null) {
canvas3d.getGraphicsContext3D().doClear();
}
// format needs to be 4BYTE_ABGR and abgr needs to be supported
// also must be in canvas callback
data = ((DataBufferByte)img.getRaster().getDataBuffer()).getData();
// Transform the affine transform,
// note we do not handle scale/rotate etc.
AffineTransform tr = getTransform();
ptSrc.x = x;
ptSrc.y = y;
tr.transform(ptSrc, ptDst1);
px = (int) ptDst1.x;
py = (int) ptDst1.y;
// clip to offscreen buffer size
if (px + imgWidth > width) {
x2 = width - px;
} else {
x2 = imgWidth;
}
if (px < 0) {
x1 = -px;
px = 0;
} else {
x1 = 0;
}
if (py + imgHeight > height) {
y2 = height - py;
} else {
y2 = imgHeight;
}
if (py < 0) {
y1 = -py;
py = 0;
} else {
y1 = 0;
}
if ((y2 - y1 > 0) && (x2 - x1 > 0)) {
copyDataToCanvas(px, py, x1,y1, x2, y2,imgWidth, imgHeight);
}
}
void copyDataToCanvas(int px, int py, int x1, int y1,
int x2, int y2, int w, int h) {
try {
if (!canvas3d.drawingSurfaceObject.renderLock()) {
return;
}
if (!initTexMap) {
if (objectId == -1) {
objectId = Canvas3D.generateTexID(canvas3d.ctx);
}
texWidth = getGreaterPowerOf2(w);
texHeight = getGreaterPowerOf2(h);
// Canvas got resize, need to init texture map again
// in Renderer thread
if (!canvas3d.initTexturemapping(canvas3d.ctx,
texWidth, texHeight,
objectId)) {
// Fail to get the texture surface, most likely
// there is not enough texture memory
initTexMap = false;
Canvas3D.freeTexture(canvas3d.ctx, objectId);
objectId = -1;
// TODO : Need to find a better way to report no resource problem --- Chien.
System.err.println("J3DGraphics2DImpl.copyDataToCanvas() : Fail to get texture resources ...");
} else {
initTexMap = true;
}
}
if (initTexMap) {
canvas3d.texturemapping(canvas3d.ctx, px, py,
x1, y1, x2, y2,
texWidth, texHeight, w,
(abgr ? ImageComponentRetained.TYPE_BYTE_ABGR:
ImageComponentRetained.TYPE_BYTE_RGBA),
objectId, data, width, height);
}
canvas3d.drawingSurfaceObject.unLock();
} catch (NullPointerException ne) {
canvas3d.drawingSurfaceObject.unLock();
throw ne;
}
clearOffScreen();
runMonitor(J3dThread.NOTIFY);
}
void clearOffScreen() {
Composite comp = offScreenGraphics2D.getComposite();
Color c = offScreenGraphics2D.getColor();
offScreenGraphics2D.setComposite(AlphaComposite.Src);
offScreenGraphics2D.setColor(blackTransparent);
offScreenGraphics2D.fillRect(xmin, ymin, (xmax-xmin), (ymax-ymin));
offScreenGraphics2D.setComposite(comp);
offScreenGraphics2D.setColor(c);
}
/**
* Return an integer of power 2 greater than x
*/
static int getGreaterPowerOf2(int x) {
int i = -1;
if (x >= 0) {
for (i = 1; i < x; i <<= 1);
}
return i;
}
/**
* MC may not scheduler Renderer thread or Renderer thread
* may not process message FLUSH. This will hang user
* thread.
*/
synchronized void runMonitor(int action) {
if (action == J3dThread.WAIT) {
// Issue 279 - loop until ready
while (threadWaiting) {
try {
wait();
} catch (InterruptedException e){}
}
} else if (action == J3dThread.NOTIFY) {
notify();
threadWaiting = false;
}
}
}