@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); }
public void actionPerformed(ActionEvent e) { Object source = e.getSource(); if (source == cmbPaint) { paintType = (PaintType)cmbPaint.getSelectedItem(); } else if (source == cmbCycle) { cycleMethod = (CycleMethod)cmbCycle.getSelectedItem(); } else if (source == cmbSpace) { colorSpace = (ColorSpaceType)cmbSpace.getSelectedItem(); } else if (source == cmbShape) { shapeType = (ShapeType)cmbShape.getSelectedItem(); } else if (source == cmbXform) { xformType = (XformType)cmbXform.getSelectedItem(); } else if (source == cbAntialias) { antialiasHint = cbAntialias.isSelected() ? RenderingHints.VALUE_ANTIALIAS_ON : RenderingHints.VALUE_ANTIALIAS_OFF; } else if (source == cbRender) { renderHint = cbRender.isSelected() ? RenderingHints.VALUE_RENDER_QUALITY : RenderingHints.VALUE_RENDER_SPEED; } gradientPanel.updatePaint(); }
/** * SLOW LOOKUP METHOD * * This method calculates the gradient color values for each interval and * places each into its own 255 size array. The arrays are stored in * gradients[][]. (255 is used because this is the maximum number of * unique colors between 2 arbitrary colors in a 24 bit color system.) * * This method uses the minimum amount of space (only 255 * number of * intervals), but it aggravates the lookup procedure, because now we * have to find out which interval to select, then calculate the index * within that interval. This causes a significant performance hit, * because it requires this calculation be done for every point in * the rendering loop. * * For those of you who are interested, this is a classic example of the * time-space tradeoff. */ private void calculateMultipleArrayGradient(Color[] colors) { // set the flag so we know later it is a non-simple lookup isSimpleLookup = false; // 2 colors to interpolate int rgb1, rgb2; // for every interval (transition between 2 colors) for (int i = 0; i < gradients.length; i++){ // create an array of the maximum theoretical size for // each interval gradients[i] = new int[GRADIENT_SIZE]; // get the the 2 colors rgb1 = colors[i].getRGB(); rgb2 = colors[i+1].getRGB(); // fill this array with the colors in between rgb1 and rgb2 interpolate(rgb1, rgb2, gradients[i]); // if the colors are opaque, transparency should still // be 0xff000000 transparencyTest &= rgb1; transparencyTest &= rgb2; } // if interpolation occurred in Linear RGB space, convert the // gradients back to SRGB using the lookup table if (colorSpace == ColorSpaceType.LINEAR_RGB) { for (int j = 0; j < gradients.length; j++) { for (int i = 0; i < gradients[j].length; i++) { gradients[j][i] = convertEntireColorLinearRGBtoSRGB(gradients[j][i]); } } } }
@Override boolean isPaintValid(SunGraphics2D sg2d) { LinearGradientPaint paint = (LinearGradientPaint)sg2d.paint; if (paint.getFractions().length == 2 && paint.getCycleMethod() != CycleMethod.REPEAT && paint.getColorSpace() != ColorSpaceType.LINEAR_RGB) { // we can delegate to the optimized two-color gradient // codepath, which does not require fragment shader support return true; } return super.isPaintValid(sg2d); }
private void testOne(BufferedImage refImg, VolatileImage testImg) { Graphics2D gref = refImg.createGraphics(); Graphics2D gtest = testImg.createGraphics(); Paint paint = makePaint(PaintType.RADIAL, CycleMethod.REPEAT, ColorSpaceType.SRGB, XformType.IDENTITY, 7); Object aahint = hints[0]; renderTest(gref, paint, aahint); renderTest(gtest, paint, aahint); Toolkit.getDefaultToolkit().sync(); compareImages(refImg, testImg.getSnapshot(), TOLERANCE, 0, ""); gref.dispose(); gtest.dispose(); }
/** * SLOW LOOKUP METHOD * * This method calculates the gradient color values for each interval and * places each into its own 255 size array. The arrays are stored in * gradients[][]. (255 is used because this is the maximum number of * unique colors between 2 arbitrary colors in a 24 bit color system.) * * This method uses the minimum amount of space (only 255 * number of * intervals), but it aggravates the lookup procedure, because now we * have to find out which interval to select, then calculate the index * within that interval. This causes a significant performance hit, * because it requires this calculation be done for every point in * the rendering loop. * * For those of you who are interested, this is a classic example of the * time-space tradeoff. */ private void calculateMultipleArrayGradient(Color[] colors) { // set the flag so we know later it is a non-simple lookup isSimpleLookup = false; // 2 colors to interpolate int rgb1, rgb2; // for every interval (transition between 2 colors) for (int i = 0; i < gradients.length; i++){ // create an array of the maximum theoretical size for // each interval gradients[i] = new int[GRADIENT_SIZE]; // get the 2 colors rgb1 = colors[i].getRGB(); rgb2 = colors[i+1].getRGB(); // fill this array with the colors in between rgb1 and rgb2 interpolate(rgb1, rgb2, gradients[i]); // if the colors are opaque, transparency should still // be 0xff000000 transparencyTest &= rgb1; transparencyTest &= rgb2; } // if interpolation occurred in Linear RGB space, convert the // gradients back to SRGB using the lookup table if (colorSpace == ColorSpaceType.LINEAR_RGB) { for (int j = 0; j < gradients.length; j++) { for (int i = 0; i < gradients[j].length; i++) { gradients[j][i] = convertEntireColorLinearRGBtoSRGB(gradients[j][i]); } } } }
