@Override public final void create(ProxySurface surface) { final String dbgPrefix; if (DEBUG) { dbgPrefix = getThreadName() + ": EGLUpstreamSurfaceHook.create( up " + upstreamSurface.getClass().getSimpleName() + " -> this " + surface.getClass().getSimpleName() + " ): "; System.err.println(dbgPrefix + this); } else { dbgPrefix = null; } if (upstreamSurface instanceof ProxySurface) { // propagate createNotify(..) so upstreamSurface will be created ((ProxySurface) upstreamSurface).createNotify(); } // lock upstreamSurface, so it can be used in case EGLDisplay is derived from it! if (NativeSurface.LOCK_SURFACE_NOT_READY >= upstreamSurface.lockSurface()) { throw new GLException("Could not lock: " + upstreamSurface); } try { evalUpstreamSurface(dbgPrefix, surface); } finally { upstreamSurface.unlockSurface(); } }
@Override public synchronized void setVisibleActionPost(boolean visible, boolean nativeWindowCreated) { long t0; if (Window.DEBUG_IMPLEMENTATION) { t0 = System.nanoTime(); System.err.println( "GLWindow.setVisibleActionPost(" + visible + ", " + nativeWindowCreated + ") " + WindowImpl.getThreadName() + ", start"); } else { t0 = 0; } if (null == drawable && visible && 0 != window.getWindowHandle() && 0 < getWidth() * getHeight()) { if ((null != context)) { throw new InternalError( "GLWindow.LifecycleHook.setVisiblePost: " + WindowImpl.getThreadName() + " - Null drawable, but valid context - " + GLWindow.this); } final NativeSurface ns; { final NativeSurface wrapped_ns = window.getWrappedSurface(); ns = null != wrapped_ns ? wrapped_ns : window; } final GLCapabilitiesImmutable glCaps = (GLCapabilitiesImmutable) ns.getGraphicsConfiguration().getChosenCapabilities(); if (null == factory) { factory = GLDrawableFactory.getFactory(glCaps.getGLProfile()); } drawable = (GLDrawableImpl) factory.createGLDrawable(ns); drawable.setRealized(true); if (!GLWindow.this.pushGLEventListenerState()) { context = (GLContextImpl) drawable.createContext(sharedContext); context.setContextCreationFlags(additionalCtxCreationFlags); } } if (Window.DEBUG_IMPLEMENTATION) { System.err.println( "GLWindow.setVisibleActionPost(" + visible + ", " + nativeWindowCreated + ") " + WindowImpl.getThreadName() + ", fin: dt " + (System.nanoTime() - t0) / 1e6 + "ms"); } }
@Override protected final GLDrawableImpl createOffscreenDrawableImpl(NativeSurface target) { if (target == null) { throw new IllegalArgumentException("Null target"); } AbstractGraphicsConfiguration config = target.getGraphicsConfiguration(); GLCapabilitiesImmutable caps = (GLCapabilitiesImmutable) config.getChosenCapabilities(); if (!caps.isPBuffer()) { return new X11PixmapGLXDrawable(this, target); } // PBuffer GLDrawable Creation GLDrawableImpl pbufferDrawable; AbstractGraphicsDevice device = config.getScreen().getDevice(); /** * Due to the ATI Bug https://bugzilla.mozilla.org/show_bug.cgi?id=486277, we need to have a * context current on the same Display to create a PBuffer. The dummy context shall also use the * same Display, since switching Display in this regard is another ATI bug. */ SharedResource sr = (SharedResource) sharedResourceRunner.getOrCreateShared(device); if (null != sr && sr.isGLXVendorATI() && null == GLContext.getCurrent()) { sr.getContext().makeCurrent(); try { pbufferDrawable = new X11PbufferGLXDrawable(this, target); } finally { sr.getContext().release(); } } else { pbufferDrawable = new X11PbufferGLXDrawable(this, target); } return pbufferDrawable; }
@Override public String toString() { final String us_s = null != upstreamSurface ? (upstreamSurface.getClass().getName() + ": 0x" + Long.toHexString(upstreamSurface.getSurfaceHandle())) : "nil"; return "EGLUpstreamSurfaceHook[ " + upstreamSurface.getSurfaceWidth() + "x" + upstreamSurface.getSurfaceHeight() + ", " + us_s + "]"; }
@Override protected GLDrawableImpl createOffscreenDrawableImpl(NativeSurface target) { if (target == null) { throw new IllegalArgumentException("Null target"); } AbstractGraphicsConfiguration config = target.getGraphicsConfiguration(); GLCapabilitiesImmutable caps = (GLCapabilitiesImmutable) config.getChosenCapabilities(); if (!caps.isPBuffer()) { throw new GLException("Non pbuffer not yet implemented"); } // PBuffer GLDrawable Creation return new EGLPbufferDrawable(this, EGLWrappedSurface.get(target)); }
/** * Calls {@link #destroy()} directly if the following requirements are met: * * <ul> * <li>An {@link GLAnimatorControl} is bound (see {@link #getAnimator()}) and running on another * thread. Here we pause the animation while issuing the destruction. * <li>Surface is not locked by another thread (considered anonymous). * </ul> * * <p>Otherwise destroy is being flagged to be called within the next call of display(). * * <p>This method is being used to avoid deadlock if destruction is desired by <i>other</i> * threads, e.g. the window manager. * * @see #defaultWindowDestroyNotifyOp() * @see #defaultDisplay() */ protected final void destroyAvoidAwareOfLocking() { final NativeSurface ns = getNativeSurface(); final GLAnimatorControl ctrl = helper.getAnimator(); // Is an animator thread perform rendering? if (helper.isAnimatorStartedOnOtherThread()) { // Pause animations before initiating safe destroy. final boolean isPaused = ctrl.pause(); destroy(); if (isPaused) { ctrl.resume(); } } else if (null != ns && ns.isSurfaceLockedByOtherThread()) { // Surface is locked by another thread. // Flag that destroy should be performed on the next // attempt to display. sendDestroy = true; // async, but avoiding deadlock } else { // Without an external thread animating or locking the // surface, we are safe. destroy(); } }
private final void evalUpstreamSurface(String dbgPrefix, ProxySurface surface) { // // evaluate nature of upstreamSurface, may create EGL instances if required // boolean isEGLSurfaceValid = true; // assume yes final EGLGraphicsDevice eglDevice; final AbstractGraphicsConfiguration aConfig; { final AbstractGraphicsConfiguration surfaceConfig = surface.getGraphicsConfiguration(); final AbstractGraphicsDevice surfaceDevice = null != surfaceConfig ? surfaceConfig.getScreen().getDevice() : null; if (DEBUG) { System.err.println( dbgPrefix + "SurfaceDevice: " + surfaceDevice.getClass().getSimpleName() + ", hash 0x" + Integer.toHexString(surfaceDevice.hashCode()) + ", " + surfaceDevice); System.err.println( dbgPrefix + "SurfaceConfig: " + surfaceConfig.getClass().getSimpleName() + ", hash 0x" + Integer.toHexString(surfaceConfig.hashCode()) + ", " + surfaceConfig); } final AbstractGraphicsConfiguration upstreamConfig = upstreamSurface.getGraphicsConfiguration(); final AbstractGraphicsDevice upstreamDevice = upstreamConfig.getScreen().getDevice(); if (DEBUG) { System.err.println( dbgPrefix + "UpstreamDevice: " + upstreamDevice.getClass().getSimpleName() + ", hash 0x" + Integer.toHexString(upstreamDevice.hashCode()) + ", " + upstreamDevice); System.err.println( dbgPrefix + "UpstreamConfig: " + upstreamConfig.getClass().getSimpleName() + ", hash 0x" + Integer.toHexString(upstreamConfig.hashCode()) + ", " + upstreamConfig); } if (surfaceDevice instanceof EGLGraphicsDevice) { eglDevice = (EGLGraphicsDevice) surfaceDevice; aConfig = surfaceConfig; if (DEBUG) { System.err.println( dbgPrefix + "Reusing this eglDevice: " + eglDevice + ", using this config " + aConfig.getClass().getSimpleName() + " " + aConfig); } if (EGL.EGL_NO_DISPLAY == eglDevice.getHandle()) { eglDevice.open(); isEGLSurfaceValid = false; surface.addUpstreamOptionBits(ProxySurface.OPT_PROXY_OWNS_UPSTREAM_DEVICE); } } else if (upstreamDevice instanceof EGLGraphicsDevice) { eglDevice = (EGLGraphicsDevice) upstreamDevice; aConfig = upstreamConfig; if (DEBUG) { System.err.println( dbgPrefix + "Reusing upstream eglDevice: " + eglDevice + ", using upstream config " + aConfig.getClass().getSimpleName() + " " + aConfig); } if (EGL.EGL_NO_DISPLAY == eglDevice.getHandle()) { eglDevice.open(); isEGLSurfaceValid = false; surface.addUpstreamOptionBits(ProxySurface.OPT_PROXY_OWNS_UPSTREAM_DEVICE); } } else { eglDevice = EGLDisplayUtil.eglCreateEGLGraphicsDevice(upstreamSurface); eglDevice.open(); aConfig = upstreamConfig; isEGLSurfaceValid = false; surface.addUpstreamOptionBits(ProxySurface.OPT_PROXY_OWNS_UPSTREAM_DEVICE); } } final GLCapabilitiesImmutable capsRequested = (GLCapabilitiesImmutable) aConfig.getRequestedCapabilities(); final EGLGraphicsConfiguration eglConfig; if (aConfig instanceof EGLGraphicsConfiguration) { // Config is already in EGL type - reuse .. final EGLGLCapabilities capsChosen = (EGLGLCapabilities) aConfig.getChosenCapabilities(); if (!isEGLSurfaceValid || !EGLGraphicsConfiguration.isEGLConfigValid( eglDevice.getHandle(), capsChosen.getEGLConfig())) { // 'refresh' the native EGLConfig handle capsChosen.setEGLConfig( EGLGraphicsConfiguration.EGLConfigId2EGLConfig( eglDevice.getHandle(), capsChosen.getEGLConfigID())); if (0 == capsChosen.getEGLConfig()) { throw new GLException( "Refreshing native EGLConfig handle failed with error " + EGLContext.toHexString(EGL.eglGetError()) + ": " + eglDevice + ", " + capsChosen + " of " + aConfig); } final AbstractGraphicsScreen eglScreen = new DefaultGraphicsScreen(eglDevice, aConfig.getScreen().getIndex()); eglConfig = new EGLGraphicsConfiguration(eglScreen, capsChosen, capsRequested, null); if (DEBUG) { System.err.println(dbgPrefix + "Refreshing eglConfig: " + eglConfig); } isEGLSurfaceValid = false; } else { eglConfig = (EGLGraphicsConfiguration) aConfig; if (DEBUG) { System.err.println(dbgPrefix + "Reusing eglConfig: " + eglConfig); } } } else { final AbstractGraphicsScreen eglScreen = new DefaultGraphicsScreen(eglDevice, aConfig.getScreen().getIndex()); eglConfig = EGLGraphicsConfigurationFactory.chooseGraphicsConfigurationStatic( capsRequested, capsRequested, null, eglScreen, aConfig.getVisualID(VIDType.NATIVE), false /* forceTransparencyFlag */); if (null == eglConfig) { throw new GLException("Couldn't create EGLGraphicsConfiguration from " + eglScreen); } else if (DEBUG) { System.err.println(dbgPrefix + "Chosen eglConfig: " + eglConfig); } isEGLSurfaceValid = false; } surface.setGraphicsConfiguration(eglConfig); if (isEGLSurfaceValid) { isEGLSurfaceValid = EGLDrawable.isValidEGLSurface(eglDevice.getHandle(), upstreamSurface.getSurfaceHandle()); } if (isEGLSurfaceValid) { surface.setSurfaceHandle(upstreamSurface.getSurfaceHandle()); surface.clearUpstreamOptionBits(ProxySurface.OPT_PROXY_OWNS_UPSTREAM_SURFACE); if (DEBUG) { System.err.println( dbgPrefix + "Fin: Already valid EGL surface - use as-is: " + upstreamSurface); } } else { surface.setSurfaceHandle(EGL.EGL_NO_SURFACE); surface.addUpstreamOptionBits( ProxySurface.OPT_PROXY_OWNS_UPSTREAM_SURFACE); // create/destroy in EGLDrawable if (DEBUG) { System.err.println(dbgPrefix + "Fin: EGL surface n/a - TBD: " + upstreamSurface); } } }
@Override public final int getSurfaceHeight(ProxySurface s) { return upstreamSurface.getSurfaceHeight(); }
@Override public final int getSurfaceWidth(ProxySurface s) { return upstreamSurface.getSurfaceWidth(); }
/** * Moves all GLEventListenerState components to the given {@link GLAutoDrawable} from this * instance, while loosing {@link #isOwner() ownership}. * * <p>If the previous {@link GLAutoDrawable} was removed from a {@link GLAnimatorControl} by * previous {@link #moveFrom(GLAutoDrawable)}, the given {@link GLAutoDrawable} is added to the * cached {@link GLAnimatorControl}. This operation is skipped, if the given {@link * GLAutoDrawable} is already added to a {@link GLAnimatorControl} instance. * * <p>Note: After this operation, the GLEventListenerState reference should be released. * * @param a {@link GLAutoDrawable} destination to move GLEventListenerState components to * @throws GLException if the {@link GLAutoDrawable}'s configuration is incompatible, i.e. * different {@link GLCapabilitiesImmutable}. * @see #moveFrom(GLAutoDrawable) * @see #isOwner() */ public final void moveTo(GLAutoDrawable a) { final List<GLRunnable> aGLCmds = new ArrayList<GLRunnable>(); final int aSz = listenerCount(); final NativeSurface aSurface = a.getNativeSurface(); final MutableGraphicsConfiguration aCfg = (MutableGraphicsConfiguration) aSurface.getGraphicsConfiguration(); final GLCapabilitiesImmutable aCaps = (GLCapabilitiesImmutable) aCfg.getChosenCapabilities(); if (caps.getVisualID(VisualIDHolder.VIDType.INTRINSIC) != aCaps.getVisualID(VisualIDHolder.VIDType.INTRINSIC) || caps.getVisualID(VisualIDHolder.VIDType.NATIVE) != aCaps.getVisualID(VisualIDHolder.VIDType.NATIVE)) { throw new GLException( "Incompatible Capabilities - Prev-Holder: " + caps + ", New-Holder " + caps); } // Destroy and remove currently associated GLContext, if any (will be replaced) { final GLContext ctx = a.getContext(); if (null != ctx) { ctx.destroy(); } a.setContext(null); } final boolean aRealized = a.isRealized(); if (aRealized) { a.setRealized(false); } // Set new Screen and close previous one { if (DEBUG) { System.err.println( "XX0 NativeSurface: " + aSurface.getClass().getName() + ", " + aSurface); } final AbstractGraphicsScreen aScreen1 = aCfg.getScreen(); aCfg.setScreen(screen); aScreen1.getDevice().close(); System.err.println( "XXX NativeSurface: " + aSurface.getClass().getName() + ", " + aSurface); } // If using a ProxySurface w/ an upstream surface, set new Screen and close previous one on it { boolean upstreamSet = false; if (aSurface instanceof ProxySurface) { final ProxySurface aProxy = (ProxySurface) aSurface; final NativeSurface aUpSurface = aProxy.getUpstreamSurface(); if (null != aUpSurface) { final MutableGraphicsConfiguration aUpCfg = (MutableGraphicsConfiguration) aUpSurface.getGraphicsConfiguration(); final AbstractGraphicsScreen aUpScreen1 = aUpCfg.getScreen(); if (null != upstreamScreen) { System.err.println( "XX0 UpstreamSurface: " + aUpSurface.getClass().getName() + ", " + aUpSurface); aUpCfg.setScreen(upstreamScreen); aUpScreen1.getDevice().close(); upstreamSet = true; System.err.println( "XXX UpstreamSurface: " + aUpSurface.getClass().getName() + ", " + aUpSurface); } else { throw new GLException( "Incompatible Surface config - Has Upstream-Surface: Prev-Holder = false, New-Holder = true"); } } } if (!upstreamSet && null != upstreamScreen) { throw new GLException( "Incompatible Surface config - Has Upstream-Surface: Prev-Holder = true, New-Holder = false"); } } if (aRealized) { a.setRealized(true); } final boolean surfaceLocked = false; // NativeSurface.LOCK_SURFACE_NOT_READY < aSurface.lockSurface(); try { a.setContext(context); } finally { if (surfaceLocked) { aSurface.unlockSurface(); } } owner = false; // // Trigger GL-Viewport reset and reshape of all initialized GLEventListeners // aGLCmds.add(setViewport); for (int i = 0; i < aSz; i++) { if (listenersInit[i]) { aGLCmds.add(new ReshapeGLEventListener(listeners[i])); } } aGLCmds.add(glFinish); a.invoke(aRealized, aGLCmds); // only wait if already realized // add all cached GLEventListener to their destination and fix their init-state for (int i = 0; i < aSz; i++) { final GLEventListener l = listeners[i]; a.addGLEventListener(l); a.setGLEventListenerInitState(l, listenersInit[i]); listeners[i] = null; } if (null != anim && null == a.getAnimator()) { anim.add(a); // also handles ECT } }
/** * Moves all GLEventListenerState components from the given {@link GLAutoDrawable} to a newly * created instance. * * <p>Note that all components are removed from the {@link GLAutoDrawable}, i.e. the {@link * GLContext}, all {@link GLEventListener}. * * <p>If the {@link GLAutoDrawable} was added to a {@link GLAnimatorControl}, it is removed and * the {@link GLAnimatorControl} added to the GLEventListenerState. * * <p>The returned GLEventListenerState instance is the {@link #isOwner() owner of the * components}. * * @param a {@link GLAutoDrawable} source to move components from * @return new GLEventListenerState instance {@link #isOwner() owning} moved components. * @see #moveTo(GLAutoDrawable) */ public static GLEventListenerState moveFrom(GLAutoDrawable a) { final int aSz = a.getGLEventListenerCount(); // Create new AbstractGraphicsScreen w/ cloned AbstractGraphicsDevice for future GLAutoDrawable // allowing this AbstractGraphicsDevice to loose ownership -> not closing display/device! final NativeSurface aSurface = a.getNativeSurface(); final AbstractGraphicsConfiguration aCfg = aSurface.getGraphicsConfiguration(); final AbstractGraphicsScreen aScreen1 = aCfg.getScreen(); final GLCapabilitiesImmutable caps = (GLCapabilitiesImmutable) aCfg.getChosenCapabilities(); final AbstractGraphicsScreen aScreen2 = cloneScreen(aScreen1); if (DEBUG) { System.err.println( "X00 NativeSurface: " + aSurface.getClass().getName() + ", " + aSurface); } aScreen1.getDevice().clearHandleOwner(); // don't close device handle final AbstractGraphicsScreen aUpScreen2; { AbstractGraphicsScreen _aUpScreen2 = null; if (aSurface instanceof ProxySurface) { final ProxySurface aProxy = (ProxySurface) aSurface; final NativeSurface aUpSurface = aProxy.getUpstreamSurface(); if (null != aUpSurface) { System.err.println( "X00 UpstreamSurface: " + aUpSurface.getClass().getName() + ", " + aUpSurface); } aProxy.clearUpstreamOptionBits( ProxySurface.OPT_PROXY_OWNS_UPSTREAM_DEVICE); // don't close device handle if (null != aUpSurface) { final AbstractGraphicsScreen aUpScreen1 = aUpSurface.getGraphicsConfiguration().getScreen(); _aUpScreen2 = cloneScreen(aUpScreen1); if (null != aUpScreen1) { aUpScreen1.getDevice().clearHandleOwner(); // don't close device handle } System.err.println( "X0X NativeSurface: " + aSurface.getClass().getName() + ", " + aSurface); System.err.println( "X0X UpstreamSurface: " + aUpSurface.getClass().getName() + ", " + aUpSurface); } } aUpScreen2 = _aUpScreen2; } final GLAnimatorControl aAnim = a.getAnimator(); if (null != aAnim) { aAnim.remove(a); // also handles ECT } final GLEventListenerState glls = new GLEventListenerState(aUpScreen2, aScreen2, caps, a.getContext(), aSz, aAnim); // // remove and cache all GLEventListener and their init-state // for (int i = 0; i < aSz; i++) { final GLEventListener l = a.getGLEventListener(0); glls.listenersInit[i] = a.getGLEventListenerInitState(l); glls.listeners[i] = a.removeGLEventListener(l); } // // trigger glFinish to sync GL ctx // a.invoke(true, glFinish); a.setContext(null); return glls; }