| /* |
| * 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); |
| } |
