/* * Copyright (c) 2007, 2014, Oracle and/or its affiliates. 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. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package sun.java2d.d3d; import java.awt.AlphaComposite; import java.awt.BufferCapabilities; import java.awt.Component; import java.awt.GraphicsConfiguration; import java.awt.GraphicsDevice; import java.awt.GraphicsEnvironment; import java.awt.Image; import java.awt.Rectangle; import java.awt.Transparency; import java.awt.image.ColorModel; import java.awt.image.DataBuffer; import java.awt.image.DirectColorModel; import java.awt.image.Raster; import java.awt.image.SampleModel; import java.awt.image.SinglePixelPackedSampleModel; import sun.awt.SunHints; import sun.awt.image.DataBufferNative; import sun.awt.image.PixelConverter; import sun.awt.image.SurfaceManager; import sun.awt.image.WritableRasterNative; import sun.awt.windows.WComponentPeer; import sun.java2d.pipe.hw.AccelSurface; import sun.java2d.InvalidPipeException; import sun.java2d.SunGraphics2D; import sun.java2d.SurfaceData; import sun.java2d.loops.GraphicsPrimitive; import sun.java2d.loops.MaskFill; import sun.java2d.loops.SurfaceType; import sun.java2d.loops.CompositeType; import sun.java2d.pipe.ParallelogramPipe; import sun.java2d.pipe.PixelToParallelogramConverter; import sun.java2d.pipe.RenderBuffer; import sun.java2d.pipe.TextPipe; import static sun.java2d.pipe.BufferedOpCodes.*; import static sun.java2d.d3d.D3DContext.D3DContextCaps.*; import static sun.java2d.pipe.hw.ExtendedBufferCapabilities.VSyncType.*; import sun.java2d.pipe.hw.ExtendedBufferCapabilities.VSyncType; import java.awt.BufferCapabilities.FlipContents; import java.awt.Dimension; import java.awt.Window; import java.awt.geom.AffineTransform; import sun.awt.SunToolkit; import sun.awt.image.SunVolatileImage; import sun.awt.windows.WWindowPeer; import sun.java2d.ScreenUpdateManager; import sun.java2d.StateTracker; import sun.java2d.SurfaceDataProxy; import sun.java2d.pipe.hw.ExtendedBufferCapabilities; /** * This class describes a D3D "surface", that is, a region of pixels * managed via D3D. An D3DSurfaceData can be tagged with one of three * different SurfaceType objects for the purpose of registering loops, etc. * This diagram shows the hierarchy of D3D SurfaceTypes: * * Any * / \ * D3DSurface D3DTexture * | * D3DSurfaceRTT * * D3DSurface * This kind of surface can be rendered to using D3D APIs. It is also * possible to copy a D3DSurface to another D3DSurface (or to itself). * * D3DTexture * This kind of surface cannot be rendered to using D3D (in the same sense * as in D3DSurface). However, it is possible to upload a region of pixels * to a D3DTexture object via Lock/UnlockRect(). One can also copy a * surface of type D3DTexture to a D3DSurface by binding the texture * to a quad and then rendering it to the destination surface (this process * is known as "texture mapping"). * * D3DSurfaceRTT * This kind of surface can be thought of as a sort of hybrid between * D3DSurface and D3DTexture, in that one can render to this kind of * surface as if it were of type D3DSurface, but the process of copying * this kind of surface to another is more like a D3DTexture. (Note that * "RTT" stands for "render-to-texture".) * * In addition to these SurfaceType variants, we have also defined some * constants that describe in more detail the type of underlying D3D * surface. This table helps explain the relationships between those * "type" constants and their corresponding SurfaceType: * * D3D Type Corresponding SurfaceType * -------- ------------------------- * RT_PLAIN D3DSurface * TEXTURE D3DTexture * FLIP_BACKBUFFER D3DSurface * RT_TEXTURE D3DSurfaceRTT */ public class D3DSurfaceData extends SurfaceData implements AccelSurface { /** * To be used with getNativeResource() only. * @see #getNativeResource */ public static final int D3D_DEVICE_RESOURCE= 100; /* * Surface types. * We use these surface types when copying from a sw surface * to a surface or texture. */ public static final int ST_INT_ARGB = 0; public static final int ST_INT_ARGB_PRE = 1; public static final int ST_INT_ARGB_BM = 2; public static final int ST_INT_RGB = 3; public static final int ST_INT_BGR = 4; public static final int ST_USHORT_565_RGB = 5; public static final int ST_USHORT_555_RGB = 6; public static final int ST_BYTE_INDEXED = 7; public static final int ST_BYTE_INDEXED_BM = 8; public static final int ST_3BYTE_BGR = 9; /** Equals to D3DSWAPEFFECT_DISCARD */ public static final int SWAP_DISCARD = 1; /** Equals to D3DSWAPEFFECT_FLIP */ public static final int SWAP_FLIP = 2; /** Equals to D3DSWAPEFFECT_COPY */ public static final int SWAP_COPY = 3; /* * SurfaceTypes */ private static final String DESC_D3D_SURFACE = "D3D Surface"; private static final String DESC_D3D_SURFACE_RTT = "D3D Surface (render-to-texture)"; private static final String DESC_D3D_TEXTURE = "D3D Texture"; // REMIND: regarding ArgbPre?? static final SurfaceType D3DSurface = SurfaceType.Any.deriveSubType(DESC_D3D_SURFACE, PixelConverter.ArgbPre.instance); static final SurfaceType D3DSurfaceRTT = D3DSurface.deriveSubType(DESC_D3D_SURFACE_RTT); static final SurfaceType D3DTexture = SurfaceType.Any.deriveSubType(DESC_D3D_TEXTURE); private int type; private int width, height; private final double scaleX; private final double scaleY; // these fields are set from the native code when the surface is // initialized private int nativeWidth, nativeHeight; protected WComponentPeer peer; private Image offscreenImage; protected D3DGraphicsDevice graphicsDevice; private int swapEffect; private VSyncType syncType; private int backBuffersNum; private WritableRasterNative wrn; protected static D3DRenderer d3dRenderPipe; protected static PixelToParallelogramConverter d3dTxRenderPipe; protected static ParallelogramPipe d3dAAPgramPipe; protected static D3DTextRenderer d3dTextPipe; protected static D3DDrawImage d3dImagePipe; private native boolean initTexture(long pData, boolean isRTT, boolean isOpaque); private native boolean initFlipBackbuffer(long pData, long pPeerData, int numbuffers, int swapEffect, int syncType); private native boolean initRTSurface(long pData, boolean isOpaque); private native void initOps(int screen, int width, int height); static { D3DRenderQueue rq = D3DRenderQueue.getInstance(); d3dImagePipe = new D3DDrawImage(); d3dTextPipe = new D3DTextRenderer(rq); d3dRenderPipe = new D3DRenderer(rq); if (GraphicsPrimitive.tracingEnabled()) { d3dTextPipe = d3dTextPipe.traceWrap(); d3dRenderPipe = d3dRenderPipe.traceWrap(); //The wrapped d3dRenderPipe will wrap the AA pipe as well... //d3dAAPgramPipe = d3dRenderPipe.traceWrap(); } d3dAAPgramPipe = d3dRenderPipe.getAAParallelogramPipe(); d3dTxRenderPipe = new PixelToParallelogramConverter(d3dRenderPipe, d3dRenderPipe, 1.0, 0.25, true); D3DBlitLoops.register(); D3DMaskFill.register(); D3DMaskBlit.register(); } protected D3DSurfaceData(WComponentPeer peer, D3DGraphicsConfig gc, int width, int height, Image image, ColorModel cm, int numBackBuffers, int swapEffect, VSyncType vSyncType, int type) { super(getCustomSurfaceType(type), cm); this.graphicsDevice = gc.getD3DDevice(); this.scaleX = type == TEXTURE ? 1 : graphicsDevice.getDefaultScaleX(); this.scaleY = type == TEXTURE ? 1 : graphicsDevice.getDefaultScaleY(); this.peer = peer; this.type = type; if (scaleX == 1 && scaleY == 1) { this.width = width; this.height = height; } else if (peer instanceof WWindowPeer) { Dimension scaledSize = ((WWindowPeer) peer).getScaledWindowSize(); this.width = scaledSize.width; this.height = scaledSize.height; } else { this.width = (int) Math.ceil(width * scaleX); this.height = (int) Math.ceil(height * scaleY); } this.offscreenImage = image; this.backBuffersNum = numBackBuffers; this.swapEffect = swapEffect; this.syncType = vSyncType; initOps(graphicsDevice.getScreen(), this.width, this.height); if (type == WINDOW) { // we put the surface into the "lost" // state; it will be restored by the D3DScreenUpdateManager // prior to rendering to it for the first time. This is done // so that vram is not wasted for surfaces never rendered to setSurfaceLost(true); } else { initSurface(); } setBlitProxyKey(gc.getProxyKey()); } @Override public double getDefaultScaleX() { return scaleX; } @Override public double getDefaultScaleY() { return scaleY; } @Override public SurfaceDataProxy makeProxyFor(SurfaceData srcData) { return D3DSurfaceDataProxy. createProxy(srcData, (D3DGraphicsConfig)graphicsDevice.getDefaultConfiguration()); } /** * Creates a SurfaceData object representing the back buffer of a * double-buffered on-screen Window. */ public static D3DSurfaceData createData(WComponentPeer peer, Image image) { D3DGraphicsConfig gc = getGC(peer); if (gc == null || !peer.isAccelCapable()) { return null; } BufferCapabilities caps = peer.getBackBufferCaps(); VSyncType vSyncType = VSYNC_DEFAULT; if (caps instanceof ExtendedBufferCapabilities) { vSyncType = ((ExtendedBufferCapabilities)caps).getVSync(); } Rectangle r = peer.getBounds(); BufferCapabilities.FlipContents flip = caps.getFlipContents(); int swapEffect; if (flip == FlipContents.COPIED) { swapEffect = SWAP_COPY; } else if (flip == FlipContents.PRIOR) { swapEffect = SWAP_FLIP; } else { // flip == FlipContents.UNDEFINED || .BACKGROUND swapEffect = SWAP_DISCARD; } return new D3DSurfaceData(peer, gc, r.width, r.height, image, peer.getColorModel(), peer.getBackBuffersNum(), swapEffect, vSyncType, FLIP_BACKBUFFER); } /** * Returns a WINDOW type of surface - a * swap chain which serves as an on-screen surface, * handled by the D3DScreenUpdateManager. * * Note that the native surface is not initialized * when the surface is created to avoid using excessive * resources, and the surface is placed into the lost * state. It will be restored prior to any rendering * to it. * * @param peer peer for which the onscreen surface is to be created * @return a D3DWindowSurfaceData (flip chain) surface */ public static D3DSurfaceData createData(WComponentPeer peer) { D3DGraphicsConfig gc = getGC(peer); if (gc == null || !peer.isAccelCapable()) { return null; } return new D3DWindowSurfaceData(peer, gc); } /** * Creates a SurfaceData object representing an off-screen buffer (either * a plain surface or Texture). */ public static D3DSurfaceData createData(D3DGraphicsConfig gc, int width, int height, ColorModel cm, Image image, int type) { if (type == RT_TEXTURE) { boolean isOpaque = cm.getTransparency() == Transparency.OPAQUE; int cap = isOpaque ? CAPS_RT_TEXTURE_OPAQUE : CAPS_RT_TEXTURE_ALPHA; if (!gc.getD3DDevice().isCapPresent(cap)) { type = RT_PLAIN; } } D3DSurfaceData ret = null; try { ret = new D3DSurfaceData(null, gc, width, height, image, cm, 0, SWAP_DISCARD, VSYNC_DEFAULT, type); } catch (InvalidPipeException ipe) { // try again - we might have ran out of vram, and rt textures // could take up more than a plain surface, so it might succeed if (type == RT_TEXTURE) { // If a RT_TEXTURE was requested do not attempt to create a // plain surface. (note that RT_TEXTURE can only be requested // from a VI so the cast is safe) if (((SunVolatileImage)image).getForcedAccelSurfaceType() != RT_TEXTURE) { type = RT_PLAIN; ret = new D3DSurfaceData(null, gc, width, height, image, cm, 0, SWAP_DISCARD, VSYNC_DEFAULT, type); } } } return ret; } /** * Returns the appropriate SurfaceType corresponding to the given D3D * surface type constant (e.g. TEXTURE -> D3DTexture). */ private static SurfaceType getCustomSurfaceType(int d3dType) { switch (d3dType) { case TEXTURE: return D3DTexture; case RT_TEXTURE: return D3DSurfaceRTT; default: return D3DSurface; } } private boolean initSurfaceNow() { boolean isOpaque = (getTransparency() == Transparency.OPAQUE); switch (type) { case RT_PLAIN: return initRTSurface(getNativeOps(), isOpaque); case TEXTURE: return initTexture(getNativeOps(), false/*isRTT*/, isOpaque); case RT_TEXTURE: return initTexture(getNativeOps(), true/*isRTT*/, isOpaque); // REMIND: we may want to pass the exact type to the native // level here so that we could choose the right presentation // interval for the frontbuffer (immediate vs v-synced) case WINDOW: case FLIP_BACKBUFFER: return initFlipBackbuffer(getNativeOps(), peer.getData(), backBuffersNum, swapEffect, syncType.id()); default: return false; } } /** * Initializes the appropriate D3D offscreen surface based on the value * of the type parameter. If the surface creation fails for any reason, * an OutOfMemoryError will be thrown. */ protected void initSurface() { // any time we create or restore the surface, recreate the raster synchronized (this) { wrn = null; } // REMIND: somewhere a puppy died class Status { boolean success = false; }; final Status status = new Status(); D3DRenderQueue rq = D3DRenderQueue.getInstance(); rq.lock(); try { rq.flushAndInvokeNow(new Runnable() { public void run() { status.success = initSurfaceNow(); } }); if (!status.success) { throw new InvalidPipeException("Error creating D3DSurface"); } } finally { rq.unlock(); } } /** * Returns the D3DContext for the GraphicsConfig associated with this * surface. */ public final D3DContext getContext() { return graphicsDevice.getContext(); } /** * Returns one of the surface type constants defined above. */ public final int getType() { return type; } private static native int dbGetPixelNative(long pData, int x, int y); private static native void dbSetPixelNative(long pData, int x, int y, int pixel); static class D3DDataBufferNative extends DataBufferNative { int pixel; protected D3DDataBufferNative(SurfaceData sData, int type, int w, int h) { super(sData, type, w, h); } protected int getElem(final int x, final int y, final SurfaceData sData) { if (sData.isSurfaceLost()) { return 0; } int retPixel; D3DRenderQueue rq = D3DRenderQueue.getInstance(); rq.lock(); try { rq.flushAndInvokeNow(new Runnable() { public void run() { pixel = dbGetPixelNative(sData.getNativeOps(), x, y); } }); } finally { retPixel = pixel; rq.unlock(); } return retPixel; } protected void setElem(final int x, final int y, final int pixel, final SurfaceData sData) { if (sData.isSurfaceLost()) { return; } D3DRenderQueue rq = D3DRenderQueue.getInstance(); rq.lock(); try { rq.flushAndInvokeNow(new Runnable() { public void run() { dbSetPixelNative(sData.getNativeOps(), x, y, pixel); } }); sData.markDirty(); } finally { rq.unlock(); } } } public synchronized Raster getRaster(int x, int y, int w, int h) { if (wrn == null) { DirectColorModel dcm = (DirectColorModel)getColorModel(); SampleModel smHw; int dataType = 0; int scanStride = width; if (dcm.getPixelSize() > 16) { dataType = DataBuffer.TYPE_INT; } else { // 15, 16 dataType = DataBuffer.TYPE_USHORT; } // note that we have to use the surface width and height here, // not the passed w,h smHw = new SinglePixelPackedSampleModel(dataType, width, height, scanStride, dcm.getMasks()); DataBuffer dbn = new D3DDataBufferNative(this, dataType, width, height); wrn = WritableRasterNative.createNativeRaster(smHw, dbn); } return wrn; } /** * For now, we can only render LCD text if: * - the pixel shaders are available, and * - blending is disabled, and * - the source color is opaque * - and the destination is opaque */ public boolean canRenderLCDText(SunGraphics2D sg2d) { return graphicsDevice.isCapPresent(CAPS_LCD_SHADER) && sg2d.compositeState <= SunGraphics2D.COMP_ISCOPY && sg2d.paintState <= SunGraphics2D.PAINT_OPAQUECOLOR && sg2d.surfaceData.getTransparency() == Transparency.OPAQUE; } /** * If acceleration should no longer be used for this surface. * This implementation flags to the manager that it should no * longer attempt to re-create a D3DSurface. */ void disableAccelerationForSurface() { if (offscreenImage != null) { SurfaceManager sm = SurfaceManager.getManager(offscreenImage); if (sm instanceof D3DVolatileSurfaceManager) { setSurfaceLost(true); ((D3DVolatileSurfaceManager)sm).setAccelerationEnabled(false); } } } public void validatePipe(SunGraphics2D sg2d) { TextPipe textpipe; boolean validated = false; // REMIND: the D3D pipeline doesn't support XOR!, more // fixes will be needed below. For now we disable D3D rendering // for the surface which had any XOR rendering done to. if (sg2d.compositeState >= SunGraphics2D.COMP_XOR) { super.validatePipe(sg2d); sg2d.imagepipe = d3dImagePipe; disableAccelerationForSurface(); return; } // D3DTextRenderer handles both AA and non-AA text, but // only works with the following modes: // (Note: For LCD text we only enter this code path if // canRenderLCDText() has already validated that the mode is // CompositeType.SrcNoEa (opaque color), which will be subsumed // by the CompositeType.SrcNoEa (any color) test below.) if (/* CompositeType.SrcNoEa (any color) */ (sg2d.compositeState <= SunGraphics2D.COMP_ISCOPY && sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR) || /* CompositeType.SrcOver (any color) */ (sg2d.compositeState == SunGraphics2D.COMP_ALPHA && sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR && (((AlphaComposite)sg2d.composite).getRule() == AlphaComposite.SRC_OVER)) || /* CompositeType.Xor (any color) */ (sg2d.compositeState == SunGraphics2D.COMP_XOR && sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR)) { textpipe = d3dTextPipe; } else { // do this to initialize textpipe correctly; we will attempt // to override the non-text pipes below super.validatePipe(sg2d); textpipe = sg2d.textpipe; validated = true; } PixelToParallelogramConverter txPipe = null; D3DRenderer nonTxPipe = null; if (sg2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON) { if (sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR) { if (sg2d.compositeState <= SunGraphics2D.COMP_XOR) { txPipe = d3dTxRenderPipe; nonTxPipe = d3dRenderPipe; } } else if (sg2d.compositeState <= SunGraphics2D.COMP_ALPHA) { if (D3DPaints.isValid(sg2d)) { txPipe = d3dTxRenderPipe; nonTxPipe = d3dRenderPipe; } // custom paints handled by super.validatePipe() below } } else { if (sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR) { if (graphicsDevice.isCapPresent(CAPS_AA_SHADER) && (sg2d.imageComp == CompositeType.SrcOverNoEa || sg2d.imageComp == CompositeType.SrcOver)) { if (!validated) { super.validatePipe(sg2d); validated = true; } PixelToParallelogramConverter aaConverter = new PixelToParallelogramConverter(sg2d.shapepipe, d3dAAPgramPipe, 1.0/8.0, 0.499, false); sg2d.drawpipe = aaConverter; sg2d.fillpipe = aaConverter; sg2d.shapepipe = aaConverter; } else if (sg2d.compositeState == SunGraphics2D.COMP_XOR) { // install the solid pipes when AA and XOR are both enabled txPipe = d3dTxRenderPipe; nonTxPipe = d3dRenderPipe; } } // other cases handled by super.validatePipe() below } if (txPipe != null) { if (sg2d.transformState >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) { sg2d.drawpipe = txPipe; sg2d.fillpipe = txPipe; } else if (sg2d.strokeState != SunGraphics2D.STROKE_THIN) { sg2d.drawpipe = txPipe; sg2d.fillpipe = nonTxPipe; } else { sg2d.drawpipe = nonTxPipe; sg2d.fillpipe = nonTxPipe; } // Note that we use the transforming pipe here because it // will examine the shape and possibly perform an optimized // operation if it can be simplified. The simplifications // will be valid for all STROKE and TRANSFORM types. sg2d.shapepipe = txPipe; } else { if (!validated) { super.validatePipe(sg2d); } } // install the text pipe based on our earlier decision sg2d.textpipe = textpipe; // always override the image pipe with the specialized D3D pipe sg2d.imagepipe = d3dImagePipe; } @Override protected MaskFill getMaskFill(SunGraphics2D sg2d) { if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR) { /* * We can only accelerate non-Color MaskFill operations if * all of the following conditions hold true: * - there is an implementation for the given paintState * - the current Paint can be accelerated for this destination * - multitexturing is available (since we need to modulate * the alpha mask texture with the paint texture) * * In all other cases, we return null, in which case the * validation code will choose a more general software-based loop. */ if (!D3DPaints.isValid(sg2d) || !graphicsDevice.isCapPresent(CAPS_MULTITEXTURE)) { return null; } } return super.getMaskFill(sg2d); } @Override public boolean copyArea(SunGraphics2D sg2d, int x, int y, int w, int h, int dx, int dy) { if (sg2d.compositeState >= SunGraphics2D.COMP_XOR) { return false; } d3dRenderPipe.copyArea(sg2d, x, y, w, h, dx, dy); return true; } @Override public void flush() { D3DRenderQueue rq = D3DRenderQueue.getInstance(); rq.lock(); try { RenderBuffer buf = rq.getBuffer(); rq.ensureCapacityAndAlignment(12, 4); buf.putInt(FLUSH_SURFACE); buf.putLong(getNativeOps()); // this call is expected to complete synchronously, so flush now rq.flushNow(); } finally { rq.unlock(); } } /** * Disposes the native resources associated with the given D3DSurfaceData * (referenced by the pData parameter). This method is invoked from * the native Dispose() method from the Disposer thread when the * Java-level D3DSurfaceData object is about to go away. */ static void dispose(long pData) { D3DRenderQueue rq = D3DRenderQueue.getInstance(); rq.lock(); try { RenderBuffer buf = rq.getBuffer(); rq.ensureCapacityAndAlignment(12, 4); buf.putInt(DISPOSE_SURFACE); buf.putLong(pData); // this call is expected to complete synchronously, so flush now rq.flushNow(); } finally { rq.unlock(); } } static void swapBuffers(D3DSurfaceData sd, final int x1, final int y1, final int x2, final int y2) { long pData = sd.getNativeOps(); D3DRenderQueue rq = D3DRenderQueue.getInstance(); // swapBuffers can be called from the toolkit thread by swing, we // should detect this and prevent the deadlocks if (D3DRenderQueue.isRenderQueueThread()) { if (!rq.tryLock()) { // if we could not obtain the lock, repaint the area // that was supposed to be swapped, and no-op this swap final Component target = (Component)sd.getPeer().getTarget(); SunToolkit.executeOnEventHandlerThread(target, new Runnable() { public void run() { double scaleX = sd.getDefaultScaleX(); double scaleY = sd.getDefaultScaleY(); if (scaleX > 1 || scaleY > 1) { int sx1 = (int) Math.floor(x1 / scaleX); int sy1 = (int) Math.floor(y1 / scaleY); int sx2 = (int) Math.ceil(x2 / scaleX); int sy2 = (int) Math.ceil(y2 / scaleY); target.repaint(sx1, sy1, sx2 - sx1, sy2 - sy1); } else { target.repaint(x1, y1, x2 - x1, y2 - y1); } } }); return; } } else { rq.lock(); } try { RenderBuffer buf = rq.getBuffer(); rq.ensureCapacityAndAlignment(28, 4); buf.putInt(SWAP_BUFFERS); buf.putLong(pData); buf.putInt(x1); buf.putInt(y1); buf.putInt(x2); buf.putInt(y2); rq.flushNow(); } finally { rq.unlock(); } } /** * Returns destination Image associated with this SurfaceData. */ public Object getDestination() { return offscreenImage; } public Rectangle getBounds() { if (type == FLIP_BACKBUFFER || type == WINDOW) { double scaleX = getDefaultScaleX(); double scaleY = getDefaultScaleY(); Rectangle r = peer.getBounds(); r.x = r.y = 0; r.width = (int) Math.ceil(r.width * scaleX); r.height = (int) Math.ceil(r.height * scaleY); return r; } else { return new Rectangle(width, height); } } public Rectangle getNativeBounds() { D3DRenderQueue rq = D3DRenderQueue.getInstance(); // need to lock to make sure nativeWidth and Height are consistent // since they are set from the render thread from the native // level rq.lock(); try { // REMIND: use xyoffsets? return new Rectangle(nativeWidth, nativeHeight); } finally { rq.unlock(); } } public GraphicsConfiguration getDeviceConfiguration() { return graphicsDevice.getDefaultConfiguration(); } public SurfaceData getReplacement() { return restoreContents(offscreenImage); } private static D3DGraphicsConfig getGC(WComponentPeer peer) { GraphicsConfiguration gc; if (peer != null) { gc = peer.getGraphicsConfiguration(); } else { GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment(); GraphicsDevice gd = env.getDefaultScreenDevice(); gc = gd.getDefaultConfiguration(); } return (gc instanceof D3DGraphicsConfig) ? (D3DGraphicsConfig)gc : null; } /** * Attempts to restore the surface by initializing the native data */ void restoreSurface() { initSurface(); } WComponentPeer getPeer() { return peer; } /** * We need to let the surface manager know that the surface is lost so * that for example BufferStrategy.contentsLost() returns correct result. * Normally the status of contentsLost is set in validate(), but in some * cases (like Swing's buffer per window) we intentionally don't call * validate from the toolkit thread but only check for the BS status. */ @Override public void setSurfaceLost(boolean lost) { super.setSurfaceLost(lost); if (lost && offscreenImage != null) { SurfaceManager sm = SurfaceManager.getManager(offscreenImage); sm.acceleratedSurfaceLost(); } } private static native long getNativeResourceNative(long sdops, int resType); /** * Returns a pointer to the native resource of specified {@code resType} * associated with this surface. * * Specifically, for {@code D3DSurfaceData} this method returns pointers of * the following: * 
     * TEXTURE              - (IDirect3DTexture9*)
     * RT_TEXTURE, RT_PLAIN - (IDirect3DSurface9*)
     * FLIP_BACKBUFFER      - (IDirect3DSwapChain9*)
     * D3D_DEVICE_RESOURCE  - (IDirect3DDevice9*)
     *
* * Multiple resources may be available for some types (i.e. for render to * texture one could retrieve both a destination surface by specifying * RT_TEXTURE, and a texture by using TEXTURE). * * Note: the pointer returned by this method is only valid on the rendering * thread. * * @return pointer to the native resource of specified type or 0L if * such resource doesn't exist or can not be retrieved. * @see sun.java2d.pipe.hw.AccelSurface#getNativeResource */ public long getNativeResource(int resType) { return getNativeResourceNative(getNativeOps(), resType); } /** * Class representing an on-screen d3d surface. Since d3d can't * render to the screen directly, it is implemented as a swap chain, * controlled by D3DScreenUpdateManager. * * @see D3DScreenUpdateManager */ public static class D3DWindowSurfaceData extends D3DSurfaceData { StateTracker dirtyTracker; public D3DWindowSurfaceData(WComponentPeer peer, D3DGraphicsConfig gc) { super(peer, gc, peer.getBounds().width, peer.getBounds().height, null, peer.getColorModel(), 1, SWAP_COPY, VSYNC_DEFAULT, WINDOW); dirtyTracker = getStateTracker(); } /** * {@inheritDoc} * * Overridden to use ScreenUpdateManager to obtain the replacement * surface. * * @see sun.java2d.ScreenUpdateManager#getReplacementScreenSurface */ @Override public SurfaceData getReplacement() { ScreenUpdateManager mgr = ScreenUpdateManager.getInstance(); return mgr.getReplacementScreenSurface(peer, this); } /** * Returns destination Component associated with this SurfaceData. */ @Override public Object getDestination() { return peer.getTarget(); } @Override void disableAccelerationForSurface() { // for on-screen surfaces we need to make sure a backup GDI surface is // is used until a new one is set (which may happen during a resize). We // don't want the screen update maanger to replace the surface right way // because it causes repainting issues in Swing, so we invalidate it, // this will prevent SUM from issuing a replaceSurfaceData call. setSurfaceLost(true); invalidate(); flush(); peer.disableAcceleration(); ScreenUpdateManager.getInstance().dropScreenSurface(this); } @Override void restoreSurface() { if (!peer.isAccelCapable()) { throw new InvalidPipeException("Onscreen acceleration " + "disabled for this surface"); } Window fsw = graphicsDevice.getFullScreenWindow(); if (fsw != null && fsw != peer.getTarget()) { throw new InvalidPipeException("Can't restore onscreen surface"+ " when in full-screen mode"); } super.restoreSurface(); // if initialization was unsuccessful, an IPE will be thrown // and the surface will remain lost setSurfaceLost(false); // This is to make sure the render target is reset after this // surface is restored. The reason for this is that sometimes this // surface can be restored from multiple threads (the screen update // manager's thread and app's rendering thread) at the same time, // and when that happens the second restoration will create the // native resource which will not be set as render target because // the BufferedContext's validate method will think that since the // surface data object didn't change then the current render target // is correct and no rendering will appear on the screen. D3DRenderQueue rq = D3DRenderQueue.getInstance(); rq.lock(); try { getContext().invalidateContext(); } finally { rq.unlock(); } } public boolean isDirty() { return !dirtyTracker.isCurrent(); } public void markClean() { dirtyTracker = getStateTracker(); } } /** * Updates the layered window with the contents of the surface. * * @param pd3dsd pointer to the D3DSDOps structure * @param pData pointer to the AwtWindow peer data * @param w width of the window * @param h height of the window * @see sun.awt.windows.TranslucentWindowPainter */ public static native boolean updateWindowAccelImpl(long pd3dsd, long pData, int w, int h); }