JDK8/Java8源码在线阅读
/*
* Copyright (c) 2007, 2013, 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.pipe;
import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.LinearGradientPaint;
import java.awt.MultipleGradientPaint;
import java.awt.MultipleGradientPaint.ColorSpaceType;
import java.awt.MultipleGradientPaint.CycleMethod;
import java.awt.Paint;
import java.awt.RadialGradientPaint;
import java.awt.TexturePaint;
import java.awt.geom.AffineTransform;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import sun.awt.image.PixelConverter;
import sun.java2d.SunGraphics2D;
import sun.java2d.SurfaceData;
import sun.java2d.loops.CompositeType;
import sun.java2d.loops.SurfaceType;
import static sun.java2d.pipe.BufferedOpCodes.*;
import java.lang.annotation.Native;
public class BufferedPaints {
static void setPaint(RenderQueue rq, SunGraphics2D sg2d,
Paint paint, int ctxflags)
{
if (sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR) {
setColor(rq, sg2d.pixel);
} else {
boolean useMask = (ctxflags & BufferedContext.USE_MASK) != 0;
switch (sg2d.paintState) {
case SunGraphics2D.PAINT_GRADIENT:
setGradientPaint(rq, sg2d,
(GradientPaint)paint, useMask);
break;
case SunGraphics2D.PAINT_LIN_GRADIENT:
setLinearGradientPaint(rq, sg2d,
(LinearGradientPaint)paint, useMask);
break;
case SunGraphics2D.PAINT_RAD_GRADIENT:
setRadialGradientPaint(rq, sg2d,
(RadialGradientPaint)paint, useMask);
break;
case SunGraphics2D.PAINT_TEXTURE:
setTexturePaint(rq, sg2d,
(TexturePaint)paint, useMask);
break;
default:
break;
}
}
}
static void resetPaint(RenderQueue rq) {
// assert rq.lock.isHeldByCurrentThread();
rq.ensureCapacity(4);
RenderBuffer buf = rq.getBuffer();
buf.putInt(RESET_PAINT);
}
/****************************** Color support *******************************/
private static void setColor(RenderQueue rq, int pixel) {
// assert rq.lock.isHeldByCurrentThread();
rq.ensureCapacity(8);
RenderBuffer buf = rq.getBuffer();
buf.putInt(SET_COLOR);
buf.putInt(pixel);
}
/************************* GradientPaint support ****************************/
/**
* Note: This code is factored out into a separate static method
* so that it can be shared by both the Gradient and LinearGradient
* implementations. LinearGradient uses this code (for the
* two-color sRGB case only) because it can be much faster than the
* equivalent implementation that uses fragment shaders.
*
* We use OpenGL's texture coordinate generator to automatically
* apply a smooth gradient (either cyclic or acyclic) to the geometry
* being rendered. This technique is almost identical to the one
* described in the comments for BufferedPaints.setTexturePaint(),
* except the calculations take place in one dimension instead of two.
* Instead of an anchor rectangle in the TexturePaint case, we use
* the vector between the two GradientPaint end points in our
* calculations. The generator uses a single plane equation that
* takes the (x,y) location (in device space) of the fragment being
* rendered to calculate a (u) texture coordinate for that fragment:
* u = Ax + By + Cz + Dw
*
* The gradient renderer uses a two-pixel 1D texture where the first
* pixel contains the first GradientPaint color, and the second pixel
* contains the second GradientPaint color. (Note that we use the
* GL_CLAMP_TO_EDGE wrapping mode for acyclic gradients so that we
* clamp the colors properly at the extremes.) The following diagram
* attempts to show the layout of the texture containing the two
* GradientPaint colors (C1 and C2):
*
* +-----------------+
* | C1 | C2 |
* | | |
* +-----------------+
* u=0 .25 .5 .75 1
*
* We calculate our plane equation constants (A,B,D) such that u=0.25
* corresponds to the first GradientPaint end point in user space and
* u=0.75 corresponds to the second end point. This is somewhat
* non-obvious, but since the gradient colors are generated by
* interpolating between C1 and C2, we want the pure color at the
* end points, and we will get the pure color only when u correlates
* to the center of a texel. The following chart shows the expected
* color for some sample values of u (where C' is the color halfway
* between C1 and C2):
*
* u value acyclic (GL_CLAMP) cyclic (GL_REPEAT)
* ------- ------------------ ------------------
* -0.25 C1 C2
* 0.0 C1 C'
* 0.25 C1 C1
* 0.5 C' C'
* 0.75 C2 C2
* 1.0 C2 C'
* 1.25 C2 C1
*
* Original inspiration for this technique came from UMD's Agile2D
* project (GradientManager.java).
*/
private static void setGradientPaint(RenderQueue rq, AffineTransform at,
Color c1, Color c2,
Point2D pt1, Point2D pt2,
boolean isCyclic, boolean useMask)
{
// convert gradient colors to IntArgbPre format
PixelConverter pc = PixelConverter.ArgbPre.instance;
int pixel1 = pc.rgbToPixel(c1.getRGB(), null);
int pixel2 = pc.rgbToPixel(c2.getRGB(), null);
// calculate plane equation constants
double x = pt1.getX();
double y = pt1.getY();
at.translate(x, y);
// now gradient point 1 is at the origin
x = pt2.getX() - x;
y = pt2.getY() - y;
double len = Math.sqrt(x * x + y * y);
at.rotate(x, y);
// now gradient point 2 is on the positive x-axis
at.scale(2*len, 1);
// now gradient point 2 is at (0.5, 0)
at.translate(-0.25, 0);
// now gradient point 1 is at (0.25, 0), point 2 is at (0.75, 0)
double p0, p1, p3;
try {
at.invert();
p0 = at.getScaleX();
p1 = at.getShearX();
p3 = at.getTranslateX();
} catch (java.awt.geom.NoninvertibleTransformException e) {
p0 = p1 = p3 = 0.0;
}
// assert rq.lock.isHeldByCurrentThread();
rq.ensureCapacityAndAlignment(44, 12);
RenderBuffer buf = rq.getBuffer();
buf.putInt(SET_GRADIENT_PAINT);
buf.putInt(useMask ? 1 : 0);
buf.putInt(isCyclic ? 1 : 0);
buf.putDouble(p0).putDouble(p1).putDouble(p3);
buf.putInt(pixel1).putInt(pixel2);
}
private static void setGradientPaint(RenderQueue rq,
SunGraphics2D sg2d,
GradientPaint paint,
boolean useMask)
{
setGradientPaint(rq, (AffineTransform)sg2d.transform.clone(),
paint.getColor1(), paint.getColor2(),
paint.getPoint1(), paint.getPoint2(),
paint.isCyclic(), useMask);
}
/************************** TexturePaint support ****************************/
/**
* We use OpenGL's texture coordinate generator to automatically
* map the TexturePaint image to the geometry being rendered. The
* generator uses two separate plane equations that take the (x,y)
* location (in device space) of the fragment being rendered to
* calculate (u,v) texture coordinates for that fragment:
* u = Ax + By + Cz + Dw
* v = Ex + Fy + Gz + Hw
*
* Since we use a 2D orthographic projection, we can assume that z=0
* and w=1 for any fragment. So we need to calculate appropriate
* values for the plane equation constants (A,B,D) and (E,F,H) such
* that {u,v}=0 for the top-left of the TexturePaint's anchor
* rectangle and {u,v}=1 for the bottom-right of the anchor rectangle.
* We can easily make the texture image repeat for {u,v} values
* outside the range [0,1] by specifying the GL_REPEAT texture wrap
* mode.
*
* Calculating the plane equation constants is surprisingly simple.
* We can think of it as an inverse matrix operation that takes
* device space coordinates and transforms them into user space
* coordinates that correspond to a location relative to the anchor
* rectangle. First, we translate and scale the current user space
* transform by applying the anchor rectangle bounds. We then take
* the inverse of this affine transform. The rows of the resulting
* inverse matrix correlate nicely to the plane equation constants
* we were seeking.
*/
private static void setTexturePaint(RenderQueue rq,
SunGraphics2D sg2d,
TexturePaint paint,
boolean useMask)
{
BufferedImage bi = paint.getImage();
SurfaceData dstData = sg2d.surfaceData;
SurfaceData srcData =
dstData.getSourceSurfaceData(bi, SunGraphics2D.TRANSFORM_ISIDENT,
CompositeType.SrcOver, null);
boolean filter =
(sg2d.interpolationType !=
AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
// calculate plane equation constants
AffineTransform at = (AffineTransform)sg2d.transform.clone();
Rectangle2D anchor = paint.getAnchorRect();
at.translate(anchor.getX(), anchor.getY());
at.scale(anchor.getWidth(), anchor.getHeight());
double xp0, xp1, xp3, yp0, yp1, yp3;
try {
at.invert();
xp0 = at.getScaleX();
xp1 = at.getShearX();
xp3 = at.getTranslateX();
yp0 = at.getShearY();
yp1 = at.getScaleY();
yp3 = at.getTranslateY();
} catch (java.awt.geom.NoninvertibleTransformException e) {
xp0 = xp1 = xp3 = yp0 = yp1 = yp3 = 0.0;
}
// assert rq.lock.isHeldByCurrentThread();
rq.ensureCapacityAndAlignment(68, 12);
RenderBuffer buf = rq.getBuffer();
buf.putInt(SET_TEXTURE_PAINT);
buf.putInt(useMask ? 1 : 0);
buf.putInt(filter ? 1 : 0);
buf.putLong(srcData.getNativeOps());
buf.putDouble(xp0).putDouble(xp1).putDouble(xp3);
buf.putDouble(yp0).putDouble(yp1).putDouble(yp3);
}
/****************** Shared MultipleGradientPaint support ********************/
/**
* The maximum number of gradient "stops" supported by our native
* fragment shader implementations.
*
* This value has been empirically determined and capped to allow
* our native shaders to run on all shader-level graphics hardware,
* even on the older, more limited GPUs. Even the oldest Nvidia
* hardware could handle 16, or even 32 fractions without any problem.
* But the first-generation boards from ATI would fall back into
* software mode (which is unusably slow) for values larger than 12;
* it appears that those boards do not have enough native registers
* to support the number of array accesses required by our gradient
* shaders. So for now we will cap this value at 12, but we can
* re-evaluate this in the future as hardware becomes more capable.
*/
@Native public static final int MULTI_MAX_FRACTIONS = 12;
/**
* Helper function to convert a color component in sRGB space to
* linear RGB space. Copied directly from the
* MultipleGradientPaintContext class.
*/
public static int convertSRGBtoLinearRGB(int color) {
float input, output;
input = color / 255.0f;
if (input <= 0.04045f) {
output = input / 12.92f;
} else {
output = (float)Math.pow((input + 0.055) / 1.055, 2.4);
}
return Math.round(output * 255.0f);
}
/**
* Helper function to convert a (non-premultiplied) Color in sRGB
* space to an IntArgbPre pixel value, optionally in linear RGB space.
* Based on the PixelConverter.ArgbPre.rgbToPixel() method.
*/
private static int colorToIntArgbPrePixel(Color c, boolean linear) {
int rgb = c.getRGB();
if (!linear && ((rgb >> 24) == -1)) {
return rgb;
}
int a = rgb >>> 24;
int r = (rgb >> 16) & 0xff;
int g = (rgb >> 8) & 0xff;
int b = (rgb ) & 0xff;
if (linear) {
r = convertSRGBtoLinearRGB(r);
g = convertSRGBtoLinearRGB(g);
b = convertSRGBtoLinearRGB(b);
}
int a2 = a + (a >> 7);
r = (r * a2) >> 8;
g = (g * a2) >> 8;
b = (b * a2) >> 8;
return ((a << 24) | (r << 16) | (g << 8) | (b));
}
/**
* Converts the given array of Color objects into an int array
* containing IntArgbPre pixel values. If the linear parameter
* is true, the Color values will be converted into a linear RGB
* color space before being returned.
*/
private static int[] convertToIntArgbPrePixels(Color[] colors,
boolean linear)
{
int[] pixels = new int[colors.length];
for (int i = 0; i < colors.length; i++) {
pixels[i] = colorToIntArgbPrePixel(colors[i], linear);
}
return pixels;
}
/********************** LinearGradientPaint support *************************/
/**
* This method uses techniques that are nearly identical to those
* employed in setGradientPaint() above. The primary difference
* is that at the native level we use a fragment shader to manually
* apply the plane equation constants to the current fragment position
* to calculate the gradient position in the range [0,1] (the native
* code for GradientPaint does the same, except that it uses OpenGL's
* automatic texture coordinate generation facilities).
*
* One other minor difference worth mentioning is that
* setGradientPaint() calculates the plane equation constants
* such that the gradient end points are positioned at 0.25 and 0.75
* (for reasons discussed in the comments for that method). In
* contrast, for LinearGradientPaint we setup the equation constants
* such that the gradient end points fall at 0.0 and 1.0. The
* reason for this difference is that in the fragment shader we
* have more control over how the gradient values are interpreted
* (depending on the paint's CycleMethod).
*/
private static void setLinearGradientPaint(RenderQueue rq,
SunGraphics2D sg2d,
LinearGradientPaint paint,
boolean useMask)
{
boolean linear =
(paint.getColorSpace() == ColorSpaceType.LINEAR_RGB);
Color[] colors = paint.getColors();
int numStops = colors.length;
Point2D pt1 = paint.getStartPoint();
Point2D pt2 = paint.getEndPoint();
AffineTransform at = paint.getTransform();
at.preConcatenate(sg2d.transform);
if (!linear && numStops == 2 &&
paint.getCycleMethod() != CycleMethod.REPEAT)
{
// delegate to the optimized two-color gradient codepath
boolean isCyclic =
(paint.getCycleMethod() != CycleMethod.NO_CYCLE);
setGradientPaint(rq, at,
colors[0], colors[1],
pt1, pt2,
isCyclic, useMask);
return;
}
int cycleMethod = paint.getCycleMethod().ordinal();
float[] fractions = paint.getFractions();
int[] pixels = convertToIntArgbPrePixels(colors, linear);
// calculate plane equation constants
double x = pt1.getX();
double y = pt1.getY();
at.translate(x, y);
// now gradient point 1 is at the origin
x = pt2.getX() - x;
y = pt2.getY() - y;
double len = Math.sqrt(x * x + y * y);
at.rotate(x, y);
// now gradient point 2 is on the positive x-axis
at.scale(len, 1);
// now gradient point 1 is at (0.0, 0), point 2 is at (1.0, 0)
float p0, p1, p3;
try {
at.invert();
p0 = (float)at.getScaleX();
p1 = (float)at.getShearX();
p3 = (float)at.getTranslateX();
} catch (java.awt.geom.NoninvertibleTransformException e) {
p0 = p1 = p3 = 0.0f;
}
// assert rq.lock.isHeldByCurrentThread();
rq.ensureCapacity(20 + 12 + (numStops*4*2));
RenderBuffer buf = rq.getBuffer();
buf.putInt(SET_LINEAR_GRADIENT_PAINT);
buf.putInt(useMask ? 1 : 0);
buf.putInt(linear ? 1 : 0);
buf.putInt(cycleMethod);
buf.putInt(numStops);
buf.putFloat(p0);
buf.putFloat(p1);
buf.putFloat(p3);
buf.put(fractions);
buf.put(pixels);
}
/********************** RadialGradientPaint support *************************/
/**
* This method calculates six m** values and a focusX value that
* are used by the native fragment shader. These techniques are
* based on a whitepaper by Daniel Rice on radial gradient performance
* (attached to the bug report for 6521533). One can refer to that
* document for the complete set of formulas and calculations, but
* the basic goal is to compose a transform that will convert an
* (x,y) position in device space into a "u" value that represents
* the relative distance to the gradient focus point. The resulting
* value can be used to look up the appropriate color by linearly
* interpolating between the two nearest colors in the gradient.
*/
private static void setRadialGradientPaint(RenderQueue rq,
SunGraphics2D sg2d,
RadialGradientPaint paint,
boolean useMask)
{
boolean linear =
/**代码未完, 请加载全部代码(NowJava.com).**/
关注时代Java
关注时代Java