View difference between Paste ID: tLPeGap2 and X7g5zKcK

 #include <GL/glew.h>
 #include <sstream>
 #include <fstream>
 
 #include <glm/glm.hpp>
 #include <glm/gtc/quaternion.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/type_ptr.hpp>
 #include <glm/gtc/noise.hpp>
 
 #include <iostream>
 #include <string>
 #include <map>
 //#include <stdint.h>
 
 // Imports by Alexander
 #include <Inventor/nodes/SoSeparator.h>
 #include <Inventor/nodes/SoMaterial.h>
 #include <Inventor/nodes/SoSceneTexture2.h>
 #include <Inventor/nodes/SoCube.h>
 #include <Inventor/nodes/SoCone.h>
 #include <Inventor/nodes/SoSphere.h>
 #include <Inventor/nodes/SoCoordinate3.h>
 #include <Inventor/nodes/SoComplexity.h>
 #include <Inventor/nodes/SoCallback.h>
 #include <Inventor/nodes/SoTexture2.h>
 #include <Inventor/nodes/SoTextureCoordinate2.h>
 #include <Inventor/nodes/SoShaderProgram.h>
 #include <Inventor/nodes/SoFragmentShader.h>
 #include <Inventor/nodes/SoDirectionalLight.h>
 #include <Inventor/nodes/SoVertexShader.h>
 #include <Inventor/nodes/SoShaderObject.h>
 #include <Inventor/nodes/SoTriangleStripSet.h>
 #include <Inventor/nodes/SoPerspectiveCamera.h>
 #include <Inventor/nodes/SoTransform.h>
 #include <Inventor/nodes/SoShaderParameter.h>
 #include <Inventor/nodes/SoOrthographicCamera.h>
 #include <Inventor\fields\SoSFVec3f.h>
 #include <Inventor\SoSceneManager.h>
 #include <Inventor/SoOffscreenRenderer.h>
 #include <Inventor\actions\SoGLRenderAction.h>
 
 #include <QApplication>
 #include <QKeyEvent>
 
 #include <QGLShaderProgram>
 #include <QGLShader>
 #include <QGLWidget>
 //#include <qthread.h>
 #include "GLprogram.h"
 
 
 #ifdef __APPLE__
     #include "CoreFoundation/CFBundle.h"
 #endif
 
 #include "OVR.h"
 #undef new
 
 #ifdef WIN32
 
     long millis() {
         static long start = GetTickCount();
         return GetTickCount() - start;
     }
 
 #else
 
     #include <sys/time.h>
 
     long millis() {
         timeval time;
         gettimeofday(&time, NULL);
         long millis = (time.tv_sec * 1000) + (time.tv_usec / 1000);
         static long start = millis;
         return millis - start;
     }
 
 #endif
 
 using namespace std;
 using namespace OVR;
 using namespace OVR::Util::Render;
 
 // Some defines to make calculations below more transparent
 #define TRIANGLES_PER_FACE 2
 #define VERTICES_PER_TRIANGLE 3
 #define VERTICES_PER_EDGE 2
 #define FLOATS_PER_VERTEX 3
 
 // Cube geometry
 #define VERT_COUNT 8
 #define FACE_COUNT 6
 #define EDGE_COUNT 12
 
 #define CUBE_SIZE 0.4f
 #define CUBE_P (CUBE_SIZE / 2.0f)
 #define CUBE_N (-1.0f * CUBE_P)
 
 #define ON 1.0
 #define PQ 0.25
 
 #define RED 1, 0, 0
 #define GREEN 0, 1, 0
 #define BLUE 0, 0, 1
 #define YELLOW 1, 1, 0
 #define CYAN 0, 1, 1
 #define MAGENTA 1, 0, 1
 
 // How big do we want our renderbuffer
 #define FRAMEBUFFER_OBJECT_SCALE 3
 
 const glm::vec3 X_AXIS = glm::vec3(1.0f, 0.0f, 0.0f);
 const glm::vec3 Y_AXIS = glm::vec3(0.0f, 1.0f, 0.0f);
 const glm::vec3 Z_AXIS = glm::vec3(0.0f, 0.0f, 1.0f);        // Animate the cube
 const glm::vec3 CAMERA = glm::vec3(0.0f, 0.0f, 0.8f);
 const glm::vec3 ORIGIN = glm::vec3(0.0f, 0.0f, 0.0f);
 const glm::vec3 UP = Y_AXIS;
 
 // Vertices for a unit cube centered at the origin
 const GLfloat CUBE_VERTEX_DATA[VERT_COUNT * FLOATS_PER_VERTEX] = {
     CUBE_N, CUBE_N, CUBE_N, // Vertex 0 position
     CUBE_P, CUBE_N, CUBE_N, // Vertex 1 position
     CUBE_P, CUBE_P, CUBE_N, // Vertex 2 position
     CUBE_N, CUBE_P, CUBE_N, // Vertex 3 position
     CUBE_N, CUBE_N, CUBE_P, // Vertex 4 position
     CUBE_P, CUBE_N, CUBE_P, // Vertex 5 position
     CUBE_P, CUBE_P, CUBE_P, // Vertex 6 position
     CUBE_N, CUBE_P, CUBE_P, // Vertex 7 position
 };
 
 
 const GLfloat CUBE_FACE_COLORS[] = {
     RED, 1,
     GREEN, 1,
     BLUE, 1,
     YELLOW, 1,
     CYAN, 1,
     MAGENTA, 1,
 };
 
 // 6 sides * 2 triangles * 3 vertices
 const unsigned int CUBE_INDICES[FACE_COUNT * TRIANGLES_PER_FACE * VERTICES_PER_TRIANGLE ] = {
    0, 4, 5, 0, 5, 1, // Face 0
    1, 5, 6, 1, 6, 2, // Face 1
    2, 6, 7, 2, 7, 3, // Face 2
    3, 7, 4, 3, 4, 0, // Face 3
    4, 7, 6, 4, 6, 5, // Face 4
    3, 0, 1, 3, 1, 2  // Face 5
 };
 
 //
 const unsigned int CUBE_WIRE_INDICES[EDGE_COUNT * VERTICES_PER_EDGE ] = {
    0, 1, 1, 2, 2, 3, 3, 0, // square
    4, 5, 5, 6, 6, 7, 7, 4, // facing square
    0, 4, 1, 5, 2, 6, 3, 7, // transverse lines
 };
 
 const GLfloat QUAD_VERTICES[] = {
     -1, -1, 0, 0,
      1, -1, 1, 0,
      1,  1, 1, 1,
     -1,  1, 0, 1,
 };
 
 const GLuint QUAD_INDICES[] = {
    2, 0, 3, 0, 1, 2,
 };
 
 
 #ifdef WIN32
 
     static string loadResource(const string& in) {
         static HMODULE module = GetModuleHandle(NULL);
         HRSRC res = FindResourceA(module, in.c_str(), "TEXTFILE");
         HGLOBAL mem = LoadResource(module, res);
         DWORD size = SizeofResource(module, res);
         LPVOID data = LockResource(mem);
         string result((const char*)data, size);
         FreeResource(mem);
         return result;
     }
 
 #else
 
     static string slurp(ifstream& in) {
         stringstream sstr;
         sstr << in.rdbuf();
         string result = sstr.str();
         assert(!result.empty());
         return result;
     }
 
     static string slurpFile(const string & in) {
         ifstream ins(in.c_str());
         assert(ins);
         return slurp(ins);
     }
 
     #ifdef __APPLE__
         static string loadResource(const string& in) {
             static CFBundleRef mainBundle = CFBundleGetMainBundle();
             assert(mainBundle);
 
             CFStringRef stringRef = CFStringCreateWithCString(NULL, in.c_str(), kCFStringEncodingASCII);
             assert(stringRef);
             CFURLRef resourceURL = CFBundleCopyResourceURL(mainBundle, stringRef, NULL, NULL);
             assert(resourceURL);
             char *fileurl = new char[PATH_MAX];
             auto result = CFURLGetFileSystemRepresentation(resourceURL, true, (UInt8*)fileurl, PATH_MAX);
             assert(result);
             return slurpFile(string(fileurl));
         }
 
     #else
         string executableDirectory(".");
 
         static string loadResource(const string& in) {
             return slurpFile(executableDirectory + "/" + in);
         }
 
     #endif // __APPLE__
 
 #endif // WIN32
 
 // A small class to encapsulate loading of shaders into a GL program
 class GLprogram {
     static string getProgramLog(GLuint program) {
         string log;
         GLint infoLen = 0;
         glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLen);
 
         if (infoLen > 1) {
             char* infoLog = new char[infoLen];
             glGetProgramInfoLog(program, infoLen, NULL, infoLog);
             log = string(infoLog);
             delete[] infoLog;
         }
         return log;
     }
 
     static string getShaderLog(GLuint shader) {
         string log;
         GLint infoLen = 0;
         glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
 
         if (infoLen > 1) {
             char* infoLog = new char[infoLen];
             glGetShaderInfoLog(shader, infoLen, NULL, infoLog);
             log = string(infoLog);
             delete[] infoLog;
         }
         return log;
     }
 
     static GLuint compileShader(GLuint type, const string shaderSrc) {
         // Create the shader object
         GLuint shader = glCreateShader(type);
         assert(shader != 0);
         const char * srcPtr = shaderSrc.c_str();
         glShaderSource(shader, 1, &srcPtr, NULL);
         glCompileShader(shader);
         GLint compiled;
         glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
         if (compiled == 0) {
             string errorLog = getShaderLog(shader);
             cerr << errorLog << endl;
         }
         assert(compiled != 0);
         return shader;
     }
 
     static GLuint linkProgram(GLuint vertexShader, GLuint fragmentShader) {
         GLuint program = glCreateProgram();
         assert(program != 0);
         glAttachShader(program, vertexShader);
         glAttachShader(program, fragmentShader);
         // Link the newProgram
         glLinkProgram(program);
         // Check the link status
         GLint linked;
         glGetProgramiv(program, GL_LINK_STATUS, &linked);
         if (linked == 0) {
             cerr << getProgramLog(program) << endl;
         }
         assert(linked != 0);
         return program;
     }
 
     GLuint vertexShader;
     GLuint fragmentShader;
     GLuint program;
     typedef map<string, GLint> Map;
     Map attributes;
     Map uniforms;
 
 public:
     GLprogram() : vertexShader(0), fragmentShader(0), program(0), wasCalled(false) { }
 	bool wasCalled;
 
     void use() {
         glUseProgram(program);
     }
 
     void close() {
         if (0 != program) {
             glDeleteProgram(program);
             program = 0;
         }
         if (0 != vertexShader) {
             glDeleteShader(vertexShader);
         }
         if (0 != fragmentShader) {
             glDeleteShader(fragmentShader);
         }
     }
 
     void open(const string & name) {
 		// load shaders only once
 		if(!wasCalled){
 			cout << "open shader " << name << "\n";
 			open(name + ".vs", name + ".fs");
 			wasCalled = true;
 		}
     }
 
     void open(const string & vertexShaderFile, const string & fragmentShaderFile) {
         string source = loadResource(vertexShaderFile);
         vertexShader = compileShader(GL_VERTEX_SHADER, source);
         source = loadResource(fragmentShaderFile);
         fragmentShader = compileShader(GL_FRAGMENT_SHADER, source);
         program = linkProgram(vertexShader, fragmentShader);
         attributes.clear();
         static GLchar GL_OUTPUT_BUFFER[8192];
         int numVars;
         glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &numVars);
         for (int i = 0; i < numVars; ++i) {
             GLsizei bufSize = 8192;
             GLsizei size; GLenum type;
             glGetActiveAttrib(program, i, bufSize, &bufSize, &size, &type, GL_OUTPUT_BUFFER);
             string name = string(GL_OUTPUT_BUFFER, bufSize);
             GLint location = glGetAttribLocation(program, name.c_str());
             attributes[name] = location;
             cout << "Found attribute " << name << " at location " << location << endl;
         }
 
         uniforms.clear();
         glGetProgramiv(program, GL_ACTIVE_UNIFORMS, &numVars);
         for (int i = 0; i < numVars; ++i) {
             GLsizei bufSize = 8192;
             GLsizei size;
             GLenum type;
             glGetActiveUniform(program, i, bufSize, &bufSize, &size, &type, GL_OUTPUT_BUFFER);
             string name = string(GL_OUTPUT_BUFFER, bufSize);
             GLint location = glGetUniformLocation(program, name.c_str());
             uniforms[name] = location;
             cout << "Found uniform " << name << " at location " << location << endl;
         }
     }
 
     GLint getUniformLocation(const string & uniform) const {
         auto itr = uniforms.find(uniform);
         if (uniforms.end() != itr) {
             return itr->second;
         }
         return -1;
     }
 
     GLint getAttributeLocation(const string & attribute) const {
         Map::const_iterator itr = attributes.find(attribute);
         if (attributes.end() != itr) {
             return itr->second;
         }
         return -1;
     }
 
     void uniformMat4(const string & uniform, const glm::mat4 & mat) const {
         glUniformMatrix4fv(getUniformLocation(uniform), 1, GL_FALSE, glm::value_ptr(mat));
     }
 
     void uniform4f(const string & uniform, float a, float b, float c, float d) const{
         glUniform4f(getUniformLocation(uniform), a, b, c, d);
     }
 
     void uniform4f(const string & uniform, const float * fv) const {
         uniform4f(uniform, fv[0], fv[1], fv[2], fv[3]);
     }
 
     void uniform2f(const string & uniform, float a, float b) const {
         glUniform2f(getUniformLocation(uniform), a, b);
     }
 
     void uniform2f(const string & uniform, const glm::vec2 & vec) const {
         uniform2f(uniform, vec.x, vec.y);
     }
 };
 //
 void checkGlError() {
     GLenum error = glGetError();
     if (error != GL_NO_ERROR) {
 		switch(error){
 			case GL_INVALID_ENUM:
 				qDebug() << "OpenGL Error: GL_INVALID_ENUM";
 				break;
 			case GL_INVALID_VALUE:
 				qDebug() << "OpenGL Error: GL_INVALID_VALUE";
 				break;
 			case GL_INVALID_OPERATION:
 				qDebug() << "OpenGL Error: GL_INVALID_OPERATION";
 				break;
 			case GL_INVALID_FRAMEBUFFER_OPERATION:
 				qDebug() << "OpenGL Error: GL_INVALID_FRAMEBUFFER_OPERATION";
 				break;
 			case GL_OUT_OF_MEMORY:
 				qDebug() << "OpenGL Error: GL_OUT_OF_MEMORY";
 				break;
 			case GL_STACK_UNDERFLOW:
 				qDebug() << "OpenGL Error: GL_STACK_UNDERFLOW";
 				break;
 			case GL_STACK_OVERFLOW:
 				qDebug() << "OpenGL Error GL_STACK_OVERFLOW";
 				break;
 		}
     }
     //assert(error == 0);
 }
 
 const StereoEye EYES[2] = { StereoEye_Left, StereoEye_Right };
 
 //
 class Example00 : public QGLWidget {
 	public slots:
 
 protected:
     enum Mode {
         MONO, STEREO, STEREO_DISTORT
     };
 
     glm::mat4 projection;
     glm::mat4 modelview;
     Ptr<SensorDevice> ovrSensor;
     SensorFusion sensorFusion;
     StereoConfig stereoConfig;
 
     // Provides the resolution and location of the Rift
     HMDInfo hmdInfo;
     // Calculated width and height of the per-eye rendering area used
     int eyeWidth, eyeHeight;
     // Calculated width and height of the frame buffer object used to contain
     // intermediate results for the multipass render
     int fboWidth, fboHeight;
 
     Mode renderMode;
     bool useTracker;
     long elapsed;
 
     GLuint cubeVertexBuffer;
     GLuint cubeIndexBuffer;
     GLuint cubeWireIndexBuffer;
 
     GLuint quadVertexBuffer;
     GLuint quadIndexBuffer;
 
     GLprogram renderProgram;
     GLprogram textureProgram;
     GLprogram distortProgram;
 
     GLuint frameBuffer;
     GLuint frameBufferTexture;
     GLuint depthBuffer;
 
 	// additions by Alexander
 	SoPerspectiveCamera *m_perspCam;
 	SoSeparator *m_root;
 
 	GLuint offscreenBufferTexture;
 	GLuint backgroundimage;
 	GLuint backgroundSceneImage;
 	GLuint backgroundBufferImage;
 
 	GLuint testFrameBuffer;
 	GLprogram ipoProgram;
 
 	QGLFramebufferObject *fbo;
 	SoSceneManager *sceneManager;
 
 	SoSeparator *root;
 	SbViewportRegion vpRegion;
 	SoPerspectiveCamera *perscam;
 
 	void initializeGL(){
 		qDebug() << "initializeGL";
 		char *ver = (char *) glGetString(GL_VERSION);
 		qDebug() << "GL Version" << ver;
 
 		// Since QGLFunctions is bugged, use glew for openGL access
 		glewInit();
 
 		initOpenGL();
 		loadShaders();
 
 		checkGlError();
         modelview = glm::lookAt(CAMERA, ORIGIN, UP);
         projection = glm::perspective(60.0f, (float)hmdInfo.HResolution / (float)hmdInfo.VResolution, 0.1f, 100.f);
 
 		// Use Window Resolution for correct distortion
 		resize(hmdInfo.HResolution, hmdInfo.VResolution);
 		move(0,0);
 		setWindowTitle("Oculus QGLWidget");
 
 		makeCurrent();
 		loadCoinScene();
 	}
 	//
 	void resizeGL(int w, int h){
 		qDebug() << "resizeGL";
 	}
 	//
 	void paintGL(){
 		draw();
 		update();
 	}
 	//
 	void loadCoinScene(){
 		qDebug() << "loadCoinScene";
 
 		// Init Coin
 		SoDB::init();
 		// The root node
 		root = new SoSeparator;
 		root->ref();
 
 		// It is mandatory to have at least one light for the offscreen renderer
 		SoDirectionalLight * light = new SoDirectionalLight;
 		root->addChild(light);
 		light->direction = SbVec3f(0, -0.5, -0.3);
 
 		vpRegion.setViewportPixels(0, 0, hmdInfo.HResolution, hmdInfo.VResolution);
 
 		perscam = new SoPerspectiveCamera();
 		root->addChild(perscam);
 
 		SoMaterial * greenmaterial = new SoMaterial;
 		greenmaterial->diffuseColor.setValue(0, 0.5, 0.5);
 		SoCube * cube = new SoCube;
 		root->addChild(greenmaterial);
 		root->addChild(cube);
 
 		// same as projection = glm::perspective(60.0f,
 		//				(float)hmdInfo.HResolution / (float)hmdInfo.VResolution, 0.1f, 100.f);
 		perscam->nearDistance = 0.1;
 		perscam->farDistance = 100.0f;
 		perscam->heightAngle = glm::radians(60.0f);
 		perscam->aspectRatio = (float)hmdInfo.HResolution / (float)hmdInfo.VResolution;
 		perscam->viewportMapping = SoPerspectiveCamera::LEAVE_ALONE;
 
 		sceneManager = new SoSceneManager();
 		sceneManager->setSceneGraph(root);
 	}
 public:
 	Example00(QWidget *parent) : QGLWidget(parent), renderMode(MONO), useTracker(false), elapsed(0),
         cubeVertexBuffer(0), cubeIndexBuffer(0), cubeWireIndexBuffer(0), quadVertexBuffer(0), quadIndexBuffer(0),
 		frameBuffer(0), frameBufferTexture(0), depthBuffer(0) {
 
 		qDebug() << "Example00(QWidget *parent)";
 		initOculus();
 	}
 
 	Example00() : renderMode(MONO), useTracker(false), elapsed(0),
         cubeVertexBuffer(0), cubeIndexBuffer(0), cubeWireIndexBuffer(0), quadVertexBuffer(0), quadIndexBuffer(0),
         frameBuffer(0), frameBufferTexture(0), depthBuffer(0) {
 
 		qDebug() << "Example00()";
 		initOculus();
     }
 	//
 	void initOculus(){
         // do the master initialization for the Oculus VR SDK
         OVR::System::Init();
 
         sensorFusion.SetGravityEnabled(false);
         sensorFusion.SetPredictionEnabled(false);
         sensorFusion.SetYawCorrectionEnabled(false);
 
         hmdInfo.HResolution = 1280;
         hmdInfo.VResolution = 800;
         hmdInfo.HScreenSize = 0.149759993f;
         hmdInfo.VScreenSize = 0.0935999975f;
         hmdInfo.VScreenCenter = 0.0467999987f;
         hmdInfo.EyeToScreenDistance    = 0.0410000011f;
         hmdInfo.LensSeparationDistance = 0.0635000020f;
         hmdInfo.InterpupillaryDistance = 0.0640000030f;
         hmdInfo.DistortionK[0] = 1.00000000f;
         hmdInfo.DistortionK[1] = 0.219999999f;
         hmdInfo.DistortionK[2] = 0.239999995f;
         hmdInfo.DistortionK[3] = 0.000000000f;
         hmdInfo.ChromaAbCorrection[0] = 0.995999992f;
         hmdInfo.ChromaAbCorrection[1] = -0.00400000019f;
         hmdInfo.ChromaAbCorrection[2] = 1.01400006f;
         hmdInfo.ChromaAbCorrection[3] = 0.000000000f;
         hmdInfo.DesktopX = 0;
         hmdInfo.DesktopY = 0;
 
 
         ///////////////////////////////////////////////////////////////////////////
         // Initialize Oculus VR SDK and hardware
         Ptr<DeviceManager> ovrManager = *DeviceManager::Create();
         if (ovrManager) {
             ovrSensor = *ovrManager->EnumerateDevices<SensorDevice>().CreateDevice();
             if (ovrSensor) {
                 useTracker = true;
                 sensorFusion.AttachToSensor(ovrSensor);
             }
             Ptr<HMDDevice> ovrHmd = *ovrManager->EnumerateDevices<HMDDevice>().CreateDevice();
             if (ovrHmd) {
                 ovrHmd->GetDeviceInfo(&hmdInfo);
             }
             // The HMDInfo structure contains everything we need for now, so no
             // need to keep the device handle around
             ovrHmd.Clear();
         }
         // The device manager is reference counted and will be released automatically
         // when our sensorObject is destroyed.
         ovrManager.Clear();
         stereoConfig.SetHMDInfo(hmdInfo);
 		stereoConfig.SetStereoMode(StereoMode::Stereo_None);
 	}
 	//
 	void initOpenGL(){
 		// Enable the zbuffer test
         glEnable(GL_DEPTH_TEST);
         glLineWidth(2.0f);
         glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
         glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
 
         glGenBuffers(1, &cubeVertexBuffer);
         glBindBuffer(GL_ARRAY_BUFFER, cubeVertexBuffer);
         glBufferData(GL_ARRAY_BUFFER,
                 sizeof(GLfloat) * VERT_COUNT * VERTICES_PER_TRIANGLE, CUBE_VERTEX_DATA, GL_STATIC_DRAW);
         glBindBuffer(GL_ARRAY_BUFFER, 0);
 
         glGenBuffers(1, &cubeIndexBuffer);
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cubeIndexBuffer);
         glBufferData(GL_ELEMENT_ARRAY_BUFFER,
                 sizeof(GLuint) * FACE_COUNT * TRIANGLES_PER_FACE * VERTICES_PER_TRIANGLE,
                 CUBE_INDICES, GL_STATIC_DRAW);
 
         glGenBuffers(1, &cubeWireIndexBuffer);
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cubeWireIndexBuffer);
         glBufferData(GL_ELEMENT_ARRAY_BUFFER,
                 sizeof(GLuint) * EDGE_COUNT * VERTICES_PER_EDGE,
                 CUBE_WIRE_INDICES, GL_STATIC_DRAW);
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 
         glGenBuffers(1, &quadVertexBuffer);
         glGenBuffers(1, &quadIndexBuffer);
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, quadIndexBuffer);
         glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * 6, QUAD_INDICES, GL_STATIC_DRAW);
 
 
         eyeWidth = hmdInfo.HResolution / 2;
         eyeHeight = hmdInfo.VResolution;
         fboWidth = eyeWidth * FRAMEBUFFER_OBJECT_SCALE;
         fboHeight = eyeHeight * FRAMEBUFFER_OBJECT_SCALE;
 
         glGenFramebuffers(1, &frameBuffer);
         glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);
 
         glGenTextures(1, &frameBufferTexture);
         glBindTexture(GL_TEXTURE_2D, frameBufferTexture);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
         // Allocate space for the texture
         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, fboWidth, fboHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 
         glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, frameBufferTexture, 0);
         glGenRenderbuffers(1, &depthBuffer);
         glBindRenderbuffer(GL_RENDERBUFFER, depthBuffer);
         glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, fboWidth, fboHeight);
         glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthBuffer);
         glEnable(GL_TEXTURE_2D);
         glBindFramebuffer(GL_FRAMEBUFFER, 0);
 	}
 	// Create the rendering shaders
 	void loadShaders(){
         renderProgram.open("Simple");
         textureProgram.open("Texture");
         distortProgram.open("Distort");
 	}
 	//
     virtual ~Example00() {
         sensorFusion.AttachToSensor(nullptr);
         ovrSensor.Clear();
         OVR::System::Destroy();
     }
 	//
 	void keyPressEvent( QKeyEvent * event ){
 		//QQuaternion absRot = Iv3dUtils::toQQuaternion(m_perspCam->orientation.getValue());
 
 		switch (event->key()){
 			case Qt::Key_P:
 				renderMode = static_cast<Mode>((renderMode + 1) % 3);
 				if (renderMode == MONO) {
 					projection = glm::perspective(60.0f,
 							(float)hmdInfo.HResolution / (float)hmdInfo.VResolution, 0.1f, 100.f);
 
 					perscam->heightAngle = glm::radians(60.0f);
 					perscam->aspectRatio = (float)hmdInfo.HResolution / (float)hmdInfo.VResolution;
 
 					stereoConfig.SetStereoMode(StereoMode::Stereo_None);
 				} else if (renderMode == STEREO) {
 					projection = glm::perspective(60.0f,
 							(float)hmdInfo.HResolution / 2.0f / (float)hmdInfo.VResolution, 0.1f, 100.f);
 
 					perscam->heightAngle = glm::radians(60.0f);
 					perscam->aspectRatio = (float)hmdInfo.HResolution / 2.0f / (float)hmdInfo.VResolution;
 
 					stereoConfig.SetStereoMode(StereoMode::Stereo_LeftRight_Multipass);
 				} else if (renderMode == STEREO_DISTORT) {
 					projection = glm::perspective(stereoConfig.GetYFOVDegrees(),
 							(float)hmdInfo.HResolution / 2.0f / (float)hmdInfo.VResolution, 0.1f, 100.f);
 
 					perscam->heightAngle = stereoConfig.GetYFOVRadians();
 					perscam->aspectRatio = (float)hmdInfo.HResolution / 2.0f / (float)hmdInfo.VResolution;
 
 					stereoConfig.SetStereoMode(StereoMode::Stereo_LeftRight_Multipass);
 				}
 				break;
 		}
 		QWidget ::keyPressEvent(event);
 	}
 	//
     virtual void update() {
         long now = millis();
         if (useTracker) {
             // For some reason building the quaternion directly from the OVR
             // x,y,z,w values does not work.  So instead we convert it into
             // euler angles and construct our glm::quaternion from those
 
             // Fetch the pitch roll and yaw out of the sensorFusion device
             glm::vec3 eulerAngles;
             sensorFusion.GetOrientation().GetEulerAngles<Axis_X, Axis_Y, Axis_Z, Rotate_CW, Handed_R>(
                 &eulerAngles.x, &eulerAngles.y, &eulerAngles.z);
 
             // Not convert it into a GLM quaternion.
             glm::quat orientation = glm::quat(eulerAngles);
 
             // Most applications want take a basic camera postion and apply the
             // orientation transform to it in this way:
             // modelview = glm::mat4_cast(orientation) * glm::lookAt(CAMERA, ORIGIN, UP);
 
             // However for this demonstration we want the cube to remain
             // centered in the viewport, and orbit our view around it.  This
             // serves two purposes.
             //
             // First, it's not possible to see a blank screen in the event
             // the HMD is oriented to point away from the origin of the scene.
             //
             // Second, a scene that has no points of reference other than a
             // single small object can be disorienting, leaving the user
             // feeling lost in a void.  Having a fixed object in the center
             // of the screen that you appear to be moving around should
             // provide less immersion, which in this instance is better
             modelview = glm::lookAt(CAMERA, ORIGIN, UP) * glm::mat4_cast(orientation);
 
 			//perscam->orientation = toSbRotation(getOrientation());	// experimental
         } else {
             // In the absence of head tracker information, we want to slowly
             // rotate the cube so that the animation of the scene is apparent
             static const float Y_ROTATION_RATE = 0.01f;
             static const float Z_ROTATION_RATE = 0.05f;
             modelview = glm::lookAt(CAMERA, ORIGIN, UP);
             //modelview = glm::rotate(modelview, elapsed * Y_ROTATION_RATE, Y_AXIS);
             //modelview = glm::rotate(modelview, elapsed * Z_ROTATION_RATE, Z_AXIS);
         }
         elapsed = now;
 
 		QGLWidget::update();
     }
 	//
     virtual void draw() {
 		//perscam->viewAll(root, vpRegion);	// experimental
 
         if (renderMode == MONO) {
             // If we're not working stereo, we're just going to render the
             // scene once, from a single position, directly to the back buffer
 			vpRegion.setViewportPixels(0, 0, hmdInfo.HResolution, hmdInfo.VResolution);
 
             glViewport(0, 0, hmdInfo.HResolution, hmdInfo.VResolution);
 			renderScene(glm::vec3(), glm::vec3(), stereoConfig.GetEyeRenderParams(StereoEye_Center));
         } else {
             // If we get here, we're rendering in stereo, so we have to render our output twice
             // We have to explicitly clear the screen here.  the Clear command doesn't object the viewport
             // and the clear command inside renderScene will only target the active framebuffer object.
             glClearColor(0, 1, 0, 1);
             glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
             for (int i = 0; i < 2; ++i) {
                 StereoEye eye = EYES[i];
                 glBindTexture(GL_TEXTURE_2D, 0);
 
                 // Compute the modelview and projection matrices for the rendered scene based on the eye and
                 // whether or not we're doing side by side or rift rendering
                 glm::vec3 eyeProjectionOffset;
                 if (renderMode == STEREO_DISTORT) {
                 	eyeProjectionOffset = glm::vec3(-stereoConfig.GetProjectionCenterOffset() / 2.0f, 0, 0);
                 }
                 glm::vec3 eyeModelviewOffset = glm::vec3(-stereoConfig.GetIPD() / 2.0f, 0, 0);
                 if (eye == StereoEye_Left) {
                     eyeModelviewOffset *= -1;
                     eyeProjectionOffset *= -1;
                 }
 
 		vpRegion.setViewportPixels(0, 0, fboWidth, fboHeight);
 
                 glViewport(0, 0, fboWidth, fboHeight);
                 glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);
 				renderScene(eyeProjectionOffset, eyeModelviewOffset, stereoConfig.GetEyeRenderParams(eye));
                 glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
 		// Setup the viewport for the eye to which we're rendering
                 glViewport(1 + (eye == StereoEye_Left ? 0 : eyeWidth), 1, eyeWidth - 2, eyeHeight - 2);
                 GLprogram & program = (renderMode == STEREO_DISTORT) ? distortProgram : textureProgram;
                 program.use();
                 GLint positionLocation = program.getAttributeLocation("Position");
                 assert(positionLocation > -1);
                 GLint texCoordLocation = program.getAttributeLocation("TexCoord");
                 assert(texCoordLocation > -1);
 
                 float texL = 0, texR = 1, texT = 1, texB = 0;
                 if (renderMode == STEREO_DISTORT) {
                     // Pysical width of the viewport
                     static float eyeScreenWidth = hmdInfo.HScreenSize / 2.0f;
                     // The viewport goes from -1,1.  We want to get the offset
                     // of the lens from the center of the viewport, so we only
                     // want to look at the distance from 0, 1, so we divide in
                     // half again
                     static float halfEyeScreenWidth = eyeScreenWidth / 2.0f;
 
                     // The distance from the center of the display panel (NOT
                     // the center of the viewport) to the lens axis
                     static float lensDistanceFromScreenCenter = hmdInfo.LensSeparationDistance / 2.0f;
 
                     // Now we we want to turn the measurement from
                     // millimeters into the range 0, 1
                     static float lensDistanceFromViewportEdge = lensDistanceFromScreenCenter / halfEyeScreenWidth;
 
                     // Finally, we want the distnace from the center, not the
                     // distance from the edge, so subtract the value from 1
                     static float lensOffset = 1.0f - lensDistanceFromViewportEdge;
                     static glm::vec2 aspect(1.0, (float)eyeWidth / (float)eyeHeight);
 
                     glm::vec2 lensCenter(lensOffset, 0);
 
                     // Texture coordinates need to be in lens-space for the
                     // distort shader
                     texL = -1 - lensOffset;
                     texR = 1 - lensOffset;
                     texT = 1 / aspect.y;
                     texB = -1 / aspect.y;
                     // Flip the values for the right eye
                     if (eye != StereoEye_Left) {
                         swap(texL, texR);
                         texL *= -1;
                         texR *= -1;
                         lensCenter *= -1;
                     }
 
                     static glm::vec2 distortionScale(1.0f / stereoConfig.GetDistortionScale(),
                         1.0f / stereoConfig.GetDistortionScale());
                     program.uniform2f("LensCenter", lensCenter);
                     program.uniform2f("Aspect", aspect);
                     program.uniform2f("DistortionScale", distortionScale);
                     program.uniform4f("K", hmdInfo.DistortionK);
                 }
 
 				// Vertices zeichnen
                 const GLfloat quadVertices[] = {
                     -1, -1, texL, texB,
                      1, -1, texR, texB,
                      1,  1, texR, texT,
                     -1,  1, texL, texT,
                 };
 
                 glBindTexture(GL_TEXTURE_2D, frameBufferTexture);
                 glBindBuffer(GL_ARRAY_BUFFER, quadVertexBuffer);
                 glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 2 * 2 * 4, quadVertices, GL_DYNAMIC_DRAW);
 
                 int stride = sizeof(GLfloat) * 2 * 2;
                 glEnableVertexAttribArray(positionLocation);
                 glVertexAttribPointer(positionLocation, 2, GL_FLOAT, GL_FALSE, stride, 0);
                 glEnableVertexAttribArray(texCoordLocation);
                 glVertexAttribPointer(texCoordLocation, 2, GL_FLOAT, GL_FALSE, stride, (GLvoid*)(sizeof(GLfloat) * 2));
 
                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, quadIndexBuffer);
                 glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, (GLvoid*)0);
                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 
                 glBindBuffer(GL_ARRAY_BUFFER, 0);
             } // for
         } // if
     }
 	//
 	virtual void renderScene(const glm::vec3 & projectionOffset, const glm::vec3 & modelviewOffset, const StereoEyeParams eyeParam) {
     	glm::mat4 sceneProjection = glm::translate(glm::mat4(), projectionOffset) * projection;
         glm::mat4 sceneModelview = glm::translate(glm::mat4(), modelviewOffset) * modelview;
-		glm::mat4 sceneProjModelProduct = sceneProjection * sceneModelview;	// experimental
+	glm::mat4 sceneProjModelProduct = sceneProjection * sceneModelview;
 
     	// Clear the buffer
         glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
         // Configure the GL pipeline for rendering our geometry
         renderProgram.use();
 
         // Load the projection and modelview matrices into the program
         renderProgram.uniformMat4("Projection", sceneProjection);
         renderProgram.uniformMat4("ModelView", sceneModelview);
-		renderProgram.uniformMat4("ProjectionModelView", sceneProjModelProduct);	// experimental
+
         // Load up our cube geometry (vertices and indices)
         glBindBuffer(GL_ARRAY_BUFFER, cubeVertexBuffer);
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cubeIndexBuffer);
 
         // Bind the vertex data to the program
         GLint positionLocation = renderProgram.getAttributeLocation("Position");
         GLint colorLocation = renderProgram.getUniformLocation("Color");
 
         glEnableVertexAttribArray(positionLocation);
         glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, 12, (GLvoid*)0);
 
         // Draw the cube faces, two calls for each face in order to set the color and then draw the geometry
         for (uintptr_t i = 0; i < FACE_COUNT; ++i) {
             renderProgram.uniform4f("Color", CUBE_FACE_COLORS + (i * 4));
             glDrawElements(GL_TRIANGLES, TRIANGLES_PER_FACE * VERTICES_PER_TRIANGLE, GL_UNSIGNED_INT, (void*)(i * 6 * 4));
         }
 
         // Now scale the modelview matrix slightly, so we can draw the cube outline
         //glm::mat4 scaledCamera = glm::scale(sceneModelview, glm::vec3(1.01f));
         //renderProgram.uniformMat4("ModelView", scaledCamera);
 
         // Drawing a white wireframe around the cube
         //glUniform4f(colorLocation, 1, 1, 1, 1);
 
         /*glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cubeWireIndexBuffer);
         glDrawElements(GL_LINES, EDGE_COUNT * VERTICES_PER_EDGE, GL_UNSIGNED_INT, (void*)0);*/
         //glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 
         glBindBuffer(GL_ARRAY_BUFFER, 0);
 
 	glUseProgram(0);
-		glUseProgram(0);
+
 
 	///////////////////////////////////////////////////////////////////////////////////////////
-		///////////////////////////////////////////////////////////////////////////////////////////
+	//perscam->viewAll(root, vpRegion);
-		//perscam->viewAll(root, vpRegion);
+
 	sceneManager->setViewportRegion(vpRegion);
-		sceneManager->setViewportRegion(vpRegion);
+	sceneManager->render(false, false);
-		sceneManager->render(false, false);
+
 	SbMatrix SbSceneProjModelView = toSbMatrix(sceneProjModelProduct);
-		SbMatrix SbSceneProjModelView = toSbMatrix(sceneProjModelProduct);
+
 	SbVec3f translation;
-		SbVec3f translation;
+	SbRotation rotation;
-		SbRotation rotation;
+	SbVec3f scaleFactor;
-		SbVec3f scaleFactor;
+	SbRotation scaleOrientation;
-		SbRotation scaleOrientation;
+	SbSceneProjModelView.getTransform(translation, rotation, scaleFactor, scaleOrientation);
-		SbSceneProjModelView.getTransform(translation, rotation, scaleFactor, scaleOrientation);
+
 	perscam->position = translation;
-		perscam->position = translation;
+	perscam->orientation = rotation;
-		perscam->orientation = rotation;
+
 
 	QQuaternion getOrientation() const{
 		// Create identity quaternion
 		QQuaternion osgQuat(0.0f, 0.0f, 0.0f, 1.0f);
 
 		if (sensorFusion.IsAttachedToSensor()) {
 			OVR::Quatf quat = sensorFusion.GetOrientation();
 			osgQuat = QQuaternion(quat.w, quat.x, quat.y, quat.z);
 		}
 
 		return osgQuat;
 	}
 	SbRotation toSbRotation(QQuaternion &q){
 		return SbRotation(q.x(), q.y(), q.z(),q.scalar());
 	}
 	SbVec3f toSbVec3f(const QVector3D &v ){
 		return SbVec3f(v.x(), v.y(), v.z());
 	}
 	SbVec3f toSbVec3f(const glm::vec3 &v ){
 		return SbVec3f(v.x, v.y, v.z);
 	}
 	QVector3D toQVector3D(const glm::vec3 &v ){
 		return QVector3D(v.x, v.y, v.z);
 	}
 	SbMatrix toSbMatrix(const glm::mat4 &m){
 		return SbMatrix(
 			m[0][0], m[0][1], m[0][2], m[0][3],
 			m[1][0], m[1][1], m[1][2], m[1][3],
 			m[2][0], m[2][1], m[2][2], m[2][3],
 			m[3][0], m[3][1], m[3][2], m[3][3]
 		);
 	}
 };
 
 
 int main(int argc, char ** argv) {
 	QApplication app(argc, argv);
 
 	Example00 exmpl = Example00();
 
 	// widget
 	exmpl.show();
 	app.exec();
 }