/*

 * Copyright (c) 2007, 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.

 */

#ifndef HEADLESS

#include <jlong.h>

#include <string.h>

#include "sun_java2d_SunGraphics2D.h"

#include "sun_java2d_pipe_BufferedPaints.h"

#include "OGLPaints.h"

#include "OGLContext.h"

#include "OGLRenderQueue.h"

#include "OGLSurfaceData.h"

void

OGLPaints_ResetPaint(OGLContext *oglc)

{

    jubyte ea;

    J2dTraceLn(J2D_TRACE_INFO, "OGLPaints_ResetPaint");

    RETURN_IF_NULL(oglc);

    J2dTraceLn1(J2D_TRACE_VERBOSE, "  state=%d", oglc->paintState);

    RESET_PREVIOUS_OP();

    if (oglc->useMask) {

        // switch to texture unit 1, where paint state is currently enabled

        j2d_glActiveTextureARB(GL_TEXTURE1_ARB);

    }

    switch (oglc->paintState) {

    case sun_java2d_SunGraphics2D_PAINT_GRADIENT:

        j2d_glDisable(GL_TEXTURE_1D);

        j2d_glDisable(GL_TEXTURE_GEN_S);

        break;

    case sun_java2d_SunGraphics2D_PAINT_TEXTURE:

        // Note: The texture object used in SetTexturePaint() will

        // still be bound at this point, so it is safe to call the following.

        OGLSD_RESET_TEXTURE_WRAP(GL_TEXTURE_2D);

        j2d_glDisable(GL_TEXTURE_2D);

        j2d_glDisable(GL_TEXTURE_GEN_S);

        j2d_glDisable(GL_TEXTURE_GEN_T);

        break;

    case sun_java2d_SunGraphics2D_PAINT_LIN_GRADIENT:

    case sun_java2d_SunGraphics2D_PAINT_RAD_GRADIENT:

        j2d_glUseProgramObjectARB(0);

        j2d_glDisable(GL_TEXTURE_1D);

        break;

    case sun_java2d_SunGraphics2D_PAINT_ALPHACOLOR:

    default:

        break;

    }

    if (oglc->useMask) {

        // restore control to texture unit 0

        j2d_glActiveTextureARB(GL_TEXTURE0_ARB);

    }

    // set each component of the current color state to the extra alpha

    // value, which will effectively apply the extra alpha to each fragment

    // in paint/texturing operations

    ea = (jubyte)(oglc->extraAlpha * 0xff + 0.5f);

    j2d_glColor4ub(ea, ea, ea, ea);

    oglc->pixel = (ea << 24) | (ea << 16) | (ea << 8) | (ea << 0);

    oglc->r = ea;

    oglc->g = ea;

    oglc->b = ea;

    oglc->a = ea;

    oglc->useMask = JNI_FALSE;

    oglc->paintState = -1;

}

void

OGLPaints_SetColor(OGLContext *oglc, jint pixel)

{

    jubyte r, g, b, a;

    J2dTraceLn1(J2D_TRACE_INFO, "OGLPaints_SetColor: pixel=%08x", pixel);

    RETURN_IF_NULL(oglc);

    // glColor*() is allowed within glBegin()/glEnd() pairs, so

    // no need to reset the current op state here unless the paint

    // state really needs to be changed

    if (oglc->paintState > sun_java2d_SunGraphics2D_PAINT_ALPHACOLOR) {

        OGLPaints_ResetPaint(oglc);

    }

    // store the raw (unmodified) pixel value, which may be used for

    // special operations later

    oglc->pixel = pixel;

    if (oglc->compState != sun_java2d_SunGraphics2D_COMP_XOR) {

        r = (jubyte)(pixel >> 16);

        g = (jubyte)(pixel >>  8);

        b = (jubyte)(pixel >>  0);

        a = (jubyte)(pixel >> 24);

        J2dTraceLn4(J2D_TRACE_VERBOSE,

                    "  updating color: r=%02x g=%02x b=%02x a=%02x",

                    r, g, b, a);

    } else {

        pixel ^= oglc->xorPixel;

        r = (jubyte)(pixel >> 16);

        g = (jubyte)(pixel >>  8);

        b = (jubyte)(pixel >>  0);

        a = 0xff;

        J2dTraceLn4(J2D_TRACE_VERBOSE,

                    "  updating xor color: r=%02x g=%02x b=%02x xorpixel=%08x",

                    r, g, b, oglc->xorPixel);

    }

    j2d_glColor4ub(r, g, b, a);

    oglc->r = r;

    oglc->g = g;

    oglc->b = b;

    oglc->a = a;

    oglc->useMask = JNI_FALSE;

    oglc->paintState = sun_java2d_SunGraphics2D_PAINT_ALPHACOLOR;

}

/************************* GradientPaint support ****************************/

static GLuint gradientTexID = 0;

static void

{

    GLclampf priority = 1.0f;

    J2dTraceLn(J2D_TRACE_INFO, "OGLPaints_InitGradientTexture");

    j2d_glGenTextures(1, &gradientTexID);

    j2d_glBindTexture(GL_TEXTURE_1D, gradientTexID);

    j2d_glPrioritizeTextures(1, &gradientTexID, &priority);

    j2d_glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    j2d_glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    j2d_glTexImage1D(GL_TEXTURE_1D, 0,

                     GL_RGBA8, 2, 0,

                     GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);

}

void

OGLPaints_SetGradientPaint(OGLContext *oglc,

                           jboolean useMask, jboolean cyclic,

                           jdouble p0, jdouble p1, jdouble p3,

                           jint pixel1, jint pixel2)

{

    GLdouble texParams[4];

    GLuint pixels[2];

    J2dTraceLn(J2D_TRACE_INFO, "OGLPaints_SetGradientPaint");

    RETURN_IF_NULL(oglc);

    OGLPaints_ResetPaint(oglc);

    texParams[0] = p0;

    texParams[1] = p1;

    texParams[2] = 0.0;

    texParams[3] = p3;

    pixels[0] = pixel1;

    pixels[1] = pixel2;

    if (useMask) {

        // set up the paint on texture unit 1 (instead of the usual unit 0)

        j2d_glActiveTextureARB(GL_TEXTURE1_ARB);

        j2d_glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

    } else {

        // texture unit 0 is already active; we can use the helper macro here

        OGLC_UPDATE_TEXTURE_FUNCTION(oglc, GL_MODULATE);

    }

    if (gradientTexID == 0) {

        OGLPaints_InitGradientTexture();

    }

    j2d_glEnable(GL_TEXTURE_1D);

    j2d_glEnable(GL_TEXTURE_GEN_S);

    j2d_glBindTexture(GL_TEXTURE_1D, gradientTexID);

    j2d_glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S,

                        cyclic ? GL_REPEAT : GL_CLAMP_TO_EDGE);

    j2d_glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);

    j2d_glTexGendv(GL_S, GL_OBJECT_PLANE, texParams);

    j2d_glTexSubImage1D(GL_TEXTURE_1D, 0,

                        0, 2, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, pixels);

    if (useMask) {

        // restore control to texture unit 0

        j2d_glActiveTextureARB(GL_TEXTURE0_ARB);

    }

    // oglc->pixel has been set appropriately in OGLPaints_ResetPaint()

    oglc->useMask = useMask;

    oglc->paintState = sun_java2d_SunGraphics2D_PAINT_GRADIENT;

}

/************************** TexturePaint support ****************************/

void

OGLPaints_SetTexturePaint(OGLContext *oglc,

                          jboolean useMask,

                          jlong pSrcOps, jboolean filter,

                          jdouble xp0, jdouble xp1, jdouble xp3,

                          jdouble yp0, jdouble yp1, jdouble yp3)

{

    OGLSDOps *srcOps = (OGLSDOps *)jlong_to_ptr(pSrcOps);

    GLdouble xParams[4];

    GLdouble yParams[4];

    GLint hint = (filter ? GL_LINEAR : GL_NEAREST);

    J2dTraceLn(J2D_TRACE_INFO, "OGLPaints_SetTexturePaint");

    RETURN_IF_NULL(srcOps);

    RETURN_IF_NULL(oglc);

    OGLPaints_ResetPaint(oglc);

    xParams[0] = xp0;

    xParams[1] = xp1;

    xParams[2] = 0.0;

    xParams[3] = xp3;

    yParams[0] = yp0;

    yParams[1] = yp1;

    yParams[2] = 0.0;

    yParams[3] = yp3;

    /*

     * Note that we explicitly use GL_TEXTURE_2D below rather than using

     * srcOps->textureTarget.  This is because the texture wrap mode employed

     * here (GL_REPEAT) is not available for GL_TEXTURE_RECTANGLE_ARB targets.

     * The setup code in OGLPaints.Texture.isPaintValid() and in

     * OGLSurfaceData.initTexture() ensures that we only get here for

     * GL_TEXTURE_2D targets.

     */

    if (useMask) {

        // set up the paint on texture unit 1 (instead of the usual unit 0)

        j2d_glActiveTextureARB(GL_TEXTURE1_ARB);

        j2d_glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

    } else {

        // texture unit 0 is already active; we can use the helper macro here

        OGLC_UPDATE_TEXTURE_FUNCTION(oglc, GL_MODULATE);

    }

    j2d_glEnable(GL_TEXTURE_2D);

    j2d_glEnable(GL_TEXTURE_GEN_S);

    j2d_glEnable(GL_TEXTURE_GEN_T);

    j2d_glBindTexture(GL_TEXTURE_2D, srcOps->textureID);

    OGLSD_UPDATE_TEXTURE_FILTER(srcOps, hint);

    OGLSD_UPDATE_TEXTURE_WRAP(GL_TEXTURE_2D, GL_REPEAT);

    j2d_glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);

    j2d_glTexGendv(GL_S, GL_OBJECT_PLANE, xParams);

    j2d_glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);

    j2d_glTexGendv(GL_T, GL_OBJECT_PLANE, yParams);

    if (useMask) {

        // restore control to texture unit 0

        j2d_glActiveTextureARB(GL_TEXTURE0_ARB);

    }

    // oglc->pixel has been set appropriately in OGLPaints_ResetPaint()

    oglc->useMask = useMask;

    oglc->paintState = sun_java2d_SunGraphics2D_PAINT_TEXTURE;

}

/****************** Shared MultipleGradientPaint support ********************/

/**

 * These constants are identical to those defined in the

 * MultipleGradientPaint.CycleMethod enum; they are copied here for

 * convenience (ideally we would pull them directly from the Java level,

 * but that entails more hassle than it is worth).

 */

#define CYCLE_NONE    0

#define CYCLE_REFLECT 1

#define CYCLE_REPEAT  2

/**

 * The following constants are flags that can be bitwise-or'ed together

 * to control how the MultipleGradientPaint shader source code is generated:

 *

 *   MULTI_CYCLE_METHOD

 *     Placeholder for the CycleMethod enum constant.

 *

 *   MULTI_LARGE

 *     If set, use the (slower) shader that supports a larger number of

 *     gradient colors; otherwise, use the optimized codepath.  See

 *     the MAX_FRACTIONS_SMALL/LARGE constants below for more details.

 *

 *   MULTI_USE_MASK

 *     If set, apply the alpha mask value from texture unit 0 to the

 *     final color result (only used in the MaskFill case).

 *

 *   MULTI_LINEAR_RGB

 *     If set, convert the linear RGB result back into the sRGB color space.

 */

#define MULTI_CYCLE_METHOD (3 << 0)

#define MULTI_LARGE        (1 << 2)

#define MULTI_USE_MASK     (1 << 3)

#define MULTI_LINEAR_RGB   (1 << 4)

/**

 * This value determines the size of the array of programs for each

 * MultipleGradientPaint type.  This value reflects the maximum value that

 * can be represented by performing a bitwise-or of all the MULTI_*

 * constants defined above.

 */

#define MAX_PROGRAMS 32

/** Evaluates to true if the given bit is set on the local flags variable. */

#define IS_SET(flagbit) \

    (((flags) & (flagbit)) != 0)

/** Composes the given parameters as flags into the given flags variable.*/

#define COMPOSE_FLAGS(flags, cycleMethod, large, useMask, linear) \

    do {                                                   \

        flags |= ((cycleMethod) & MULTI_CYCLE_METHOD);     \

        if (large)   flags |= MULTI_LARGE;                 \

        if (useMask) flags |= MULTI_USE_MASK;              \

        if (linear)  flags |= MULTI_LINEAR_RGB;            \

    } while (0)

/** Extracts the CycleMethod enum value from the given flags variable. */

#define EXTRACT_CYCLE_METHOD(flags) \

    ((flags) & MULTI_CYCLE_METHOD)

/**

 * The maximum number of gradient "stops" supported by the fragment shader

 * and related code.  When the MULTI_LARGE flag is set, we will use

 * MAX_FRACTIONS_LARGE; otherwise, we use MAX_FRACTIONS_SMALL.  By having

 * two separate values, we can have one highly optimized shader (SMALL) that

 * supports only a few fractions/colors, and then another, less optimal

 * shader that supports more stops.

 */

#define MAX_FRACTIONS sun_java2d_pipe_BufferedPaints_MULTI_MAX_FRACTIONS

#define MAX_FRACTIONS_LARGE MAX_FRACTIONS

#define MAX_FRACTIONS_SMALL 4

/**

 * The maximum number of gradient colors supported by all of the gradient

 * fragment shaders.  Note that this value must be a power of two, as it

 * determines the size of the 1D texture created below.  It also must be

 * greater than or equal to MAX_FRACTIONS (there is no strict requirement

 * that the two values be equal).

 */

#define MAX_COLORS 16

/**

 * The handle to the gradient color table texture object used by the shaders.

 */

static GLuint multiGradientTexID = 0;

/**

 * This is essentially a template of the shader source code that can be used

 * for either LinearGradientPaint or RadialGradientPaint.  It includes the

 * structure and some variables that are common to each; the remaining

 * code snippets (for CycleMethod, ColorSpaceType, and mask modulation)

 * are filled in prior to compiling the shader at runtime depending on the

 * paint parameters.  See OGLPaints_CreateMultiGradProgram() for more details.

 */

static const char *multiGradientShaderSource =

    // gradient texture size (in texels)

    "const int TEXTURE_SIZE = %d;"

    // maximum number of fractions/colors supported by this shader

    "const int MAX_FRACTIONS = %d;"

    // size of a single texel

    "const float FULL_TEXEL = (1.0 / float(TEXTURE_SIZE));"

    // size of half of a single texel

    "const float HALF_TEXEL = (FULL_TEXEL / 2.0);"

    // texture containing the gradient colors

    "uniform sampler1D colors;"

    // array of gradient stops/fractions

    "uniform float fractions[MAX_FRACTIONS];"

    // array of scale factors (one for each interval)

    "uniform float scaleFactors[MAX_FRACTIONS-1];"

    // (placeholder for mask variable)

    "%s"

    // (placeholder for Linear/RadialGP-specific variables)

    "%s"

    ""

    "void main(void)"

    "{"

    "    float dist;"

         // (placeholder for Linear/RadialGradientPaint-specific code)

    "    %s"

    ""

    "    float tc;"

         // (placeholder for CycleMethod-specific code)

    "    %s"

    ""

         // calculate interpolated color

    "    vec4 result = texture1D(colors, tc);"

    ""

         // (placeholder for ColorSpace conversion code)

    "    %s"

    ""

         // (placeholder for mask modulation code)

    "    %s"

    ""

         // modulate with gl_Color in order to apply extra alpha

    "    gl_FragColor = result * gl_Color;"

    "}";

/**

 * This code takes a "dist" value as input (as calculated earlier by the

 * LGP/RGP-specific code) in the range [0,1] and produces a texture

 * coordinate value "tc" that represents the position of the chosen color

 * in the one-dimensional gradient texture (also in the range [0,1]).

 *

 * One naive way to implement this would be to iterate through the fractions

 * to figure out in which interval "dist" falls, and then compute the

 * relative distance between the two nearest stops.  This approach would

 * require an "if" check on every iteration, and it is best to avoid

 * conditionals in fragment shaders for performance reasons.  Also, one might

 * be tempted to use a break statement to jump out of the loop once the

 * interval was found, but break statements (and non-constant loop bounds)

 * are not natively available on most graphics hardware today, so that is

 * a non-starter.

 *

 * The more optimal approach used here avoids these issues entirely by using

 * an accumulation function that is equivalent to the process described above.

 * The scaleFactors array is pre-initialized at enable time as follows:

 *     scaleFactors[i] = 1.0 / (fractions[i+1] - fractions[i]);

 *

 * For each iteration, we subtract fractions[i] from dist and then multiply

 * that value by scaleFactors[i].  If we are within the target interval,

 * this value will be a fraction in the range [0,1] indicating the relative

 * distance between fraction[i] and fraction[i+1].  If we are below the

 * target interval, this value will be negative, so we clamp it to zero

 * to avoid accumulating any value.  If we are above the target interval,

 * the value will be greater than one, so we clamp it to one.  Upon exiting

 * the loop, we will have accumulated zero or more 1.0's and a single

 * fractional value.  This accumulated value tells us the position of the

 * fragment color in the one-dimensional gradient texture, i.e., the

 * texcoord called "tc".

 */

static const char *texCoordCalcCode =

    "int i;"

    "float relFraction = 0.0;"

    "for (i = 0; i < MAX_FRACTIONS-1; i++) {"

    "    relFraction +="

    "        clamp((dist - fractions[i]) * scaleFactors[i], 0.0, 1.0);"

    "}"

    // we offset by half a texel so that we find the linearly interpolated

    // color between the two texel centers of interest

    "tc = HALF_TEXEL + (FULL_TEXEL * relFraction);";

/** Code for NO_CYCLE that gets plugged into the CycleMethod placeholder. */

static const char *noCycleCode =

    "if (dist <= 0.0) {"

    "    tc = 0.0;"

    "} else if (dist >= 1.0) {"

    "    tc = 1.0;"

    "} else {"

         // (placeholder for texcoord calculation)

    "    %s"

    "}";

/** Code for REFLECT that gets plugged into the CycleMethod placeholder. */

static const char *reflectCode =

    "dist = 1.0 - (abs(fract(dist * 0.5) - 0.5) * 2.0);"

    // (placeholder for texcoord calculation)

    "%s";

/** Code for REPEAT that gets plugged into the CycleMethod placeholder. */

static const char *repeatCode =

    "dist = fract(dist);"

    // (placeholder for texcoord calculation)

    "%s";

static void

{

    GLclampf priority = 1.0f;

    J2dTraceLn(J2D_TRACE_INFO, "OGLPaints_InitMultiGradientTexture");

    j2d_glGenTextures(1, &multiGradientTexID);

    j2d_glBindTexture(GL_TEXTURE_1D, multiGradientTexID);

    j2d_glPrioritizeTextures(1, &multiGradientTexID, &priority);

    j2d_glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    j2d_glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    j2d_glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

    j2d_glTexImage1D(GL_TEXTURE_1D, 0,

                     GL_RGBA8, MAX_COLORS, 0,

                     GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);

}

/**

 * Compiles and links the MultipleGradientPaint shader program.  If

 * successful, this function returns a handle to the newly created

 * shader program; otherwise returns 0.

 */

static GLhandleARB

OGLPaints_CreateMultiGradProgram(jint flags,

                                 char *paintVars, char *distCode)