/*

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

 */

#include "math.h"

#include "GraphicsPrimitiveMgr.h"

#include "LineUtils.h"

#include "LoopMacros.h"

#include "Trace.h"

#include "sun_java2d_loops_FillParallelogram.h"

#include "sun_java2d_loops_DrawParallelogram.h"

DECLARE_SOLID_DRAWLINE(AnyInt);

#define HANDLE_PGRAM_EDGE(X1, Y1, X2, Y2, \

                          pRasInfo, pixel, pPrim, pFunc, pCompInfo) \

    do { \

         jint ix1 = (jint) floor(X1); \

         jint ix2 = (jint) floor(X2); \

         jint iy1 = (jint) floor(Y1); \

         jint iy2 = (jint) floor(Y2); \

         LineUtils_ProcessLine(pRasInfo, pixel, \

                               pFunc, pPrim, pCompInfo, \

                               ix1, iy1, ix2, iy2, JNI_TRUE); \

    } while (0)

#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)

typedef struct {

    jdouble x0;

    jdouble y0;

    jdouble y1;

    jdouble slope;

    jlong dx;

    jint ystart;

    jint yend;

} EdgeInfo;

#define STORE_EDGE(pEDGE, X0, Y0, Y1, SLOPE, DELTAX) \

    do { \

        (pEDGE)->x0 = (X0); \

        (pEDGE)->y0 = (Y0); \

        (pEDGE)->y1 = (Y1); \

        (pEDGE)->slope = (SLOPE); \

        (pEDGE)->dx = (DELTAX); \

        (pEDGE)->ystart = (jint) floor((Y0) + 0.5); \

        (pEDGE)->yend   = (jint) floor((Y1) + 0.5); \

    } while (0)

#define STORE_PGRAM(pLTEDGE, pRTEDGE, \

                    X0, Y0, dX1, dY1, dX2, dY2, \

                    SLOPE1, SLOPE2, DELTAX1, DELTAX2) \

    do { \

        STORE_EDGE((pLTEDGE)+0, \

                   (X0), (Y0), (Y0) + (dY1), \

                   (SLOPE1), (DELTAX1)); \

        STORE_EDGE((pRTEDGE)+0, \

                   (X0), (Y0), (Y0) + (dY2), \

                   (SLOPE2), (DELTAX2)); \

        STORE_EDGE((pLTEDGE)+1, \

                   (X0) + (dX1), (Y0) + (dY1), (Y0) + (dY1) + (dY2), \

                   (SLOPE2), (DELTAX2)); \

        STORE_EDGE((pRTEDGE)+1, \

                   (X0) + (dX2), (Y0) + (dY2), (Y0) + (dY1) + (dY2), \

                   (SLOPE1), (DELTAX1)); \

    } while (0)

/*

 * Class:     sun_java2d_loops_DrawParallelogram

 * Method:    DrawParallelogram

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

 */

JNIEXPORT void JNICALL

Java_sun_java2d_loops_DrawParallelogram_DrawParallelogram

    (JNIEnv *env, jobject self,

     jobject sg2d, jobject sData,

     jdouble x0, jdouble y0,

     jdouble dx1, jdouble dy1,

     jdouble dx2, jdouble dy2,

     jdouble lw1, jdouble lw2)

{

    SurfaceDataOps *sdOps;

    SurfaceDataRasInfo rasInfo;

    NativePrimitive *pPrim;

    CompositeInfo compInfo;

    jint pixel;

    EdgeInfo edges[8];

    EdgeInfo *active[4];

    jint ix1, iy1, ix2, iy2;

    jdouble ldx1, ldy1, ldx2, ldy2;

    jdouble ox0, oy0;

    /*

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

     * has a non-negative y delta.

     */

    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;

               v = lw1; lw1 = lw2; lw2 = v;

    }

    // dx,dy for line width in the "1" and "2" directions.

    ldx1 = dx1 * lw1;

    ldy1 = dy1 * lw1;

    ldx2 = dx2 * lw2;

    ldy2 = dy2 * lw2;

    // calculate origin of the outer parallelogram

    ox0 = x0 - (ldx1 + ldx2) / 2.0;

    oy0 = y0 - (ldy1 + ldy2) / 2.0;

    PGRAM_MIN_MAX(ix1, ix2, ox0, dx1+ldx1, dx2+ldx2);

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

    iy2 = (jint) floor(oy0 + dy1 + ldy1 + dy2 + ldy2 + 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, rslope;

            jlong ldx, rdx;

            jint loy, hiy, numedges;

            FillParallelogramFunc *pFill =

                pPrim->funcs.drawparallelogram->fillpgram;

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

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

            ldx = DblToLong(lslope);

            rdx = DblToLong(rslope);

            // Only need to generate 4 quads if the interior still

            // has a hole in it (i.e. if the line width ratios were

            // both less than 1.0)

            if (lw1 < 1.0f && lw2 < 1.0f) {

                // If the line widths are both less than a pixel wide

                // then we can use a drawline function instead for even

                // more performance.

                lw1 = sqrt(ldx1*ldx1 + ldy1*ldy1);

                lw2 = sqrt(ldx2*ldx2 + ldy2*ldy2);

                if (lw1 <= 1.0001 && lw2 <= 1.0001) {

                    jdouble x3, y3;

                    DrawLineFunc *pLine =

                        pPrim->funcs.drawparallelogram->drawline;

                    x3 = (dx1 += x0);

                    y3 = (dy1 += y0);

                    x3 += dx2;

                    y3 += dy2;

                    dx2 += x0;

                    dy2 += y0;

                    HANDLE_PGRAM_EDGE( x0,  y0, dx1, dy1,

                                      &rasInfo, pixel, pPrim, pLine, &compInfo);

                    HANDLE_PGRAM_EDGE(dx1, dy1,  x3,  y3,

                                      &rasInfo, pixel, pPrim, pLine, &compInfo);

                    HANDLE_PGRAM_EDGE( x3,  y3, dx2, dy2,

                                      &rasInfo, pixel, pPrim, pLine, &compInfo);

                    HANDLE_PGRAM_EDGE(dx2, dy2,  x0,  y0,

                                      &rasInfo, pixel, pPrim, pLine, &compInfo);

                    SurfaceData_InvokeRelease(env, sdOps, &rasInfo);

                    SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);

                    return;

                }

                // To simplify the edge management below we presort the

                // inner and outer edges so that they are globally sorted

                // from left to right.  If you scan across the array of

                // edges for a given Y range then the edges you encounter

                // will be sorted in X as well.

                // If AB are left top and bottom edges of outer parallelogram,

                // and CD are the right pair of edges, and abcd are the

                // corresponding inner parallelogram edges then we want them

                // sorted as ABabcdCD to ensure this horizontal ordering.

                // Conceptually it is like 2 pairs of nested parentheses.

                STORE_PGRAM(edges + 2, edges + 4,

                            ox0 + ldx1 + ldx2, oy0 + ldy1 + ldy2,

                            dx1 - ldx1, dy1 - ldy1,

                            dx2 - ldx2, dy2 - ldy2,

                            lslope, rslope, ldx, rdx);

                numedges = 8;

            } else {

                // The line width ratios were large enough to consume

                // the entire hole in the middle of the parallelogram

                // so we can just issue one large quad for the outer

                // parallelogram.

                numedges = 4;

            }

            // The outer parallelogram always goes in the first two

            // and last two entries in the array so we either have

            // ABabcdCD ordering for 8 edges or ABCD ordering for 4

            // edges.  See comment above where we store the inner

            // parallelogram for a more complete description.

            STORE_PGRAM(edges + 0, edges + numedges-2,

                        ox0, oy0,

                        dx1 + ldx1, dy1 + ldy1,

                        dx2 + ldx2, dy2 + ldy2,

                        lslope, rslope, ldx, rdx);

            loy = edges[0].ystart;

            if (loy < iy1) loy = iy1;

            while (loy < iy2) {

                jint numactive = 0;

                jint cur;

                hiy = iy2;

                // Maintaining a sorted edge list is probably overkill for

                // 4 or 8 edges.  The indices chosen above for storing the

                // inner and outer left and right edges already guarantee

                // left to right ordering so we just need to scan for edges

                // that overlap the current Y range (and also determine the

                // maximum Y value for which the range is valid).

                for (cur = 0; cur < numedges; cur++) {

                    EdgeInfo *pEdge = &edges[cur];

                    jint yend = pEdge->yend;

                    if (loy < yend) {

                        // This edge is still in play, have we reached it yet?

                        jint ystart = pEdge->ystart;

                        if (loy < ystart) {

                            // This edge is not active (yet)

                            // Stop before we get to the top of it

                            if (hiy > ystart) hiy = ystart;

                        } else {

                            // This edge is active, store it

                            active[numactive++] = pEdge;

                            // And stop when we get to the bottom of it

                            if (hiy > yend) hiy = yend;

                        }

                    }

                }

#ifdef DEBUG

                if ((numactive & 1) != 0) {

                    J2dTraceLn1(J2D_TRACE_ERROR,

                                "DrawParallelogram: "

                                "ODD NUMBER OF PGRAM EDGES (%d)!!",

                                numactive);

                }

#endif

                for (cur = 0; cur < numactive; cur += 2) {

                    EdgeInfo *pLeft  = active[cur+0];

                    EdgeInfo *pRight = active[cur+1];

                    jlong lx = PGRAM_INIT_X(loy,

                                            pLeft->x0, pLeft->y0,

                                            pLeft->slope);

                    jlong rx = PGRAM_INIT_X(loy,

                                            pRight->x0, pRight->y0,

                                            pRight->slope);

                    (*pFill)(&rasInfo,

                             ix1, loy, ix2, hiy,

                             lx, pLeft->dx,

                             rx, pRight->dx,

                             pixel, pPrim, &compInfo);

                }

                loy = hiy;

            }

        }

        SurfaceData_InvokeRelease(env, sdOps, &rasInfo);

    }

    SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);

}