summaryrefslogtreecommitdiffstats
path: root/Samples/CommonSrc/Platform
diff options
context:
space:
mode:
Diffstat (limited to 'Samples/CommonSrc/Platform')
-rw-r--r--Samples/CommonSrc/Platform/Gamepad.h204
-rw-r--r--Samples/CommonSrc/Platform/Linux_Gamepad.cpp48
-rw-r--r--Samples/CommonSrc/Platform/Linux_Gamepad.h51
-rw-r--r--Samples/CommonSrc/Platform/Linux_Platform.cpp563
-rw-r--r--Samples/CommonSrc/Platform/Linux_Platform.h120
-rw-r--r--Samples/CommonSrc/Platform/OSX_Gamepad.cpp848
-rw-r--r--Samples/CommonSrc/Platform/OSX_Gamepad.h133
-rw-r--r--Samples/CommonSrc/Platform/OSX_Platform.h160
-rw-r--r--Samples/CommonSrc/Platform/OSX_PlatformObjc.h62
-rw-r--r--Samples/CommonSrc/Platform/OSX_WavPlayer.cpp484
-rw-r--r--Samples/CommonSrc/Platform/OSX_WavPlayer.h128
-rw-r--r--Samples/CommonSrc/Platform/Platform.cpp150
-rw-r--r--Samples/CommonSrc/Platform/Platform.h380
-rw-r--r--Samples/CommonSrc/Platform/Platform_Default.h118
-rw-r--r--Samples/CommonSrc/Platform/Win32_Gamepad.cpp202
-rw-r--r--Samples/CommonSrc/Platform/Win32_Gamepad.h108
-rw-r--r--Samples/CommonSrc/Platform/Win32_Platform.cpp1200
-rw-r--r--Samples/CommonSrc/Platform/Win32_Platform.h202
18 files changed, 2971 insertions, 2190 deletions
diff --git a/Samples/CommonSrc/Platform/Gamepad.h b/Samples/CommonSrc/Platform/Gamepad.h
index 01eaab4..f32effc 100644
--- a/Samples/CommonSrc/Platform/Gamepad.h
+++ b/Samples/CommonSrc/Platform/Gamepad.h
@@ -1,102 +1,102 @@
-/************************************************************************************
-
-Filename : Gamepad.h
-Content : Cross platform Gamepad interface.
-Created : May 6, 2013
-Authors : Lee Cooper
-
-Copyright : Copyright 2013 Oculus VR, Inc. All Rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-************************************************************************************/
-
-#ifndef OVR_Gamepad_h
-#define OVR_Gamepad_h
-
-#include "OVR.h"
-
-namespace OVR { namespace Platform {
-
-// Buttons on a typical gamepad controller.
-enum GamepadButtons
-{
- Gamepad_A = 0x1000,
- Gamepad_CROSS = 0x1000,
- Gamepad_B = 0x2000,
- Gamepad_CIRCLE = 0x2000,
- Gamepad_X = 0x4000,
- Gamepad_SQUARE = 0x4000,
- Gamepad_Y = 0x8000,
- Gamepad_TRIANGLE = 0x8000,
- Gamepad_Up = 0x0001,
- Gamepad_Down = 0x0002,
- Gamepad_Left = 0x0004,
- Gamepad_Right = 0x0008,
- Gamepad_Start = 0x0010,
- Gamepad_Back = 0x0020,
- Gamepad_LStick = 0x0040,
- Gamepad_RStick = 0x0080,
- Gamepad_L1 = 0x0100,
- Gamepad_R1 = 0x0200,
-};
-
-//-------------------------------------------------------------------------------------
-// ***** GamepadState
-
-// Describes the state of the controller buttons and analog inputs.
-struct GamepadState
-{
- UInt32 Buttons; // Bitfield representing button state.
- float LX; // Left stick X axis [-1,1]
- float LY; // Left stick Y axis [-1,1]
- float RX; // Right stick X axis [-1,1]
- float RY; // Right stick Y axis [-1,1]
- float LT; // Left trigger [0,1]
- float RT; // Right trigger [0,1]
-
- GamepadState() : Buttons(0), LX(0), LY(0), RX(0), RY(0), LT(0), RT(0) {}
-
- bool operator==(const GamepadState& b) const
- {
- return Buttons == b.Buttons && LX == b.LX && LY == b.LY && RX == b.RX && RY == b.RY && LT == b.LT && RT == b.RT;
- }
- bool operator!=(const GamepadState& b) const
- {
- return !(*this == b);
- }
- void Debug()
- {
- OVR_DEBUG_LOG(("Buttons:0x%4x LX:%.2f LY:%.2f RX:%.2f RY:%.2f LT:%.2f RT:%.2f", Buttons, LX, LY, RX, RY, LT, RT));
- }
-};
-
-//-------------------------------------------------------------------------------------
-// ***** GamepadManager
-
-// GamepadManager provides a cross platform interface for accessing gamepad controller
-// state.
-class GamepadManager : public RefCountBase<GamepadManager>
-{
-public:
-
- // Get the number of connected gamepads.
- virtual UInt32 GetGamepadCount() = 0;
-
- // Get the state of the gamepad with a given index.
- virtual bool GetGamepadState(UInt32 index, GamepadState* pState) = 0;
-};
-
-}} // OVR::Platform
-
-#endif // OVR_Gamepad_h
+/************************************************************************************
+
+Filename : Gamepad.h
+Content : Cross platform Gamepad interface.
+Created : May 6, 2013
+Authors : Lee Cooper
+
+Copyright : Copyright 2013 Oculus VR, Inc. All Rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************************/
+
+#ifndef OVR_Gamepad_h
+#define OVR_Gamepad_h
+
+#include <OVR.h>
+
+namespace OVR { namespace Platform {
+
+// Buttons on a typical gamepad controller.
+enum GamepadButtons
+{
+ Gamepad_A = 0x1000,
+ Gamepad_CROSS = 0x1000,
+ Gamepad_B = 0x2000,
+ Gamepad_CIRCLE = 0x2000,
+ Gamepad_X = 0x4000,
+ Gamepad_SQUARE = 0x4000,
+ Gamepad_Y = 0x8000,
+ Gamepad_TRIANGLE = 0x8000,
+ Gamepad_Up = 0x0001,
+ Gamepad_Down = 0x0002,
+ Gamepad_Left = 0x0004,
+ Gamepad_Right = 0x0008,
+ Gamepad_Start = 0x0010,
+ Gamepad_Back = 0x0020,
+ Gamepad_LStick = 0x0040,
+ Gamepad_RStick = 0x0080,
+ Gamepad_L1 = 0x0100,
+ Gamepad_R1 = 0x0200,
+};
+
+//-------------------------------------------------------------------------------------
+// ***** GamepadState
+
+// Describes the state of the controller buttons and analog inputs.
+struct GamepadState
+{
+ UInt32 Buttons; // Bitfield representing button state.
+ float LX; // Left stick X axis [-1,1]
+ float LY; // Left stick Y axis [-1,1]
+ float RX; // Right stick X axis [-1,1]
+ float RY; // Right stick Y axis [-1,1]
+ float LT; // Left trigger [0,1]
+ float RT; // Right trigger [0,1]
+
+ GamepadState() : Buttons(0), LX(0), LY(0), RX(0), RY(0), LT(0), RT(0) {}
+
+ bool operator==(const GamepadState& b) const
+ {
+ return Buttons == b.Buttons && LX == b.LX && LY == b.LY && RX == b.RX && RY == b.RY && LT == b.LT && RT == b.RT;
+ }
+ bool operator!=(const GamepadState& b) const
+ {
+ return !(*this == b);
+ }
+ void Debug()
+ {
+ OVR_DEBUG_LOG(("Buttons:0x%4x LX:%.2f LY:%.2f RX:%.2f RY:%.2f LT:%.2f RT:%.2f", Buttons, LX, LY, RX, RY, LT, RT));
+ }
+};
+
+//-------------------------------------------------------------------------------------
+// ***** GamepadManager
+
+// GamepadManager provides a cross platform interface for accessing gamepad controller
+// state.
+class GamepadManager : public RefCountBase<GamepadManager>
+{
+public:
+
+ // Get the number of connected gamepads.
+ virtual UInt32 GetGamepadCount() = 0;
+
+ // Get the state of the gamepad with a given index.
+ virtual bool GetGamepadState(UInt32 index, GamepadState* pState) = 0;
+};
+
+}} // OVR::Platform
+
+#endif // OVR_Gamepad_h
diff --git a/Samples/CommonSrc/Platform/Linux_Gamepad.cpp b/Samples/CommonSrc/Platform/Linux_Gamepad.cpp
new file mode 100644
index 0000000..9370120
--- /dev/null
+++ b/Samples/CommonSrc/Platform/Linux_Gamepad.cpp
@@ -0,0 +1,48 @@
+/************************************************************************************
+
+Filename : Linux_Gamepad.cpp
+Content : Linux implementation of Platform app infrastructure
+Created : May 6, 2013
+Authors : Lee Cooper
+
+Copyright : Copyright 2013 Oculus VR, Inc. All Rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************************/
+
+#include "Linux_Gamepad.h"
+
+namespace OVR { namespace Platform { namespace Linux {
+
+GamepadManager::GamepadManager()
+{
+
+}
+
+GamepadManager::~GamepadManager()
+{
+
+}
+
+UInt32 GamepadManager::GetGamepadCount()
+{
+ return 1;
+}
+
+bool GamepadManager::GetGamepadState(UInt32 index, GamepadState* pState)
+{
+ return false;
+}
+
+}}} // OVR::Platform::Linux
diff --git a/Samples/CommonSrc/Platform/Linux_Gamepad.h b/Samples/CommonSrc/Platform/Linux_Gamepad.h
new file mode 100644
index 0000000..9e6413d
--- /dev/null
+++ b/Samples/CommonSrc/Platform/Linux_Gamepad.h
@@ -0,0 +1,51 @@
+/************************************************************************************
+
+Filename : Linux_Gamepad.h
+Content : Linux implementation of Gamepad functionality.
+Created : May 6, 2013
+Authors : Lee Cooper
+
+Copyright : Copyright 2013 Oculus VR, Inc. All Rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************************/
+
+#ifndef OVR_Linux_Gamepad_h
+#define OVR_Linux_Gamepad_h
+
+#include "Gamepad.h"
+
+namespace OVR { namespace Platform { namespace Linux {
+
+class GamepadManager : public Platform::GamepadManager
+{
+public:
+ GamepadManager();
+ ~GamepadManager();
+
+ virtual UInt32 GetGamepadCount();
+ virtual bool GetGamepadState(UInt32 index, GamepadState* pState);
+
+private:
+ // Dynamically ink to XInput to simplify projects.
+ //HMODULE hXInputModule;
+ //typedef DWORD (WINAPI *PFn_XInputGetState)(DWORD dwUserIndex, XINPUT_STATE* pState);
+ //PFn_XInputGetState pXInputGetState;
+
+ //UInt32 LastPadPacketNo;
+};
+
+}}}
+
+#endif // OVR_Linux_Gamepad_h
diff --git a/Samples/CommonSrc/Platform/Linux_Platform.cpp b/Samples/CommonSrc/Platform/Linux_Platform.cpp
new file mode 100644
index 0000000..c9d3e40
--- /dev/null
+++ b/Samples/CommonSrc/Platform/Linux_Platform.cpp
@@ -0,0 +1,563 @@
+/************************************************************************************
+
+Filename : Platform_Linux.cpp
+Content : Linux (X11) implementation of Platform app infrastructure
+Created : September 6, 2012
+Authors : Andrew Reisse
+
+Copyright : Copyright 2012 Oculus VR, Inc. All Rights reserved.
+
+Use of this software is subject to the terms of the Oculus LLC license
+agreement provided at the time of installation or download, or which
+otherwise accompanies this software in either electronic or hard copy form.
+
+************************************************************************************/
+
+#include "Kernel/OVR_System.h"
+#include "Kernel/OVR_Array.h"
+#include "Kernel/OVR_String.h"
+#include "Kernel/OVR_Timer.h"
+
+#include "Linux_Platform.h"
+#include "Linux_Gamepad.h"
+
+// Renderers
+#include "../Render/Render_GL_Device.h"
+
+#include <X11/extensions/Xinerama.h>
+
+
+namespace OVR { namespace Platform { namespace Linux {
+
+static const char *AtomNames[] = {"WM_PROTOCOLS", "WM_DELETE_WINDOW"};
+
+PlatformCore::PlatformCore(Application* app)
+ : Platform::PlatformCore(app), Disp(NULL), Win(0), Vis(NULL), Quit(0), MMode(Mouse_Normal)
+{
+ pGamepadManager = *new Linux::GamepadManager();
+}
+PlatformCore::~PlatformCore()
+{
+ XFreeCursor(Disp, InvisibleCursor);
+
+ if (Disp)
+ XCloseDisplay(Disp);
+}
+
+// Setup an X11 window in windowed mode.
+bool PlatformCore::SetupWindow(int w, int h)
+{
+
+ if (!Disp)
+ {
+ XInitThreads();
+
+ Disp = XOpenDisplay(NULL);
+ if (!Disp)
+ {
+ OVR_DEBUG_LOG(("XOpenDisplay failed."));
+ return false;
+ }
+
+ XInternAtoms(Disp, const_cast<char**>(AtomNames), NumAtoms, false, Atoms);
+ }
+
+ XSetWindowAttributes winattr;
+ unsigned attrmask = CWEventMask | CWBorderPixel;
+
+ winattr.event_mask = ButtonPressMask|ButtonReleaseMask|KeyPressMask|KeyReleaseMask|ButtonMotionMask|PointerMotionMask|
+ /*PointerMotionHintMask|*/StructureNotifyMask;//|ExposureMask;
+ winattr.border_pixel = 0;
+
+ int screenNumber = DefaultScreen(Disp);
+
+ if (!Vis)
+ {
+ int attr[16];
+ int nattr = 2;
+
+ attr[0] = GLX_RGBA;
+ attr[1] = GLX_DOUBLEBUFFER;
+ attr[nattr++] = GLX_DEPTH_SIZE;
+ attr[nattr++] = 24;
+ attr[nattr] = 0;
+
+ Vis = glXChooseVisual(Disp, screenNumber, attr);
+
+ if (!Vis)
+ {
+ OVR_DEBUG_LOG(("glXChooseVisual failed."));
+ return false;
+ }
+ }
+
+ Window rootWindow = XRootWindow(Disp, Vis->screen);
+
+ winattr.colormap = XCreateColormap(Disp, rootWindow, Vis->visual, AllocNone);
+ attrmask |= CWColormap;
+
+
+ Win = XCreateWindow(Disp, rootWindow, 0, 0, w, h, 0, Vis->depth,
+ InputOutput, Vis->visual, attrmask, &winattr);
+
+ if (!Win)
+ {
+ OVR_DEBUG_LOG(("XCreateWindow failed."));
+ return false;
+ }
+
+
+ XStoreName(Disp, Win, "OVR App");
+ XSetWMProtocols(Disp, Win, &Atoms[WM_DELETE_WINDOW], 1);
+
+ // Intialize empty cursor for show/hide.
+ XColor black;
+ static char noData[] = { 0,0,0,0,0,0,0,0 };
+ black.red = black.green = black.blue = 0;
+
+ Pixmap bitmapNoData = XCreateBitmapFromData(Disp, Win, noData, 8, 8);
+ InvisibleCursor = XCreatePixmapCursor(Disp, bitmapNoData, bitmapNoData,
+ &black, &black, 0, 0);
+ XDefineCursor(Disp, Win, InvisibleCursor);
+
+ Width = w;
+ Height = h;
+
+ return true;
+}
+
+void PlatformCore::SetMouseMode(MouseMode mm)
+{
+ if (mm == MMode)
+ return;
+
+ if (Win)
+ {
+ if (mm == Mouse_Relative)
+ {
+ XWarpPointer(Disp, Win, Win, 0,0,Width,Height, Width/2, Height/2);
+ }
+ else
+ {
+ //if (MMode == Mouse_Relative)
+ // ShowCursor(TRUE);
+ }
+ }
+ MMode = mm;
+}
+
+void PlatformCore::GetWindowSize(int* w, int* h) const
+{
+ *w = Width;
+ *h = Height;
+}
+
+void PlatformCore::SetWindowTitle(const char* title)
+{
+ XStoreName(Disp, Win, title);
+}
+
+void PlatformCore::ShowWindow(bool show)
+{
+ if (show)
+ XRaiseWindow(Disp, Win);
+ else
+ XIconifyWindow(Disp, Win, 0);
+}
+
+void PlatformCore::DestroyWindow()
+{
+ if (Win)
+ XDestroyWindow(Disp, Win);
+ Win = 0;
+}
+
+
+static int KeyMap[][2] =
+{
+ { XK_BackSpace, Key_Backspace },
+ { XK_Tab, Key_Tab },
+ { XK_Clear, Key_Clear },
+ { XK_Return, Key_Return },
+ { XK_Shift_L, Key_Shift },
+ { XK_Control_L, Key_Control },
+ { XK_Alt_L, Key_Alt },
+ { XK_Shift_R, Key_Shift },
+ { XK_Control_R, Key_Control },
+ { XK_Alt_R, Key_Alt },
+ { XK_Pause, Key_Pause },
+ { XK_Caps_Lock, Key_CapsLock },
+ { XK_Escape, Key_Escape },
+ { XK_space, Key_Space },
+ { XK_Page_Up, Key_PageUp },
+ { XK_Page_Down, Key_PageDown },
+ { XK_Prior, Key_PageUp },
+ { XK_Next, Key_PageDown },
+ { XK_End, Key_End },
+ { XK_Home, Key_Home },
+ { XK_Left, Key_Left },
+ { XK_Up, Key_Up },
+ { XK_Right, Key_Right },
+ { XK_Down, Key_Down },
+ { XK_Insert, Key_Insert },
+ { XK_Delete, Key_Delete },
+ { XK_Help, Key_Help },
+ { XK_Num_Lock, Key_NumLock },
+ { XK_Scroll_Lock, Key_ScrollLock },
+};
+
+
+static KeyCode MapXKToKeyCode(unsigned vk)
+{
+ unsigned key = Key_None;
+
+ if ((vk >= 'a') && (vk <= 'z'))
+ {
+ key = vk - 'a' + Key_A;
+ }
+ else if ((vk >= ' ') && (vk <= '~'))
+ {
+ key = vk;
+ }
+ else if ((vk >= XK_KP_0) && (vk <= XK_KP_9))
+ {
+ key = vk - XK_KP_0 + Key_KP_0;
+ }
+ else if ((vk >= XK_F1) && (vk <= XK_F15))
+ {
+ key = vk - XK_F1 + Key_F1;
+ }
+ else
+ {
+ for (unsigned i = 0; i< (sizeof(KeyMap) / sizeof(KeyMap[1])); i++)
+ {
+ if (vk == KeyMap[i][0])
+ {
+ key = KeyMap[i][1];
+ break;
+ }
+ }
+ }
+
+ return (KeyCode)key;
+}
+
+static int MapModifiers(int xmod)
+{
+ int mod = 0;
+ if (xmod & ShiftMask)
+ mod |= Mod_Shift;
+ if (xmod & ControlMask)
+ mod |= Mod_Control;
+ if (xmod & Mod1Mask)
+ mod |= Mod_Alt;
+ if (xmod & Mod4Mask)
+ mod |= Mod_Meta;
+ return mod;
+}
+
+void PlatformCore::processEvent(XEvent& event)
+{
+ switch (event.xany.type)
+ {
+ case ConfigureNotify:
+ if (event.xconfigure.width != Width || event.xconfigure.height != Height)
+ {
+ Width = event.xconfigure.width;
+ Height = event.xconfigure.height;
+ pApp->OnResize(Width, Height);
+
+ if (pRender)
+ pRender->SetWindowSize(Width, Height);
+ }
+ break;
+
+ case KeyPress:
+ case KeyRelease:
+ {
+ char chars[8] = {0};
+ KeySym xk;
+ XComposeStatus comp;
+ XLookupString(&event.xkey, chars, sizeof(chars), &xk, &comp);
+ if (xk != XK_VoidSymbol)
+ pApp->OnKey(MapXKToKeyCode((unsigned)xk), chars[0], event.xany.type == KeyPress, MapModifiers(event.xkey.state));
+ if (xk == XK_Escape && MMode == Mouse_Relative)
+ {
+ //ungrab
+ MMode = Mouse_RelativeEscaped;
+ showCursor(true);
+ }
+ }
+ break;
+
+ case MotionNotify:
+ if (MMode == Mouse_Relative)
+ {
+ int dx = event.xmotion.x - Width/2;
+ int dy = event.xmotion.y - Height/2;
+
+ // do not remove this check, WarpPointer generates events too.
+ if (dx == 0 && dy == 0)
+ break;
+
+ XWarpPointer(Disp, Win, Win, 0,0,Width,Height, Width/2, Height/2);
+ pApp->OnMouseMove(dx, dy, Mod_MouseRelative|MapModifiers(event.xmotion.state));
+ }
+ else
+ {
+ pApp->OnMouseMove(event.xmotion.x, event.xmotion.y, MapModifiers(event.xmotion.state));
+ }
+ break;
+
+ case MapNotify:
+ if (MMode == Mouse_Relative)
+ {
+ XWarpPointer(Disp, Win, Win, 0,0,Width,Height, Width/2, Height/2);
+ showCursor(false);
+ }
+ break;
+
+ case ButtonPress:
+ if (event.xbutton.button == 1)
+ {
+ //grab
+
+ if (MMode == Mouse_RelativeEscaped)
+ {
+ XWarpPointer(Disp, Win, Win, 0,0,Width,Height, Width/2, Height/2);
+ showCursor(false);
+ MMode = Mouse_Relative;
+ }
+ }
+ break;
+
+ case FocusOut:
+ if (MMode == Mouse_Relative)
+ {
+ MMode = Mouse_RelativeEscaped;
+ showCursor(true);
+ }
+ break;
+
+ case ClientMessage:
+ if (event.xclient.message_type == Atoms[WM_PROTOCOLS] &&
+ Atom(event.xclient.data.l[0]) == Atoms[WM_DELETE_WINDOW])
+ pApp->OnQuitRequest();
+ break;
+ }
+}
+
+int PlatformCore::Run()
+{
+ while (!Quit)
+ {
+ if (XPending(Disp))
+ {
+ XEvent event;
+ XNextEvent(Disp, &event);
+
+ if (pApp && event.xany.window == Win)
+ processEvent(event);
+ }
+ else
+ {
+ pApp->OnIdle();
+ }
+ }
+
+ return ExitCode;
+}
+
+bool PlatformCore::determineScreenOffset(int screenId, int* screenOffsetX, int* screenOffsetY)
+{
+ Display* display = XOpenDisplay(NULL);
+
+ bool foundScreen = false;
+
+ if (display)
+ {
+ int numberOfScreens;
+ XineramaScreenInfo* screens = XineramaQueryScreens(display, &numberOfScreens);
+
+ if (screenId < numberOfScreens)
+ {
+ XineramaScreenInfo screenInfo = screens[screenId];
+ *screenOffsetX = screenInfo.x_org;
+ *screenOffsetY = screenInfo.y_org;
+
+ foundScreen = true;
+ }
+
+ XFree(screens);
+ }
+
+ return foundScreen;
+}
+
+void PlatformCore::showWindowDecorations(bool show)
+{
+ // Declaration of 'MOTIF_WM_HINTS' struct and flags can be found at:
+ // https://people.gnome.org/~tthurman/docs/metacity/xprops_8h-source.html
+ typedef struct WMHints
+ {
+ unsigned long flags;
+ unsigned long functions;
+ unsigned long decorations;
+ long inputMode;
+ unsigned long status;
+ } Hints;
+
+ #define MWM_DECOR_ALL (1L << 0)
+ #define MWM_DECOR_BORDER (1L << 1)
+ #define MWM_DECOR_RESIZEH (1L << 2)
+ #define MWM_DECOR_TITLE (1L << 3)
+ #define MWM_DECOR_MENU (1L << 4)
+ #define MWM_DECOR_MINIMIZE (1L << 5)
+ #define MWM_DECOR_MAXIMIZE (1L << 6)
+
+ Atom property = XInternAtom(Disp, "_MOTIF_WM_HINTS", true);
+
+ Hints hints;
+ hints.flags = 2; // We only want to specify decoration.
+
+ if (show)
+ {
+ hints.decorations = MWM_DECOR_BORDER | MWM_DECOR_TITLE | MWM_DECOR_MENU | MWM_DECOR_MINIMIZE | MWM_DECOR_MAXIMIZE;
+ }
+ else
+ {
+ // Remove all window border items.
+ hints.decorations = 0;
+ }
+
+ XChangeProperty(Disp,Win,property,property,32,PropModeReplace,(unsigned char *)&hints,5);
+}
+
+bool PlatformCore::SetFullscreen(const Render::RendererParams& rp, int fullscreen)
+{
+ if (rp.Fullscreen == Render::Display_Window && fullscreen == Render::Display_FakeFullscreen)
+ {
+ // Transitioning from windowed to fake fullscreen.
+ int xOffset;
+ int yOffset;
+
+ if (!determineScreenOffset(rp.Display.CgDisplayId, &xOffset, &yOffset))
+ {
+ return false;
+ }
+
+ showWindowDecorations(false);
+
+ XMoveWindow(Disp, Win, xOffset, yOffset);
+ XMapRaised(Disp, Win);
+
+ Platform::PlatformCore::SetFullscreen(rp, fullscreen);
+ return true;
+ }
+ else if (rp.Fullscreen == Render::Display_FakeFullscreen && fullscreen == Render::Display_Window)
+ {
+ // Transitioning from fake fullscreen to windowed.
+ showWindowDecorations(true);
+
+ XMoveWindow(Disp, Win, 0, 0);
+ XMapRaised(Disp, Win);
+
+ Platform::PlatformCore::SetFullscreen(rp, fullscreen);
+ return true;
+ }
+ else if (fullscreen == Render::Display_Fullscreen)
+ {
+ return false;
+ }
+}
+
+RenderDevice* PlatformCore::SetupGraphics(const SetupGraphicsDeviceSet& setupGraphicsDesc,
+ const char* type, const Render::RendererParams& rp)
+{
+ const SetupGraphicsDeviceSet* setupDesc = setupGraphicsDesc.PickSetupDevice(type);
+ OVR_ASSERT(setupDesc);
+
+ pRender = *setupDesc->pCreateDevice(rp, this);
+ if (pRender)
+ pRender->SetWindowSize(Width, Height);
+
+ return pRender.GetPtr();
+}
+
+void PlatformCore::showCursor(bool show)
+{
+ if (show)
+ {
+ XUndefineCursor(Disp, Win);
+ }
+ else
+ {
+ XDefineCursor(Disp, Win, InvisibleCursor);
+ }
+}
+
+}}
+
+// GL
+namespace Render { namespace GL { namespace Linux {
+
+Render::RenderDevice* RenderDevice::CreateDevice(const RendererParams& rp, void* oswnd)
+{
+ Platform::Linux::PlatformCore* PC = (Platform::Linux::PlatformCore*)oswnd;
+
+ GLXContext context = glXCreateContext(PC->Disp, PC->Vis, 0, GL_TRUE);
+
+ if (!context)
+ return NULL;
+
+ if (!glXMakeCurrent(PC->Disp, PC->Win, context))
+ {
+ glXDestroyContext(PC->Disp, context);
+ return NULL;
+ }
+
+ XMapRaised(PC->Disp, PC->Win);
+
+ return new Render::GL::Linux::RenderDevice(rp, PC->Disp, PC->Win, context);
+}
+
+void RenderDevice::Present()
+{
+ glXSwapBuffers(Disp, Win);
+}
+
+void RenderDevice::Shutdown()
+{
+ if (Context)
+ {
+ glXMakeCurrent(Disp, 0, NULL);
+ glXDestroyContext(Disp, Context);
+ Context = NULL;
+ Win = 0;
+ }
+}
+
+}}}}
+
+
+int main(int argc, const char* argv[])
+{
+ using namespace OVR;
+ using namespace OVR::Platform;
+
+ // CreateApplication must be the first call since it does OVR::System::Initialize.
+ Application* app = Application::CreateApplication();
+ Linux::PlatformCore* platform = new Linux::PlatformCore(app);
+ // The platform attached to an app will be deleted by DestroyApplication.
+ app->SetPlatformCore(platform);
+
+ int exitCode = app->OnStartup(argc, argv);
+ if (!exitCode)
+ exitCode = platform->Run();
+
+ // No OVR functions involving memory are allowed after this.
+ Application::DestroyApplication(app);
+ app = 0;
+
+ return exitCode;
+}
diff --git a/Samples/CommonSrc/Platform/Linux_Platform.h b/Samples/CommonSrc/Platform/Linux_Platform.h
new file mode 100644
index 0000000..7fbb220
--- /dev/null
+++ b/Samples/CommonSrc/Platform/Linux_Platform.h
@@ -0,0 +1,120 @@
+/************************************************************************************
+
+Filename : Platform_Linux.h
+Content : Linux (X11) implementation of Platform app infrastructure
+Created : September 6, 2012
+Authors : Andrew Reisse
+
+Copyright : Copyright 2012 Oculus VR, Inc. All Rights reserved.
+
+Use of this software is subject to the terms of the Oculus LLC license
+agreement provided at the time of installation or download, or which
+otherwise accompanies this software in either electronic or hard copy form.
+
+************************************************************************************/
+
+#ifndef OVR_Platform_Linux_h
+#define OVR_Platform_Linux_h
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <GL/glx.h>
+
+#include "Platform.h"
+#include "../Render/Render_GL_Device.h"
+
+namespace OVR { namespace Render {
+ class RenderDevice;
+}}
+
+namespace OVR { namespace Platform { namespace Linux {
+
+class PlatformCore : public Platform::PlatformCore
+{
+public:
+ Display* Disp;
+ XVisualInfo* Vis;
+ Window Win;
+
+ bool Quit;
+ int ExitCode;
+ int Width, Height;
+
+ MouseMode MMode;
+ Cursor InvisibleCursor;
+
+ enum
+ {
+ WM_PROTOCOLS,
+ WM_DELETE_WINDOW,
+ NumAtoms
+ };
+ Atom Atoms[NumAtoms];
+
+ void processEvent(XEvent& event);
+
+ Render::RenderDevice* SetupGraphics_GL(const Render::RendererParams& rp);
+
+ void showCursor(bool show);
+ bool determineScreenOffset(int screenId, int* screenOffsetX, int* screenOffsetY);
+ void showWindowDecorations(bool show);
+
+public:
+ PlatformCore(Application* app);
+ ~PlatformCore();
+
+ bool SetupWindow(int w, int h);
+ void Exit(int exitcode) { Quit = 1; ExitCode = exitcode; }
+
+ RenderDevice* SetupGraphics(const SetupGraphicsDeviceSet& setupGraphicsDesc,
+ const char* gtype, const Render::RendererParams& rp);
+
+ void SetMouseMode(MouseMode mm);
+ void GetWindowSize(int* w, int* h) const;
+
+ void SetWindowTitle(const char*title);
+
+ void ShowWindow(bool show);
+ void DestroyWindow();
+ bool SetFullscreen(const Render::RendererParams& rp, int fullscreen);
+ int Run();
+};
+
+}}
+namespace Render { namespace GL { namespace Linux {
+
+class RenderDevice : public Render::GL::RenderDevice
+{
+ Display* Disp;
+ Window Win;
+ GLXContext Context;
+
+public:
+ RenderDevice(const Render::RendererParams& p, Display* disp, Window w, GLXContext gl)
+ : GL::RenderDevice(p), Disp(disp), Win(w), Context(gl) {}
+
+ virtual void Shutdown();
+ virtual void Present();
+
+ // oswnd = Linux::PlatformCore*
+ static Render::RenderDevice* CreateDevice(const RendererParams& rp, void* oswnd);
+};
+
+}}}}
+
+
+// OVR_PLATFORM_APP_ARGS specifies the Application class to use for startup,
+// providing it with startup arguments.
+#define OVR_PLATFORM_APP_ARGS(AppClass, args) \
+ OVR::Platform::Application* OVR::Platform::Application::CreateApplication() \
+ { OVR::System::Init(OVR::Log::ConfigureDefaultLog(OVR::LogMask_All)); \
+ return new AppClass args; } \
+ void OVR::Platform::Application::DestroyApplication(OVR::Platform::Application* app) \
+ { OVR::Platform::PlatformCore* platform = app->pPlatform; \
+ delete app; delete platform; OVR::System::Destroy(); };
+
+// OVR_PLATFORM_APP_ARGS specifies the Application startup class with no args.
+#define OVR_PLATFORM_APP(AppClass) OVR_PLATFORM_APP_ARGS(AppClass, ())
+
+
+#endif
diff --git a/Samples/CommonSrc/Platform/OSX_Gamepad.cpp b/Samples/CommonSrc/Platform/OSX_Gamepad.cpp
index 3ac53ab..934319b 100644
--- a/Samples/CommonSrc/Platform/OSX_Gamepad.cpp
+++ b/Samples/CommonSrc/Platform/OSX_Gamepad.cpp
@@ -1,424 +1,424 @@
-/************************************************************************************
-
-Filename : OSX_Gamepad.cpp
-Content : OSX implementation of Gamepad functionality.
-Created : May 6, 2013
-Authors : Lee Cooper
-
-Copyright : Copyright 2013 Oculus VR, Inc. All Rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-************************************************************************************/
-
-#include "OSX_Gamepad.h"
-
-
-static const UInt32 Logitech_F710_VendorID = 0x046D;
-static const UInt32 Logitech_F710_ProductID = 0xC219;
-
-static const UInt32 Sony_DualShock3_VendorID = 0x054C;
-static const UInt32 Sony_DualShock3_ProductID = 0x0268;
-
-
-namespace OVR { namespace Platform { namespace OSX {
-
-
-GamepadManager::GamepadManager()
- : bStateChanged(false)
-{
-
- HidManager = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
- IOHIDManagerOpen(HidManager, kIOHIDOptionsTypeNone);
- IOHIDManagerScheduleWithRunLoop(HidManager,
- CFRunLoopGetCurrent(),
- kCFRunLoopDefaultMode);
-
-
- // Setup device matching.
- CFStringRef keys[] = { CFSTR(kIOHIDDeviceUsagePageKey),
- CFSTR(kIOHIDDeviceUsageKey)};
-
- int value;
- CFNumberRef values[2];
- CFDictionaryRef dictionaries[2];
-
- // Match joysticks.
- value = kHIDPage_GenericDesktop;
- values[0] = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &value);
-
- value = kHIDUsage_GD_Joystick;
- values[1] = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &value);
-
- dictionaries[0] = CFDictionaryCreate(kCFAllocatorDefault,
- (const void **) keys,
- (const void **) values,
- 2,
- &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
- CFRelease(values[0]);
- CFRelease(values[1]);
-
- // Match gamepads.
- value = kHIDPage_GenericDesktop;
- values[0] = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &value);
-
- value = kHIDUsage_GD_GamePad;
- values[1] = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &value);
-
- dictionaries[1] = CFDictionaryCreate(kCFAllocatorDefault,
- (const void **) keys,
- (const void **) values,
- 2,
- &kCFTypeDictionaryKeyCallBacks,
- &kCFTypeDictionaryValueCallBacks);
- CFRelease(values[0]);
- CFRelease(values[1]);
-
- CFArrayRef array = CFArrayCreate( kCFAllocatorDefault,
- (const void **) dictionaries,
- 2,
- &kCFTypeArrayCallBacks);
- CFRelease(dictionaries[0]);
- CFRelease(dictionaries[1]);
-
- IOHIDManagerSetDeviceMatchingMultiple(HidManager, array);
-
- CFRelease(array);
-
-
- IOHIDManagerRegisterDeviceMatchingCallback(HidManager, staticOnDeviceMatched, this);
- IOHIDManagerRegisterDeviceRemovalCallback(HidManager, staticOnDeviceRemoved, this);
-
-}
-
-GamepadManager::~GamepadManager()
-{
- CFRelease(HidManager);
-}
-
-UInt32 GamepadManager::GetGamepadCount()
-{
- return 1;
-}
-
-bool GamepadManager::GetGamepadState(UInt32 index, GamepadState* pState)
-{
- // For now we just support one gamepad.
- OVR_UNUSED(index);
-
- if (!bStateChanged)
- {
- return false;
- }
-
- bStateChanged = false;
-// State.Debug();
-
- *pState = State;
- return true;
-}
-
-int GamepadManager::getIntDeviceProperty(IOHIDDeviceRef device, CFStringRef key)
-{
- CFTypeRef type = IOHIDDeviceGetProperty(device, key);
- OVR_ASSERT(type != NULL && CFGetTypeID(type) == CFNumberGetTypeID());
-
- int value;
- CFNumberGetValue((CFNumberRef) type, kCFNumberSInt32Type, &value);
-
- return value;
-}
-
-void GamepadManager::staticOnDeviceMatched(void* context, IOReturn result, void* sender, IOHIDDeviceRef device)
-{
- GamepadManager* pManager = (GamepadManager*) context;
- pManager->onDeviceMatched(device);
-}
-
-void GamepadManager::onDeviceMatched(IOHIDDeviceRef device)
-{
- IOHIDDeviceRegisterInputValueCallback(device, staticOnDeviceValueChanged, this);
-}
-
-void GamepadManager::staticOnDeviceRemoved(void* context, IOReturn result, void* sender, IOHIDDeviceRef device)
-{
- GamepadManager* pManager = (GamepadManager*) context;
- pManager->onDeviceRemoved(device);
-}
-
-void GamepadManager::onDeviceRemoved(IOHIDDeviceRef device)
-{
- IOHIDDeviceRegisterInputValueCallback(device, NULL, NULL);
-}
-
-void GamepadManager::staticOnDeviceValueChanged(void* context, IOReturn result, void* sender, IOHIDValueRef value)
-{
- GamepadManager* pManager = (GamepadManager*) context;
- pManager->onDeviceValueChanged(value);
-}
-
-float GamepadManager::mapAnalogAxis(IOHIDValueRef value, IOHIDElementRef element)
-{
-
- CFIndex val = IOHIDValueGetIntegerValue(value);
- CFIndex min = IOHIDElementGetLogicalMin(element);
- CFIndex max = IOHIDElementGetLogicalMax(element);
-
- float v = (float) (val - min) / (float) (max - min);
- v = v * 2.0f - 1.0f;
-
- // Dead zone.
- if (v < 0.1f && v > -0.1f)
- {
- v = 0.0f;
- }
-
- return v;
-}
-
-bool GamepadManager::setStateIfDifferent(float& state, float newState)
-{
- if (state == newState)
- return false;
-
- state = newState;
-
- return true;
-}
-
-void GamepadManager::onDeviceValueChanged(IOHIDValueRef value)
-{
-
- IOHIDElementRef element = IOHIDValueGetElement(value);
- IOHIDDeviceRef device = IOHIDElementGetDevice(element);
-
- int vendorID = getIntDeviceProperty(device, CFSTR(kIOHIDVendorIDKey));
- int productID = getIntDeviceProperty(device, CFSTR(kIOHIDProductIDKey));
- OVR_UNUSED(productID);
-
- uint32_t usagePage = IOHIDElementGetUsagePage(element);
- uint32_t usage = IOHIDElementGetUsage(element);
-
- // The following controller mapping is based on the Logitech F710, however we use it for
- // all Logitech devices on the assumption that they're likely to share the same mapping.
- if (vendorID == Logitech_F710_VendorID)
- {
- // Logitech F710 mapping.
- if (usagePage == kHIDPage_Button)
- {
- bool buttonState = IOHIDValueGetIntegerValue(value);
-
- switch(usage)
- {
- case kHIDUsage_Button_1:
- manipulateBitField(State.Buttons, Gamepad_X, buttonState);
- break;
- case kHIDUsage_Button_2:
- manipulateBitField(State.Buttons, Gamepad_A, buttonState);
- break;
- case kHIDUsage_Button_3:
- manipulateBitField(State.Buttons, Gamepad_B, buttonState);
- break;
- case kHIDUsage_Button_4:
- manipulateBitField(State.Buttons, Gamepad_Y, buttonState);
- break;
- case 0x05:
- manipulateBitField(State.Buttons, Gamepad_L1, buttonState);
- break;
- case 0x06:
- manipulateBitField(State.Buttons, Gamepad_R1, buttonState);
- break;
- case 0x07:
- State.LT = buttonState ? 1.0f:0.0f;
- break;
- case 0x08:
- State.RT = buttonState ? 1.0f:0.0f;
- break;
- case 0x09:
- manipulateBitField(State.Buttons, Gamepad_Back, buttonState);
- break;
- case 0x0A:
- manipulateBitField(State.Buttons, Gamepad_Start, buttonState);
- break;
- case 0x0B:
- manipulateBitField(State.Buttons, Gamepad_LStick, buttonState);
- break;
- case 0x0C:
- manipulateBitField(State.Buttons, Gamepad_RStick, buttonState);
- break;
- default:
- return;
- }
- }
- else if (usagePage == kHIDPage_GenericDesktop)
- {
- float v;
- switch(usage)
- {
- case kHIDUsage_GD_X:
- v = mapAnalogAxis(value, element);
- if (!setStateIfDifferent(State.LX, v))
- return;
- break;
- case kHIDUsage_GD_Y:
- v = mapAnalogAxis(value, element);
- if (!setStateIfDifferent(State.LY, -v))
- return;
- break;
- case kHIDUsage_GD_Z:
- v = mapAnalogAxis(value, element);
- if (!setStateIfDifferent(State.RX, v))
- return;
- break;
- case kHIDUsage_GD_Rz:
- v = mapAnalogAxis(value, element);
- if (!setStateIfDifferent(State.RY, -v))
- return;
- break;
- case kHIDUsage_GD_Hatswitch:
- {
- CFIndex integerValue = IOHIDValueGetIntegerValue(value);
-
- manipulateBitField(State.Buttons,
- Gamepad_Up,
- integerValue == 7 || integerValue == 0 || integerValue == 1);
- manipulateBitField(State.Buttons,
- Gamepad_Down,
- integerValue == 3 || integerValue == 4 || integerValue == 5);
- manipulateBitField(State.Buttons,
- Gamepad_Left,
- integerValue == 5 || integerValue == 6 || integerValue == 7);
- manipulateBitField(State.Buttons,
- Gamepad_Right,
- integerValue == 1 || integerValue == 2 || integerValue == 3);
- }
- break;
- default:
- return;
- }
- }
- }
- // The following controller mapping is based on the Sony DualShock3, however we use it for
- // all Sony devices on the assumption that they're likely to share the same mapping.
- else if (vendorID == Sony_DualShock3_VendorID)
- {
- // PS3 Controller.
- if (usagePage == kHIDPage_Button)
- {
- bool buttonState = IOHIDValueGetIntegerValue(value);
-
- switch(usage)
- {
- case kHIDUsage_Button_1:
- manipulateBitField(State.Buttons, Gamepad_Back, buttonState);
- break;
- case kHIDUsage_Button_2:
- manipulateBitField(State.Buttons, Gamepad_LStick, buttonState);
- break;
- case kHIDUsage_Button_3:
- manipulateBitField(State.Buttons, Gamepad_RStick, buttonState);
- break;
- case kHIDUsage_Button_4:
- manipulateBitField(State.Buttons, Gamepad_Start, buttonState);
- break;
- case 0x05:
- manipulateBitField(State.Buttons, Gamepad_Up, buttonState);
- break;
- case 0x06:
- manipulateBitField(State.Buttons, Gamepad_Right, buttonState);
- break;
- case 0x07:
- manipulateBitField(State.Buttons, Gamepad_Down, buttonState);
- break;
- case 0x08:
- manipulateBitField(State.Buttons, Gamepad_Left, buttonState);
- break;
- case 0x09:
- State.LT = buttonState ? 1.0f:0.0f;
- break;
- case 0x0A:
- State.RT = buttonState ? 1.0f:0.0f;
- break;
- case 0x0B:
- manipulateBitField(State.Buttons, Gamepad_L1, buttonState);
- break;
- case 0x0C:
- manipulateBitField(State.Buttons, Gamepad_R1, buttonState);
- break;
- case 0x0D:
- // PS3 Triangle.
- manipulateBitField(State.Buttons, Gamepad_TRIANGLE, buttonState);
- break;
- case 0x0E:
- // PS3 Circle
- manipulateBitField(State.Buttons, Gamepad_CIRCLE, buttonState);
- break;
- case 0x0F:
- // PS3 Cross
- manipulateBitField(State.Buttons, Gamepad_CROSS, buttonState);
- break;
- case 0x10:
- // PS3 Square
- manipulateBitField(State.Buttons, Gamepad_SQUARE, buttonState);
- break;
- default:
- return;
- }
- }
- else if (usagePage == kHIDPage_GenericDesktop)
- {
- float v;
- switch(usage)
- {
- case kHIDUsage_GD_X:
- v = mapAnalogAxis(value, element);
- if (!setStateIfDifferent(State.LX, v))
- return;
- break;
- case kHIDUsage_GD_Y:
- v = mapAnalogAxis(value, element);
- if (!setStateIfDifferent(State.LY, -v))
- return;
- break;
- case kHIDUsage_GD_Z:
- v = mapAnalogAxis(value, element);
- if (!setStateIfDifferent(State.RX, v))
- return;
- break;
- case kHIDUsage_GD_Rz:
- v = mapAnalogAxis(value, element);
- if (!setStateIfDifferent(State.RY, -v))
- return;
- break;
- default:
- return;
- }
- }
- }
-
- bStateChanged = true;
-}
-
-void GamepadManager::manipulateBitField(unsigned int& bitfield, unsigned int mask, bool val)
-{
- if (val)
- {
- bitfield |= mask;
- }
- else
- {
- bitfield &= ~mask;
- }
-}
-
-}}} // OVR::Platform::OSX
+/************************************************************************************
+
+Filename : OSX_Gamepad.cpp
+Content : OSX implementation of Gamepad functionality.
+Created : May 6, 2013
+Authors : Lee Cooper
+
+Copyright : Copyright 2013 Oculus VR, Inc. All Rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************************/
+
+#include "OSX_Gamepad.h"
+
+
+static const UInt32 Logitech_F710_VendorID = 0x046D;
+static const UInt32 Logitech_F710_ProductID = 0xC219;
+
+static const UInt32 Sony_DualShock3_VendorID = 0x054C;
+static const UInt32 Sony_DualShock3_ProductID = 0x0268;
+
+
+namespace OVR { namespace Platform { namespace OSX {
+
+
+GamepadManager::GamepadManager()
+ : bStateChanged(false)
+{
+
+ HidManager = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
+ IOHIDManagerOpen(HidManager, kIOHIDOptionsTypeNone);
+ IOHIDManagerScheduleWithRunLoop(HidManager,
+ CFRunLoopGetCurrent(),
+ kCFRunLoopDefaultMode);
+
+
+ // Setup device matching.
+ CFStringRef keys[] = { CFSTR(kIOHIDDeviceUsagePageKey),
+ CFSTR(kIOHIDDeviceUsageKey)};
+
+ int value;
+ CFNumberRef values[2];
+ CFDictionaryRef dictionaries[2];
+
+ // Match joysticks.
+ value = kHIDPage_GenericDesktop;
+ values[0] = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &value);
+
+ value = kHIDUsage_GD_Joystick;
+ values[1] = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &value);
+
+ dictionaries[0] = CFDictionaryCreate(kCFAllocatorDefault,
+ (const void **) keys,
+ (const void **) values,
+ 2,
+ &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+ CFRelease(values[0]);
+ CFRelease(values[1]);
+
+ // Match gamepads.
+ value = kHIDPage_GenericDesktop;
+ values[0] = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &value);
+
+ value = kHIDUsage_GD_GamePad;
+ values[1] = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &value);
+
+ dictionaries[1] = CFDictionaryCreate(kCFAllocatorDefault,
+ (const void **) keys,
+ (const void **) values,
+ 2,
+ &kCFTypeDictionaryKeyCallBacks,
+ &kCFTypeDictionaryValueCallBacks);
+ CFRelease(values[0]);
+ CFRelease(values[1]);
+
+ CFArrayRef array = CFArrayCreate( kCFAllocatorDefault,
+ (const void **) dictionaries,
+ 2,
+ &kCFTypeArrayCallBacks);
+ CFRelease(dictionaries[0]);
+ CFRelease(dictionaries[1]);
+
+ IOHIDManagerSetDeviceMatchingMultiple(HidManager, array);
+
+ CFRelease(array);
+
+
+ IOHIDManagerRegisterDeviceMatchingCallback(HidManager, staticOnDeviceMatched, this);
+ IOHIDManagerRegisterDeviceRemovalCallback(HidManager, staticOnDeviceRemoved, this);
+
+}
+
+GamepadManager::~GamepadManager()
+{
+ CFRelease(HidManager);
+}
+
+UInt32 GamepadManager::GetGamepadCount()
+{
+ return 1;
+}
+
+bool GamepadManager::GetGamepadState(UInt32 index, GamepadState* pState)
+{
+ // For now we just support one gamepad.
+ OVR_UNUSED(index);
+
+ if (!bStateChanged)
+ {
+ return false;
+ }
+
+ bStateChanged = false;
+// State.Debug();
+
+ *pState = State;
+ return true;
+}
+
+int GamepadManager::getIntDeviceProperty(IOHIDDeviceRef device, CFStringRef key)
+{
+ CFTypeRef type = IOHIDDeviceGetProperty(device, key);
+ OVR_ASSERT(type != NULL && CFGetTypeID(type) == CFNumberGetTypeID());
+
+ int value;
+ CFNumberGetValue((CFNumberRef) type, kCFNumberSInt32Type, &value);
+
+ return value;
+}
+
+void GamepadManager::staticOnDeviceMatched(void* context, IOReturn result, void* sender, IOHIDDeviceRef device)
+{
+ GamepadManager* pManager = (GamepadManager*) context;
+ pManager->onDeviceMatched(device);
+}
+
+void GamepadManager::onDeviceMatched(IOHIDDeviceRef device)
+{
+ IOHIDDeviceRegisterInputValueCallback(device, staticOnDeviceValueChanged, this);
+}
+
+void GamepadManager::staticOnDeviceRemoved(void* context, IOReturn result, void* sender, IOHIDDeviceRef device)
+{
+ GamepadManager* pManager = (GamepadManager*) context;
+ pManager->onDeviceRemoved(device);
+}
+
+void GamepadManager::onDeviceRemoved(IOHIDDeviceRef device)
+{
+ IOHIDDeviceRegisterInputValueCallback(device, NULL, NULL);
+}
+
+void GamepadManager::staticOnDeviceValueChanged(void* context, IOReturn result, void* sender, IOHIDValueRef value)
+{
+ GamepadManager* pManager = (GamepadManager*) context;
+ pManager->onDeviceValueChanged(value);
+}
+
+float GamepadManager::mapAnalogAxis(IOHIDValueRef value, IOHIDElementRef element)
+{
+
+ CFIndex val = IOHIDValueGetIntegerValue(value);
+ CFIndex min = IOHIDElementGetLogicalMin(element);
+ CFIndex max = IOHIDElementGetLogicalMax(element);
+
+ float v = (float) (val - min) / (float) (max - min);
+ v = v * 2.0f - 1.0f;
+
+ // Dead zone.
+ if (v < 0.1f && v > -0.1f)
+ {
+ v = 0.0f;
+ }
+
+ return v;
+}
+
+bool GamepadManager::setStateIfDifferent(float& state, float newState)
+{
+ if (state == newState)
+ return false;
+
+ state = newState;
+
+ return true;
+}
+
+void GamepadManager::onDeviceValueChanged(IOHIDValueRef value)
+{
+
+ IOHIDElementRef element = IOHIDValueGetElement(value);
+ IOHIDDeviceRef device = IOHIDElementGetDevice(element);
+
+ int vendorID = getIntDeviceProperty(device, CFSTR(kIOHIDVendorIDKey));
+ int productID = getIntDeviceProperty(device, CFSTR(kIOHIDProductIDKey));
+ OVR_UNUSED(productID);
+
+ uint32_t usagePage = IOHIDElementGetUsagePage(element);
+ uint32_t usage = IOHIDElementGetUsage(element);
+
+ // The following controller mapping is based on the Logitech F710, however we use it for
+ // all Logitech devices on the assumption that they're likely to share the same mapping.
+ if (vendorID == Logitech_F710_VendorID)
+ {
+ // Logitech F710 mapping.
+ if (usagePage == kHIDPage_Button)
+ {
+ bool buttonState = IOHIDValueGetIntegerValue(value);
+
+ switch(usage)
+ {
+ case kHIDUsage_Button_1:
+ manipulateBitField(State.Buttons, Gamepad_X, buttonState);
+ break;
+ case kHIDUsage_Button_2:
+ manipulateBitField(State.Buttons, Gamepad_A, buttonState);
+ break;
+ case kHIDUsage_Button_3:
+ manipulateBitField(State.Buttons, Gamepad_B, buttonState);
+ break;
+ case kHIDUsage_Button_4:
+ manipulateBitField(State.Buttons, Gamepad_Y, buttonState);
+ break;
+ case 0x05:
+ manipulateBitField(State.Buttons, Gamepad_L1, buttonState);
+ break;
+ case 0x06:
+ manipulateBitField(State.Buttons, Gamepad_R1, buttonState);
+ break;
+ case 0x07:
+ State.LT = buttonState ? 1.0f:0.0f;
+ break;
+ case 0x08:
+ State.RT = buttonState ? 1.0f:0.0f;
+ break;
+ case 0x09:
+ manipulateBitField(State.Buttons, Gamepad_Back, buttonState);
+ break;
+ case 0x0A:
+ manipulateBitField(State.Buttons, Gamepad_Start, buttonState);
+ break;
+ case 0x0B:
+ manipulateBitField(State.Buttons, Gamepad_LStick, buttonState);
+ break;
+ case 0x0C:
+ manipulateBitField(State.Buttons, Gamepad_RStick, buttonState);
+ break;
+ default:
+ return;
+ }
+ }
+ else if (usagePage == kHIDPage_GenericDesktop)
+ {
+ float v;
+ switch(usage)
+ {
+ case kHIDUsage_GD_X:
+ v = mapAnalogAxis(value, element);
+ if (!setStateIfDifferent(State.LX, v))
+ return;
+ break;
+ case kHIDUsage_GD_Y:
+ v = mapAnalogAxis(value, element);
+ if (!setStateIfDifferent(State.LY, -v))
+ return;
+ break;
+ case kHIDUsage_GD_Z:
+ v = mapAnalogAxis(value, element);
+ if (!setStateIfDifferent(State.RX, v))
+ return;
+ break;
+ case kHIDUsage_GD_Rz:
+ v = mapAnalogAxis(value, element);
+ if (!setStateIfDifferent(State.RY, -v))
+ return;
+ break;
+ case kHIDUsage_GD_Hatswitch:
+ {
+ CFIndex integerValue = IOHIDValueGetIntegerValue(value);
+
+ manipulateBitField(State.Buttons,
+ Gamepad_Up,
+ integerValue == 7 || integerValue == 0 || integerValue == 1);
+ manipulateBitField(State.Buttons,
+ Gamepad_Down,
+ integerValue == 3 || integerValue == 4 || integerValue == 5);
+ manipulateBitField(State.Buttons,
+ Gamepad_Left,
+ integerValue == 5 || integerValue == 6 || integerValue == 7);
+ manipulateBitField(State.Buttons,
+ Gamepad_Right,
+ integerValue == 1 || integerValue == 2 || integerValue == 3);
+ }
+ break;
+ default:
+ return;
+ }
+ }
+ }
+ // The following controller mapping is based on the Sony DualShock3, however we use it for
+ // all Sony devices on the assumption that they're likely to share the same mapping.
+ else if (vendorID == Sony_DualShock3_VendorID)
+ {
+ // PS3 Controller.
+ if (usagePage == kHIDPage_Button)
+ {
+ bool buttonState = IOHIDValueGetIntegerValue(value);
+
+ switch(usage)
+ {
+ case kHIDUsage_Button_1:
+ manipulateBitField(State.Buttons, Gamepad_Back, buttonState);
+ break;
+ case kHIDUsage_Button_2:
+ manipulateBitField(State.Buttons, Gamepad_LStick, buttonState);
+ break;
+ case kHIDUsage_Button_3:
+ manipulateBitField(State.Buttons, Gamepad_RStick, buttonState);
+ break;
+ case kHIDUsage_Button_4:
+ manipulateBitField(State.Buttons, Gamepad_Start, buttonState);
+ break;
+ case 0x05:
+ manipulateBitField(State.Buttons, Gamepad_Up, buttonState);
+ break;
+ case 0x06:
+ manipulateBitField(State.Buttons, Gamepad_Right, buttonState);
+ break;
+ case 0x07:
+ manipulateBitField(State.Buttons, Gamepad_Down, buttonState);
+ break;
+ case 0x08:
+ manipulateBitField(State.Buttons, Gamepad_Left, buttonState);
+ break;
+ case 0x09:
+ State.LT = buttonState ? 1.0f:0.0f;
+ break;
+ case 0x0A:
+ State.RT = buttonState ? 1.0f:0.0f;
+ break;
+ case 0x0B:
+ manipulateBitField(State.Buttons, Gamepad_L1, buttonState);
+ break;
+ case 0x0C:
+ manipulateBitField(State.Buttons, Gamepad_R1, buttonState);
+ break;
+ case 0x0D:
+ // PS3 Triangle.
+ manipulateBitField(State.Buttons, Gamepad_TRIANGLE, buttonState);
+ break;
+ case 0x0E:
+ // PS3 Circle
+ manipulateBitField(State.Buttons, Gamepad_CIRCLE, buttonState);
+ break;
+ case 0x0F:
+ // PS3 Cross
+ manipulateBitField(State.Buttons, Gamepad_CROSS, buttonState);
+ break;
+ case 0x10:
+ // PS3 Square
+ manipulateBitField(State.Buttons, Gamepad_SQUARE, buttonState);
+ break;
+ default:
+ return;
+ }
+ }
+ else if (usagePage == kHIDPage_GenericDesktop)
+ {
+ float v;
+ switch(usage)
+ {
+ case kHIDUsage_GD_X:
+ v = mapAnalogAxis(value, element);
+ if (!setStateIfDifferent(State.LX, v))
+ return;
+ break;
+ case kHIDUsage_GD_Y:
+ v = mapAnalogAxis(value, element);
+ if (!setStateIfDifferent(State.LY, -v))
+ return;
+ break;
+ case kHIDUsage_GD_Z:
+ v = mapAnalogAxis(value, element);
+ if (!setStateIfDifferent(State.RX, v))
+ return;
+ break;
+ case kHIDUsage_GD_Rz:
+ v = mapAnalogAxis(value, element);
+ if (!setStateIfDifferent(State.RY, -v))
+ return;
+ break;
+ default:
+ return;
+ }
+ }
+ }
+
+ bStateChanged = true;
+}
+
+void GamepadManager::manipulateBitField(unsigned int& bitfield, unsigned int mask, bool val)
+{
+ if (val)
+ {
+ bitfield |= mask;
+ }
+ else
+ {
+ bitfield &= ~mask;
+ }
+}
+
+}}} // OVR::Platform::OSX
diff --git a/Samples/CommonSrc/Platform/OSX_Gamepad.h b/Samples/CommonSrc/Platform/OSX_Gamepad.h
index 6d3344c..335a512 100644
--- a/Samples/CommonSrc/Platform/OSX_Gamepad.h
+++ b/Samples/CommonSrc/Platform/OSX_Gamepad.h
@@ -1,67 +1,66 @@
-/************************************************************************************
-
-Filename : OSX_Gamepad.h
-Content : OSX implementation of Gamepad functionality.
-Created : May 6, 2013
-Authors : Lee Cooper
-
-Copyright : Copyright 2013 Oculus VR, Inc. All Rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-************************************************************************************/
-
-#ifndef OVR_OSX_Gamepad_h
-#define OVR_OSX_Gamepad_h
-
-#include "Gamepad.h"
-
-#include <IOKit/IOKitLib.h>
-#include <IOKit/hid/IOHIDManager.h>
-
-
-namespace OVR { namespace Platform { namespace OSX {
-
-
-class GamepadManager : public Platform::GamepadManager
-{
-public:
- GamepadManager();
- ~GamepadManager();
-
- virtual UInt32 GetGamepadCount();
- virtual bool GetGamepadState(UInt32 index, GamepadState* pState);
-
-private:
- static void staticOnDeviceMatched(void* context, IOReturn result, void* sender, IOHIDDeviceRef device);
- void onDeviceMatched(IOHIDDeviceRef device);
-
- static void staticOnDeviceRemoved(void* context, IOReturn result, void* sender, IOHIDDeviceRef device);
- void onDeviceRemoved(IOHIDDeviceRef device);
-
- static void staticOnDeviceValueChanged(void* context, IOReturn result, void* sender, IOHIDValueRef value);
- void onDeviceValueChanged(IOHIDValueRef value);
-
- int getIntDeviceProperty(IOHIDDeviceRef device, CFStringRef key);
- float mapAnalogAxis(IOHIDValueRef value, IOHIDElementRef element);
- void manipulateBitField(unsigned int& bitfield, unsigned int mask, bool val);
- bool setStateIfDifferent(float& state, float newState);
-
- IOHIDManagerRef HidManager;
- GamepadState State;
- bool bStateChanged;
-};
-
-}}}
-
-#endif // OVR_OSX_Gamepad_h
+/************************************************************************************
+
+Filename : OSX_Gamepad.h
+Content : OSX implementation of Gamepad functionality.
+Created : May 6, 2013
+Authors : Lee Cooper
+
+Copyright : Copyright 2013 Oculus VR, Inc. All Rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************************/
+
+#ifndef OVR_OSX_Gamepad_h
+#define OVR_OSX_Gamepad_h
+
+#include <IOKit/IOKitLib.h>
+#include <IOKit/hid/IOHIDManager.h>
+
+#include "Gamepad.h"
+
+namespace OVR { namespace Platform { namespace OSX {
+
+
+class GamepadManager : public Platform::GamepadManager
+{
+public:
+ GamepadManager();
+ ~GamepadManager();
+
+ virtual UInt32 GetGamepadCount();
+ virtual bool GetGamepadState(UInt32 index, GamepadState* pState);
+
+private:
+ static void staticOnDeviceMatched(void* context, IOReturn result, void* sender, IOHIDDeviceRef device);
+ void onDeviceMatched(IOHIDDeviceRef device);
+
+ static void staticOnDeviceRemoved(void* context, IOReturn result, void* sender, IOHIDDeviceRef device);
+ void onDeviceRemoved(IOHIDDeviceRef device);
+
+ static void staticOnDeviceValueChanged(void* context, IOReturn result, void* sender, IOHIDValueRef value);
+ void onDeviceValueChanged(IOHIDValueRef value);
+
+ int getIntDeviceProperty(IOHIDDeviceRef device, CFStringRef key);
+ float mapAnalogAxis(IOHIDValueRef value, IOHIDElementRef element);
+ void manipulateBitField(unsigned int& bitfield, unsigned int mask, bool val);
+ bool setStateIfDifferent(float& state, float newState);
+
+ IOHIDManagerRef HidManager;
+ GamepadState State;
+ bool bStateChanged;
+};
+
+}}}
+
+#endif // OVR_OSX_Gamepad_h
diff --git a/Samples/CommonSrc/Platform/OSX_Platform.h b/Samples/CommonSrc/Platform/OSX_Platform.h
index 748c5fa..11d4279 100644
--- a/Samples/CommonSrc/Platform/OSX_Platform.h
+++ b/Samples/CommonSrc/Platform/OSX_Platform.h
@@ -1,80 +1,80 @@
-
-#include "../Platform/Platform.h"
-#include "../Render/Render_GL_Device.h"
-
-namespace OVR { namespace Platform { namespace OSX {
-
-class PlatformCore : public Platform::PlatformCore
-{
-public:
- void* Win;
- void* View;
- void* NsApp;
- bool Quit;
- int ExitCode;
- int Width, Height;
- MouseMode MMode;
-
- void RunIdle();
-
-public:
- PlatformCore(Application* app, void* nsapp);
- ~PlatformCore();
-
- bool SetupWindow(int w, int h);
- void Exit(int exitcode);
-
- RenderDevice* SetupGraphics(const SetupGraphicsDeviceSet& setupGraphicsDesc,
- const char* gtype, const Render::RendererParams& rp);
-
- void SetMouseMode(MouseMode mm);
- void GetWindowSize(int* w, int* h) const;
-
- void SetWindowTitle(const char*title);
-
- void ShowWindow(bool show);
- void DestroyWindow();
- bool SetFullscreen(const Render::RendererParams& rp, int fullscreen);
- int GetDisplayCount();
- Render::DisplayId GetDisplay(int screen);
-
- String GetContentDirectory() const;
-};
-
-}}
-namespace Render { namespace GL { namespace OSX {
-
-class RenderDevice : public Render::GL::RenderDevice
-{
-public:
- void* Context;
-
- RenderDevice(const Render::RendererParams& p, void* context)
- : GL::RenderDevice(p), Context(context) {}
-
- virtual void Shutdown();
- virtual void Present();
-
- virtual bool SetFullscreen(DisplayMode fullscreen);
-
- // oswnd = X11::PlatformCore*
- static Render::RenderDevice* CreateDevice(const RendererParams& rp, void* oswnd);
-};
-
-}}}}
-
-
-// OVR_PLATFORM_APP_ARGS specifies the Application class to use for startup,
-// providing it with startup arguments.
-#define OVR_PLATFORM_APP_ARGS(AppClass, args) \
-OVR::Platform::Application* OVR::Platform::Application::CreateApplication() \
-{ OVR::System::Init(OVR::Log::ConfigureDefaultLog(OVR::LogMask_All)); \
-return new AppClass args; } \
-void OVR::Platform::Application::DestroyApplication(OVR::Platform::Application* app) \
-{ OVR::Platform::PlatformCore* platform = app->pPlatform; \
-delete app; delete platform; OVR::System::Destroy(); };
-
-// OVR_PLATFORM_APP_ARGS specifies the Application startup class with no args.
-#define OVR_PLATFORM_APP(AppClass) OVR_PLATFORM_APP_ARGS(AppClass, ())
-
-
+
+#include "../Platform/Platform.h"
+#include "../Render/Render_GL_Device.h"
+
+namespace OVR { namespace Platform { namespace OSX {
+
+class PlatformCore : public Platform::PlatformCore
+{
+public:
+ void* Win;
+ void* View;
+ void* NsApp;
+ bool Quit;
+ int ExitCode;
+ int Width, Height;
+ MouseMode MMode;
+
+ void RunIdle();
+
+public:
+ PlatformCore(Application* app, void* nsapp);
+ ~PlatformCore();
+
+ bool SetupWindow(int w, int h);
+ void Exit(int exitcode);
+
+ RenderDevice* SetupGraphics(const SetupGraphicsDeviceSet& setupGraphicsDesc,
+ const char* gtype, const Render::RendererParams& rp);
+
+ void SetMouseMode(MouseMode mm);
+ void GetWindowSize(int* w, int* h) const;
+
+ void SetWindowTitle(const char*title);
+
+ void ShowWindow(bool show);
+ void DestroyWindow();
+ bool SetFullscreen(const Render::RendererParams& rp, int fullscreen);
+ int GetDisplayCount();
+ Render::DisplayId GetDisplay(int screen);
+
+ String GetContentDirectory() const;
+};
+
+}}
+namespace Render { namespace GL { namespace OSX {
+
+class RenderDevice : public Render::GL::RenderDevice
+{
+public:
+ void* Context;
+
+ RenderDevice(const Render::RendererParams& p, void* context)
+ : GL::RenderDevice(p), Context(context) {}
+
+ virtual void Shutdown();
+ virtual void Present();
+
+ virtual bool SetFullscreen(DisplayMode fullscreen);
+
+ // oswnd = X11::PlatformCore*
+ static Render::RenderDevice* CreateDevice(const RendererParams& rp, void* oswnd);
+};
+
+}}}}
+
+
+// OVR_PLATFORM_APP_ARGS specifies the Application class to use for startup,
+// providing it with startup arguments.
+#define OVR_PLATFORM_APP_ARGS(AppClass, args) \
+OVR::Platform::Application* OVR::Platform::Application::CreateApplication() \
+{ OVR::System::Init(OVR::Log::ConfigureDefaultLog(OVR::LogMask_All)); \
+return new AppClass args; } \
+void OVR::Platform::Application::DestroyApplication(OVR::Platform::Application* app) \
+{ OVR::Platform::PlatformCore* platform = app->pPlatform; \
+delete app; delete platform; OVR::System::Destroy(); };
+
+// OVR_PLATFORM_APP_ARGS specifies the Application startup class with no args.
+#define OVR_PLATFORM_APP(AppClass) OVR_PLATFORM_APP_ARGS(AppClass, ())
+
+
diff --git a/Samples/CommonSrc/Platform/OSX_PlatformObjc.h b/Samples/CommonSrc/Platform/OSX_PlatformObjc.h
index 7e69a4d..7d195eb 100644
--- a/Samples/CommonSrc/Platform/OSX_PlatformObjc.h
+++ b/Samples/CommonSrc/Platform/OSX_PlatformObjc.h
@@ -1,31 +1,31 @@
-
-#import <Cocoa/Cocoa.h>
-#import "OSX_Platform.h"
-#import "OSX_Gamepad.h"
-
-#import <CoreGraphics/CoreGraphics.h>
-#import <CoreGraphics/CGDirectDisplay.h>
-
-@interface OVRApp : NSApplication
-
-@property (assign) IBOutlet NSWindow* win;
-@property (assign) OVR::Platform::OSX::PlatformCore* Platform;
-@property (assign) OVR::Platform::Application* App;
-
--(void) run;
-
-@end
-
-@interface OVRView : NSOpenGLView <NSWindowDelegate>
-
-@property (assign) OVR::Platform::OSX::PlatformCore* Platform;
-@property (assign) OVR::Platform::Application* App;
-@property unsigned long Modifiers;
-
--(void)ProcessMouse:(NSEvent*)event;
--(void)warpMouseToCenter;
-
-+(CGDirectDisplayID) displayFromScreen:(NSScreen*)s;
-
-@end
-
+
+#import <Cocoa/Cocoa.h>
+#import "OSX_Platform.h"
+#import "OSX_Gamepad.h"
+
+#import <CoreGraphics/CoreGraphics.h>
+#import <CoreGraphics/CGDirectDisplay.h>
+
+@interface OVRApp : NSApplication
+
+@property (assign) IBOutlet NSWindow* win;
+@property (assign) OVR::Platform::OSX::PlatformCore* Platform;
+@property (assign) OVR::Platform::Application* App;
+
+-(void) run;
+
+@end
+
+@interface OVRView : NSOpenGLView <NSWindowDelegate>
+
+@property (assign) OVR::Platform::OSX::PlatformCore* Platform;
+@property (assign) OVR::Platform::Application* App;
+@property unsigned long Modifiers;
+
+-(void)ProcessMouse:(NSEvent*)event;
+-(void)warpMouseToCenter;
+
++(CGDirectDisplayID) displayFromScreen:(NSScreen*)s;
+
+@end
+
diff --git a/Samples/CommonSrc/Platform/OSX_WavPlayer.cpp b/Samples/CommonSrc/Platform/OSX_WavPlayer.cpp
index 6119888..a6cb937 100644
--- a/Samples/CommonSrc/Platform/OSX_WavPlayer.cpp
+++ b/Samples/CommonSrc/Platform/OSX_WavPlayer.cpp
@@ -1,242 +1,242 @@
-/************************************************************************************
-
-Filename : WavPlayer_OSX.cpp
-Content : An Apple OSX audio handler.
-Created : March 5, 2013
-Authors : Robotic Arm Software - Peter Hoff, Dan Goodman, Bryan Croteau
-
-Copyright : Copyright 2013 Oculus VR, Inc. All Rights reserved.
-
-Use of this software is subject to the terms of the Oculus LLC license
-agreement provided at the time of installation or download, or which
-otherwise accompanies this software in either electronic or hard copy form.
-
-************************************************************************************/
-
-#include "OSX_WavPlayer.h"
-
-namespace OVR { namespace Platform { namespace OSX {
-
-WavPlayer::WavPlayer(const char* fileName)
-{
- FileName = fileName;
-}
-
-bool WavPlayer::isDataChunk(unsigned char* buffer, int index)
-{
- unsigned char a = buffer[index];
- unsigned char b = buffer[index + 1];
- unsigned char c = buffer[index + 2];
- unsigned char d = buffer[index + 3];
- return (a == 'D' || a == 'd') && (b == 'A' || b == 'a') &&
- (c == 'T' || c == 't') && (d == 'A' || d == 'a');
-}
-
-int WavPlayer::getWord(unsigned char* buffer, int index)
-{
- unsigned char a = buffer[index];
- unsigned char b = buffer[index + 1];
- unsigned char c = buffer[index + 2];
- unsigned char d = buffer[index + 3];
- int result = 0;
- result |= a;
- result |= b << 8;
- result |= c << 16;
- result |= d << 24;
- return result;
-}
-
-short WavPlayer::getHalf(unsigned char* buffer, int index)
-{
- unsigned char a = buffer[index];
- unsigned char b = buffer[index + 1];
- short result = 0;
- result |= a;
- result |= b << 8;
- return result;
-}
-
-void *WavPlayer::LoadPCM(const char *filename, unsigned long *len)
-{
- FILE *file;
- struct stat s;
- void *pcm;
-
- if(stat(filename, &s))
- {
- return NULL;
- }
- *len = s.st_size;
- pcm = (void *) malloc(s.st_size);
- if(!pcm)
- {
- return NULL;
- }
- file = fopen(filename, "rb");
- if(!file)
- {
- free(pcm);
- return NULL;
- }
- fread(pcm, s.st_size, 1, file);
- fclose(file);
- return pcm;
-}
-
-int WavPlayer::PlayBuffer(void *pcmbuffer, unsigned long len)
-{
- AQCallbackStruct aqc;
- UInt32 err, bufferSize;
- int i;
-
- aqc.DataFormat.mSampleRate = SampleRate;
- aqc.DataFormat.mFormatID = kAudioFormatLinearPCM;
- if(BitsPerSample == 16)
- {
- aqc.DataFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger
- | kAudioFormatFlagIsPacked;
- }
- aqc.DataFormat.mBytesPerPacket = NumChannels * (BitsPerSample / 8);
- aqc.DataFormat.mFramesPerPacket = 1;
- aqc.DataFormat.mBytesPerFrame = NumChannels * (BitsPerSample / 8);
- aqc.DataFormat.mChannelsPerFrame = NumChannels;
- aqc.DataFormat.mBitsPerChannel = BitsPerSample;
- aqc.FrameCount = SampleRate / 60;
- aqc.SampleLen = (UInt32)(len);
- aqc.PlayPtr = 0;
- aqc.PCMBuffer = static_cast<unsigned char*>(pcmbuffer);
-
- err = AudioQueueNewOutput(&aqc.DataFormat,
- aqBufferCallback,
- &aqc,
- NULL,
- kCFRunLoopCommonModes,
- 0,
- &aqc.Queue);
- if(err)
- {
- return err;
- }
-
- aqc.FrameCount = SampleRate / 60;
- bufferSize = aqc.FrameCount * aqc.DataFormat.mBytesPerPacket;
-
- for(i = 0; i < AUDIO_BUFFERS; i++)
- {
- err = AudioQueueAllocateBuffer(aqc.Queue, bufferSize,
- &aqc.Buffers[i]);
- if(err)
- {
- return err;
- }
- aqBufferCallback(&aqc, aqc.Queue, aqc.Buffers[i]);
- }
-
- err = AudioQueueStart(aqc.Queue, NULL);
- if(err)
- {
- return err;
- }
-
- while(true)
- {
- }
- sleep(1);
- return 0;
-}
-
-void WavPlayer::aqBufferCallback(void *in, AudioQueueRef inQ, AudioQueueBufferRef outQB)
-{
- AQCallbackStruct *aqc;
- unsigned char *coreAudioBuffer;
-
- aqc = (AQCallbackStruct *) in;
- coreAudioBuffer = (unsigned char*) outQB->mAudioData;
-
- printf("Sync: %u / %u\n", aqc->PlayPtr, aqc->SampleLen);
-
- if(aqc->FrameCount > 0)
- {
- outQB->mAudioDataByteSize = aqc->DataFormat.mBytesPerFrame * aqc->FrameCount;
- for(int i = 0; i < aqc->FrameCount * aqc->DataFormat.mBytesPerFrame; i++)
- {
- if(aqc->PlayPtr > aqc->SampleLen)
- {
- aqc->PlayPtr = 0;
- i = 0;
- }
- coreAudioBuffer[i] = aqc->PCMBuffer[aqc->PlayPtr];
- aqc->PlayPtr++;
- }
- AudioQueueEnqueueBuffer(inQ, outQB, 0, NULL);
- }
-}
-
-int WavPlayer::PlayAudio()
-{
- unsigned long len;
- void *pcmbuffer;
- int ret;
-
- pcmbuffer = LoadPCM(FileName, &len);
- if(!pcmbuffer)
- {
- fprintf(stderr, "%s: %s\n", FileName, strerror(errno));
- exit(EXIT_FAILURE);
- }
-
- unsigned char* bytes = (unsigned char*)pcmbuffer;
- int index = 0;
-
- // 'RIFF'
- getWord(bytes, index);
- index += 4;
- // int Length
- getWord(bytes, index);
- index += 4;
- // 'WAVE'
- getWord(bytes, index);
- index += 4;
- // 'fmt '
- getWord(bytes, index);
- index += 4;
-
- // int Format Length
- int fmtLen = getWord(bytes, index);
- index += 4;
- AudioFormat = getHalf(bytes, index);
- index += 2;
- NumChannels = getHalf(bytes, index);
- index += 2;
- SampleRate = getWord(bytes, index);
- index += 4;
- ByteRate = getWord(bytes, index);
- index += 4;
- BlockAlign = getHalf(bytes, index);
- index += 2;
- BitsPerSample = getHalf(bytes, index);
- index += 2;
- index += fmtLen - 16;
- while(!isDataChunk(bytes, index))
- {
- // Any Chunk
- getWord(bytes, index);
- index += 4;
- // Any Chunk Length
- int anyChunkLen = getWord(bytes, index);
- index += 4 + anyChunkLen;
- }
- // 'data'
- getWord(bytes, index);
- index += 4;
- // int Data Length
- unsigned long dataLen = getWord(bytes, index);
- index += 4;
- unsigned char* target = &bytes[index];
-
- ret = PlayBuffer((void *)target, dataLen);
- free(pcmbuffer);
- return ret;
-}
-
-}}}
+/************************************************************************************
+
+Filename : WavPlayer_OSX.cpp
+Content : An Apple OSX audio handler.
+Created : March 5, 2013
+Authors : Robotic Arm Software - Peter Hoff, Dan Goodman, Bryan Croteau
+
+Copyright : Copyright 2013 Oculus VR, Inc. All Rights reserved.
+
+Use of this software is subject to the terms of the Oculus LLC license
+agreement provided at the time of installation or download, or which
+otherwise accompanies this software in either electronic or hard copy form.
+
+************************************************************************************/
+
+#include "OSX_WavPlayer.h"
+
+namespace OVR { namespace Platform { namespace OSX {
+
+WavPlayer::WavPlayer(const char* fileName)
+{
+ FileName = fileName;
+}
+
+bool WavPlayer::isDataChunk(unsigned char* buffer, int index)
+{
+ unsigned char a = buffer[index];
+ unsigned char b = buffer[index + 1];
+ unsigned char c = buffer[index + 2];
+ unsigned char d = buffer[index + 3];
+ return (a == 'D' || a == 'd') && (b == 'A' || b == 'a') &&
+ (c == 'T' || c == 't') && (d == 'A' || d == 'a');
+}
+
+int WavPlayer::getWord(unsigned char* buffer, int index)
+{
+ unsigned char a = buffer[index];
+ unsigned char b = buffer[index + 1];
+ unsigned char c = buffer[index + 2];
+ unsigned char d = buffer[index + 3];
+ int result = 0;
+ result |= a;
+ result |= b << 8;
+ result |= c << 16;
+ result |= d << 24;
+ return result;
+}
+
+short WavPlayer::getHalf(unsigned char* buffer, int index)
+{
+ unsigned char a = buffer[index];
+ unsigned char b = buffer[index + 1];
+ short result = 0;
+ result |= a;
+ result |= b << 8;
+ return result;
+}
+
+void *WavPlayer::LoadPCM(const char *filename, unsigned long *len)
+{
+ FILE *file;
+ struct stat s;
+ void *pcm;
+
+ if(stat(filename, &s))
+ {
+ return NULL;
+ }
+ *len = s.st_size;
+ pcm = (void *) malloc(s.st_size);
+ if(!pcm)
+ {
+ return NULL;
+ }
+ file = fopen(filename, "rb");
+ if(!file)
+ {
+ free(pcm);
+ return NULL;
+ }
+ fread(pcm, s.st_size, 1, file);
+ fclose(file);
+ return pcm;
+}
+
+int WavPlayer::PlayBuffer(void *pcmbuffer, unsigned long len)
+{
+ AQCallbackStruct aqc;
+ UInt32 err, bufferSize;
+ int i;
+
+ aqc.DataFormat.mSampleRate = SampleRate;
+ aqc.DataFormat.mFormatID = kAudioFormatLinearPCM;
+ if(BitsPerSample == 16)
+ {
+ aqc.DataFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger
+ | kAudioFormatFlagIsPacked;
+ }
+ aqc.DataFormat.mBytesPerPacket = NumChannels * (BitsPerSample / 8);
+ aqc.DataFormat.mFramesPerPacket = 1;
+ aqc.DataFormat.mBytesPerFrame = NumChannels * (BitsPerSample / 8);
+ aqc.DataFormat.mChannelsPerFrame = NumChannels;
+ aqc.DataFormat.mBitsPerChannel = BitsPerSample;
+ aqc.FrameCount = SampleRate / 60;
+ aqc.SampleLen = (UInt32)(len);
+ aqc.PlayPtr = 0;
+ aqc.PCMBuffer = static_cast<unsigned char*>(pcmbuffer);
+
+ err = AudioQueueNewOutput(&aqc.DataFormat,
+ aqBufferCallback,
+ &aqc,
+ NULL,
+ kCFRunLoopCommonModes,
+ 0,
+ &aqc.Queue);
+ if(err)
+ {
+ return err;
+ }
+
+ aqc.FrameCount = SampleRate / 60;
+ bufferSize = aqc.FrameCount * aqc.DataFormat.mBytesPerPacket;
+
+ for(i = 0; i < AUDIO_BUFFERS; i++)
+ {
+ err = AudioQueueAllocateBuffer(aqc.Queue, bufferSize,
+ &aqc.Buffers[i]);
+ if(err)
+ {
+ return err;
+ }
+ aqBufferCallback(&aqc, aqc.Queue, aqc.Buffers[i]);
+ }
+
+ err = AudioQueueStart(aqc.Queue, NULL);
+ if(err)
+ {
+ return err;
+ }
+
+ while(true)
+ {
+ }
+ sleep(1);
+ return 0;
+}
+
+void WavPlayer::aqBufferCallback(void *in, AudioQueueRef inQ, AudioQueueBufferRef outQB)
+{
+ AQCallbackStruct *aqc;
+ unsigned char *coreAudioBuffer;
+
+ aqc = (AQCallbackStruct *) in;
+ coreAudioBuffer = (unsigned char*) outQB->mAudioData;
+
+ printf("Sync: %u / %u\n", aqc->PlayPtr, aqc->SampleLen);
+
+ if(aqc->FrameCount > 0)
+ {
+ outQB->mAudioDataByteSize = aqc->DataFormat.mBytesPerFrame * aqc->FrameCount;
+ for(int i = 0; i < aqc->FrameCount * aqc->DataFormat.mBytesPerFrame; i++)
+ {
+ if(aqc->PlayPtr > aqc->SampleLen)
+ {
+ aqc->PlayPtr = 0;
+ i = 0;
+ }
+ coreAudioBuffer[i] = aqc->PCMBuffer[aqc->PlayPtr];
+ aqc->PlayPtr++;
+ }
+ AudioQueueEnqueueBuffer(inQ, outQB, 0, NULL);
+ }
+}
+
+int WavPlayer::PlayAudio()
+{
+ unsigned long len;
+ void *pcmbuffer;
+ int ret;
+
+ pcmbuffer = LoadPCM(FileName, &len);
+ if(!pcmbuffer)
+ {
+ fprintf(stderr, "%s: %s\n", FileName, strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+
+ unsigned char* bytes = (unsigned char*)pcmbuffer;
+ int index = 0;
+
+ // 'RIFF'
+ getWord(bytes, index);
+ index += 4;
+ // int Length
+ getWord(bytes, index);
+ index += 4;
+ // 'WAVE'
+ getWord(bytes, index);
+ index += 4;
+ // 'fmt '
+ getWord(bytes, index);
+ index += 4;
+
+ // int Format Length
+ int fmtLen = getWord(bytes, index);
+ index += 4;
+ AudioFormat = getHalf(bytes, index);
+ index += 2;
+ NumChannels = getHalf(bytes, index);
+ index += 2;
+ SampleRate = getWord(bytes, index);
+ index += 4;
+ ByteRate = getWord(bytes, index);
+ index += 4;
+ BlockAlign = getHalf(bytes, index);
+ index += 2;
+ BitsPerSample = getHalf(bytes, index);
+ index += 2;
+ index += fmtLen - 16;
+ while(!isDataChunk(bytes, index))
+ {
+ // Any Chunk
+ getWord(bytes, index);
+ index += 4;
+ // Any Chunk Length
+ int anyChunkLen = getWord(bytes, index);
+ index += 4 + anyChunkLen;
+ }
+ // 'data'
+ getWord(bytes, index);
+ index += 4;
+ // int Data Length
+ unsigned long dataLen = getWord(bytes, index);
+ index += 4;
+ unsigned char* target = &bytes[index];
+
+ ret = PlayBuffer((void *)target, dataLen);
+ free(pcmbuffer);
+ return ret;
+}
+
+}}}
diff --git a/Samples/CommonSrc/Platform/OSX_WavPlayer.h b/Samples/CommonSrc/Platform/OSX_WavPlayer.h
index 1b88b8c..4aaba10 100644
--- a/Samples/CommonSrc/Platform/OSX_WavPlayer.h
+++ b/Samples/CommonSrc/Platform/OSX_WavPlayer.h
@@ -1,64 +1,64 @@
-/************************************************************************************
-
-Filename : WavPlayer_OSX.h
-Content : An Apple OSX audio handler.
-Created : March 5, 2013
-Authors : Robotic Arm Software - Peter Hoff, Dan Goodman, Bryan Croteau
-
-Copyright : Copyright 2013 Oculus VR, Inc. All Rights reserved.
-
-Use of this software is subject to the terms of the Oculus LLC license
-agreement provided at the time of installation or download, or which
-otherwise accompanies this software in either electronic or hard copy form.
-
-************************************************************************************/
-
-#ifndef OVR_WavPlayer_h
-#define OVR_WavPlayer_h
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <sys/stat.h>
-#include <AudioToolbox/AudioQueue.h>
-
-#define AUDIO_BUFFERS 4
-
-namespace OVR { namespace Platform { namespace OSX {
-
-typedef struct AQCallbackStruct
-{
- AudioQueueRef Queue;
- UInt32 FrameCount;
- AudioQueueBufferRef Buffers[AUDIO_BUFFERS];
- AudioStreamBasicDescription DataFormat;
- UInt32 PlayPtr;
- UInt32 SampleLen;
- unsigned char* PCMBuffer;
-} AQCallbackStruct;
-
-class WavPlayer
-{
-public:
- WavPlayer(const char* fileName);
- int PlayAudio();
-private:
- bool isDataChunk(unsigned char* buffer, int index);
- int getWord(unsigned char* buffer, int index);
- short getHalf(unsigned char* buffer, int index);
- void *LoadPCM(const char *filename, unsigned long *len);
- int PlayBuffer(void *pcm, unsigned long len);
- static void aqBufferCallback(void *in, AudioQueueRef inQ, AudioQueueBufferRef outQB);
-
- short AudioFormat;
- short NumChannels;
- int SampleRate;
- int ByteRate;
- short BlockAlign;
- short BitsPerSample;
- const char* FileName;
-};
-
-}}}
-
-#endif
+/************************************************************************************
+
+Filename : WavPlayer_OSX.h
+Content : An Apple OSX audio handler.
+Created : March 5, 2013
+Authors : Robotic Arm Software - Peter Hoff, Dan Goodman, Bryan Croteau
+
+Copyright : Copyright 2013 Oculus VR, Inc. All Rights reserved.
+
+Use of this software is subject to the terms of the Oculus LLC license
+agreement provided at the time of installation or download, or which
+otherwise accompanies this software in either electronic or hard copy form.
+
+************************************************************************************/
+
+#ifndef OVR_WavPlayer_h
+#define OVR_WavPlayer_h
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <AudioToolbox/AudioQueue.h>
+
+#define AUDIO_BUFFERS 4
+
+namespace OVR { namespace Platform { namespace OSX {
+
+typedef struct AQCallbackStruct
+{
+ AudioQueueRef Queue;
+ UInt32 FrameCount;
+ AudioQueueBufferRef Buffers[AUDIO_BUFFERS];
+ AudioStreamBasicDescription DataFormat;
+ UInt32 PlayPtr;
+ UInt32 SampleLen;
+ unsigned char* PCMBuffer;
+} AQCallbackStruct;
+
+class WavPlayer
+{
+public:
+ WavPlayer(const char* fileName);
+ int PlayAudio();
+private:
+ bool isDataChunk(unsigned char* buffer, int index);
+ int getWord(unsigned char* buffer, int index);
+ short getHalf(unsigned char* buffer, int index);
+ void *LoadPCM(const char *filename, unsigned long *len);
+ int PlayBuffer(void *pcm, unsigned long len);
+ static void aqBufferCallback(void *in, AudioQueueRef inQ, AudioQueueBufferRef outQB);
+
+ short AudioFormat;
+ short NumChannels;
+ int SampleRate;
+ int ByteRate;
+ short BlockAlign;
+ short BitsPerSample;
+ const char* FileName;
+};
+
+}}}
+
+#endif
diff --git a/Samples/CommonSrc/Platform/Platform.cpp b/Samples/CommonSrc/Platform/Platform.cpp
index bf5b8a5..c0e4438 100644
--- a/Samples/CommonSrc/Platform/Platform.cpp
+++ b/Samples/CommonSrc/Platform/Platform.cpp
@@ -1,75 +1,75 @@
-/************************************************************************************
-
-Filename : Platform.cpp
-Content : Platform-independent app framework for Oculus samples
-Created : September 6, 2012
-Authors : Andrew Reisse
-
-Copyright : Copyright 2012 Oculus VR, Inc. All Rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-************************************************************************************/
-
-
-
-#include "Platform.h"
-#include <Kernel/OVR_Std.h>
-#include <Kernel/OVR_Timer.h>
-#include "../Render/Render_Device.h"
-#include "Gamepad.h"
-
-namespace OVR { namespace Platform {
-
-
-const SetupGraphicsDeviceSet* SetupGraphicsDeviceSet::PickSetupDevice(const char* typeArg) const
-{
- // Search for graphics creation object that matches type arg.
- if (typeArg)
- {
- for (const SetupGraphicsDeviceSet* p = this; p != 0; p = p->pNext)
- {
- if (!OVR_stricmp(p->pTypeArg, typeArg))
- return p;
- }
- }
- return this;
-}
-
-//-------------------------------------------------------------------------------------
-
-PlatformCore::PlatformCore(Application *app)
-{
- pApp = app;
- pApp->SetPlatformCore(this);
- StartupTicks = OVR::Timer::GetTicks();
-}
-
-double PlatformCore::GetAppTime() const
-{
- return (OVR::Timer::GetTicks() - StartupTicks) * (1.0 / (double)OVR::Timer::MksPerSecond);
-}
-
-bool PlatformCore::SetFullscreen(const Render::RendererParams&, int fullscreen)
-{
- if (pRender)
- return pRender->SetFullscreen((Render::DisplayMode)fullscreen);
- return 0;
-}
-
-Render::DisplayId PlatformCore::GetDisplay(int screen)
-{
- OVR_UNUSED(screen); return Render::DisplayId();
-}
-
-}}
+/************************************************************************************
+
+Filename : Platform.cpp
+Content : Platform-independent app framework for Oculus samples
+Created : September 6, 2012
+Authors : Andrew Reisse
+
+Copyright : Copyright 2012 Oculus VR, Inc. All Rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************************/
+
+
+
+#include "Platform.h"
+#include <Kernel/OVR_Std.h>
+#include <Kernel/OVR_Timer.h>
+#include "../Render/Render_Device.h"
+#include "Gamepad.h"
+
+namespace OVR { namespace Platform {
+
+
+const SetupGraphicsDeviceSet* SetupGraphicsDeviceSet::PickSetupDevice(const char* typeArg) const
+{
+ // Search for graphics creation object that matches type arg.
+ if (typeArg)
+ {
+ for (const SetupGraphicsDeviceSet* p = this; p != 0; p = p->pNext)
+ {
+ if (!OVR_stricmp(p->pTypeArg, typeArg))
+ return p;
+ }
+ }
+ return this;
+}
+
+//-------------------------------------------------------------------------------------
+
+PlatformCore::PlatformCore(Application *app)
+{
+ pApp = app;
+ pApp->SetPlatformCore(this);
+ StartupTicks = OVR::Timer::GetTicks();
+}
+
+double PlatformCore::GetAppTime() const
+{
+ return (OVR::Timer::GetTicks() - StartupTicks) * (1.0 / (double)OVR::Timer::MksPerSecond);
+}
+
+bool PlatformCore::SetFullscreen(const Render::RendererParams&, int fullscreen)
+{
+ if (pRender)
+ return pRender->SetFullscreen((Render::DisplayMode)fullscreen);
+ return 0;
+}
+
+Render::DisplayId PlatformCore::GetDisplay(int screen)
+{
+ OVR_UNUSED(screen); return Render::DisplayId();
+}
+
+}}
diff --git a/Samples/CommonSrc/Platform/Platform.h b/Samples/CommonSrc/Platform/Platform.h
index 8ef4593..201aad6 100644
--- a/Samples/CommonSrc/Platform/Platform.h
+++ b/Samples/CommonSrc/Platform/Platform.h
@@ -1,190 +1,190 @@
-/************************************************************************************
-
-Filename : Platform.h
-Content : Platform-independent app and rendering framework for Oculus samples
-Created : September 6, 2012
-Authors : Andrew Reisse
-
-Copyright : Copyright 2012 Oculus VR, Inc. All Rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-************************************************************************************/
-
-#ifndef OVR_Platform_h
-#define OVR_Platform_h
-
-#include "OVR.h"
-
-#include "Kernel/OVR_KeyCodes.h"
-
-namespace OVR { namespace Render {
- class RenderDevice;
- struct DisplayId;
- struct RendererParams;
-}}
-
-namespace OVR { namespace Platform {
-
-using Render::RenderDevice;
-
-class PlatformCore;
-class Application;
-class GamepadManager;
-
-// MouseMode configures mouse input behavior of the app. Three states are
-// currently supported:
-// Normal - Reports absolute coordinates with cursor shown.
-// Relative - Reports relative delta coordinates with cursor hidden
-// until 'Esc' key is pressed or window loses focus.
-// RelativeEscaped - Relative input is desired, but has been escaped until
-// mouse is clicked in the window, which will return the state
-// to relative. Absolute coordinates are reported.
-
-enum MouseMode
-{
- Mouse_Normal,
- Mouse_Relative, // Cursor hidden, mouse grab, OnMouseMove reports relative deltas.
- Mouse_RelativeEscaped, // Clicking in window will return to Relative state.
-};
-
-
-enum Modifiers
-{
- Mod_Shift = 0x001,
- Mod_Control = 0x002,
- Mod_Meta = 0x004,
- Mod_Alt = 0x008,
-
- // Set for input Mouse_Relative mode, indicating that x,y are relative deltas.
- Mod_MouseRelative = 0x100,
-};
-
-//-------------------------------------------------------------------------------------
-// ***** SetupGraphicsDeviceSet
-
-typedef RenderDevice* (*RenderDeviceCreateFunc)(const Render::RendererParams&, void*);
-
-// SetupGraphicsDeviceSet is a PlatformCore::SetupGraphics initialization helper class,
-// used to build up a list of RenderDevices that can be used for rendering.
-// Specifying a smaller set allows application to avoid linking unused graphics devices.
-struct SetupGraphicsDeviceSet
-{
- SetupGraphicsDeviceSet(const char* typeArg, RenderDeviceCreateFunc createFunc)
- : pTypeArg(typeArg), pCreateDevice(createFunc), pNext(0) { }
- SetupGraphicsDeviceSet(const char* typeArg, RenderDeviceCreateFunc createFunc,
- const SetupGraphicsDeviceSet& next)
- : pTypeArg(typeArg), pCreateDevice(createFunc), pNext(&next) { }
-
- // Selects graphics object based on type string; returns 'this' if not found.
- const SetupGraphicsDeviceSet* PickSetupDevice(const char* typeArg) const;
-
- const char* pTypeArg;
- RenderDeviceCreateFunc pCreateDevice;
-
-private:
- const SetupGraphicsDeviceSet* pNext;
-};
-
-//-------------------------------------------------------------------------------------
-// ***** PlatformCore
-
-// PlatformCore defines abstract system window/viewport setup functionality and
-// maintains a renderer. This class is separated from Application because it can have
-// derived platform-specific implementations.
-// Specific implementation classes are hidden within platform-specific versions
-// such as Win32::PlatformCore.
-
-class PlatformCore : public NewOverrideBase
-{
-protected:
- Application* pApp;
- Ptr<RenderDevice> pRender;
- Ptr<GamepadManager> pGamepadManager;
- UInt64 StartupTicks;
-
-public:
- PlatformCore(Application *app);
- virtual ~PlatformCore() { }
- Application* GetApp() { return pApp; }
- RenderDevice* GetRenderer() const { return pRender; }
- GamepadManager* GetGamepadManager() const { return pGamepadManager; }
-
- virtual bool SetupWindow(int w, int h) = 0;
- // Destroys window and also releases renderer.
- virtual void DestroyWindow() = 0;
- virtual void Exit(int exitcode) = 0;
-
- virtual void ShowWindow(bool visible) = 0;
-
- virtual bool SetFullscreen(const Render::RendererParams& rp, int fullscreen);
-
- // Search for a matching graphics renderer based on type argument and initializes it.
- virtual RenderDevice* SetupGraphics(const SetupGraphicsDeviceSet& setupGraphicsDesc,
- const char* gtype,
- const Render::RendererParams& rp) = 0;
-
- virtual void SetMouseMode(MouseMode mm) { OVR_UNUSED(mm); }
-
- virtual void GetWindowSize(int* w, int* h) const = 0;
-
- virtual void SetWindowTitle(const char*title) = 0;
- virtual void PlayMusicFile(const char *fileName) { OVR_UNUSED(fileName); }
- virtual int GetDisplayCount() { return 0; }
- virtual Render::DisplayId GetDisplay(int screen);
-
- // Get time since start of application in seconds.
- double GetAppTime() const;
-
- virtual String GetContentDirectory() const { return "."; }
-};
-
-//-------------------------------------------------------------------------------------
-// PlatformApp is a base application class from which end-user application
-// classes derive.
-
-class Application : public NewOverrideBase
-{
-protected:
- class PlatformCore* pPlatform;
-
-public:
- virtual ~Application() { }
-
- virtual int OnStartup(int argc, const char** argv) = 0;
- virtual void OnQuitRequest() { pPlatform->Exit(0); }
-
- virtual void OnIdle() {}
-
- virtual void OnKey(KeyCode key, int chr, bool down, int modifiers)
- { OVR_UNUSED4(key, chr, down, modifiers); }
- virtual void OnMouseMove(int x, int y, int modifiers)
- { OVR_UNUSED3(x, y, modifiers); }
-
- virtual void OnResize(int width, int height)
- { OVR_UNUSED2(width, height); }
-
- void SetPlatformCore(PlatformCore* p) { pPlatform = p; }
- PlatformCore* GetPlatformCore() const { return pPlatform; }
-
-
- // Static functions defined by OVR_PLATFORM_APP and used to initialize and
- // shut down the application class.
- static Application* CreateApplication();
- static void DestroyApplication(Application* app);
-};
-
-
-}}
-
-#endif
+/************************************************************************************
+
+Filename : Platform.h
+Content : Platform-independent app and rendering framework for Oculus samples
+Created : September 6, 2012
+Authors : Andrew Reisse
+
+Copyright : Copyright 2012 Oculus VR, Inc. All Rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************************/
+
+#ifndef OVR_Platform_h
+#define OVR_Platform_h
+
+#include "OVR.h"
+
+#include "Kernel/OVR_KeyCodes.h"
+
+namespace OVR { namespace Render {
+ class RenderDevice;
+ struct DisplayId;
+ struct RendererParams;
+}}
+
+namespace OVR { namespace Platform {
+
+using Render::RenderDevice;
+
+class PlatformCore;
+class Application;
+class GamepadManager;
+
+// MouseMode configures mouse input behavior of the app. Three states are
+// currently supported:
+// Normal - Reports absolute coordinates with cursor shown.
+// Relative - Reports relative delta coordinates with cursor hidden
+// until 'Esc' key is pressed or window loses focus.
+// RelativeEscaped - Relative input is desired, but has been escaped until
+// mouse is clicked in the window, which will return the state
+// to relative. Absolute coordinates are reported.
+
+enum MouseMode
+{
+ Mouse_Normal,
+ Mouse_Relative, // Cursor hidden, mouse grab, OnMouseMove reports relative deltas.
+ Mouse_RelativeEscaped, // Clicking in window will return to Relative state.
+};
+
+
+enum Modifiers
+{
+ Mod_Shift = 0x001,
+ Mod_Control = 0x002,
+ Mod_Meta = 0x004,
+ Mod_Alt = 0x008,
+
+ // Set for input Mouse_Relative mode, indicating that x,y are relative deltas.
+ Mod_MouseRelative = 0x100,
+};
+
+//-------------------------------------------------------------------------------------
+// ***** SetupGraphicsDeviceSet
+
+typedef RenderDevice* (*RenderDeviceCreateFunc)(const Render::RendererParams&, void*);
+
+// SetupGraphicsDeviceSet is a PlatformCore::SetupGraphics initialization helper class,
+// used to build up a list of RenderDevices that can be used for rendering.
+// Specifying a smaller set allows application to avoid linking unused graphics devices.
+struct SetupGraphicsDeviceSet
+{
+ SetupGraphicsDeviceSet(const char* typeArg, RenderDeviceCreateFunc createFunc)
+ : pTypeArg(typeArg), pCreateDevice(createFunc), pNext(0) { }
+ SetupGraphicsDeviceSet(const char* typeArg, RenderDeviceCreateFunc createFunc,
+ const SetupGraphicsDeviceSet& next)
+ : pTypeArg(typeArg), pCreateDevice(createFunc), pNext(&next) { }
+
+ // Selects graphics object based on type string; returns 'this' if not found.
+ const SetupGraphicsDeviceSet* PickSetupDevice(const char* typeArg) const;
+
+ const char* pTypeArg;
+ RenderDeviceCreateFunc pCreateDevice;
+
+private:
+ const SetupGraphicsDeviceSet* pNext;
+};
+
+//-------------------------------------------------------------------------------------
+// ***** PlatformCore
+
+// PlatformCore defines abstract system window/viewport setup functionality and
+// maintains a renderer. This class is separated from Application because it can have
+// derived platform-specific implementations.
+// Specific implementation classes are hidden within platform-specific versions
+// such as Win32::PlatformCore.
+
+class PlatformCore : public NewOverrideBase
+{
+protected:
+ Application* pApp;
+ Ptr<RenderDevice> pRender;
+ Ptr<GamepadManager> pGamepadManager;
+ UInt64 StartupTicks;
+
+public:
+ PlatformCore(Application *app);
+ virtual ~PlatformCore() { }
+ Application* GetApp() { return pApp; }
+ RenderDevice* GetRenderer() const { return pRender; }
+ GamepadManager* GetGamepadManager() const { return pGamepadManager; }
+
+ virtual bool SetupWindow(int w, int h) = 0;
+ // Destroys window and also releases renderer.
+ virtual void DestroyWindow() = 0;
+ virtual void Exit(int exitcode) = 0;
+
+ virtual void ShowWindow(bool visible) = 0;
+
+ virtual bool SetFullscreen(const Render::RendererParams& rp, int fullscreen);
+
+ // Search for a matching graphics renderer based on type argument and initializes it.
+ virtual RenderDevice* SetupGraphics(const SetupGraphicsDeviceSet& setupGraphicsDesc,
+ const char* gtype,
+ const Render::RendererParams& rp) = 0;
+
+ virtual void SetMouseMode(MouseMode mm) { OVR_UNUSED(mm); }
+
+ virtual void GetWindowSize(int* w, int* h) const = 0;
+
+ virtual void SetWindowTitle(const char*title) = 0;
+ virtual void PlayMusicFile(const char *fileName) { OVR_UNUSED(fileName); }
+ virtual int GetDisplayCount() { return 0; }
+ virtual Render::DisplayId GetDisplay(int screen);
+
+ // Get time since start of application in seconds.
+ double GetAppTime() const;
+
+ virtual String GetContentDirectory() const { return "."; }
+};
+
+//-------------------------------------------------------------------------------------
+// PlatformApp is a base application class from which end-user application
+// classes derive.
+
+class Application : public NewOverrideBase
+{
+protected:
+ class PlatformCore* pPlatform;
+
+public:
+ virtual ~Application() { }
+
+ virtual int OnStartup(int argc, const char** argv) = 0;
+ virtual void OnQuitRequest() { pPlatform->Exit(0); }
+
+ virtual void OnIdle() {}
+
+ virtual void OnKey(KeyCode key, int chr, bool down, int modifiers)
+ { OVR_UNUSED4(key, chr, down, modifiers); }
+ virtual void OnMouseMove(int x, int y, int modifiers)
+ { OVR_UNUSED3(x, y, modifiers); }
+
+ virtual void OnResize(int width, int height)
+ { OVR_UNUSED2(width, height); }
+
+ void SetPlatformCore(PlatformCore* p) { pPlatform = p; }
+ PlatformCore* GetPlatformCore() const { return pPlatform; }
+
+
+ // Static functions defined by OVR_PLATFORM_APP and used to initialize and
+ // shut down the application class.
+ static Application* CreateApplication();
+ static void DestroyApplication(Application* app);
+};
+
+
+}}
+
+#endif
diff --git a/Samples/CommonSrc/Platform/Platform_Default.h b/Samples/CommonSrc/Platform/Platform_Default.h
index d82be10..e4fecf2 100644
--- a/Samples/CommonSrc/Platform/Platform_Default.h
+++ b/Samples/CommonSrc/Platform/Platform_Default.h
@@ -1,59 +1,59 @@
-/************************************************************************************
-
-Filename : Platform_Default.h
-Content : Default Platform class and RenderDevice selection file
-Created : October 4, 2012
-Authors :
-
-Copyright : Copyright 2012 Oculus VR, Inc. All Rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-*************************************************************************************/
-
-#ifndef OVR_Platform_Default_h
-#define OVR_Platform_Default_h
-
-// This should select proper header file for the platform/compiler.
-#include <Kernel/OVR_Types.h>
-
-#if defined(OVR_OS_WIN32)
- #include "Win32_Platform.h"
-
- #include "../Render/Render_D3D11_Device.h"
- #undef OVR_D3D_VERSION
- #include "../Render/Render_D3D10_Device.h"
-// #include "../Render/Render_GL_Win32_Device.h"
-
-// Modify this list or pass a smaller set to select a specific render device,
-// while avoiding linking extra classes.
- #define OVR_DEFAULT_RENDER_DEVICE_SET \
- SetupGraphicsDeviceSet("D3D11", &OVR::Render::D3D11::RenderDevice::CreateDevice, \
- SetupGraphicsDeviceSet("D3D10", &OVR::Render::D3D10::RenderDevice::CreateDevice) )
-
-#elif defined(OVR_OS_MAC) && !defined(OVR_MAC_X11)
- #include "OSX_Platform.h"
-
- #define OVR_DEFAULT_RENDER_DEVICE_SET \
- SetupGraphicsDeviceSet("GL", &OVR::Render::GL::OSX::RenderDevice::CreateDevice)
-
-#else
-
- #include "X11_Platform.h"
-
- #define OVR_DEFAULT_RENDER_DEVICE_SET \
- SetupGraphicsDeviceSet("GL", &OVR::Render::GL::X11::RenderDevice::CreateDevice)
-
-#endif
-
-#endif // OVR_Platform_Default_h
+/************************************************************************************
+
+Filename : Platform_Default.h
+Content : Default Platform class and RenderDevice selection file
+Created : October 4, 2012
+Authors :
+
+Copyright : Copyright 2012 Oculus VR, Inc. All Rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+*************************************************************************************/
+
+#ifndef OVR_Platform_Default_h
+#define OVR_Platform_Default_h
+
+// This should select proper header file for the platform/compiler.
+#include <Kernel/OVR_Types.h>
+
+#if defined(OVR_OS_WIN32)
+ #include "Win32_Platform.h"
+
+ #include "../Render/Render_D3D11_Device.h"
+ #undef OVR_D3D_VERSION
+ #include "../Render/Render_D3D10_Device.h"
+// #include "../Render/Render_GL_Win32_Device.h"
+
+// Modify this list or pass a smaller set to select a specific render device,
+// while avoiding linking extra classes.
+ #define OVR_DEFAULT_RENDER_DEVICE_SET \
+ SetupGraphicsDeviceSet("D3D11", &OVR::Render::D3D11::RenderDevice::CreateDevice, \
+ SetupGraphicsDeviceSet("D3D10", &OVR::Render::D3D10::RenderDevice::CreateDevice) )
+
+#elif defined(OVR_OS_MAC) && !defined(OVR_MAC_X11)
+ #include "OSX_Platform.h"
+
+ #define OVR_DEFAULT_RENDER_DEVICE_SET \
+ SetupGraphicsDeviceSet("GL", &OVR::Render::GL::OSX::RenderDevice::CreateDevice)
+
+#else
+
+ #include "Linux_Platform.h"
+
+ #define OVR_DEFAULT_RENDER_DEVICE_SET \
+ SetupGraphicsDeviceSet("GL", &OVR::Render::GL::Linux::RenderDevice::CreateDevice)
+
+#endif
+
+#endif // OVR_Platform_Default_h
diff --git a/Samples/CommonSrc/Platform/Win32_Gamepad.cpp b/Samples/CommonSrc/Platform/Win32_Gamepad.cpp
index db6524a..9b8793f 100644
--- a/Samples/CommonSrc/Platform/Win32_Gamepad.cpp
+++ b/Samples/CommonSrc/Platform/Win32_Gamepad.cpp
@@ -1,101 +1,101 @@
-/************************************************************************************
-
-Filename : Win32_Gamepad.cpp
-Content : Win32 implementation of Platform app infrastructure
-Created : May 6, 2013
-Authors : Lee Cooper
-
-Copyright : Copyright 2013 Oculus VR, Inc. All Rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-************************************************************************************/
-
-#include "Win32_Gamepad.h"
-
-namespace OVR { namespace Platform { namespace Win32 {
-
-GamepadManager::GamepadManager()
-{
- hXInputModule = ::LoadLibraryA("Xinput9_1_0.dll");
- if (hXInputModule)
- {
- pXInputGetState = (PFn_XInputGetState)
- ::GetProcAddress(hXInputModule, "XInputGetState");
- }
-}
-
-GamepadManager::~GamepadManager()
-{
- if (hXInputModule)
- ::FreeLibrary(hXInputModule);
-}
-
-static inline float GamepadStick(short in)
-{
- float v;
- if (abs(in) < 9000)
- return 0;
- else if (in > 9000)
- v = (float) in - 9000;
- else
- v = (float) in + 9000;
- return v / (32767 - 9000);
-}
-
-static inline float GamepadTrigger(BYTE in)
-{
- if (in < 30)
- return 0;
- else
- return float(in-30) / 225;
-}
-
-UInt32 GamepadManager::GetGamepadCount()
-{
- return 1;
-}
-
-bool GamepadManager::GetGamepadState(UInt32 index, GamepadState* pState)
-{
- // For now we just support one gamepad.
- OVR_UNUSED(index);
-
- if (pXInputGetState)
- {
- XINPUT_STATE xis;
-
- if (pXInputGetState(0, &xis))
- return false;
-
- if (xis.dwPacketNumber == LastPadPacketNo)
- return false;
-
- // State changed.
- pState->Buttons = xis.Gamepad.wButtons; // Currently matches Xinput
- pState->LT = GamepadTrigger(xis.Gamepad.bLeftTrigger);
- pState->RT = GamepadTrigger(xis.Gamepad.bRightTrigger);
- pState->LX = GamepadStick(xis.Gamepad.sThumbLX);
- pState->LY = GamepadStick(xis.Gamepad.sThumbLY);
- pState->RX = GamepadStick(xis.Gamepad.sThumbRX);
- pState->RY = GamepadStick(xis.Gamepad.sThumbRY);
-
- LastPadPacketNo = xis.dwPacketNumber;
-
- return true;
- }
-
- return false;
-}
-
-}}} // OVR::Platform::Win32
+/************************************************************************************
+
+Filename : Win32_Gamepad.cpp
+Content : Win32 implementation of Platform app infrastructure
+Created : May 6, 2013
+Authors : Lee Cooper
+
+Copyright : Copyright 2013 Oculus VR, Inc. All Rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************************/
+
+#include "Win32_Gamepad.h"
+
+namespace OVR { namespace Platform { namespace Win32 {
+
+GamepadManager::GamepadManager()
+{
+ hXInputModule = ::LoadLibraryA("Xinput9_1_0.dll");
+ if (hXInputModule)
+ {
+ pXInputGetState = (PFn_XInputGetState)
+ ::GetProcAddress(hXInputModule, "XInputGetState");
+ }
+}
+
+GamepadManager::~GamepadManager()
+{
+ if (hXInputModule)
+ ::FreeLibrary(hXInputModule);
+}
+
+static inline float GamepadStick(short in)
+{
+ float v;
+ if (abs(in) < 9000)
+ return 0;
+ else if (in > 9000)
+ v = (float) in - 9000;
+ else
+ v = (float) in + 9000;
+ return v / (32767 - 9000);
+}
+
+static inline float GamepadTrigger(BYTE in)
+{
+ if (in < 30)
+ return 0;
+ else
+ return float(in-30) / 225;
+}
+
+UInt32 GamepadManager::GetGamepadCount()
+{
+ return 1;
+}
+
+bool GamepadManager::GetGamepadState(UInt32 index, GamepadState* pState)
+{
+ // For now we just support one gamepad.
+ OVR_UNUSED(index);
+
+ if (pXInputGetState)
+ {
+ XINPUT_STATE xis;
+
+ if (pXInputGetState(0, &xis))
+ return false;
+
+ if (xis.dwPacketNumber == LastPadPacketNo)
+ return false;
+
+ // State changed.
+ pState->Buttons = xis.Gamepad.wButtons; // Currently matches Xinput
+ pState->LT = GamepadTrigger(xis.Gamepad.bLeftTrigger);
+ pState->RT = GamepadTrigger(xis.Gamepad.bRightTrigger);
+ pState->LX = GamepadStick(xis.Gamepad.sThumbLX);
+ pState->LY = GamepadStick(xis.Gamepad.sThumbLY);
+ pState->RX = GamepadStick(xis.Gamepad.sThumbRX);
+ pState->RY = GamepadStick(xis.Gamepad.sThumbRY);
+
+ LastPadPacketNo = xis.dwPacketNumber;
+
+ return true;
+ }
+
+ return false;
+}
+
+}}} // OVR::Platform::Win32
diff --git a/Samples/CommonSrc/Platform/Win32_Gamepad.h b/Samples/CommonSrc/Platform/Win32_Gamepad.h
index 9066798..09815ae 100644
--- a/Samples/CommonSrc/Platform/Win32_Gamepad.h
+++ b/Samples/CommonSrc/Platform/Win32_Gamepad.h
@@ -1,54 +1,54 @@
-/************************************************************************************
-
-Filename : Win32_Gamepad.h
-Content : Win32 implementation of Gamepad functionality.
-Created : May 6, 2013
-Authors : Lee Cooper
-
-Copyright : Copyright 2013 Oculus VR, Inc. All Rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-************************************************************************************/
-
-#ifndef OVR_Win32_Gamepad_h
-#define OVR_Win32_Gamepad_h
-
-#include "Gamepad.h"
-
-#include <windows.h>
-#include <xinput.h>
-
-namespace OVR { namespace Platform { namespace Win32 {
-
-class GamepadManager : public Platform::GamepadManager
-{
-public:
- GamepadManager();
- ~GamepadManager();
-
- virtual UInt32 GetGamepadCount();
- virtual bool GetGamepadState(UInt32 index, GamepadState* pState);
-
-private:
- // Dynamically ink to XInput to simplify projects.
- HMODULE hXInputModule;
- typedef DWORD (WINAPI *PFn_XInputGetState)(DWORD dwUserIndex, XINPUT_STATE* pState);
- PFn_XInputGetState pXInputGetState;
-
- UInt32 LastPadPacketNo;
-};
-
-}}}
-
-#endif // OVR_Win32_Gamepad_h
+/************************************************************************************
+
+Filename : Win32_Gamepad.h
+Content : Win32 implementation of Gamepad functionality.
+Created : May 6, 2013
+Authors : Lee Cooper
+
+Copyright : Copyright 2013 Oculus VR, Inc. All Rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************************/
+
+#ifndef OVR_Win32_Gamepad_h
+#define OVR_Win32_Gamepad_h
+
+#include "Gamepad.h"
+
+#include <windows.h>
+#include <xinput.h>
+
+namespace OVR { namespace Platform { namespace Win32 {
+
+class GamepadManager : public Platform::GamepadManager
+{
+public:
+ GamepadManager();
+ ~GamepadManager();
+
+ virtual UInt32 GetGamepadCount();
+ virtual bool GetGamepadState(UInt32 index, GamepadState* pState);
+
+private:
+ // Dynamically ink to XInput to simplify projects.
+ HMODULE hXInputModule;
+ typedef DWORD (WINAPI *PFn_XInputGetState)(DWORD dwUserIndex, XINPUT_STATE* pState);
+ PFn_XInputGetState pXInputGetState;
+
+ UInt32 LastPadPacketNo;
+};
+
+}}}
+
+#endif // OVR_Win32_Gamepad_h
diff --git a/Samples/CommonSrc/Platform/Win32_Platform.cpp b/Samples/CommonSrc/Platform/Win32_Platform.cpp
index cdd1e1f..9be7196 100644
--- a/Samples/CommonSrc/Platform/Win32_Platform.cpp
+++ b/Samples/CommonSrc/Platform/Win32_Platform.cpp
@@ -1,600 +1,600 @@
-/************************************************************************************
-
-Filename : Win32_Platform.cpp
-Content : Win32 implementation of Platform app infrastructure
-Created : September 6, 2012
-Authors : Andrew Reisse
-
-Copyright : Copyright 2012 Oculus VR, Inc. All Rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-************************************************************************************/
-
-#include "Kernel/OVR_System.h"
-#include "Kernel/OVR_Array.h"
-#include "Kernel/OVR_String.h"
-
-#include "Win32_Platform.h"
-#include "Win32_Gamepad.h"
-#include "../Render/Render_Device.h"
-
-namespace OVR { namespace Platform { namespace Win32 {
-
-
-PlatformCore::PlatformCore(Application* app, HINSTANCE hinst)
- : Platform::PlatformCore(app), hWnd(NULL), hInstance(hinst), Quit(0), MMode(Mouse_Normal),
- Cursor(0), Modifiers(0), WindowTitle("App")
-{
- pGamepadManager = *new Win32::GamepadManager();
-}
-
-PlatformCore::~PlatformCore()
-{
-}
-
-bool PlatformCore::SetupWindow(int w, int h)
-{
- WNDCLASS wc;
- memset(&wc, 0, sizeof(wc));
- wc.lpszClassName = L"OVRAppWindow";
- wc.style = CS_OWNDC;
- wc.lpfnWndProc = systemWindowProc;
- wc.cbWndExtra = sizeof(PlatformCore*);
-
- RegisterClass(&wc);
-
- Width = w;
- Height = h;
- RECT winSize;
- winSize.left = winSize.top = 0;
- winSize.right = Width;
- winSize.bottom = Height;
- AdjustWindowRect(&winSize, WS_OVERLAPPEDWINDOW, false);
- hWnd = CreateWindowA("OVRAppWindow", WindowTitle.ToCStr(), WS_OVERLAPPEDWINDOW,
- CW_USEDEFAULT, CW_USEDEFAULT,
- // 1950, 10,
- winSize.right-winSize.left, winSize.bottom-winSize.top,
- NULL, NULL, hInstance, (LPVOID)this);
- Modifiers = 0;
-
- Cursor = LoadCursor(NULL, IDC_CROSS);
-
- // Initialize Window center in screen coordinates
- POINT center = { Width / 2, Height / 2 };
- ::ClientToScreen(hWnd, &center);
- WindowCenter = center;
-
- if (MMode == Mouse_Relative)
- {
- ::SetCursorPos(WindowCenter.x, WindowCenter.y);
- ShowCursor(FALSE);
- }
- ::SetFocus(hWnd);
-
- return (hWnd != NULL);
-}
-
-void PlatformCore::DestroyWindow()
-{
- // Release renderer.
- pRender.Clear();
-
- // Release gamepad.
- pGamepadManager.Clear();
-
- // Release window resources.
- ::DestroyWindow(hWnd);
- UnregisterClass(L"OVRAppWindow", hInstance);
- hWnd = 0;
- Width = Height = 0;
-
- //DestroyCursor(Cursor);
- Cursor = 0;
-}
-
-void PlatformCore::ShowWindow(bool visible)
-{
- ::ShowWindow(hWnd, visible ? SW_SHOW : SW_HIDE);
-}
-
-void PlatformCore::SetMouseMode(MouseMode mm)
-{
- if (mm == MMode)
- return;
-
- if (hWnd)
- {
- if (mm == Mouse_Relative)
- {
- ShowCursor(FALSE);
- ::SetCursorPos(WindowCenter.x, WindowCenter.y);
- }
- else
- {
- if (MMode == Mouse_Relative)
- ShowCursor(TRUE);
- }
- }
- MMode = mm;
-}
-
-void PlatformCore::GetWindowSize(int* w, int* h) const
-{
- *w = Width;
- *h = Height;
-}
-
-
-void PlatformCore::SetWindowTitle(const char* title)
-{
- WindowTitle = title;
- if (hWnd)
- ::SetWindowTextA(hWnd, title);
-}
-
-static UByte KeyMap[][2] =
-{
- { VK_BACK, Key_Backspace },
- { VK_TAB, Key_Tab },
- { VK_CLEAR, Key_Clear },
- { VK_RETURN, Key_Return },
- { VK_SHIFT, Key_Shift },
- { VK_CONTROL, Key_Control },
- { VK_MENU, Key_Alt },
- { VK_PAUSE, Key_Pause },
- { VK_CAPITAL, Key_CapsLock },
- { VK_ESCAPE, Key_Escape },
- { VK_SPACE, Key_Space },
- { VK_PRIOR, Key_PageUp },
- { VK_NEXT, Key_PageDown },
- { VK_END, Key_End },
- { VK_HOME, Key_Home },
- { VK_LEFT, Key_Left },
- { VK_UP, Key_Up },
- { VK_RIGHT, Key_Right },
- { VK_DOWN, Key_Down },
- { VK_INSERT, Key_Insert },
- { VK_DELETE, Key_Delete },
- { VK_HELP, Key_Help },
-
- { VK_NUMLOCK, Key_NumLock },
- { VK_SCROLL, Key_ScrollLock },
-
- { VK_OEM_1, Key_Semicolon },
- { VK_OEM_PLUS, Key_Equal },
- { VK_OEM_COMMA, Key_Comma },
- { VK_OEM_MINUS, Key_Minus },
- { VK_OEM_PERIOD,Key_Period },
- { VK_OEM_2, Key_Slash },
- { VK_OEM_3, Key_Bar },
- { VK_OEM_4, Key_BracketLeft },
- { VK_OEM_5, Key_Backslash },
- { VK_OEM_6, Key_BracketRight },
- { VK_OEM_7, Key_Quote },
-
- { VK_OEM_AX, Key_OEM_AX }, // 'AX' key on Japanese AX keyboard.
- { VK_OEM_102, Key_OEM_102 }, // "<>" or "\|" on RT 102-key keyboard.
- { VK_ICO_HELP, Key_ICO_HELP },
- { VK_ICO_00, Key_ICO_00 }
-};
-
-
-KeyCode MapVKToKeyCode(unsigned vk)
-{
- unsigned key = Key_None;
-
- if ((vk >= '0') && (vk <= '9'))
- {
- key = vk - '0' + Key_Num0;
- }
- else if ((vk >= 'A') && (vk <= 'Z'))
- {
- key = vk - 'A' + Key_A;
- }
- else if ((vk >= VK_NUMPAD0) && (vk <= VK_DIVIDE))
- {
- key = vk - VK_NUMPAD0 + Key_KP_0;
- }
- else if ((vk >= VK_F1) && (vk <= VK_F15))
- {
- key = vk - VK_F1 + Key_F1;
- }
- else
- {
- for (unsigned i = 0; i< (sizeof(KeyMap) / sizeof(KeyMap[1])); i++)
- {
- if (vk == KeyMap[i][0])
- {
- key = KeyMap[i][1];
- break;
- }
- }
- }
-
- return (KeyCode)key;
-}
-
-
-
-LRESULT CALLBACK PlatformCore::systemWindowProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
-{
- PlatformCore* self;
-
- // WM_NCCREATE should be the first message to come it; use it to set class pointer.
- if (msg == WM_NCCREATE)
- {
- self = static_cast<PlatformCore*>(((LPCREATESTRUCT)lp)->lpCreateParams);
-
- if (self)
- {
- SetWindowLongPtr(hwnd, 0, (LONG_PTR)self);
- self->hWnd = hwnd;
- }
- }
- else
- {
- self = (PlatformCore*)(UPInt)GetWindowLongPtr(hwnd, 0);
- }
-
- return self ? self->WindowProc(msg, wp, lp) :
- DefWindowProc(hwnd, msg, wp, lp);
-}
-
-
-LRESULT PlatformCore::WindowProc(UINT msg, WPARAM wp, LPARAM lp)
-{
- KeyCode keyCode;
-
- switch (msg)
- {
- case WM_PAINT:
- {
- PAINTSTRUCT ps;
- BeginPaint(hWnd, &ps);
- EndPaint(hWnd, &ps);
- }
- return 0;
-
- case WM_SETCURSOR:
- ::SetCursor(Cursor);
- return 0;
-
- case WM_MOUSEMOVE:
- if (MMode == Mouse_Relative)
- {
- POINT newPos = { LOWORD(lp), HIWORD(lp) };
- ::ClientToScreen(hWnd, &newPos);
- if ((newPos.x == WindowCenter.x) && (newPos.y == WindowCenter.y))
- break;
- ::SetCursorPos(WindowCenter.x, WindowCenter.y);
-
- LONG dx = newPos.x - WindowCenter.x;
- LONG dy = newPos.y - WindowCenter.y;
-
- pApp->OnMouseMove(dx, dy, Mod_MouseRelative);
- }
- else
- {
- pApp->OnMouseMove(LOWORD(lp), HIWORD(lp), 0);
- }
- break;
-
- case WM_MOVE:
- {
- RECT r;
- GetClientRect(hWnd, &r);
- WindowCenter.x = r.right/2;
- WindowCenter.y = r.bottom/2;
- ::ClientToScreen(hWnd, &WindowCenter);
- }
- break;
-
- case WM_KEYDOWN:
- switch (wp)
- {
- case VK_CONTROL: Modifiers |= Mod_Control; break;
- case VK_MENU: Modifiers |= Mod_Alt; break;
- case VK_SHIFT: Modifiers |= Mod_Shift; break;
- case VK_LWIN:
- case VK_RWIN: Modifiers |= Mod_Meta; break;
- }
- if ((keyCode = MapVKToKeyCode((unsigned)wp)) != Key_None)
- pApp->OnKey(keyCode, 0, true, Modifiers);
-
- if (keyCode == Key_Escape && MMode == Mouse_Relative)
- {
- MMode = Mouse_RelativeEscaped;
- ShowCursor(TRUE);
- }
- break;
-
- case WM_KEYUP:
- if ((keyCode = MapVKToKeyCode((unsigned)wp)) != Key_None)
- pApp->OnKey(keyCode, 0, false, Modifiers);
- switch (wp)
- {
- case VK_CONTROL: Modifiers &= ~Mod_Control; break;
- case VK_MENU: Modifiers &= ~Mod_Alt; break;
- case VK_SHIFT: Modifiers &= ~Mod_Shift; break;
- case VK_LWIN:
- case VK_RWIN: Modifiers &= ~Mod_Meta; break;
- }
- break;
-
- case WM_LBUTTONDOWN:
- //App->OnMouseButton(0,
-
- ::SetCapture(hWnd);
-
- if (MMode == Mouse_RelativeEscaped)
- {
- ::SetCursorPos(WindowCenter.x, WindowCenter.y);
- ::ShowCursor(FALSE);
- MMode = Mouse_Relative;
- }
- break;
-
- case WM_LBUTTONUP:
- ReleaseCapture();
- break;
-
- case WM_SETFOCUS:
- // Do NOT restore the Relative mode here, since calling SetCursorPos
- // would screw up titlebar window dragging.
- // Let users click in the center instead to resume.
- break;
-
- case WM_KILLFOCUS:
- if (MMode == Mouse_Relative)
- {
- MMode = Mouse_RelativeEscaped;
- ShowCursor(TRUE);
- }
- break;
-
- case WM_SIZE:
- // Change window size as long as we're not being minimized.
- if (wp != SIZE_MINIMIZED)
- {
- Width = LOWORD(lp);
- Height = HIWORD(lp);
- if (pRender)
- pRender->SetWindowSize(Width, Height);
- pApp->OnResize(Width,Height);
- }
- break;
-
- case WM_STYLECHANGING:
- // Resize the window. This is needed because the size includes any present system controls, and
- // windows does not adjust it when changing to fullscreen.
- {
- STYLESTRUCT* pss = (STYLESTRUCT*)lp;
- RECT winSize;
- winSize.left = winSize.top = 0;
- winSize.right = Width;
- winSize.bottom = Height;
- int w = winSize.right-winSize.left;
- int h = winSize.bottom-winSize.top;
- AdjustWindowRect(&winSize, pss->styleNew, false);
- ::SetWindowPos(hWnd, NULL, 0, 0, w, h, SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
- }
- break;
-
- case WM_QUIT:
- case WM_CLOSE:
- pApp->OnQuitRequest();
- return false;
- }
-
- return DefWindowProc(hWnd, msg, wp, lp);
-}
-
-int PlatformCore::Run()
-{
- while (!Quit)
- {
- MSG msg;
- if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
- {
- TranslateMessage(&msg);
- DispatchMessage(&msg);
- }
- else
- {
- pApp->OnIdle();
-
- // Keep sleeping when we're minimized.
- if (IsIconic(hWnd))
- {
- Sleep(10);
- }
- }
- }
-
- return ExitCode;
-}
-
-
-RenderDevice* PlatformCore::SetupGraphics(const SetupGraphicsDeviceSet& setupGraphicsDesc,
- const char* type, const Render::RendererParams& rp)
-{
- const SetupGraphicsDeviceSet* setupDesc = setupGraphicsDesc.PickSetupDevice(type);
- OVR_ASSERT(setupDesc);
-
- pRender = *setupDesc->pCreateDevice(rp, (void*)hWnd);
- if (pRender)
- pRender->SetWindowSize(Width, Height);
-
- ::ShowWindow(hWnd, SW_RESTORE);
- return pRender.GetPtr();
-}
-
-
-void PlatformCore::PlayMusicFile(const char *fileName)
-{
- PlaySoundA(fileName, NULL, SND_FILENAME | SND_LOOP | SND_ASYNC);
-}
-
-
-//-----------------------------------------------------------------------------
-
-// Used to capture all the active monitor handles
-struct MonitorSet
-{
- enum { MaxMonitors = 8 };
- HMONITOR Monitors[MaxMonitors];
- int MonitorCount;
- int PrimaryCount;
-};
-
-
-BOOL CALLBACK MonitorEnumProc(HMONITOR hMonitor, HDC, LPRECT, LPARAM dwData)
-{
- MonitorSet* monitorSet = (MonitorSet*)dwData;
- if (monitorSet->MonitorCount > MonitorSet::MaxMonitors)
- return FALSE;
-
- monitorSet->Monitors[monitorSet->MonitorCount] = hMonitor;
- monitorSet->MonitorCount++;
- return TRUE;
-};
-
-
-// Returns the number of active screens for extended displays and 1 for mirrored display
-int PlatformCore::GetDisplayCount()
-{
- // Get all the monitor handles
- MonitorSet monitors;
- monitors.MonitorCount = 0;
- EnumDisplayMonitors(NULL, NULL, MonitorEnumProc, (LPARAM)&monitors);
-
- // Count the primary monitors
- int primary = 0;
- MONITORINFOEX info;
- for (int m=0; m < monitors.MonitorCount; m++)
- {
- info.cbSize = sizeof(MONITORINFOEX);
- GetMonitorInfo(monitors.Monitors[m], &info);
-
- if (info.dwFlags & MONITORINFOF_PRIMARY)
- primary++;
- }
-
- if (primary > 1)
- return 1; // Regard mirrored displays as a single screen
- else
- return monitors.MonitorCount; // Return all extended displays
-}
-
-//-----------------------------------------------------------------------------
-// Returns the device name for the given screen index or empty string for invalid index
-// The zero index will always return the primary screen name
-Render::DisplayId PlatformCore::GetDisplay(int screen)
-{
- // Get all the monitor handles
- MonitorSet monitors;
- monitors.MonitorCount = 0;
- EnumDisplayMonitors(NULL, NULL, MonitorEnumProc, (LPARAM)&monitors);
-
- String screen_name;
-
- // Get the name of the suppled screen index with the requirement
- // that screen 0 is the primary monitor
- int non_primary_count = 0;
- MONITORINFOEX info;
- for (int m=0; m < monitors.MonitorCount; m++)
- {
- info.cbSize = sizeof(MONITORINFOEX);
- GetMonitorInfo(monitors.Monitors[m], &info);
-
- if (info.dwFlags & MONITORINFOF_PRIMARY)
- {
- if (screen == 0)
- {
- screen_name = info.szDevice;
- break;
- }
- }
- else
- {
- non_primary_count++;
- if (screen == non_primary_count)
- {
- screen_name = info.szDevice;
- break;
- }
- }
- }
-
- return screen_name;
-}
-
-
-}}}
-
-
-int WINAPI WinMain(HINSTANCE hinst, HINSTANCE prevInst, LPSTR inArgs, int show)
-{
- using namespace OVR;
- using namespace OVR::Platform;
-
- OVR_UNUSED2(prevInst, show);
-
- // CreateApplication must be the first call since it does OVR::System::Initialize.
- Application* app = Application::CreateApplication();
- Win32::PlatformCore* platform = new Win32::PlatformCore(app, hinst);
- // The platform attached to an app will be deleted by DestroyApplication.
- app->SetPlatformCore(platform);
-
- int exitCode = 0;
-
- // Nested scope for container destructors to shutdown before DestroyApplication.
- {
- Array<String> args;
- Array<const char*> argv;
- argv.PushBack("app");
-
- const char* p = inArgs;
- const char* pstart = inArgs;
- while (*p)
- {
- if (*p == ' ')
- {
- args.PushBack(String(pstart, p - pstart));
- while (*p == ' ')
- p++;
- pstart = p;
- }
- else
- {
- p++;
- }
- }
- if (p != pstart)
- args.PushBack(String(pstart, p - pstart));
- for (UPInt i = 0; i < args.GetSize(); i++)
- argv.PushBack(args[i].ToCStr());
-
- exitCode = app->OnStartup((int)argv.GetSize(), &argv[0]);
- if (!exitCode)
- exitCode = platform->Run();
- }
-
- // No OVR functions involving memory are allowed after this.
- Application::DestroyApplication(app);
- app = 0;
-
- OVR_DEBUG_STATEMENT(_CrtDumpMemoryLeaks());
- return exitCode;
-}
+/************************************************************************************
+
+Filename : Win32_Platform.cpp
+Content : Win32 implementation of Platform app infrastructure
+Created : September 6, 2012
+Authors : Andrew Reisse
+
+Copyright : Copyright 2012 Oculus VR, Inc. All Rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************************/
+
+#include "Kernel/OVR_System.h"
+#include "Kernel/OVR_Array.h"
+#include "Kernel/OVR_String.h"
+
+#include "Win32_Platform.h"
+#include "Win32_Gamepad.h"
+#include "../Render/Render_Device.h"
+
+namespace OVR { namespace Platform { namespace Win32 {
+
+
+PlatformCore::PlatformCore(Application* app, HINSTANCE hinst)
+ : Platform::PlatformCore(app), hWnd(NULL), hInstance(hinst), Quit(0), MMode(Mouse_Normal),
+ Cursor(0), Modifiers(0), WindowTitle("App")
+{
+ pGamepadManager = *new Win32::GamepadManager();
+}
+
+PlatformCore::~PlatformCore()
+{
+}
+
+bool PlatformCore::SetupWindow(int w, int h)
+{
+ WNDCLASS wc;
+ memset(&wc, 0, sizeof(wc));
+ wc.lpszClassName = L"OVRAppWindow";
+ wc.style = CS_OWNDC;
+ wc.lpfnWndProc = systemWindowProc;
+ wc.cbWndExtra = sizeof(PlatformCore*);
+
+ RegisterClass(&wc);
+
+ Width = w;
+ Height = h;
+ RECT winSize;
+ winSize.left = winSize.top = 0;
+ winSize.right = Width;
+ winSize.bottom = Height;
+ AdjustWindowRect(&winSize, WS_OVERLAPPEDWINDOW, false);
+ hWnd = CreateWindowA("OVRAppWindow", WindowTitle.ToCStr(), WS_OVERLAPPEDWINDOW,
+ CW_USEDEFAULT, CW_USEDEFAULT,
+ // 1950, 10,
+ winSize.right-winSize.left, winSize.bottom-winSize.top,
+ NULL, NULL, hInstance, (LPVOID)this);
+ Modifiers = 0;
+
+ Cursor = LoadCursor(NULL, IDC_CROSS);
+
+ // Initialize Window center in screen coordinates
+ POINT center = { Width / 2, Height / 2 };
+ ::ClientToScreen(hWnd, &center);
+ WindowCenter = center;
+
+ if (MMode == Mouse_Relative)
+ {
+ ::SetCursorPos(WindowCenter.x, WindowCenter.y);
+ ShowCursor(FALSE);
+ }
+ ::SetFocus(hWnd);
+
+ return (hWnd != NULL);
+}
+
+void PlatformCore::DestroyWindow()
+{
+ // Release renderer.
+ pRender.Clear();
+
+ // Release gamepad.
+ pGamepadManager.Clear();
+
+ // Release window resources.
+ ::DestroyWindow(hWnd);
+ UnregisterClass(L"OVRAppWindow", hInstance);
+ hWnd = 0;
+ Width = Height = 0;
+
+ //DestroyCursor(Cursor);
+ Cursor = 0;
+}
+
+void PlatformCore::ShowWindow(bool visible)
+{
+ ::ShowWindow(hWnd, visible ? SW_SHOW : SW_HIDE);
+}
+
+void PlatformCore::SetMouseMode(MouseMode mm)
+{
+ if (mm == MMode)
+ return;
+
+ if (hWnd)
+ {
+ if (mm == Mouse_Relative)
+ {
+ ShowCursor(FALSE);
+ ::SetCursorPos(WindowCenter.x, WindowCenter.y);
+ }
+ else
+ {
+ if (MMode == Mouse_Relative)
+ ShowCursor(TRUE);
+ }
+ }
+ MMode = mm;
+}
+
+void PlatformCore::GetWindowSize(int* w, int* h) const
+{
+ *w = Width;
+ *h = Height;
+}
+
+
+void PlatformCore::SetWindowTitle(const char* title)
+{
+ WindowTitle = title;
+ if (hWnd)
+ ::SetWindowTextA(hWnd, title);
+}
+
+static UByte KeyMap[][2] =
+{
+ { VK_BACK, Key_Backspace },
+ { VK_TAB, Key_Tab },
+ { VK_CLEAR, Key_Clear },
+ { VK_RETURN, Key_Return },
+ { VK_SHIFT, Key_Shift },
+ { VK_CONTROL, Key_Control },
+ { VK_MENU, Key_Alt },
+ { VK_PAUSE, Key_Pause },
+ { VK_CAPITAL, Key_CapsLock },
+ { VK_ESCAPE, Key_Escape },
+ { VK_SPACE, Key_Space },
+ { VK_PRIOR, Key_PageUp },
+ { VK_NEXT, Key_PageDown },
+ { VK_END, Key_End },
+ { VK_HOME, Key_Home },
+ { VK_LEFT, Key_Left },
+ { VK_UP, Key_Up },
+ { VK_RIGHT, Key_Right },
+ { VK_DOWN, Key_Down },
+ { VK_INSERT, Key_Insert },
+ { VK_DELETE, Key_Delete },
+ { VK_HELP, Key_Help },
+
+ { VK_NUMLOCK, Key_NumLock },
+ { VK_SCROLL, Key_ScrollLock },
+
+ { VK_OEM_1, Key_Semicolon },
+ { VK_OEM_PLUS, Key_Equal },
+ { VK_OEM_COMMA, Key_Comma },
+ { VK_OEM_MINUS, Key_Minus },
+ { VK_OEM_PERIOD,Key_Period },
+ { VK_OEM_2, Key_Slash },
+ { VK_OEM_3, Key_Bar },
+ { VK_OEM_4, Key_BracketLeft },
+ { VK_OEM_5, Key_Backslash },
+ { VK_OEM_6, Key_BracketRight },
+ { VK_OEM_7, Key_Quote },
+
+ { VK_OEM_AX, Key_OEM_AX }, // 'AX' key on Japanese AX keyboard.
+ { VK_OEM_102, Key_OEM_102 }, // "<>" or "\|" on RT 102-key keyboard.
+ { VK_ICO_HELP, Key_ICO_HELP },
+ { VK_ICO_00, Key_ICO_00 }
+};
+
+
+KeyCode MapVKToKeyCode(unsigned vk)
+{
+ unsigned key = Key_None;
+
+ if ((vk >= '0') && (vk <= '9'))
+ {
+ key = vk - '0' + Key_Num0;
+ }
+ else if ((vk >= 'A') && (vk <= 'Z'))
+ {
+ key = vk - 'A' + Key_A;
+ }
+ else if ((vk >= VK_NUMPAD0) && (vk <= VK_DIVIDE))
+ {
+ key = vk - VK_NUMPAD0 + Key_KP_0;
+ }
+ else if ((vk >= VK_F1) && (vk <= VK_F15))
+ {
+ key = vk - VK_F1 + Key_F1;
+ }
+ else
+ {
+ for (unsigned i = 0; i< (sizeof(KeyMap) / sizeof(KeyMap[1])); i++)
+ {
+ if (vk == KeyMap[i][0])
+ {
+ key = KeyMap[i][1];
+ break;
+ }
+ }
+ }
+
+ return (KeyCode)key;
+}
+
+
+
+LRESULT CALLBACK PlatformCore::systemWindowProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
+{
+ PlatformCore* self;
+
+ // WM_NCCREATE should be the first message to come it; use it to set class pointer.
+ if (msg == WM_NCCREATE)
+ {
+ self = static_cast<PlatformCore*>(((LPCREATESTRUCT)lp)->lpCreateParams);
+
+ if (self)
+ {
+ SetWindowLongPtr(hwnd, 0, (LONG_PTR)self);
+ self->hWnd = hwnd;
+ }
+ }
+ else
+ {
+ self = (PlatformCore*)(UPInt)GetWindowLongPtr(hwnd, 0);
+ }
+
+ return self ? self->WindowProc(msg, wp, lp) :
+ DefWindowProc(hwnd, msg, wp, lp);
+}
+
+
+LRESULT PlatformCore::WindowProc(UINT msg, WPARAM wp, LPARAM lp)
+{
+ KeyCode keyCode;
+
+ switch (msg)
+ {
+ case WM_PAINT:
+ {
+ PAINTSTRUCT ps;
+ BeginPaint(hWnd, &ps);
+ EndPaint(hWnd, &ps);
+ }
+ return 0;
+
+ case WM_SETCURSOR:
+ ::SetCursor(Cursor);
+ return 0;
+
+ case WM_MOUSEMOVE:
+ if (MMode == Mouse_Relative)
+ {
+ POINT newPos = { LOWORD(lp), HIWORD(lp) };
+ ::ClientToScreen(hWnd, &newPos);
+ if ((newPos.x == WindowCenter.x) && (newPos.y == WindowCenter.y))
+ break;
+ ::SetCursorPos(WindowCenter.x, WindowCenter.y);
+
+ LONG dx = newPos.x - WindowCenter.x;
+ LONG dy = newPos.y - WindowCenter.y;
+
+ pApp->OnMouseMove(dx, dy, Mod_MouseRelative);
+ }
+ else
+ {
+ pApp->OnMouseMove(LOWORD(lp), HIWORD(lp), 0);
+ }
+ break;
+
+ case WM_MOVE:
+ {
+ RECT r;
+ GetClientRect(hWnd, &r);
+ WindowCenter.x = r.right/2;
+ WindowCenter.y = r.bottom/2;
+ ::ClientToScreen(hWnd, &WindowCenter);
+ }
+ break;
+
+ case WM_KEYDOWN:
+ switch (wp)
+ {
+ case VK_CONTROL: Modifiers |= Mod_Control; break;
+ case VK_MENU: Modifiers |= Mod_Alt; break;
+ case VK_SHIFT: Modifiers |= Mod_Shift; break;
+ case VK_LWIN:
+ case VK_RWIN: Modifiers |= Mod_Meta; break;
+ }
+ if ((keyCode = MapVKToKeyCode((unsigned)wp)) != Key_None)
+ pApp->OnKey(keyCode, 0, true, Modifiers);
+
+ if (keyCode == Key_Escape && MMode == Mouse_Relative)
+ {
+ MMode = Mouse_RelativeEscaped;
+ ShowCursor(TRUE);
+ }
+ break;
+
+ case WM_KEYUP:
+ if ((keyCode = MapVKToKeyCode((unsigned)wp)) != Key_None)
+ pApp->OnKey(keyCode, 0, false, Modifiers);
+ switch (wp)
+ {
+ case VK_CONTROL: Modifiers &= ~Mod_Control; break;
+ case VK_MENU: Modifiers &= ~Mod_Alt; break;
+ case VK_SHIFT: Modifiers &= ~Mod_Shift; break;
+ case VK_LWIN:
+ case VK_RWIN: Modifiers &= ~Mod_Meta; break;
+ }
+ break;
+
+ case WM_LBUTTONDOWN:
+ //App->OnMouseButton(0,
+
+ ::SetCapture(hWnd);
+
+ if (MMode == Mouse_RelativeEscaped)
+ {
+ ::SetCursorPos(WindowCenter.x, WindowCenter.y);
+ ::ShowCursor(FALSE);
+ MMode = Mouse_Relative;
+ }
+ break;
+
+ case WM_LBUTTONUP:
+ ReleaseCapture();
+ break;
+
+ case WM_SETFOCUS:
+ // Do NOT restore the Relative mode here, since calling SetCursorPos
+ // would screw up titlebar window dragging.
+ // Let users click in the center instead to resume.
+ break;
+
+ case WM_KILLFOCUS:
+ if (MMode == Mouse_Relative)
+ {
+ MMode = Mouse_RelativeEscaped;
+ ShowCursor(TRUE);
+ }
+ break;
+
+ case WM_SIZE:
+ // Change window size as long as we're not being minimized.
+ if (wp != SIZE_MINIMIZED)
+ {
+ Width = LOWORD(lp);
+ Height = HIWORD(lp);
+ if (pRender)
+ pRender->SetWindowSize(Width, Height);
+ pApp->OnResize(Width,Height);
+ }
+ break;
+
+ case WM_STYLECHANGING:
+ // Resize the window. This is needed because the size includes any present system controls, and
+ // windows does not adjust it when changing to fullscreen.
+ {
+ STYLESTRUCT* pss = (STYLESTRUCT*)lp;
+ RECT winSize;
+ winSize.left = winSize.top = 0;
+ winSize.right = Width;
+ winSize.bottom = Height;
+ int w = winSize.right-winSize.left;
+ int h = winSize.bottom-winSize.top;
+ AdjustWindowRect(&winSize, pss->styleNew, false);
+ ::SetWindowPos(hWnd, NULL, 0, 0, w, h, SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
+ }
+ break;
+
+ case WM_QUIT:
+ case WM_CLOSE:
+ pApp->OnQuitRequest();
+ return false;
+ }
+
+ return DefWindowProc(hWnd, msg, wp, lp);
+}
+
+int PlatformCore::Run()
+{
+ while (!Quit)
+ {
+ MSG msg;
+ if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
+ {
+ TranslateMessage(&msg);
+ DispatchMessage(&msg);
+ }
+ else
+ {
+ pApp->OnIdle();
+
+ // Keep sleeping when we're minimized.
+ if (IsIconic(hWnd))
+ {
+ Sleep(10);
+ }
+ }
+ }
+
+ return ExitCode;
+}
+
+
+RenderDevice* PlatformCore::SetupGraphics(const SetupGraphicsDeviceSet& setupGraphicsDesc,
+ const char* type, const Render::RendererParams& rp)
+{
+ const SetupGraphicsDeviceSet* setupDesc = setupGraphicsDesc.PickSetupDevice(type);
+ OVR_ASSERT(setupDesc);
+
+ pRender = *setupDesc->pCreateDevice(rp, (void*)hWnd);
+ if (pRender)
+ pRender->SetWindowSize(Width, Height);
+
+ ::ShowWindow(hWnd, SW_RESTORE);
+ return pRender.GetPtr();
+}
+
+
+void PlatformCore::PlayMusicFile(const char *fileName)
+{
+ PlaySoundA(fileName, NULL, SND_FILENAME | SND_LOOP | SND_ASYNC);
+}
+
+
+//-----------------------------------------------------------------------------
+
+// Used to capture all the active monitor handles
+struct MonitorSet
+{
+ enum { MaxMonitors = 8 };
+ HMONITOR Monitors[MaxMonitors];
+ int MonitorCount;
+ int PrimaryCount;
+};
+
+
+BOOL CALLBACK MonitorEnumProc(HMONITOR hMonitor, HDC, LPRECT, LPARAM dwData)
+{
+ MonitorSet* monitorSet = (MonitorSet*)dwData;
+ if (monitorSet->MonitorCount > MonitorSet::MaxMonitors)
+ return FALSE;
+
+ monitorSet->Monitors[monitorSet->MonitorCount] = hMonitor;
+ monitorSet->MonitorCount++;
+ return TRUE;
+};
+
+
+// Returns the number of active screens for extended displays and 1 for mirrored display
+int PlatformCore::GetDisplayCount()
+{
+ // Get all the monitor handles
+ MonitorSet monitors;
+ monitors.MonitorCount = 0;
+ EnumDisplayMonitors(NULL, NULL, MonitorEnumProc, (LPARAM)&monitors);
+
+ // Count the primary monitors
+ int primary = 0;
+ MONITORINFOEX info;
+ for (int m=0; m < monitors.MonitorCount; m++)
+ {
+ info.cbSize = sizeof(MONITORINFOEX);
+ GetMonitorInfo(monitors.Monitors[m], &info);
+
+ if (info.dwFlags & MONITORINFOF_PRIMARY)
+ primary++;
+ }
+
+ if (primary > 1)
+ return 1; // Regard mirrored displays as a single screen
+ else
+ return monitors.MonitorCount; // Return all extended displays
+}
+
+//-----------------------------------------------------------------------------
+// Returns the device name for the given screen index or empty string for invalid index
+// The zero index will always return the primary screen name
+Render::DisplayId PlatformCore::GetDisplay(int screen)
+{
+ // Get all the monitor handles
+ MonitorSet monitors;
+ monitors.MonitorCount = 0;
+ EnumDisplayMonitors(NULL, NULL, MonitorEnumProc, (LPARAM)&monitors);
+
+ String screen_name;
+
+ // Get the name of the suppled screen index with the requirement
+ // that screen 0 is the primary monitor
+ int non_primary_count = 0;
+ MONITORINFOEX info;
+ for (int m=0; m < monitors.MonitorCount; m++)
+ {
+ info.cbSize = sizeof(MONITORINFOEX);
+ GetMonitorInfo(monitors.Monitors[m], &info);
+
+ if (info.dwFlags & MONITORINFOF_PRIMARY)
+ {
+ if (screen == 0)
+ {
+ screen_name = info.szDevice;
+ break;
+ }
+ }
+ else
+ {
+ non_primary_count++;
+ if (screen == non_primary_count)
+ {
+ screen_name = info.szDevice;
+ break;
+ }
+ }
+ }
+
+ return screen_name;
+}
+
+
+}}}
+
+
+int WINAPI WinMain(HINSTANCE hinst, HINSTANCE prevInst, LPSTR inArgs, int show)
+{
+ using namespace OVR;
+ using namespace OVR::Platform;
+
+ OVR_UNUSED2(prevInst, show);
+
+ // CreateApplication must be the first call since it does OVR::System::Initialize.
+ Application* app = Application::CreateApplication();
+ Win32::PlatformCore* platform = new Win32::PlatformCore(app, hinst);
+ // The platform attached to an app will be deleted by DestroyApplication.
+ app->SetPlatformCore(platform);
+
+ int exitCode = 0;
+
+ // Nested scope for container destructors to shutdown before DestroyApplication.
+ {
+ Array<String> args;
+ Array<const char*> argv;
+ argv.PushBack("app");
+
+ const char* p = inArgs;
+ const char* pstart = inArgs;
+ while (*p)
+ {
+ if (*p == ' ')
+ {
+ args.PushBack(String(pstart, p - pstart));
+ while (*p == ' ')
+ p++;
+ pstart = p;
+ }
+ else
+ {
+ p++;
+ }
+ }
+ if (p != pstart)
+ args.PushBack(String(pstart, p - pstart));
+ for (UPInt i = 0; i < args.GetSize(); i++)
+ argv.PushBack(args[i].ToCStr());
+
+ exitCode = app->OnStartup((int)argv.GetSize(), &argv[0]);
+ if (!exitCode)
+ exitCode = platform->Run();
+ }
+
+ // No OVR functions involving memory are allowed after this.
+ Application::DestroyApplication(app);
+ app = 0;
+
+ OVR_DEBUG_STATEMENT(_CrtDumpMemoryLeaks());
+ return exitCode;
+}
diff --git a/Samples/CommonSrc/Platform/Win32_Platform.h b/Samples/CommonSrc/Platform/Win32_Platform.h
index 5d40861..6081968 100644
--- a/Samples/CommonSrc/Platform/Win32_Platform.h
+++ b/Samples/CommonSrc/Platform/Win32_Platform.h
@@ -1,101 +1,101 @@
-/************************************************************************************
-
-Filename : Win32_Platform.h
-Content : Win32 implementation of Platform app infrastructure
-Created : September 6, 2012
-Authors : Andrew Reisse
-
-Copyright : Copyright 2012 Oculus VR, Inc. All Rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-************************************************************************************/
-
-#ifndef OVR_Win32_Platform_h
-#define OVR_Win32_Platform_h
-
-#include "Platform.h"
-#include <windows.h>
-
-
-namespace OVR { namespace Render {
- class RenderDevice;
- struct DisplayId;
-}}
-
-namespace OVR { namespace Platform { namespace Win32 {
-
-class PlatformCore : public Platform::PlatformCore
-{
- HWND hWnd;
- HINSTANCE hInstance;
- bool Quit;
- int ExitCode;
- int Width, Height;
-
- MouseMode MMode;
- POINT WindowCenter; // In desktop coordinates
- HCURSOR Cursor;
- int Modifiers;
- String WindowTitle;
-
- // Win32 static function that delegates to WindowProc member function.
- static LRESULT CALLBACK systemWindowProc(HWND window, UINT msg, WPARAM wp, LPARAM lp);
-
- LRESULT WindowProc(UINT msg, WPARAM wp, LPARAM lp);
-
-public:
- PlatformCore(Application* app, HINSTANCE hinst);
- ~PlatformCore();
-
- bool SetupWindow(int w, int h);
- void DestroyWindow();
- void ShowWindow(bool visible);
- void Exit(int exitcode) { Quit = 1; ExitCode = exitcode; }
-
- RenderDevice* SetupGraphics(const SetupGraphicsDeviceSet& setupGraphicsDesc,
- const char* type,
- const Render::RendererParams& rp);
-
- void SetMouseMode(MouseMode mm);
- void GetWindowSize(int* w, int* h) const;
-
- void SetWindowTitle(const char*title);
- void PlayMusicFile(const char *fileName);
- int GetDisplayCount();
- Render::DisplayId GetDisplay(int screen);
-
- int Run();
-};
-
-
-// Win32 key conversion helper.
-KeyCode MapVKToKeyCode(unsigned vk);
-
-}}}
-
-
-// OVR_PLATFORM_APP_ARGS specifies the Application class to use for startup,
-// providing it with startup arguments.
-#define OVR_PLATFORM_APP_ARGS(AppClass, args) \
- OVR::Platform::Application* OVR::Platform::Application::CreateApplication() \
- { OVR::System::Init(OVR::Log::ConfigureDefaultLog(OVR::LogMask_All)); \
- return new AppClass args; } \
- void OVR::Platform::Application::DestroyApplication(OVR::Platform::Application* app) \
- { OVR::Platform::PlatformCore* platform = app->pPlatform; \
- delete app; delete platform; OVR::System::Destroy(); };
-
-// OVR_PLATFORM_APP_ARGS specifies the Application startup class with no args.
-#define OVR_PLATFORM_APP(AppClass) OVR_PLATFORM_APP_ARGS(AppClass, ())
-
-#endif // OVR_Win32_Platform_h
+/************************************************************************************
+
+Filename : Win32_Platform.h
+Content : Win32 implementation of Platform app infrastructure
+Created : September 6, 2012
+Authors : Andrew Reisse
+
+Copyright : Copyright 2012 Oculus VR, Inc. All Rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************************/
+
+#ifndef OVR_Win32_Platform_h
+#define OVR_Win32_Platform_h
+
+#include "Platform.h"
+#include <windows.h>
+
+
+namespace OVR { namespace Render {
+ class RenderDevice;
+ struct DisplayId;
+}}
+
+namespace OVR { namespace Platform { namespace Win32 {
+
+class PlatformCore : public Platform::PlatformCore
+{
+ HWND hWnd;
+ HINSTANCE hInstance;
+ bool Quit;
+ int ExitCode;
+ int Width, Height;
+
+ MouseMode MMode;
+ POINT WindowCenter; // In desktop coordinates
+ HCURSOR Cursor;
+ int Modifiers;
+ String WindowTitle;
+
+ // Win32 static function that delegates to WindowProc member function.
+ static LRESULT CALLBACK systemWindowProc(HWND window, UINT msg, WPARAM wp, LPARAM lp);
+
+ LRESULT WindowProc(UINT msg, WPARAM wp, LPARAM lp);
+
+public:
+ PlatformCore(Application* app, HINSTANCE hinst);
+ ~PlatformCore();
+
+ bool SetupWindow(int w, int h);
+ void DestroyWindow();
+ void ShowWindow(bool visible);
+ void Exit(int exitcode) { Quit = 1; ExitCode = exitcode; }
+
+ RenderDevice* SetupGraphics(const SetupGraphicsDeviceSet& setupGraphicsDesc,
+ const char* type,
+ const Render::RendererParams& rp);
+
+ void SetMouseMode(MouseMode mm);
+ void GetWindowSize(int* w, int* h) const;
+
+ void SetWindowTitle(const char*title);
+ void PlayMusicFile(const char *fileName);
+ int GetDisplayCount();
+ Render::DisplayId GetDisplay(int screen);
+
+ int Run();
+};
+
+
+// Win32 key conversion helper.
+KeyCode MapVKToKeyCode(unsigned vk);
+
+}}}
+
+
+// OVR_PLATFORM_APP_ARGS specifies the Application class to use for startup,
+// providing it with startup arguments.
+#define OVR_PLATFORM_APP_ARGS(AppClass, args) \
+ OVR::Platform::Application* OVR::Platform::Application::CreateApplication() \
+ { OVR::System::Init(OVR::Log::ConfigureDefaultLog(OVR::LogMask_All)); \
+ return new AppClass args; } \
+ void OVR::Platform::Application::DestroyApplication(OVR::Platform::Application* app) \
+ { OVR::Platform::PlatformCore* platform = app->pPlatform; \
+ delete app; delete platform; OVR::System::Destroy(); };
+
+// OVR_PLATFORM_APP_ARGS specifies the Application startup class with no args.
+#define OVR_PLATFORM_APP(AppClass) OVR_PLATFORM_APP_ARGS(AppClass, ())
+
+#endif // OVR_Win32_Platform_h
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-24 07:31:58 +0000