aboutsummaryrefslogtreecommitdiffstats
path: root/src/jogl/classes/com/jogamp/opengl/impl
diff options
context:
space:
mode:
Diffstat (limited to 'src/jogl/classes/com/jogamp/opengl/impl')
-rw-r--r--src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsExternalWGLContext.java4
-rw-r--r--src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsPbufferWGLDrawable.java24
-rw-r--r--src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLContext.java6
-rw-r--r--src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLDrawableFactory.java3
-rw-r--r--src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLGraphicsConfiguration.java263
-rw-r--r--src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java450
-rw-r--r--src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXGraphicsConfigurationFactory.java148
7 files changed, 539 insertions, 359 deletions
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsExternalWGLContext.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsExternalWGLContext.java
index f50b1a716..173109db9 100644
--- a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsExternalWGLContext.java
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsExternalWGLContext.java
@@ -66,7 +66,9 @@ public class WindowsExternalWGLContext extends WindowsWGLContext {
}
GLContextShareSet.contextCreated(this);
setGLFunctionAvailability(false, 0, 0, CTX_PROFILE_COMPAT|CTX_OPTION_ANY);
- cfg.updateCapabilitiesByWGL(this);
+ WindowsWGLGraphicsConfiguration config =
+ (WindowsWGLGraphicsConfiguration)drawable.getNativeSurface().getGraphicsConfiguration().getNativeGraphicsConfiguration();
+ config.updateGraphicsConfiguration(drawable.getFactory(), drawable.getNativeSurface());
getGLStateTracker().setEnabled(false); // external context usage can't track state in Java
}
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsPbufferWGLDrawable.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsPbufferWGLDrawable.java
index 842096e55..47b33dd6b 100644
--- a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsPbufferWGLDrawable.java
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsPbufferWGLDrawable.java
@@ -51,7 +51,6 @@ import javax.media.opengl.GLProfile;
import com.jogamp.nativewindow.impl.windows.GDI;
import com.jogamp.nativewindow.impl.windows.PIXELFORMATDESCRIPTOR;
-import com.jogamp.opengl.impl.GLContextImpl;
import javax.media.opengl.GLCapabilitiesImmutable;
public class WindowsPbufferWGLDrawable extends WindowsWGLDrawable {
@@ -145,10 +144,7 @@ public class WindowsPbufferWGLDrawable extends WindowsWGLDrawable {
}
if(!WindowsWGLGraphicsConfiguration.GLCapabilities2AttribList(capabilities,
- iattributes,
- sharedCtx,
- true,
- floatModeTmp)){
+ iattributes, sharedCtx, -1, true, floatModeTmp)){
throw new GLException("Pbuffer-related extensions not supported");
}
@@ -166,11 +162,11 @@ public class WindowsPbufferWGLDrawable extends WindowsWGLDrawable {
int nformats;
int[] nformatsTmp = new int[1];
if (!wglExt.wglChoosePixelFormatARB(parentHdc,
- iattributes, 0,
- fattributes, 0,
- WindowsWGLGraphicsConfiguration.MAX_PFORMATS,
- pformats, 0,
- nformatsTmp, 0)) {
+ iattributes, 0,
+ fattributes, 0,
+ WindowsWGLGraphicsConfiguration.MAX_PFORMATS,
+ pformats, 0,
+ nformatsTmp, 0)) {
throw new GLException("pbuffer creation error: wglChoosePixelFormat() failed");
}
nformats = nformatsTmp[0];
@@ -304,16 +300,16 @@ public class WindowsPbufferWGLDrawable extends WindowsWGLDrawable {
iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_PBUFFER_ARB;
int[] ivalues = new int[niattribs];
if (wglExt.wglGetPixelFormatAttribivARB(parentHdc, pformats[whichFormat], 0, niattribs, iattributes, 0, ivalues, 0)) {
- GLCapabilitiesImmutable newCaps = WindowsWGLGraphicsConfiguration.AttribList2GLCapabilities(glProfile, iattributes, niattribs, ivalues, true, false, true);
+ GLCapabilitiesImmutable newCaps = WindowsWGLGraphicsConfiguration.AttribList2GLCapabilities(glProfile, iattributes, niattribs, ivalues, false, true);
+ if(null == newCaps|| newCaps.isOnscreen() || !newCaps.isPBuffer()) {
+ throw new GLException("Error: Selected Onscreen Caps for PBuffer: "+newCaps);
+ }
PIXELFORMATDESCRIPTOR pfd = WindowsWGLGraphicsConfiguration.createPixelFormatDescriptor();
if (GDI.DescribePixelFormat(parentHdc, pformats[whichFormat], pfd.size(), pfd) == 0) {
if (DEBUG) {
System.err.println("Unable to describe pixel format (Continue: true) " + whichFormat + "/" + nformats + " pfdID " + pformats[whichFormat]+":\n\t"+newCaps);
}
}
- if(newCaps.isOnscreen()) {
- throw new GLException("Error: Selected Onscreen Caps for PBuffer: "+newCaps+"\n\t"+newCaps);
- }
config.setCapsPFD(newCaps, pfd, pformats[whichFormat], true);
} else {
PIXELFORMATDESCRIPTOR pfd = WindowsWGLGraphicsConfiguration.createPixelFormatDescriptor();
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLContext.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLContext.java
index 816532262..c0bab78b0 100644
--- a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLContext.java
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLContext.java
@@ -344,12 +344,6 @@ public class WindowsWGLContext extends GLContextImpl {
}
}
}
-
- if (newCreated) {
- WindowsWGLGraphicsConfiguration config =
- (WindowsWGLGraphicsConfiguration)drawable.getNativeSurface().getGraphicsConfiguration().getNativeGraphicsConfiguration();
- config.updateCapabilitiesByWGL(this);
- }
}
protected void releaseImpl() throws GLException {
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLDrawableFactory.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLDrawableFactory.java
index 2e29e9c83..80261114f 100644
--- a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLDrawableFactory.java
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLDrawableFactory.java
@@ -213,6 +213,9 @@ public class WindowsWGLDrawableFactory extends GLDrawableFactoryImpl {
}
sharedMap.clear();
+ if (DEBUG) {
+ System.err.println("!!! Shutdown Shared Finished");
+ }
}
protected final GLDrawableImpl createOnscreenDrawableImpl(NativeSurface target) {
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLGraphicsConfiguration.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLGraphicsConfiguration.java
index c01072a6f..13df54d0e 100644
--- a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLGraphicsConfiguration.java
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLGraphicsConfiguration.java
@@ -101,30 +101,10 @@ public class WindowsWGLGraphicsConfiguration extends DefaultGraphicsConfiguratio
return super.clone();
}
- /** Update config - before having a valid context */
protected void updateGraphicsConfiguration(GLDrawableFactory factory, NativeSurface ns) {
WindowsWGLGraphicsConfigurationFactory.updateGraphicsConfiguration(chooser, factory, ns);
}
- /** Update config - after having a valid and current context */
- protected void updateCapabilitiesByWGL(WindowsWGLContext context) {
- if(choosenByWGLPixelFormat) return; // already done ..
-
- GLCapabilitiesImmutable capabilities = (GLCapabilitiesImmutable) getRequestedCapabilities();
- boolean onscreen = capabilities.isOnscreen();
- boolean usePBuffer = capabilities.isPBuffer();
- GLProfile glp = capabilities.getGLProfile();
-
- GLDrawable drawable = context.getGLDrawable();
- NativeSurface ns = drawable.getNativeSurface();
- long hdc = ns.getSurfaceHandle();
-
- GLCapabilitiesImmutable[] caps = HDC2GLCapabilities(context, hdc, getPixelFormatID(), glp, true, onscreen, usePBuffer);
- if(null!=caps && null!=caps[0]) {
- setCapsPFD(caps[0], getPixelFormat(), getPixelFormatID(), true);
- }
- }
-
protected void setCapsPFD(GLCapabilitiesImmutable caps, PIXELFORMATDESCRIPTOR pfd, int pfdID, boolean choosenByWGLPixelFormat) {
this.pixelfmt = pfd;
this.pixelfmtID = pfdID;
@@ -144,19 +124,158 @@ public class WindowsWGLGraphicsConfiguration extends DefaultGraphicsConfiguratio
public int getPixelFormatID() { return pixelfmtID; }
public boolean isChoosenByWGL() { return choosenByWGLPixelFormat; }
- public static GLCapabilitiesImmutable[] HDC2GLCapabilities(WindowsWGLContext sharedCtx, long hdc, int pfdIDOnly,
- GLProfile glp, boolean relaxed, boolean onscreen, boolean usePBuffer) {
-
+ private static int fillAttribsForGeneralWGLARBQuery(boolean haveWGLARBMultisample, int[] iattributes) {
+ int niattribs = 0;
+ iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_WINDOW_ARB;
+ iattributes[niattribs++] = WGLExt.WGL_ACCELERATION_ARB;
+ iattributes[niattribs++] = WGLExt.WGL_SUPPORT_OPENGL_ARB;
+ iattributes[niattribs++] = WGLExt.WGL_DEPTH_BITS_ARB;
+ iattributes[niattribs++] = WGLExt.WGL_STENCIL_BITS_ARB;
+ iattributes[niattribs++] = WGLExt.WGL_DOUBLE_BUFFER_ARB;
+ iattributes[niattribs++] = WGLExt.WGL_STEREO_ARB;
+ iattributes[niattribs++] = WGLExt.WGL_PIXEL_TYPE_ARB;
+ iattributes[niattribs++] = WGLExt.WGL_RED_BITS_ARB;
+ iattributes[niattribs++] = WGLExt.WGL_GREEN_BITS_ARB;
+ iattributes[niattribs++] = WGLExt.WGL_BLUE_BITS_ARB;
+ iattributes[niattribs++] = WGLExt.WGL_ALPHA_BITS_ARB;
+ iattributes[niattribs++] = WGLExt.WGL_ACCUM_RED_BITS_ARB;
+ iattributes[niattribs++] = WGLExt.WGL_ACCUM_GREEN_BITS_ARB;
+ iattributes[niattribs++] = WGLExt.WGL_ACCUM_BLUE_BITS_ARB;
+ iattributes[niattribs++] = WGLExt.WGL_ACCUM_ALPHA_BITS_ARB;
+ if (haveWGLARBMultisample) {
+ iattributes[niattribs++] = WGLExt.WGL_SAMPLE_BUFFERS_ARB;
+ iattributes[niattribs++] = WGLExt.WGL_SAMPLES_ARB;
+ }
+ return niattribs;
+ }
+
+ public static boolean wglARBPFIDValid(WindowsWGLContext sharedCtx, long hdc, int pfdID) {
+ int[] in = new int[1];
+ int[] out = new int[1];
+ in[0] = WGLExt.WGL_COLOR_BITS_ARB;
+ if (!sharedCtx.getWGLExt().wglGetPixelFormatAttribivARB(hdc, pfdID, 0, 1, in, 0, out, 0)) {
+ // Intel Extreme graphics 'fails' with a zero error code
+ return GDI.GetLastError() == 0 ;
+ }
+ return true;
+ }
+
+ public static GLCapabilitiesImmutable wglARBPFID2GLCapabilities(WindowsWGLContext sharedCtx, long hdc, int pfdID,
+ GLProfile glp, boolean onscreen, boolean usePBuffer) {
boolean haveWGLChoosePixelFormatARB = sharedCtx.isExtensionAvailable("WGL_ARB_pixel_format");
+ if (!haveWGLChoosePixelFormatARB) {
+ return null;
+ }
boolean haveWGLARBMultisample = sharedCtx.isExtensionAvailable("WGL_ARB_multisample");
- if(DEBUG) {
- System.err.println("HDC2GLCapabilities: ARB_pixel_format: "+haveWGLChoosePixelFormatARB);
- System.err.println("HDC2GLCapabilities: ARB_multisample : "+haveWGLARBMultisample);
+
+ int[] iattributes = new int [2*MAX_ATTRIBS];
+ int[] iresults = new int [2*MAX_ATTRIBS];
+
+ iattributes[0] = WGLExt.WGL_NUMBER_PIXEL_FORMATS_ARB;
+ if (sharedCtx.getWGLExt().wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, iattributes, 0, iresults, 0)) {
+ if(iresults[0] > 0 ) {
+ int niattribs = fillAttribsForGeneralWGLARBQuery(haveWGLARBMultisample, iattributes);
+ if (!sharedCtx.getWGLExt().wglGetPixelFormatAttribivARB(hdc, pfdID, 0, niattribs, iattributes, 0, iresults, 0)) {
+ throw new GLException("wglARBPFID2GLCapabilities: Error getting pixel format attributes for pixel format " + pfdID + " of device context");
+ }
+ return AttribList2GLCapabilities(glp, iattributes, niattribs, iresults,
+ onscreen, usePBuffer);
+ }
+ }
+ long lastErr = GDI.GetLastError();
+ // Intel Extreme graphics fails with a zero error code
+ if (lastErr != 0) {
+ throw new GLException("wglARBPFID2GLCapabilities: Unable to enumerate pixel formats of window using wglGetPixelFormatAttribivARB: error code " + GDI.GetLastError());
}
+ return null;
+ }
+ protected static int wglChoosePixelFormatARB(long hdc, WindowsWGLContext sharedContext,
+ GLCapabilitiesImmutable capabilities,
+ int[] iattributes, int accelerationMode, float[] fattributes,
+ int[] pformats)
+ {
+ int numFormats = -1;
+
+ if(WindowsWGLGraphicsConfiguration.GLCapabilities2AttribList(capabilities,
+ iattributes,
+ sharedContext,
+ accelerationMode,
+ false,
+ null)) {
+ int[] numFormatsTmp = new int[1];
+ if (sharedContext.getWGLExt().wglChoosePixelFormatARB(hdc,
+ iattributes, 0,
+ fattributes, 0,
+ WindowsWGLGraphicsConfiguration.MAX_PFORMATS,
+ pformats, 0,
+ numFormatsTmp, 0)) {
+ numFormats = numFormatsTmp[0];
+ if (DEBUG) {
+ System.err.println("wglChoosePixelFormatARB1: NumFormats (wglChoosePixelFormatARB) accelMode 0x" +
+ Integer.toHexString(accelerationMode) + ": " + numFormats + " / " + WindowsWGLGraphicsConfiguration.MAX_PFORMATS);
+ }
+ } else {
+ if (DEBUG) {
+ System.err.println("wglChoosePixelFormatARB1: wglChoosePixelFormatARB failed: " + GDI.GetLastError() );
+ Thread.dumpStack();
+ }
+ }
+ } else {
+ if (DEBUG) {
+ System.err.println("wglChoosePixelFormatARB1: GLCapabilities2AttribList failed: " + GDI.GetLastError() );
+ Thread.dumpStack();
+ }
+ }
+ return numFormats;
+ }
+
+ public static GLCapabilitiesImmutable[] wglARBPFIDs2GLCapabilities(WindowsWGLContext sharedCtx, long hdc, int[] pfdIDs, int numFormats,
+ GLProfile glp, boolean onscreen, boolean usePBuffer) {
+ boolean haveWGLChoosePixelFormatARB = sharedCtx.isExtensionAvailable("WGL_ARB_pixel_format");
+ if (!haveWGLChoosePixelFormatARB) {
+ return null;
+ }
+ boolean haveWGLARBMultisample = sharedCtx.isExtensionAvailable("WGL_ARB_multisample");
+
+ GLCapabilitiesImmutable[] caps = new GLCapabilitiesImmutable[numFormats];
+
+ int[] iattributes = new int [2*MAX_ATTRIBS];
+ int[] iresults = new int [2*MAX_ATTRIBS];
+ int niattribs = fillAttribsForGeneralWGLARBQuery(haveWGLARBMultisample, iattributes);
+
+ for(int i = 0; i<numFormats; i++) {
+ if ( pfdIDs[i] >= 1 &&
+ sharedCtx.getWGLExt().wglGetPixelFormatAttribivARB(hdc, pfdIDs[i], 0, niattribs, iattributes, 0, iresults, 0) ) {
+ caps[i] = AttribList2GLCapabilities(glp, iattributes, niattribs, iresults, onscreen, usePBuffer);
+ } else {
+ if (DEBUG) {
+ System.err.println("wglARBPFIDs2GLCapabilities: Cannot get pixel format attributes for pixel format " +
+ i + "/" + numFormats + ": " + pfdIDs[i]);
+ }
+ caps[i] = null;
+ }
+ }
+ return caps;
+ }
+
+ /**
+ *
+ * @param sharedCtx
+ * @param hdc
+ * @param glp
+ * @param onscreen
+ * @param usePBuffer
+ * @param pfIDs stores the PIXELFORMAT ID for the GLCapabilitiesImmutable[]
+ * @return the resulting GLCapabilitiesImmutable[]
+ */
+ public static GLCapabilitiesImmutable[] wglARBAllPFIDs2GLCapabilities(WindowsWGLContext sharedCtx, long hdc,
+ GLProfile glp, boolean onscreen, boolean usePBuffer, int[] pfIDs) {
+ boolean haveWGLChoosePixelFormatARB = sharedCtx.isExtensionAvailable("WGL_ARB_pixel_format");
if (!haveWGLChoosePixelFormatARB) {
return null;
}
+ boolean haveWGLARBMultisample = sharedCtx.isExtensionAvailable("WGL_ARB_multisample");
// Produce a list of GLCapabilities to give to the
// GLCapabilitiesChooser.
@@ -170,70 +289,36 @@ public class WindowsWGLGraphicsConfiguration extends DefaultGraphicsConfiguratio
GLCapabilitiesImmutable[] availableCaps = null;
int numFormats = 0;
int niattribs = 0;
- int[] iattributes = new int [2*MAX_ATTRIBS];
- int[] iresults = new int [2*MAX_ATTRIBS];
+ int[] iattributes = new int[2 * MAX_ATTRIBS];
+ int[] iresults = new int[2 * MAX_ATTRIBS];
WGLExt wglExt = sharedCtx.getWGLExt();
iattributes[0] = WGLExt.WGL_NUMBER_PIXEL_FORMATS_ARB;
if (wglExt.wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, iattributes, 0, iresults, 0)) {
- numFormats = iresults[0];
-
- if (DEBUG) {
- System.err.println("wglGetPixelFormatAttribivARB reported WGL_NUMBER_PIXEL_FORMATS = " + numFormats);
- }
-
- if(pfdIDOnly>0 && pfdIDOnly>numFormats) {
- throw new GLException("Invalid pixelformat ID " + pfdIDOnly + " (should be between 1 and " + numFormats + ")");
- }
+ numFormats = iresults[0];
+ if (DEBUG) {
+ System.err.println("wglARBAllPFIDs2GLCapabilities: wglGetPixelFormatAttribivARB reported WGL_NUMBER_PIXEL_FORMATS = " + numFormats + ", pfIDs sz "+pfIDs.length);
+ }
+ if (numFormats > pfIDs.length) {
+ numFormats = pfIDs.length;
+ }
- // Should we be filtering out the pixel formats which aren't
- // applicable, as we are doing here?
- // We don't have enough information in the GLCapabilities to
- // represent those that aren't...
- iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_WINDOW_ARB;
- iattributes[niattribs++] = WGLExt.WGL_ACCELERATION_ARB;
- iattributes[niattribs++] = WGLExt.WGL_SUPPORT_OPENGL_ARB;
- iattributes[niattribs++] = WGLExt.WGL_DEPTH_BITS_ARB;
- iattributes[niattribs++] = WGLExt.WGL_STENCIL_BITS_ARB;
- iattributes[niattribs++] = WGLExt.WGL_DOUBLE_BUFFER_ARB;
- iattributes[niattribs++] = WGLExt.WGL_STEREO_ARB;
- iattributes[niattribs++] = WGLExt.WGL_PIXEL_TYPE_ARB;
- iattributes[niattribs++] = WGLExt.WGL_RED_BITS_ARB;
- iattributes[niattribs++] = WGLExt.WGL_GREEN_BITS_ARB;
- iattributes[niattribs++] = WGLExt.WGL_BLUE_BITS_ARB;
- iattributes[niattribs++] = WGLExt.WGL_ALPHA_BITS_ARB;
- iattributes[niattribs++] = WGLExt.WGL_ACCUM_RED_BITS_ARB;
- iattributes[niattribs++] = WGLExt.WGL_ACCUM_GREEN_BITS_ARB;
- iattributes[niattribs++] = WGLExt.WGL_ACCUM_BLUE_BITS_ARB;
- iattributes[niattribs++] = WGLExt.WGL_ACCUM_ALPHA_BITS_ARB;
- if (haveWGLARBMultisample) {
- iattributes[niattribs++] = WGLExt.WGL_SAMPLE_BUFFERS_ARB;
- iattributes[niattribs++] = WGLExt.WGL_SAMPLES_ARB;
- }
+ niattribs = fillAttribsForGeneralWGLARBQuery(haveWGLARBMultisample, iattributes);
- if(pfdIDOnly>0) {
- availableCaps = new GLCapabilitiesImmutable[1];
- if (!wglExt.wglGetPixelFormatAttribivARB(hdc, pfdIDOnly, 0, niattribs, iattributes, 0, iresults, 0)) {
- throw new GLException("Error getting pixel format attributes for pixel format " + pfdIDOnly + " of device context");
- }
- availableCaps[0] = AttribList2GLCapabilities(glp, iattributes, niattribs, iresults,
- relaxed, onscreen, usePBuffer);
- } else {
- availableCaps = new GLCapabilitiesImmutable[numFormats];
- for (int i = 0; i < numFormats; i++) {
- if (!wglExt.wglGetPixelFormatAttribivARB(hdc, i+1, 0, niattribs, iattributes, 0, iresults, 0)) {
- throw new GLException("Error getting pixel format attributes for pixel format " + (i + 1) + " of device context");
+ availableCaps = new GLCapabilitiesImmutable[numFormats];
+ for (int i = 0; i < numFormats; i++) {
+ pfIDs[i] = i + 1;
+ if (!wglExt.wglGetPixelFormatAttribivARB(hdc, pfIDs[i], 0, niattribs, iattributes, 0, iresults, 0)) {
+ throw new GLException("wglARBAllPFIDs2GLCapabilities: Error getting pixel format attributes for pixel format " + pfIDs[i]);
}
- availableCaps[i] = AttribList2GLCapabilities(glp, iattributes, niattribs, iresults,
- relaxed, onscreen, usePBuffer);
- }
- }
+ availableCaps[i] = AttribList2GLCapabilities(glp, iattributes, niattribs, iresults, onscreen, usePBuffer);
+ }
} else {
- long lastErr = GDI.GetLastError();
- // Intel Extreme graphics fails with a zero error code
- if (lastErr != 0) {
- throw new GLException("Unable to enumerate pixel formats of window using wglGetPixelFormatAttribivARB: error code " + GDI.GetLastError());
- }
+ long lastErr = GDI.GetLastError();
+ // Intel Extreme graphics fails with a zero error code
+ if (lastErr != 0) {
+ throw new GLException("wglARBAllPFIDs2GLCapabilities: Unable to enumerate pixel formats of window using wglGetPixelFormatAttribivARB: error code " + GDI.GetLastError());
+ }
}
return availableCaps;
}
@@ -241,6 +326,7 @@ public class WindowsWGLGraphicsConfiguration extends DefaultGraphicsConfiguratio
public static boolean GLCapabilities2AttribList(GLCapabilitiesImmutable caps,
int[] iattributes,
GLContextImpl sharedCtx,
+ int accellerationValue,
boolean pbuffer,
int[] floatMode) throws GLException {
boolean haveWGLChoosePixelFormatARB = sharedCtx.isExtensionAvailable("WGL_ARB_pixel_format");
@@ -258,6 +344,10 @@ public class WindowsWGLGraphicsConfiguration extends DefaultGraphicsConfiguratio
iattributes[niattribs++] = WGLExt.WGL_SUPPORT_OPENGL_ARB;
iattributes[niattribs++] = GL.GL_TRUE;
+ if(accellerationValue>0) {
+ iattributes[niattribs++] = WGLExt.WGL_ACCELERATION_ARB;
+ iattributes[niattribs++] = accellerationValue;
+ }
if (pbuffer) {
iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_PBUFFER_ARB;
iattributes[niattribs++] = GL.GL_TRUE;
@@ -445,15 +535,12 @@ public class WindowsWGLGraphicsConfiguration extends DefaultGraphicsConfiguratio
GLProfile glp, int[] iattribs,
int niattribs,
int[] iresults,
- boolean relaxed, boolean onscreen, boolean usePBuffer) {
+ boolean onscreen, boolean usePBuffer) {
GLCapabilities res = new GLCapabilities(glp);
int drawableTypeBits = WGLConfig2DrawableTypeBits(iattribs, niattribs, iresults);
if(WGLConfigDrawableTypeVerify(drawableTypeBits, onscreen, usePBuffer)) {
res.setOnscreen(onscreen);
res.setPBuffer(usePBuffer);
- } else if(relaxed) {
- res.setOnscreen( 0 != (drawableTypeBits & WINDOW_BIT) );
- res.setPBuffer ( 0 != (drawableTypeBits & PBUFFER_BIT) );
} else {
if(DEBUG) {
System.err.println("WGL DrawableType does not match: req(onscrn "+onscreen+", pbuffer "+usePBuffer+"), got(onscreen "+( 0 != (drawableTypeBits & WINDOW_BIT) )+", pbuffer "+( 0 != (drawableTypeBits & PBUFFER_BIT) )+", pixmap "+( 0 != (drawableTypeBits & BITMAP_BIT))+")");
@@ -575,8 +662,8 @@ public class WindowsWGLGraphicsConfiguration extends DefaultGraphicsConfiguratio
res.setStencilBits (pfd.getCStencilBits());
res.setDoubleBuffered((pfd.getDwFlags() & GDI.PFD_DOUBLEBUFFER) != 0);
res.setStereo ((pfd.getDwFlags() & GDI.PFD_STEREO) != 0);
- res.setHardwareAccelerated( ((pfd.getDwFlags() & GDI.PFD_GENERIC_FORMAT) == 0) ||
- ((pfd.getDwFlags() & GDI.PFD_GENERIC_ACCELERATED) != 0) );
+ res.setHardwareAccelerated( (pfd.getDwFlags() & GDI.PFD_GENERIC_FORMAT) == 0 ||
+ (pfd.getDwFlags() & GDI.PFD_GENERIC_ACCELERATED) != 0 );
res.setOnscreen ( onscreen && ((pfd.getDwFlags() & GDI.PFD_DRAW_TO_WINDOW) != 0) );
res.setPBuffer ( usePBuffer );
/* FIXME: Missing ??
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java
index 4989d86a2..6228a80a9 100644
--- a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java
@@ -51,6 +51,7 @@ import javax.media.opengl.GLProfile;
import com.jogamp.nativewindow.impl.windows.GDI;
import com.jogamp.nativewindow.impl.windows.PIXELFORMATDESCRIPTOR;
import javax.media.nativewindow.CapabilitiesImmutable;
+import javax.media.opengl.DefaultGLCapabilitiesChooser;
import javax.media.opengl.GLCapabilitiesImmutable;
/** Subclass of GraphicsConfigurationFactory used when non-AWT tookits
@@ -109,226 +110,309 @@ public class WindowsWGLGraphicsConfigurationFactory extends GraphicsConfiguratio
protected static void updateGraphicsConfiguration(CapabilitiesChooser chooser,
GLDrawableFactory _factory, NativeSurface ns) {
- WindowsWGLDrawableFactory factory = (WindowsWGLDrawableFactory) _factory;
if (ns == null) {
throw new IllegalArgumentException("NativeSurface is null");
}
-
- if (chooser != null &&
- !(chooser instanceof GLCapabilitiesChooser)) {
+ long hdc = ns.getSurfaceHandle();
+ if (0 == hdc) {
+ throw new GLException("Error: HDC is null");
+ }
+ WindowsWGLGraphicsConfiguration config = (WindowsWGLGraphicsConfiguration) ns.getGraphicsConfiguration().getNativeGraphicsConfiguration();
+ if (chooser != null && !(chooser instanceof GLCapabilitiesChooser)) {
throw new IllegalArgumentException("This NativeWindowFactory accepts only GLCapabilitiesChooser objects");
}
- WindowsWGLGraphicsConfiguration config = (WindowsWGLGraphicsConfiguration) ns.getGraphicsConfiguration().getNativeGraphicsConfiguration();
- AbstractGraphicsDevice device = config.getScreen().getDevice();
- WindowsWGLContext sharedContext = (WindowsWGLContext) factory.getOrCreateSharedContextImpl(device);
- if(null==sharedContext) {
- throw new InternalError("SharedContext is null: "+device);
+ if (DEBUG) {
+ System.err.println("updateGraphicsConfiguration: hdc "+toHexString(hdc));
+ System.err.println("!!! user chosen caps " + config.getChosenCapabilities());
}
- boolean choosenBywGLPixelFormat = false;
- GLCapabilitiesImmutable capabilities = (GLCapabilitiesImmutable) config.getChosenCapabilities();
- boolean onscreen = capabilities.isOnscreen();
- boolean usePBuffer = capabilities.isPBuffer();
- GLProfile glProfile = capabilities.getGLProfile();
- long hdc = ns.getSurfaceHandle();
- if(0==hdc) {
- throw new GLException("Error: HDC is null "+toHexString(hdc));
+ if( !updateGraphicsConfigurationARB(hdc, config, chooser, (WindowsWGLDrawableFactory) _factory) ) {
+ updateGraphicsConfigurationGDI(hdc, config, chooser, (WindowsWGLDrawableFactory) _factory);
}
- if(DEBUG) {
- Exception ex = new Exception("Info: WindowsWGLGraphicsConfigurationFactory got HDC "+toHexString(hdc));
- ex.printStackTrace();
+ }
+
+ protected static boolean updateGraphicsConfigurationARB(long hdc, WindowsWGLGraphicsConfiguration config,
+ CapabilitiesChooser chooser, WindowsWGLDrawableFactory factory) {
+ AbstractGraphicsDevice device = config.getScreen().getDevice();
+ WindowsWGLContext sharedContext = (WindowsWGLContext) factory.getOrCreateSharedContextImpl(device);
+ if (null == sharedContext) {
+ throw new InternalError("SharedContext is null: " + device);
}
+ GLCapabilitiesImmutable capsChosen = (GLCapabilitiesImmutable) config.getChosenCapabilities();
+ boolean onscreen = capsChosen.isOnscreen();
+ boolean usePBuffer = capsChosen.isPBuffer();
+ GLProfile glProfile = capsChosen.getGLProfile();
+
+ int pixelFormatSet = -1; // 1-based pixel format
+ GLCapabilitiesImmutable pixelFormatCaps = null;
- PIXELFORMATDESCRIPTOR pfd = null;
- int pixelFormat = -1; // 1-based pixel format
- boolean pixelFormatSet = false;
- GLCapabilitiesImmutable chosenCaps = null;
+ GLCapabilitiesImmutable[] availableCaps = null;
+ int[] pformats = null; // if != null, then index matches availableCaps
+ int numFormats = -1;
+ int recommendedIndex = -1;
- if (onscreen) {
- if ((pixelFormat = GDI.GetPixelFormat(hdc)) != 0) {
+ if ((pixelFormatSet = GDI.GetPixelFormat(hdc)) != 0) {
// Pixelformat already set by either
// - a previous updateGraphicsConfiguration() call on the same HDC,
// - the graphics driver, copying the HDC's pixelformat to the new one,
// - or the Java2D/OpenGL pipeline's configuration
if (DEBUG) {
- System.err.println("!!!! NOTE: pixel format already chosen for HDC: " + toHexString(hdc)+
- ", pixelformat "+pixelFormat);
+ System.err.println("updateGraphicsConfigurationARB: Pixel format already chosen for HDC: " + toHexString(hdc)
+ + ", pixelformat " + pixelFormatSet);
}
- pixelFormatSet = true;
- }
-
- GLCapabilitiesImmutable[] availableCaps = null;
- int numFormats = 0;
- pfd = WindowsWGLGraphicsConfiguration.createPixelFormatDescriptor();
- // Produce a recommended pixel format selection for the GLCapabilitiesChooser.
- // Use wglChoosePixelFormatARB if user requested multisampling and if we have it available
- int recommendedPixelFormat = pixelFormat; // 1-based pixel format
- boolean gotAvailableCaps = false;
- synchronized(sharedContext) {
- sharedContext.makeCurrent();
- try {
- WGLExt wglExt = sharedContext.getWGLExt();
- boolean haveWGLChoosePixelFormatARB = false;
- if (wglExt != null) {
- haveWGLChoosePixelFormatARB = wglExt.isExtensionAvailable("WGL_ARB_pixel_format");
- if (haveWGLChoosePixelFormatARB) {
- if(pixelFormat<=0) {
- int[] iattributes = new int [2*WindowsWGLGraphicsConfiguration.MAX_ATTRIBS];
- float[] fattributes = new float[1];
-
- if(WindowsWGLGraphicsConfiguration.GLCapabilities2AttribList(capabilities,
- iattributes,
- sharedContext,
- false,
- null)) {
- int[] pformats = new int[WindowsWGLGraphicsConfiguration.MAX_PFORMATS];
- int[] numFormatsTmp = new int[1];
- if (wglExt.wglChoosePixelFormatARB(hdc,
- iattributes, 0,
- fattributes, 0,
- WindowsWGLGraphicsConfiguration.MAX_PFORMATS,
- pformats, 0,
- numFormatsTmp, 0)) {
- numFormats = numFormatsTmp[0];
- if (DEBUG) {
- System.err.println(getThreadName() + ": NumFormats (wglChoosePixelFormatARB) " + numFormats);
- }
- if (recommendedPixelFormat<=0 && numFormats > 0) {
- recommendedPixelFormat = pformats[0];
- if (DEBUG) {
- System.err.println(getThreadName() + ": Used wglChoosePixelFormatARB to recommend pixel format " + recommendedPixelFormat);
- }
- }
- } else {
- if (DEBUG) {
- System.err.println(getThreadName() + ": wglChoosePixelFormatARB failed: " + GDI.GetLastError() );
- Thread.dumpStack();
- }
- }
+ }
+
+ synchronized (sharedContext) {
+ sharedContext.makeCurrent();
+ try {
+ if (!sharedContext.isExtensionAvailable("WGL_ARB_pixel_format")) {
+ if (DEBUG) {
+ System.err.println("updateGraphicsConfigurationARB: wglChoosePixelFormatARB not available");
+ }
+ return false;
+ }
+ if (pixelFormatSet >= 1) {
+ // only fetch the specific one ..
+ pixelFormatCaps = WindowsWGLGraphicsConfiguration.wglARBPFID2GLCapabilities(sharedContext, hdc, pixelFormatSet,
+ glProfile, onscreen, usePBuffer);
+ } else {
+ int[] iattributes = new int[2 * WindowsWGLGraphicsConfiguration.MAX_ATTRIBS];
+ float[] fattributes = new float[1];
+ pformats = new int[WindowsWGLGraphicsConfiguration.MAX_PFORMATS];
+
+ // 1st choice: get GLCapabilities based on users GLCapabilities setting recommendedIndex as preferred choice
+ numFormats = WindowsWGLGraphicsConfiguration.wglChoosePixelFormatARB(hdc, sharedContext, capsChosen,
+ iattributes, -1, fattributes, pformats);
+ if (0 < numFormats) {
+ availableCaps = WindowsWGLGraphicsConfiguration.wglARBPFIDs2GLCapabilities(sharedContext, hdc, pformats, numFormats,
+ glProfile, onscreen, usePBuffer);
+ if (null != availableCaps) {
+ recommendedIndex = 0;
+ pixelFormatCaps = availableCaps[0];
if (DEBUG) {
- if (recommendedPixelFormat <= 0) {
- System.err.print(getThreadName() + ": wglChoosePixelFormatARB didn't recommend a pixel format: "+GDI.GetLastError());
- if (capabilities.getSampleBuffers()) {
- System.err.print(" for multisampled GLCapabilities");
- }
- System.err.println();
- }
+ System.err.println("updateGraphicsConfigurationARB: NumFormats (wglChoosePixelFormatARB) " + numFormats + " / " + WindowsWGLGraphicsConfiguration.MAX_PFORMATS);
+ System.err.println("updateGraphicsConfigurationARB: Used wglChoosePixelFormatARB to recommend pixel format " + pformats[recommendedIndex] + ", idx " + recommendedIndex);
+ System.err.println("!!! recommended caps " + pixelFormatCaps);
}
- }
}
+ }
- availableCaps = WindowsWGLGraphicsConfiguration.HDC2GLCapabilities(sharedContext, hdc, -1, glProfile, pixelFormatSet, onscreen, usePBuffer);
- gotAvailableCaps = null!=availableCaps ;
- choosenBywGLPixelFormat = gotAvailableCaps ;
- } else if (DEBUG) {
- System.err.println(getThreadName() + ": wglChoosePixelFormatARB not available");
- }
- }
- } finally {
- sharedContext.release();
- }
- } // synchronized(factory.sharedContext)
-
- if (!gotAvailableCaps) {
- if (DEBUG) {
- System.err.println(getThreadName() + ": Using ChoosePixelFormat ... (LastError: "+GDI.GetLastError()+")");
+ // 2nd choice: get all GLCapabilities available, no preferred recommendedIndex available
+ if (null == availableCaps) {
+ if (DEBUG) {
+ System.err.println("updateGraphicsConfigurationARB: wglChoosePixelFormatARB failed (Query all formats without recommendation): " + GDI.GetLastError());
+ }
+ availableCaps = WindowsWGLGraphicsConfiguration.wglARBAllPFIDs2GLCapabilities(sharedContext, hdc,
+ glProfile, onscreen, usePBuffer, pformats);
+ if (null != availableCaps) {
+ numFormats = availableCaps.length;
+ }
+ }
+ }
+ } finally {
+ sharedContext.release();
}
- pfd = WindowsWGLGraphicsConfiguration.GLCapabilities2PFD(capabilities);
- recommendedPixelFormat = GDI.ChoosePixelFormat(hdc, pfd);
+ } // synchronized(factory.sharedContext)
+
+ if (pixelFormatSet <= 0 && null == availableCaps) {
if (DEBUG) {
- System.err.println(getThreadName() + ": ChoosePixelFormat(HDC "+toHexString(hdc)+") = " + recommendedPixelFormat + " (LastError: "+GDI.GetLastError()+")");
- System.err.println(getThreadName() + ": Used " + capabilities);
+ System.err.println("updateGraphicsConfigurationARB: No PixelFormat chosen via ARB ... (LastError: " + GDI.GetLastError() + ")");
}
+ return false;
+ }
+
+ int pfdID;
+
+ if (pixelFormatSet <= 0) {
+ if (null == pixelFormatCaps && null == chooser) {
+ chooser = new DefaultGLCapabilitiesChooser();
+ }
+
+ int chosenIndex = recommendedIndex;
+ try {
+ if (null != chooser) {
+ chosenIndex = chooser.chooseCapabilities(capsChosen, availableCaps, recommendedIndex);
+ pixelFormatCaps = availableCaps[chosenIndex];
+ if (DEBUG) {
+ System.err.println("updateGraphicsConfigurationARB: chooser: idx " + chosenIndex);
+ System.err.println("!!! chosen caps " + pixelFormatCaps);
+ }
+ }
+ } catch (NativeWindowException e) {
+ if (DEBUG) {
+ e.printStackTrace();
+ }
+ }
+
+ if (chosenIndex < 0) {
+ // keep on going ..
+ // seek first available one ..
+ for (chosenIndex = 0; chosenIndex < availableCaps.length && availableCaps[chosenIndex] == null; chosenIndex++) {
+ // nop
+ }
+ if (chosenIndex == availableCaps.length) {
+ // give up ..
+ if (DEBUG) {
+ System.err.println("updateGraphicsConfigurationARB: Failed .. nothing available, bail out");
+ }
+ return false;
+ }
+ pixelFormatCaps = availableCaps[chosenIndex];
+ if (DEBUG) {
+ System.err.println("updateGraphicsConfigurationARB: Failed .. unable to choose config, using first available idx: " + chosenIndex);
+ System.err.println("!!! fallback caps " + pixelFormatCaps);
+ }
+ }
+ pfdID = pformats[chosenIndex];
+ } else {
+ pfdID = pixelFormatSet;
+ }
+ if (DEBUG) {
+ System.err.println("updateGraphicsConfigurationARB: using pfdID "+pfdID);
+ }
+
+ PIXELFORMATDESCRIPTOR pfd = WindowsWGLGraphicsConfiguration.createPixelFormatDescriptor();
- numFormats = GDI.DescribePixelFormat(hdc, 1, 0, null);
- if (numFormats == 0) {
- throw new GLException("Unable to enumerate pixel formats of window " +
- toHexString(hdc) + " for GLCapabilitiesChooser (LastError: "+GDI.GetLastError()+")");
+ if (GDI.DescribePixelFormat(hdc, pfdID, pfd.size(), pfd) == 0) {
+ throw new GLException("updateGraphicsConfigurationARB: Error describing the chosen pixel format: " + pfdID + ", " + GDI.GetLastError());
+ }
+
+ if (pixelFormatSet <= 0) {
+ if (!GDI.SetPixelFormat(hdc, pfdID, pfd)) {
+ long lastError = GDI.GetLastError();
+ throw new GLException("Unable to set pixel format " + pfdID + " for device context " + toHexString(hdc) + ": error code " + lastError);
}
+ }
+
+ config.setCapsPFD(pixelFormatCaps, pfd, pfdID, true);
+ return true;
+ }
+
+ protected static boolean updateGraphicsConfigurationGDI(long hdc, WindowsWGLGraphicsConfiguration config,
+ CapabilitiesChooser chooser, WindowsWGLDrawableFactory factory) {
+ AbstractGraphicsDevice device = config.getScreen().getDevice();
+ WindowsWGLContext sharedContext = (WindowsWGLContext) factory.getOrCreateSharedContextImpl(device);
+ if (null == sharedContext) {
+ throw new InternalError("SharedContext is null: " + device);
+ }
+ GLCapabilitiesImmutable capsChosen = (GLCapabilitiesImmutable) config.getChosenCapabilities();
+ boolean onscreen = capsChosen.isOnscreen();
+ boolean usePBuffer = capsChosen.isPBuffer();
+ GLProfile glProfile = capsChosen.getGLProfile();
+
+ int pixelFormatSet = -1; // 1-based pixel format
+ GLCapabilitiesImmutable pixelFormatCaps = null;
+
+ GLCapabilitiesImmutable[] availableCaps = null;
+ int numFormats = -1;
+ int recommendedIndex = -1;
+
+ if ((pixelFormatSet = GDI.GetPixelFormat(hdc)) != 0) {
+ // Pixelformat already set by either
+ // - a previous updateGraphicsConfiguration() call on the same HDC,
+ // - the graphics driver, copying the HDC's pixelformat to the new one,
+ // - or the Java2D/OpenGL pipeline's configuration
if (DEBUG) {
- System.err.println(getThreadName() + ": NumFormats (DescribePixelFormat) " + numFormats);
+ System.err.println("updateGraphicsConfigurationGDI: NOTE: pixel format already chosen for HDC: " + toHexString(hdc)
+ + ", pixelformat " + pixelFormatSet);
}
+ }
+
+ int recommendedPixelFormat = pixelFormatSet;
- availableCaps = new GLCapabilitiesImmutable[numFormats];
- for (int i = 0; i < numFormats; i++) {
- if (GDI.DescribePixelFormat(hdc, 1 + i, pfd.size(), pfd) == 0) {
+ numFormats = GDI.DescribePixelFormat(hdc, 1, 0, null);
+ if (numFormats == 0) {
+ throw new GLException("Unable to enumerate pixel formats of window "
+ + toHexString(hdc) + " for GLCapabilitiesChooser (LastError: " + GDI.GetLastError() + ")");
+ }
+ if (DEBUG) {
+ System.err.println("updateGraphicsConfigurationGDI: NumFormats (DescribePixelFormat) " + numFormats);
+ }
+
+ PIXELFORMATDESCRIPTOR pfd = WindowsWGLGraphicsConfiguration.createPixelFormatDescriptor();
+ availableCaps = new GLCapabilitiesImmutable[numFormats];
+ for (int i = 0; i < numFormats; i++) {
+ if (GDI.DescribePixelFormat(hdc, 1 + i, pfd.size(), pfd) == 0) {
throw new GLException("Error describing pixel format " + (1 + i) + " of device context");
- }
- availableCaps[i] = WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(glProfile, pfd, onscreen, usePBuffer);
}
- }
-
- // NOTE: officially, should make a copy of all of these
- // GLCapabilities to avoid mutation by the end user during the
- // chooseCapabilities call, but for the time being, assume they
- // won't be changed
-
- if(pixelFormat<=0) {
- if(null!=chooser) {
- // Supply information to chooser
- try {
- pixelFormat = chooser.chooseCapabilities(capabilities, availableCaps, recommendedPixelFormat) + 1;
- } catch (NativeWindowException e) {
- if(DEBUG) {
- e.printStackTrace();
+ availableCaps[i] = WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(glProfile, pfd, onscreen, usePBuffer);
+ }
+
+ int pfdID;
+
+ if (pixelFormatSet <= 0) {
+ pfd = WindowsWGLGraphicsConfiguration.GLCapabilities2PFD(capsChosen);
+ recommendedPixelFormat = GDI.ChoosePixelFormat(hdc, pfd);
+ recommendedIndex = recommendedPixelFormat - 1;
+ pixelFormatCaps = availableCaps[recommendedIndex];
+ if (DEBUG) {
+ System.err.println("updateGraphicsConfigurationGDI: ChoosePixelFormat(HDC " + toHexString(hdc) + ") = " + recommendedPixelFormat + " (LastError: " + GDI.GetLastError() + ")");
+ System.err.println("!!! recommended caps " + pixelFormatCaps);
+ }
+
+ int chosenIndex = recommendedIndex;
+ try {
+ if (null != chooser) {
+ chosenIndex = chooser.chooseCapabilities(capsChosen, availableCaps, recommendedIndex);
+ pixelFormatCaps = availableCaps[chosenIndex];
+ if (DEBUG) {
+ System.err.println("updateGraphicsConfigurationGDI: chooser: idx " + chosenIndex);
+ System.err.println("!!! chosen caps " + pixelFormatCaps);
}
- pixelFormat = -1;
- }
- } else {
- pixelFormat = recommendedPixelFormat;
- }
- if (pixelFormat <= 0) {
- // keep on going ..
- if(DEBUG) {
- System.err.println("WindowsWGLGraphicsConfigurationFactory.updateGraphicsConfiguration .. unable to choose config, using first");
- }
- pixelFormat = 1; // default ..
- } else if ( pixelFormat > numFormats ) {
- // keep on going ..
- if(DEBUG) {
- System.err.println("GLCapabilitiesChooser specified invalid index (expected 1.." + numFormats + ", got "+pixelFormat+")");
- }
- pixelFormat = 1; // default ..
- }
- }
- chosenCaps = availableCaps[pixelFormat-1];
- if (DEBUG) {
- System.err.println(getThreadName() + ": Chosen pixel format (" + pixelFormat + "):");
- System.err.println(chosenCaps);
- }
- if (GDI.DescribePixelFormat(hdc, pixelFormat, pfd.size(), pfd) == 0) {
- throw new GLException("Error re-describing the chosen pixel format: " + GDI.GetLastError());
- }
+ }
+ } catch (NativeWindowException e) {
+ if (DEBUG) {
+ e.printStackTrace();
+ }
+ }
+
+ if (chosenIndex < 0) {
+ // keep on going ..
+ // seek first available one ..
+ for (chosenIndex = 0; chosenIndex < availableCaps.length && availableCaps[chosenIndex] == null; chosenIndex++) {
+ // nop
+ }
+ if (chosenIndex == availableCaps.length) {
+ // give up ..
+ if (DEBUG) {
+ System.err.println("updateGraphicsConfigurationGDI: Failed .. nothing available, bail out");
+ }
+ return false;
+ }
+ pixelFormatCaps = availableCaps[chosenIndex];
+ if (DEBUG) {
+ System.err.println("updateGraphicsConfigurationGDI: Failed .. unable to choose config, using first available idx: " + chosenIndex);
+ System.err.println("!!! fallback caps " + pixelFormatCaps);
+ }
+ }
+ pfdID = chosenIndex + 1;
} else {
- // For now, use ChoosePixelFormat for offscreen surfaces until
- // we figure out how to properly choose an offscreen-
- // compatible pixel format
- pfd = WindowsWGLGraphicsConfiguration.GLCapabilities2PFD(capabilities);
- pixelFormat = GDI.ChoosePixelFormat(hdc, pfd);
- }
- if(!pixelFormatSet) {
- if (!GDI.SetPixelFormat(hdc, pixelFormat, pfd)) {
- long lastError = GDI.GetLastError();
- if (DEBUG) {
- System.err.println(getThreadName() + ": SetPixelFormat failed: current context = " + WGL.wglGetCurrentContext() +
- ", current DC = " + WGL.wglGetCurrentDC());
- System.err.println(getThreadName() + ": GetPixelFormat(hdc " + toHexString(hdc) + ") returns " + GDI.GetPixelFormat(hdc));
- }
- throw new GLException("Unable to set pixel format " + pixelFormat + " for device context " + toHexString(hdc) + ": error code " + lastError);
+ pfdID = pixelFormatSet;
+ pixelFormatCaps = availableCaps[pixelFormatSet-1];
+ if (DEBUG) {
+ System.err.println("updateGraphicsConfigurationGDI: Using preset PFID: " + pixelFormatSet);
+ System.err.println("!!! preset caps " + pixelFormatCaps);
}
- pixelFormatSet=true;
}
- // Reuse the previously-constructed GLCapabilities because it
- // turns out that using DescribePixelFormat on some pixel formats
- // (which, for example, support full-scene antialiasing) for some
- // reason return that they are not OpenGL-capable
- if (chosenCaps != null) {
- capabilities = chosenCaps;
- } else {
- capabilities = WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(glProfile, pfd, onscreen, usePBuffer);
+ if (DEBUG) {
+ System.err.println("updateGraphicsConfigurationGDI: using pfdID "+pfdID);
}
- config.setCapsPFD(capabilities, pfd, pixelFormat, choosenBywGLPixelFormat);
+
+ if (GDI.DescribePixelFormat(hdc, pfdID, pfd.size(), pfd) == 0) {
+ throw new GLException("Error describing the chosen pixel format: " + pfdID + ", " + GDI.GetLastError());
+ }
+
+ if (pixelFormatSet <= 0) {
+ if (!GDI.SetPixelFormat(hdc, pfdID, pfd)) {
+ long lastError = GDI.GetLastError();
+ throw new GLException("Unable to set pixel format " + pfdID + " for device context " + toHexString(hdc) + ": error code " + lastError);
+ }
+ }
+
+ config.setCapsPFD(pixelFormatCaps, pfd, pfdID, true);
+ return true;
+
}
protected static String getThreadName() {
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXGraphicsConfigurationFactory.java b/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXGraphicsConfigurationFactory.java
index d3f9f378f..b2f493932 100644
--- a/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXGraphicsConfigurationFactory.java
+++ b/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXGraphicsConfigurationFactory.java
@@ -99,7 +99,7 @@ public class X11GLXGraphicsConfigurationFactory extends GraphicsConfigurationFac
X11GraphicsScreen x11Screen = (X11GraphicsScreen)absScreen;
GLProfile glProfile = GLProfile.getDefault();
- GLCapabilities caps=null;
+ GLCapabilities availableCaps=null;
XVisualInfo xvis=null;
long fbcfg = 0;
int fbid = -1;
@@ -115,13 +115,13 @@ public class X11GLXGraphicsConfigurationFactory extends GraphicsConfigurationFac
long visID = X11Util.DefaultVisualID(display, x11Screen.getIndex());
xvis = X11GLXGraphicsConfiguration.XVisualID2XVisualInfo(display, visID);
- caps = X11GLXGraphicsConfiguration.XVisualInfo2GLCapabilities(glProfile, display, xvis, onscreen, usePBuffer, isMultisampleAvailable);
+ availableCaps = X11GLXGraphicsConfiguration.XVisualInfo2GLCapabilities(glProfile, display, xvis, onscreen, usePBuffer, isMultisampleAvailable);
- int[] attribs = X11GLXGraphicsConfiguration.GLCapabilities2AttribList(caps, true, isMultisampleAvailable, display, screen);
+ int[] attribs = X11GLXGraphicsConfiguration.GLCapabilities2AttribList(availableCaps, true, isMultisampleAvailable, display, screen);
int[] count = { -1 };
PointerBuffer fbcfgsL = GLX.glXChooseFBConfig(display, screen, attribs, 0, count, 0);
if (fbcfgsL == null || fbcfgsL.limit()<1) {
- throw new Exception("Could not fetch FBConfig for "+caps);
+ throw new Exception("Could not fetch FBConfig for "+availableCaps);
}
fbcfg = fbcfgsL.get(0);
capsFB = X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(glProfile, display, fbcfg, true, onscreen, usePBuffer, isMultisampleAvailable);
@@ -135,7 +135,7 @@ public class X11GLXGraphicsConfigurationFactory extends GraphicsConfigurationFac
} catch (Throwable t) {
}
- return new X11GLXGraphicsConfiguration(x11Screen, (null!=capsFB)?capsFB:caps, caps, null, xvis, fbcfg, fbid);
+ return new X11GLXGraphicsConfiguration(x11Screen, (null!=capsFB)?capsFB:availableCaps, availableCaps, null, xvis, fbcfg, fbid);
} */
protected static X11GLXGraphicsConfiguration chooseGraphicsConfigurationStatic(GLCapabilitiesImmutable capsChosen,
@@ -202,12 +202,11 @@ public class X11GLXGraphicsConfigurationFactory extends GraphicsConfigurationFac
GLCapabilitiesImmutable capsReq,
GLCapabilitiesChooser chooser,
X11GraphicsScreen x11Screen) {
- long recommendedFBConfig = 0;
+ long recommendedFBConfig = -1;
int recommendedIndex = -1;
- GLCapabilitiesImmutable[] caps = null;
- PointerBuffer fbcfgsL = null;
- int chosen=-1;
int retFBID=-1;
+ GLCapabilitiesImmutable[] availableCaps = null;
+ PointerBuffer fbcfgsL = null;
XVisualInfo retXVisualInfo = null;
GLProfile glProfile = capsChosen.getGLProfile();
boolean onscreen = capsChosen.isOnscreen();
@@ -223,103 +222,118 @@ public class X11GLXGraphicsConfigurationFactory extends GraphicsConfigurationFac
int[] attribs = X11GLXGraphicsConfiguration.GLCapabilities2AttribList(capsChosen, true, isMultisampleAvailable, display, screen);
int[] count = { -1 };
- // determine the recommended FBConfig ..
+ // 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()<1) {
- if(DEBUG) {
- System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: Failed glXChooseFBConfig ("+x11Screen+","+capsChosen+"): "+fbcfgsL+", "+count[0]);
- }
- } else if( !X11GLXGraphicsConfiguration.GLXFBConfigValid( display, fbcfgsL.get(0) ) ) {
- if(DEBUG) {
- System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: Failed - GLX FBConfig invalid: ("+x11Screen+","+capsChosen+"): "+fbcfgsL+", fbcfg: "+toHexString(fbcfgsL.get(0)));
+ if (fbcfgsL != null && fbcfgsL.limit()>0) {
+ availableCaps = new GLCapabilitiesImmutable[fbcfgsL.limit()];
+ for (int i = 0; i < fbcfgsL.limit(); i++) {
+ if( !X11GLXGraphicsConfiguration.GLXFBConfigValid( display, fbcfgsL.get(i) ) ) {
+ if(DEBUG) {
+ System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: FBConfig invalid (1): ("+x11Screen+","+capsChosen+"): fbcfg: "+toHexString(fbcfgsL.get(i)));
+ }
+ } else {
+ availableCaps[i] = X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(glProfile, display, fbcfgsL.get(i),
+ false, onscreen, usePBuffer, isMultisampleAvailable);
+ }
}
- } else {
- recommendedFBConfig = fbcfgsL.get(0);
- }
-
- // get all, glXChooseFBConfig(.. attribs==null ..) == glXGetFBConfig(..)
- fbcfgsL = GLX.glXChooseFBConfig(display, screen, null, 0, count, 0);
- if (fbcfgsL == null || fbcfgsL.limit()<1) {
- if(DEBUG) {
- System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: Failed glXGetFBConfig ("+x11Screen+"): "+fbcfgsL+", "+count[0]);
+ if(availableCaps[0]!=null) {
+ recommendedFBConfig = fbcfgsL.get(0);
+ recommendedIndex=0;
+ if (DEBUG) {
+ System.err.println("!!! glXChooseFBConfig recommended fbcfg " + toHexString(recommendedFBConfig) + ", idx " + recommendedIndex);
+ System.err.println("!!! user caps " + capsChosen);
+ System.err.println("!!! fbcfg caps " + availableCaps[recommendedIndex]);
+ }
+ } else {
+ if (DEBUG) {
+ System.err.println("!!! glXChooseFBConfig no caps for recommended fbcfg " + toHexString(recommendedFBConfig));
+ System.err.println("!!! user caps " + capsChosen);
+ }
}
- return null;
}
- // make GLCapabilities and seek the recommendedIndex
- caps = new GLCapabilitiesImmutable[fbcfgsL.limit()];
- for (int i = 0; i < fbcfgsL.limit(); i++) {
- if( !X11GLXGraphicsConfiguration.GLXFBConfigValid( display, fbcfgsL.get(i) ) ) {
+ // 2nd choice: get all GLCapabilities available, no preferred recommendedIndex available
+ if(null == availableCaps) {
+ fbcfgsL = GLX.glXChooseFBConfig(display, screen, null, 0, count, 0);
+ if (fbcfgsL == null || fbcfgsL.limit()<=0) {
if(DEBUG) {
- System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: FBConfig invalid: ("+x11Screen+","+capsChosen+"): fbcfg: "+toHexString(fbcfgsL.get(i)));
+ System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: Failed glXChooseFBConfig ("+x11Screen+","+capsChosen+"): "+fbcfgsL+", "+count[0]);
}
- } else {
- caps[i] = X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(glProfile, display, fbcfgsL.get(i),
- false, onscreen, usePBuffer, isMultisampleAvailable);
- if(caps[i]!=null && recommendedFBConfig==fbcfgsL.get(i)) {
- recommendedIndex=i;
- if (DEBUG) {
- System.err.println("!!! glXChooseFBConfig recommended "+i+", "+caps[i]);
+ return null;
+ }
+
+ availableCaps = new GLCapabilitiesImmutable[fbcfgsL.limit()];
+ for (int i = 0; i < fbcfgsL.limit(); i++) {
+ if( !X11GLXGraphicsConfiguration.GLXFBConfigValid( display, fbcfgsL.get(i) ) ) {
+ if(DEBUG) {
+ System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: FBConfig invalid (2): ("+x11Screen+"): fbcfg: "+toHexString(fbcfgsL.get(i)));
}
+ } else {
+ availableCaps[i] = X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(glProfile, display, fbcfgsL.get(i),
+ false, onscreen, usePBuffer, isMultisampleAvailable);
}
}
}
- if(null==chooser) {
- chosen = recommendedIndex; // may still be -1 in case nothing was recommended (-1)
+ if( recommendedIndex < 1 && null==chooser) {
+ chooser = new DefaultGLCapabilitiesChooser();
}
- if (chosen < 0) {
- if(null==chooser) {
- // nothing recommended .. so use our default implementation
- chooser = new DefaultGLCapabilitiesChooser();
- }
- try {
- chosen = chooser.chooseCapabilities(capsChosen, caps, recommendedIndex);
- } catch (NativeWindowException e) {
- if(DEBUG) {
- e.printStackTrace();
- }
- chosen = -1;
+ int chosenIndex = recommendedIndex;
+ try {
+ if(null != chooser) {
+ chosenIndex = chooser.chooseCapabilities(capsChosen, availableCaps, recommendedIndex);
+ if(DEBUG) {
+ System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig chooser: idx "+chosenIndex);
+ System.err.println("!!! user caps " + capsChosen);
+ System.err.println("!!! chosen caps " + availableCaps[chosenIndex]);
}
- }
- if (chosen < 0) {
- // keep on going ..
+ }
+ } catch (NativeWindowException e) {
if(DEBUG) {
- System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig Failed .. unable to choose config, using first");
+ e.printStackTrace();
}
+ }
+
+ if (chosenIndex < 0) {
+ // keep on going ..
// seek first available one ..
- for(chosen = 0; chosen < caps.length && caps[chosen]==null; chosen++) {
+ for(chosenIndex = 0; chosenIndex < availableCaps.length && availableCaps[chosenIndex]==null; chosenIndex++) {
// nop
}
- if(chosen==caps.length) {
+ if(chosenIndex==availableCaps.length) {
// give up ..
if(DEBUG) {
System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig Failed .. nothing available, bail out");
}
return null;
}
- } else if (chosen >= caps.length) {
+ if(DEBUG) {
+ System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig Failed .. unable to choose config, using first available idx: "+chosenIndex);
+ System.err.println("!!! user caps " + capsChosen);
+ System.err.println("!!! fallback caps " + availableCaps[chosenIndex]);
+ }
+ } else if (chosenIndex >= availableCaps.length) {
if(DEBUG) {
- System.err.println("GLCapabilitiesChooser specified invalid index (expected 0.." + (caps.length - 1) + ", got "+chosen+")");
+ System.err.println("GLCapabilitiesChooser specified invalid index (expected 0.." + (availableCaps.length - 1) + ", got "+chosenIndex+")");
}
return null;
}
- retFBID = X11GLXGraphicsConfiguration.glXFBConfig2FBConfigID(display, fbcfgsL.get(chosen));
+ retFBID = X11GLXGraphicsConfiguration.glXFBConfig2FBConfigID(display, fbcfgsL.get(chosenIndex));
- retXVisualInfo = GLX.glXGetVisualFromFBConfig(display, fbcfgsL.get(chosen));
+ retXVisualInfo = GLX.glXGetVisualFromFBConfig(display, fbcfgsL.get(chosenIndex));
if (retXVisualInfo==null) {
if(DEBUG) {
- System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: Failed glXGetVisualFromFBConfig ("+x11Screen+", "+fbcfgsL.get(chosen) +" (Continue: "+(false==caps[chosen].isOnscreen())+"):\n\t"+caps[chosen]);
+ System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: Failed glXGetVisualFromFBConfig ("+x11Screen+", "+fbcfgsL.get(chosenIndex) +" (Continue: "+(false==availableCaps[chosenIndex].isOnscreen())+"):\n\t"+availableCaps[chosenIndex]);
}
- if(caps[chosen].isOnscreen()) {
+ if(availableCaps[chosenIndex].isOnscreen()) {
// Onscreen drawables shall have a XVisual ..
return null;
}
}
- return new X11GLXGraphicsConfiguration(x11Screen, caps[chosen], capsReq, chooser, retXVisualInfo, fbcfgsL.get(chosen), retFBID);
+ return new X11GLXGraphicsConfiguration(x11Screen, availableCaps[chosenIndex], capsReq, chooser, retXVisualInfo, fbcfgsL.get(chosenIndex), retFBID);
}
private static X11GLXGraphicsConfiguration chooseGraphicsConfigurationXVisual(GLCapabilitiesImmutable capsChosen,
@@ -368,7 +382,7 @@ public class X11GLXGraphicsConfigurationFactory extends GraphicsConfigurationFac
caps = new GLCapabilitiesImmutable[infos.length];
for (int i = 0; i < infos.length; i++) {
caps[i] = X11GLXGraphicsConfiguration.XVisualInfo2GLCapabilities(glProfile, display, infos[i], onscreen, false, isMultisampleAvailable);
- // Attempt to find the visual chosen by glXChooseVisual
+ // Attempt to find the visual chosenIndex by glXChooseVisual
if (recommendedVis != null && recommendedVis.getVisualid() == infos[i].getVisualid()) {
recommendedIndex = i;
}