public Class BufferedPaints

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.

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.

Color 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).

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.

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.