Bug 1116 - Add OculusVR DK2 Support - Part-1 (DK2 on DK1 SDK w/o Eye Tracker)

- DK2's screen on X11 (at least) starts in rotated mode,
  detect and apply MonitorDevice rotation via NEWT's OpenGL StereoDeviceUtil

- Move StereoDevice.Config -> StereoDeviceConfig

- Expose generic StereoDevice to public: GenericStereoDeviceConfig + GenericStereoDeviceFactory

- GenericStereoDeviceFactory exposes public GenericStereoDeviceConfig creation
  for mono, sbs-stereo and lense-sbs-stereo w/ diff. parameters.

- Pass eye surface/texture size for each eye from device to renderer,
  instead of assuming unified values.

- Unify GenericStereoDevice.createRenderer(..) and OVRStereoDevice.createRenderer(..) code

2 files changed, 370 insertions, 0 deletions

diff --git a/src/jogl/classes/com/jogamp/opengl/util/stereo/generic/GenericStereoDeviceConfig.java b/src/jogl/classes/com/jogamp/opengl/util/stereo/generic/GenericStereoDeviceConfig.java
new file mode 100644
index 000000000..04fd8343c
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/stereo/generic/GenericStereoDeviceConfig.java
@@ -0,0 +1,177 @@
+/**
+ * Copyright 2015 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+package com.jogamp.opengl.util.stereo.generic;
+
+import java.util.Arrays;
+
+import jogamp.opengl.util.stereo.DistortionMesh;
+import jogamp.opengl.util.stereo.GenericStereoDevice;
+
+import com.jogamp.nativewindow.util.DimensionImmutable;
+import com.jogamp.opengl.util.stereo.EyeParameter;
+import com.jogamp.opengl.util.stereo.StereoDeviceConfig;
+import com.jogamp.opengl.util.stereo.StereoDeviceRenderer;
+import com.jogamp.opengl.util.stereo.StereoUtil;
+
+/**
+ * Configuration for {@link GenericStereoDevice}s.
+ */
+public class GenericStereoDeviceConfig extends StereoDeviceConfig {
+    public static enum ShutterType {
+        Global, RollingLeftToRight, RollingRightToLeft, RollingTopToBottom
+    }
+    public GenericStereoDeviceConfig(final String name,
+                  final GenericStereoDeviceConfig.ShutterType shutterType,
+                  final DimensionImmutable surfaceSizeInPixels,
+                  final float[] screenSizeInMeters,
+                  final DimensionImmutable[/*pre-eye*/] eyeTextureSize,
+                  final float pupilCenterFromScreenTopInMeters,
+                  final float interpupillaryDistanceInMeters,
+                  final int[] eyeRenderOrder,
+                  final EyeParameter[] defaultEyeParam,
+                  final DistortionMesh.Producer distortionMeshProducer,
+                  final int supportedDistortionBits,
+                  final int recommendedDistortionBits,
+                  final int minimumDistortionBits
+                  ) {
+        if( eyeRenderOrder.length != defaultEyeParam.length ) {
+            throw new IllegalArgumentException("eye arrays of different length");
+        }
+        this.name = name;
+        this.shutterType = shutterType;
+        this.surfaceSizeInPixels = surfaceSizeInPixels;
+        this.screenSizeInMeters = screenSizeInMeters;
+        this.eyeTextureSizes = eyeTextureSize;
+        this.pupilCenterFromScreenTopInMeters = pupilCenterFromScreenTopInMeters;
+        this.interpupillaryDistanceInMeters = interpupillaryDistanceInMeters;
+        this.eyeRenderOrder = eyeRenderOrder;
+        this.defaultEyeParam = defaultEyeParam;
+        this.distortionMeshProducer = distortionMeshProducer;
+        this.supportedDistortionBits = supportedDistortionBits;
+        this.recommendedDistortionBits = recommendedDistortionBits;
+        this.minimumDistortionBits = minimumDistortionBits;
+        this.pupilCenterFromTopLeft = new float[2][2];
+        calcPupilCenterFromTopLeft();
+    }
+    /** A variation w/ different surface/screen specs */
+    public GenericStereoDeviceConfig(final GenericStereoDeviceConfig source,
+                  final DimensionImmutable surfaceSizeInPixels,
+                  final float[] screenSizeInMeters,
+                  final DimensionImmutable[/*pre-eye*/] eyeTextureSize) {
+        this.name = source.name;
+        this.shutterType = source.shutterType;
+        this.surfaceSizeInPixels = surfaceSizeInPixels;
+        this.screenSizeInMeters = screenSizeInMeters;
+        this.eyeTextureSizes = eyeTextureSize;
+        this.pupilCenterFromScreenTopInMeters = source.pupilCenterFromScreenTopInMeters;
+        this.interpupillaryDistanceInMeters = source.interpupillaryDistanceInMeters;
+        this.eyeRenderOrder = source.eyeRenderOrder;
+        this.defaultEyeParam = source.defaultEyeParam;
+        this.distortionMeshProducer = source.distortionMeshProducer;
+        this.supportedDistortionBits = source.supportedDistortionBits;
+        this.recommendedDistortionBits = source.recommendedDistortionBits;
+        this.minimumDistortionBits = source.minimumDistortionBits;
+        this.pupilCenterFromTopLeft = new float[2][2];
+        calcPupilCenterFromTopLeft();
+    }
+    private void calcPupilCenterFromTopLeft() {
+        final float visibleWidthOfOneEye = 0.5f * screenSizeInMeters[0];
+        final float leftPupilCenterFromLeftInMeters = ( screenSizeInMeters[0] - interpupillaryDistanceInMeters ) * 0.5f;
+        final float rightPupilCenterFromMiddleInMeters = leftPupilCenterFromLeftInMeters + interpupillaryDistanceInMeters - visibleWidthOfOneEye;
+        pupilCenterFromTopLeft[0][0] = leftPupilCenterFromLeftInMeters / visibleWidthOfOneEye;
+        pupilCenterFromTopLeft[0][1] = pupilCenterFromScreenTopInMeters     / screenSizeInMeters[1];
+        pupilCenterFromTopLeft[1][0] = rightPupilCenterFromMiddleInMeters / visibleWidthOfOneEye;
+        pupilCenterFromTopLeft[1][1] =  pupilCenterFromTopLeft[0][1];
+    }
+
+    /**
+     * One time lazy initialization before use.
+     * @see #isInitialized()
+     */
+    public synchronized void init() {
+        if( !isInitialized ) {
+            if( null != distortionMeshProducer ) {
+                final float[] eyeReliefInMeters = new float[defaultEyeParam.length];
+                if( 0 < defaultEyeParam.length ) {
+                    eyeReliefInMeters[0] = defaultEyeParam[0].eyeReliefZ;
+                }
+                if( 1 < defaultEyeParam.length ) {
+                    eyeReliefInMeters[1] = defaultEyeParam[1].eyeReliefZ;
+                }
+                distortionMeshProducer.init(this, eyeReliefInMeters);
+            }
+            isInitialized = true;
+        }
+    }
+    /**
+     * Returns {@code true} if {@link #init() initialized}, otherwise {@code false}.
+     * @see #init()
+     */
+    public final boolean isInitialized() { return isInitialized; }
+
+    @Override
+    public String toString() { return "StereoConfig["+name+", shutter "+shutterType+", surfaceSize "+surfaceSizeInPixels+
+                               ", screenSize "+screenSizeInMeters[0]+" x "+screenSizeInMeters[0]+
+                               " [m], eyeTexSize "+Arrays.toString(eyeTextureSizes)+", IPD "+interpupillaryDistanceInMeters+
+                               " [m], eyeParam "+Arrays.toString(defaultEyeParam)+
+                               ", distortionBits[supported ["+StereoUtil.distortionBitsToString(supportedDistortionBits)+
+                                              "], recommended ["+StereoUtil.distortionBitsToString(recommendedDistortionBits)+
+                                              "], minimum ["+StereoUtil.distortionBitsToString(minimumDistortionBits)+"]]]";
+    }
+
+    /** Configuration Name */
+    public final String name;
+    public final GenericStereoDeviceConfig.ShutterType shutterType;
+
+    public final DimensionImmutable surfaceSizeInPixels;
+    public final float[] screenSizeInMeters;
+    /** Texture size per eye */
+    public final DimensionImmutable[/*pre-eye*/] eyeTextureSizes;
+
+    /** Vertical distance from pupil to screen-top in meters */
+    public final float pupilCenterFromScreenTopInMeters;
+    /** Horizontal interpupillary distance (IPD) in meters */
+    public final float interpupillaryDistanceInMeters;
+    /**
+     * Pupil center from top left per eye, ranging from [0..1], maybe used to produce FovHVHalves,
+     * see {@link #getHorizPupilCenterFromLeft(float, float)} and {@link #getVertPupilCenterFromTop(float, float)}.
+     */
+    public final float[/*per-eye*/][/*xy*/] pupilCenterFromTopLeft;
+    public final int[] eyeRenderOrder;
+    public final EyeParameter[] defaultEyeParam;
+    public final DistortionMesh.Producer distortionMeshProducer;
+
+    /** Supported distortion bits, see {@link StereoDeviceRenderer.DISTORTION_BARREL}. */
+    public final int supportedDistortionBits;
+    /** Recommended distortion bits, see {@link StereoDeviceRenderer.DISTORTION_BARREL}. */
+    public final int recommendedDistortionBits;
+    /** Required distortion bits, see {@link StereoDeviceRenderer.DISTORTION_BARREL}. */
+    public final int minimumDistortionBits;
+
+    private boolean isInitialized = false;
+}
\ No newline at end of file
diff --git a/src/jogl/classes/com/jogamp/opengl/util/stereo/generic/GenericStereoDeviceFactory.java b/src/jogl/classes/com/jogamp/opengl/util/stereo/generic/GenericStereoDeviceFactory.java
new file mode 100644
index 000000000..1d5000c97
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/stereo/generic/GenericStereoDeviceFactory.java
@@ -0,0 +1,193 @@
+/**
+ * Copyright 2014 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+package com.jogamp.opengl.util.stereo.generic;
+
+import jogamp.opengl.util.stereo.DistortionMesh;
+import jogamp.opengl.util.stereo.GenericStereoDevice;
+
+import com.jogamp.common.util.ReflectionUtil;
+import com.jogamp.nativewindow.util.Dimension;
+import com.jogamp.nativewindow.util.DimensionImmutable;
+import com.jogamp.opengl.math.FloatUtil;
+import com.jogamp.opengl.math.FovHVHalves;
+import com.jogamp.opengl.util.stereo.EyeParameter;
+import com.jogamp.opengl.util.stereo.StereoDevice;
+import com.jogamp.opengl.util.stereo.StereoDeviceConfig;
+import com.jogamp.opengl.util.stereo.StereoDeviceFactory;
+import com.jogamp.opengl.util.stereo.StereoDeviceRenderer;
+import com.jogamp.opengl.util.stereo.StereoUtil;
+
+public class GenericStereoDeviceFactory extends StereoDeviceFactory {
+
+    /**
+     * Create a generic monoscopic {@link GenericStereoDeviceConfig generic device config}.
+     * @param name
+     * @param surfaceSizeInPixel
+     * @param screenSizeInMeters
+     * @param defaultEyePositionOffset
+     */
+    public static GenericStereoDeviceConfig createMono(final String name,
+                             final DimensionImmutable surfaceSizeInPixel, final float[] screenSizeInMeters,
+                             final float[] defaultEyePositionOffset) {
+        final float pupilCenterFromScreenTopInMeters = screenSizeInMeters[1] / 2f;
+        final float d2r = FloatUtil.PI / 180.0f;
+        return new GenericStereoDeviceConfig(
+                        name,
+                        GenericStereoDeviceConfig.ShutterType.RollingTopToBottom,
+                        surfaceSizeInPixel,                // resolution
+                        screenSizeInMeters,                // screenSize [m]
+                        new DimensionImmutable[] { surfaceSizeInPixel }, // eye textureSize
+                        pupilCenterFromScreenTopInMeters,  // pupilCenterFromScreenTop [m]
+                        0f,                                // IPD [m]
+                        new int[] { 0 },                   // eye order
+                        new EyeParameter[] {
+                            new EyeParameter(0, defaultEyePositionOffset,
+                                             // degrees: 45/2 l, 45/2 r, 45/2 * aspect t, 45/2 * aspect b
+                                             FovHVHalves.byFovyRadianAndAspect(45f*d2r, 1280f / 800f),
+                                             0f /* distNoseToPupil */, 0f /* verticalDelta */, 0f /* eyeReliefInMeters */) },
+                        null, // mash producer distortion bits
+                        0,    // supported distortion bits
+                        0,    // recommended distortion bits
+                        0     // minimum distortion bits
+                        );
+    }
+
+    /**
+     * Create a generic homogenous side-by-side stereoscopic {@link GenericStereoDeviceConfig generic device config}.
+     * @param name
+     * @param surfaceSizeInPixel
+     * @param screenSizeInMeters
+     * @param interpupillaryDistanceInMeters
+     * @param fovy
+     * @param defaultEyePositionOffset
+     */
+    public static GenericStereoDeviceConfig createStereoSBS(final String name,
+                             final DimensionImmutable surfaceSizeInPixel, final float[] screenSizeInMeters,
+                             final float interpupillaryDistanceInMeters, final float fovy,
+                             final float[] defaultEyePositionOffset) {
+        final float pupilCenterFromScreenTopInMeters = screenSizeInMeters[1] / 2f;
+        final float d2r = FloatUtil.PI / 180.0f;
+
+        final DimensionImmutable eyeTextureSize = new Dimension(surfaceSizeInPixel.getWidth()/2, surfaceSizeInPixel.getHeight());
+        final float[] horizPupilCenterFromLeft = StereoUtil.getHorizPupilCenterFromLeft(screenSizeInMeters[0], interpupillaryDistanceInMeters);
+        final float vertPupilCenterFromTop = StereoUtil.getVertPupilCenterFromTop(screenSizeInMeters[1], pupilCenterFromScreenTopInMeters);
+        final float aspect = (float)eyeTextureSize.getWidth() / (float)eyeTextureSize.getHeight();
+        final FovHVHalves defaultSBSEyeFovLeft = FovHVHalves.byFovyRadianAndAspect(fovy * d2r, vertPupilCenterFromTop, aspect, horizPupilCenterFromLeft[0]);
+        final FovHVHalves defaultSBSEyeFovRight = FovHVHalves.byFovyRadianAndAspect(fovy * d2r, vertPupilCenterFromTop, aspect, horizPupilCenterFromLeft[1]);
+
+        return new GenericStereoDeviceConfig(
+                        name,
+                        GenericStereoDeviceConfig.ShutterType.RollingTopToBottom,
+                        surfaceSizeInPixel,                // resolution
+                        screenSizeInMeters,                // screenSize [m]
+                        new DimensionImmutable[] { eyeTextureSize, eyeTextureSize }, // eye textureSize
+                        pupilCenterFromScreenTopInMeters,  // pupilCenterFromScreenTop [m]
+                        interpupillaryDistanceInMeters,    // IPD [m]
+                        new int[] { 0, 1 },                // eye order
+                        new EyeParameter[] {
+                            new EyeParameter(0, defaultEyePositionOffset, defaultSBSEyeFovLeft,
+                                          interpupillaryDistanceInMeters/2f /* distNoseToPupil */, 0f /* verticalDelta */, 0.010f /* eyeReliefInMeters */),
+                            new EyeParameter(1, defaultEyePositionOffset, defaultSBSEyeFovRight,
+                                         -interpupillaryDistanceInMeters/2f /* distNoseToPupil */, 0f /* verticalDelta */, 0.010f /* eyeReliefInMeters */) },
+                        null,   // mash producer distortion bits
+                        0,      // supported distortion bits
+                        0,      // recommended distortion bits
+                        0       // minimum distortion bits
+                        );
+
+    }
+
+    /**
+     * Create a generic lense distorted side-by-side stereoscopic {@link GenericStereoDeviceConfig generic device config}.
+     * @param name
+     * @param surfaceSizeInPixel
+     * @param screenSizeInMeters
+     * @param interpupillaryDistanceInMeters
+     * @param fovy
+     * @param eyeTextureSize
+     * @param defaultEyePositionOffset
+     */
+    public static GenericStereoDeviceConfig createStereoSBSLense(final String name,
+                             final DimensionImmutable surfaceSizeInPixel, final float[] screenSizeInMeters,
+                             final float interpupillaryDistanceInMeters, final float fovy,
+                             final DimensionImmutable eyeTextureSize,
+                             final float[] defaultEyePositionOffset) {
+        DistortionMesh.Producer lenseDistMeshProduce = null;
+        try {
+            lenseDistMeshProduce =
+                (DistortionMesh.Producer)
+                ReflectionUtil.createInstance("jogamp.opengl.oculusvr.stereo.lense.DistortionMeshProducer", GenericStereoDevice.class.getClassLoader());
+        } catch (final Throwable t) {
+            if(StereoDevice.DEBUG) { System.err.println("Caught: "+t.getMessage()); t.printStackTrace(); }
+        }
+        if( null == lenseDistMeshProduce ) {
+            return null;
+        }
+        final float pupilCenterFromScreenTopInMeters = screenSizeInMeters[1] / 2f;
+        final float d2r = FloatUtil.PI / 180.0f;
+
+        final float[] horizPupilCenterFromLeft = StereoUtil.getHorizPupilCenterFromLeft(screenSizeInMeters[0], interpupillaryDistanceInMeters);
+        final float vertPupilCenterFromTop = StereoUtil.getVertPupilCenterFromTop(screenSizeInMeters[1], pupilCenterFromScreenTopInMeters);
+        final float aspect = (float)eyeTextureSize.getWidth() / (float)eyeTextureSize.getHeight();
+        final FovHVHalves defaultSBSEyeFovLeft = FovHVHalves.byFovyRadianAndAspect(fovy * d2r, vertPupilCenterFromTop, aspect, horizPupilCenterFromLeft[0]);
+        final FovHVHalves defaultSBSEyeFovRight = FovHVHalves.byFovyRadianAndAspect(fovy * d2r, vertPupilCenterFromTop, aspect, horizPupilCenterFromLeft[1]);
+
+        return new GenericStereoDeviceConfig(
+                        name,
+                        GenericStereoDeviceConfig.ShutterType.RollingTopToBottom,
+                        surfaceSizeInPixel,                // resolution
+                        screenSizeInMeters,                // screenSize [m]
+                        new DimensionImmutable[] { eyeTextureSize, eyeTextureSize }, // eye textureSize
+                        pupilCenterFromScreenTopInMeters,  // pupilCenterFromScreenTop [m]
+                        interpupillaryDistanceInMeters,    // IPD [m]
+                        new int[] { 0, 1 },                // eye order
+                        new EyeParameter[] {
+                            new EyeParameter(0, defaultEyePositionOffset, defaultSBSEyeFovLeft,
+                                          interpupillaryDistanceInMeters/2f /* distNoseToPupil */, 0f /* verticalDelta */, 0.010f /* eyeReliefInMeters */),
+                            new EyeParameter(1, defaultEyePositionOffset, defaultSBSEyeFovRight,
+                                         -interpupillaryDistanceInMeters/2f /* distNoseToPupil */, 0f /* verticalDelta */, 0.010f /* eyeReliefInMeters */) },
+                        lenseDistMeshProduce,
+                        // supported distortion bits
+                        StereoDeviceRenderer.DISTORTION_BARREL | StereoDeviceRenderer.DISTORTION_CHROMATIC | StereoDeviceRenderer.DISTORTION_VIGNETTE,
+                        // recommended distortion bits
+                        StereoDeviceRenderer.DISTORTION_BARREL | StereoDeviceRenderer.DISTORTION_CHROMATIC | StereoDeviceRenderer.DISTORTION_VIGNETTE,
+                        // minimum distortion bits
+                        StereoDeviceRenderer.DISTORTION_BARREL
+                        );
+    }
+
+
+    public static boolean isAvailable() {
+        return true;
+    }
+
+    @Override
+    public final StereoDevice createDevice(final int deviceIndex, final StereoDeviceConfig config, final boolean verbose) {
+        return new GenericStereoDevice(this, deviceIndex, config);
+    }
+}