jdk/src/java.desktop/windows/classes/sun/java2d/opengl/WGLVolatileSurfaceManager.java
changeset 25859 3317bb8137f4
parent 9035 1255eb81cc2f
child 28234 f694f2576719
equal deleted inserted replaced
25858:836adbf7a2cd 25859:3317bb8137f4
       
     1 /*
       
     2  * Copyright (c) 2004, 2010, 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.opengl;
       
    27 
       
    28 import java.awt.BufferCapabilities;
       
    29 import static java.awt.BufferCapabilities.FlipContents.*;
       
    30 import java.awt.Component;
       
    31 import java.awt.GraphicsConfiguration;
       
    32 import java.awt.Transparency;
       
    33 import java.awt.image.ColorModel;
       
    34 import sun.awt.image.SunVolatileImage;
       
    35 import sun.awt.image.VolatileSurfaceManager;
       
    36 import sun.awt.windows.WComponentPeer;
       
    37 import sun.java2d.SurfaceData;
       
    38 import static sun.java2d.opengl.OGLContext.OGLContextCaps.*;
       
    39 import static sun.java2d.pipe.hw.AccelSurface.*;
       
    40 import sun.java2d.pipe.hw.ExtendedBufferCapabilities;
       
    41 import static sun.java2d.pipe.hw.ExtendedBufferCapabilities.VSyncType.*;
       
    42 
       
    43 public class WGLVolatileSurfaceManager
       
    44     extends VolatileSurfaceManager
       
    45 {
       
    46     private boolean accelerationEnabled;
       
    47 
       
    48     public WGLVolatileSurfaceManager(SunVolatileImage vImg, Object context) {
       
    49         super(vImg, context);
       
    50 
       
    51         /*
       
    52          * We will attempt to accelerate this image only under the
       
    53          * following conditions:
       
    54          *   - the image is opaque OR
       
    55          *   - the image is translucent AND
       
    56          *       - the GraphicsConfig supports the FBO extension OR
       
    57          *       - the GraphicsConfig has a stored alpha channel
       
    58          */
       
    59         int transparency = vImg.getTransparency();
       
    60         WGLGraphicsConfig gc = (WGLGraphicsConfig)vImg.getGraphicsConfig();
       
    61         accelerationEnabled =
       
    62             (transparency == Transparency.OPAQUE) ||
       
    63             ((transparency == Transparency.TRANSLUCENT) &&
       
    64              (gc.isCapPresent(CAPS_EXT_FBOBJECT) ||
       
    65               gc.isCapPresent(CAPS_STORED_ALPHA)));
       
    66     }
       
    67 
       
    68     protected boolean isAccelerationEnabled() {
       
    69         return accelerationEnabled;
       
    70     }
       
    71 
       
    72     /**
       
    73      * Create a pbuffer-based SurfaceData object (or init the backbuffer
       
    74      * of an existing window if this is a double buffered GraphicsConfig).
       
    75      */
       
    76     protected SurfaceData initAcceleratedSurface() {
       
    77         SurfaceData sData;
       
    78         Component comp = vImg.getComponent();
       
    79         WComponentPeer peer =
       
    80             (comp != null) ? (WComponentPeer)comp.getPeer() : null;
       
    81 
       
    82         try {
       
    83             boolean createVSynced = false;
       
    84             boolean forceback = false;
       
    85             if (context instanceof Boolean) {
       
    86                 forceback = ((Boolean)context).booleanValue();
       
    87                 if (forceback) {
       
    88                     BufferCapabilities caps = peer.getBackBufferCaps();
       
    89                     if (caps instanceof ExtendedBufferCapabilities) {
       
    90                         ExtendedBufferCapabilities ebc =
       
    91                             (ExtendedBufferCapabilities)caps;
       
    92                         if (ebc.getVSync() == VSYNC_ON &&
       
    93                             ebc.getFlipContents() == COPIED)
       
    94                         {
       
    95                             createVSynced = true;
       
    96                             forceback = false;
       
    97                         }
       
    98                     }
       
    99                 }
       
   100             }
       
   101 
       
   102             if (forceback) {
       
   103                 // peer must be non-null in this case
       
   104                 sData = WGLSurfaceData.createData(peer, vImg, FLIP_BACKBUFFER);
       
   105             } else {
       
   106                 WGLGraphicsConfig gc =
       
   107                     (WGLGraphicsConfig)vImg.getGraphicsConfig();
       
   108                 ColorModel cm = gc.getColorModel(vImg.getTransparency());
       
   109                 int type = vImg.getForcedAccelSurfaceType();
       
   110                 // if acceleration type is forced (type != UNDEFINED) then
       
   111                 // use the forced type, otherwise choose one based on caps
       
   112                 if (type == OGLSurfaceData.UNDEFINED) {
       
   113                     type = gc.isCapPresent(CAPS_EXT_FBOBJECT) ?
       
   114                         OGLSurfaceData.FBOBJECT : OGLSurfaceData.PBUFFER;
       
   115                 }
       
   116                 if (createVSynced) {
       
   117                     sData = WGLSurfaceData.createData(peer, vImg, type);
       
   118                 } else {
       
   119                     sData = WGLSurfaceData.createData(gc,
       
   120                                                       vImg.getWidth(),
       
   121                                                       vImg.getHeight(),
       
   122                                                       cm, vImg, type);
       
   123                 }
       
   124             }
       
   125         } catch (NullPointerException ex) {
       
   126             sData = null;
       
   127         } catch (OutOfMemoryError er) {
       
   128             sData = null;
       
   129         }
       
   130 
       
   131         return sData;
       
   132     }
       
   133 
       
   134     @Override
       
   135     protected boolean isConfigValid(GraphicsConfiguration gc) {
       
   136         return ((gc == null) ||
       
   137                 ((gc instanceof WGLGraphicsConfig) &&
       
   138                  (gc == vImg.getGraphicsConfig())));
       
   139     }
       
   140 
       
   141     @Override
       
   142     public void initContents() {
       
   143         if (vImg.getForcedAccelSurfaceType() != OGLSurfaceData.TEXTURE) {
       
   144             super.initContents();
       
   145         }
       
   146     }
       
   147 }