1 /* 2 * Copyright (c) 2011, 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.AWTException; 29 import java.awt.BufferCapabilities; 30 import java.awt.Color; 31 import java.awt.Component; 32 import java.awt.Graphics; 33 import java.awt.Graphics2D; 34 import java.awt.Image; 35 import java.awt.ImageCapabilities; 36 import java.awt.Transparency; 37 import java.awt.color.ColorSpace; 38 import java.awt.image.BufferedImage; 39 import java.awt.image.ColorModel; 40 import java.awt.image.DataBuffer; 41 import java.awt.image.DirectColorModel; 42 import java.awt.image.VolatileImage; 43 import java.awt.image.WritableRaster; 44 45 import sun.awt.CGraphicsConfig; 46 import sun.awt.CGraphicsDevice; 47 import sun.awt.image.OffScreenImage; 48 import sun.awt.image.SunVolatileImage; 49 import sun.awt.image.SurfaceManager; 50 import sun.java2d.Disposer; 51 import sun.java2d.DisposerRecord; 52 import sun.java2d.SunGraphics2D; 53 import sun.java2d.Surface; 54 import sun.java2d.SurfaceData; 55 import sun.java2d.opengl.OGLContext.OGLContextCaps; 56 import sun.java2d.pipe.hw.AccelSurface; 57 import sun.java2d.pipe.hw.AccelTypedVolatileImage; 58 import sun.java2d.pipe.hw.ContextCapabilities; 59 import static sun.java2d.opengl.OGLSurfaceData.*; 60 import static sun.java2d.opengl.OGLContext.OGLContextCaps.*; 61 import sun.java2d.opengl.CGLSurfaceData.CGLVSyncOffScreenSurfaceData; 62 import sun.java2d.pipe.hw.AccelDeviceEventListener; 63 import sun.java2d.pipe.hw.AccelDeviceEventNotifier; 64 65 import sun.lwawt.macosx.CPlatformView; 66 67 public class CGLGraphicsConfig extends CGraphicsConfig 68 implements OGLGraphicsConfig 69 { 70 //private static final int kOpenGLSwapInterval = RuntimeOptions.getCurrentOptions().OpenGLSwapInterval; 71 private static final int kOpenGLSwapInterval = 0; // TODO 72 protected static boolean cglAvailable; 73 private static ImageCapabilities imageCaps = new CGLImageCaps(); 74 75 private int pixfmt; 76 private BufferCapabilities bufferCaps; 77 private long pConfigInfo; 78 private ContextCapabilities oglCaps; 79 private OGLContext context; 80 private Object disposerReferent = new Object(); 81 82 public static native int getDefaultPixFmt(int screennum); 83 private static native boolean initCGL(); 84 private static native long getCGLConfigInfo(int screennum, int visualnum, 85 int swapInterval); 86 private static native int getOGLCapabilities(long configInfo); 87 88 static { 89 cglAvailable = initCGL(); 90 } 91 92 protected CGLGraphicsConfig(CGraphicsDevice device, int pixfmt, 93 long configInfo, ContextCapabilities oglCaps) 94 { 95 super(device); 96 97 this.pixfmt = pixfmt; 98 this.pConfigInfo = configInfo; 99 this.oglCaps = oglCaps; 100 context = new OGLContext(OGLRenderQueue.getInstance(), this); 101 102 // add a record to the Disposer so that we destroy the native 103 // CGLGraphicsConfigInfo data when this object goes away 104 Disposer.addRecord(disposerReferent, 105 new CGLGCDisposerRecord(pConfigInfo)); 106 } 107 108 @Override 109 public Object getProxyKey() { 110 return this; 111 } 112 113 @Override 114 public SurfaceData createManagedSurface(int w, int h, int transparency) { 115 return CGLSurfaceData.createData(this, w, h, 116 getColorModel(transparency), 117 null, 118 OGLSurfaceData.TEXTURE); 119 } 120 121 public static CGLGraphicsConfig getConfig(CGraphicsDevice device, 122 int pixfmt) 123 { 124 if (!cglAvailable) { 125 return null; 126 } 127 128 long cfginfo = 0; 129 final String ids[] = new String[1]; 130 OGLRenderQueue rq = OGLRenderQueue.getInstance(); 131 rq.lock(); 132 try { 133 // getCGLConfigInfo() creates and destroys temporary 134 // surfaces/contexts, so we should first invalidate the current 135 // Java-level context and flush the queue... 136 OGLContext.invalidateCurrentContext(); 137 138 cfginfo = getCGLConfigInfo(device.getCoreGraphicsScreen(), pixfmt, 139 kOpenGLSwapInterval); 140 141 OGLContext.setScratchSurface(cfginfo); 142 rq.flushAndInvokeNow(new Runnable() { 143 public void run() { 144 ids[0] = OGLContext.getOGLIdString(); 145 } 146 }); 147 } finally { 148 rq.unlock(); 149 } 150 if (cfginfo == 0) { 151 return null; 152 } 153 154 int oglCaps = getOGLCapabilities(cfginfo); 155 ContextCapabilities caps = new OGLContextCaps(oglCaps, ids[0]); 156 157 return new CGLGraphicsConfig(device, pixfmt, cfginfo, caps); 158 } 159 160 public static boolean isCGLAvailable() { 161 return cglAvailable; 162 } 163 164 /** 165 * Returns true if the provided capability bit is present for this config. 166 * See OGLContext.java for a list of supported capabilities. 167 */ 168 public final boolean isCapPresent(int cap) { 169 return ((oglCaps.getCaps() & cap) != 0); 170 } 171 172 public final long getNativeConfigInfo() { 173 return pConfigInfo; 174 } 175 176 /** 177 * {@inheritDoc} 178 * 179 * @see sun.java2d.pipe.hw.BufferedContextProvider#getContext 180 */ 181 public final OGLContext getContext() { 182 return context; 183 } 184 185 @Override 186 public BufferedImage createCompatibleImage(int width, int height) { 187 ColorModel model = new DirectColorModel(24, 0xff0000, 0xff00, 0xff); 188 WritableRaster 189 raster = model.createCompatibleWritableRaster(width, height); 190 return new BufferedImage(model, raster, model.isAlphaPremultiplied(), 191 null); 192 } 193 194 @Override 195 public ColorModel getColorModel(int transparency) { 196 switch (transparency) { 197 case Transparency.OPAQUE: 198 // REMIND: once the ColorModel spec is changed, this should be 199 // an opaque premultiplied DCM... 200 return new DirectColorModel(24, 0xff0000, 0xff00, 0xff); 201 case Transparency.BITMASK: 202 return new DirectColorModel(25, 0xff0000, 0xff00, 0xff, 0x1000000); 203 case Transparency.TRANSLUCENT: 204 ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_sRGB); 205 return new DirectColorModel(cs, 32, 206 0xff0000, 0xff00, 0xff, 0xff000000, 207 true, DataBuffer.TYPE_INT); 208 default: 209 return null; 210 } 211 } 212 213 public boolean isDoubleBuffered() { 214 return isCapPresent(CAPS_DOUBLEBUFFERED); 215 } 216 217 private static class CGLGCDisposerRecord implements DisposerRecord { 218 private long pCfgInfo; 219 public CGLGCDisposerRecord(long pCfgInfo) { 220 this.pCfgInfo = pCfgInfo; 221 } 222 public void dispose() { 223 if (pCfgInfo != 0) { 224 OGLRenderQueue.disposeGraphicsConfig(pCfgInfo); 225 pCfgInfo = 0; 226 } 227 } 228 } 229 230 // TODO: CGraphicsConfig doesn't implement displayChanged() yet 231 //@Override 232 public synchronized void displayChanged() { 233 //super.displayChanged(); 234 235 // the context could hold a reference to a CGLSurfaceData, which in 236 // turn has a reference back to this CGLGraphicsConfig, so in order 237 // for this instance to be disposed we need to break the connection 238 OGLRenderQueue rq = OGLRenderQueue.getInstance(); 239 rq.lock(); 240 try { 241 OGLContext.invalidateCurrentContext(); 242 } finally { 243 rq.unlock(); 244 } 245 } 246 247 @Override 248 public String toString() { 249 int screen = getDevice().getCoreGraphicsScreen(); 250 return ("CGLGraphicsConfig[dev="+screen+",pixfmt="+pixfmt+"]"); 251 } 252 253 254 /** 255 * The following methods are invoked from ComponentModel.java rather 256 * than having the Mac OS X-dependent implementations hardcoded in that 257 * class. This way the appropriate actions are taken based on the peer's 258 * GraphicsConfig, whether it is a CGraphicsConfig or a 259 * CGLGraphicsConfig. 260 */ 261 262 /** 263 * Creates a new SurfaceData that will be associated with the given 264 * LWWindowPeer. 265 */ 266 @Override 267 public SurfaceData createSurfaceData(CPlatformView pView) { 268 return CGLSurfaceData.createData(pView); 269 } 270 271 /** 272 * Creates a new SurfaceData that will be associated with the given 273 * CGLLayer. 274 */ 275 @Override 276 public SurfaceData createSurfaceData(CGLLayer layer) { 277 return CGLSurfaceData.createData(layer); 278 } 279 280 /** 281 * Creates a new hidden-acceleration image of the given width and height 282 * that is associated with the target Component. 283 */ 284 @Override 285 public Image createAcceleratedImage(Component target, 286 int width, int height) 287 { 288 ColorModel model = getColorModel(Transparency.OPAQUE); 289 WritableRaster wr = 290 model.createCompatibleWritableRaster(width, height); 291 return new OffScreenImage(target, model, wr, 292 model.isAlphaPremultiplied()); 293 } 294 295 /** 296 * The following methods correspond to the multibuffering methods in 297 * CWindowPeer.java... 298 */ 299 300 /** 301 * Attempts to create a OGL-based backbuffer for the given peer. If 302 * the requested configuration is not natively supported, an AWTException 303 * is thrown. Otherwise, if the backbuffer creation is successful, a 304 * value of 1 is returned. 305 */ 306 @Override 307 public long createBackBuffer(CPlatformView pView, 308 int numBuffers, BufferCapabilities caps) 309 throws AWTException 310 { 311 if (numBuffers > 2) { 312 throw new AWTException( 313 "Only double or single buffering is supported"); 314 } 315 BufferCapabilities configCaps = getBufferCapabilities(); 316 if (!configCaps.isPageFlipping()) { 317 throw new AWTException("Page flipping is not supported"); 318 } 319 if (caps.getFlipContents() == BufferCapabilities.FlipContents.PRIOR) { 320 throw new AWTException("FlipContents.PRIOR is not supported"); 321 } 322 323 // non-zero return value means backbuffer creation was successful 324 // (checked in CPlatformWindow.flip(), etc.) 325 return 1; 326 } 327 328 /** 329 * Destroys the backbuffer object represented by the given handle value. 330 */ 331 @Override 332 public void destroyBackBuffer(long backBuffer) { 333 } 334 335 /** 336 * Creates a VolatileImage that essentially wraps the target Component's 337 * backbuffer (the provided backbuffer handle is essentially ignored). 338 */ 339 @Override 340 public VolatileImage createBackBufferImage(Component target, 341 long backBuffer) 342 { 343 return new SunVolatileImage(target, 344 target.getWidth(), target.getHeight(), 345 Boolean.TRUE); 346 } 347 348 /** 349 * Performs the native OGL flip operation for the given target Component. 350 */ 351 @Override 352 public void flip(CPlatformView pView, 353 Component target, VolatileImage xBackBuffer, 354 int x1, int y1, int x2, int y2, 355 BufferCapabilities.FlipContents flipAction) 356 { 357 if (flipAction == BufferCapabilities.FlipContents.COPIED) { 358 SurfaceManager vsm = SurfaceManager.getManager(xBackBuffer); 359 SurfaceData sd = vsm.getPrimarySurfaceData(); 360 361 if (sd instanceof CGLVSyncOffScreenSurfaceData) { 362 CGLVSyncOffScreenSurfaceData vsd = 363 (CGLVSyncOffScreenSurfaceData)sd; 364 SurfaceData bbsd = vsd.getFlipSurface(); 365 Graphics2D bbg = 366 new SunGraphics2D(bbsd, Color.black, Color.white, null); 367 try { 368 bbg.drawImage(xBackBuffer, 0, 0, null); 369 } finally { 370 bbg.dispose(); 371 } 372 } else { 373 pView.drawImageOnPeer(xBackBuffer, x1, y1, x2, y2); 374 return; 375 } 376 } else if (flipAction == BufferCapabilities.FlipContents.PRIOR) { 377 // not supported by CGL... 378 return; 379 } 380 381 OGLSurfaceData.swapBuffers(pView.getAWTView()); 382 383 if (flipAction == BufferCapabilities.FlipContents.BACKGROUND) { 384 Graphics g = xBackBuffer.getGraphics(); 385 try { 386 g.setColor(target.getBackground()); 387 g.fillRect(0, 0, 388 xBackBuffer.getWidth(), 389 xBackBuffer.getHeight()); 390 } finally { 391 g.dispose(); 392 } 393 } 394 } 395 396 private static class CGLBufferCaps extends BufferCapabilities { 397 public CGLBufferCaps(boolean dblBuf) { 398 super(imageCaps, imageCaps, 399 dblBuf ? FlipContents.UNDEFINED : null); 400 } 401 } 402 403 @Override 404 public BufferCapabilities getBufferCapabilities() { 405 if (bufferCaps == null) { 406 bufferCaps = new CGLBufferCaps(isDoubleBuffered()); 407 } 408 return bufferCaps; 409 } 410 411 private static class CGLImageCaps extends ImageCapabilities { 412 private CGLImageCaps() { 413 super(true); 414 } 415 public boolean isTrueVolatile() { 416 return true; 417 } 418 } 419 420 @Override 421 public ImageCapabilities getImageCapabilities() { 422 return imageCaps; 423 } 424 425 /** 426 * {@inheritDoc} 427 * 428 * @see sun.java2d.pipe.hw.AccelGraphicsConfig#createCompatibleVolatileImage 429 */ 430 public VolatileImage 431 createCompatibleVolatileImage(int width, int height, 432 int transparency, int type) 433 { 434 if (type == FLIP_BACKBUFFER || type == WINDOW || type == UNDEFINED || 435 transparency == Transparency.BITMASK) 436 { 437 return null; 438 } 439 440 if (type == FBOBJECT) { 441 if (!isCapPresent(CAPS_EXT_FBOBJECT)) { 442 return null; 443 } 444 } else if (type == PBUFFER) { 445 boolean isOpaque = transparency == Transparency.OPAQUE; 446 if (!isOpaque && !isCapPresent(CAPS_STORED_ALPHA)) { 447 return null; 448 } 449 } 450 451 SunVolatileImage vi = new AccelTypedVolatileImage(this, width, height, 452 transparency, type); 453 Surface sd = vi.getDestSurface(); 454 if (!(sd instanceof AccelSurface) || 455 ((AccelSurface)sd).getType() != type) 456 { 457 vi.flush(); 458 vi = null; 459 } 460 461 return vi; 462 } 463 464 /** 465 * {@inheritDoc} 466 * 467 * @see sun.java2d.pipe.hw.AccelGraphicsConfig#getContextCapabilities 468 */ 469 public ContextCapabilities getContextCapabilities() { 470 return oglCaps; 471 } 472 473 public void addDeviceEventListener(AccelDeviceEventListener l) { 474 int screen = getDevice().getCoreGraphicsScreen(); 475 AccelDeviceEventNotifier.addListener(l, screen); 476 } 477 478 public void removeDeviceEventListener(AccelDeviceEventListener l) { 479 AccelDeviceEventNotifier.removeListener(l); 480 } 481 }