View difference between Paste ID: mbGRQuXY and K8B7fK90

 #define GLEW_STATIC
 #include "GL/glew.h"
 // Uncomment your platform
 //#define OVR_OS_WIN32
 //#define OVR_OS_MAC
 //#define OVR_OS_LINUX
 #include "OVR_CAPI_GL.h"
 #include "Kernel/OVR_Math.h"
 #include "SDL.h"
 #include "SDL_syswm.h"
 
 using namespace OVR;
 
 int main(int argc, char *argv[])
 {
 	SDL_Init(SDL_INIT_VIDEO);
 
 	int x = SDL_WINDOWPOS_CENTERED;
 	int y = SDL_WINDOWPOS_CENTERED;
 	Uint32 flags = SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN;
 
 	bool debug = false;
 
 	ovr_Initialize();
 
 	ovrHmd hmd = ovrHmd_Create(0);
 
 	if (hmd == NULL)
 	{
 		hmd = ovrHmd_CreateDebug(ovrHmd_DK1);
 
 		debug = true;
 	}
 
 	if (debug == false)
 	{
 		x = hmd->WindowsPos.x;
 		y = hmd->WindowsPos.y;
 		flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
 	}
 
 	int w = hmd->Resolution.w;
 	int h = hmd->Resolution.h;
 
 	SDL_Window *window = SDL_CreateWindow("Oculus Rift SDL2 OpenGL Demo", x, y, w, h, flags);
 
 	SDL_GLContext context = SDL_GL_CreateContext(window);
 
 	glewExperimental = GL_TRUE;
 
 	glewInit();
 
 	Sizei recommendedTex0Size = ovrHmd_GetFovTextureSize(hmd, ovrEye_Left, hmd->DefaultEyeFov[0], 1.0f);
 	Sizei recommendedTex1Size = ovrHmd_GetFovTextureSize(hmd, ovrEye_Right, hmd->DefaultEyeFov[1], 1.0f);
 	Sizei renderTargetSize;
 	renderTargetSize.w = recommendedTex0Size.w + recommendedTex1Size.w;
 	renderTargetSize.h = max(recommendedTex0Size.h, recommendedTex1Size.h);
 
 	GLuint frameBuffer;
 	glGenFramebuffers(1, &frameBuffer);
 
 	GLuint texture;
 	glGenTextures(1, &texture);
 
 	glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);
 	glBindTexture(GL_TEXTURE_2D, texture);
 	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, renderTargetSize.w, renderTargetSize.h, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 	glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, texture, 0);
 
 	GLuint renderBuffer;
 	glGenRenderbuffers(1, &renderBuffer);
 	glBindRenderbuffer(GL_RENDERBUFFER, renderBuffer);
 	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, renderTargetSize.w, renderTargetSize.h);
 	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, renderBuffer);
 
 	if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
 	{
 		glDeleteFramebuffers(1, &frameBuffer);
 		glDeleteTextures(1, &texture);
 		glDeleteRenderbuffers(1, &renderBuffer);
 
 		SDL_GL_DeleteContext(context);
 
 		SDL_DestroyWindow(window);
 
 		ovrHmd_Destroy(hmd);
 
 		ovr_Shutdown();
 
 		SDL_Quit();
 
 		return 0;
 	}
 
 	ovrFovPort eyeFov[2] = { hmd->DefaultEyeFov[0], hmd->DefaultEyeFov[1] };
 
 	ovrRecti eyeRenderViewport[2];
 	eyeRenderViewport[0].Pos = Vector2i(0, 0);
 	eyeRenderViewport[0].Size = Sizei(renderTargetSize.w / 2, renderTargetSize.h);
 	eyeRenderViewport[1].Pos = Vector2i((renderTargetSize.w + 1) / 2, 0);
 	eyeRenderViewport[1].Size = eyeRenderViewport[0].Size;
 
 	ovrGLTexture eyeTexture[2];
 	eyeTexture[0].OGL.Header.API = ovrRenderAPI_OpenGL;
 	eyeTexture[0].OGL.Header.TextureSize = renderTargetSize;
 	eyeTexture[0].OGL.Header.RenderViewport = eyeRenderViewport[0];
 	eyeTexture[0].OGL.TexId = texture;
 
 	eyeTexture[1] = eyeTexture[0];
 	eyeTexture[1].OGL.Header.RenderViewport = eyeRenderViewport[1];
 
 	SDL_SysWMinfo info;
 
 	SDL_VERSION(&info.version);
 
 	SDL_GetWindowWMInfo(window, &info);
 
 	ovrGLConfig cfg;
 	cfg.OGL.Header.API = ovrRenderAPI_OpenGL;
 	cfg.OGL.Header.RTSize = Sizei(hmd->Resolution.w, hmd->Resolution.h);
 	cfg.OGL.Header.Multisample = 1;
 #if defined(OVR_OS_WIN32)
-	ovrHmd_AttachToWindow(hmd, info.info.win.window, NULL, NULL);
+	if (!(hmd->HmdCaps & ovrHmdCap_ExtendDesktop))
 		ovrHmd_AttachToWindow(hmd, info.info.win.window, NULL, NULL);
 
 	cfg.OGL.Window = info.info.win.window;
 	cfg.OGL.DC = NULL;
 #elif defined(OVR_OS_LINUX)
 	cfg.OGL.Disp = info.info.x11.display;
 	cfg.OGL.Win = info.info.x11.window;
 #endif
 
 	ovrEyeRenderDesc eyeRenderDesc[2];
 
 	ovrHmd_ConfigureRendering(hmd, &cfg.Config, ovrDistortionCap_Chromatic | ovrDistortionCap_Vignette | ovrDistortionCap_TimeWarp | ovrDistortionCap_Overdrive, eyeFov, eyeRenderDesc);
 
 	ovrHmd_SetEnabledCaps(hmd, ovrHmdCap_LowPersistence | ovrHmdCap_DynamicPrediction);
 
 	ovrHmd_ConfigureTracking(hmd, ovrTrackingCap_Orientation | ovrTrackingCap_MagYawCorrection | ovrTrackingCap_Position, 0);
 
 	const GLchar *vertexShaderSource[] = {
 		"#version 150\n"
 		"uniform mat4 MVPMatrix;\n"
 		"in vec3 position;\n"
 		"void main()\n"
 		"{\n"
 		"    gl_Position = MVPMatrix * vec4(position, 1.0);\n"
 		"}"
 	};
 
 	GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
 	glShaderSource(vertexShader, 1, vertexShaderSource, NULL);
 	glCompileShader(vertexShader);
 
 	const GLchar *fragmentShaderSource[] = {
 		"#version 150\n"
 		"out vec4 outputColor;\n"
 		"void main()\n"
 		"{\n"
 		"    outputColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
 		"}"
 	};
 
 	GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
 	glShaderSource(fragmentShader, 1, fragmentShaderSource, NULL);
 	glCompileShader(fragmentShader);
 
 	GLuint program = glCreateProgram();
 	glAttachShader(program, vertexShader);
 	glAttachShader(program, fragmentShader);
 	glLinkProgram(program);
 	glUseProgram(program);
 
 	GLuint MVPMatrixLocation = glGetUniformLocation(program, "MVPMatrix");
 	GLuint positionLocation = glGetAttribLocation(program, "position");
 
 	GLuint vertexArray;
 	glGenVertexArrays(1, &vertexArray);
 	glBindVertexArray(vertexArray);
 
 	GLfloat vertices[] = {
 		0.0f, 1.0f, -2.0f,
 		-1.0f, -1.0f, -2.0f,
 		1.0f, -1.0f, -2.0f
 	};
 
 	GLuint positionBuffer;
 	glGenBuffers(1, &positionBuffer);
 	glBindBuffer(GL_ARRAY_BUFFER, positionBuffer);
 	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
 	glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, 0, 0);
 	glEnableVertexAttribArray(positionLocation);
 
 	glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
 	glClearDepth(1.0f);
 
 	glDepthFunc(GL_LEQUAL);
 	glEnable(GL_DEPTH_TEST);
 
 	bool running = true;
 
 	while (running == true)
 	{
 		SDL_Event event;
 
 		while (SDL_PollEvent(&event))
 		{
 			switch (event.type)
 			{
 			case SDL_QUIT:
 				running = false;
 				break;
 			case SDL_KEYDOWN:
 				ovrHmd_DismissHSWDisplay(hmd);
 
 				switch (event.key.keysym.sym)
 				{
 				case SDLK_ESCAPE:
 					running = false;
 					break;
 				default:
 					break;
 				}
 				break;
 			default:
 				break;
 			}
 		}
 
 		ovrFrameTiming frameTiming = ovrHmd_BeginFrame(hmd, 0);
 
 		glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);
 
 		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
 		ovrPosef eyeRenderPose[2];
 
 		for (int eyeIndex = 0; eyeIndex < ovrEye_Count; eyeIndex++)
 		{
 			ovrEyeType eye = hmd->EyeRenderOrder[eyeIndex];
 			eyeRenderPose[eye] = ovrHmd_GetEyePose(hmd, eye);
 
 			Matrix4f MVPMatrix = Matrix4f(ovrMatrix4f_Projection(eyeRenderDesc[eye].Fov, 0.01f, 10000.0f, true)) * Matrix4f::Translation(eyeRenderDesc[eye].ViewAdjust) * Matrix4f(Quatf(eyeRenderPose[eye].Orientation).Inverted());
 
 			glUniformMatrix4fv(MVPMatrixLocation, 1, GL_FALSE, &MVPMatrix.Transposed().M[0][0]);
 
 			glViewport(eyeRenderViewport[eye].Pos.x, eyeRenderViewport[eye].Pos.y, eyeRenderViewport[eye].Size.w, eyeRenderViewport[eye].Size.h);
 
 			glDrawArrays(GL_TRIANGLES, 0, 3);
 		}
 
 		glBindVertexArray(0);
 
 		ovrHmd_EndFrame(hmd, eyeRenderPose, &eyeTexture[0].Texture);
 
 		glBindVertexArray(vertexArray);
 	}
 
 	glDeleteVertexArrays(1, &vertexArray);
 	glDeleteBuffers(1, &positionBuffer);
 
 	glDeleteShader(vertexShader);
 	glDeleteShader(fragmentShader);
 	glDeleteProgram(program);
 
 	glDeleteFramebuffers(1, &frameBuffer);
 	glDeleteTextures(1, &texture);
 	glDeleteRenderbuffers(1, &renderBuffer);
 
 	SDL_GL_DeleteContext(context);
 
 	SDL_DestroyWindow(window);
 
 	ovrHmd_Destroy(hmd);
 
 	ovr_Shutdown();
 
 	SDL_Quit();
 
 	return 0;
 }