/*
* Copyright 2005-2006 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 sun.java2d.d3d;
import java.awt.AlphaComposite;
import java.awt.Composite;
import java.awt.GraphicsEnvironment;
import java.awt.geom.AffineTransform;
import sun.awt.Win32GraphicsDevice;
import sun.java2d.InvalidPipeException;
import sun.java2d.SurfaceData;
import sun.java2d.pipe.Region;
import sun.java2d.windows.WindowsFlags;
public class D3DContext {
public static final int NO_CONTEXT_FLAGS = 0;
/**
* Used in D3DBlitLoops: if the source surface is opaque
* alpha blending can be turned off on the native level
* (if there's no ea), thus improving performance.
*/
public static final int SRC_IS_OPAQUE = 1;
/**
* This is a list of capabilities supported by the device this
* context is associated with.
* @see getDeviceCaps
*/
public static final int J2D_D3D_FAILURE = (0 << 0);
/**
* Device supports depth buffer for d3d render targets
*/
public static final int J2D_D3D_DEPTH_SURFACE_OK = (1 << 0);
/**
* Device supports creation of plain d3d surfaces
*/
public static final int J2D_D3D_PLAIN_SURFACE_OK = (1 << 1);
/**
* Device supports creation of opaque textures
*/
public static final int J2D_D3D_OP_TEXTURE_SURFACE_OK = (1 << 2);
/**
* Device supports creation of bitmask textures
*/
public static final int J2D_D3D_BM_TEXTURE_SURFACE_OK = (1 << 3);
/**
* Device supports creation of translucent textures
*/
public static final int J2D_D3D_TR_TEXTURE_SURFACE_OK = (1 << 4);
/**
* Device supports creation of opaque render-to-textures
*/
public static final int J2D_D3D_OP_RTT_SURFACE_OK = (1 << 5);
/**
* Device can render lines correctly (no pixelization issues)
*/
public static final int J2D_D3D_LINES_OK = (1 << 6);
/**
* Device supports texture mapping (no pixelization issues)
*/
public static final int J2D_D3D_TEXTURE_BLIT_OK = (1 << 7);
/**
* Device supports texture mapping with transforms (no pixelization issues)
*/
public static final int J2D_D3D_TEXTURE_TRANSFORM_OK = (1 << 8);
/**
* Device can render clipped lines correctly.
*/
public static final int J2D_D3D_LINE_CLIPPING_OK = (1 << 9);
/**
* Device has all hw capabilities the d3d pipeline requires
*/
public static final int J2D_D3D_DEVICE_OK = (1 <<10);
/**
* Device supports all necessary texture formats required by d3d pipeline
*/
public static final int J2D_D3D_PIXEL_FORMATS_OK = (1 <<11);
/**
* Device supports geometry transformations
*/
public static final int J2D_D3D_SET_TRANSFORM_OK = (1 <<12);
/**
* The device is not from a list of known bad devices
* (see D3DRuntimeTest.cpp)
*/
public static final int J2D_D3D_HW_OK = (1 <<13);
/**
* Direct3D pipeline is enabled on this device
*/
public static final int J2D_D3D_ENABLED_OK = (1 <<14);
/**
* The lock object used to synchronize access to the native windowing
* system layer. Note that rendering methods should always synchronize on
* D3DContext.LOCK before calling the D3DContext.getContext() method,
* or any other method that invokes native D3d commands.
* REMIND: in D3D case we should really be synchronizing on per-device
* basis.
*/
static Object LOCK;
private Win32GraphicsDevice gd;
private boolean valid;
protected long nativeContext;
private SurfaceData validatedDstData;
private Region validatedClip;
private Composite validatedComp;
private int validatedPixel;
private int validatedFlags;
private boolean xformInUse;
// validated transform's data
private double vScaleX, vScaleY, vShearX, vShearY, vTransX, vTransY;
private int deviceCaps;
private native void setRenderTarget(long pCtx, long pDst);
private native void setClip(long pCtx, long pDst, Region clip, boolean isRect,
int x1, int y1, int x2, int y2);
private native void resetClip(long pCtx, long pDst);
private native void resetComposite(long pCtx);
private native void setAlphaComposite(long pCtx, int rule,
float extraAlpha, int flags);
private native void setTransform(long pCtx, long pDst,
AffineTransform xform,
double m00, double m10, double m01,
double m11, double m02, double m12);
private native void resetTransform(long pCtx, long pDst);
private native void setColor(long pCtx, int pixel, int flags);
private native long initNativeContext(int screen);
private native int getNativeDeviceCaps(long pCtx);
static {
if (!GraphicsEnvironment.isHeadless()) {
LOCK = D3DContext.class;
}
}
public D3DContext(Win32GraphicsDevice gd) {
this.gd = gd;
reinitNativeContext();
}
/**
* Reinitializes the context by retrieving a pointer to the native
* D3DContext object, and resetting the device caps.
*/
void reinitNativeContext() {
nativeContext = initNativeContext(gd.getScreen());
deviceCaps = nativeContext != 0L ?
getNativeDeviceCaps(nativeContext) : J2D_D3D_FAILURE;
valid = ((deviceCaps & J2D_D3D_ENABLED_OK) != 0);
if (WindowsFlags.isD3DVerbose()) {
if (valid) {
System.out.println("Direct3D pipeline enabled on screen " +
gd.getScreen());
} else {
System.out.println("Could not enable Direct3D pipeline on " +
"screen " + gd.getScreen() +
". Device Caps: " +
Integer.toHexString(deviceCaps));
}
}
}
/**
* Invalidates this context by resetting its status: the validated
* destination surface, and a pointer to the native context.
* This method is called in the following cases:
* - if a surface loss situation is detected at the native level
* during any of the validation methods (setClip, setRenderTarget etc)
* and an InvalidPipeException is thrown.
* This situation happens when there was a surface loss, but
* there were no display change event (like in case of command prompt
* going fullscreen).
* - as part of surface restoration when a surface is the current
* target surface for this context. Since surface restoration
* resets the depth buffer contents, we need to make sure the clip
* is reset, and since the target surface is reset, we'll set a new
* clip the next time we attempt to render to the target surface.
* - when a display change occurs, the native D3DContext object is
* released and recreated as part of primary surface recreation.
* At the time of the release, the java D3DContext object need to be
* invalidated because a new D3D device is created and the target
* surface will need to be reset.
*
* Invalidation of the context causes its revalidation the next time
* someone tries to get the D3DContext for rendering or creating a new
* surface.
*
* @see #reinitNativeContext
*/
private void invalidateContext() {
valid = false;
nativeContext = 0L;
validatedDstData = null;
// We don't set deviceCaps to J2D_D3D_FAILURE here because
// it will prevent from creating d3d surfaces, which means that
// we'll never get a chance to continue using d3d after a single
// invalidation event (for example, a display change).
}
/**
* Fetches the D3DContext associated with the current
* thread/GraphicsConfig pair, validates the context using the given
* parameters, then returns the handle to the native context object.
* Most rendering operations will call this method first in order to
* prepare the native D3d layer before issuing rendering commands.
*/
static long getContext(SurfaceData srcData,
SurfaceData dstData,
Region clip, Composite comp,
AffineTransform xform,
int pixel, int flags)
{
if (dstData instanceof D3DSurfaceData == false) {
throw new InvalidPipeException("Incorrect destination surface");
}
D3DContext d3dc = ((D3DSurfaceData)dstData).getContext();
try {
d3dc.validate(srcData, dstData, clip, comp, xform, pixel, flags);
} catch (InvalidPipeException e) {
d3dc.invalidateContext();
// note that we do not propagate the exception. Once the context
// is invalidated, any d3d rendering operations are noops, and
// we are waiting for the primary surface restoration, which
// happens when VolatileImage is validated. At this point
// the native D3DContext will be reinitialized, and the next
// time around validation of the context will succeed.
// Throwing the exception here will do no good, since the
// destination surface (which is associated with a VolatileImage
// or a BufferStrategy) will not be restored until VI.validate()
// is called by the rendering thread.
}
return d3dc.getNativeContext();
}
public int getDeviceCaps() {
return deviceCaps;
}
boolean isRTTSupported() {
return ((deviceCaps & J2D_D3D_OP_RTT_SURFACE_OK) != 0);
}
/**
* Returns a handle to the native D3DContext structure associated with
* this object.
*/
long getNativeContext() {
return nativeContext;
}
/**
* Validates the given parameters against the current state for this
* context. If this context is not current, it will be made current
* for the given source and destination surfaces, and the viewport will
* be updated. Then each part of the context state (clip, composite,
* etc.) is checked against the previous value. If the value has changed
* since the last call to validate(), it will be updated accordingly.
*/
private void validate(SurfaceData srcData, SurfaceData dstData,
Region clip, Composite comp, AffineTransform xform,
int pixel, int flags)
{
boolean updateClip = false;
if ((srcData != null && !srcData.isValid()) || !dstData.isValid() ||
dstData.getNativeOps() == 0L || dstData.isSurfaceLost())
{
throw new InvalidPipeException("Invalid surface");
}
if (!valid) {
// attempt to reinitialize the context. If the device has been
// reset, the following calls to setRenderTarget/setClip will
// succeed and not throw InvalidPipeException.
reinitNativeContext();
}
if (dstData != validatedDstData) {
// invalidate pixel and clip (so they will be updated below)
validatedPixel = ~pixel;
updateClip = true;
// update the viewport
long pDst = dstData.getNativeOps();
setRenderTarget(nativeContext, pDst);
// keep the reference to the old data until we set the
// new one on the native level, preventing it from being disposed
SurfaceData tmpData = dstData;
validatedDstData = dstData;
tmpData = null;
}
// it's better to use dstData instead of validatedDstData because
// the latter may be set to null via invalidateContext at any moment.
long pDest = dstData.getNativeOps();
// validate clip
if ((clip != validatedClip) || updateClip) {
if (clip != null) {
/**
* It's cheaper to make this check than set clip every time.
*
* Set the new clip only if:
* - we were asked to do it (updateClip == true)
* - no clip was set before
* - if both the old and the new clip are shapes
* - if they're both rectangular but don't represent
* the same rectangle
*/
if (updateClip ||
validatedClip == null ||
!(validatedClip.isRectangular() && clip.isRectangular()) ||
((clip.getLoX() != validatedClip.getLoX() ||
clip.getLoY() != validatedClip.getLoY() ||
clip.getHiX() != validatedClip.getHiX() ||
clip.getHiY() != validatedClip.getHiY())))
{
setClip(nativeContext, pDest,
clip, clip.isRectangular(),
clip.getLoX(), clip.getLoY(),
clip.getHiX(), clip.getHiY());
}
} else {
resetClip(nativeContext, pDest);
}
validatedClip = clip;
}
if ((comp != validatedComp) || (flags != validatedFlags)) {
// invalidate pixel
validatedPixel = ~pixel;
validatedComp = comp;
if (comp != null) {
AlphaComposite ac = (AlphaComposite)comp;
setAlphaComposite(nativeContext, ac.getRule(),
ac.getAlpha(), flags);
} else {
resetComposite(nativeContext);
}
}
// validate transform
if (xform == null) {
if (xformInUse) {
resetTransform(nativeContext, pDest);
xformInUse = false;
vScaleX = vScaleY = 1.0;
vShearX = vShearY = vTransX = vTransY = 0.0;
}
} else {
double nScaleX = xform.getScaleX();
double nScaleY = xform.getScaleY();
double nShearX = xform.getShearX();
double nShearY = xform.getShearY();
double nTransX = xform.getTranslateX();
double nTransY = xform.getTranslateY();
if (nTransX != vTransX || nTransY != vTransY ||
nScaleX != vScaleX || nScaleY != vScaleY ||
nShearX != vShearX || nShearY != vShearY)
{
setTransform(nativeContext, pDest,
xform,
nScaleX, nShearY, nShearX, nScaleY,
nTransX, nTransY);
vScaleX = nScaleX;
vScaleY = nScaleY;
vShearX = nShearX;
vShearY = nShearY;
vTransX = nTransY;
vTransY = nTransY;
xformInUse = true;
}
}
// validate pixel
if (pixel != validatedPixel) {
validatedPixel = pixel;
setColor(nativeContext, pixel, flags);
}
// save flags for later comparison
validatedFlags = flags;
// mark dstData dirty
dstData.markDirty();
}
}