break; case CGL.NSOpenGLPFANoRecovery: ivalues.put(idx, caps.getHardwareAccelerated() ? 1 : 0); break; ivalues.put(idx, ( !caps.isOnscreen() && caps.isPBuffer() ) ? 1 : 0); break; ivalues.put(idx, (caps.getDoubleBuffered() ? 1 : 0)); break; ivalues.put(idx, (caps.getStereo() ? 1 : 0)); break; ivalues.put(idx, (caps.getRedBits() + caps.getGreenBits() + caps.getBlueBits())); break; ivalues.put(idx, caps.getAlphaBits()); break; ivalues.put(idx, caps.getDepthBits()); break; ivalues.put(idx, (caps.getAccumRedBits() + caps.getAccumGreenBits() + caps.getAccumBlueBits() + caps.getAccumAlphaBits())); break; ivalues.put(idx, caps.getStencilBits()); break;
/** * Copies all {@link GLCapabilitiesImmutable} values * from <code>source</code> into this instance. * @return this instance */ public GLCapabilities copyFrom(final GLCapabilitiesImmutable source) { super.copyFrom(source); glProfile = source.getGLProfile(); isPBuffer = source.isPBuffer(); isFBO = source.isFBO(); doubleBuffered = source.getDoubleBuffered(); stereo = source.getStereo(); hardwareAccelerated = source.getHardwareAccelerated(); depthBits = source.getDepthBits(); stencilBits = source.getStencilBits(); accumRedBits = source.getAccumRedBits(); accumGreenBits = source.getAccumGreenBits(); accumBlueBits = source.getAccumBlueBits(); accumAlphaBits = source.getAccumAlphaBits(); sampleBuffers = source.getSampleBuffers(); numSamples = source.getNumSamples(); sampleExtension = source.getSampleExtension(); return this; }
final GLProfile glp = capsRequested.getGLProfile(); final boolean fboAvailable = GLContext.isFBOAvailable(device, glp); final boolean pbufferAvailable = factory.canCreateGLPbuffer(device, glp); if( capsRequested.getDoubleBuffered() && ( capsRequested.isPBuffer() && glrq.exist(GLRendererQuirks.NoDoubleBufferedPBuffer) ) || ( capsRequested.isBitmap() && glrq.exist(GLRendererQuirks.NoDoubleBufferedBitmap) ) ) { doubleBufferAvailable = false; } else { final boolean auto = !( fboAvailable && capsRequested.isFBO() ) && !( pbufferAvailable && capsRequested.isPBuffer() ) && !( bitmapAvailable && capsRequested.isBitmap() ) ; final boolean useFBO = fboAvailable && ( auto || capsRequested.isFBO() ) ; final boolean usePbuffer = !useFBO && pbufferAvailable && ( auto || capsRequested.isPBuffer() ) ; final boolean useBitmap = !useFBO && !usePbuffer && bitmapAvailable && ( auto || capsRequested.isBitmap() ) ; if( capsRequested.isOnscreen() || useFBO != capsRequested.isFBO() || usePbuffer != capsRequested.isPBuffer() || useBitmap != capsRequested.isBitmap() || !doubleBufferAvailable && capsRequested.getDoubleBuffered() ) final GLCapabilities caps2 = (GLCapabilities) capsRequested.cloneMutable(); caps2.setOnscreen(false); caps2.setFBO( useFBO );
/** * Determines whether the chosen {@link GLCapabilitiesImmutable} * requires a {@link GLDrawable#swapBuffers() swap-buffers} * before reading pixels. * <p> * Usually one uses the {@link GLBase#getDefaultReadBuffer() default-read-buffer} * in which case {@link GLDrawable#swapBuffers() swap-buffers} shall happen <b>after</b> calling reading pixels, the default. * </p> * <p> * However, <i>multisampling</i> offscreen {@link javax.media.opengl.GLFBODrawable}s * utilize {@link GLDrawable#swapBuffers() swap-buffers} to <i>downsample</i> * the multisamples into the readable sampling sink. * In this case, we require {@link GLDrawable#swapBuffers() swap-buffers} <b>before</b> reading pixels. * </p> * @return chosenCaps.isFBO() && chosenCaps.getSampleBuffers() */ public static final boolean swapBuffersBeforeRead(final GLCapabilitiesImmutable chosenCaps) { return chosenCaps.isFBO() && chosenCaps.getSampleBuffers(); } }
/** * @see #getExclusiveWinAttributeBits(boolean, boolean, boolean, boolean) */ public static final int getExclusiveWinAttributeBits(final GLCapabilitiesImmutable caps) { return getExclusiveWinAttributeBits(caps.isOnscreen(), caps.isFBO(), caps.isPBuffer(), caps.isBitmap()); }
if( caps.isOnscreen() ) { surfaceType = EGL.EGL_WINDOW_BIT; } else if( caps.isFBO() ) { } else if( caps.isPBuffer() ) { surfaceType = EGL.EGL_PBUFFER_BIT; } else if( caps.isBitmap() ) { surfaceType = EGL.EGL_PIXMAP_BIT; } else { attrs.put(idx++, caps.getRedBits()); attrs.put(idx++, caps.getGreenBits()); attrs.put(idx++, caps.getBlueBits()); if(caps.getAlphaBits()>0) { attrs.put(idx++, EGL.EGL_ALPHA_SIZE); attrs.put(idx++, caps.getAlphaBits()); if(caps.getStencilBits()>0) { attrs.put(idx++, EGL.EGL_STENCIL_SIZE); attrs.put(idx++, caps.getStencilBits()); attrs.put(idx++, caps.getDepthBits()); if(caps.getSampleBuffers()) { if(caps.getSampleExtension().equals(GLGraphicsConfigurationUtil.NV_coverage_sample)) { attrs.put(idx++, EGLExt.EGL_COVERAGE_BUFFERS_NV);
if ((getGLInteger(gl, GL.GL_RED_BITS) < reqOffscreenCaps.getRedBits()) || (getGLInteger(gl, GL.GL_GREEN_BITS) < reqOffscreenCaps.getGreenBits()) || (getGLInteger(gl, GL.GL_BLUE_BITS) < reqOffscreenCaps.getBlueBits()) || (getGLInteger(gl, GL2.GL_ACCUM_RED_BITS) < reqOffscreenCaps.getAccumRedBits()) || (getGLInteger(gl, GL2.GL_ACCUM_GREEN_BITS) < reqOffscreenCaps.getAccumGreenBits()) || (getGLInteger(gl, GL2.GL_ACCUM_BLUE_BITS) < reqOffscreenCaps.getAccumBlueBits()) || (getGLInteger(gl, GL2.GL_ACCUM_ALPHA_BITS) < reqOffscreenCaps.getAccumAlphaBits()) || (getGLInteger(gl, GL.GL_STENCIL_BITS) < reqOffscreenCaps.getStencilBits())) { if (DEBUG) { System.err.println(getThreadName()+": GLJPanel: Falling back to pbuffer-based support because Java2D context insufficient"); System.err.println(" Available Required"); System.err.println("GL_RED_BITS " + getGLInteger(gl, GL.GL_RED_BITS) + " " + reqOffscreenCaps.getRedBits()); System.err.println("GL_GREEN_BITS " + getGLInteger(gl, GL.GL_GREEN_BITS) + " " + reqOffscreenCaps.getGreenBits()); System.err.println("GL_BLUE_BITS " + getGLInteger(gl, GL.GL_BLUE_BITS) + " " + reqOffscreenCaps.getBlueBits()); System.err.println("GL_ALPHA_BITS " + getGLInteger(gl, GL.GL_ALPHA_BITS) + " " + reqOffscreenCaps.getAlphaBits()); System.err.println("GL_ACCUM_RED_BITS " + getGLInteger(gl, GL2.GL_ACCUM_RED_BITS) + " " + reqOffscreenCaps.getAccumRedBits()); System.err.println("GL_ACCUM_GREEN_BITS " + getGLInteger(gl, GL2.GL_ACCUM_GREEN_BITS) + " " + reqOffscreenCaps.getAccumGreenBits()); System.err.println("GL_ACCUM_BLUE_BITS " + getGLInteger(gl, GL2.GL_ACCUM_BLUE_BITS) + " " + reqOffscreenCaps.getAccumBlueBits()); System.err.println("GL_ACCUM_ALPHA_BITS " + getGLInteger(gl, GL2.GL_ACCUM_ALPHA_BITS) + " " + reqOffscreenCaps.getAccumAlphaBits()); System.err.println("GL_DEPTH_BITS " + getGLInteger(gl, GL.GL_DEPTH_BITS) + " " + reqOffscreenCaps.getDepthBits()); System.err.println("GL_STENCIL_BITS " + getGLInteger(gl, GL.GL_STENCIL_BITS) + " " + reqOffscreenCaps.getStencilBits());
if(hardwareAccelerated && !caps.getHardwareAccelerated()) { return 1; } else if(!hardwareAccelerated && caps.getHardwareAccelerated()) { return -1; if(stereo && !caps.getStereo()) { return 1; } else if(!stereo && caps.getStereo()) { return -1; if(doubleBuffered && !caps.getDoubleBuffered()) { return 1; } else if(!doubleBuffered && caps.getDoubleBuffered()) { return -1; final int xms = caps.getNumSamples() ; if(stencilBits > caps.getStencilBits()) { return 1; } else if(stencilBits < caps.getStencilBits()) { return -1; if(depthBits > caps.getDepthBits()) { return 1; } else if(depthBits < caps.getDepthBits()) { return -1;
final boolean usingAccumulatorBuffer = requestedCaps.getAccumAlphaBits() > 0 || requestedCaps.getAccumRedBits() > 0 || requestedCaps.getAccumGreenBits() > 0 || requestedCaps.getAccumBlueBits() > 0; if( ( chosenCapsA.isOnscreen() && !chosenCapsB.isOnscreen() || !chosenCapsA.isOnscreen() && chosenCapsB.isOnscreen() ) && // switching between on- and offscreen ( chosenCapsA.getSampleBuffers() || chosenCapsB.getSampleBuffers() ) || // MSAA involved ( chosenCapsA.getStereo() || chosenCapsB.getStereo() ) || // Stereo involved
public static GLCapabilitiesImmutable clipRGBAGLCapabilities(final GLCapabilitiesImmutable caps, final boolean allowRGB555, final boolean allowAlpha) { final int iR = caps.getRedBits(); final int iG = caps.getGreenBits(); final int iB = caps.getBlueBits(); final int iA = caps.getAlphaBits(); final int oR = clipColor(iR, allowRGB555); final int oG = clipColor(iG, allowRGB555); final int oB = clipColor(iB, allowRGB555); final int oA = ( allowAlpha && 0 < iA ) ? oR : 0 ; // align alpha to red if requested and allowed if( iR != oR || iG != oG || iB != oB || iA != oA ) { final GLCapabilities caps2 = (GLCapabilities) caps.cloneMutable(); caps2.setRedBits(oR); caps2.setGreenBits(oG); caps2.setBlueBits(oB); caps2.setAlphaBits(oA); return caps2; } return caps; }
final public static String[] getGLInfos(GLAutoDrawable drawable) { GL gl = drawable.getGL(); GLCapabilitiesImmutable c = drawable.getChosenGLCapabilities(); String[] ret = { c + "", c.getDoubleBuffered() + "", c.getStereo() + "", c.getStencilBits() + "", gl.getClass().getName(), gl.glGetString(GL.GL_VENDOR), gl.glGetString(GL.GL_RENDERER), gl.glGetString(GL.GL_VERSION) }; return ret; }
private final void swapFBOImplPost(final GLContext glc) { // Safely reset the previous front FBO - after completing propagating swap if(0 <= pendingFBOReset) { final GLCapabilitiesImmutable caps = (GLCapabilitiesImmutable) surface.getGraphicsConfiguration().getChosenCapabilities(); reset(glc.getGL(), pendingFBOReset, getSurfaceWidth(), getSurfaceHeight(), samples, caps.getAlphaBits()>0, caps.getDepthBits(), caps.getStencilBits()); pendingFBOReset = -1; } }
final GLCapabilitiesImmutable chosenCaps = (GLCapabilitiesImmutable) config.getChosenCapabilities(); final AbstractGraphicsDevice adevice = config.getScreen().getDevice(); final boolean isFBOAvailable = GLContext.isFBOAvailable(adevice, chosenCaps.getGLProfile()); GLDrawable result = null; adevice.lock(); if( !chosenCapsMod.isFBO() && !chosenCapsMod.isPBuffer() ) { throw new GLException("Neither FBO nor Pbuffer is available for "+chosenCapsMod+", "+target); throw new IllegalArgumentException("Passed NativeSurface must implement SurfaceChangeable for offscreen layered surface: "+target); if( chosenCapsMod.isFBO() ) { result = createFBODrawableImpl(target, chosenCapsMod, 0); } else { result = createOffscreenDrawableImpl(target); } else if(chosenCaps.isOnscreen()) { chosenCaps.isFBO()+" / "+isFBOAvailable+", "+chosenCaps.isPBuffer()+": "+target); if( chosenCaps.isFBO() && isFBOAvailable ) { final ProxySurface dummySurface = createDummySurfaceImpl(adevice, false, new GLCapabilities(chosenCaps.getGLProfile()), (GLCapabilitiesImmutable)config.getRequestedCapabilities(), null, 64, 64); dummySurface.setUpstreamSurfaceHook(new DelegatedUpstreamSurfaceHookWithSurfaceSize(dummySurface.getUpstreamSurfaceHook(), target)); result = createFBODrawableImpl(dummySurface, chosenCaps, 0);
final GLProfile glProfile = capsChosen.getGLProfile(); final int winattrmask = GLGraphicsConfigurationUtil.getExclusiveWinAttributeBits(capsChosen.isOnscreen(), capsChosen.isFBO(), false /* pbuffer */, capsChosen.isBitmap()); final List<GLCapabilitiesImmutable> availableCaps = new ArrayList<GLCapabilitiesImmutable>(); int recommendedIndex = -1; availableCaps.add(caps); if (capsChosen.isBackgroundOpaque() && recommendedVis != null && recommendedVis.getVisualid() == infos[i].getVisualid()) { recommendedIndex = availableCaps.size() - 1;
/** Fix double buffered setting */ public static GLCapabilitiesImmutable fixDoubleBufferedGLCapabilities(final GLCapabilitiesImmutable capsRequested, final boolean doubleBuffered) { if( capsRequested.getDoubleBuffered() != doubleBuffered) { final GLCapabilities caps2 = (GLCapabilities) capsRequested.cloneMutable(); caps2.setDoubleBuffered(doubleBuffered); return caps2; } return capsRequested; }
offscreenIsFBO = offscreenDrawable.getRequestedGLCapabilities().isFBO(); final boolean useGLSLFlip_pre = flipVertical && offscreenIsFBO && reqOffscreenCaps.getGLProfile().isGL2ES2() && USE_GLSL_TEXTURE_RASTERIZER; if( offscreenIsFBO && !useGLSLFlip_pre ) { fboFlipped = new FBObject(); fboFlipped.init(gl, panelWidth, panelHeight, 0); fboFlipped.attachColorbuffer(gl, 0, chosenCaps.getAlphaBits()>0);
} else if( CHOSEN_BITS == reqBits ) { final GLCapabilitiesImmutable caps = gl.getContext().getGLDrawable().getChosenGLCapabilities(); reqDepth = caps.getDepthBits(); reqStencil = caps.getStencilBits(); } else if( REQUESTED_BITS == reqBits ) { final GLCapabilitiesImmutable caps = gl.getContext().getGLDrawable().getRequestedGLCapabilities(); reqDepth = caps.getDepthBits(); reqStencil = caps.getStencilBits(); } else if( DEFAULT_BITS == reqBits ) { reqDepth = 24;
/** Callback for special implementations, allowing GLContext to fetch a custom default read buffer of current framebuffer. */ protected int getDefaultReadBuffer(final GL gl, final boolean hasDedicatedDrawableRead) { if( gl.isGLES() || hasDedicatedDrawableRead || getChosenGLCapabilities().getDoubleBuffered() ) { // Note-1: Neither ES1 nor ES2 supports selecting the read buffer via glReadBuffer // Note-2: ES3 only supports GL_BACK, GL_NONE or GL_COLOR_ATTACHMENT0+i return GL.GL_BACK; } return GL.GL_FRONT ; }
final int printNumSamples = printAWTTiles.getNumSamples(gladCaps); GLDrawable printDrawable = printGLAD.getDelegatedDrawable(); final boolean reqNewGLADSamples = printNumSamples != gladCaps.getNumSamples(); final boolean reqNewGLADSize = printAWTTiles.customTileWidth != -1 && printAWTTiles.customTileWidth != printDrawable.getSurfaceWidth() || printAWTTiles.customTileHeight != -1 && printAWTTiles.customTileHeight != printDrawable.getSurfaceHeight(); final boolean reqNewGLADOnscrn = gladCaps.isOnscreen(); final GLCapabilities newGLADCaps = (GLCapabilities)gladCaps.cloneMutable(); newGLADCaps.setDoubleBuffered(false); newGLADCaps.setOnscreen(false);
@Override public final GLDrawable createOffscreenDrawable(final AbstractGraphicsDevice deviceReq, final GLCapabilitiesImmutable capsRequested, final GLCapabilitiesChooser chooser, final int width, final int height) { if(width<=0 || height<=0) { throw new GLException("initial size must be positive (were (" + width + " x " + height + "))"); } final AbstractGraphicsDevice device = getOrCreateSharedDevice(deviceReq); if(null == device) { throw new GLException("No shared device for requested: "+deviceReq); } final GLCapabilitiesImmutable capsChosen = GLGraphicsConfigurationUtil.fixOffscreenGLCapabilities(capsRequested, this, device); if( capsChosen.isFBO() ) { // Use minimum GLCapabilities for the dummy surface w/ same profile final ProxySurface dummySurface = createDummySurfaceImpl(device, true, new GLCapabilities(capsChosen.getGLProfile()), capsRequested, null, width, height); final GLDrawableImpl dummyDrawable = createOnscreenDrawableImpl(dummySurface); return new GLFBODrawableImpl.ResizeableImpl(this, dummyDrawable, dummySurface, capsChosen, 0); } return createOffscreenDrawableImpl( createMutableSurfaceImpl(device, true, capsChosen, capsRequested, chooser, new UpstreamSurfaceHookMutableSize(width, height) ) ); }