1 files changed, 233 insertions, 0 deletions
diff --git a/src/windows/classes/sun/java2d/d3d/D3DPaints.java b/src/windows/classes/sun/java2d/d3d/D3DPaints.java
new file mode 100644
index 000000000..a112ffcc4
--- /dev/null
+++ b/src/windows/classes/sun/java2d/d3d/D3DPaints.java
@@ -0,0 +1,233 @@
+/*
+ * Copyright 2007-2008 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.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 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, sg2d.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, sg2d.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.
+         */
+        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() {}
+    }
+}