/*

 * 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.

 */

#include "math.h"

#include "GraphicsPrimitiveMgr.h"

#include "sun_java2d_loops_FillParallelogram.h"

#define PGRAM_MIN_MAX(bmin, bmax, v0, dv1, dv2) \

    do { \

        double vmin, vmax; \

        if (dv1 < 0) { \

            vmin = v0+dv1; \

            vmax = v0; \

        } else { \

            vmin = v0; \

            vmax = v0+dv1; \

        } \

        if (dv2 < 0) { \

            vmin -= dv2; \

        } else { \

            vmax += dv2; \

        } \

        bmin = (jint) floor(vmin + 0.5); \

        bmax = (jint) floor(vmax + 0.5); \

    } while(0)

#define PGRAM_INIT_X(starty, x, y, slope) \

    (DblToLong((x) + (slope) * ((starty)+0.5 - (y))) + LongOneHalf - 1)

/*

 * Class:     sun_java2d_loops_FillParallelogram

 * Method:    FillParallelogram

 * Signature: (Lsun/java2d/SunGraphics2D;Lsun/java2d/SurfaceData;DDDDDD)V

 */

JNIEXPORT void JNICALL

Java_sun_java2d_loops_FillParallelogram_FillParallelogram

    (JNIEnv *env, jobject self,

     jobject sg2d, jobject sData,

     jdouble x0, jdouble y0,

     jdouble dx1, jdouble dy1,

     jdouble dx2, jdouble dy2)

{

    SurfaceDataOps *sdOps;

    SurfaceDataRasInfo rasInfo;

    NativePrimitive *pPrim;

    CompositeInfo compInfo;

    jint pixel;

    jint ix1, iy1, ix2, iy2;

    if ((dy1 == 0 && dx1 == 0) || (dy2 == 0 && dx2 == 0)) {

        return;

    }

    /*

     * Sort parallelogram by y values, ensure that each delta vector

     * has a non-negative y delta, and eliminate degenerate parallelograms.

     */

    if (dy1 < 0) {

        x0 += dx1;  y0 += dy1;

        dx1 = -dx1; dy1 = -dy1;

    }

    if (dy2 < 0) {

        x0 += dx2;  y0 += dy2;

        dx2 = -dx2; dy2 = -dy2;

    }

    /* Sort delta vectors so dxy1 is left of dxy2. */

    if (dx1 * dy2 > dx2 * dy1) {

        double v = dx1; dx1 = dx2; dx2 = v;

               v = dy1; dy1 = dy2; dy2 = v;

    }

    PGRAM_MIN_MAX(ix1, ix2, x0, dx1, dx2);

    iy1 = (jint) floor(y0 + 0.5);

    iy2 = (jint) floor(y0 + dy1 + dy2 + 0.5);

    pPrim = GetNativePrim(env, self);

    if (pPrim == NULL) {

        return;

    }

    pixel = GrPrim_Sg2dGetPixel(env, sg2d);

    if (pPrim->pCompType->getCompInfo != NULL) {

        GrPrim_Sg2dGetCompInfo(env, sg2d, pPrim, &compInfo);

    }

    sdOps = SurfaceData_GetOps(env, sData);

    if (sdOps == NULL) {

        return;

    }

    GrPrim_Sg2dGetClip(env, sg2d, &rasInfo.bounds);

    SurfaceData_IntersectBoundsXYXY(&rasInfo.bounds, ix1, iy1, ix2, iy2);

    if (rasInfo.bounds.y2 <= rasInfo.bounds.y1 ||

        rasInfo.bounds.x2 <= rasInfo.bounds.x1)

    {

        return;

    }

    if (sdOps->Lock(env, sdOps, &rasInfo, pPrim->dstflags) != SD_SUCCESS) {

        return;

    }

    ix1 = rasInfo.bounds.x1;

    iy1 = rasInfo.bounds.y1;

    ix2 = rasInfo.bounds.x2;

    iy2 = rasInfo.bounds.y2;

    if (ix2 > ix1 && iy2 > iy1) {

        sdOps->GetRasInfo(env, sdOps, &rasInfo);

        if (rasInfo.rasBase) {

            jdouble lslope = (dy1 == 0) ? 0 : dx1 / dy1;

            jdouble rslope = (dy2 == 0) ? 0 : dx2 / dy2;

            jlong ldx = DblToLong(lslope);

            jlong rdx = DblToLong(rslope);

            jint cy1, cy2, loy, hiy;

            dx1 += x0;

            dy1 += y0;

            dx2 += x0;

            dy2 += y0;

            cy1 = (jint) floor(dy1 + 0.5);

            cy2 = (jint) floor(dy2 + 0.5);

            /* Top triangular portion. */

            loy = iy1;

            hiy = (cy1 < cy2) ? cy1 : cy2;

            if (hiy > iy2) hiy = iy2;

            if (loy < hiy) {

                jlong lx = PGRAM_INIT_X(loy, x0, y0, lslope);

                jlong rx = PGRAM_INIT_X(loy, x0, y0, rslope);

                (*pPrim->funcs.fillparallelogram)(&rasInfo,

                                                  ix1, loy, ix2, hiy,

                                                  lx, ldx, rx, rdx,

                                                  pixel, pPrim, &compInfo);

            }

            /* Middle parallelogram portion, which way does it slant? */

            if (cy1 < cy2) {

                /* Middle parallelogram portion, slanted to right. */

                /* left leg turned a corner at y0+dy1 */

                /* right leg continuing on its initial trajectory from y0 */

                loy = cy1;

                hiy = cy2;

                if (loy < iy1) loy = iy1;

                if (hiy > iy2) hiy = iy2;

                if (loy < hiy) {

                    jlong lx = PGRAM_INIT_X(loy, dx1, dy1, rslope);

                    jlong rx = PGRAM_INIT_X(loy,  x0,  y0, rslope);

                    (*pPrim->funcs.fillparallelogram)(&rasInfo,

                                                      ix1, loy, ix2, hiy,

                                                      lx, rdx, rx, rdx,

                                                      pixel, pPrim, &compInfo);

                }

            } else if (cy2 < cy1) {

                /* Middle parallelogram portion, slanted to left. */

                /* left leg continuing on its initial trajectory from y0 */

                /* right leg turned a corner at y0+dy2 */

                loy = cy2;

                hiy = cy1;

                if (loy < iy1) loy = iy1;

                if (hiy > iy2) hiy = iy2;

                if (loy < hiy) {

                    jlong lx = PGRAM_INIT_X(loy,  x0,  y0, lslope);

                    jlong rx = PGRAM_INIT_X(loy, dx2, dy2, lslope);

                    (*pPrim->funcs.fillparallelogram)(&rasInfo,

                                                      ix1, loy, ix2, hiy,

                                                      lx, ldx, rx, ldx,

                                                      pixel, pPrim, &compInfo);

                }

            }

            /* Bottom triangular portion. */

            loy = (cy1 > cy2) ? cy1 : cy2;

            if (loy < iy1) loy = iy1;

            hiy = iy2;

            if (loy < hiy) {

                /* left leg turned its corner at y0+dy1, now moving right */

                /* right leg turned its corner at y0+dy2, now moving left */

                jlong lx = PGRAM_INIT_X(loy, dx1, dy1, rslope);

                jlong rx = PGRAM_INIT_X(loy, dx2, dy2, lslope);

                (*pPrim->funcs.fillparallelogram)(&rasInfo,

                                                  ix1, loy, ix2, hiy,

                                                  lx, rdx, rx, ldx,

                                                  pixel, pPrim, &compInfo);

            }

        }

        SurfaceData_InvokeRelease(env, sdOps, &rasInfo);

    }

    SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);

}