1 /*
   2  * Copyright (c) 2009, 2014, 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
  23  * questions.
  24  */
  25 
  26 package com.sun.prism.impl;
  27 
  28 import java.nio.ByteBuffer;
  29 import java.util.HashMap;
  30 import java.util.Iterator;
  31 import java.util.Map;
  32 import com.sun.glass.ui.Screen;
  33 import com.sun.javafx.font.FontResource;
  34 import com.sun.javafx.font.FontStrike;

  35 import com.sun.javafx.geom.transform.BaseTransform;


  36 import com.sun.javafx.sg.prism.NGCamera;
  37 import com.sun.prism.PixelFormat;
  38 import com.sun.prism.RTTexture;
  39 import com.sun.prism.RenderTarget;
  40 import com.sun.prism.ResourceFactory;
  41 import com.sun.prism.Texture;
  42 import com.sun.prism.Texture.WrapMode;
  43 import com.sun.prism.impl.paint.PaintUtil;
  44 import com.sun.prism.impl.shape.MaskData;
  45 import com.sun.prism.paint.Gradient;
  46 
  47 public abstract class BaseContext {
  48 
  49     private final Screen screen;
  50     private final ResourceFactory factory;
  51     private final VertexBuffer vertexBuffer;
  52 

  53     private Texture maskTex;






  54     private Texture paintTex;
  55     private int[] paintPixels;
  56     private ByteBuffer paintBuffer;
  57 
  58     private Texture rectTex;
  59     private int rectTexMax;
  60     private Texture wrapRectTex;
  61     private Texture ovalTex;
  62 
  63     // TODO: need to dispose these when the context is disposed... (RT-27421)
  64     private final Map<FontStrike, GlyphCache>
  65         greyGlyphCaches = new HashMap<FontStrike, GlyphCache>();
  66     private final Map<FontStrike, GlyphCache>
  67         lcdGlyphCaches = new HashMap<FontStrike, GlyphCache>();
  68 
  69     protected BaseContext(Screen screen, ResourceFactory factory, VertexBuffer vb) {
  70         this.screen = screen;
  71         this.factory = factory;
  72         this.vertexBuffer = vb;
  73     }
  74 
  75     protected void setDeviceParametersFor2D() {}
  76     protected void setDeviceParametersFor3D() {}
  77 
  78     public Screen getAssociatedScreen() {
  79         return screen;
  80     }
  81 
  82     public ResourceFactory getResourceFactory() {
  83         return factory;
  84     }
  85 
  86     public VertexBuffer getVertexBuffer() {
  87         return vertexBuffer;
  88     }
  89 
  90     public void flushVertexBuffer() {










  91         vertexBuffer.flush();
  92     }
  93 
  94     /**
  95      *
  96      * This method will call releaseRenderTarget method to reset last
  97      * renderTarget and textures if g is null
  98      */
  99     public void setRenderTarget(BaseGraphics g) {
 100         if (g != null) {
 101             setRenderTarget(g.getRenderTarget(), g.getCameraNoClone(),
 102                     g.isDepthTest() && g.isDepthBuffer(), g.isState3D());
 103         } else {
 104             releaseRenderTarget();
 105         }
 106     }
 107 
 108     protected void releaseRenderTarget() {
 109         // Default implementation is a no-op. A pipeline may override if needed.
 110     }
 111 
 112     protected abstract void setRenderTarget(RenderTarget target, NGCamera camera,
 113                                             boolean depthTest, boolean state3D);
 114 
 115     public abstract void validateClearOp(BaseGraphics g);
 116 
 117     public abstract void validatePaintOp(BaseGraphics g, BaseTransform xform,
 118                                          Texture maskTex,
 119                                          float bx, float by, float bw, float bh);
 120 
 121     public abstract void validateTextureOp(BaseGraphics g, BaseTransform xform,
 122                                            Texture src, PixelFormat format);
 123 
 124     public void clearGlyphCaches() {
 125         clearCaches(greyGlyphCaches);
 126         clearCaches(lcdGlyphCaches);
 127     }
 128 
 129     private void clearCaches(Map<FontStrike, GlyphCache> glyphCaches) {
 130         for (Iterator<FontStrike> iter = glyphCaches.keySet().iterator(); iter.hasNext();) {
 131             iter.next().clearDesc();
 132         }
 133 
 134         for (GlyphCache cache : glyphCaches.values()) {
 135             if (cache != null) {
 136                 cache.clear();
 137             }
 138         }
 139         glyphCaches.clear();
 140     }
 141 
 142     abstract public RTTexture getLCDBuffer();
 143 
 144     public GlyphCache getGlyphCache(FontStrike strike) {
 145         Map<FontStrike, GlyphCache> glyphCaches =
 146             (strike.getAAMode() ==FontResource.AA_LCD)
 147             ? lcdGlyphCaches : greyGlyphCaches;
 148         return getGlyphCache(strike, glyphCaches);
 149     }
 150 
 151     public boolean isSuperShaderEnabled() {
 152         return false;
 153     }
 154 
 155     private GlyphCache getGlyphCache(FontStrike strike,
 156                                      Map<FontStrike, GlyphCache> glyphCaches) {
 157         GlyphCache glyphCache = glyphCaches.get(strike);
 158         if (glyphCache == null) {
 159             glyphCache = new GlyphCache(this, strike);
 160             glyphCaches.put(strike, glyphCache);
 161         }
 162         return glyphCache;
 163     }
 164 
 165     public Texture getMaskTexture(MaskData maskData, boolean canScale) {
 166         int maskW = maskData.getWidth();
 167         int maskH = maskData.getHeight();



 168         if (maskTex != null) {
 169             maskTex.lock();
 170             if (maskTex.isSurfaceLost()) {
 171                 maskTex = null;



 172             }
 173         }
 174         if (maskTex == null ||
 175             maskTex.getContentWidth()  < maskW ||
 176             maskTex.getContentHeight() < maskH)
 177         {
 178             int newTexW = maskW;
 179             int newTexH = maskH;
 180             if (maskTex != null) {






 181                 // grow the mask texture so that the new one is always
 182                 // at least as large as the previous one; this avoids
 183                 // lots of creation/disposal when the shapes alternate
 184                 // between narrow/tall and wide/short
 185                 newTexW = Math.max(maskW, maskTex.getContentWidth());
 186                 newTexH = Math.max(maskH, maskTex.getContentHeight());
 187                 maskTex.dispose();
 188             }
 189             maskTex = getResourceFactory().
 190                 createMaskTexture(newTexW, newTexH,
 191                                   canScale
 192                                       ? WrapMode.CLAMP_TO_ZERO
 193                                       : WrapMode.CLAMP_NOT_NEEDED);



 194         }
 195 
 196         maskData.uploadToTexture(maskTex, 0, 0, false);
 197 
 198         return maskTex;
 199     }
 200 




















































 201     public int getRectTextureMaxSize() {
 202         if (rectTex == null) {
 203             createRectTexture();
 204         }
 205         return rectTexMax;
 206     }
 207 
 208     public Texture getRectTexture() {
 209         if (rectTex == null) {
 210             createRectTexture();
 211         }
 212 
 213         // rectTex is left permanent and locked so it never
 214         // goes away or needs to be checked for isSurfaceLost(), but we
 215         // add a lock here so that the caller can unlock without knowing
 216         // our inner implementation details
 217         rectTex.lock();
 218         return rectTex;
 219     }
 220 
 221     private void createRectTexture() {
 222         int texMax = PrismSettings.primTextureSize;
 223         if (texMax < 0) texMax = getResourceFactory().getMaximumTextureSize();
 224         int texDim = 3;
 225         int nextCellSize = 2;
 226         while (texDim + nextCellSize + 1 <= texMax) {
 227             rectTexMax = nextCellSize;
 228             texDim += ++nextCellSize;
 229         }
 230         byte mask[] = new byte[texDim * texDim];
 231         int cellY = 1;
 232         for (int cellH = 1; cellH <= rectTexMax; cellH++) {
 233             int cellX = 1;
 234             for (int cellW = 1; cellW <= rectTexMax; cellW++) {
 235                 int index = cellY * texDim + cellX;
 236                 for (int y = 0; y < cellH; y++) {
 237                     for (int x = 0; x < cellW; x++) {
 238                         mask[index + x] = (byte) 0xff;
 239                     }
 240                     index += texDim;
 241                 }
 242                 cellX += cellW + 1;
 243             }
 244             cellY += cellH + 1;
 245         }
 246         if (PrismSettings.verbose) {
 247             System.out.println("max rectangle texture cell size = "+rectTexMax);
 248         }
 249         Texture tex =
 250             getResourceFactory().createMaskTexture(texDim, texDim,
 251                                                    WrapMode.CLAMP_NOT_NEEDED);
 252         // rectTex remains permanently locked, useful, and permanent
 253         // an additional lock is added when a caller calls getWrapGreientTeture for
 254         // them to unlock
 255         tex.contentsUseful();
 256         tex.makePermanent();
 257         PixelFormat pf = tex.getPixelFormat();
 258         int scan = texDim * pf.getBytesPerPixelUnit();
 259         tex.update(ByteBuffer.wrap(mask), pf,
 260                    0, 0, 0, 0, texDim, texDim,
 261                    scan, false);
 262         rectTex = tex;
 263     }
 264 
 265     public Texture getWrapRectTexture() {
 266         if (wrapRectTex == null) {
 267             Texture tex =
 268                 getResourceFactory().createMaskTexture(2, 2, WrapMode.CLAMP_TO_EDGE);
 269             // wrapRectTex remains permanently locked, useful, and permanent
 270             // an additional lock is added when a caller calls getWrapGreientTeture for
 271             // them to unlock
 272             tex.contentsUseful();
 273             tex.makePermanent();
 274             int w = tex.getPhysicalWidth();
 275             int h = tex.getPhysicalHeight();
 276             if (PrismSettings.verbose) {
 277                 System.out.println("wrap rectangle texture = "+w+" x "+h);
 278             }
 279             // assert w == 2 && h == 2?
 280             byte mask[] = new byte[w * h];
 281             int off = w;
 282             for (int y = 1; y < h; y++) {
 283                 for (int x = 1; x < h; x++) {
 284                     mask[off + x] = (byte) 0xff;
 285                 }
 286                 off += w;
 287             }
 288             PixelFormat pf = tex.getPixelFormat();
 289             int scan = w * pf.getBytesPerPixelUnit();
 290             tex.update(ByteBuffer.wrap(mask), pf,
 291                        0, 0, 0, 0, w, h,
 292                        scan, false);
 293             wrapRectTex = tex;
 294         }
 295 
 296         // wrapRectTex is left permanent and locked so it never
 297         // goes away or needs to be checked for isSurfaceLost(), but we
 298         // add a lock here so that the caller can unlock without knowing
 299         // our inner implementation details
 300         wrapRectTex.lock();
 301         return wrapRectTex;
 302     }
 303 
 304     public Texture getOvalTexture() {
 305         if (ovalTex == null) {
 306             int cellMax = getRectTextureMaxSize();
 307             int texDim = (cellMax * (cellMax + 1)) / 2;
 308             // size now points at the start of the max-sized cell
 309             texDim += cellMax + 1;
 310             // size now points just past the empty row on the far side of the
 311             // max-sized cell - which is the dimension we want the texture...
 312             byte mask[] = new byte[texDim * texDim];
 313             int cellY = 1;
 314             for (int cellH = 1; cellH <= cellMax; cellH++) {
 315                 int cellX = 1;
 316                 for (int cellW = 1; cellW <= cellMax; cellW++) {
 317                     int index = cellY * texDim + cellX;
 318 //                    System.out.println("rasterizing "+cell_w+" x "+cell_h);
 319                     for (int y = 0; y < cellH; y++) {
 320                         if (y * 2 >= cellH) {
 321                             int reflecty = cellH - 1 - y;
 322                             // handle bottom half of ellipse via reflection
 323                             int rindex = index + (reflecty - y) * texDim;
 324                             for (int x = 0; x < cellW; x++) {
 325                                 mask[index + x] = mask[rindex + x];
 326                             }
 327                         } else {
 328                             // Use 8 sub-row samples
 329                             float ovalY = y + 0.0625f;  // 1/16
 330                             for (int i = 0; i < 8; i++) {
 331                                 float ovalX = (ovalY / cellH) - 0.5f;
 332                                 ovalX = (float) Math.sqrt(0.25f - ovalX * ovalX);
 333                                 int oxi = Math.round(cellW * 4.0f * (1.0f - ovalX * 2.0f));
 334                                 int edgeX = oxi >> 3;
 335                                 int subX = oxi & 0x7;
 336 //                                System.out.println("y = "+oy+", mask["+rx+"] += "+(8-subx)+", mask["+(rx+1)+"] += "+subx);
 337                                 mask[index + edgeX] += 8 - subX;
 338                                 mask[index + edgeX + 1] += subX;
 339                                 ovalY += 0.125f;  // 1/8
 340                             }
 341                             int accum = 0;
 342                             for (int x = 0; x < cellW; x++) {
 343                                 if (x * 2 >= cellW) {
 344                                     // handle right half of ellipse via reflection
 345                                     mask[index + x] = mask[index + cellW - 1 - x];
 346                                 } else {
 347                                     accum += mask[index + x];
 348 //                                    System.out.println("accum["+rx+"] = "+accum);
 349                                     mask[index + x] = (byte) ((accum * 255 + 32) / 64);
 350                                 }
 351                             }
 352                             // Sometimes for smaller ovals we leave some
 353                             // accumulation dirt just past the last cell
 354                             mask[index + cellW] = 0;
 355                         }
 356                         index += texDim;
 357                     }
 358                     cellX += cellW + 1;
 359                 }
 360                 cellY += cellH + 1;
 361             }
 362             if (false) {
 363                 int index = 0;
 364                 for (int y = 0; y < texDim; y++) {
 365                     for (int x = 0; x < texDim; x++) {
 366                         String s = Integer.toHexString((mask[index++] & 0xff) | 0x100);
 367                         System.out.print(s.substring(1)+" ");
 368                     }
 369                     System.out.println();
 370                 }
 371             }
 372             Texture tex =
 373                 getResourceFactory().createMaskTexture(texDim, texDim,
 374                                                        WrapMode.CLAMP_NOT_NEEDED);
 375             tex.contentsUseful();
 376             tex.makePermanent();
 377             PixelFormat pf = tex.getPixelFormat();
 378             int scan = texDim * pf.getBytesPerPixelUnit();
 379             tex.update(ByteBuffer.wrap(mask), pf,
 380                        0, 0, 0, 0, texDim, texDim,
 381                        scan, false);
 382             ovalTex = tex;
 383         }
 384 
 385         // ovalTex is left permanent and locked so it never
 386         // goes away or needs to be checked for isSurfaceLost(), but we
 387         // add a lock here so that the caller can unlock without knowing
 388         // our inner implementation details
 389         ovalTex.lock();
 390         return ovalTex;
 391     }
 392 
 393     public Texture getGradientTexture(Gradient grad, BaseTransform xform,
 394                                       int paintW, int paintH,
 395                                       MaskData maskData,
 396                                       float bx, float by, float bw, float bh)
 397     {
 398         int sizeInPixels = paintW * paintH;
 399         int sizeInBytes = sizeInPixels * 4;
 400         if (paintBuffer == null || paintBuffer.capacity() < sizeInBytes) {
 401             paintPixels = new int[sizeInPixels];
 402             paintBuffer = ByteBuffer.wrap(new byte[sizeInBytes]);
 403         }
 404 
 405         if (paintTex != null) {
 406             paintTex.lock();
 407             if (paintTex.isSurfaceLost()) {
 408                 paintTex = null;
 409             }
 410         }
 411 
 412         if (paintTex == null ||
 413             paintTex.getContentWidth()  < paintW ||
 414             paintTex.getContentHeight() < paintH)
 415         {
 416             int newTexW = paintW;
 417             int newTexH = paintH;
 418             if (paintTex != null) {
 419                 // grow the paint texture so that the new one is always
 420                 // at least as large as the previous one; this avoids
 421                 // lots of creation/disposal when the shapes alternate
 422                 // between narrow/tall and wide/short
 423                 newTexW = Math.max(paintW, paintTex.getContentWidth());
 424                 newTexH = Math.max(paintH, paintTex.getContentHeight());
 425                 paintTex.dispose();
 426             }
 427             paintTex = getResourceFactory().
 428                 createTexture(PixelFormat.BYTE_BGRA_PRE,
 429                               Texture.Usage.DEFAULT,
 430                               Texture.WrapMode.CLAMP_NOT_NEEDED,
 431                               newTexW, newTexH);
 432         }
 433 
 434         // note that the gradient will be tightly packed into paintImg
 435         // (i.e., no space at the end of each logical row) since there
 436         // is no way to control scanline stride for texture uploads in ES1
 437         PaintUtil.fillImageWithGradient(paintPixels, grad, xform,
 438                                         0, 0, paintW, paintH,
 439                                         bx, by, bw, bh);
 440 
 441         // RT-27421
 442         // TODO: could save some work here if we converted the *GradientContext
 443         // classes to produce ByteRgbaPre data instead of IntArgbPre data...
 444         byte[] bytePixels = paintBuffer.array();
 445         if (maskData != null) {
 446             // modulate with the mask pixels while we convert from
 447             // IntArgbPre to ByteRgbaPre
 448             byte[] maskPixels = maskData.getMaskBuffer().array();
 449             int j = 0;
 450             for (int i = 0; i < sizeInPixels; i++) {
 451                 int pixel = paintPixels[i];
 452                 int maskA = maskPixels[i] & 0xff;
 453                 bytePixels[j++] = (byte)((((pixel       ) & 0xff) * maskA) / 255);
 454                 bytePixels[j++] = (byte)((((pixel >>   8) & 0xff) * maskA) / 255);
 455                 bytePixels[j++] = (byte)((((pixel >>  16) & 0xff) * maskA) / 255);
 456                 bytePixels[j++] = (byte)((((pixel >>> 24)       ) * maskA) / 255);
 457             }
 458         } else {
 459             // just convert from IntArgbPre to ByteRgbaPre
 460             int j = 0;
 461             for (int i = 0; i < sizeInPixels; i++) {
 462                 int pixel = paintPixels[i];
 463                 bytePixels[j++] = (byte)((pixel       ) & 0xff);
 464                 bytePixels[j++] = (byte)((pixel >>   8) & 0xff);
 465                 bytePixels[j++] = (byte)((pixel >>  16) & 0xff);
 466                 bytePixels[j++] = (byte)((pixel >>> 24)       );
 467             }
 468         }
 469 
 470         paintTex.update(paintBuffer, PixelFormat.BYTE_BGRA_PRE,
 471                         0, 0, 0, 0, paintW, paintH, paintW*4, false);
 472 
 473         return paintTex;
 474     }
 475 }
--- EOF ---