1 /*

     2  * Copyright (c) 2019, 2019, 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 sun.java2d.metal;

    27 

    28 import java.awt.*;

    29 

    30 import sun.awt.image.PixelConverter;

    31 import sun.java2d.SurfaceData;

    32 

    33 import java.awt.Composite;

    34 import sun.java2d.loops.CompositeType;

    35 import sun.java2d.loops.GraphicsPrimitive;

    36 import java.awt.image.ColorModel;

    37 import java.awt.image.Raster;

    38 import sun.java2d.loops.SurfaceType;

    39 import sun.java2d.metal.MetalLayer;

    40 import sun.awt.SunHints;

    41 import sun.java2d.metal.MetalGraphicsConfig;

    42 import sun.java2d.opengl.CGLGraphicsConfig;

    43 import sun.java2d.opengl.CGLLayer;

    44 import sun.java2d.opengl.CGLSurfaceData;

    45 import sun.java2d.opengl.OGLRenderQueue;

    46 import sun.lwawt.macosx.CPlatformView;

    47 import sun.java2d.pipe.hw.AccelSurface;

    48 import sun.java2d.metal.MetalRenderer;

    49 import sun.java2d.metal.MetalRenderQueue;

    50 import sun.java2d.pipe.PixelToParallelogramConverter;

    51 import sun.java2d.pipe.ParallelogramPipe;

    52 import sun.java2d.SunGraphics2D;

    53 

    54 public class MetalSurfaceData extends SurfaceData

    55     implements AccelSurface {

    56     //protected final int scale;

    57     protected final int width;

    58     protected final int height;

    59     protected CPlatformView pView;

    60     private MetalGraphicsConfig graphicsConfig;

    61 

    62     //private MetalGraphicsConfig graphicsConfig;

    63     private int nativeWidth, nativeHeight;

    64     protected int type;

    65     protected static ParallelogramPipe mtlAAPgramPipe;

    66     protected static MetalRenderer mtlRenderPipe;

    67     protected static PixelToParallelogramConverter mtlTxRenderPipe;

    68 

    69     /**

    70      * SurfaceTypes

    71      */

    72     private static final String DESC_METAL_SURFACE = "Metal Surface";

    73 

    74     static final SurfaceType MetalSurface =

    75             SurfaceType.Any.deriveSubType(DESC_METAL_SURFACE,

    76                     PixelConverter.ArgbPre.instance);

    77 

    78     private native int getTextureTarget(long pData);

    79     private native int getTextureID(long pData);

    80     protected native boolean initTexture(long pData,

    81                                          boolean isOpaque,

    82                                          int width, int height);

    83     protected native void clearWindow();

    84 

    85  static {

    86         if (!GraphicsEnvironment.isHeadless()) {

    87             MetalRenderQueue rq = MetalRenderQueue.getInstance();

    88             mtlRenderPipe = new MetalRenderer(rq);  

    89 

    90             mtlAAPgramPipe = mtlRenderPipe.getAAParallelogramPipe();

    91 

    92             mtlTxRenderPipe =

    93                 new PixelToParallelogramConverter(mtlRenderPipe,

    94                                                   mtlRenderPipe,

    95                                                   1.0, 0.25, true);

    96             MetalBlitLoops.register();

    97         }

    98     }

    99 

   100     native void validate(int xoff, int yoff, int width, int height, boolean isOpaque);

   101 

   102     private native void initOps(long pConfigInfo, long pPeerData, long layerPtr,

   103                                 int xoff, int yoff, boolean isOpaque);

   104 

   105     MetalSurfaceData(MetalGraphicsConfig gc, ColorModel cm, int type,

   106                      int width, int height) {

   107         // TODO : Map the coming type to proper custom type and call super()

   108         //super(gc, cm, type);

   109         //super(SurfaceType.Any3Byte, cm );

   110         super(MetalSurface, cm );

   111         // TEXTURE shouldn't be scaled, it is used for managed BufferedImages.

   112         // TODO : We need to set scale factor

   113         //scale = type == TEXTURE ? 1 : gc.getDevice().getScaleFactor();

   114         this.width = width ;// * scale;

   115         this.height = height;// * scale;

   116 

   117         graphicsConfig = gc;

   118     }

   119 

   120     protected MetalSurfaceData(CPlatformView pView, MetalGraphicsConfig gc,

   121                               ColorModel cm, int type, int width, int height)

   122     {

   123         this(gc, cm, type, width, height);

   124         this.pView = pView;

   125         this.graphicsConfig = gc;

   126 

   127         // TODO : Check whether we need native config info here

   128         long pConfigInfo = gc.getNativeConfigInfo();

   129         long pPeerData = 0L;

   130         boolean isOpaque = true;

   131         if (pView != null) {

   132             pPeerData = pView.getAWTView();

   133             isOpaque = pView.isOpaque();

   134         }

   135         // TODO : check initOps logic it is native is OGL

   136         initOps(pConfigInfo, pPeerData, 0, 0, 0, isOpaque);

   137     }

   138 

   139     protected MetalSurfaceData(MetalLayer layer, MetalGraphicsConfig gc,

   140                              ColorModel cm, int type, int width, int height)

   141     {

   142         this(gc, cm, type, width, height);

   143         this.graphicsConfig = gc;

   144 

   145         long pConfigInfo = gc.getNativeConfigInfo();

   146         long layerPtr = 0L;

   147         boolean isOpaque = true;

   148         if (layer != null) {

   149             layerPtr = layer.getPointer();

   150             isOpaque = layer.isOpaque();

   151         }

   152         initOps(pConfigInfo, 0, layerPtr, 0, 0, isOpaque);

   153     }

   154 

   155     public  GraphicsConfiguration getDeviceConfiguration() {

   156         return graphicsConfig; //dummy

   157     }

   158 

   159     public static MetalWindowSurfaceData createData(CPlatformView pView) {

   160         MetalGraphicsConfig gc = getGC(pView);

   161         return new MetalWindowSurfaceData(pView, gc);

   162     }

   163 

   164     public static MetalSurfaceData createData(MetalLayer layer) {

   165         MetalGraphicsConfig gc = getGC(layer);

   166         Rectangle r = layer.getBounds();

   167         //return new MetalSurfaceData( gc, gc.getColorModel(), 1, r.width, r.height);

   168         return new MetalLayerSurfaceData(layer, gc, r.width, r.height);

   169     }

   170 

   171     public static MetalGraphicsConfig getGC(CPlatformView pView) {

   172         if (pView != null) {

   173             return (MetalGraphicsConfig)pView.getGraphicsConfiguration();

   174         } else {

   175             // REMIND: this should rarely (never?) happen, but what if

   176             // default config is not CGL?

   177             GraphicsEnvironment env = GraphicsEnvironment

   178                     .getLocalGraphicsEnvironment();

   179             GraphicsDevice gd = env.getDefaultScreenDevice();

   180             return (MetalGraphicsConfig) gd.getDefaultConfiguration();

   181         }

   182     }

   183 

   184     public static MetalGraphicsConfig getGC(MetalLayer layer) {

   185         return (MetalGraphicsConfig)layer.getGraphicsConfiguration();

   186     }

   187 

   188     public void validate() {

   189         // Overridden in MetalWindowSurfaceData below

   190     }

   191 

   192     public Rectangle getNativeBounds() {

   193         MetalRenderQueue rq = MetalRenderQueue.getInstance();

   194         rq.lock();

   195         try {

   196             return new Rectangle(nativeWidth, nativeHeight);

   197         } finally {

   198             rq.unlock();

   199         }

   200     }

   201 

   202     public long getNativeResource(int resType) {

   203         if (resType == TEXTURE) {

   204             return getTextureID();

   205         }

   206         return 0L;

   207     }

   208 

   209     public  Object getDestination() {

   210           return this; //dummy

   211     }

   212 

   213 

   214      //Returns one of the surface type constants defined above.

   215      

   216     public final int getType() {

   217         return type;

   218     }

   219 

   220      //

   221      // If this surface is backed by a texture object, returns the target

   222      // for that texture (either GL_TEXTURE_2D or GL_TEXTURE_RECTANGLE_ARB).

   223      /// Otherwise, this method will return zero.

   224     public final int getTextureTarget() {

   225         return getTextureTarget(getNativeOps());

   226     }

   227 

   228     //

   229     // If this surface is backed by a texture object, returns the texture ID

   230     // for that texture.

   231     //Otherwise, this method will return zero.

   232     //

   233     public final int getTextureID() {

   234         return getTextureID(getNativeOps());

   235     }

   236 

   237     // Returns the MetalContext for the GraphicsConfig associated with this

   238     //surface.   

   239     public final MetalContext getContext() {

   240         return graphicsConfig.getContext();

   241     }

   242 

   243 

   244 

   245 

   246 public void validatePipe(SunGraphics2D sg2d) {

   247         //TextPipe textpipe;

   248         //boolean validated = false;

   249 

   250         // OGLTextRenderer handles both AA and non-AA text, but

   251         // only works with the following modes:

   252         // (Note: For LCD text we only enter this code path if

   253         // canRenderLCDText() has already validated that the mode is

   254         // CompositeType.SrcNoEa (opaque color), which will be subsumed

   255         // by the CompositeType.SrcNoEa (any color) test below.)

   256 

   257         // Copy block from OGLSurfaceData

   258         //textpipe = sg2d.textpipe; //tmp

   259 

   260         PixelToParallelogramConverter txPipe = null;

   261         MetalRenderer nonTxPipe = null;

   262 

   263         if (sg2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON) {

   264             if (sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR) {

   265                 if (sg2d.compositeState <= SunGraphics2D.COMP_XOR) {

   266                     txPipe = mtlTxRenderPipe;

   267                     nonTxPipe = mtlRenderPipe;

   268                 }

   269             } else if (sg2d.compositeState <= SunGraphics2D.COMP_ALPHA) {

   270                 //if (OGLPaints.isValid(sg2d)) {

   271                     txPipe = mtlTxRenderPipe;

   272                     nonTxPipe = mtlRenderPipe;

   273                 //}

   274                 // custom paints handled by super.validatePipe() below

   275             }

   276         } else {

   277             if (sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR) {

   278                 if (//graphicsConfig.isCapPresent(CAPS_PS30) &&

   279                     (sg2d.imageComp == CompositeType.SrcOverNoEa ||

   280                      sg2d.imageComp == CompositeType.SrcOver))

   281                 {

   282                     //if (!validated) {

   283                         super.validatePipe(sg2d);

   284                         //validated = true;

   285                     //}

   286                     PixelToParallelogramConverter aaConverter =

   287                         new PixelToParallelogramConverter(sg2d.shapepipe,

   288                                                           mtlAAPgramPipe,

   289                                                           1.0/8.0, 0.499,

   290                                                           false);

   291                     sg2d.drawpipe = aaConverter;

   292                     sg2d.fillpipe = aaConverter;

   293                     sg2d.shapepipe = aaConverter;

   294                 } else if (sg2d.compositeState == SunGraphics2D.COMP_XOR) {

   295                     // install the solid pipes when AA and XOR are both enabled

   296                     txPipe = mtlTxRenderPipe;

   297                     nonTxPipe = mtlRenderPipe;

   298                 }

   299             }

   300             // other cases handled by super.validatePipe() below

   301         }

   302 

   303         if (txPipe != null) {

   304             if (sg2d.transformState >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) {

   305                 sg2d.drawpipe = txPipe;

   306                 sg2d.fillpipe = txPipe;

   307             } else if (sg2d.strokeState != SunGraphics2D.STROKE_THIN) {

   308                 sg2d.drawpipe = txPipe;

   309                 sg2d.fillpipe = nonTxPipe;

   310             } else {

   311                 sg2d.drawpipe = nonTxPipe;

   312                 sg2d.fillpipe = nonTxPipe;

   313             }

   314             // Note that we use the transforming pipe here because it

   315             // will examine the shape and possibly perform an optimized

   316             // operation if it can be simplified.  The simplifications

   317             // will be valid for all STROKE and TRANSFORM types.

   318             sg2d.shapepipe = txPipe;

   319         } else {

   320             

   321                 super.validatePipe(sg2d);

   322             

   323         }

   324 

   325         // install the text pipe based on our earlier decision

   326         //sg2d.textpipe = textpipe;

   327 

   328         // always override the image pipe with the specialized OGL pipe

   329         // TODO : We dont override image pipe with MetalImagePipe.

   330         // this needs to be implemented.

   331         sg2d.imagepipe = imagepipe;

   332     }

   333 

   334     public SurfaceData getReplacement() {

   335         return this; //dummy

   336     }

   337 

   338     /*

   339      * TODO : In case of OpenGL their is no getRaster()

   340      * implementation in CGLSurfaceData or OGLSurfaceData.

   341      * Needs more verification.

   342      */

   343     public Raster getRaster(int x, int y, int w, int h) {

   344         throw new InternalError("not implemented yet");

   345         //System.out.println("MetalSurfaceData -- getRaster() not implemented yet");

   346     }

   347 

   348     public Rectangle getBounds() {

   349         //Rectangle r = pView.getBounds();

   350         return new Rectangle(0, 0, width, height);

   351     }

   352 

   353     protected void initSurface(final int width, final int height) {

   354         MetalRenderQueue rq = MetalRenderQueue.getInstance();

   355         rq.lock();

   356         try {

   357             rq.flushAndInvokeNow(new Runnable() {

   358                 public void run() {

   359                     initSurfaceNow(width, height);

   360                 }

   361             });

   362         } finally {

   363             rq.unlock();

   364         }

   365     }

   366 

   367     private void initSurfaceNow(int width, int height) {

   368         boolean isOpaque = (getTransparency() == Transparency.OPAQUE);

   369         boolean success = false;

   370 

   371         /*switch (type) {

   372             case TEXTURE:

   373                 success = initTexture(getNativeOps(),

   374                         isOpaque, isTexNonPow2Available(),

   375                         isTexRectAvailable(),

   376                         width, height);

   377                 break;

   378 

   379             case FBOBJECT:

   380                 success = initFBObject(getNativeOps(),

   381                         isOpaque, isTexNonPow2Available(),

   382                         isTexRectAvailable(),

   383                         width, height);

   384                 break;

   385 

   386             case FLIP_BACKBUFFER:

   387                 success = initFlipBackbuffer(getNativeOps());

   388                 break;

   389 

   390             default:

   391                 break;

   392         }*/

   393 

   394         success = initTexture(getNativeOps(),

   395                               isOpaque,

   396                               width, height);

   397         if (!success) {

   398             throw new OutOfMemoryError("can't create offscreen surface");

   399         }

   400     }

   401 

   402     /**

   403      * Creates a SurfaceData object representing the back buffer of a

   404      * double-buffered on-screen Window.

   405      */

   406     /*public static CGLOffScreenSurfaceData createData(CPlatformView pView,

   407                                                      Image image, int type) {

   408         CGLGraphicsConfig gc = getGC(pView);

   409         Rectangle r = pView.getBounds();

   410         if (type == FLIP_BACKBUFFER) {

   411             return new CGLOffScreenSurfaceData(pView, gc, r.width, r.height,

   412                     image, gc.getColorModel(), FLIP_BACKBUFFER);

   413         } else {

   414             return new CGLVSyncOffScreenSurfaceData(pView, gc, r.width,

   415                     r.height, image, gc.getColorModel(), type);

   416         }

   417     }*/

   418 

   419     /**

   420      * Creates a SurfaceData object representing an off-screen buffer (either a

   421      * FBO or Texture).

   422      */

   423     public static MetalOffScreenSurfaceData createData(MetalGraphicsConfig gc,

   424                                                      int width, int height, ColorModel cm, Image image, int type) {

   425         return new MetalOffScreenSurfaceData(null, gc, width, height, image, cm,

   426                 type);

   427     }

   428 

   429     public static class MetalWindowSurfaceData extends MetalSurfaceData {

   430 

   431         public MetalWindowSurfaceData(CPlatformView pView,

   432                                     MetalGraphicsConfig gc) {

   433             super(pView, gc, gc.getColorModel(), WINDOW, 0, 0);

   434         }

   435 

   436         @Override

   437         public SurfaceData getReplacement() {

   438             return pView.getSurfaceData();

   439         }

   440 

   441         @Override

   442         public Rectangle getBounds() {

   443             Rectangle r = pView.getBounds();

   444             return new Rectangle(0, 0, r.width, r.height);

   445         }

   446 

   447         /**

   448          * Returns destination Component associated with this SurfaceData.

   449          */

   450         @Override

   451         public Object getDestination() {

   452             return pView.getDestination();

   453         }

   454 

   455         @Override

   456         public void validate() {

   457             MetalRenderQueue rq = MetalRenderQueue.getInstance();

   458             rq.lock();

   459             try {

   460                 rq.flushAndInvokeNow(new Runnable() {

   461                     public void run() {

   462                         Rectangle peerBounds = pView.getBounds();

   463                         validate(0, 0, peerBounds.width, peerBounds.height, pView.isOpaque());

   464                     }

   465                 });

   466             } finally {

   467                 rq.unlock();

   468             }

   469         }

   470 

   471         @Override

   472         public void invalidate() {

   473             super.invalidate();

   474             clearWindow();

   475         }

   476     }

   477 

   478     public static class MetalLayerSurfaceData extends MetalSurfaceData {

   479 

   480         private MetalLayer layer;

   481 

   482         public MetalLayerSurfaceData(MetalLayer layer, MetalGraphicsConfig gc,

   483                                    int width, int height) {

   484             super(layer, gc, gc.getColorModel(), RT_TEXTURE, width, height);

   485             this.layer = layer;

   486             initSurface(this.width, this.height);

   487         }

   488 

   489         @Override

   490         public SurfaceData getReplacement() {

   491             return layer.getSurfaceData();

   492         }

   493 

   494         /*@Override

   495         boolean isOnScreen() {

   496             return true;

   497         }*/

   498 

   499         @Override

   500         public Rectangle getBounds() {

   501             return new Rectangle(width, height);

   502         }

   503 

   504         @Override

   505         public Object getDestination() {

   506             return layer.getDestination();

   507         }

   508 

   509         @Override

   510         public int getTransparency() {

   511             return layer.getTransparency();

   512         }

   513 

   514         @Override

   515         public void invalidate() {

   516             super.invalidate();

   517             clearWindow();

   518         }

   519     }

   520 

   521     public static class MetalOffScreenSurfaceData extends MetalSurfaceData {

   522         private Image offscreenImage;

   523 

   524         public MetalOffScreenSurfaceData(CPlatformView pView,

   525                                        MetalGraphicsConfig gc, int width, int height, Image image,

   526                                        ColorModel cm, int type) {

   527             super(pView, gc, cm, type, width, height);

   528             offscreenImage = image;

   529             initSurface(this.width, this.height);

   530         }

   531 

   532         @Override

   533         public SurfaceData getReplacement() {

   534             return restoreContents(offscreenImage);

   535         }

   536 

   537         @Override

   538         public Rectangle getBounds() {

   539             if (type == FLIP_BACKBUFFER) {

   540                 Rectangle r = pView.getBounds();

   541                 return new Rectangle(0, 0, r.width, r.height);

   542             } else {

   543                 return new Rectangle(width, height);

   544             }

   545         }

   546 

   547         /**

   548          * Returns destination Image associated with this SurfaceData.

   549          */

   550         @Override

   551         public Object getDestination() {

   552             return offscreenImage;

   553         }

   554     }

   555     // TODO : We have some OGL Mac specific functions, verify their use case

   556 }