--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/java.desktop/windows/classes/sun/java2d/d3d/D3DPaints.java Sun Aug 17 15:54:13 2014 +0100
@@ -0,0 +1,234 @@
+/*
+ * 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.LinearGradientPaint;
+import java.awt.MultipleGradientPaint;
+import java.awt.MultipleGradientPaint.ColorSpaceType;
+import java.awt.MultipleGradientPaint.CycleMethod;
+import java.awt.TexturePaint;
+import java.awt.image.BufferedImage;
+import java.util.HashMap;
+import java.util.Map;
+import java.lang.annotation.Native;
+import sun.java2d.SunGraphics2D;
+import sun.java2d.SurfaceData;
+import sun.java2d.loops.CompositeType;
+import static sun.java2d.d3d.D3DContext.D3DContextCaps.*;
+
+abstract class D3DPaints {
+
+ /**
+ * Holds all registered implementations, using the corresponding
+ * SunGraphics2D.PAINT_* constant as the hash key.
+ */
+ private static Map<Integer, D3DPaints> impls =
+ new HashMap<Integer, D3DPaints>(4, 1.0f);
+
+ static {
+ impls.put(SunGraphics2D.PAINT_GRADIENT, new Gradient());
+ impls.put(SunGraphics2D.PAINT_LIN_GRADIENT, new LinearGradient());
+ impls.put(SunGraphics2D.PAINT_RAD_GRADIENT, new RadialGradient());
+ impls.put(SunGraphics2D.PAINT_TEXTURE, new Texture());
+ }
+
+ /**
+ * Attempts to locate an implementation corresponding to the paint state
+ * of the provided SunGraphics2D object. If no implementation can be
+ * found, or if the paint cannot be accelerated under the conditions
+ * of the SunGraphics2D, this method returns false; otherwise, returns
+ * true.
+ */
+ static boolean isValid(SunGraphics2D sg2d) {
+ D3DPaints impl = impls.get(sg2d.paintState);
+ return (impl != null && impl.isPaintValid(sg2d));
+ }
+
+ /**
+ * Returns true if this implementation is able to accelerate the
+ * Paint object associated with, and under the conditions of, the
+ * provided SunGraphics2D instance; otherwise returns false.
+ */
+ abstract boolean isPaintValid(SunGraphics2D sg2d);
+
+/************************* GradientPaint support ****************************/
+
+ private static class Gradient extends D3DPaints {
+ private Gradient() {}
+
+ /**
+ * Returns true if the given GradientPaint instance can be
+ * used by the accelerated D3DPaints.Gradient implementation.
+ * A GradientPaint is considered valid only if the destination
+ * has support for fragment shaders.
+ */
+ @Override
+ boolean isPaintValid(SunGraphics2D sg2d) {
+ D3DSurfaceData dstData = (D3DSurfaceData)sg2d.surfaceData;
+ D3DGraphicsDevice gd = (D3DGraphicsDevice)
+ dstData.getDeviceConfiguration().getDevice();
+ return gd.isCapPresent(CAPS_LCD_SHADER);
+ }
+ }
+
+/************************** TexturePaint support ****************************/
+
+ private static class Texture extends D3DPaints {
+ private Texture() {}
+
+ /**
+ * Returns true if the given TexturePaint instance can be used by the
+ * accelerated BufferedPaints.Texture implementation.
+ *
+ * A TexturePaint is considered valid if the following conditions
+ * are met:
+ * - the texture image dimensions are power-of-two
+ * - the texture image can be (or is already) cached in a D3D
+ * texture object
+ */
+ @Override
+ public boolean isPaintValid(SunGraphics2D sg2d) {
+ TexturePaint paint = (TexturePaint)sg2d.paint;
+ D3DSurfaceData dstData = (D3DSurfaceData)sg2d.surfaceData;
+ BufferedImage bi = paint.getImage();
+
+ // verify that the texture image dimensions are pow2
+ D3DGraphicsDevice gd =
+ (D3DGraphicsDevice)dstData.getDeviceConfiguration().getDevice();
+ int imgw = bi.getWidth();
+ int imgh = bi.getHeight();
+ if (!gd.isCapPresent(CAPS_TEXNONPOW2)) {
+ if ((imgw & (imgw - 1)) != 0 || (imgh & (imgh - 1)) != 0) {
+ return false;
+ }
+ }
+ // verify that the texture image is square if it has to be
+ if (!gd.isCapPresent(CAPS_TEXNONSQUARE) && imgw != imgh)
+ {
+ return false;
+ }
+
+ SurfaceData srcData =
+ dstData.getSourceSurfaceData(bi, SunGraphics2D.TRANSFORM_ISIDENT,
+ CompositeType.SrcOver, null);
+ if (!(srcData instanceof D3DSurfaceData)) {
+ // REMIND: this is a hack that attempts to cache the system
+ // memory image from the TexturePaint instance into a
+ // D3D texture...
+ srcData =
+ dstData.getSourceSurfaceData(bi, SunGraphics2D.TRANSFORM_ISIDENT,
+ CompositeType.SrcOver, null);
+ if (!(srcData instanceof D3DSurfaceData)) {
+ return false;
+ }
+ }
+
+ // verify that the source surface is actually a texture
+ D3DSurfaceData d3dData = (D3DSurfaceData)srcData;
+ if (d3dData.getType() != D3DSurfaceData.TEXTURE) {
+ return false;
+ }
+
+ return true;
+ }
+ }
+
+/****************** Shared MultipleGradientPaint support ********************/
+
+ private static abstract class MultiGradient extends D3DPaints {
+
+ /**
+ * Note that this number is lower than the MULTI_MAX_FRACTIONS
+ * defined in the superclass. The D3D pipeline now uses a
+ * slightly more complicated shader (to avoid the gradient banding
+ * issues), which has a higher instruction count. To ensure that
+ * all versions of the shader can be compiled for PS 2.0 hardware,
+ * we need to cap this maximum value at 8.
+ */
+ @Native public static final int MULTI_MAX_FRACTIONS_D3D = 8;
+
+ protected MultiGradient() {}
+
+ /**
+ * Returns true if the given MultipleGradientPaint instance can be
+ * used by the accelerated D3DPaints.MultiGradient implementation.
+ * A MultipleGradientPaint is considered valid if the following
+ * conditions are met:
+ * - the number of gradient "stops" is <= MAX_FRACTIONS
+ * - the destination has support for fragment shaders
+ */
+ @Override
+ boolean isPaintValid(SunGraphics2D sg2d) {
+ MultipleGradientPaint paint = (MultipleGradientPaint)sg2d.paint;
+ // REMIND: ugh, this creates garbage; would be nicer if
+ // we had a MultipleGradientPaint.getNumStops() method...
+ if (paint.getFractions().length > MULTI_MAX_FRACTIONS_D3D) {
+ return false;
+ }
+
+ D3DSurfaceData dstData = (D3DSurfaceData)sg2d.surfaceData;
+ D3DGraphicsDevice gd = (D3DGraphicsDevice)
+ dstData.getDeviceConfiguration().getDevice();
+ if (!gd.isCapPresent(CAPS_LCD_SHADER)) {
+ return false;
+ }
+ return true;
+ }
+ }
+
+/********************** LinearGradientPaint support *************************/
+
+ private static class LinearGradient extends MultiGradient {
+ private LinearGradient() {}
+
+ @Override
+ boolean isPaintValid(SunGraphics2D sg2d) {
+ LinearGradientPaint paint = (LinearGradientPaint)sg2d.paint;
+
+ if (paint.getFractions().length == 2 &&
+ paint.getCycleMethod() != CycleMethod.REPEAT &&
+ paint.getColorSpace() != ColorSpaceType.LINEAR_RGB)
+ {
+ D3DSurfaceData dstData = (D3DSurfaceData)sg2d.surfaceData;
+ D3DGraphicsDevice gd = (D3DGraphicsDevice)
+ dstData.getDeviceConfiguration().getDevice();
+ if (gd.isCapPresent(CAPS_LCD_SHADER)) {
+ // we can delegate to the optimized two-color gradient
+ // codepath, which should be faster
+ return true;
+ }
+ }
+
+ return super.isPaintValid(sg2d);
+ }
+ }
+
+/********************** RadialGradientPaint support *************************/
+
+ private static class RadialGradient extends MultiGradient {
+ private RadialGradient() {}
+ }
+}