From cc39b4660a6a4e0c9a9939c2d9a445bcf102fe66 Mon Sep 17 00:00:00 2001 From: raysan5 Date: Sun, 1 May 2016 21:55:34 +0200 Subject: [PATCH] New oculus sample to test... --- .../oculus_glfw_sample/oculus_glfw_sample.c | 30 +- .../oculus_glfw_sample_new.c | 280 ++++++++++++++++++ 2 files changed, 298 insertions(+), 12 deletions(-) create mode 100644 examples/oculus_glfw_sample/oculus_glfw_sample_new.c diff --git a/examples/oculus_glfw_sample/oculus_glfw_sample.c b/examples/oculus_glfw_sample/oculus_glfw_sample.c index f6287631..19de0188 100644 --- a/examples/oculus_glfw_sample/oculus_glfw_sample.c +++ b/examples/oculus_glfw_sample/oculus_glfw_sample.c @@ -91,12 +91,13 @@ int main() { // Initialization //-------------------------------------------------------------------------------------- + ovrSession session; + ovrGraphicsLuid luid; // Useless for OpenGL since SDK 0.7 + ovrHmdDesc hmdDesc; + ovrResult result = ovr_Initialize(NULL); if (OVR_FAILURE(result)) TraceLog(LOG_ERROR, "OVR: Could not initialize Oculus device"); - ovrSession session; - ovrGraphicsLuid luid; // Useless for OpenGL since SDK 0.7 - result = ovr_Create(&session, &luid); if (OVR_FAILURE(result)) { @@ -104,7 +105,7 @@ int main() ovr_Shutdown(); } - ovrHmdDesc hmdDesc = ovr_GetHmdDesc(session); + hmdDesc = ovr_GetHmdDesc(session); TraceLog(LOG_INFO, "OVR: Product Name: %s", hmdDesc.ProductName); TraceLog(LOG_INFO, "OVR: Manufacturer: %s", hmdDesc.Manufacturer); @@ -129,10 +130,12 @@ int main() } else TraceLog(LOG_INFO, "GLFW3: GLFW initialized successfully"); + glfwWindowHint(GLFW_DEPTH_BITS, 16); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); - glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); + //glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); + glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE); glfwWindowHint(GLFW_DECORATED, GL_FALSE); // Mandatory on Oculus Rift to avoid program crash! window = glfwCreateWindow(screenWidth, screenHeight, "rlgl standalone", NULL, NULL); @@ -209,6 +212,10 @@ int main() TraceLog(LOG_WARNING, "OVR: Could not initialize mirror framebuffers"); } + glClearColor(1.0f, 0.1f, 0.1f, 0.0f); + glEnable(GL_DEPTH_TEST); + ovr_RecenterTrackingOrigin(session); + // FloorLevel will give tracking poses where the floor height is 0 ovr_SetTrackingOriginType(session, ovrTrackingOrigin_FloorLevel); //-------------------------------------------------------------------------------------- @@ -218,7 +225,8 @@ int main() { // Update //---------------------------------------------------------------------------------- - + frameIndex++; + // TODO: Update game here! // Call ovr_GetRenderDesc each frame to get the ovrEyeRenderDesc, as the returned values (e.g. HmdToEyeOffset) may change at runtime. @@ -238,15 +246,15 @@ int main() //---------------------------------------------------------------------------------- // Clear screen to red color - glClearColor(1.0f, 0.1f, 0.1f, 0.0f); - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + //glClearColor(1.0f, 0.1f, 0.1f, 0.0f); + //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); if (isVisible) { for (int eye = 0; eye < 2; ++eye) { SetOculusBuffer(session, eyeRenderBuffer[eye]); - + // TODO: Get view and projection matrices for the eye // Sample using Oculus OVR_Math.h (C++) /* @@ -322,8 +330,6 @@ int main() glfwSwapBuffers(window); glfwPollEvents(); - - //frameIndex++; //? //---------------------------------------------------------------------------------- } @@ -398,7 +404,7 @@ static OculusBuffer LoadOculusBuffer(ovrSession session, int width, int height) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); - glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, buffer.width, buffer.height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL); + glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT16, buffer.width, buffer.height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL); return buffer; } diff --git a/examples/oculus_glfw_sample/oculus_glfw_sample_new.c b/examples/oculus_glfw_sample/oculus_glfw_sample_new.c new file mode 100644 index 00000000..4a468949 --- /dev/null +++ b/examples/oculus_glfw_sample/oculus_glfw_sample_new.c @@ -0,0 +1,280 @@ + +#include +#include +#include + +#include "glad.h" // Extensions loading library +#include + +#include "OculusSDK/LibOVR/Include/OVR_CAPI_GL.h" // Oculus SDK for OpenGL + +#define FAIL(X) printf(X); + +typedef struct Vector2 { + float x; + float y; +} Vector2; + +typedef struct Matrix { + float m0, m4, m8, m12; + float m1, m5, m9, m13; + float m2, m6, m10, m14; + float m3, m7, m11, m15; +} Matrix; + +// RiftManagerApp class +ovrSession session; +ovrHmdDesc hmdDesc; +ovrGraphicsLuid luid; + +// RiftApp class +GLuint fbo = 0; +GLuint depthBuffer = 0; +ovrTextureSwapChain eyeTexture; + +GLuint mirrorFbo = 0; +ovrMirrorTexture mirrorTexture; +ovrEyeRenderDesc eyeRenderDescs[2]; +Matrix eyeProjections[2]; + +ovrLayerEyeFov eyeLayer; +ovrViewScaleDesc viewScaleDesc; + +Vector2 renderTargetSize; +Vector2 mirrorSize; + +// GlfwApp class +GLFWwindow *window = NULL; +unsigned int frame = 0; + +static void ErrorCallback(int error, const char* description) +{ + fputs(description, stderr); +} + +static void KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods) +{ + if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) + { + glfwSetWindowShouldClose(window, GL_TRUE); + } +} + +// Execute our example class +int main() +{ + if (!OVR_SUCCESS(ovr_Initialize(NULL))) FAIL("Failed to initialize the Oculus SDK\n"); + + //result = ExampleApp().run(); // class ExampleApp : public RiftApp : public GlfwApp, public RiftManagerApp + + if (!OVR_SUCCESS(ovr_Create(&session, &luid))) FAIL("Unable to create HMD session\n"); + hmdDesc = ovr_GetHmdDesc(session); + + // RiftApp() constructor + viewScaleDesc.HmdSpaceToWorldScaleInMeters = 1.0f; + memset(&eyeLayer, 0, sizeof(ovrLayerEyeFov)); + eyeLayer.Header.Type = ovrLayerType_EyeFov; + eyeLayer.Header.Flags = ovrLayerFlag_TextureOriginAtBottomLeft; + + //ovr::for_each_eye([&](ovrEyeType eye) + for (int eye = 0; eye < 2; eye++) + { + eyeRenderDescs[eye] = ovr_GetRenderDesc(session, eye, hmdDesc.DefaultEyeFov[eye]); + ovrMatrix4f ovrPerspectiveProjection = ovrMatrix4f_Projection(eyeRenderDescs[eye].Fov, 0.01f, 1000.0f, ovrProjection_ClipRangeOpenGL); + //eyeProjections[eye] = ovr::toGlm(ovrPerspectiveProjection); + viewScaleDesc.HmdToEyeOffset[eye] = eyeRenderDescs[eye].HmdToEyeOffset; + + eyeLayer.Fov[eye] = eyeRenderDescs[eye].Fov; + ovrSizei eyeSize = ovr_GetFovTextureSize(session, eye, eyeLayer.Fov[eye], 1.0f); + eyeLayer.Viewport[eye].Size = eyeSize; + eyeLayer.Viewport[eye].Pos.x = renderTargetSize.x; + eyeLayer.Viewport[eye].Pos.y = 0; + + renderTargetSize.y = renderTargetSize.y; // std::max(renderTargetSize.y, (uint32_t)eyeSize.h); + renderTargetSize.x += eyeSize.w; + } + + // Make the on screen window 1/4 the resolution of the render target + mirrorSize = renderTargetSize; + mirrorSize.x /= 2; + mirrorSize.y /= 2; + + // GLFWApp() constructor + if (!glfwInit()) FAIL("Failed to initialize GLFW\n"); // Initialize the GLFW system for creating and positioning windows + glfwSetErrorCallback(ErrorCallback); + + ////preCreate(); + glfwWindowHint(GLFW_DEPTH_BITS, 16); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); + glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE); + + //***************window = createRenderingTarget(windowSize, windowPosition); //GLFWwindow *createRenderingTarget(uvec2 & size, ivec2 & pos) = 0; //glfw::createWindow(_mirrorSize); + /* + GLFWwindow *createWindow(const uvec2 &size, const ivec2 &position = ivec2(INT_MIN)) + { + GLFWwindow *window = glfwCreateWindow(size.x, size.y, "glfw", NULL, NULL); // size = mirrorSize + + if (!window) FAIL("Unable to create rendering window\n"); + + if ((position.x > INT_MIN) && (position.y > INT_MIN)) // INT_MIN = -32767 // #define INT_MIN (-2147483647 - 1) + { + glfwSetWindowPos(window, position.x, position.y); + } + + return window; + } + */ + + window = glfwCreateWindow(mirrorSize.x, mirrorSize.y, "glfw", NULL, NULL); + + if (!window) FAIL("Unable to create OpenGL window\n"); + + ////postCreate(); + //glfwSetWindowUserPointer(window, this); //// Useful to hack input callbacks + glfwSetKeyCallback(window, KeyCallback); + glfwMakeContextCurrent(window); + + // Initialize the OpenGL extensions + if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) FAIL("GLAD failed\n"); + /* + glewExperimental = GL_TRUE; + if (0 != glewInit()) FAIL("Failed to initialize GLEW\n"); + glGetError(); + + if (GLEW_KHR_debug) + { + GLint v; + glGetIntegerv(GL_CONTEXT_FLAGS, &v); + if (v & GL_CONTEXT_FLAG_DEBUG_BIT) glDebugMessageCallback(glDebugCallbackHandler, this); + } + */ + + ////initGl(); + { + // RiftApp::InitGL() -----> + //GlfwApp::initGl(); // virtual + + // Disable the v-sync for buffer swap + glfwSwapInterval(0); + + ovrTextureSwapChainDesc desc = {}; + desc.Type = ovrTexture_2D; + desc.ArraySize = 1; + desc.Width = renderTargetSize.x; + desc.Height = renderTargetSize.y; + desc.MipLevels = 1; + desc.Format = OVR_FORMAT_R8G8B8A8_UNORM_SRGB; + desc.SampleCount = 1; + desc.StaticImage = ovrFalse; + + ovrResult result = ovr_CreateTextureSwapChainGL(session, &desc, &eyeTexture); + eyeLayer.ColorTexture[0] = eyeTexture; + + if (!OVR_SUCCESS(result)) FAIL("Failed to create swap textures"); + + int length = 0; + result = ovr_GetTextureSwapChainLength(session, eyeTexture, &length); + + if (!OVR_SUCCESS(result) || !length) FAIL("Unable to count swap chain textures"); + + for (int i = 0; i < length; ++i) + { + GLuint chainTexId; + ovr_GetTextureSwapChainBufferGL(session, eyeTexture, i, &chainTexId); + glBindTexture(GL_TEXTURE_2D, chainTexId); + 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); + } + + glBindTexture(GL_TEXTURE_2D, 0); + + // Set up the framebuffer object + glGenFramebuffers(1, &fbo); + glGenRenderbuffers(1, &depthBuffer); + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo); + glBindRenderbuffer(GL_RENDERBUFFER, depthBuffer); + glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, renderTargetSize.x, renderTargetSize.y); + glBindRenderbuffer(GL_RENDERBUFFER, 0); + glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthBuffer); + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); + + ovrMirrorTextureDesc mirrorDesc; + memset(&mirrorDesc, 0, sizeof(mirrorDesc)); + mirrorDesc.Format = OVR_FORMAT_R8G8B8A8_UNORM_SRGB; + mirrorDesc.Width = mirrorSize.x; + mirrorDesc.Height = mirrorSize.y; + + if (!OVR_SUCCESS(ovr_CreateMirrorTextureGL(session, &mirrorDesc, &mirrorTexture))) FAIL("Could not create mirror texture"); + + glGenFramebuffers(1, &mirrorFbo); + + // RiftApp::InitGL() <------ + + glClearColor(0.2f, 0.2f, 0.2f, 0.0f); + glEnable(GL_DEPTH_TEST); + ovr_RecenterTrackingOrigin(session); + + // TODO: Init cube scene --> cubeScene = std::shared_ptr(new ColorCubeScene()); + } + + while (!glfwWindowShouldClose(window)) + { + frame++; + glfwPollEvents(); + + //update(); + + //draw(); ------> + ovrPosef eyePoses[2]; + ovr_GetEyePoses(session, frame, ovrTrue, viewScaleDesc.HmdToEyeOffset, eyePoses, &eyeLayer.SensorSampleTime); + + int curIndex; + ovr_GetTextureSwapChainCurrentIndex(session, eyeTexture, &curIndex); + GLuint curTexId; + ovr_GetTextureSwapChainBufferGL(session, eyeTexture, curIndex, &curTexId); + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo); + glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, curTexId, 0); + + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + for (int eye = 0; eye < 2; eye++) + { + glViewport(eyeLayer.Viewport[eye].Pos.x, eyeLayer.Viewport[eye].Pos.y, + eyeLayer.Viewport[eye].Size.w, eyeLayer.Viewport[eye].Size.h); + eyeLayer.RenderPose[eye] = eyePoses[eye]; + + //renderScene(_eyeProjections[eye], ovr::toGlm(eyePoses[eye])); --> cubeScene->render(projection, glm::inverse(headPose)); + } + + glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0); + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); + ovr_CommitTextureSwapChain(session, eyeTexture); + ovrLayerHeader *headerList = &eyeLayer.Header; + + ovr_SubmitFrame(session, frame, &viewScaleDesc, &headerList, 1); + + GLuint mirrorTextureId; + ovr_GetMirrorTextureBufferGL(session, mirrorTexture, &mirrorTextureId); + glBindFramebuffer(GL_READ_FRAMEBUFFER, mirrorFbo); + glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mirrorTextureId, 0); + glBlitFramebuffer(0, 0, mirrorSize.x, mirrorSize.y, 0, mirrorSize.y, mirrorSize.x, 0, GL_COLOR_BUFFER_BIT, GL_NEAREST); + glBindFramebuffer(GL_READ_FRAMEBUFFER, 0); + //draw() <------------- + + glfwSwapBuffers(window); //finishFrame(); + } + + //shutdownGl(); // Delete scene: cubeScene.reset(); + + glfwDestroyWindow(window); + glfwTerminate(); + + ovr_Destroy(session); + ovr_Shutdown(); + + return 0; +}