static X11GLXGraphicsConfiguration fetchGraphicsConfigurationFBConfig(
X11GraphicsScreen x11Screen, int fbID, GLProfile glp) {
final AbstractGraphicsDevice absDevice = x11Screen.getDevice();
final long display = absDevice.getHandle();
final int screen = x11Screen.getIndex();
final long fbcfg = X11GLXGraphicsConfiguration.glXFBConfigID2FBConfig(display, screen, fbID);
if (0 == fbcfg || !X11GLXGraphicsConfiguration.GLXFBConfigValid(display, fbcfg)) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: Failed - GLX FBConfig invalid: ("
+ x11Screen
+ ","
+ toHexString(fbID)
+ "): fbcfg: "
+ toHexString(fbcfg));
}
return null;
}
final X11GLXDrawableFactory factory =
(X11GLXDrawableFactory) GLDrawableFactory.getDesktopFactory();
final X11GLCapabilities caps =
X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(
glp, display, fbcfg, true, true, true, factory.isGLXMultisampleAvailable(absDevice));
return new X11GLXGraphicsConfiguration(
x11Screen, caps, caps, new DefaultGLCapabilitiesChooser());
}
static List<GLCapabilitiesImmutable> getAvailableGLCapabilitiesXVisual(
X11GraphicsScreen x11Screen, GLProfile glProfile, boolean isMultisampleAvailable) {
AbstractGraphicsDevice absDevice = x11Screen.getDevice();
long display = absDevice.getHandle();
int screen = x11Screen.getIndex();
int[] count = new int[1];
XVisualInfo template = XVisualInfo.create();
template.setScreen(screen);
XVisualInfo[] infos =
X11Lib.XGetVisualInfo(display, X11Lib.VisualScreenMask, template, count, 0);
if (infos == null || infos.length < 1) {
throw new GLException("Error while enumerating available XVisualInfos");
}
ArrayList<GLCapabilitiesImmutable> availableCaps = new ArrayList<GLCapabilitiesImmutable>();
for (int i = 0; i < infos.length; i++) {
if (!X11GLXGraphicsConfiguration.XVisualInfo2GLCapabilities(
availableCaps,
glProfile,
display,
infos[i],
GLGraphicsConfigurationUtil.ALL_BITS,
isMultisampleAvailable)) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.getAvailableGLCapabilitiesXVisual: XVisual invalid: ("
+ x11Screen
+ "): fbcfg: "
+ toHexString(infos[i].getVisualid()));
}
}
}
return availableCaps;
}
protected static List<GLCapabilitiesImmutable> getAvailableCapabilities(
X11GLXDrawableFactory factory, AbstractGraphicsDevice device) {
X11GLXDrawableFactory.SharedResource sharedResource = factory.getOrCreateSharedResource(device);
if (null == sharedResource) {
throw new GLException("Shared resource for device n/a: " + device);
}
final X11GraphicsScreen sharedScreen = (X11GraphicsScreen) sharedResource.getScreen();
final boolean isMultisampleAvailable =
factory.isGLXMultisampleAvailable(sharedScreen.getDevice());
final X11GLXDrawable sharedDrawable = (X11GLXDrawable) sharedResource.getDrawable();
final GLCapabilitiesImmutable capsChosen = sharedDrawable.getChosenGLCapabilities();
final GLProfile glp = capsChosen.getGLProfile();
List<GLCapabilitiesImmutable> availableCaps = null;
if (sharedResource.isGLXVersionGreaterEqualOneThree()) {
availableCaps = getAvailableGLCapabilitiesFBConfig(sharedScreen, glp, isMultisampleAvailable);
}
if (null == availableCaps || availableCaps.isEmpty()) {
availableCaps = getAvailableGLCapabilitiesXVisual(sharedScreen, glp, isMultisampleAvailable);
}
if (null != availableCaps && availableCaps.size() > 1) {
Collections.sort(availableCaps, XVisualIDComparator);
}
return availableCaps;
}
protected static X11ExternalGLXContext create(GLDrawableFactory factory, GLProfile glp) {
long ctx = GLX.glXGetCurrentContext();
if (ctx == 0) {
throw new GLException("Error: current context null");
}
long display = GLX.glXGetCurrentDisplay();
if (display == 0) {
throw new GLException("Error: current display null");
}
long drawable = GLX.glXGetCurrentDrawable();
if (drawable == 0) {
throw new GLException(
"Error: attempted to make an external GLDrawable without a drawable/context current");
}
IntBuffer val = Buffers.newDirectIntBuffer(1);
int w, h;
GLX.glXQueryDrawable(display, drawable, GLX.GLX_WIDTH, val);
w = val.get(0);
GLX.glXQueryDrawable(display, drawable, GLX.GLX_HEIGHT, val);
h = val.get(0);
GLX.glXQueryContext(display, ctx, GLX.GLX_SCREEN, val);
X11GraphicsScreen x11Screen =
(X11GraphicsScreen) X11GraphicsScreen.createScreenDevice(display, val.get(0), false);
GLX.glXQueryContext(display, ctx, GLX.GLX_FBCONFIG_ID, val);
X11GLXGraphicsConfiguration cfg = null;
// sometimes glXQueryContext on an external context gives us a framebuffer config ID
// of 0, which doesn't work in a subsequent call to glXChooseFBConfig; if this happens,
// create and use a default config (this has been observed when running on CentOS 5.5 inside
// of VMWare Server 2.0 with the Mesa 6.5.1 drivers)
if (VisualIDHolder.VID_UNDEFINED == val.get(0)
|| !X11GLXGraphicsConfiguration.GLXFBConfigIDValid(
display, x11Screen.getIndex(), val.get(0))) {
GLCapabilities glcapsDefault = new GLCapabilities(GLProfile.getDefault());
cfg =
X11GLXGraphicsConfigurationFactory.chooseGraphicsConfigurationStatic(
glcapsDefault, glcapsDefault, null, x11Screen, VisualIDHolder.VID_UNDEFINED);
if (DEBUG) {
System.err.println(
"X11ExternalGLXContext invalid FBCONFIG_ID "
+ val.get(0)
+ ", using default cfg: "
+ cfg);
}
} else {
cfg = X11GLXGraphicsConfiguration.create(glp, x11Screen, val.get(0));
}
final WrappedSurface ns = new WrappedSurface(cfg, drawable, w, h, true);
return new X11ExternalGLXContext(new Drawable(factory, ns), ctx);
}
static List<GLCapabilitiesImmutable> getAvailableGLCapabilitiesFBConfig(
X11GraphicsScreen x11Screen, GLProfile glProfile, boolean isMultisampleAvailable) {
PointerBuffer fbcfgsL = null;
// Utilizing FBConfig
//
AbstractGraphicsDevice absDevice = x11Screen.getDevice();
long display = absDevice.getHandle();
int screen = x11Screen.getIndex();
int[] count = {-1};
ArrayList<GLCapabilitiesImmutable> availableCaps = new ArrayList<GLCapabilitiesImmutable>();
fbcfgsL = GLX.glXChooseFBConfig(display, screen, null, 0, count, 0);
if (fbcfgsL == null || fbcfgsL.limit() <= 0) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.getAvailableGLCapabilitiesFBConfig: Failed glXChooseFBConfig ("
+ x11Screen
+ "): "
+ fbcfgsL
+ ", "
+ count[0]);
}
return null;
}
for (int i = 0; i < fbcfgsL.limit(); i++) {
if (!X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(
availableCaps,
glProfile,
display,
fbcfgsL.get(i),
GLGraphicsConfigurationUtil.ALL_BITS,
isMultisampleAvailable)) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.getAvailableGLCapabilitiesFBConfig: FBConfig invalid (2): ("
+ x11Screen
+ "): fbcfg: "
+ toHexString(fbcfgsL.get(i)));
}
}
}
return availableCaps;
}
static X11GLXGraphicsConfiguration chooseGraphicsConfigurationStatic(
GLCapabilitiesImmutable capsChosen,
GLCapabilitiesImmutable capsReq,
GLCapabilitiesChooser chooser,
X11GraphicsScreen x11Screen) {
if (x11Screen == null) {
throw new IllegalArgumentException("AbstractGraphicsScreen is null");
}
if (capsChosen == null) {
capsChosen = new GLCapabilities(null);
}
X11GraphicsDevice x11Device = (X11GraphicsDevice) x11Screen.getDevice();
X11GLXDrawableFactory factory = (X11GLXDrawableFactory) GLDrawableFactory.getDesktopFactory();
capsChosen =
GLGraphicsConfigurationUtil.fixGLCapabilities(
capsChosen, factory.canCreateGLPbuffer(x11Device));
boolean usePBuffer = capsChosen.isPBuffer();
X11GLXGraphicsConfiguration res = null;
if (factory.isGLXVersionGreaterEqualOneThree(x11Device)) {
res = chooseGraphicsConfigurationFBConfig(capsChosen, capsReq, chooser, x11Screen);
}
if (null == res) {
if (usePBuffer) {
throw new GLException(
"Error: Couldn't create X11GLXGraphicsConfiguration based on FBConfig for "
+ capsChosen);
}
res = chooseGraphicsConfigurationXVisual(capsChosen, capsReq, chooser, x11Screen);
}
if (null == res) {
throw new GLException(
"Error: Couldn't create X11GLXGraphicsConfiguration based on FBConfig and XVisual for "
+ capsChosen);
}
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationStatic("
+ x11Screen
+ ","
+ capsChosen
+ "): "
+ res);
}
return res;
}
private static X11GLXGraphicsConfiguration chooseGraphicsConfigurationXVisual(
GLCapabilitiesImmutable capsChosen,
GLCapabilitiesImmutable capsReq,
GLCapabilitiesChooser chooser,
X11GraphicsScreen x11Screen) {
if (chooser == null) {
chooser = new DefaultGLCapabilitiesChooser();
}
GLProfile glProfile = capsChosen.getGLProfile();
final int winattrmask =
GLGraphicsConfigurationUtil.getWinAttributeBits(
capsChosen.isOnscreen(), false /* pbuffer */);
ArrayList availableCaps = new ArrayList();
int recommendedIndex = -1;
AbstractGraphicsDevice absDevice = x11Screen.getDevice();
long display = absDevice.getHandle();
int screen = x11Screen.getIndex();
final X11GLXDrawableFactory factory =
(X11GLXDrawableFactory) GLDrawableFactory.getDesktopFactory();
final boolean isMultisampleAvailable = factory.isGLXMultisampleAvailable(absDevice);
int[] attribs =
X11GLXGraphicsConfiguration.GLCapabilities2AttribList(
capsChosen, false, isMultisampleAvailable, display, screen);
// 1st choice: get GLCapabilities based on users GLCapabilities setting recommendedIndex as
// preferred choice
XVisualInfo recommendedVis = GLX.glXChooseVisual(display, screen, attribs, 0);
if (DEBUG) {
System.err.print("glXChooseVisual recommended ");
if (recommendedVis == null) {
System.err.println("null visual");
} else {
System.err.println("visual id " + toHexString(recommendedVis.getVisualid()));
}
}
// 2nd choice: get all GLCapabilities available, preferred recommendedIndex might be available
// if 1st choice was successful
int[] count = new int[1];
XVisualInfo template = XVisualInfo.create();
template.setScreen(screen);
XVisualInfo[] infos =
X11Lib.XGetVisualInfo(display, X11Lib.VisualScreenMask, template, count, 0);
if (infos == null || infos.length < 1) {
throw new GLException("Error while enumerating available XVisualInfos");
}
for (int i = 0; i < infos.length; i++) {
if (!X11GLXGraphicsConfiguration.XVisualInfo2GLCapabilities(
availableCaps, glProfile, display, infos[i], winattrmask, isMultisampleAvailable)) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationXVisual: XVisual invalid: ("
+ x11Screen
+ "): fbcfg: "
+ toHexString(infos[i].getVisualid()));
}
} else {
// Attempt to find the visual chosenIndex by glXChooseVisual, if not translucent
if (capsChosen.isBackgroundOpaque()
&& recommendedVis != null
&& recommendedVis.getVisualid() == infos[i].getVisualid()) {
recommendedIndex = availableCaps.size() - 1;
}
}
}
int chosenIndex = chooseCapabilities(chooser, capsChosen, availableCaps, recommendedIndex);
if (0 > chosenIndex) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationXVisual: failed, return null");
Thread.dumpStack();
}
return null;
}
X11GLCapabilities chosenCaps = (X11GLCapabilities) availableCaps.get(chosenIndex);
return new X11GLXGraphicsConfiguration(x11Screen, chosenCaps, capsReq, chooser);
}
private static X11GLXGraphicsConfiguration chooseGraphicsConfigurationFBConfig(
GLCapabilitiesImmutable capsChosen,
GLCapabilitiesImmutable capsReq,
GLCapabilitiesChooser chooser,
X11GraphicsScreen x11Screen) {
int recommendedIndex = -1;
PointerBuffer fbcfgsL = null;
GLProfile glProfile = capsChosen.getGLProfile();
boolean onscreen = capsChosen.isOnscreen();
boolean usePBuffer = capsChosen.isPBuffer();
// Utilizing FBConfig
//
AbstractGraphicsDevice absDevice = x11Screen.getDevice();
long display = absDevice.getHandle();
int screen = x11Screen.getIndex();
final X11GLXDrawableFactory factory =
(X11GLXDrawableFactory) GLDrawableFactory.getDesktopFactory();
final boolean isMultisampleAvailable = factory.isGLXMultisampleAvailable(absDevice);
int[] attribs =
X11GLXGraphicsConfiguration.GLCapabilities2AttribList(
capsChosen, true, isMultisampleAvailable, display, screen);
int[] count = {-1};
ArrayList /*<X11GLCapabilities>*/ availableCaps = new ArrayList();
final int winattrmask = GLGraphicsConfigurationUtil.getWinAttributeBits(onscreen, usePBuffer);
// 1st choice: get GLCapabilities based on users GLCapabilities setting recommendedIndex as
// preferred choice
fbcfgsL = GLX.glXChooseFBConfig(display, screen, attribs, 0, count, 0);
if (fbcfgsL != null && fbcfgsL.limit() > 0) {
for (int i = 0; i < fbcfgsL.limit(); i++) {
if (!X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(
availableCaps,
glProfile,
display,
fbcfgsL.get(i),
winattrmask,
isMultisampleAvailable)) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: FBConfig invalid (1): ("
+ x11Screen
+ ","
+ capsChosen
+ "): fbcfg: "
+ toHexString(fbcfgsL.get(i)));
}
}
}
if (availableCaps.size() > 0) {
recommendedIndex =
capsChosen.isBackgroundOpaque() ? 0 : -1; // only use recommended idx if not translucent
if (DEBUG) {
System.err.println(
"glXChooseFBConfig recommended fbcfg "
+ toHexString(fbcfgsL.get(0))
+ ", idx "
+ recommendedIndex);
System.err.println("user caps " + capsChosen);
System.err.println("fbcfg caps " + availableCaps.get(0));
}
} else if (DEBUG) {
System.err.println(
"glXChooseFBConfig no caps for recommended fbcfg " + toHexString(fbcfgsL.get(0)));
System.err.println("user caps " + capsChosen);
}
}
// 2nd choice: get all GLCapabilities available, no preferred recommendedIndex available
if (0 == availableCaps.size()) {
// reset ..
recommendedIndex = -1;
fbcfgsL = GLX.glXChooseFBConfig(display, screen, null, 0, count, 0);
if (fbcfgsL == null || fbcfgsL.limit() <= 0) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: Failed glXChooseFBConfig ("
+ x11Screen
+ ","
+ capsChosen
+ "): "
+ fbcfgsL
+ ", "
+ count[0]);
}
return null;
}
for (int i = 0; i < fbcfgsL.limit(); i++) {
if (!X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(
availableCaps,
glProfile,
display,
fbcfgsL.get(i),
winattrmask,
isMultisampleAvailable)) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: FBConfig invalid (2): ("
+ x11Screen
+ "): fbcfg: "
+ toHexString(fbcfgsL.get(i)));
}
}
}
}
int chosenIndex = chooseCapabilities(chooser, capsChosen, availableCaps, recommendedIndex);
if (0 > chosenIndex) {
if (DEBUG) {
System.err.println(
"X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: failed, return null");
Thread.dumpStack();
}
return null;
}
X11GLCapabilities chosenCaps = (X11GLCapabilities) availableCaps.get(chosenIndex);
return new X11GLXGraphicsConfiguration(x11Screen, chosenCaps, capsReq, chooser);
}