1 /*
2 * Copyright (c) 2007, 2017, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
30 import java.awt.geom.AffineTransform;
31 import java.awt.geom.Path2D;
32 import java.awt.geom.PathIterator;
33 import java.security.AccessController;
34 import static sun.java2d.marlin.MarlinUtils.logInfo;
35 import sun.awt.geom.PathConsumer2D;
36 import sun.java2d.ReentrantContextProvider;
37 import sun.java2d.ReentrantContextProviderCLQ;
38 import sun.java2d.ReentrantContextProviderTL;
39 import sun.java2d.pipe.AATileGenerator;
40 import sun.java2d.pipe.Region;
41 import sun.java2d.pipe.RenderingEngine;
42 import sun.security.action.GetPropertyAction;
43
44 /**
45 * Marlin RendererEngine implementation (derived from Pisces)
46 */
47 public final class MarlinRenderingEngine extends RenderingEngine
48 implements MarlinConst
49 {
50 private static enum NormMode {
51 ON_WITH_AA {
52 @Override
53 PathIterator getNormalizingPathIterator(final RendererContext rdrCtx,
54 final PathIterator src)
55 {
56 // NormalizingPathIterator NearestPixelCenter:
57 return rdrCtx.nPCPathIterator.init(src);
58 }
59 },
60 ON_NO_AA{
61 @Override
62 PathIterator getNormalizingPathIterator(final RendererContext rdrCtx,
63 final PathIterator src)
64 {
65 // NearestPixel NormalizingPathIterator:
66 return rdrCtx.nPQPathIterator.init(src);
67 }
68 },
69 OFF{
70 @Override
71 PathIterator getNormalizingPathIterator(final RendererContext rdrCtx,
72 final PathIterator src)
73 {
74 // return original path iterator if normalization is disabled:
75 return src;
76 }
77 };
78
79 abstract PathIterator getNormalizingPathIterator(RendererContext rdrCtx,
80 PathIterator src);
81 }
82
83 private static final float MIN_PEN_SIZE = 1.0f / NORM_SUBPIXELS;
84
85 static final float UPPER_BND = Float.MAX_VALUE / 2.0f;
86 static final float LOWER_BND = -UPPER_BND;
87
88 static final boolean DO_CLIP = MarlinProperties.isDoClip();
89 static final boolean DO_CLIP_FILL = true;
90
91 static final boolean DO_TRACE_PATH = false;
92
93 static final boolean DO_CLIP_RUNTIME_ENABLE = MarlinProperties.isDoClipRuntimeFlag();
94
95 /**
96 * Public constructor
97 */
98 public MarlinRenderingEngine() {
99 super();
100 logSettings(MarlinRenderingEngine.class.getName());
101 }
102
103 /**
104 * Create a widened path as specified by the parameters.
105 * <p>
106 * The specified {@code src} {@link Shape} is widened according
107 * to the specified attribute parameters as per the
108 * {@link BasicStroke} specification.
109 *
110 * @param src the source path to be widened
111 * @param width the width of the widened path as per {@code BasicStroke}
112 * @param caps the end cap decorations as per {@code BasicStroke}
113 * @param join the segment join decorations as per {@code BasicStroke}
114 * @param miterlimit the miter limit as per {@code BasicStroke}
402 at = null;
403 }
404
405 final TransformingPathConsumer2D transformerPC2D = rdrCtx.transformerPC2D;
406
407 if (DO_TRACE_PATH) {
408 // trace Stroker:
409 pc2d = transformerPC2D.traceStroker(pc2d);
410 }
411
412 if (USE_SIMPLIFIER) {
413 // Use simplifier after stroker before Renderer
414 // to remove collinear segments (notably due to cap square)
415 pc2d = rdrCtx.simplifier.init(pc2d);
416 }
417
418 // deltaTransformConsumer may adjust the clip rectangle:
419 pc2d = transformerPC2D.deltaTransformConsumer(pc2d, strokerat);
420
421 // stroker will adjust the clip rectangle (width / miter limit):
422 pc2d = rdrCtx.stroker.init(pc2d, width, caps, join, miterlimit, scale);
423
424 if (dashes != null) {
425 if (!recycleDashes) {
426 dashLen = dashes.length;
427 }
428 pc2d = rdrCtx.dasher.init(pc2d, dashes, dashLen, dashphase,
429 recycleDashes);
430 } else if (rdrCtx.doClip && (caps != Stroker.CAP_BUTT)) {
431 if (DO_TRACE_PATH) {
432 pc2d = transformerPC2D.traceClosedPathDetector(pc2d);
433 }
434
435 // If no dash and clip is enabled:
436 // detect closedPaths (polygons) for caps
437 pc2d = transformerPC2D.detectClosedPath(pc2d);
438 }
439 pc2d = transformerPC2D.inverseDeltaTransformConsumer(pc2d, strokerat);
440
441 if (DO_TRACE_PATH) {
442 // trace Input:
443 pc2d = transformerPC2D.traceInput(pc2d);
444 }
445
446 final PathIterator pi = norm.getNormalizingPathIterator(rdrCtx,
447 src.getPathIterator(at));
448
449 pathTo(rdrCtx, pi, pc2d);
608 }
609
610 static final class NearestPixelQuarter
611 extends NormalizingPathIterator
612 {
613 NearestPixelQuarter(final float[] tmp) {
614 super(tmp);
615 }
616
617 @Override
618 float normCoord(final float coord) {
619 // round to nearest (0.25, 0.25) pixel quarter
620 return FloatMath.floor_f(coord + 0.25f) + 0.25f;
621 }
622 }
623 }
624
625 private static void pathTo(final RendererContext rdrCtx, final PathIterator pi,
626 PathConsumer2D pc2d)
627 {
628 // mark context as DIRTY:
629 rdrCtx.dirty = true;
630
631 pathToLoop(rdrCtx.float6, pi, pc2d);
632
633 // mark context as CLEAN:
634 rdrCtx.dirty = false;
635 }
636
637 private static void pathToLoop(final float[] coords, final PathIterator pi,
638 final PathConsumer2D pc2d)
639 {
640 // ported from DuctusRenderingEngine.feedConsumer() but simplified:
641 // - removed skip flag = !subpathStarted
642 // - removed pathClosed (ie subpathStarted not set to false)
643 boolean subpathStarted = false;
644
645 for (; !pi.isDone(); pi.next()) {
646 switch (pi.currentSegment(coords)) {
647 case PathIterator.SEG_MOVETO:
1053 case ReentrantContextProvider.REF_WEAK:
1054 refType = "weak";
1055 break;
1056 }
1057
1058 logInfo("=========================================================="
1059 + "=====================");
1060
1061 logInfo("Marlin software rasterizer = ENABLED");
1062 logInfo("Version = ["
1063 + Version.getVersion() + "]");
1064 logInfo("sun.java2d.renderer = "
1065 + reClass);
1066 logInfo("sun.java2d.renderer.useThreadLocal = "
1067 + USE_THREAD_LOCAL);
1068 logInfo("sun.java2d.renderer.useRef = "
1069 + refType);
1070
1071 logInfo("sun.java2d.renderer.edges = "
1072 + MarlinConst.INITIAL_EDGES_COUNT);
1073 logInfo("sun.java2d.renderer.pixelsize = "
1074 + MarlinConst.INITIAL_PIXEL_DIM);
1075
1076 logInfo("sun.java2d.renderer.subPixel_log2_X = "
1077 + MarlinConst.SUBPIXEL_LG_POSITIONS_X);
1078 logInfo("sun.java2d.renderer.subPixel_log2_Y = "
1079 + MarlinConst.SUBPIXEL_LG_POSITIONS_Y);
1080
1081 logInfo("sun.java2d.renderer.tileSize_log2 = "
1082 + MarlinConst.TILE_H_LG);
1083 logInfo("sun.java2d.renderer.tileWidth_log2 = "
1084 + MarlinConst.TILE_W_LG);
1085 logInfo("sun.java2d.renderer.blockSize_log2 = "
1086 + MarlinConst.BLOCK_SIZE_LG);
1087
1088 // RLE / blockFlags settings
1089
1090 logInfo("sun.java2d.renderer.forceRLE = "
1091 + MarlinProperties.isForceRLE());
1092 logInfo("sun.java2d.renderer.forceNoRLE = "
1093 + MarlinProperties.isForceNoRLE());
1094 logInfo("sun.java2d.renderer.useTileFlags = "
1095 + MarlinProperties.isUseTileFlags());
1096 logInfo("sun.java2d.renderer.useTileFlags.useHeuristics = "
1097 + MarlinProperties.isUseTileFlagsWithHeuristics());
1098 logInfo("sun.java2d.renderer.rleMinWidth = "
1099 + MarlinCache.RLE_MIN_WIDTH);
1100
1101 // optimisation parameters
1102 logInfo("sun.java2d.renderer.useSimplifier = "
1103 + MarlinConst.USE_SIMPLIFIER);
1104
1105 logInfo("sun.java2d.renderer.clip = "
1106 + MarlinProperties.isDoClip());
1107 logInfo("sun.java2d.renderer.clip.runtime.enable = "
1108 + MarlinProperties.isDoClipRuntimeFlag());
1109
1110 // debugging parameters
1111 logInfo("sun.java2d.renderer.doStats = "
1112 + MarlinConst.DO_STATS);
1113 logInfo("sun.java2d.renderer.doMonitors = "
1114 + MarlinConst.DO_MONITORS);
1115 logInfo("sun.java2d.renderer.doChecks = "
1116 + MarlinConst.DO_CHECKS);
1117
1118 // logging parameters
1119 logInfo("sun.java2d.renderer.useLogger = "
1120 + MarlinConst.USE_LOGGER);
1121 logInfo("sun.java2d.renderer.logCreateContext = "
1122 + MarlinConst.LOG_CREATE_CONTEXT);
1123 logInfo("sun.java2d.renderer.logUnsafeMalloc = "
1124 + MarlinConst.LOG_UNSAFE_MALLOC);
1125
1126 // quality settings
1127 logInfo("sun.java2d.renderer.cubic_dec_d2 = "
1128 + MarlinProperties.getCubicDecD2());
1129 logInfo("sun.java2d.renderer.cubic_inc_d1 = "
1130 + MarlinProperties.getCubicIncD1());
1131 logInfo("sun.java2d.renderer.quad_dec_d2 = "
1132 + MarlinProperties.getQuadDecD2());
1133
1134 logInfo("Renderer settings:");
1135 logInfo("CUB_DEC_BND = " + Renderer.CUB_DEC_BND);
1136 logInfo("CUB_INC_BND = " + Renderer.CUB_INC_BND);
1137 logInfo("QUAD_DEC_BND = " + Renderer.QUAD_DEC_BND);
1138
1139 logInfo("INITIAL_EDGES_CAPACITY = "
1140 + MarlinConst.INITIAL_EDGES_CAPACITY);
1141 logInfo("INITIAL_CROSSING_COUNT = "
1142 + Renderer.INITIAL_CROSSING_COUNT);
1143
1144 logInfo("=========================================================="
1145 + "=====================");
1146 }
|
1 /*
2 * Copyright (c) 2007, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
30 import java.awt.geom.AffineTransform;
31 import java.awt.geom.Path2D;
32 import java.awt.geom.PathIterator;
33 import java.security.AccessController;
34 import static sun.java2d.marlin.MarlinUtils.logInfo;
35 import sun.awt.geom.PathConsumer2D;
36 import sun.java2d.ReentrantContextProvider;
37 import sun.java2d.ReentrantContextProviderCLQ;
38 import sun.java2d.ReentrantContextProviderTL;
39 import sun.java2d.pipe.AATileGenerator;
40 import sun.java2d.pipe.Region;
41 import sun.java2d.pipe.RenderingEngine;
42 import sun.security.action.GetPropertyAction;
43
44 /**
45 * Marlin RendererEngine implementation (derived from Pisces)
46 */
47 public final class MarlinRenderingEngine extends RenderingEngine
48 implements MarlinConst
49 {
50 // slightly slower ~2% if enabled stroker clipping (lines) but skipping cap / join handling is few percents faster in specific cases
51 static final boolean DISABLE_2ND_STROKER_CLIPPING = true;
52
53 static final boolean DO_TRACE_PATH = false;
54
55 static final boolean DO_CLIP = MarlinProperties.isDoClip();
56 static final boolean DO_CLIP_FILL = true;
57 static final boolean DO_CLIP_RUNTIME_ENABLE = MarlinProperties.isDoClipRuntimeFlag();
58
59 private static final float MIN_PEN_SIZE = 1.0f / MIN_SUBPIXELS;
60
61 static final float UPPER_BND = Float.MAX_VALUE / 2.0f;
62 static final float LOWER_BND = -UPPER_BND;
63
64 private enum NormMode {
65 ON_WITH_AA {
66 @Override
67 PathIterator getNormalizingPathIterator(final RendererContext rdrCtx,
68 final PathIterator src)
69 {
70 // NormalizingPathIterator NearestPixelCenter:
71 return rdrCtx.nPCPathIterator.init(src);
72 }
73 },
74 ON_NO_AA{
75 @Override
76 PathIterator getNormalizingPathIterator(final RendererContext rdrCtx,
77 final PathIterator src)
78 {
79 // NearestPixel NormalizingPathIterator:
80 return rdrCtx.nPQPathIterator.init(src);
81 }
82 },
83 OFF{
84 @Override
85 PathIterator getNormalizingPathIterator(final RendererContext rdrCtx,
86 final PathIterator src)
87 {
88 // return original path iterator if normalization is disabled:
89 return src;
90 }
91 };
92
93 abstract PathIterator getNormalizingPathIterator(RendererContext rdrCtx,
94 PathIterator src);
95 }
96
97 /**
98 * Public constructor
99 */
100 public MarlinRenderingEngine() {
101 super();
102 logSettings(MarlinRenderingEngine.class.getName());
103 }
104
105 /**
106 * Create a widened path as specified by the parameters.
107 * <p>
108 * The specified {@code src} {@link Shape} is widened according
109 * to the specified attribute parameters as per the
110 * {@link BasicStroke} specification.
111 *
112 * @param src the source path to be widened
113 * @param width the width of the widened path as per {@code BasicStroke}
114 * @param caps the end cap decorations as per {@code BasicStroke}
115 * @param join the segment join decorations as per {@code BasicStroke}
116 * @param miterlimit the miter limit as per {@code BasicStroke}
404 at = null;
405 }
406
407 final TransformingPathConsumer2D transformerPC2D = rdrCtx.transformerPC2D;
408
409 if (DO_TRACE_PATH) {
410 // trace Stroker:
411 pc2d = transformerPC2D.traceStroker(pc2d);
412 }
413
414 if (USE_SIMPLIFIER) {
415 // Use simplifier after stroker before Renderer
416 // to remove collinear segments (notably due to cap square)
417 pc2d = rdrCtx.simplifier.init(pc2d);
418 }
419
420 // deltaTransformConsumer may adjust the clip rectangle:
421 pc2d = transformerPC2D.deltaTransformConsumer(pc2d, strokerat);
422
423 // stroker will adjust the clip rectangle (width / miter limit):
424 pc2d = rdrCtx.stroker.init(pc2d, width, caps, join, miterlimit, scale,
425 (dashes == null));
426
427 // Curve Monotizer:
428 rdrCtx.monotonizer.init(width);
429
430 if (dashes != null) {
431 if (!recycleDashes) {
432 dashLen = dashes.length;
433 }
434 if (DO_TRACE_PATH) {
435 pc2d = transformerPC2D.traceDasher(pc2d);
436 }
437 pc2d = rdrCtx.dasher.init(pc2d, dashes, dashLen, dashphase,
438 recycleDashes);
439
440 if (DISABLE_2ND_STROKER_CLIPPING) {
441 // disable stoker clipping
442 rdrCtx.stroker.disableClipping();
443 }
444
445 } else if (rdrCtx.doClip && (caps != Stroker.CAP_BUTT)) {
446 if (DO_TRACE_PATH) {
447 pc2d = transformerPC2D.traceClosedPathDetector(pc2d);
448 }
449
450 // If no dash and clip is enabled:
451 // detect closedPaths (polygons) for caps
452 pc2d = transformerPC2D.detectClosedPath(pc2d);
453 }
454 pc2d = transformerPC2D.inverseDeltaTransformConsumer(pc2d, strokerat);
455
456 if (DO_TRACE_PATH) {
457 // trace Input:
458 pc2d = transformerPC2D.traceInput(pc2d);
459 }
460
461 final PathIterator pi = norm.getNormalizingPathIterator(rdrCtx,
462 src.getPathIterator(at));
463
464 pathTo(rdrCtx, pi, pc2d);
623 }
624
625 static final class NearestPixelQuarter
626 extends NormalizingPathIterator
627 {
628 NearestPixelQuarter(final float[] tmp) {
629 super(tmp);
630 }
631
632 @Override
633 float normCoord(final float coord) {
634 // round to nearest (0.25, 0.25) pixel quarter
635 return FloatMath.floor_f(coord + 0.25f) + 0.25f;
636 }
637 }
638 }
639
640 private static void pathTo(final RendererContext rdrCtx, final PathIterator pi,
641 PathConsumer2D pc2d)
642 {
643 if (USE_PATH_SIMPLIFIER) {
644 // Use path simplifier at the first step
645 // to remove useless points
646 pc2d = rdrCtx.pathSimplifier.init(pc2d);
647 }
648
649 // mark context as DIRTY:
650 rdrCtx.dirty = true;
651
652 pathToLoop(rdrCtx.float6, pi, pc2d);
653
654 // mark context as CLEAN:
655 rdrCtx.dirty = false;
656 }
657
658 private static void pathToLoop(final float[] coords, final PathIterator pi,
659 final PathConsumer2D pc2d)
660 {
661 // ported from DuctusRenderingEngine.feedConsumer() but simplified:
662 // - removed skip flag = !subpathStarted
663 // - removed pathClosed (ie subpathStarted not set to false)
664 boolean subpathStarted = false;
665
666 for (; !pi.isDone(); pi.next()) {
667 switch (pi.currentSegment(coords)) {
668 case PathIterator.SEG_MOVETO:
1074 case ReentrantContextProvider.REF_WEAK:
1075 refType = "weak";
1076 break;
1077 }
1078
1079 logInfo("=========================================================="
1080 + "=====================");
1081
1082 logInfo("Marlin software rasterizer = ENABLED");
1083 logInfo("Version = ["
1084 + Version.getVersion() + "]");
1085 logInfo("sun.java2d.renderer = "
1086 + reClass);
1087 logInfo("sun.java2d.renderer.useThreadLocal = "
1088 + USE_THREAD_LOCAL);
1089 logInfo("sun.java2d.renderer.useRef = "
1090 + refType);
1091
1092 logInfo("sun.java2d.renderer.edges = "
1093 + MarlinConst.INITIAL_EDGES_COUNT);
1094 logInfo("sun.java2d.renderer.pixelWidth = "
1095 + MarlinConst.INITIAL_PIXEL_WIDTH);
1096 logInfo("sun.java2d.renderer.pixelHeight = "
1097 + MarlinConst.INITIAL_PIXEL_HEIGHT);
1098
1099 logInfo("sun.java2d.renderer.subPixel_log2_X = "
1100 + MarlinConst.SUBPIXEL_LG_POSITIONS_X);
1101 logInfo("sun.java2d.renderer.subPixel_log2_Y = "
1102 + MarlinConst.SUBPIXEL_LG_POSITIONS_Y);
1103
1104 logInfo("sun.java2d.renderer.tileSize_log2 = "
1105 + MarlinConst.TILE_H_LG);
1106 logInfo("sun.java2d.renderer.tileWidth_log2 = "
1107 + MarlinConst.TILE_W_LG);
1108 logInfo("sun.java2d.renderer.blockSize_log2 = "
1109 + MarlinConst.BLOCK_SIZE_LG);
1110
1111 // RLE / blockFlags settings
1112
1113 logInfo("sun.java2d.renderer.forceRLE = "
1114 + MarlinProperties.isForceRLE());
1115 logInfo("sun.java2d.renderer.forceNoRLE = "
1116 + MarlinProperties.isForceNoRLE());
1117 logInfo("sun.java2d.renderer.useTileFlags = "
1118 + MarlinProperties.isUseTileFlags());
1119 logInfo("sun.java2d.renderer.useTileFlags.useHeuristics = "
1120 + MarlinProperties.isUseTileFlagsWithHeuristics());
1121 logInfo("sun.java2d.renderer.rleMinWidth = "
1122 + MarlinCache.RLE_MIN_WIDTH);
1123
1124 // optimisation parameters
1125 logInfo("sun.java2d.renderer.useSimplifier = "
1126 + MarlinConst.USE_SIMPLIFIER);
1127 logInfo("sun.java2d.renderer.usePathSimplifier= "
1128 + MarlinConst.USE_PATH_SIMPLIFIER);
1129 logInfo("sun.java2d.renderer.pathSimplifier.pixTol = "
1130 + MarlinProperties.getPathSimplifierPixelTolerance());
1131
1132 logInfo("sun.java2d.renderer.clip = "
1133 + MarlinProperties.isDoClip());
1134 logInfo("sun.java2d.renderer.clip.runtime.enable = "
1135 + MarlinProperties.isDoClipRuntimeFlag());
1136
1137 logInfo("sun.java2d.renderer.clip.subdivider = "
1138 + MarlinProperties.isDoClipSubdivider());
1139 logInfo("sun.java2d.renderer.clip.subdivider.minLength = "
1140 + MarlinProperties.getSubdividerMinLength());
1141
1142 // debugging parameters
1143 logInfo("sun.java2d.renderer.doStats = "
1144 + MarlinConst.DO_STATS);
1145 logInfo("sun.java2d.renderer.doMonitors = "
1146 + MarlinConst.DO_MONITORS);
1147 logInfo("sun.java2d.renderer.doChecks = "
1148 + MarlinConst.DO_CHECKS);
1149
1150 // logging parameters
1151 logInfo("sun.java2d.renderer.useLogger = "
1152 + MarlinConst.USE_LOGGER);
1153 logInfo("sun.java2d.renderer.logCreateContext = "
1154 + MarlinConst.LOG_CREATE_CONTEXT);
1155 logInfo("sun.java2d.renderer.logUnsafeMalloc = "
1156 + MarlinConst.LOG_UNSAFE_MALLOC);
1157
1158 // quality settings
1159 logInfo("sun.java2d.renderer.curve_len_err = "
1160 + MarlinProperties.getCurveLengthError());
1161 logInfo("sun.java2d.renderer.cubic_dec_d2 = "
1162 + MarlinProperties.getCubicDecD2());
1163 logInfo("sun.java2d.renderer.cubic_inc_d1 = "
1164 + MarlinProperties.getCubicIncD1());
1165 logInfo("sun.java2d.renderer.quad_dec_d2 = "
1166 + MarlinProperties.getQuadDecD2());
1167
1168 logInfo("Renderer settings:");
1169 logInfo("CUB_DEC_BND = " + Renderer.CUB_DEC_BND);
1170 logInfo("CUB_INC_BND = " + Renderer.CUB_INC_BND);
1171 logInfo("QUAD_DEC_BND = " + Renderer.QUAD_DEC_BND);
1172
1173 logInfo("INITIAL_EDGES_CAPACITY = "
1174 + MarlinConst.INITIAL_EDGES_CAPACITY);
1175 logInfo("INITIAL_CROSSING_COUNT = "
1176 + Renderer.INITIAL_CROSSING_COUNT);
1177
1178 logInfo("=========================================================="
1179 + "=====================");
1180 }
|