OVR_Common_HMDDevice.cpp

Go to the documentation of this file.

/************************************************************************************

Filename    :   OVR_Common_HMDDevice.cpp
Content     :   
Created     :
Authors     :

Copyright   :   Copyright 2014 Oculus VR, Inc. All Rights reserved.

Licensed under the Oculus VR Rift SDK License Version 3.1 (the "License"); 
you may not use the Oculus VR Rift SDK except in compliance with the License, 
which is provided at the time of installation or download, or which 
otherwise accompanies this software in either electronic or hard copy form.

You may obtain a copy of the License at

http://www.oculusvr.com/licenses/LICENSE-3.1 

Unless required by applicable law or agreed to in writing, the Oculus VR SDK 
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.

*************************************************************************************/

// Should be #included from the relevant OVR_YourPlatformHere_HMDDevice.cpp

#include "Kernel/OVR_Alg.h"

//-------------------------------------------------------------------------------------
// ***** HMDDeviceCreateDesc

DeviceBase* HMDDeviceCreateDesc::NewDeviceInstance()
{
    return new HMDDevice(this);
}

void  HMDDeviceCreateDesc::SetScreenParameters(int x, int y,
                              int hres, int vres,
                              float hsize, float vsize,
                              float vCenterFromTopInMeters, float lensSeparationInMeters)
{
    Desktop.X = x;
    Desktop.Y = y;
    ResolutionInPixels = Sizei(hres, vres);
    ScreenSizeInMeters = Sizef(hsize, vsize);
    VCenterFromTopInMeters = vCenterFromTopInMeters;
    LensSeparationInMeters = lensSeparationInMeters;

    Contents |= Contents_Screen;
}


void HMDDeviceCreateDesc::SetDistortion(const float* dks)
{
    for (int i = 0; i < 4; i++)
        DistortionK[i] = dks[i];
    // TODO: add DistortionEqn
    Contents |= Contents_Distortion;
}

HmdTypeEnum HMDDeviceCreateDesc::GetHmdType() const
{
    // Determine the HMD model
    // The closest thing we have to a dependable model indicator are the 
    // the screen characteristics.  Additionally we can check the sensor
    // (on attached devices) to further refine our guess
    HmdTypeEnum hmdType = HmdType_Unknown;

    if ( ResolutionInPixels.w == 1280 )
    {
        if ( ScreenSizeInMeters.w > 0.1497f && ScreenSizeInMeters.w < 0.1498f )
            hmdType = HmdType_DK1;
        else
            hmdType = HmdType_DKProto;
    }
    else if ( ResolutionInPixels.w == 1920 )
    {
        // DKHD protoypes, all 1920x1080
        if ( ScreenSizeInMeters.w > 0.1209f && ScreenSizeInMeters.w < 0.1210f )
        {
            // Screen size 0.12096 x 0.06804
            hmdType = HmdType_DKHDProto;
        }
        else if ( ScreenSizeInMeters.w > 0.1257f && ScreenSizeInMeters.w < 0.1258f )
        {
            // Screen size 0.125 x 0.071
            // Could be a HmdType_DKHDProto566Mi, HmdType_CrystalCoveProto, or DK2
            // - most likely the latter.
            hmdType = HmdType_DK2;

            // If available, check the sensor to determine exactly which variant this is
            if (pDevice)
            {
                Ptr<SensorDevice> sensor = *((HMDDevice*)pDevice)->GetSensor();
                
                SensorInfo sinfo;
                if (sensor && sensor->GetDeviceInfo(&sinfo))
                {
                    if (sinfo.ProductId == 1)
                    {
                        hmdType = HmdType_DKHDProto566Mi;
                    }
                    else
                    {   // Crystal Cove uses 0.# firmware, DK2 uses 1.#
                        int firm_major = Alg::DecodeBCD((sinfo.Version >> 8) & 0x00ff);
                        int firm_minor = Alg::DecodeBCD(sinfo.Version & 0xff);
                        OVR_UNUSED(firm_minor);
                        if (firm_major == 0)
                            hmdType = HmdType_CrystalCoveProto;
                        else
                            hmdType = HmdType_DK2;
                    }
                }
            }
        }
        else if (ScreenSizeInMeters.w > 0.1295f && ScreenSizeInMeters.w < 0.1297f)
        {
            // Screen size 0.1296 x 0.0729
            hmdType = HmdType_DKHD2Proto;
        }
    }
    
    OVR_ASSERT( hmdType != HmdType_Unknown );
    return hmdType;
}

bool HMDDeviceCreateDesc::GetDeviceInfo(DeviceInfo* info) const
{
    if ((info->InfoClassType != Device_HMD) &&
        (info->InfoClassType != Device_None))
        return false;

    HmdTypeEnum hmdType = GetHmdType();
    char const* deviceName = "Oculus HMD";
    switch (hmdType)
    {
        case HmdType_DKProto:          deviceName = "Oculus Rift Prototype";    break;
        case HmdType_DK1:              deviceName = "Oculus Rift DK1";          break;
        case HmdType_DKHDProto:        deviceName = "Oculus Rift DKHD";         break;
        case HmdType_DKHD2Proto:       deviceName = "Oculus Rift DKHD2";        break;
        case HmdType_DKHDProto566Mi:   deviceName = "Oculus Rift DKHD 566 Mi";  break;
        case HmdType_CrystalCoveProto: deviceName = "Oculus Rift Crystal Cove"; break;
        case HmdType_DK2:              deviceName = "Oculus Rift DK2";          break;
        default:                       deviceName = "Oculus HMD";               break;
    }
   
    info->ProductName = deviceName;
    info->Manufacturer = "Oculus VR";
    info->Type    = Device_HMD;
    info->Version = 0;

    // Display detection.
    if (info->InfoClassType == Device_HMD)
    {
        HMDInfo* hmdInfo = static_cast<HMDInfo*>(info);

        hmdInfo->HmdType                = hmdType;
        hmdInfo->DesktopX               = Desktop.X;
        hmdInfo->DesktopY               = Desktop.Y;
        hmdInfo->ResolutionInPixels     = ResolutionInPixels;                
        hmdInfo->ScreenSizeInMeters     = ScreenSizeInMeters;        // Includes ScreenGapSizeInMeters
        hmdInfo->ScreenGapSizeInMeters  = 0.0f;
        hmdInfo->CenterFromTopInMeters  = VCenterFromTopInMeters;
        hmdInfo->LensSeparationInMeters = LensSeparationInMeters;
        // TODO: any other information we get from the hardware itself should be added to this list

        switch ( hmdInfo->HmdType )
        {
        case HmdType_DKProto:
            // WARNING - estimated.
            hmdInfo->Shutter.Type                             = HmdShutter_RollingTopToBottom;
            hmdInfo->Shutter.VsyncToNextVsync                 = ( 1.0f / 60.0f );
            hmdInfo->Shutter.VsyncToFirstScanline             = 0.000052f;
            hmdInfo->Shutter.FirstScanlineToLastScanline      = 0.016580f;
            hmdInfo->Shutter.PixelSettleTime                  = 0.015f; // estimated.
            hmdInfo->Shutter.PixelPersistence                 = hmdInfo->Shutter.VsyncToNextVsync; // Full persistence
            break;
        case HmdType_DK1:
            // Data from specs.
            hmdInfo->Shutter.Type                             = HmdShutter_RollingTopToBottom;
            hmdInfo->Shutter.VsyncToNextVsync                 = ( 1.0f / 60.0f );
            hmdInfo->Shutter.VsyncToFirstScanline             = 0.00018226f;
            hmdInfo->Shutter.FirstScanlineToLastScanline      = 0.01620089f;
            hmdInfo->Shutter.PixelSettleTime                  = 0.017f; // estimated.
            hmdInfo->Shutter.PixelPersistence                 = hmdInfo->Shutter.VsyncToNextVsync; // Full persistence
            break;
        case HmdType_DKHDProto:
            // Data from specs.
            hmdInfo->Shutter.Type                             = HmdShutter_RollingRightToLeft;
            hmdInfo->Shutter.VsyncToNextVsync                 = ( 1.0f / 60.0f );
            hmdInfo->Shutter.VsyncToFirstScanline             = 0.0000859f;
            hmdInfo->Shutter.FirstScanlineToLastScanline      = 0.0164948f;
            hmdInfo->Shutter.PixelSettleTime                  = 0.012f; // estimated.
            hmdInfo->Shutter.PixelPersistence                 = hmdInfo->Shutter.VsyncToNextVsync; // Full persistence
            break;
        case HmdType_DKHD2Proto:
            // Data from specs.
            hmdInfo->Shutter.Type                             = HmdShutter_RollingRightToLeft;
            hmdInfo->Shutter.VsyncToNextVsync                 = ( 1.0f / 60.0f );
            hmdInfo->Shutter.VsyncToFirstScanline             = 0.000052f;
            hmdInfo->Shutter.FirstScanlineToLastScanline      = 0.016580f;
            hmdInfo->Shutter.PixelSettleTime                  = 0.015f; // estimated.
            hmdInfo->Shutter.PixelPersistence                 = hmdInfo->Shutter.VsyncToNextVsync; // Full persistence
            break;
        case HmdType_DKHDProto566Mi:
#if 0
            // Low-persistence global shutter
            hmdInfo->Shutter.Type                             = HmdShutter_Global;
            hmdInfo->Shutter.VsyncToNextVsync                 = ( 1.0f / 76.0f );
            hmdInfo->Shutter.VsyncToFirstScanline             = 0.0000273f + 0.0131033f;    // Global shutter - first visible scan line is actually the last!
            hmdInfo->Shutter.FirstScanlineToLastScanline      = 0.000f;                     // Global shutter - all visible at once.
            hmdInfo->Shutter.PixelSettleTime                  = 0.0f;                       // <100us
            hmdInfo->Shutter.PixelPersistence                 = 0.18f * hmdInfo->Shutter.VsyncToNextVsync;     // Confgurable - currently set to 18% of total frame.
#else
            // Low-persistence rolling shutter
            hmdInfo->Shutter.Type                             = HmdShutter_RollingRightToLeft;
            hmdInfo->Shutter.VsyncToNextVsync                 = ( 1.0f / 76.0f );
            hmdInfo->Shutter.VsyncToFirstScanline             = 0.0000273f;
            hmdInfo->Shutter.FirstScanlineToLastScanline      = 0.0131033f;
            hmdInfo->Shutter.PixelSettleTime                  = 0.0f;                       // <100us
            hmdInfo->Shutter.PixelPersistence                 = 0.18f * hmdInfo->Shutter.VsyncToNextVsync;     // Confgurable - currently set to 18% of total frame.
#endif
            break;
        case HmdType_CrystalCoveProto:
            // Low-persistence rolling shutter
            hmdInfo->Shutter.Type                             = HmdShutter_RollingRightToLeft;
            hmdInfo->Shutter.VsyncToNextVsync                 = ( 1.0f / 76.0f );
            hmdInfo->Shutter.VsyncToFirstScanline             = 0.0000273f;
            hmdInfo->Shutter.FirstScanlineToLastScanline      = 0.0131033f;
            hmdInfo->Shutter.PixelSettleTime                  = 0.0f;                       // <100us
            hmdInfo->Shutter.PixelPersistence                 = 0.18f * hmdInfo->Shutter.VsyncToNextVsync;     // Confgurable - currently set to 18% of total frame.
            break;
        case HmdType_DK2:
            // Low-persistence rolling shutter
            hmdInfo->Shutter.Type                             = HmdShutter_RollingRightToLeft;
            hmdInfo->Shutter.VsyncToNextVsync                 = ( 1.0f / 76.0f );
            hmdInfo->Shutter.VsyncToFirstScanline             = 0.0000273f;
            hmdInfo->Shutter.FirstScanlineToLastScanline      = 0.0131033f;
            hmdInfo->Shutter.PixelSettleTime                  = 0.0f;                       // <100us
            hmdInfo->Shutter.PixelPersistence                 = 0.18f * hmdInfo->Shutter.VsyncToNextVsync;     // Confgurable - currently set to 18% of total frame.
            break;
        default: OVR_ASSERT ( false ); break;
        }


        OVR_strcpy(hmdInfo->DisplayDeviceName, sizeof(hmdInfo->DisplayDeviceName),
                   DisplayDeviceName.ToCStr());
#if   defined(OVR_OS_WIN32)
        // Nothing special for Win32.
#elif defined(OVR_OS_MAC)
        hmdInfo->DisplayId = DisplayId;
#elif defined(OVR_OS_LINUX)
        hmdInfo->DisplayId = DisplayId;
#elif defined(OVR_OS_ANDROID)
        hmdInfo->DisplayId = DisplayId;
#else
#error Unknown platform
#endif

    }

    return true;
}





//-------------------------------------------------------------------------------------
// ***** HMDDevice

HMDDevice::HMDDevice(HMDDeviceCreateDesc* createDesc)
    : OVR::DeviceImpl<OVR::HMDDevice>(createDesc, 0)
{
}
HMDDevice::~HMDDevice()
{
}

bool HMDDevice::Initialize(DeviceBase* parent)
{
    pParent = parent;
    return true;
}
void HMDDevice::Shutdown()
{
    ProfileName.Clear();
    pCachedProfile.Clear();
    pParent.Clear();
}

Profile* HMDDevice::GetProfile()
{    
    // Loads and returns a cached profile based on this device and current user
    if (pCachedProfile == NULL)
    {
        ProfileManager* mgr = GetManager()->GetProfileManager();
        const char* profile_name = GetProfileName();
        if (profile_name && profile_name[0])
            pCachedProfile = *mgr->GetProfile(this, profile_name);

        if (pCachedProfile == NULL)
            pCachedProfile = *mgr->GetDefaultProfile(this);
        
    }
    return pCachedProfile.GetPtr();
}

const char* HMDDevice::GetProfileName()
{
    if (ProfileName.IsEmpty())
    {   // If the profile name has not been initialized then
        // retrieve the stored default user for this specific device
        ProfileManager* mgr = GetManager()->GetProfileManager();
        const char* name = mgr->GetDefaultUser(this);
        ProfileName = name;
    }
    
    return ProfileName.ToCStr();
}

bool HMDDevice::SetProfileName(const char* name)
{
    if (ProfileName == name)
        return true;   // already set
    
    // Flush the old profile
    pCachedProfile.Clear();
    if (!name)
    {
        ProfileName.Clear();
        return false;
    }

    // Set the name and attempt to cache the profile
    ProfileName = name;
    if (GetProfile())
    {
        return true;
    }
    else
    {
        ProfileName.Clear();
        return false;
    }
}

OVR::SensorDevice* HMDDevice::GetSensor()
{
    // Just return first sensor found since we have no way to match it yet.    

    // Create DK2 sensor if it exists otherwise create first DK1 sensor.
    SensorDevice* sensor = NULL;

    DeviceEnumerator<SensorDevice> enumerator = GetManager()->EnumerateDevices<SensorDevice>();

    while(enumerator.GetType() != Device_None)
    {
        SensorInfo info;
        enumerator.GetDeviceInfo(&info);
      
        if (info.ProductId == Device_Tracker2_ProductId)
        {
            sensor = enumerator.CreateDevice();
            break;
        }

        enumerator.Next();
    }

    if (sensor == NULL)
    {
        sensor = GetManager()->EnumerateDevices<SensorDevice>().CreateDevice();
    }    

    if (sensor)
    {
        sensor->SetCoordinateFrame(SensorDevice::Coord_HMD);
    }

    return sensor;
}