openjfx9/modules/javafx.graphics/src/main/java/com/sun/marlin/RendererContext.java

@@ -21,63 +21,64 @@
  * 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.
  */
 
-package sun.java2d.marlin;
+package com.sun.marlin;
 
 import java.awt.geom.Path2D;
 import java.lang.ref.WeakReference;
 import java.util.concurrent.atomic.AtomicInteger;
-import sun.java2d.ReentrantContext;
-import sun.java2d.marlin.ArrayCacheConst.CacheStats;
-import sun.java2d.marlin.MarlinRenderingEngine.NormalizingPathIterator;
+import com.sun.ReentrantContext;
+import com.sun.javafx.geom.Rectangle;
+import com.sun.marlin.ArrayCacheConst.CacheStats;
 
 /**
  * This class is a renderer context dedicated to a single thread
  */
-final class RendererContext extends ReentrantContext implements MarlinConst {
+public final class RendererContext extends ReentrantContext implements MarlinConst {
 
     // RendererContext creation counter
     private static final AtomicInteger CTX_COUNT = new AtomicInteger(1);
 
     /**
      * Create a new renderer context
      *
      * @return new RendererContext instance
      */
-    static RendererContext createContext() {
+    public static RendererContext createContext() {
         return new RendererContext("ctx"
                        + Integer.toString(CTX_COUNT.getAndIncrement()));
     }
 
     // Smallest object used as Cleaner's parent reference
     private final Object cleanerObj;
     // dirty flag indicating an exception occured during pipeline in pathTo()
-    boolean dirty = false;
+    public boolean dirty = false;
     // shared data
-    final float[] float6 = new float[6];
+    public final float[] float6 = new float[6];
     // shared curve (dirty) (Renderer / Stroker)
     final Curve curve = new Curve();
-    // MarlinRenderingEngine NormalizingPathIterator NearestPixelCenter:
-    final NormalizingPathIterator nPCPathIterator;
-    // MarlinRenderingEngine NearestPixelQuarter NormalizingPathIterator:
-    final NormalizingPathIterator nPQPathIterator;
     // MarlinRenderingEngine.TransformingPathConsumer2D
-    final TransformingPathConsumer2D transformerPC2D;
+    public final TransformingPathConsumer2D transformerPC2D;
     // recycled Path2D instance (weak)
     private WeakReference<Path2D.Float> refPath2D = null;
-    final Renderer renderer;
-    final Stroker stroker;
+    public final Renderer renderer;
+    private RendererNoAA rendererNoAA = null;
+    public final Stroker stroker;
     // Simplifies out collinear lines
-    final CollinearSimplifier simplifier = new CollinearSimplifier();
-    final Dasher dasher;
-    final MarlinTileGenerator ptg;
-    final MarlinCache cache;
+    public final CollinearSimplifier simplifier = new CollinearSimplifier();
+    public final Dasher dasher;
     // flag indicating the shape is stroked (1) or filled (0)
     int stroking = 0;
 
+// MarlinFX specific:
+    // dirty bbox rectangle
+    public final Rectangle clip = new Rectangle();
+    // dirty AlphaConsumer
+    public Object consumer = null;
+
     // Array caches:
     /* clean int[] cache (zero-filled) = 5 refs */
     private final IntArrayCache cleanIntCache = new IntArrayCache(true, 5);
     /* dirty int[] cache = 4 refs */
     private final IntArrayCache dirtyIntCache = new IntArrayCache(false, 4);

@@ -109,31 +110,25 @@
             };
         } else {
             stats = null;
         }
 
-        // NormalizingPathIterator instances:
-        nPCPathIterator = new NormalizingPathIterator.NearestPixelCenter(float6);
-        nPQPathIterator  = new NormalizingPathIterator.NearestPixelQuarter(float6);
-
         // MarlinRenderingEngine.TransformingPathConsumer2D
         transformerPC2D = new TransformingPathConsumer2D();
 
         // Renderer:
-        cache = new MarlinCache(this);
-        renderer = new Renderer(this); // needs MarlinCache from rdrCtx.cache
-        ptg = new MarlinTileGenerator(renderer);
+        renderer = new Renderer(this);
 
         stroker = new Stroker(this);
         dasher = new Dasher(this);
     }
 
     /**
      * Disposes this renderer context:
      * clean up before reusing this context
      */
-    void dispose() {
+    public void dispose() {
         if (DO_STATS) {
             if (stats.totalOffHeap > stats.totalOffHeapMax) {
                 stats.totalOffHeapMax = stats.totalOffHeap;
             }
             stats.totalOffHeap = 0L;

@@ -142,13 +137,10 @@
         // if context is maked as DIRTY:
         if (dirty) {
             // may happen if an exception if thrown in the pipeline processing:
             // force cleanup of all possible pipelined blocks (except Renderer):
 
-            // NormalizingPathIterator instances:
-            this.nPCPathIterator.dispose();
-            this.nPQPathIterator.dispose();
             // Dasher:
             this.dasher.dispose();
             // Stroker:
             this.stroker.dispose();
 

@@ -172,10 +164,17 @@
         // reset the path anyway:
         p2d.reset();
         return p2d;
     }
 
+    public RendererNoAA getRendererNoAA() {
+        if (rendererNoAA == null) {
+            rendererNoAA = new RendererNoAA(this);
+        }
+        return rendererNoAA;
+    }
+
     OffHeapArray newOffHeapArray(final long initialSize) {
         if (DO_STATS) {
             stats.totalOffHeapInitial += initialSize;
         }
         return new OffHeapArray(cleanerObj, initialSize);