/*
* Copyright 2005-2007 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.GraphicsConfiguration;
import java.awt.Image;
import java.awt.Transparency;
import java.awt.image.ColorModel;
import java.awt.image.DirectColorModel;
import sun.awt.SunHints;
import sun.awt.Win32GraphicsConfig;
import sun.awt.Win32GraphicsDevice;
import sun.awt.image.SurfaceManager;
import sun.java2d.InvalidPipeException;
import sun.java2d.SunGraphics2D;
import sun.java2d.SurfaceData;
import sun.java2d.SurfaceDataProxy;
import sun.java2d.loops.GraphicsPrimitive;
import sun.java2d.loops.SurfaceType;
import sun.java2d.pipe.PixelToShapeConverter;
import sun.java2d.pipe.TextPipe;
import sun.java2d.windows.Win32OffScreenSurfaceData;
import sun.java2d.windows.Win32SurfaceData;
import sun.java2d.windows.WinVolatileSurfaceManager;
import sun.java2d.windows.WindowsFlags;
import static sun.java2d.windows.Win32SurfaceData.*;
public class D3DSurfaceData extends Win32OffScreenSurfaceData {
// properties of a surface
/**
* This property is used for a back-buffer surface
*/
public static final int D3D_ATTACHED_SURFACE = (1 << 15);
/**
* A surface with this property can be used as a Direct3D rendering
* destination.
*/
public static final int D3D_RENDER_TARGET = (1 << 16);
public static final int
D3D_INVALID_SURFACE = 0;
/**
* Surface is a Direct3D plain surface (not a texture).
* Plain surface can be used as render target.
* VolatileImages typically use plain surfaces as their hardware
* accelerated surfaces.
*/
public static final int
D3D_PLAIN_SURFACE = (1 << 0) | D3D_RENDER_TARGET;
/**
* Direct3D texture. Mostly used for cached accelerated surfaces.
* Surfaces of this type can be copied from using hardware acceleration
* by using texture mapping.
*/
public static final int
D3D_TEXTURE_SURFACE = (1 << 1);
/**
* Direct3D Backbuffer surface - an attached surface. Used for
* multibuffered BufferStrategies.
*/
public static final int
D3D_BACKBUFFER_SURFACE = D3D_PLAIN_SURFACE | D3D_ATTACHED_SURFACE;
/**
* Render-to-texture. A texture which can also be a render target.
* Combines the benefits of textures (fast copies-from) and
* backbuffers or plain surfaces (hw-accelerated rendering to the surface)
*/
public static final int
D3D_RTT_SURFACE = D3D_TEXTURE_SURFACE | D3D_RENDER_TARGET;
// supported texture pixel formats
public static final int PF_INVALID = 0;
public static final int PF_INT_ARGB = 1;
public static final int PF_INT_RGB = 2;
public static final int PF_INT_RGBX = 3;
public static final int PF_INT_BGR = 4;
public static final int PF_USHORT_565_RGB = 5;
public static final int PF_USHORT_555_RGB = 6;
public static final int PF_USHORT_555_RGBX = 7;
public static final int PF_INT_ARGB_PRE = 8;
public static final int PF_USHORT_4444_ARGB= 9;
public static final String
DESC_INT_ARGB_D3D = "Integer ARGB D3D with translucency";
public static final String
DESC_USHORT_4444_ARGB_D3D = "UShort 4444 ARGB D3D with translucency";
/**
* Surface type for texture destination. We cannot render textures to
* the screen because Direct3D is not clipped by the window's clip list,
* so we only enable the texture blit loops for copies to offscreen
* accelerated surfaces.
*/
public static final String
DESC_DEST_D3D = "D3D render target";
public static final SurfaceType D3DSurface =
SurfaceType.Any.deriveSubType("Direct3D Surface");
public static final SurfaceType D3DTexture =
D3DSurface.deriveSubType("Direct3D Texture");
/**
* D3D destination surface types (derive from offscreen dd surfaces).
* Note that all of these surfaces have the same surface description;
* we do not care about the depth of the surface since texture ops
* support multiple depths.
*/
public static final SurfaceType IntRgbD3D =
IntRgbDD.deriveSubType(DESC_DEST_D3D);
public static final SurfaceType IntRgbxD3D =
IntRgbxDD.deriveSubType(DESC_DEST_D3D);
public static final SurfaceType Ushort565RgbD3D =
Ushort565RgbDD.deriveSubType(DESC_DEST_D3D);
public static final SurfaceType Ushort555RgbxD3D =
Ushort555RgbxDD.deriveSubType(DESC_DEST_D3D);
public static final SurfaceType Ushort555RgbD3D =
Ushort555RgbDD.deriveSubType(DESC_DEST_D3D);
// REMIND: Is it possible to have d3d accelerated on this type of surface?
public static final SurfaceType ThreeByteBgrD3D =
ThreeByteBgrDD.deriveSubType(DESC_DEST_D3D);
public static final SurfaceType IntArgbD3D =
SurfaceType.IntArgb.deriveSubType(DESC_INT_ARGB_D3D);
public static final SurfaceType Ushort4444ArgbD3D =
SurfaceType.Ushort4444Argb.deriveSubType(DESC_USHORT_4444_ARGB_D3D);
// Textures we can render to using d3d
public static final SurfaceType IntRgbD3D_RTT =
IntRgbD3D.deriveSubType(DESC_DEST_D3D);
public static final SurfaceType IntRgbxD3D_RTT =
IntRgbxD3D.deriveSubType(DESC_DEST_D3D);
public static final SurfaceType Ushort565RgbD3D_RTT =
Ushort565RgbD3D.deriveSubType(DESC_DEST_D3D);
public static final SurfaceType Ushort555RgbxD3D_RTT =
Ushort555RgbxD3D.deriveSubType(DESC_DEST_D3D);
public static final SurfaceType Ushort555RgbD3D_RTT =
Ushort555RgbD3D.deriveSubType(DESC_DEST_D3D);
public static final SurfaceType Ushort4444ArgbD3D_RTT =
Ushort4444ArgbD3D.deriveSubType(DESC_DEST_D3D);
public static final SurfaceType IntArgbD3D_RTT =
IntArgbD3D.deriveSubType(DESC_DEST_D3D);
public static final SurfaceType ThreeByteBgrD3D_RTT =
ThreeByteBgrD3D.deriveSubType(DESC_DEST_D3D);
// the type of this surface - texture, plain, back-buffer
protected int type;
protected int pixelFormat;
private D3DContext d3dContext;
protected static D3DRenderer d3dPipe;
protected static PixelToShapeConverter d3dTxPipe;
protected static D3DTextRenderer d3dTextPipe;
protected static D3DDrawImage d3dDrawImagePipe;
private native void initOps(int depth, int transparency);
static {
if (WindowsFlags.isD3DEnabled()) {
D3DBlitLoops.register();
D3DMaskFill.register();
}
d3dPipe = new D3DRenderer();
d3dTxPipe = new PixelToShapeConverter(d3dPipe);
d3dTextPipe = new D3DTextRenderer();
d3dDrawImagePipe = new D3DDrawImage();
if (GraphicsPrimitive.tracingEnabled()) {
d3dPipe = d3dPipe.traceWrapD3D();
d3dTextPipe = d3dTextPipe.traceWrap();
}
}
@Override
public SurfaceDataProxy makeProxyFor(SurfaceData srcData) {
//D3D may be eliminated soon so no Proxy was created for it...
//return D3DSurfaceDataProxy.createProxy(srcData, graphicsConfig);
return SurfaceDataProxy.UNCACHED;
}
/**
* Non-public constructor. Use createData() to create an object.
*
* This constructor is used to house the common construction
* code shared between the creation of D3DSurfaceData objects
* and subclasses of D3DSurfaceData (such as D3DBackBufferSD).
*
* It calls the common constructor in the parent, and then
* initializes other shared D3D data.
*/
protected D3DSurfaceData(int width, int height,
int d3dSurfaceType,
SurfaceType sType, ColorModel cm,
GraphicsConfiguration gc,
Image image, int transparency)
{
super(width, height, sType, cm, gc, image, transparency);
this.type = d3dSurfaceType;
}
/**
* Private constructor. Use createData() to create an object.
*
* This constructor calls the common constructor above and then
* performs the specific initialization of the D3DSurface.
*/
private D3DSurfaceData(int width, int height,
int d3dSurfaceType,
SurfaceType sType, ColorModel cm,
GraphicsConfiguration gc,
Image image, int transparency,
int screen)
{
this(width, height, d3dSurfaceType, sType, cm, gc, image, transparency);
pixelFormat = initSurface(width, height, screen,
null /*parent SurfaceData*/);
}
public static D3DSurfaceData createData(int width, int height,
int d3dSurfaceType,
ColorModel cm,
GraphicsConfiguration gc,
Image image)
{
Win32GraphicsDevice gd = (Win32GraphicsDevice)gc.getDevice();
// After a display change ddInstance may not be
// recreated yet, and in this case isD3DEnabledOnDevice will
// return false, until someone attempted to recreate the
// primary.
if (!gd.isD3DEnabledOnDevice()) {
return null;
}
return new D3DSurfaceData(width, height,
d3dSurfaceType,
getSurfaceType(gc, cm, d3dSurfaceType),
cm, gc, image,
cm.getTransparency(), gd.getScreen());
}
int getPixelFormat() {
return pixelFormat;
}
static SurfaceType getSurfaceType(GraphicsConfiguration gc,
ColorModel cm,
int d3dSurfaceType)
{
if (d3dSurfaceType == D3D_TEXTURE_SURFACE) {
// for non-rtt textures we have only one surface type
return D3DTexture;
} else {
int pixelSize = cm.getPixelSize();
Win32GraphicsDevice gd = (Win32GraphicsDevice)gc.getDevice();
int transparency = cm.getTransparency();
// We'll attempt to use render-to-texture if render target is
// requested, but it's not a back-buffer and we support RTT
// for this configuration.
boolean useRTT =
((d3dSurfaceType & D3D_RENDER_TARGET) != 0) &&
((d3dSurfaceType & D3D_BACKBUFFER_SURFACE) == 0) &&
gd.getD3DContext().isRTTSupported();
// if there's no RTT available, we can't accelerate non-opaque
// surfaces, so we return null.
if (transparency == Transparency.TRANSLUCENT ||
transparency == Transparency.BITMASK)
{
if (pixelSize == 16) {
return useRTT ? Ushort4444ArgbD3D_RTT :
null/*Ushort4444ArgbD3D*/;
} else {
return useRTT ? IntArgbD3D_RTT : null/*IntArgbD3D*/;
}
} else {
// it's an opaque surface, either a VI or a back-buffer
switch (pixelSize) {
case 32:
case 24:
if (cm instanceof DirectColorModel) {
if (((DirectColorModel)cm).getRedMask() == 0xff0000) {
return useRTT ? IntRgbD3D_RTT : IntRgbD3D;
} else {
return useRTT ? IntRgbxD3D_RTT : IntRgbxD3D;
}
} else {
return useRTT ? ThreeByteBgrD3D_RTT : ThreeByteBgrD3D;
}
case 15:
return useRTT ? Ushort555RgbD3D_RTT : Ushort555RgbD3D;
case 16:
if ((cm instanceof DirectColorModel) &&
(((DirectColorModel)cm).getBlueMask() == 0x3e))
{
return useRTT ? Ushort555RgbxD3D_RTT : Ushort555RgbxD3D;
} else {
return useRTT ? Ushort565RgbD3D_RTT : Ushort565RgbD3D;
}
case 8: // not supported
default:
throw new sun.java2d.InvalidPipeException("Unsupported bit " +
"depth: " +
cm.getPixelSize());
}
}
}
}
private native int initOffScreenSurface(long pCtx,
long pData, long parentPdata,
int width, int height,
int type, int screen);
protected int initSurface(int width, int height, int screen,
Win32SurfaceData parentData)
{
int pFormat = PF_INVALID;
synchronized (D3DContext.LOCK) {
long pData = getNativeOps();
long pDataParent = 0L;
if (parentData != null) {
pDataParent = parentData.getNativeOps();
}
D3DContext d3dContext = getContext();
long pCtx = d3dContext.getNativeContext();
// native context could be 0 if the context is currently invalid,
// so attempt to revalidate
if (pCtx == 0) {
d3dContext.reinitNativeContext();
pCtx = d3dContext.getNativeContext();
}
if (pData != 0 && pCtx != 0) {
pFormat = initOffScreenSurface(pCtx,
pData, pDataParent,
width, height, type, screen);
} else {
// if the context can't be restored, give up for now.
throw new InvalidPipeException("D3DSD.initSurface: pData " +
"or pCtx is null");
}
}
return pFormat;
}
@Override
public void validatePipe(SunGraphics2D sg2d) {
// we don't support COMP_XOR yet..
if (sg2d.compositeState < sg2d.COMP_XOR) {
TextPipe textpipe;
boolean validated = false;
if (((sg2d.compositeState <= sg2d.COMP_ISCOPY &&
sg2d.paintState <= sg2d.PAINT_ALPHACOLOR) ||
(sg2d.compositeState == sg2d.COMP_ALPHA &&
sg2d.paintState <= sg2d.PAINT_ALPHACOLOR &&
(((AlphaComposite)sg2d.composite).getRule() ==
AlphaComposite.SRC_OVER))) &&
sg2d.textAntialiasHint <= SunHints.INTVAL_TEXT_ANTIALIAS_GASP)
{
// D3DTextRenderer handles both AA and non-AA text, but
// only works if composite is SrcNoEa or SrcOver
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;
}
if (sg2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON &&
sg2d.paintState <= sg2d.PAINT_ALPHACOLOR)
{
sg2d.drawpipe =
sg2d.strokeState == sg2d.STROKE_THIN ? d3dPipe : d3dTxPipe;
sg2d.fillpipe = d3dPipe;
sg2d.shapepipe = d3dPipe;
} else if (!validated) {
super.validatePipe(sg2d);
}
// install the text pipe based on our earlier decision
sg2d.textpipe = textpipe;
} else {
super.validatePipe(sg2d);
}
// always override the image pipe with the specialized D3D pipe
sg2d.imagepipe = d3dDrawImagePipe;
}
/**
* Disables D3D acceleration on the surface manager of this surfaceData
* object. This can happen when we encounter a hard error in rendering a D3D
* primitive (for example, if we were unable to set a surface as D3D target
* surface).
* Upon next validation the SurfaceManager will create a non-D3D surface.
*/
public void disableD3D() {
markSurfaceLost();
SurfaceManager sMgr = SurfaceManager.getManager(image);
if (sMgr instanceof WinVolatileSurfaceManager) {
((WinVolatileSurfaceManager)sMgr).setD3DAccelerationEnabled(false);
}
}
@Override
public boolean surfacePunted() {
// Punting is disabled for D3D surfaces
return false;
}
D3DContext getContext() {
return ((Win32GraphicsDevice)graphicsConfig.getDevice()).getD3DContext();
}
}