bool GLApp::InitAPI()
{
mDeviceContext = GetDC(mWindow);
PIXELFORMATDESCRIPTOR pfd;
ZeroMemory(&pfd, sizeof(PIXELFORMATDESCRIPTOR));
pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 32;
pfd.cDepthBits = 24;
pfd.cStencilBits = 8;
int format = ChoosePixelFormat(mDeviceContext, &pfd);
if (!SetPixelFormat(mDeviceContext, format, &pfd))
{
MessageBox(NULL, "Error setting pixel format", "Error", MB_OK | MB_ICONERROR);
return false;
}
mGLRenderContext = wglCreateContext(mDeviceContext);
if (!wglMakeCurrent(mDeviceContext, mGLRenderContext))
{
MessageBox(NULL, "Error creating and activatign render context", "Error", MB_OK | MB_ICONERROR);
return false;
}
if (glewInit())
{
MessageBox(NULL, "Error initializing GLEW", "Error", MB_OK | MB_ICONERROR);
return false;
}
glViewport(0, 0, (GLsizei)mWidth, (GLsizei)mHeight);
SetVsync();
return true;
}
static void TW_CALL DisableVSyncCB(void*) { SetVsync(0); }
static void TW_CALL EnableVSyncCB(void*) { SetVsync(1); }
static void TW_CALL AdaptiveVSyncCB(void*) { SetVsync(-1); }
void keyboard(GLFWwindow* pWindow, int key, int codes, int action, int mods)
{
(void)pWindow;
(void)codes;
if ((key > -1) && (key <= GLFW_KEY_LAST))
{
m_keyStates[key] = action;
//printf("key ac %d %d\n", key, action);
}
const float f = 0.9f;
const float ff = 0.99f;
ShaderToyGlobalState& gs = g_app.m_galleryScene.m_globalShadertoyState;
switch (key)
{
default: break;
case GLFW_KEY_BACKSLASH:
{
if (action==GLFW_PRESS ) g_app.m_dashScene.SendMouseClick(1);
else if (action==GLFW_RELEASE) g_app.m_dashScene.SendMouseClick(0);
}
break;
case GLFW_KEY_SLASH:
{
if (action==GLFW_PRESS ) g_app.m_dashScene.SetHoldingFlag(1);
else if (action==GLFW_RELEASE) g_app.m_dashScene.SetHoldingFlag(0);
}
break;
}
if (action == GLFW_PRESS)
{
g_app.DismissHealthAndSafetyWarning();
switch (key)
{
default: break;
case GLFW_KEY_F1:
if (mods & GLFW_MOD_CONTROL)
{
g_renderMode.toggleRenderingTypeReverse();
}
else
{
g_renderMode.toggleRenderingType();
}
LOG_INFO("Render Type: %d", g_renderMode.outputType);
break;
case GLFW_KEY_F2:
g_renderMode.toggleRenderingTypeMono();
LOG_INFO("Render Type: %d", g_renderMode.outputType);
break;
case GLFW_KEY_F3:
g_renderMode.toggleRenderingTypeHMD();
LOG_INFO("Render Type: %d", g_renderMode.outputType);
break;
case GLFW_KEY_F4:
g_renderMode.toggleRenderingTypeDistortion();
LOG_INFO("Render Type: %d", g_renderMode.outputType);
break;
case GLFW_KEY_F5: g_dynamicallyScaleFBO = false; g_app.SetFBOScale(f * g_app.GetFBOScale()); break;
case GLFW_KEY_F6: g_dynamicallyScaleFBO = false; g_app.SetFBOScale(ff * g_app.GetFBOScale()); break;
case GLFW_KEY_F7: g_dynamicallyScaleFBO = false; g_app.SetFBOScale((1.f/ff) * g_app.GetFBOScale()); break;
case GLFW_KEY_F8: g_dynamicallyScaleFBO = false; g_app.SetFBOScale((1.f/f) * g_app.GetFBOScale()); break;
case GLFW_KEY_F9: SetVsync(0); break;
case GLFW_KEY_F10: SetVsync(1); break;
case GLFW_KEY_F11: SetVsync(-1); break;
case GLFW_KEY_DELETE: g_dynamicallyScaleFBO = !g_dynamicallyScaleFBO; break;
case GLFW_KEY_SEMICOLON: gs.animatedThumbnails = !gs.animatedThumbnails; break;
case GLFW_KEY_APOSTROPHE: gs.panesAsPortals = !gs.panesAsPortals; break;
case '`':
///@todo Is there a way to create an auxiliary window in Direct to rift mode?
/// The call to glfwCreateWindow crashes the app in Win7.
#ifdef USE_OCULUSSDK
if (g_app.UsingDirectMode() == false)
#endif
{
if (g_AuxWindow == NULL)
{
g_AuxWindow = initializeAuxiliaryWindow(g_pHMDWindow);
#ifdef USE_ANTTWEAKBAR
///@note This will break PaneScene's tweakbar positioning
TwWindowSize(g_auxWindow_w, g_auxWindow_h);
#endif
}
else
{
destroyAuxiliaryWindow(g_AuxWindow);
glfwMakeContextCurrent(g_pHMDWindow);
}
}
break;
case GLFW_KEY_TAB:
if (g_app.UsingDebugHmd() == false)
{
g_app.m_dashScene.m_bDraw = !g_app.m_dashScene.m_bDraw;
if (g_app.m_dashScene.m_bDraw)
{
g_app.m_dashScene.ResizeTweakbar();
}
}
break;
case GLFW_KEY_SPACE:
g_app.RecenterPose();
FindPreferredJoystick();
break;
case 'J':
FindPreferredJoystick();
break;
case 'R':
g_app.ResetChassisTransformations();
break;
case GLFW_KEY_PAGE_DOWN:
g_app.m_cinemaScopeFactor += 0.1f;
g_app.m_cinemaScopeFactor = std::min(0.95f, g_app.m_cinemaScopeFactor);
break;
case GLFW_KEY_PAGE_UP:
g_app.m_cinemaScopeFactor -= 0.1f;
g_app.m_cinemaScopeFactor = std::max(0.f, g_app.m_cinemaScopeFactor);
break;
case GLFW_KEY_ENTER:
g_app.ToggleShaderWorld();
break;
case GLFW_KEY_PRINT_SCREEN:
g_app.SaveShaderSettings();
break;
case GLFW_KEY_ESCAPE:
if (g_AuxWindow == NULL)
{
// Clear the frame before calling all the destructors - even a few
// frames worth of frozen video is enough to cause discomfort!
///@note This does not seem to work in Direct mode.
glClearColor(58.f/255.f, 110.f/255.f, 165.f/255.f, 1.f); // Win7 default desktop color
glClear(GL_COLOR_BUFFER_BIT);
glfwSwapBuffers(g_pHMDWindow);
glClear(GL_COLOR_BUFFER_BIT);
glfwSwapBuffers(g_pHMDWindow);
g_app.exitVR();
glfwDestroyWindow(g_pHMDWindow);
glfwTerminate();
exit(0);
}
else
{
destroyAuxiliaryWindow(g_AuxWindow);
glfwMakeContextCurrent(g_pHMDWindow);
}
break;
}
}
//g_app.keyboard(key, action, 0,0);
const glm::vec3 forward(0.f, 0.f, -1.f);
const glm::vec3 up(0.f, 1.f, 0.f);
const glm::vec3 right(1.f, 0.f, 0.f);
// Handle keyboard movement(WASD keys)
glm::vec3 keyboardMove(0.0f, 0.0f, 0.0f);
if (m_keyStates['W'] != GLFW_RELEASE) { keyboardMove += forward; }
if (m_keyStates['S'] != GLFW_RELEASE) { keyboardMove -= forward; }
if (m_keyStates['A'] != GLFW_RELEASE) { keyboardMove -= right; }
if (m_keyStates['D'] != GLFW_RELEASE) { keyboardMove += right; }
if (m_keyStates['Q'] != GLFW_RELEASE) { keyboardMove -= up; }
if (m_keyStates['E'] != GLFW_RELEASE) { keyboardMove += up; }
if (m_keyStates[GLFW_KEY_UP] != GLFW_RELEASE) { keyboardMove += forward; }
if (m_keyStates[GLFW_KEY_DOWN] != GLFW_RELEASE) { keyboardMove -= forward; }
if (m_keyStates[GLFW_KEY_LEFT] != GLFW_RELEASE) { keyboardMove -= right; }
if (m_keyStates[GLFW_KEY_RIGHT] != GLFW_RELEASE) { keyboardMove += right; }
float mag = 1.0f;
if (m_keyStates[GLFW_KEY_LEFT_SHIFT] != GLFW_RELEASE) mag *= 0.1f;
if (m_keyStates[GLFW_KEY_LEFT_CONTROL] != GLFW_RELEASE) mag *= 10.0f;
if (m_keyStates[GLFW_KEY_RIGHT_SHIFT] != GLFW_RELEASE) mag *= 0.1f;
if (m_keyStates[GLFW_KEY_RIGHT_CONTROL] != GLFW_RELEASE) mag *= 10.0f;
// Yaw keys
g_app.m_keyboardYaw = 0.0f;
const float dyaw = 0.5f * mag; // radians at 60Hz timestep
if (m_keyStates['1'] != GLFW_RELEASE) { g_app.m_keyboardYaw = -dyaw; }
if (m_keyStates['3'] != GLFW_RELEASE) { g_app.m_keyboardYaw = dyaw; }
// Pitch and roll controls - if yaw is VR poison,
// this is torture and death!
g_app.m_keyboardDeltaPitch = 0.0f;
g_app.m_keyboardDeltaRoll = 0.0f;
if (g_allowPitch)
{
if (m_keyStates['2'] != GLFW_RELEASE) { g_app.m_keyboardDeltaPitch = -dyaw; }
if (m_keyStates['X'] != GLFW_RELEASE) { g_app.m_keyboardDeltaPitch = dyaw; }
}
if (g_allowRoll)
{
if (m_keyStates['Z'] != GLFW_RELEASE) { g_app.m_keyboardDeltaRoll = -dyaw; }
if (m_keyStates['C'] != GLFW_RELEASE) { g_app.m_keyboardDeltaRoll = dyaw; }
}
g_app.m_keyboardMove = mag * keyboardMove;
}
int main(int argc, char** argv)
{
LOG_INFO("RiftRay version %s", pRiftRayVersion);
#if defined(_WIN32)
LOG_INFO("Windows build.");
#elif defined(_LINUX)
LOG_INFO("Linux build.");
#elif defined(_MACOS)
LOG_INFO("MacOS build.");
#endif
bool useOpenGLCoreContext = false;
g_renderMode.outputType = RenderingMode::OVR_SDK;
#ifdef USE_CORE_CONTEXT
useOpenGLCoreContext = true;
#endif
#ifdef _LINUX
// Linux driver seems to be lagging a bit
useOpenGLCoreContext = false;
#endif
LOG_INFO("Using GLFW3 backend.");
LOG_INFO("Compiled against GLFW %i.%i.%i",
GLFW_VERSION_MAJOR,
GLFW_VERSION_MINOR,
GLFW_VERSION_REVISION);
int major, minor, revision;
glfwGetVersion(&major, &minor, &revision);
LOG_INFO("Running against GLFW %i.%i.%i", major, minor, revision);
LOG_INFO("glfwGetVersionString: %s", glfwGetVersionString());
// Command line options
for (int i=0; i<argc; ++i)
{
const std::string a = argv[i];
LOG_INFO("argv[%d]: %s", i, a.c_str());
if (!a.compare("-sdk"))
{
g_renderMode.outputType = RenderingMode::OVR_SDK;
}
else if (!a.compare("-client"))
{
g_renderMode.outputType = RenderingMode::OVR_Client;
}
else if (!a.compare("-core"))
{
useOpenGLCoreContext = true;
}
else if (!a.compare("-compat"))
{
useOpenGLCoreContext = false;
}
}
LoadConfigFile();
g_app.initHMD();
GLFWwindow* l_Window = NULL;
glfwSetErrorCallback(ErrorCallback);
if (!glfwInit())
{
exit(EXIT_FAILURE);
}
#ifdef __APPLE__
// Set the working directory to the Resources dir of the .app bundle
CFBundleRef mainBundle = CFBundleGetMainBundle();
CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(mainBundle);
char path[PATH_MAX];
CFURLGetFileSystemRepresentation(resourcesURL, TRUE, (UInt8 *)path, PATH_MAX);
CFRelease(resourcesURL);
strcat( path, "/shaders" );
struct stat sb;
if (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode))
chdir(path);
#endif
#ifndef _LINUX
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
# if defined(_MACOS)
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
# else
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
# endif
#endif //ndef _LINUX
if (useOpenGLCoreContext)
{
LOG_INFO("Using OpenGL core context.");
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
}
else
{
#ifndef _LINUX
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_COMPAT_PROFILE);
#endif
}
glfwWindowHint(GLFW_SAMPLES, 0);
#ifdef _DEBUG
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
#endif
std::string windowTitle = "RiftRay-v" + std::string(pRiftRayVersion);
#ifdef USE_OCULUSSDK
const ovrSizei sz = g_app.getHmdResolution();
const ovrVector2i pos = g_app.getHmdWindowPos();
if (g_app.UsingDebugHmd() == true)
{
// Create a normal, decorated application window
LOG_INFO("Using Debug HMD mode.");
windowTitle += "-GLFW-DebugHMD";
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), NULL, NULL);
g_app.m_dashScene.m_bDraw = false;
g_renderMode.outputType = RenderingMode::Mono_Buffered;
}
else if (g_app.UsingDirectMode())
{
LOG_INFO("Using Direct to Rift mode.");
windowTitle += "-GLFW-Direct";
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), NULL, NULL);
#if defined(_WIN32)
g_app.AttachToWindow((void*)glfwGetWin32Window(l_Window));
#endif
}
else
{
LOG_INFO("Using Extended desktop mode.");
windowTitle += "-GLFW-Extended";
glfwWindowHint(GLFW_DECORATED, 0);
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), NULL, NULL);
glfwWindowHint(GLFW_DECORATED, 1);
glfwSetWindowPos(l_Window, pos.x, pos.y);
}
resize(l_Window, sz.w, sz.h); // inform AppSkeleton of window size
#else
const glm::vec2 sz(800, 600);
// Create a normal, decorated application window
LOG_INFO("Using No VR SDK.");
windowTitle += "-GLFW-NoVRSDK";
g_renderMode.outputType = RenderingMode::Mono_Buffered;
l_Window = glfwCreateWindow(sz.x, sz.y, windowTitle.c_str(), NULL, NULL);
resize(l_Window, sz.x, sz.y); // inform AppSkeleton of window size
#endif //USE_OSVR|USE_OCULUSSDK
if (!l_Window)
{
LOG_INFO("Glfw failed to create a window. Exiting.");
glfwTerminate();
exit(EXIT_FAILURE);
}
#ifdef USE_OCULUSSDK
// Required for SDK rendering (to do the buffer swap on its own)
# if defined(_WIN32)
g_app.setWindow(glfwGetWin32Window(l_Window));
# elif defined(__linux__)
g_app.setWindow(glfwGetX11Display());
# endif
#endif
glfwMakeContextCurrent(l_Window);
glfwSetWindowSizeCallback(l_Window, resize);
glfwSetMouseButtonCallback(l_Window, mouseDown);
glfwSetCursorPosCallback(l_Window, mouseMove);
glfwSetScrollCallback(l_Window, mouseWheel);
glfwSetKeyCallback(l_Window, keyboard);
memset(m_keyStates, 0, GLFW_KEY_LAST*sizeof(int));
FindPreferredJoystick();
// Log system monitor information
const GLFWmonitor* pPrimary = glfwGetPrimaryMonitor();
int monitorCount = 0;
GLFWmonitor** ppMonitors = glfwGetMonitors(&monitorCount);
for (int i=0; i<monitorCount; ++i)
{
GLFWmonitor* pCur = ppMonitors[i];
const GLFWvidmode* mode = glfwGetVideoMode(pCur);
if (mode != NULL)
{
LOG_INFO("Monitor #%d: %dx%d @ %dHz %s",
i,
mode->width,
mode->height,
mode->refreshRate,
pCur==pPrimary ? "Primary":"");
}
}
printGLContextInfo(l_Window);
glfwMakeContextCurrent(l_Window);
g_pHMDWindow = l_Window;
// Don't forget to initialize Glew, turn glewExperimental on to
// avoid problems fetching function pointers...
glewExperimental = GL_TRUE;
const GLenum l_Result = glewInit();
if (l_Result != GLEW_OK)
{
LOG_INFO("glewInit() error.");
exit(EXIT_FAILURE);
}
#ifdef _DEBUG
// Debug callback initialization
// Must be done *after* glew initialization.
glDebugMessageCallback(myCallback, NULL);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_MARKER, 0,
GL_DEBUG_SEVERITY_NOTIFICATION, -1, "Start debugging");
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
#endif
#ifdef USE_ANTTWEAKBAR
LOG_INFO("Using AntTweakbar.");
TwInit(useOpenGLCoreContext ? TW_OPENGL_CORE : TW_OPENGL, NULL);
InitializeBar();
#endif
LOG_INFO("Calling initGL...");
g_app.initGL();
LOG_INFO("Calling initVR...");
g_app.initVR();
LOG_INFO("initVR complete.");
SetVsync(1); // default to vsync on
StartShaderLoad();
while (!glfwWindowShouldClose(l_Window))
{
const bool tapped = g_app.CheckForTapOnHmd();
if (tapped && (g_receivedFirstTap == false))
{
g_app.RecenterPose();
g_receivedFirstTap = true;
}
glfwPollEvents();
joystick();
timestep();
g_fps.OnFrame();
if (g_dynamicallyScaleFBO)
{
DynamicallyScaleFBO();
}
#ifdef USE_ANTTWEAKBAR
TwRefreshBar(g_pTweakbar);
TwRefreshBar(g_pShaderTweakbar);
#endif
displayToHMD();
#ifndef _LINUX
// Indicate FPS in window title
// This is absolute death for performance in Ubuntu Linux 12.04
{
std::ostringstream oss;
oss << windowTitle
<< " "
<< static_cast<int>(g_fps.GetFPS())
<< " fps";
glfwSetWindowTitle(l_Window, oss.str().c_str());
if (g_AuxWindow != NULL)
glfwSetWindowTitle(g_AuxWindow, oss.str().c_str());
}
#endif
const float dumpInterval = 1.f;
if (g_logDumpTimer.seconds() > dumpInterval)
{
LOG_INFO("Frame rate: %d fps", static_cast<int>(g_fps.GetFPS()));
g_logDumpTimer.reset();
}
// Optionally display to auxiliary mono view
if (g_AuxWindow != NULL)
{
glfwMakeContextCurrent(g_AuxWindow);
glClearColor(0.f, 0.f, 0.f, 0.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
///@note VAOs *cannot* be shared between contexts.
///@note GLFW windows are inextricably tied to their own unique context.
/// For these two reasons, calling draw a third time for the auxiliary window
/// is not possible. Furthermore, it is not strictly desirable for the extra
/// rendering cost.
/// Instead, we share the render target texture from the stereo render and present
/// just the left eye to the aux window.
if (g_drawToAuxWindow)
{
presentSharedFboTexture();
}
#ifdef USE_ANTTWEAKBAR
TwDraw(); ///@todo Should this go first? Will it write to a depth buffer?
#endif
glfwSwapBuffers(g_AuxWindow);
if (glfwWindowShouldClose(g_AuxWindow))
{
destroyAuxiliaryWindow(g_AuxWindow);
}
// Set context to Rift window when done
glfwMakeContextCurrent(l_Window);
}
}
g_app.exitVR();
glfwDestroyWindow(l_Window);
glfwTerminate();
exit(EXIT_SUCCESS);
}
int main(int argc, char** argv)
{
#if defined(_WIN32)
LOG_INFO("Windows build.");
#elif defined(_LINUX)
LOG_INFO("Linux build.");
#elif defined(_MACOS)
LOG_INFO("MacOS build.");
#endif
bool useOpenGLCoreContext = false;
#ifdef USE_CORE_CONTEXT
useOpenGLCoreContext = true;
#endif
g_renderMode.outputType = RenderingMode::OVR_SDK;
LOG_INFO("Using GLFW3 backend.");
LOG_INFO("Compiled against GLFW %i.%i.%i",
GLFW_VERSION_MAJOR,
GLFW_VERSION_MINOR,
GLFW_VERSION_REVISION);
int major, minor, revision;
glfwGetVersion(&major, &minor, &revision);
LOG_INFO("Running against GLFW %i.%i.%i", major, minor, revision);
LOG_INFO("glfwGetVersionString: %s", glfwGetVersionString());
// Command line options
for (int i=0; i<argc; ++i)
{
const std::string a = argv[i];
LOG_INFO("argv[%d]: %s", i, a.c_str());
if (!a.compare("-sdk"))
{
g_renderMode.outputType = RenderingMode::OVR_SDK;
}
else if (!a.compare("-client"))
{
g_renderMode.outputType = RenderingMode::OVR_Client;
}
else if (!a.compare("-core"))
{
useOpenGLCoreContext = true;
}
else if (!a.compare("-compat"))
{
useOpenGLCoreContext = false;
}
}
#ifdef USE_OCULUSSDK
g_app.initHMD();
#else
g_renderMode.outputType = RenderingMode::Mono_Buffered;
#endif
GLFWwindow* l_Window = NULL;
glfwSetErrorCallback(ErrorCallback);
if (!glfwInit())
{
exit(EXIT_FAILURE);
}
// Log system monitor information
const GLFWmonitor* pPrimary = glfwGetPrimaryMonitor();
int monitorCount = 0;
GLFWmonitor** ppMonitors = glfwGetMonitors(&monitorCount);
for (int i=0; i<monitorCount; ++i)
{
GLFWmonitor* pCur = ppMonitors[i];
const GLFWvidmode* mode = glfwGetVideoMode(pCur);
if (mode != NULL)
{
(void)pPrimary;
LOG_INFO("Monitor #%d: %dx%d @ %dHz %s",
i,
mode->width,
mode->height,
mode->refreshRate,
pCur==pPrimary ? "Primary":"");
}
}
bool swapBackBufferDims = false;
// Context setup - before window creation
glfwWindowHint(GLFW_DEPTH_BITS, 16);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, useOpenGLCoreContext ? GLFW_OPENGL_CORE_PROFILE : GLFW_OPENGL_COMPAT_PROFILE);
//glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#ifdef _DEBUG
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
#endif
#if defined(USE_OSVR)
std::string windowTitle = "";
windowTitle = PROJECT_NAME "-GLFW-Osvr";
if (g_app.UsingDebugHmd())
{
const hmdRes sz = { 800, 600 };
// Create a normal, decorated application window
LOG_INFO("Using Debug HMD mode.");
windowTitle = PROJECT_NAME "-GLFW-DebugHMD";
g_renderMode.outputType = RenderingMode::Mono_Buffered;
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), NULL, NULL);
}
else
{
const hmdRes sz = {
g_app.getHmdResolution().h,
g_app.getHmdResolution().w
};
const winPos pos = g_app.getHmdWindowPos();
g_renderMode.outputType = RenderingMode::SideBySide_Undistorted;
LOG_INFO("Using Extended desktop mode.");
windowTitle = PROJECT_NAME "-GLFW-Extended";
LOG_INFO("Creating GLFW_DECORATED window %dx%d@%d,%d", sz.w, sz.h, pos.x, pos.y);
glfwWindowHint(GLFW_DECORATED, 0);
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), NULL, NULL);
glfwWindowHint(GLFW_DECORATED, 1);
glfwSetInputMode(l_Window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetWindowPos(l_Window, pos.x, pos.y);
}
#elif defined(OVRSDK06)
std::string windowTitle = "";
LOG_INFO("Using SDK 0.6.0.0's direct mode.");
windowTitle = PROJECT_NAME "-GLFW-06-Direct";
GLFWmonitor* monitor = glfwGetPrimaryMonitor();
const GLFWvidmode* mode = glfwGetVideoMode(monitor);
ovrSizei sz;
ovrVector2i pos;
sz.w = mode->width/2;
sz.h = mode->height/2;
pos.x = 100;
pos.y = 100;
// Create just a regular window for presenting OVR SDK 0.6's mirror texture
///@todo Is it any faster with no mirror at all?
LOG_INFO("Creating window %dx%d@%d,%d", sz.w, sz.h, pos.x, pos.y);
l_Window = glfwCreateWindow(sz.w, sz.h, windowTitle.c_str(), NULL, NULL);
g_app.SetAppWindowSize(sz);
#else
l_Window = glfwCreateWindow(800, 600, "GLFW Oculus Rift Test", NULL, NULL);
std::string windowTitle = PROJECT_NAME;
#endif //USE_OSVR|OVRSDK06
if (!l_Window)
{
LOG_INFO("Glfw failed to create a window. Exiting.");
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(l_Window);
glfwSetWindowSizeCallback(l_Window, resize_Aux);
glfwSetMouseButtonCallback(l_Window, mouseDown_Aux);
glfwSetCursorPosCallback(l_Window, mouseMove_Aux);
glfwSetScrollCallback(l_Window, mouseWheel_Aux);
glfwSetKeyCallback(l_Window, keyboard_Aux);
memset(m_keyStates, 0, GLFW_KEY_LAST*sizeof(int));
// joysticks
for (int i = GLFW_JOYSTICK_1; i <= GLFW_JOYSTICK_LAST; ++i)
{
if (GL_FALSE == glfwJoystickPresent(i))
continue;
const char* pJoyName = glfwGetJoystickName(i);
if (pJoyName == NULL)
continue;
int numAxes = 0;
int numButtons = 0;
glfwGetJoystickAxes(i, &numAxes);
glfwGetJoystickButtons(i, &numButtons);
LOG_INFO("Glfw opened Joystick #%d: %s w/ %d axes, %d buttons", i, pJoyName, numAxes, numButtons);
if (g_joystickIdx == -1)
g_joystickIdx = i;
}
printGLContextInfo(l_Window);
glfwMakeContextCurrent(l_Window);
g_pHMDWindow = l_Window;
// Don't forget to initialize Glew, turn glewExperimental on to
// avoid problems fetching function pointers...
glewExperimental = GL_TRUE;
const GLenum l_Result = glewInit();
if (l_Result != GLEW_OK)
{
LOG_INFO("glewInit() error.");
exit(EXIT_FAILURE);
}
#ifdef _DEBUG
// Debug callback initialization
// Must be done *after* glew initialization.
glDebugMessageCallback(myCallback, NULL);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);
glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_MARKER, 0,
GL_DEBUG_SEVERITY_NOTIFICATION, -1 , "Start debugging");
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
#endif
#ifdef USE_ANTTWEAKBAR
LOG_INFO("Using AntTweakbar.");
TwInit(useOpenGLCoreContext ? TW_OPENGL_CORE : TW_OPENGL, NULL);
InitializeBar();
#endif
LOG_INFO("Calling initGL...");
g_app.initGL();
LOG_INFO("Calling initVR...");
g_app.initVR(swapBackBufferDims);
LOG_INFO("initVR(%d) complete.", swapBackBufferDims);
SetVsync(0); // SDK 0.6 requires vsync OFF
while (!glfwWindowShouldClose(l_Window))
{
g_app.CheckForTapToDismissHealthAndSafetyWarning();
glfwPollEvents();
joystick();
timestep();
g_fps.OnFrame();
if (g_dynamicallyScaleFBO)
{
DynamicallyScaleFBO();
}
#ifdef USE_ANTTWEAKBAR
TwRefreshBar(g_pTweakbar);
#endif
g_app.pre_render_pass();
displayToHMD();
#ifndef _LINUX
// Indicate FPS in window title
// This is absolute death for performance in Ubuntu Linux 12.04
{
std::ostringstream oss;
oss << windowTitle
<< " "
<< static_cast<int>(g_fps.GetFPS())
<< " fps";
glfwSetWindowTitle(l_Window, oss.str().c_str());
}
#endif
const float dumpInterval = 1.f;
if (g_logDumpTimer.seconds() > dumpInterval)
{
LOG_INFO("Frame rate: %d fps", static_cast<int>(g_fps.GetFPS()));
g_logDumpTimer.reset();
}
}
g_app.exitVR();
glfwDestroyWindow(l_Window);
glfwTerminate();
exit(EXIT_SUCCESS);
}
void keyboard(GLFWwindow* pWindow, int key, int codes, int action, int mods)
{
(void)pWindow;
(void)codes;
if ((key > -1) && (key <= GLFW_KEY_LAST))
{
m_keyStates[key] = action;
//printf("key ac %d %d\n", key, action);
}
const float f = 0.9f;
const float ff = 0.99f;
if (action == GLFW_PRESS)
{
switch (key)
{
default:
g_app.DismissHealthAndSafetyWarning();
break;
case GLFW_KEY_F1:
if (mods & GLFW_MOD_CONTROL)
{
g_renderMode.toggleRenderingTypeReverse();
}
else
{
g_renderMode.toggleRenderingType();
}
LOG_INFO("Render Type: %d", g_renderMode.outputType);
break;
case GLFW_KEY_F2:
g_renderMode.toggleRenderingTypeMono();
LOG_INFO("Render Type: %d", g_renderMode.outputType);
break;
case GLFW_KEY_F3:
g_renderMode.toggleRenderingTypeHMD();
LOG_INFO("Render Type: %d", g_renderMode.outputType);
break;
case GLFW_KEY_F4:
g_renderMode.toggleRenderingTypeDistortion();
LOG_INFO("Render Type: %d", g_renderMode.outputType);
break;
case GLFW_KEY_F5: g_dynamicallyScaleFBO = false; g_app.SetFBOScale(f * g_app.GetFBOScale()); break;
case GLFW_KEY_F6: g_dynamicallyScaleFBO = false; g_app.SetFBOScale(ff * g_app.GetFBOScale()); break;
case GLFW_KEY_F7: g_dynamicallyScaleFBO = false; g_app.SetFBOScale((1.f/ff) * g_app.GetFBOScale()); break;
case GLFW_KEY_F8: g_dynamicallyScaleFBO = false; g_app.SetFBOScale((1.f/f) * g_app.GetFBOScale()); break;
case GLFW_KEY_F9: SetVsync(0); break;
case GLFW_KEY_F10: SetVsync(1); break;
case GLFW_KEY_F11: SetVsync(-1); break;
case GLFW_KEY_DELETE: g_dynamicallyScaleFBO = !g_dynamicallyScaleFBO; break;
case '`':
#if defined(OVRSDK05)
///@todo Is there a way to create an auxiliary window in Direct to rift mode?
/// The call to glfwCreateWindow crashes the app in Win7.
if (
(g_app.UsingDirectMode() == false) ||
(g_app.UsingDebugHmd() == true))
{
if (g_AuxWindow == NULL)
{
LOG_INFO("Creating auxiliary window.");
g_AuxWindow = initializeAuxiliaryWindow(g_pHMDWindow);
}
else
{
LOG_INFO("Destroying auxiliary window.");
destroyAuxiliaryWindow(g_AuxWindow);
glfwMakeContextCurrent(g_pHMDWindow);
}
}
#endif
break;
case GLFW_KEY_SPACE:
g_app.RecenterPose();
break;
case 'R':
g_app.ResetChassisTransformations();
break;
#ifdef USE_OCULUSSDK
case 'V': g_app.ToggleVignette(); break;
case 'T': g_app.ToggleTimeWarp(); break;
case 'O': g_app.ToggleOverdrive(); break;
case 'L': g_app.ToggleLowPersistence(); break;
case 'M': g_app.ToggleMirrorToWindow(); break;
case 'P': g_app.ToggleDynamicPrediction(); break;
#endif
case GLFW_KEY_ESCAPE:
{
// Clear the frame before calling all the destructors - even a few
// frames worth of frozen video is enough to cause discomfort!
///@note This does not seem to work in Direct mode.
glClearColor(58.f/255.f, 110.f/255.f, 165.f/255.f, 1.f); // Win7 default desktop color
glClear(GL_COLOR_BUFFER_BIT);
glfwSwapBuffers(g_pHMDWindow);
glClear(GL_COLOR_BUFFER_BIT);
glfwSwapBuffers(g_pHMDWindow);
g_app.exitVR();
glfwDestroyWindow(g_pHMDWindow);
glfwTerminate();
exit(0);
}
break;
}
}
//g_app.keyboard(key, action, 0,0);
const glm::vec3 forward(0.f, 0.f, -1.f);
const glm::vec3 up(0.f, 1.f, 0.f);
const glm::vec3 right(1.f, 0.f, 0.f);
// Handle keyboard movement(WASD keys)
glm::vec3 keyboardMove(0.0f, 0.0f, 0.0f);
if (m_keyStates['W'] != GLFW_RELEASE) { keyboardMove += forward; }
if (m_keyStates['S'] != GLFW_RELEASE) { keyboardMove -= forward; }
if (m_keyStates['A'] != GLFW_RELEASE) { keyboardMove -= right; }
if (m_keyStates['D'] != GLFW_RELEASE) { keyboardMove += right; }
if (m_keyStates['Q'] != GLFW_RELEASE) { keyboardMove -= up; }
if (m_keyStates['E'] != GLFW_RELEASE) { keyboardMove += up; }
if (m_keyStates[GLFW_KEY_UP] != GLFW_RELEASE) { keyboardMove += forward; }
if (m_keyStates[GLFW_KEY_DOWN] != GLFW_RELEASE) { keyboardMove -= forward; }
if (m_keyStates[GLFW_KEY_LEFT] != GLFW_RELEASE) { keyboardMove -= right; }
if (m_keyStates[GLFW_KEY_RIGHT] != GLFW_RELEASE) { keyboardMove += right; }
float mag = 1.0f;
if (m_keyStates[GLFW_KEY_LEFT_SHIFT] != GLFW_RELEASE)
mag *= 0.1f;
if (m_keyStates[GLFW_KEY_LEFT_CONTROL] != GLFW_RELEASE)
mag *= 10.0f;
// Yaw keys
g_app.m_keyboardYaw = 0.0f;
const float dyaw = 0.5f * mag; // radians at 60Hz timestep
if (m_keyStates['1'] != GLFW_RELEASE) { g_app.m_keyboardYaw = -dyaw; }
if (m_keyStates['3'] != GLFW_RELEASE) { g_app.m_keyboardYaw = dyaw; }
// Pitch and roll controls - if yaw is VR poison, this is torture and death!
g_app.m_keyboardDeltaPitch = 0.0f;
g_app.m_keyboardDeltaRoll = 0.0f;
if (g_allowPitch)
{
if (m_keyStates['2'] != GLFW_RELEASE) { g_app.m_keyboardDeltaPitch = -dyaw; }
if (m_keyStates['X'] != GLFW_RELEASE) { g_app.m_keyboardDeltaPitch = dyaw; }
}
if (g_allowRoll)
{
if (m_keyStates['Z'] != GLFW_RELEASE) { g_app.m_keyboardDeltaRoll = -dyaw; }
if (m_keyStates['C'] != GLFW_RELEASE) { g_app.m_keyboardDeltaRoll = dyaw; }
}
g_app.m_keyboardMove = mag * keyboardMove;
}