diff options
Diffstat (limited to 'gl4java/drawable/Win32SunJDK13GLDrawableFactory.java')
| -rw-r--r-- | gl4java/drawable/Win32SunJDK13GLDrawableFactory.java | 327 |
1 files changed, 327 insertions, 0 deletions
diff --git a/gl4java/drawable/Win32SunJDK13GLDrawableFactory.java b/gl4java/drawable/Win32SunJDK13GLDrawableFactory.java new file mode 100644 index 0000000..da8fd93 --- /dev/null +++ b/gl4java/drawable/Win32SunJDK13GLDrawableFactory.java @@ -0,0 +1,327 @@ +package gl4java.drawable;
+
+import java.awt.*;
+import java.lang.reflect.*;
+import java.util.*;
+import sun.awt.*;
+import gl4java.*;
+
+public class Win32SunJDK13GLDrawableFactory
+ extends SunJDK13GLDrawableFactory
+{
+ // Use reflection to get access to internal methods in sun.awt.*
+ private static Method getMaxConfigsMethod;
+ private static Method getDefaultPixIDMethod;
+
+ static {
+ try {
+ getMaxConfigsMethod =
+ sun.awt.Win32GraphicsDevice.class.
+ getDeclaredMethod("getMaxConfigs",
+ new Class[] { Integer.TYPE });
+ getMaxConfigsMethod.setAccessible(true);
+
+ getDefaultPixIDMethod =
+ sun.awt.Win32GraphicsDevice.class.
+ getDeclaredMethod("getDefaultPixID",
+ new Class[] { Integer.TYPE });
+ getDefaultPixIDMethod.setAccessible(true);
+ } catch (Exception e) {
+ e.printStackTrace();
+ throw new InternalError(e.toString());
+ }
+ }
+
+ public Win32SunJDK13GLDrawableFactory() {
+ // describeAllGraphicsConfigurations();
+ }
+
+ public GraphicsConfiguration
+ getGraphicsConfiguration(GLCapabilities capabilities,
+ GraphicsDevice device) {
+ // On Windows, ChoosePixelFormat does not work as desired; it
+ // shoehorns the given pixel format descriptor into what a
+ // particular window can render. Instead we enumerate all possible
+ // pixel formats for a given GraphicsDevice and try to find one
+ // matching the given capabilities. To do this we provide
+ // accessors which query the OpenGL-related properties of a
+ // GraphicsConfiguration. FIXME: should implement better selection
+ // algorithm; this one does not choose the most minimal.
+
+ Win32GraphicsConfig[] configs =
+ getAllGraphicsConfigurations((Win32GraphicsDevice) device);
+
+ int maxDepth = 0;
+ int maxColor = 0;
+ int maxStencil = 0;
+ int maxAccum = 0;
+
+ for (int i = 0; i < configs.length; i++) {
+ Win32GraphicsConfig config = configs[i];
+
+ if( ! getConfigSupportsOpenGL(config) )
+ continue;
+
+ if(getConfigDepthBits(config)>maxDepth) maxDepth=getConfigDepthBits(config);
+ if(getConfigColorBits(config)>maxColor) maxColor=getConfigColorBits(config);
+ if(getConfigStencilBits(config)>maxStencil) maxStencil=getConfigStencilBits(config);
+ if(getConfigAccumBits(config)>maxAccum) maxAccum=getConfigAccumBits(config);
+ }
+
+ if(maxDepth>24) maxDepth=24;
+
+ /** fall down to overall's maximum **/
+ if(capabilities.getDepthBits()>maxDepth) capabilities.setDepthBits(maxDepth);
+ if(capabilities.getStencilBits()>maxStencil) capabilities.setStencilBits(maxStencil);
+
+ if(getCapsColorBits(capabilities)>maxColor)
+ { capabilities.setRedBits(maxColor/3);
+ capabilities.setGreenBits(maxColor/3+maxColor%3);
+ capabilities.setBlueBits(maxColor/3);
+ }
+
+ if(getCapsAccumBits(capabilities)>maxAccum)
+ { capabilities.setAccumRedBits(maxAccum/3);
+ capabilities.setAccumGreenBits(maxAccum/3+maxAccum%3);
+ capabilities.setAccumBlueBits(maxAccum/3);
+ }
+
+ Win32GraphicsConfig config = configsSupportsCapabilities(configs, capabilities, maxDepth);
+ if(config!=null) return config;
+
+ /* lets .. fall down .. individual .. */
+
+ /* general normals .. */
+ boolean tryit = false;
+ if(capabilities.getDepthBits()>24) { capabilities.setDepthBits(24); tryit=true; }
+ else if(capabilities.getDepthBits()>16) { capabilities.setDepthBits(16); tryit=true; }
+ if(getCapsColorBits(capabilities)>24)
+ { capabilities.setRedBits(8); capabilities.setGreenBits(8); capabilities.setBlueBits(8); tryit=true; }
+ if(capabilities.getAlphaBits()>8) { capabilities.setAlphaBits(8); tryit=true; }
+ if(tryit) config = configsSupportsCapabilities(configs, capabilities, maxDepth);
+ if(config!=null) return config; tryit=false;
+
+ /* no stereo .. */
+ if(capabilities.getStereo()) { capabilities.setStereo(false); tryit=true; }
+ if(tryit) config = configsSupportsCapabilities(configs, capabilities, maxDepth);
+ if(config!=null) return config; tryit=false;
+
+ /* stencil<=16 .. */
+ if(capabilities.getStencilBits()>16) { capabilities.setStencilBits(16); tryit=true; }
+ if(tryit) config = configsSupportsCapabilities(configs, capabilities, maxDepth);
+ if(config!=null) return config; tryit=false;
+
+ /* accum rgb each <=16.. */
+ if(getCapsAccumBits(capabilities)>48)
+ { capabilities.setAccumRedBits(16); capabilities.setAccumGreenBits(16); capabilities.setAccumBlueBits(16);
+ tryit=true; }
+ if(tryit) config = configsSupportsCapabilities(configs, capabilities, maxDepth);
+ if(config!=null) return config; tryit=false;
+
+ /* stencil<=8 .. */
+ if(capabilities.getStencilBits()>8) { capabilities.setStencilBits(8); tryit=true; }
+ if(tryit) config = configsSupportsCapabilities(configs, capabilities, maxDepth);
+ if(config!=null) return config; tryit=false;
+
+ /* accum rgb each <=8.. */
+ if(getCapsAccumBits(capabilities)>24)
+ { capabilities.setAccumRedBits(8); capabilities.setAccumGreenBits(8); capabilities.setAccumBlueBits(8);
+ tryit=true; }
+ if(tryit) config = configsSupportsCapabilities(configs, capabilities, maxDepth);
+ if(config!=null) return config; tryit=false;
+
+ /* stencil=0 .. */
+ if(capabilities.getStencilBits()>0) { capabilities.setStencilBits(0); tryit=true; }
+ if(tryit) config = configsSupportsCapabilities(configs, capabilities, maxDepth);
+ if(config!=null) return config; tryit=false;
+
+ /* alpha=0 */
+ if(capabilities.getAlphaBits()>0) { capabilities.setAlphaBits(0); tryit=true; }
+ if(tryit) config = configsSupportsCapabilities(configs, capabilities, maxDepth);
+ if(config!=null) return config; tryit=false;
+
+ return null;
+ }
+
+ //----------------------------------------------------------------------
+ // Internals only below this point
+ //
+
+ private Win32GraphicsConfig configsSupportsCapabilities(Win32GraphicsConfig[] configs,
+ GLCapabilities glCaps,
+ int maxDepth)
+ {
+ if(GLContext.gljNativeDebug)
+ {
+ System.out.println("---------------");
+ System.out.println("---------------");
+ System.out.println("---------------");
+ System.out.println("->check caps: "+glCaps);
+ System.out.println("---------------");
+ }
+ for (int i = 0; i < configs.length; i++) {
+ if (configSupportsCapabilities(configs[i], glCaps, maxDepth)) {
+ glCaps.setNativeVisualID( (long) configs[i].getVisual() );
+ return configs[i];
+ }
+ }
+ return null;
+ }
+
+ private Win32GraphicsConfig[]
+ getAllGraphicsConfigurations(Win32GraphicsDevice device)
+ {
+ try {
+ int max =
+ ((Integer) getMaxConfigsMethod.invoke(device,
+ new Object[] {
+ new Integer(device.getScreen())
+ })).intValue();
+ int defaultPixID =
+ ((Integer) getDefaultPixIDMethod.invoke(device,
+ new Object[] {
+ new Integer(device.getScreen())
+ })).intValue();
+ java.util.List l = new ArrayList(max);
+ if (defaultPixID == 0) {
+ // From Win32GraphicsDevice: workaround for failing GDI calls
+ l.add(Win32GraphicsConfig.getConfig(device, defaultPixID));
+ } else {
+ for (int i = 1; i <= max; i++) {
+ l.add(Win32GraphicsConfig.getConfig(device, i));
+ }
+ }
+ Win32GraphicsConfig[] configs = new Win32GraphicsConfig[l.size()];
+ l.toArray(configs);
+ return configs;
+ } catch (Exception e) {
+ e.printStackTrace();
+ throw new InternalError(e.toString());
+ }
+ }
+
+ private boolean configSupportsCapabilities(Win32GraphicsConfig config,
+ GLCapabilities caps, int maxDepth)
+ {
+ boolean res = ( getConfigSupportsOpenGL(config)
+ && getConfigDoubleBuffered(config) == caps.getDoubleBuffered()
+ && caps.getTrueColor() == getConfigTrueColor(config)
+ && caps.getDepthBits() <= getConfigDepthBits(config)
+ && maxDepth >= getConfigDepthBits(config)
+ && caps.getStencilBits() <= getConfigStencilBits(config)
+ && (caps.getStereo() ? getConfigStereo(config):true)
+ && getCapsColorBits(caps) <= getConfigColorBits(config)
+ /* && caps.getAlphaBits() <= getConfigAlphaBits(config) N.A. */
+ && getCapsAccumBits(caps) <= getConfigAccumBits(config));
+
+ if(GLContext.gljNativeDebug)
+ {
+ System.out.println("->against config: ");
+ describeGraphicsConfiguration(config);
+ System.out.println("---------------");
+ System.out.println("result: "+res);
+ System.out.println("---------------");
+ }
+ return res;
+ }
+
+ private static int getCapsColorBits(GLCapabilities caps) {
+ return caps.getRedBits() + caps.getGreenBits() + caps.getBlueBits();
+ }
+
+ private static int getCapsAccumBits(GLCapabilities caps) {
+ return caps.getAccumRedBits() + caps.getAccumGreenBits() + caps.getAccumBlueBits();
+ }
+
+ private static boolean getConfigSupportsOpenGL(Win32GraphicsConfig config) {
+ return getVisualSupportsOpenGL(getScreen(config), config.getVisual());
+ }
+
+ private static boolean getConfigDoubleBuffered(Win32GraphicsConfig config) {
+ return getVisualDoubleBuffered(getScreen(config), config.getVisual());
+ }
+
+ private static boolean getConfigTrueColor(Win32GraphicsConfig config) {
+ return getVisualTrueColor(getScreen(config), config.getVisual());
+ }
+
+ private static boolean getConfigStereo(Win32GraphicsConfig config) {
+ return getVisualStereo(getScreen(config), config.getVisual());
+ }
+
+ private static int getConfigDepthBits(Win32GraphicsConfig config) {
+ return getVisualDepthBits(getScreen(config), config.getVisual());
+ }
+
+ private static int getConfigStencilBits(Win32GraphicsConfig config) {
+ return getVisualStencilBits(getScreen(config), config.getVisual());
+ }
+
+ private static int getConfigColorShiftBits(Win32GraphicsConfig config) {
+ return getVisualColorShiftBits(getScreen(config), config.getVisual());
+ }
+
+ private static int getConfigColorBits(Win32GraphicsConfig config) {
+ return getVisualColorBits(getScreen(config), config.getVisual());
+ }
+
+ private static int getConfigAlphaBits(Win32GraphicsConfig config) {
+ return getVisualAlphaBits(getScreen(config), config.getVisual());
+ }
+
+ private static int getConfigAccumBits(Win32GraphicsConfig config) {
+ return getVisualAccumBits(getScreen(config), config.getVisual());
+ }
+
+ private static int getScreen(Win32GraphicsConfig config) {
+ return ((Win32GraphicsDevice) config.getDevice()).getScreen();
+ }
+
+ // Native support routines that are not in GraphicsConfiguration or
+ // Win32GraphicsConfig. These are only necessary on Windows because
+ // X11's glXChooseVisual can implement getGraphicsConfiguration
+ // directly.
+ private static native boolean getVisualSupportsOpenGL (int screen, int pixelFormatIdx);
+ private static native boolean getVisualDoubleBuffered (int screen, int pixelFormatIdx);
+ private static native boolean getVisualTrueColor (int screen, int pixelFormatIdx);
+ private static native boolean getVisualStereo (int screen, int pixelFormatIdx);
+ private static native int getVisualDepthBits (int screen, int pixelFormatIdx);
+ private static native int getVisualStencilBits (int screen, int pixelFormatIdx);
+ private static native int getVisualColorShiftBits (int screen, int pixelFormatIdx);
+ private static native int getVisualColorBits (int screen, int pixelFormatIdx);
+ private static native int getVisualAlphaBits (int screen, int pixelFormatIdx);
+ private static native int getVisualAccumBits (int screen, int pixelFormatIdx);
+
+ // Debugging only
+ private void describeAllGraphicsConfigurations() {
+ Win32GraphicsConfig[] configs =
+ getAllGraphicsConfigurations(
+ (Win32GraphicsDevice)
+ GraphicsEnvironment.getLocalGraphicsEnvironment().
+ getDefaultScreenDevice()
+ );
+ System.err.println(configs.length + " graphics configurations found");
+ for (int i = 0; i < configs.length; i++) {
+ System.err.println(i + ".");
+ Win32GraphicsConfig config = configs[i];
+ describeGraphicsConfiguration(config);
+ System.err.println();
+ }
+ }
+
+ private void describeGraphicsConfiguration(Win32GraphicsConfig config)
+ {
+ boolean supportsOpenGL = getConfigSupportsOpenGL(config);
+ System.err.println(" SupportsOpenGL: " + supportsOpenGL);
+ if (supportsOpenGL) {
+ System.err.print(" DoubleBuffered: " + getConfigDoubleBuffered(config));
+ System.err.print(" TrueColor: " + getConfigTrueColor(config));
+ System.err.println(" Stereo: " + getConfigStereo(config));
+ System.err.print(" DepthBits: " + getConfigDepthBits(config));
+ System.err.println(" StencilBits: " + getConfigStencilBits(config));
+ System.err.print(" ColorBits: " + getConfigColorBits(config));
+ System.err.print(" AlphaBits: " + getConfigAlphaBits(config));
+ System.err.println(" AccumBits: " + getConfigAccumBits(config));
+ }
+ }
+}
|