private VolatileImage loadFromFile(String filename) throws ImageLoadException {
try {
BufferedImage bimage = ImageIO.read(new File(filename));
VolatileImage vimage =
createVolatileImage(bimage.getWidth(), bimage.getHeight(), Transparency.TRANSLUCENT);
Graphics2D g = null;
try {
g = vimage.createGraphics();
g.setComposite(AlphaComposite.Src);
g.setColor(new Color(0, 0, 0, 0));
g.fillRect(0, 0, vimage.getWidth(), vimage.getHeight());
g.drawImage(bimage, null, 0, 0);
} finally {
g.dispose();
}
return vimage;
} catch (Exception e) {
throw new ImageLoadException("Impossible de charger une image � " + filename, e);
}
}
/**
* Performs the native flip operation for the given target Component.
*
* <p>REMIND: we should really not get here because that would mean that a FLIP BufferStrategy has
* been created, and one could only be created if accelerated pipeline is present but in some rare
* (and transitional) cases it may happen that the accelerated graphics device may have a default
* graphics configuraiton, so this is just a precaution.
*/
public void flip(
WComponentPeer peer,
Component target,
VolatileImage backBuffer,
int x1,
int y1,
int x2,
int y2,
BufferCapabilities.FlipContents flipAction) {
if (flipAction == BufferCapabilities.FlipContents.COPIED
|| flipAction == BufferCapabilities.FlipContents.UNDEFINED) {
Graphics g = peer.getGraphics();
try {
g.drawImage(backBuffer, x1, y1, x2, y2, x1, y1, x2, y2, null);
} finally {
g.dispose();
}
} else if (flipAction == BufferCapabilities.FlipContents.BACKGROUND) {
Graphics g = backBuffer.getGraphics();
try {
g.setColor(target.getBackground());
g.fillRect(0, 0, backBuffer.getWidth(), backBuffer.getHeight());
} finally {
g.dispose();
}
}
// the rest of the flip actions are not supported
}
public void render(Graphics2D g) {
do {
do {
g = (Graphics2D) strategy.getDrawGraphics();
g.setRenderingHints(renderingHints);
vi = createVolatileImage(getWidth(), getHeight());
bi =
GraphicsEnvironment.getLocalGraphicsEnvironment()
.getDefaultScreenDevice()
.getDefaultConfiguration()
.createCompatibleImage(getWidth(), getHeight());
vi.getGraphics().fillRect(0, 0, vi.getWidth(), vi.getHeight());
for (Renderable renderable : Window.objects) {
if (renderable.getShouldDestroy()) Window.objects.remove(renderable);
if (renderable.isVisible()) renderable.render((Graphics2D) vi.getGraphics());
}
bi.getGraphics().drawImage(vi.getSnapshot(), 0, 0, getWidth(), getHeight(), null);
bi = vi.getSnapshot();
// gaussian.filter(bi, bi);
// glow.filter(bi, bi);
// motionBlur.filter(bi, bi);
g.drawImage(bi, 0, 0, getWidth(), getHeight(), null);
g.dispose();
Toolkit.getDefaultToolkit().sync();
} while (strategy.contentsRestored());
strategy.show();
} while (strategy.contentsLost());
}
/**
* Paints the image at the specified location. This method assumes scaling has already been done,
* and simply paints the background image "as-is."
*
* @param g The graphics context.
* @param x The x-coordinate at which to paint.
* @param y The y-coordinate at which to paint.
*/
protected void paintImage(Graphics g, int x, int y) {
if (bgImage != null) {
do {
int rc = bgImage.validate(null); // getGraphicsConfiguration());
if (rc == VolatileImage.IMAGE_RESTORED) {
// FIXME: If the image needs to be restored are its width
// and height still valid?? If not, we'll need to cache
// these values...
renderImage(bgImage.getWidth(), bgImage.getHeight(), getScalingHint());
}
g.drawImage(bgImage, x, y, null);
} while (bgImage.contentsLost());
}
}
/** Performs the native GLX flip operation for the given target Component. */
@Override
public void flip(
X11ComponentPeer peer,
Component target,
VolatileImage xBackBuffer,
int x1,
int y1,
int x2,
int y2,
BufferCapabilities.FlipContents flipAction) {
if (flipAction == BufferCapabilities.FlipContents.COPIED) {
SurfaceManager vsm = SurfaceManager.getManager(xBackBuffer);
SurfaceData sd = vsm.getPrimarySurfaceData();
if (sd instanceof GLXVSyncOffScreenSurfaceData) {
GLXVSyncOffScreenSurfaceData vsd = (GLXVSyncOffScreenSurfaceData) sd;
SurfaceData bbsd = vsd.getFlipSurface();
Graphics2D bbg = new SunGraphics2D(bbsd, Color.black, Color.white, null);
try {
bbg.drawImage(xBackBuffer, 0, 0, null);
} finally {
bbg.dispose();
}
} else {
Graphics g = peer.getGraphics();
try {
g.drawImage(xBackBuffer, x1, y1, x2, y2, x1, y1, x2, y2, null);
} finally {
g.dispose();
}
return;
}
} else if (flipAction == BufferCapabilities.FlipContents.PRIOR) {
// not supported by GLX...
return;
}
OGLSurfaceData.swapBuffers(peer.getContentWindow());
if (flipAction == BufferCapabilities.FlipContents.BACKGROUND) {
Graphics g = xBackBuffer.getGraphics();
try {
g.setColor(target.getBackground());
g.fillRect(0, 0, xBackBuffer.getWidth(), xBackBuffer.getHeight());
} finally {
g.dispose();
}
}
}
public void initialize() {
// openLevelFile images:
try {
boxSpriteSheet = ImageIO.read(new File("ItemContainer.png"));
coinSpriteSheet = ImageIO.read(new File("Coin.png"));
} catch (Exception e) {
}
if (openLevelFile == false) {
try {
loadLevel(initLevel);
} catch (Exception e) {
System.out.println(e);
}
} else {
loadLevel(FileOpenDialog("Open ..."));
}
// create tile layer:
renderTileLayer();
// create bg layer:
backgroundLayer = new VolatileImage[backgroundImage.length];
// render layer:
for (int i = 0; i < backgroundImage.length; i++) {
renderBackgroundLayer(0);
renderBackgroundLayer(1);
}
// create hardware accellerated rendering layer:
renderImage =
this.getGraphicsConfiguration()
.createCompatibleVolatileImage(
loadedLevel.getWidth() * 16,
loadedLevel.getHeight() * 16,
Transparency.TRANSLUCENT);
Graphics2D g2d = renderImage.createGraphics();
g2d.setComposite(AlphaComposite.Src);
// Clear the image.
g2d.setColor(new Color(0, 0, 0, 0));
g2d.fillRect(0, 0, renderImage.getWidth(), renderImage.getHeight());
g2d.setBackground(new Color(0, 0, 0, 0));
}
/** @see com.iver.cit.gvsig.fmap.tools.Behavior.Behavior#paintComponent(java.awt.Graphics) */
public void paintComponent(Graphics g) {
// long t1 = System.currentTimeMillis();
VolatileImage image = createVolatileImage();
Graphics gh = image.createGraphics();
gh.setColor(getLayoutControl().getBackground());
gh.fillRect(0, 0, image.getWidth(), image.getHeight());
getLayoutControl().getLayoutDraw().drawRectangle((Graphics2D) gh);
gh.drawImage(getLayoutControl().getImage(), 0, 0, null);
gh.drawImage(getLayoutControl().getImgRuler(), 0, 0, null);
// long t2 = System.currentTimeMillis();
// BufferedImage img = getLayoutControl().getImage();
// BufferedImage imgRuler=getLayoutControl().getImgRuler();
// g.drawImage(img, 0, 0, getLayoutControl());
// g.drawImage(imgRuler, 0, 0, getLayoutControl());
gh.setColor(Color.black);
gh.setXORMode(Color.white);
// Borramos el anterior
Rectangle r = new Rectangle();
// Dibujamos el actual
if (dragged
&& (getLayoutControl().getFirstPoint() != null)
&& (getLayoutControl().getLastPoint() != null)) {
r.setFrameFromDiagonal(getLayoutControl().getFirstPoint(), getLayoutControl().getLastPoint());
gh.drawRect(r.x, r.y, r.width, r.height);
}
IFFrame[] frames = getLayoutControl().getLayoutContext().getFFrameSelected();
for (int i = 0; i < frames.length; i++) {
gh.setColor(Color.black);
frames[i].drawHandlers((Graphics2D) gh);
}
gh.setPaintMode();
// getLayoutControl().drawCursor(gh);
g.drawImage(image, 0, 0, null);
// long t3 = System.currentTimeMillis();
// System.out.println("t1 = " + (t2-t1) + " t2=" + (t3-t2));
}
public void rebuild() {
backG.setColor(Color.BLACK);
backG.fillRect(0, 0, backImg.getWidth(), backImg.getHeight());
for (int z = 0; z < paths.length; z++) {
Path path = paths[z];
double[] d = path.getCoords(animPos);
if (path instanceof MemoryPath) {
MemoryPath mp = (MemoryPath) path;
for (int i = 1 - mp.getMemorySize(); i <= 0; i++) {
int col = 0xff0000 + (0x110000 * i);
d = mp.getPreviousCoords(i);
backG.setColor(new Color(col));
backG.fillRect((int) (d[0] - 2), (int) (d[1] - 2), 5, 5);
}
} else {
backG.setColor(Color.RED);
backG.fillRect((int) (d[0] - 2), (int) (d[1] - 2), 5, 5);
}
}
this.repaint();
}
public VolatileImage renderTileLayer() {
// create hardware accellerated tile layer (Volatile Image)
tileLayer =
this.getGraphicsConfiguration()
.createCompatibleVolatileImage(
loadedLevel.getWidth() * 16,
loadedLevel.getHeight() * 16,
Transparency.TRANSLUCENT);
Graphics2D g2d = tileLayer.createGraphics();
g2d.setComposite(AlphaComposite.Src);
// Clear the image.
g2d.setColor(new Color(0, 0, 0, 0));
g2d.fillRect(0, 0, tileLayer.getWidth(), tileLayer.getHeight());
g2d.setBackground(new Color(0, 0, 0, 0));
g2d.setColor(new Color(1f, 1f, 1f, 1f));
for (int i = 0; i < numberOfTiles; i++) {
tile[i].draw(g2d, this);
}
return tileLayer;
}