SDK 0.2.2

1 files changed, 861 insertions, 0 deletions

diff --git a/Samples/OculusRoomTiny/OSX_OculusRoomTiny.mm b/Samples/OculusRoomTiny/OSX_OculusRoomTiny.mm
new file mode 100644
index 0000000..0a59afd
--- /dev/null
+++ b/Samples/OculusRoomTiny/OSX_OculusRoomTiny.mm
@@ -0,0 +1,861 @@
+/************************************************************************************

+ 

+ Filename    :   OSX_OculusRoomTiny.mm

+ Content     :   Simplest possible first-person view test application for Oculus Rift

+ Created     :   May 7, 2013

+ Authors     :   Michael Antonov, Andrew Reisse, Artem Bolgar

+ 

+ Copyright   :   Copyright 2013 Oculus, 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.

+ 

+ *************************************************************************************/

+

+#import "OSX_OculusRoomTiny.h"

+#include "RenderTiny_GL_Device.h"

+

+#include "Kernel/OVR_KeyCodes.h"

+

+using namespace OVR;

+

+//-------------------------------------------------------------------------------------

+// ***** OculusRoomTiny Class

+

+// Static pApp simplifies routing the window function.

+OculusRoomTinyApp* OculusRoomTinyApp::pApp = 0;

+

+

+OculusRoomTinyApp::OculusRoomTinyApp(OVRApp* nsapp)

+    : pRender(0),

+    LastUpdate(0),

+    NsApp(nsapp),

+    Quit(0),

+

+    // Initial location

+    EyePos(0.0f, 1.6f, -5.0f),

+    EyeYaw(YawInitial), EyePitch(0), EyeRoll(0),

+    LastSensorYaw(0),

+    SConfig(),

+    PostProcess(PostProcess_Distortion),

+    ShiftDown(false),

+    ControlDown(false)

+{

+    pApp = this;

+    

+    Width  = 1280;

+    Height = 800;

+    

+    StartupTicks = OVR::Timer::GetTicks();

+    

+    MoveForward   = MoveBack = MoveLeft = MoveRight = 0;

+}

+

+OculusRoomTinyApp::~OculusRoomTinyApp()

+{

+	RemoveHandlerFromDevices();

+    pSensor.Clear();

+    pHMD.Clear();

+    destroyWindow();

+    pApp = 0;

+}

+

+

+int OculusRoomTinyApp::OnStartup(const char* args)

+{

+    OVR_UNUSED(args);

+    

+    

+    // *** Oculus HMD & Sensor Initialization

+    

+    // Create DeviceManager and first available HMDDevice from it.

+    // Sensor object is created from the HMD, to ensure that it is on the

+    // correct device.

+    

+    pManager = *DeviceManager::Create();

+    

+	// We'll handle it's messages in this case.

+	pManager->SetMessageHandler(this);

+    

+    CFOptionFlags detectionResult;

+    const char* detectionMessage;

+    

+    do

+    {

+        // Release Sensor/HMD in case this is a retry.

+        pSensor.Clear();

+        pHMD.Clear();

+        RenderParams.MonitorName.Clear();

+        

+        pHMD  = *pManager->EnumerateDevices<HMDDevice>().CreateDevice();

+        if (pHMD)

+        {

+            pSensor = *pHMD->GetSensor();

+            

+            // This will initialize HMDInfo with information about configured IPD,

+            // screen size and other variables needed for correct projection.

+            // We pass HMD DisplayDeviceName into the renderer to select the

+            // correct monitor in full-screen mode.

+            if (pHMD->GetDeviceInfo(&HMDInfo))

+            {

+                RenderParams.MonitorName = HMDInfo.DisplayDeviceName;

+                RenderParams.DisplayId = HMDInfo.DisplayId;

+                SConfig.SetHMDInfo(HMDInfo);

+            }

+        }

+        else

+        {

+            // If we didn't detect an HMD, try to create the sensor directly.

+            // This is useful for debugging sensor interaction; it is not needed in

+            // a shipping app.

+            pSensor = *pManager->EnumerateDevices<SensorDevice>().CreateDevice();

+        }

+        

+        

+        // If there was a problem detecting the Rift, display appropriate message.

+        detectionResult  = kCFUserNotificationAlternateResponse;

+        

+        if (!pHMD && !pSensor)

+            detectionMessage = "Oculus Rift not detected.";

+        else if (!pHMD)

+            detectionMessage = "Oculus Sensor detected; HMD Display not detected.";

+        else if (!pSensor)

+            detectionMessage = "Oculus HMD Display detected; Sensor not detected.";

+        else if (HMDInfo.DisplayDeviceName[0] == '\0')

+            detectionMessage = "Oculus Sensor detected; HMD display EDID not detected.";

+        else

+            detectionMessage = 0;

+        

+        if (detectionMessage)

+        {

+            String messageText(detectionMessage);

+            messageText += "\n\n"

+            "Press 'Try Again' to run retry detection.\n"

+            "Press 'Continue' to run full-screen anyway.";

+            

+            CFStringRef headerStrRef  = CFStringCreateWithCString(NULL, "Oculus Rift Detection", kCFStringEncodingMacRoman);

+            CFStringRef messageStrRef = CFStringCreateWithCString(NULL, messageText, kCFStringEncodingMacRoman);

+            

+            //launch the message box

+            CFUserNotificationDisplayAlert(0,

+                                           kCFUserNotificationNoteAlertLevel,

+                                           NULL, NULL, NULL,

+                                           headerStrRef, // header text

+                                           messageStrRef, // message text

+                                           CFSTR("Try again"), 

+                                           CFSTR("Continue"),

+                                           CFSTR("Cancel"),

+                                           &detectionResult);

+            

+            //Clean up the strings

+            CFRelease(headerStrRef);

+            CFRelease(messageStrRef);

+            

+            if (detectionResult == kCFUserNotificationCancelResponse ||

+                detectionResult == kCFUserNotificationOtherResponse)

+                return 1;

+        }

+        

+    } while (detectionResult != kCFUserNotificationAlternateResponse);

+    

+    

+    if (HMDInfo.HResolution > 0)

+    {

+        Width  = HMDInfo.HResolution;

+        Height = HMDInfo.VResolution;

+    }

+    

+    

+    if (!setupWindow())

+        return 1;

+    

+    if (pSensor)

+    {

+        // We need to attach sensor to SensorFusion object for it to receive

+        // body frame messages and update orientation. SFusion.GetOrientation()

+        // is used in OnIdle() to orient the view.

+        SFusion.AttachToSensor(pSensor);

+        SFusion.SetDelegateMessageHandler(this);

+		SFusion.SetPredictionEnabled(true);

+    }

+    

+    

+    // *** Initialize Rendering

+    

+    // Enable multi-sampling by default.

+    RenderParams.Multisample = 4;

+    RenderParams.Fullscreen  = false;//true; //?

+    

+    // Setup Graphics.

+    pRender = *OSX::RenderDevice::CreateDevice(RenderParams, (void*)View);

+    if (!pRender)

+        return 1;

+    

+    

+    // *** Configure Stereo settings.

+    

+    SConfig.SetFullViewport(Viewport(0,0, Width, Height));

+    SConfig.SetStereoMode(Stereo_LeftRight_Multipass);

+    

+    // Configure proper Distortion Fit.

+    // For 7" screen, fit to touch left side of the view, leaving a bit of invisible

+    // screen on the top (saves on rendering cost).

+    // For smaller screens (5.5"), fit to the top.

+    if (HMDInfo.HScreenSize > 0.0f)

+    {

+        if (HMDInfo.HScreenSize > 0.140f) // 7"

+            SConfig.SetDistortionFitPointVP(-1.0f, 0.0f);

+        else

+            SConfig.SetDistortionFitPointVP(0.0f, 1.0f);

+    }

+    

+    pRender->SetSceneRenderScale(SConfig.GetDistortionScale());

+    

+    SConfig.Set2DAreaFov(DegreeToRad(85.0f));

+    

+    

+    // *** Populate Room Scene

+    

+    // This creates lights and models.

+    PopulateRoomScene(&Scene, pRender);

+    

+    

+    LastUpdate = GetAppTime();

+    return 0;

+}

+

+void OculusRoomTinyApp::OnMessage(const Message& msg)

+{

+	if (msg.Type == Message_DeviceAdded && msg.pDevice == pManager)

+	{

+		LogText("DeviceManager reported device added.\n");

+	}

+	else if (msg.Type == Message_DeviceRemoved && msg.pDevice == pManager)

+	{

+		LogText("DeviceManager reported device removed.\n");

+	}

+	else if (msg.Type == Message_DeviceAdded && msg.pDevice == pSensor)

+	{

+		LogText("Sensor reported device added.\n");

+	}

+	else if (msg.Type == Message_DeviceRemoved && msg.pDevice == pSensor)

+	{

+		LogText("Sensor reported device removed.\n");

+	}

+}

+

+bool  OculusRoomTinyApp::setupWindow()

+{

+    NSRect winrect;

+    winrect.origin.x = 0;

+    winrect.origin.y = 1000;

+    winrect.size.width = Width;

+    winrect.size.height = Height;

+    NSWindow* win = [[NSWindow alloc] initWithContentRect:winrect styleMask:NSTitledWindowMask|NSClosableWindowMask backing:NSBackingStoreBuffered defer:NO];

+    

+    OVRView* view = [[OVRView alloc] initWithFrame:winrect];

+    [win setContentView:view];

+    [win setAcceptsMouseMovedEvents:YES];

+    [win setDelegate:view];

+    [view setApp:pApp];

+    Win = win;

+    View = view;

+

+    const char* title = "OculusRoomTiny";

+    [((NSWindow*)Win) setTitle:[[NSString alloc] initWithBytes:title length:strlen(title) encoding:NSUTF8StringEncoding]];

+    

+    [NSCursor hide];

+    [view warpMouseToCenter];

+    CGAssociateMouseAndMouseCursorPosition(false);

+

+    SetFullscreen(RenderParams, true);

+    return true;

+}

+

+void  OculusRoomTinyApp::destroyWindow()

+{

+    SetFullscreen(RenderParams, false);

+    [((NSWindow*)Win) close];

+}

+

+void OculusRoomTinyApp::OnMouseMove(int x, int y, int modifiers)

+{

+    OVR_UNUSED(modifiers);

+    

+    // Mouse motion here is always relative.

+    int         dx = x, dy = y;

+    const float maxPitch = ((3.1415f/2)*0.98f);

+    

+    // Apply to rotation. Subtract for right body frame rotation,

+    // since yaw rotation is positive CCW when looking down on XZ plane.

+    EyeYaw   -= (Sensitivity * dx)/ 360.0f;

+    

+    if (!pSensor)

+    {

+        EyePitch -= (Sensitivity * dy)/ 360.0f;

+        

+        if (EyePitch > maxPitch)

+            EyePitch = maxPitch;

+        if (EyePitch < -maxPitch)

+            EyePitch = -maxPitch;

+    }

+}

+

+

+void OculusRoomTinyApp::OnKey(unsigned vk, bool down)

+{

+    switch (vk)

+    {

+        case 'Q':

+            if (down && ControlDown)

+                Exit();;

+            break;

+        case Key_Escape:

+            if (!down)

+                Exit();

+            break;

+            

+            // Handle player movement keys.

+            // We just update movement state here, while the actual translation is done in OnIdle()

+            // based on time.

+        case 'W':      MoveForward = down ? (MoveForward | 1) : (MoveForward & ~1); break;

+        case 'S':      MoveBack    = down ? (MoveBack    | 1) : (MoveBack    & ~1); break;

+        case 'A':      MoveLeft    = down ? (MoveLeft    | 1) : (MoveLeft    & ~1); break;

+        case 'D':      MoveRight   = down ? (MoveRight   | 1) : (MoveRight   & ~1); break;

+        case Key_Up:    MoveForward = down ? (MoveForward | 2) : (MoveForward & ~2); break;

+        case Key_Down:  MoveBack    = down ? (MoveBack    | 2) : (MoveBack    & ~2); break;

+            

+        case 'R':

+            SFusion.Reset();

+            break;

+            

+        case 'P':

+            if (down)

+            {

+                // Toggle chromatic aberration correction on/off.

+                RenderDevice::PostProcessShader shader = pRender->GetPostProcessShader();

+                

+                if (shader == RenderDevice::PostProcessShader_Distortion)

+                {

+                    pRender->SetPostProcessShader(RenderDevice::PostProcessShader_DistortionAndChromAb);

+                }

+                else if (shader == RenderDevice::PostProcessShader_DistortionAndChromAb)

+                {

+                    pRender->SetPostProcessShader(RenderDevice::PostProcessShader_Distortion);

+                }

+                else

+                    OVR_ASSERT(false);

+            }

+            break;

+            

+            // Switch rendering modes/distortion.

+        case Key_F1:

+            SConfig.SetStereoMode(Stereo_None);

+            PostProcess = PostProcess_None;

+            break;

+        case Key_F2:

+            SConfig.SetStereoMode(Stereo_LeftRight_Multipass);

+            PostProcess = PostProcess_None;

+            break;

+        case Key_F3:

+            SConfig.SetStereoMode(Stereo_LeftRight_Multipass);

+            PostProcess = PostProcess_Distortion;

+            break;

+

+            // Stereo IPD adjustments, in meter (default IPD is 64mm).

+        case '+':

+        case '=':

+            if (down)

+                SConfig.SetIPD(SConfig.GetIPD() + 0.0005f * (ShiftDown ? 5.0f : 1.0f));

+            break;

+        case '-':

+        case '_':

+            if (down)

+                SConfig.SetIPD(SConfig.GetIPD() - 0.0005f * (ShiftDown ? 5.0f : 1.0f));

+            break;

+            

+            // Holding down Shift key accelerates adjustment velocity.

+        case Key_Shift:

+            ShiftDown = down;

+            break;

+        case Key_Meta:

+            ControlDown = down;

+            break;

+    }

+}

+

+

+void OculusRoomTinyApp::OnIdle()

+{

+    double curtime = GetAppTime();

+    float  dt      = float(curtime - LastUpdate);

+    LastUpdate     = curtime;

+    

+    

+    // Handle Sensor motion.

+    // We extract Yaw, Pitch, Roll instead of directly using the orientation

+    // to allow "additional" yaw manipulation with mouse/controller.

+    if (pSensor)

+    {

+        Quatf    hmdOrient = SFusion.GetOrientation();

+        float    yaw = 0.0f;

+        

+        hmdOrient.GetEulerAngles<Axis_Y, Axis_X, Axis_Z>(&yaw, &EyePitch, &EyeRoll);

+        

+        EyeYaw += (yaw - LastSensorYaw);

+        LastSensorYaw = yaw;

+    }

+    

+    

+    if (!pSensor)

+    {

+        const float maxPitch = ((3.1415f/2)*0.98f);

+        if (EyePitch > maxPitch)

+            EyePitch = maxPitch;

+        if (EyePitch < -maxPitch)

+            EyePitch = -maxPitch;

+    }

+    

+    // Handle keyboard movement.

+    // This translates EyePos based on Yaw vector direction and keys pressed.

+    // Note that Pitch and Roll do not affect movement (they only affect view).

+    if (MoveForward || MoveBack || MoveLeft || MoveRight)

+    {

+        Vector3f localMoveVector(0,0,0);

+        Matrix4f yawRotate = Matrix4f::RotationY(EyeYaw);

+        

+        if (MoveForward)

+            localMoveVector = ForwardVector;

+        else if (MoveBack)

+            localMoveVector = -ForwardVector;

+        

+        if (MoveRight)

+            localMoveVector += RightVector;

+        else if (MoveLeft)

+            localMoveVector -= RightVector;

+        

+        // Normalize vector so we don't move faster diagonally.

+        localMoveVector.Normalize();

+        Vector3f orientationVector = yawRotate.Transform(localMoveVector);

+        orientationVector *= MoveSpeed * dt * (ShiftDown ? 3.0f : 1.0f);

+        

+        EyePos += orientationVector;

+    }

+    

+    // Rotate and position View Camera, using YawPitchRoll in BodyFrame coordinates.

+    //

+    Matrix4f rollPitchYaw = Matrix4f::RotationY(EyeYaw) * Matrix4f::RotationX(EyePitch) *

+    Matrix4f::RotationZ(EyeRoll);

+    Vector3f up      = rollPitchYaw.Transform(UpVector);

+    Vector3f forward = rollPitchYaw.Transform(ForwardVector);

+    

+    

+    // Minimal head modelling.

+    float headBaseToEyeHeight     = 0.15f;  // Vertical height of eye from base of head

+    float headBaseToEyeProtrusion = 0.09f;  // Distance forward of eye from base of head

+    

+    Vector3f eyeCenterInHeadFrame(0.0f, headBaseToEyeHeight, -headBaseToEyeProtrusion);

+    Vector3f shiftedEyePos = EyePos + rollPitchYaw.Transform(eyeCenterInHeadFrame);

+    shiftedEyePos.y -= eyeCenterInHeadFrame.y; // Bring the head back down to original height

+    

+    ViewMat = Matrix4f::LookAtRH(shiftedEyePos, shiftedEyePos + forward, up);

+    

+    // This is what transformation would be without head modeling.

+    // View = Matrix4f::LookAtRH(EyePos, EyePos + forward, up);

+    

+    switch(SConfig.GetStereoMode())

+    {

+        case Stereo_None:

+            Render(SConfig.GetEyeRenderParams(StereoEye_Center));

+            break;

+            

+        case Stereo_LeftRight_Multipass:

+            Render(SConfig.GetEyeRenderParams(StereoEye_Left));

+            Render(SConfig.GetEyeRenderParams(StereoEye_Right));

+            break;

+    }

+    

+    pRender->Present();

+    // Force GPU to flush the scene, resulting in the lowest possible latency.

+    pRender->ForceFlushGPU();

+}

+

+

+// Render the scene for one eye.

+void OculusRoomTinyApp::Render(const StereoEyeParams& stereo)

+{

+    pRender->BeginScene(PostProcess);

+    

+    // Apply Viewport/Projection for the eye.

+    pRender->ApplyStereoParams(stereo);    

+    pRender->Clear();

+    pRender->SetDepthMode(true, true);

+    

+    Scene.Render(pRender, stereo.ViewAdjust * ViewMat);

+    

+    pRender->FinishScene();

+}

+

+void OculusRoomTinyApp::Exit()

+{

+    [NsApp stop:nil];

+    Quit = true;

+}

+

+bool OculusRoomTinyApp::SetFullscreen(const RenderTiny::RendererParams& rp, int fullscreen)

+{

+    if (fullscreen == RenderTiny::Display_Window)

+        [(OVRView*)View exitFullScreenModeWithOptions:nil];

+    else

+    {

+        NSScreen* usescreen = [NSScreen mainScreen];

+        NSArray* screens = [NSScreen screens];

+        for (int i = 0; i < [screens count]; i++)

+        {

+            NSScreen* s = (NSScreen*)[screens objectAtIndex:i];

+            CGDirectDisplayID disp = [OVRView displayFromScreen:s];

+            

+            if (disp == rp.DisplayId)

+                usescreen = s;

+        }

+        

+        [(OVRView*)View enterFullScreenMode:usescreen withOptions:nil];

+    }

+    

+    if (pRender)

+        pRender->SetFullscreen((RenderTiny::DisplayMode)fullscreen);

+    return 1;

+}

+

+//-------------------------------------------------------------------------------------

+// ***** OS X-Specific Logic

+

+@implementation OVRApp

+

+- (void)dealloc

+{

+    [super dealloc];

+}

+

+- (void)run

+{

+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];

+    _running = YES;

+    OculusRoomTinyApp* app;

+   

+    // Initializes LibOVR. This LogMask_All enables maximum logging.

+    // Custom allocator can also be specified here.

+    OVR::System::Init(OVR::Log::ConfigureDefaultLog(OVR::LogMask_All));

+   

+    int exitCode = 0;

+    do

+    {

+        {

+            using namespace OVR;

+            

+            // CreateApplication must be the first call since it does OVR::System::Initialize.

+            app = new OculusRoomTinyApp(self);

+            // The platform attached to an app will be deleted by DestroyApplication.

+            

+            [self setApp:app];

+            

+            const char* argv[] = {"OVRApp"};

+            exitCode = app->OnStartup(argv[0]);

+            if (exitCode)

+                break;

+        }

+        [self finishLaunching];

+        [pool drain];

+

+        while ([self isRunning])

+        {

+            pool = [[NSAutoreleasePool alloc] init];

+            NSEvent* event = [self nextEventMatchingMask:NSAnyEventMask untilDate:nil inMode:NSDefaultRunLoopMode dequeue:YES];

+            if (event)

+            {

+                [self sendEvent:event];

+            }

+            _App->OnIdle();

+            [pool drain];

+        }

+    } while(0);

+    

+    delete app;

+

+    // No OVR functions involving memory are allowed after this.

+    OVR::System::Destroy();

+}

+

+@end

+

+static int KeyMap[][2] =

+{

+    { NSDeleteFunctionKey,      OVR::Key_Delete },

+    { '\t',       OVR::Key_Tab },

+    { '\n',    OVR::Key_Return },

+    { NSPauseFunctionKey,     OVR::Key_Pause },

+    { 27,      OVR::Key_Escape },

+    { 127,     OVR::Key_Backspace },

+    { ' ',     OVR::Key_Space },

+    { NSPageUpFunctionKey,     OVR::Key_PageUp },

+    { NSPageDownFunctionKey,      OVR::Key_PageDown },

+    { NSNextFunctionKey,      OVR::Key_PageDown },

+    { NSEndFunctionKey,       OVR::Key_End },

+    { NSHomeFunctionKey,      OVR::Key_Home },

+    { NSLeftArrowFunctionKey,      OVR::Key_Left },

+    { NSUpArrowFunctionKey,        OVR::Key_Up },

+    { NSRightArrowFunctionKey,     OVR::Key_Right },

+    { NSDownArrowFunctionKey,      OVR::Key_Down },

+    { NSInsertFunctionKey,    OVR::Key_Insert },

+    { NSDeleteFunctionKey,    OVR::Key_Delete },

+    { NSHelpFunctionKey,      OVR::Key_Insert },

+};

+

+

+static KeyCode MapToKeyCode(wchar_t vk)

+{

+    unsigned key = Key_None;

+    

+    if ((vk >= 'a') && (vk <= 'z'))

+    {

+        key = vk - 'a' + Key_A;

+    }

+    else if ((vk >= ' ') && (vk <= '~'))

+    {

+        key = vk;

+    }

+    else if ((vk >= '0') && (vk <= '9'))

+    {

+        key = vk - '0' + Key_Num0;

+    }

+    else if ((vk >= NSF1FunctionKey) && (vk <= NSF15FunctionKey))

+    {

+        key = vk - NSF1FunctionKey + 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;

+}

+

+@implementation OVRView

+

+-(BOOL) acceptsFirstResponder

+{

+    return YES;

+}

+-(BOOL) acceptsFirstMouse:(NSEvent *)ev

+{

+    return YES;

+}

+

++(CGDirectDisplayID) displayFromScreen:(NSScreen *)s

+{

+    NSNumber* didref = (NSNumber*)[[s deviceDescription] objectForKey:@"NSScreenNumber"];

+    CGDirectDisplayID disp = (CGDirectDisplayID)[didref longValue];

+    return disp;

+}

+

+-(void) warpMouseToCenter

+{

+    NSPoint w;

+    w.x = _App->GetWidth()/2.0f;

+    w.y = _App->GetHeight()/2.0f;

+    w = [[self window] convertBaseToScreen:w];

+    CGDirectDisplayID disp = [OVRView displayFromScreen:[[self window] screen]];

+    CGPoint p = {w.x, CGDisplayPixelsHigh(disp)-w.y};

+    CGDisplayMoveCursorToPoint(disp, p);

+}

+

+-(void) keyDown:(NSEvent*)ev

+{

+    NSString* chars = [ev charactersIgnoringModifiers];

+    if ([chars length])

+    {

+        wchar_t ch = [chars characterAtIndex:0];

+        OVR::KeyCode key = MapToKeyCode(ch);

+        _App->OnKey(key, true);

+    }

+}

+-(void) keyUp:(NSEvent*)ev

+{

+    NSString* chars = [ev charactersIgnoringModifiers];

+    if ([chars length])

+    {

+        wchar_t ch = [chars characterAtIndex:0];

+        OVR::KeyCode key = MapToKeyCode(ch);

+        _App->OnKey(key, false);

+        

+    }

+}

+

+

+-(void)flagsChanged:(NSEvent *)ev

+{

+    static const OVR::KeyCode ModifierKeys[] = {OVR::Key_None, OVR::Key_Shift, OVR::Key_Control, OVR::Key_Alt, OVR::Key_Meta};

+

+    unsigned long cmods = [ev modifierFlags];

+    if ((cmods & 0xffff0000) != _Modifiers)

+    {

+        uint32_t mods = 0;

+        if (cmods & NSShiftKeyMask)

+            mods |= 0x01;

+        if (cmods & NSControlKeyMask)

+            mods |= 0x02;

+        if (cmods & NSAlternateKeyMask)

+            mods |= 0x04;

+        if (cmods & NSCommandKeyMask)

+            mods |= 0x08;

+

+        for (int i = 1; i <= 4; i++)

+        {

+            unsigned long m = (1 << (16+i));

+            if ((cmods & m) != (_Modifiers & m))

+            {

+                if (cmods & m)

+                    _App->OnKey(ModifierKeys[i], true);

+                else

+                    _App->OnKey(ModifierKeys[i], false);

+            }

+        }

+        _Modifiers = cmods & 0xffff0000;

+    }

+}

+

+-(void)ProcessMouse:(NSEvent*)ev

+{

+    switch ([ev type])

+    {

+        case NSLeftMouseDragged:

+        case NSRightMouseDragged:

+        case NSOtherMouseDragged:

+        case NSMouseMoved:

+        {

+            int dx = [ev deltaX];

+            int dy = [ev deltaY];

+            

+            if (dx != 0 || dy != 0)

+            {

+                _App->OnMouseMove(dx, dy, 0);

+                [self warpMouseToCenter];

+            }

+        }

+        break;

+        case NSLeftMouseDown:

+        case NSRightMouseDown:

+        case NSOtherMouseDown:

+            break;

+    }

+}

+

+-(void) mouseMoved:(NSEvent*)ev

+{

+    [self ProcessMouse:ev];

+}

+-(void) mouseDragged:(NSEvent*)ev

+{

+    [self ProcessMouse:ev];

+}

+

+-(void) mouseDown:(NSEvent*)ev

+{

+    [self warpMouseToCenter];

+    CGAssociateMouseAndMouseCursorPosition(false);

+    [NSCursor hide];

+}

+

+//-(void)

+

+-(id) initWithFrame:(NSRect)frameRect

+{

+    NSOpenGLPixelFormatAttribute attr[] =

+    {NSOpenGLPFAWindow, NSOpenGLPFADoubleBuffer, NSOpenGLPFADepthSize, 24, nil};

+        

+    NSOpenGLPixelFormat *pf = [[[NSOpenGLPixelFormat alloc] initWithAttributes:attr] autorelease];

+    

+    self = [super initWithFrame:frameRect pixelFormat:pf];

+    GLint swap = 0;

+    [[self openGLContext] setValues:&swap forParameter:NSOpenGLCPSwapInterval];

+    //[self setWantsBestResolutionOpenGLSurface:YES];

+    return self;

+}

+

+-(BOOL)windowShouldClose:(id)sender

+{

+    _App->Exit();

+    return 1;

+}

+

+@end

+

+// GL OSX-specific logic

+namespace OSX {

+

+    RenderDevice::RenderDevice(const RendererParams& p, void* osview, void* context)

+        : GL::RenderDevice(p), Context(context)

+    {

+        OVRView* view = (OVRView*)osview;

+        NSRect bounds = [view bounds];

+        WindowWidth = bounds.size.width;

+        WindowHeight= bounds.size.height;

+        

+    }

+

+    RenderDevice* RenderDevice::CreateDevice(const RendererParams& rp, void* osview)

+    {

+        OVRView* view = (OVRView*)osview;

+        NSOpenGLContext *context = [view openGLContext];

+        if (!context)

+            return NULL;

+

+        [context makeCurrentContext];

+        [[view window] makeKeyAndOrderFront:nil];

+

+        return new OSX::RenderDevice(rp, osview, context);

+    }

+

+    void RenderDevice::Present()

+    {

+        NSOpenGLContext *context = (NSOpenGLContext*)Context;

+        [context flushBuffer];

+    }

+

+    void RenderDevice::Shutdown()

+    {

+        Context = NULL;

+    }

+

+    bool RenderDevice::SetFullscreen(DisplayMode fullscreen)

+    {

+        Params.Fullscreen = fullscreen;

+        return 1;

+    }

+    

+}

+

+

+int main(int argc, char *argv[])

+{

+    NSApplication* nsapp = [OVRApp sharedApplication];

+    [nsapp run];

+    return 0;

+}

+