SharedResource(
X11GraphicsDevice dev,
X11GraphicsScreen scrn,
GLDrawableImpl draw,
GLContextImpl ctx,
VersionNumber glXServerVer,
String glXServerVendor,
boolean glXServerMultisampleAvail) {
device = dev;
screen = scrn;
drawable = draw;
context = ctx;
glXServerVersion = glXServerVer;
glXServerVersionOneOneCapable = glXServerVersion.compareTo(versionOneOne) >= 0;
glXServerVersionOneThreeCapable = glXServerVersion.compareTo(versionOneThree) >= 0;
glXServerVendorName = glXServerVendor;
isGLXServerVendorATI = GLXUtil.isVendorATI(glXServerVendorName);
isGLXServerVendorNVIDIA = GLXUtil.isVendorNVIDIA(glXServerVendorName);
glXMultisampleAvailable = glXServerMultisampleAvail;
}
public final VersionNumber getGLXVersionNumber(AbstractGraphicsDevice device) {
if (null != device) {
SharedResource sr = (SharedResource) sharedResourceRunner.getOrCreateShared(device);
if (null != sr) {
return sr.getGLXVersion();
}
if (device instanceof X11GraphicsDevice) {
return GLXUtil.getGLXServerVersionNumber((X11GraphicsDevice) device);
}
}
return null;
}
public final boolean isGLXVersionGreaterEqualOneThree(AbstractGraphicsDevice device) {
if (null != device) {
SharedResource sr = (SharedResource) sharedResourceRunner.getOrCreateShared(device);
if (null != sr) {
return sr.isGLXVersionGreaterEqualOneThree();
}
if (device instanceof X11GraphicsDevice) {
final VersionNumber glXServerVersion =
GLXUtil.getGLXServerVersionNumber((X11GraphicsDevice) device);
return glXServerVersion.compareTo(versionOneThree) >= 0;
}
}
return false;
}
protected AbstractGraphicsConfiguration chooseGraphicsConfigurationImpl(
CapabilitiesImmutable capsChosen,
CapabilitiesImmutable capsRequested,
CapabilitiesChooser chooser,
AbstractGraphicsScreen absScreen) {
if (!(absScreen instanceof X11GraphicsScreen)) {
throw new IllegalArgumentException("Only X11GraphicsScreen are allowed here");
}
if (!(capsChosen instanceof GLCapabilitiesImmutable)) {
throw new IllegalArgumentException(
"This NativeWindowFactory accepts only GLCapabilities objects - chosen");
}
if (!(capsRequested instanceof GLCapabilitiesImmutable)) {
throw new IllegalArgumentException(
"This NativeWindowFactory accepts only GLCapabilities objects - requested");
}
if (chooser != null && !(chooser instanceof GLCapabilitiesChooser)) {
throw new IllegalArgumentException(
"This NativeWindowFactory accepts only GLCapabilitiesChooser objects");
}
if (!GLXUtil.isGLXAvailableOnServer((X11GraphicsDevice) absScreen.getDevice())) {
if (null != fallbackX11GraphicsConfigurationFactory) {
if (DEBUG) {
System.err.println(
"No GLX available, fallback to "
+ fallbackX11GraphicsConfigurationFactory.getClass().getSimpleName()
+ " for: "
+ absScreen);
}
return fallbackX11GraphicsConfigurationFactory.chooseGraphicsConfiguration(
capsChosen, capsRequested, chooser, absScreen);
}
throw new InternalError(
"No GLX and no fallback GraphicsConfigurationFactory available for: " + absScreen);
}
return chooseGraphicsConfigurationStatic(
(GLCapabilitiesImmutable) capsChosen, (GLCapabilitiesImmutable) capsRequested,
(GLCapabilitiesChooser) chooser, (X11GraphicsScreen) absScreen);
}
@Override
public boolean isDeviceSupported(final AbstractGraphicsDevice device) {
final boolean res;
final X11GraphicsDevice x11Device =
new X11GraphicsDevice(
X11Util.openDisplay(device.getConnection()), device.getUnitID(), true /* owner */);
x11Device.lock();
try {
res = GLXUtil.isGLXAvailableOnServer(x11Device);
} finally {
x11Device.unlock();
x11Device.close();
}
if (DEBUG) {
System.err.println(
"GLX " + (res ? "is" : "not") + " available on device/server: " + x11Device);
}
return res;
}
@Override
public SharedResourceRunner.Resource createSharedResource(String connection) {
final X11GraphicsDevice sharedDevice =
new X11GraphicsDevice(
X11Util.openDisplay(connection),
AbstractGraphicsDevice.DEFAULT_UNIT,
true /* owner */);
sharedDevice.lock();
try {
final X11GraphicsScreen sharedScreen =
new X11GraphicsScreen(sharedDevice, sharedDevice.getDefaultScreen());
GLXUtil.initGLXClientDataSingleton(sharedDevice);
final String glXServerVendorName =
GLX.glXQueryServerString(sharedDevice.getHandle(), 0, GLX.GLX_VENDOR);
final boolean glXServerMultisampleAvailable =
GLXUtil.isMultisampleAvailable(
GLX.glXQueryServerString(sharedDevice.getHandle(), 0, GLX.GLX_EXTENSIONS));
final GLProfile glp =
GLProfile.get(sharedDevice, GLProfile.GL_PROFILE_LIST_MIN_DESKTOP, false);
if (null == glp) {
throw new GLException("Couldn't get default GLProfile for device: " + sharedDevice);
}
final GLCapabilitiesImmutable caps = new GLCapabilities(glp);
final GLDrawableImpl sharedDrawable =
createOnscreenDrawableImpl(
createDummySurfaceImpl(sharedDevice, false, caps, caps, null, 64, 64));
sharedDrawable.setRealized(true);
final X11GLCapabilities chosenCaps =
(X11GLCapabilities) sharedDrawable.getChosenGLCapabilities();
final boolean glxForcedOneOne = !chosenCaps.hasFBConfig();
final VersionNumber glXServerVersion;
if (glxForcedOneOne) {
glXServerVersion = versionOneOne;
} else {
glXServerVersion = GLXUtil.getGLXServerVersionNumber(sharedDevice);
}
final GLContextImpl sharedContext = (GLContextImpl) sharedDrawable.createContext(null);
if (null == sharedContext) {
throw new GLException("Couldn't create shared context for drawable: " + sharedDrawable);
}
boolean madeCurrent = false;
sharedContext.makeCurrent();
try {
madeCurrent = sharedContext.isCurrent();
} finally {
sharedContext.release();
}
if (sharedContext.hasRendererQuirk(GLRendererQuirks.DontCloseX11Display)) {
X11Util.markAllDisplaysUnclosable();
}
if (DEBUG) {
System.err.println("SharedDevice: " + sharedDevice);
System.err.println("SharedScreen: " + sharedScreen);
System.err.println("SharedContext: " + sharedContext + ", madeCurrent " + madeCurrent);
System.err.println("GLX Server Vendor: " + glXServerVendorName);
System.err.println(
"GLX Server Version: " + glXServerVersion + ", forced " + glxForcedOneOne);
System.err.println("GLX Server Multisample: " + glXServerMultisampleAvailable);
System.err.println("GLX Client Vendor: " + GLXUtil.getClientVendorName());
System.err.println("GLX Client Version: " + GLXUtil.getClientVersionNumber());
System.err.println("GLX Client Multisample: " + GLXUtil.isClientMultisampleAvailable());
}
return new SharedResource(
sharedDevice,
sharedScreen,
sharedDrawable,
sharedContext,
glXServerVersion,
glXServerVendorName,
glXServerMultisampleAvailable && GLXUtil.isClientMultisampleAvailable());
} catch (Throwable t) {
throw new GLException(
"X11GLXDrawableFactory - Could not initialize shared resources for " + connection, t);
} finally {
sharedDevice.unlock();
}
}
@Override
public SharedResourceRunner.Resource createSharedResource(
final AbstractGraphicsDevice adevice) {
final X11GraphicsDevice device =
new X11GraphicsDevice(
X11Util.openDisplay(adevice.getConnection()), adevice.getUnitID(), true /* owner */);
GLContextImpl context = null;
boolean contextIsCurrent = false;
device.lock();
try {
final X11GraphicsScreen screen = new X11GraphicsScreen(device, device.getDefaultScreen());
GLXUtil.initGLXClientDataSingleton(device);
final String glXServerVendorName =
GLX.glXQueryServerString(device.getHandle(), 0, GLX.GLX_VENDOR);
final boolean glXServerMultisampleAvailable =
GLXUtil.isMultisampleAvailable(
GLX.glXQueryServerString(device.getHandle(), 0, GLX.GLX_EXTENSIONS));
final GLProfile glp = GLProfile.get(device, GLProfile.GL_PROFILE_LIST_MIN_DESKTOP, false);
if (null == glp) {
throw new GLException("Couldn't get default GLProfile for device: " + device);
}
final GLCapabilitiesImmutable caps = new GLCapabilities(glp);
final GLDrawableImpl drawable =
createOnscreenDrawableImpl(
createDummySurfaceImpl(device, false, caps, caps, null, 64, 64));
drawable.setRealized(true);
final X11GLCapabilities chosenCaps = (X11GLCapabilities) drawable.getChosenGLCapabilities();
final boolean glxForcedOneOne = !chosenCaps.hasFBConfig();
final VersionNumber glXServerVersion;
if (glxForcedOneOne) {
glXServerVersion = versionOneOne;
} else {
glXServerVersion = GLXUtil.getGLXServerVersionNumber(device);
}
context = (GLContextImpl) drawable.createContext(null);
if (null == context) {
throw new GLException("Couldn't create shared context for drawable: " + drawable);
}
contextIsCurrent = GLContext.CONTEXT_NOT_CURRENT != context.makeCurrent();
final boolean allowsSurfacelessCtx;
if (contextIsCurrent && context.getGLVersionNumber().compareTo(GLContext.Version3_0) >= 0) {
allowsSurfacelessCtx = probeSurfacelessCtx(context, true /* restoreDrawable */);
} else {
setNoSurfacelessCtxQuirk(context);
allowsSurfacelessCtx = false;
}
if (context.hasRendererQuirk(GLRendererQuirks.DontCloseX11Display)) {
X11Util.markAllDisplaysUnclosable();
}
if (DEBUG_SHAREDCTX) {
System.err.println("SharedDevice: " + device);
System.err.println("SharedScreen: " + screen);
System.err.println("SharedContext: " + context + ", madeCurrent " + contextIsCurrent);
System.err.println(" allowsSurfacelessCtx " + allowsSurfacelessCtx);
System.err.println("GLX Server Vendor: " + glXServerVendorName);
System.err.println(
"GLX Server Version: " + glXServerVersion + ", forced " + glxForcedOneOne);
System.err.println("GLX Server Multisample: " + glXServerMultisampleAvailable);
System.err.println("GLX Client Vendor: " + GLXUtil.getClientVendorName());
System.err.println("GLX Client Version: " + GLXUtil.getClientVersionNumber());
System.err.println("GLX Client Multisample: " + GLXUtil.isClientMultisampleAvailable());
}
return new SharedResource(
device,
screen,
drawable,
context,
glXServerVersion,
glXServerVendorName,
glXServerMultisampleAvailable && GLXUtil.isClientMultisampleAvailable());
} catch (final Throwable t) {
throw new GLException(
"X11GLXDrawableFactory - Could not initialize shared resources for " + adevice, t);
} finally {
if (contextIsCurrent) {
context.release();
}
device.unlock();
}
}
