FillParallelogram.c

/*
 * Copyright (c) 2008, 2010, 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 "ParallelogramUtils.h"

#include "sun_java2d_loops_FillParallelogram.h"

/*
 * 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.
     */
    SORT_PGRAM(x0, y0, dx1, dy1, dx2, dy2, );

    PGRAM_MIN_MAX(ix1, ix2, x0, dx1, dx2, JNI_FALSE);
    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);
}