< prev index next >

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

Print this page




   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
  23  * questions.
  24  */
  25 
  26 package sun.java2d.marlin;
  27 
  28 import java.awt.geom.Path2D;
  29 import java.lang.ref.WeakReference;
  30 import java.util.concurrent.atomic.AtomicInteger;
  31 import sun.java2d.ReentrantContext;
  32 import sun.java2d.marlin.ArrayCacheConst.CacheStats;
  33 import sun.java2d.marlin.MarlinRenderingEngine.NormalizingPathIterator;
  34 
  35 /**
  36  * This class is a renderer context dedicated to a single thread
  37  */
  38 final class RendererContext extends ReentrantContext implements MarlinConst {
  39 
  40     // RendererContext creation counter
  41     private static final AtomicInteger CTX_COUNT = new AtomicInteger(1);
  42 
  43     /**
  44      * Create a new renderer context
  45      *
  46      * @return new RendererContext instance
  47      */
  48     static RendererContext createContext() {
  49         return new RendererContext("ctx"
  50                        + Integer.toString(CTX_COUNT.getAndIncrement()));
  51     }
  52 
  53     // Smallest object used as Cleaner's parent reference
  54     private final Object cleanerObj;
  55     // dirty flag indicating an exception occured during pipeline in pathTo()
  56     boolean dirty = false;
  57     // shared data
  58     final float[] float6 = new float[6];
  59     // shared curve (dirty) (Renderer / Stroker)
  60     final Curve curve = new Curve();
  61     // MarlinRenderingEngine NormalizingPathIterator NearestPixelCenter:
  62     final NormalizingPathIterator nPCPathIterator;
  63     // MarlinRenderingEngine NearestPixelQuarter NormalizingPathIterator:
  64     final NormalizingPathIterator nPQPathIterator;
  65     // MarlinRenderingEngine.TransformingPathConsumer2D
  66     final TransformingPathConsumer2D transformerPC2D;
  67     // recycled Path2D instance (weak)
  68     private WeakReference<Path2D.Float> refPath2D = null;
  69     final Renderer renderer;
  70     final Stroker stroker;

  71     // Simplifies out collinear lines
  72     final CollinearSimplifier simplifier = new CollinearSimplifier();
  73     final Dasher dasher;
  74     final MarlinTileGenerator ptg;
  75     final MarlinCache cache;
  76     // flag indicating the shape is stroked (1) or filled (0)
  77     int stroking = 0;
  78 






  79     // Array caches:
  80     /* clean int[] cache (zero-filled) = 5 refs */
  81     private final IntArrayCache cleanIntCache = new IntArrayCache(true, 5);
  82     /* dirty int[] cache = 4 refs */
  83     private final IntArrayCache dirtyIntCache = new IntArrayCache(false, 4);
  84     /* dirty float[] cache = 3 refs */
  85     private final FloatArrayCache dirtyFloatCache = new FloatArrayCache(false, 3);
  86     /* dirty byte[] cache = 1 ref */
  87     private final ByteArrayCache dirtyByteCache = new ByteArrayCache(false, 1);
  88 
  89     // RendererContext statistics
  90     final RendererStats stats;
  91 
  92     /**
  93      * Constructor
  94      *
  95      * @param name context name (debugging)
  96      */
  97     RendererContext(final String name) {
  98         if (LOG_CREATE_CONTEXT) {
  99             MarlinUtils.logInfo("new RendererContext = " + name);
 100         }
 101         this.cleanerObj = new Object();
 102 
 103         // create first stats (needed by newOffHeapArray):
 104         if (DO_STATS || DO_MONITORS) {
 105             stats = RendererStats.createInstance(cleanerObj, name);
 106             // push cache stats:
 107             stats.cacheStats = new CacheStats[] { cleanIntCache.stats,
 108                 dirtyIntCache.stats, dirtyFloatCache.stats, dirtyByteCache.stats
 109             };
 110         } else {
 111             stats = null;
 112         }
 113 
 114         // NormalizingPathIterator instances:
 115         nPCPathIterator = new NormalizingPathIterator.NearestPixelCenter(float6);
 116         nPQPathIterator  = new NormalizingPathIterator.NearestPixelQuarter(float6);
 117 
 118         // MarlinRenderingEngine.TransformingPathConsumer2D
 119         transformerPC2D = new TransformingPathConsumer2D();
 120 
 121         // Renderer:
 122         cache = new MarlinCache(this);
 123         renderer = new Renderer(this); // needs MarlinCache from rdrCtx.cache
 124         ptg = new MarlinTileGenerator(renderer);
 125 
 126         stroker = new Stroker(this);
 127         dasher = new Dasher(this);
 128     }
 129 
 130     /**
 131      * Disposes this renderer context:
 132      * clean up before reusing this context
 133      */
 134     void dispose() {
 135         if (DO_STATS) {
 136             if (stats.totalOffHeap > stats.totalOffHeapMax) {
 137                 stats.totalOffHeapMax = stats.totalOffHeap;
 138             }
 139             stats.totalOffHeap = 0L;
 140         }
 141         stroking = 0;
 142         // if context is maked as DIRTY:
 143         if (dirty) {
 144             // may happen if an exception if thrown in the pipeline processing:
 145             // force cleanup of all possible pipelined blocks (except Renderer):
 146 
 147             // NormalizingPathIterator instances:
 148             this.nPCPathIterator.dispose();
 149             this.nPQPathIterator.dispose();
 150             // Dasher:
 151             this.dasher.dispose();
 152             // Stroker:
 153             this.stroker.dispose();
 154 
 155             // mark context as CLEAN:
 156             dirty = false;
 157         }
 158     }
 159 
 160     Path2D.Float getPath2D() {
 161         // resolve reference:
 162         Path2D.Float p2d
 163             = (refPath2D != null) ? refPath2D.get() : null;
 164 
 165         // create a new Path2D ?
 166         if (p2d == null) {
 167             p2d = new Path2D.Float(Path2D.WIND_NON_ZERO, INITIAL_EDGES_COUNT); // 32K
 168 
 169             // update weak reference:
 170             refPath2D = new WeakReference<Path2D.Float>(p2d);
 171         }
 172         // reset the path anyway:
 173         p2d.reset();
 174         return p2d;







 175     }
 176 
 177     OffHeapArray newOffHeapArray(final long initialSize) {
 178         if (DO_STATS) {
 179             stats.totalOffHeapInitial += initialSize;
 180         }
 181         return new OffHeapArray(cleanerObj, initialSize);
 182     }
 183 
 184     IntArrayCache.Reference newCleanIntArrayRef(final int initialSize) {
 185         return cleanIntCache.createRef(initialSize);
 186     }
 187 
 188     IntArrayCache.Reference newDirtyIntArrayRef(final int initialSize) {
 189         return dirtyIntCache.createRef(initialSize);
 190     }
 191 
 192     FloatArrayCache.Reference newDirtyFloatArrayRef(final int initialSize) {
 193         return dirtyFloatCache.createRef(initialSize);
 194     }


   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
  23  * questions.
  24  */
  25 
  26 package com.sun.marlin;
  27 
  28 import java.awt.geom.Path2D;
  29 import java.lang.ref.WeakReference;
  30 import java.util.concurrent.atomic.AtomicInteger;
  31 import com.sun.ReentrantContext;
  32 import com.sun.javafx.geom.Rectangle;
  33 import com.sun.marlin.ArrayCacheConst.CacheStats;
  34 
  35 /**
  36  * This class is a renderer context dedicated to a single thread
  37  */
  38 public final class RendererContext extends ReentrantContext implements MarlinConst {
  39 
  40     // RendererContext creation counter
  41     private static final AtomicInteger CTX_COUNT = new AtomicInteger(1);
  42 
  43     /**
  44      * Create a new renderer context
  45      *
  46      * @return new RendererContext instance
  47      */
  48     public static RendererContext createContext() {
  49         return new RendererContext("ctx"
  50                        + Integer.toString(CTX_COUNT.getAndIncrement()));
  51     }
  52 
  53     // Smallest object used as Cleaner's parent reference
  54     private final Object cleanerObj;
  55     // dirty flag indicating an exception occured during pipeline in pathTo()
  56     public boolean dirty = false;
  57     // shared data
  58     public final float[] float6 = new float[6];
  59     // shared curve (dirty) (Renderer / Stroker)
  60     final Curve curve = new Curve();




  61     // MarlinRenderingEngine.TransformingPathConsumer2D
  62     public final TransformingPathConsumer2D transformerPC2D;
  63     // recycled Path2D instance (weak)
  64     private WeakReference<Path2D.Float> refPath2D = null;
  65     public final Renderer renderer;
  66     private RendererNoAA rendererNoAA = null;
  67     public final Stroker stroker;
  68     // Simplifies out collinear lines
  69     public final CollinearSimplifier simplifier = new CollinearSimplifier();
  70     public final Dasher dasher;


  71     // flag indicating the shape is stroked (1) or filled (0)
  72     int stroking = 0;
  73 
  74 // MarlinFX specific:
  75     // dirty bbox rectangle
  76     public final Rectangle clip = new Rectangle();
  77     // dirty AlphaConsumer
  78     public Object consumer = null;
  79 
  80     // Array caches:
  81     /* clean int[] cache (zero-filled) = 5 refs */
  82     private final IntArrayCache cleanIntCache = new IntArrayCache(true, 5);
  83     /* dirty int[] cache = 4 refs */
  84     private final IntArrayCache dirtyIntCache = new IntArrayCache(false, 4);
  85     /* dirty float[] cache = 3 refs */
  86     private final FloatArrayCache dirtyFloatCache = new FloatArrayCache(false, 3);
  87     /* dirty byte[] cache = 1 ref */
  88     private final ByteArrayCache dirtyByteCache = new ByteArrayCache(false, 1);
  89 
  90     // RendererContext statistics
  91     final RendererStats stats;
  92 
  93     /**
  94      * Constructor
  95      *
  96      * @param name context name (debugging)
  97      */
  98     RendererContext(final String name) {
  99         if (LOG_CREATE_CONTEXT) {
 100             MarlinUtils.logInfo("new RendererContext = " + name);
 101         }
 102         this.cleanerObj = new Object();
 103 
 104         // create first stats (needed by newOffHeapArray):
 105         if (DO_STATS || DO_MONITORS) {
 106             stats = RendererStats.createInstance(cleanerObj, name);
 107             // push cache stats:
 108             stats.cacheStats = new CacheStats[] { cleanIntCache.stats,
 109                 dirtyIntCache.stats, dirtyFloatCache.stats, dirtyByteCache.stats
 110             };
 111         } else {
 112             stats = null;
 113         }
 114 




 115         // MarlinRenderingEngine.TransformingPathConsumer2D
 116         transformerPC2D = new TransformingPathConsumer2D();
 117 
 118         // Renderer:
 119         renderer = new Renderer(this);


 120 
 121         stroker = new Stroker(this);
 122         dasher = new Dasher(this);
 123     }
 124 
 125     /**
 126      * Disposes this renderer context:
 127      * clean up before reusing this context
 128      */
 129     public void dispose() {
 130         if (DO_STATS) {
 131             if (stats.totalOffHeap > stats.totalOffHeapMax) {
 132                 stats.totalOffHeapMax = stats.totalOffHeap;
 133             }
 134             stats.totalOffHeap = 0L;
 135         }
 136         stroking = 0;
 137         // if context is maked as DIRTY:
 138         if (dirty) {
 139             // may happen if an exception if thrown in the pipeline processing:
 140             // force cleanup of all possible pipelined blocks (except Renderer):
 141 



 142             // Dasher:
 143             this.dasher.dispose();
 144             // Stroker:
 145             this.stroker.dispose();
 146 
 147             // mark context as CLEAN:
 148             dirty = false;
 149         }
 150     }
 151 
 152     Path2D.Float getPath2D() {
 153         // resolve reference:
 154         Path2D.Float p2d
 155             = (refPath2D != null) ? refPath2D.get() : null;
 156 
 157         // create a new Path2D ?
 158         if (p2d == null) {
 159             p2d = new Path2D.Float(Path2D.WIND_NON_ZERO, INITIAL_EDGES_COUNT); // 32K
 160 
 161             // update weak reference:
 162             refPath2D = new WeakReference<Path2D.Float>(p2d);
 163         }
 164         // reset the path anyway:
 165         p2d.reset();
 166         return p2d;
 167     }
 168 
 169     public RendererNoAA getRendererNoAA() {
 170         if (rendererNoAA == null) {
 171             rendererNoAA = new RendererNoAA(this);
 172         }
 173         return rendererNoAA;
 174     }
 175 
 176     OffHeapArray newOffHeapArray(final long initialSize) {
 177         if (DO_STATS) {
 178             stats.totalOffHeapInitial += initialSize;
 179         }
 180         return new OffHeapArray(cleanerObj, initialSize);
 181     }
 182 
 183     IntArrayCache.Reference newCleanIntArrayRef(final int initialSize) {
 184         return cleanIntCache.createRef(initialSize);
 185     }
 186 
 187     IntArrayCache.Reference newDirtyIntArrayRef(final int initialSize) {
 188         return dirtyIntCache.createRef(initialSize);
 189     }
 190 
 191     FloatArrayCache.Reference newDirtyFloatArrayRef(final int initialSize) {
 192         return dirtyFloatCache.createRef(initialSize);
 193     }
< prev index next >