diff options
Diffstat (limited to 'LibOVR/Src/Displays')
21 files changed, 6041 insertions, 0 deletions
diff --git a/LibOVR/Src/Displays/OVR_Display.cpp b/LibOVR/Src/Displays/OVR_Display.cpp new file mode 100644 index 0000000..55eb8a9 --- /dev/null +++ b/LibOVR/Src/Displays/OVR_Display.cpp @@ -0,0 +1,36 @@ +/************************************************************************************ + +PublicHeader: None +Filename : OVR_Display.cpp +Content : Common implementation for display device +Created : May 6, 2014 +Notes : + +Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved. + +Licensed under the Oculus VR Rift SDK License Version 3.2 (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.2 + +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. + +************************************************************************************/ + +#include "OVR_Display.h" + +namespace OVR { + + +// Place platform-independent code here + + +} // namespace OVR diff --git a/LibOVR/Src/Displays/OVR_Display.h b/LibOVR/Src/Displays/OVR_Display.h new file mode 100644 index 0000000..46e9f13 --- /dev/null +++ b/LibOVR/Src/Displays/OVR_Display.h @@ -0,0 +1,203 @@ +/************************************************************************************ + +PublicHeader: None +Filename : OVR_Display.h +Content : Contains platform independent display management +Created : May 6, 2014 +Notes : + +Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved. + +Licensed under the Oculus VR Rift SDK License Version 3.2 (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.2 + +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. + +************************************************************************************/ + +#ifndef OVR_Display_h +#define OVR_Display_h + +#include "../Sensors/OVR_DeviceConstants.h" // Required for HmdTypeEnum + +#include "../Kernel/OVR_Types.h" +#include "../Kernel/OVR_Atomic.h" +#include "../Kernel/OVR_RefCount.h" +#include "../Kernel/OVR_Array.h" +#include "../Kernel/OVR_String.h" +#include "../Kernel/OVR_Math.h" + +namespace OVR { + + +class DisplaySearchHandle : virtual public RefCountBaseV<DisplaySearchHandle> +{ +public: + DisplaySearchHandle() {} + + virtual ~DisplaySearchHandle() {} + + void operator= (const DisplaySearchHandle&) {} +}; + +//------------------------------------------------------------------------------------- +// ***** Display + +// Display object describes an Oculus HMD screen in LibOVR, providing information such +// as EDID serial number and resolution in platform-independent manner. +// +// Display is an abstract base class to support OS and driver specific implementations. +// It support HMD screen enumeration through GetDisplayCount/GetDisplay static functions. +// +// Examples of implementations of Display are the following: +// Display_Win32_Generic - Compatibly mode implementation that maintains operation on +// systems without drivers. +// Display_Win32_Driver - Driver-Based display +// Display_OSX_Generic - Additional compatibility mode implementation for OS X + +class Display : public RefCountBase<Display> +{ +protected: + enum MirrorMode + { + MirrorEnabled = 0, + MirrorDisabled = 1 + }; + + MirrorMode mirrorMode; + + Display( + HmdTypeEnum deviceTypeGuess, +#ifdef OVR_OS_MAC + uint32_t displayID, +#else + const String& displayID, +#endif + const String& modelName, + const String& editSerial, + const Sizei& logicalRes, + const Sizei& nativeRes, + const Vector2i& displayOffset, + const uint64_t devNumber, + const uint32_t rotation, + const bool appExclusive): + mirrorMode(MirrorDisabled), + DeviceTypeGuess(deviceTypeGuess), + DisplayID(displayID), + ModelName(modelName), + EdidSerialNumber(editSerial), + LogicalResolutionInPixels(logicalRes), + NativeResolutionInPixels(nativeRes), + DesktopDisplayOffset(displayOffset), + DeviceNumber(devNumber), + Rotation(rotation), + ApplicationExclusive(appExclusive) + { + } + + void operator = (const Display&) { } // Quiet warning. + +public: + virtual ~Display() { } + + // ----- Platform specific static Display functionality ----- + + // Mandatory function that sets up the display environment with + // any necessary shimming and function hooks. This should be one + // of the very first things your application does when it + // initializes LibOVR + static bool Initialize(); + + // Returns a count of the detected displays. These are Rift displays + // attached directly to an active display port + static int GetDisplayCount( DisplaySearchHandle* handle = NULL, bool extended = true, bool applicationOnly = true, bool extendedEDIDSerials = false ); + // Returns a specific index of a display. Displays are sorted in no particular order. + static Ptr<Display> GetDisplay( int index = 0, DisplaySearchHandle* handle = NULL ); + + + // Returns true if we are referencing the same display; useful for matching display + // objects with the ones already detected. + bool MatchDisplay(const Display* other) + { + // Note this is not checking the DeviceName, which corresponds to which monitor the device is. + // This allows matching to match a display that has changed how it is plugged in. + return (DisplayID == other->DisplayID) && + (EdidSerialNumber == other->EdidSerialNumber) && + (NativeResolutionInPixels == other->NativeResolutionInPixels) && + (DesktopDisplayOffset == other->DesktopDisplayOffset) && + (ApplicationExclusive == other->ApplicationExclusive); + } + + + // ----- Device independent instance based Display functionality ----- + + // Device type guess based on display info. + const HmdTypeEnum DeviceTypeGuess; +#if defined(OVR_OS_MAC) + // CGDirectDisplayID for the rift. + const uint32_t DisplayID; +#else + // A string denoting the display device name so that apps can recognize the monitor + const String DisplayID; +#endif + // A literal string containing the name of the model, i.e. Rift DK2 + const String ModelName; + // Part of the serial number encoded in Edid, used for monitor <-> sensor matching. + const String EdidSerialNumber; + // Logical resolution is the display resolution in presentation terms. + // That is to say, the resolution that represents the orientation the + // display is projected to the user. For DK2, while being a portrait display + // the display is held in landscape and therefore the logical resolution + // is 1920x1080 + const Sizei LogicalResolutionInPixels; + // Native resolution is the resolution reported by the EDID and represents the + // exact hardware resolution of the Rift. For example, on DK2 + // this is 1080x1920 + // In theory, an OS rotated Rift's native and logical resolutions should match + const Sizei NativeResolutionInPixels; + // For displays that are attached to the desktop, this return value has meaning. + // Otherwise it should always return origin + const Vector2i DesktopDisplayOffset; + // For Windows machines this value stores the ChildUid used to identify this display + const uint64_t DeviceNumber; + // Stores the device specific default rotation of the screen + // E.g. DK2 is rotated 90 degrees as it is a portrait display + const uint32_t Rotation; + // Is set if the Display is capable in Application-Only mode + const bool ApplicationExclusive; + + // Functionality for rendering within the window + virtual MirrorMode SetMirrorMode( MirrorMode newMode ) = 0; + + // Functionality for enabling/disabling display + virtual bool SetDisplaySleep(bool off) + { + // Override to implement if supported + OVR_UNUSED(off); + return false; + } + + // Check if right now the current rendering application should be in compatibility mode + static bool InCompatibilityMode( bool displaySearch = true ); + + // Get/set the mode for all applications + static bool GetDriverMode(bool& driverInstalled, bool& compatMode, bool& hideDK1Mode); + static bool SetDriverMode(bool compatMode, bool hideDK1Mode); + + static DisplaySearchHandle* GetDisplaySearchHandle(); +}; + + +} // namespace OVR + +#endif diff --git a/LibOVR/Src/Displays/OVR_Linux_Display.cpp b/LibOVR/Src/Displays/OVR_Linux_Display.cpp new file mode 100644 index 0000000..4b840dd --- /dev/null +++ b/LibOVR/Src/Displays/OVR_Linux_Display.cpp @@ -0,0 +1,494 @@ +/************************************************************************************ + +Filename : OVR_Linux_Display.cpp +Content : Linux-specific Display declarations +Created : July 2, 2014 +Authors : James Hughes + +Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved. + +Licensed under the Oculus VR Rift SDK License Version 3.2 (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.2 + +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. + +*************************************************************************************/ + +#include "OVR_Linux_Display.h" +#include "../Kernel/OVR_Log.h" + +#include "../../../3rdParty/EDID/edid.h" + +#include <X11/Xlib.h> +#include <X11/Xutil.h> +#include <X11/extensions/Xrandr.h> +#include <X11/Xatom.h> + +//------------------------------------------------------------------------------------- +// ***** Display enumeration Helpers + +namespace OVR { + +static const uint8_t edid_v1_header[] = { 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00 }; + +static const uint8_t edid_v1_descriptor_flag[] = { 0x00, 0x00 }; + +static const int DESCRIPTOR_DATA = 5; +static const int UNKNOWN_DESCRIPTOR = -1; +static const int DETAILED_TIMING_BLOCK = -2; + +// The following three functions were pulled from OVR_Linux_Display.cpp +// and modified slightly. +static int blockType(uint8_t* block) +{ + if (!strncmp((const char*)edid_v1_descriptor_flag, (const char*)block, 2)) + { + if (block[2] != 0) + { + return UNKNOWN_DESCRIPTOR; + } + else + { + return block[3]; + } + } + else + { + return DETAILED_TIMING_BLOCK; + } +} + +static char* getMonitorName(const uint8_t* block) +{ + static char name[13]; + uint8_t const* ptr = block + DESCRIPTOR_DATA; + + for (int i = 0; i < 13; i++, ptr++) + { + if (*ptr == 0xa) + { + name[i] = 0; + return name; + } + + name[i] = *ptr; + } + + return name; +} + +// Returns -1 on failure, 0 otherwise. +static int parseEdid(uint8_t* edid, Linux::DisplayEDID& edidResult) +{ + const int EDID_LENGTH = 0x80; + const int EDID_HEADER = 0x00; + const int EDID_HEADER_END = 0x07; + + // const int EDID_STRUCT_VERSION = 0x12; + // const int EDID_STRUCT_REVISION = 0x13; + + const int MONITOR_NAME = 0xfc; + // const int MONITOR_LIMITS = 0xfd; + const int MONITOR_SERIAL = 0xff; + + // const int ESTABLISHED_TIMING_1 = 0x23; + // const int ESTABLISHED_TIMING_2 = 0x24; + // const int MANUFACTURERS_TIMINGS = 0x25; + + const int DETAILED_TIMING_DESCRIPTIONS_START = 0x36; + const int DETAILED_TIMING_DESCRIPTION_SIZE = 18; + const int NO_DETAILED_TIMING_DESCRIPTIONS = 4; + + // const int DETAILED_TIMING_DESCRIPTION_1 = 0x36; + // const int DETAILED_TIMING_DESCRIPTION_2 = 0x48; + // const int DETAILED_TIMING_DESCRIPTION_3 = 0x5a; + // const int DETAILED_TIMING_DESCRIPTION_4 = 0x6c; + + const char* monitorName = "Unknown"; + uint8_t* block = NULL; + uint8_t checksum = 0; + + for (int i = 0; i < EDID_LENGTH; i++) + { + checksum += edid[i]; + } + + // Bad checksum, fail EDID + if (checksum != 0) + { + return -1; + } + + if (strncmp((const char*)edid + EDID_HEADER, + (const char*)edid_v1_header, EDID_HEADER_END + 1)) + { + // First bytes don't match EDID version 1 header + return -1; + } + + // Monitor name and timings + char serialNumber[14]; + memset(serialNumber, 0, 14); + + block = edid + DETAILED_TIMING_DESCRIPTIONS_START; + + for (int i = 0; i < NO_DETAILED_TIMING_DESCRIPTIONS; + i++, block += DETAILED_TIMING_DESCRIPTION_SIZE) + { + + if (blockType(block) == MONITOR_NAME) + { + monitorName = getMonitorName(block); + } + + if (blockType(block) == MONITOR_SERIAL) + { + memcpy(serialNumber, block + 5, 13); + break; + } + } + + uint8_t vendorString[4] = {0}; + + vendorString[0] = (edid[8] >> 2 & 31) + 64; + vendorString[1] = (((edid[8] & 3) << 3) | (edid[9] >> 5)) + 64; + vendorString[2] = (edid[9] & 31) + 64; + + edidResult.ModelNumber = *(uint16_t*)&edid[10]; + edidResult.MonitorName = monitorName; + edidResult.VendorName = reinterpret_cast<const char*>(vendorString); + edidResult.SerialNumber = serialNumber; + + // FIXME: Get timings as well + + // std::cout << "# EDID version " << static_cast<int>(edid[EDID_STRUCT_VERSION]) + // << " revision " << static_cast<int>(edid[EDID_STRUCT_REVISION]) + // << std::endl; + + return 0; +} + + +// Returns -1 in the case of failure, 0 otherwise. +// Parameters: +// data OUT This pointer is modified to point to the output from +// XRRGetOutputProperty. You *must* call XFree on this pointer. +// dataLen OUT The length of the data returned in 'data'. +static int getXRRProperty(struct _XDisplay* display, RROutput output, Atom atom, + uint8_t** data, int* dataLen) +{ + unsigned long nitems; + unsigned long bytesAfter; + int actualFormat; + Atom actualType; + + int ret = XRRGetOutputProperty(display, output, atom, 0, 100, + False, False, AnyPropertyType, + &actualType, &actualFormat, &nitems, + &bytesAfter, data); + + if (None != ret) + { + *dataLen = nitems; + return 0; + } + else + { + return -1; + } +} + +static XRRModeInfo* findModeByXID(XRRScreenResources* screen, RRMode xid) +{ + for (int m = 0; m < screen->nmode; ++m) + { + XRRModeInfo* mode = &screen->modes[m]; + if (xid == mode->id) + { + return mode; + } + } + return NULL; +} + +static int discoverExtendedRifts(OVR::Linux::DisplayDesc* descriptorArray, int inputArraySize, bool /*edidInfo*/) +{ + int result = 0; + + struct _XDisplay* display = XOpenDisplay(NULL); + + if (display == NULL) + { + OVR::LogError("[Linux Display] Unable to open X Display!"); + return 0; + } + + Atom EDIDAtom = XInternAtom(display, RR_PROPERTY_RANDR_EDID, False); + int numScreens = XScreenCount(display); + for (int i = 0; i < numScreens; ++i) + { + Window sr = XRootWindow(display, i); + XRRScreenResources* screen = XRRGetScreenResources(display, sr); + + for (int ii = 0; ii < screen->ncrtc; ++ii) + { + XRRCrtcInfo* crtcInfo = XRRGetCrtcInfo(display, screen, screen->crtcs[ii]); + + if (0 == crtcInfo->noutput) + { + XRRFreeCrtcInfo(crtcInfo); + continue; + } + + bool foundOutput = false; + RROutput output = crtcInfo->outputs[0]; + for (int k = 0; k < crtcInfo->noutput; ++k) + { + XRROutputInfo* outputInfo = + XRRGetOutputInfo(display, screen, crtcInfo->outputs[k]); + + for (int kk = 0; kk < outputInfo->nmode; ++kk) + { + if (outputInfo->modes[kk] == crtcInfo->mode) + { + output = crtcInfo->outputs[k]; + foundOutput = true; + break; + } + } + XRRFreeOutputInfo(outputInfo); + if (foundOutput) + { + break; + } + } + + if (!foundOutput) + { + XRRFreeCrtcInfo(crtcInfo); + continue; + } + + XRROutputInfo* outputInfo = XRRGetOutputInfo(display, screen, output); + if (RR_Connected != outputInfo->connection) + { + XRRFreeOutputInfo(outputInfo); + XRRFreeCrtcInfo(crtcInfo); + continue; + } + + // Read EDID associated with crtc. + uint8_t* data = NULL; + int dataLen = 0; + if (getXRRProperty(display, output, EDIDAtom, &data, &dataLen) != 0) + { + // Identify rifts based on EDID. + Linux::DisplayEDID edid; + parseEdid(data, edid); + XFree(data); + data = NULL; + + // TODO: Remove either this 3rdParty call to read EDID data + // or remove our own parsing of the EDID. Probably opt + // to remove our parsing. + MonitorInfo* mi = read_edid_data(display, output); + if (mi == NULL) + { + XRRFreeOutputInfo(outputInfo); + XRRFreeCrtcInfo(crtcInfo); + continue; + } + + if (edid.VendorName == "OVR") + { + if( result >= inputArraySize ) + { + delete mi; + XRRFreeOutputInfo(outputInfo); + XRRFreeCrtcInfo(crtcInfo); + return result; + } + + XRRModeInfo* modeInfo = findModeByXID(screen, crtcInfo->mode); + + int width = modeInfo->width; + int height = modeInfo->height; + + if ( crtcInfo->rotation == RR_Rotate_90 + || crtcInfo->rotation == RR_Rotate_270 ) + { + width = modeInfo->height; + height = modeInfo->width; + } + + int x = crtcInfo->x; + int y = crtcInfo->y; + + // Generate a device ID string similar Windows does it + char device_id[32]; + OVR_sprintf(device_id, 32, "%s%04d-%d", + mi->manufacturer_code, mi->product_code, + screen->crtcs[ii]); + + OVR::Linux::DisplayDesc& desc = descriptorArray[result++]; + desc.DisplayID = device_id; + desc.ModelName = edid.MonitorName; + desc.EdidSerialNumber = edid.SerialNumber; + desc.LogicalResolutionInPixels = Sizei(width, height); + desc.DesktopDisplayOffset = Vector2i(x, y); + + switch (mi->product_code) + { + case 3: desc.DeviceTypeGuess = HmdType_DK2; break; + case 2: desc.DeviceTypeGuess = HmdType_DKHDProto; break; + case 1: desc.DeviceTypeGuess = HmdType_DK1; break; + + default: + case 0: desc.DeviceTypeGuess = HmdType_Unknown; break; + } + + // Hard-coded defaults in case the device doesn't have the + // data itself. DK2 prototypes (0003) or DK HD Prototypes (0002). + if ( desc.DeviceTypeGuess == HmdType_DK2 + || desc.DeviceTypeGuess == HmdType_DKHDProto) + { + desc.LogicalResolutionInPixels = Sizei(1920, 1080); + desc.NativeResolutionInPixels = Sizei(1080, 1920); + } + else + { + desc.LogicalResolutionInPixels = Sizei(width, height); + desc.NativeResolutionInPixels = Sizei(width, height); + } + } + + delete mi; + mi = NULL; + } + + XRRFreeOutputInfo(outputInfo); + XRRFreeCrtcInfo(crtcInfo); + } + + XRRFreeScreenResources(screen); + } + + XCloseDisplay(display); + + return result; +} + + +//------------------------------------------------------------------------------------- +// ***** Display + +bool Display::Initialize() +{ + // Nothing to initialize. OS X only supports compatibility mode. + return true; +} + +bool Display::GetDriverMode(bool& driverInstalled, bool& compatMode, bool& hideDK1Mode) +{ + driverInstalled = false; + compatMode = true; + hideDK1Mode = false; + return true; +} + +bool Display::SetDriverMode(bool /*compatMode*/, bool /*hideDK1Mode*/) +{ + return false; +} + +DisplaySearchHandle* Display::GetDisplaySearchHandle() +{ + return new Linux::LinuxDisplaySearchHandle(); +} + +bool Display::InCompatibilityMode( bool displaySearch ) +{ + OVR_UNUSED( displaySearch ); + return true; +} + +int Display::GetDisplayCount(DisplaySearchHandle* handle, bool extended, bool applicationOnly, bool edidInfo) +{ + OVR_UNUSED4(handle, extended, applicationOnly, edidInfo); + + static int extendedCount = -1; + + Linux::LinuxDisplaySearchHandle* localHandle = (Linux::LinuxDisplaySearchHandle*)handle; + if (localHandle == NULL) + { + OVR::LogError("[Linux Display] No search handle passed into GetDisplayCount. Return 0 rifts."); + return 0; + } + + if (extendedCount == -1 || extended) + { + extendedCount = discoverExtendedRifts(localHandle->cachedDescriptorArray, Linux::LinuxDisplaySearchHandle::DescArraySize, edidInfo); + } + + localHandle->extended = true; + localHandle->extendedDisplayCount = extendedCount; + int totalCount = extendedCount; + + /// FIXME: Implement application mode for OS X. + localHandle->application = false; + localHandle->applicationDisplayCount = 0; + + localHandle->displayCount = totalCount; + + return totalCount; +} + + +Ptr<Display> Display::GetDisplay( int index, DisplaySearchHandle* handle ) +{ + Ptr<Display> result = NULL; + + if (index < 0) + { + OVR::LogError("[Linux Display] Invalid index given to GetDisplay."); + return NULL; + } + + Linux::LinuxDisplaySearchHandle* localHandle = (Linux::LinuxDisplaySearchHandle*)handle; + if (localHandle == NULL) + { + OVR::LogError("[Linux Display] No search handle passed into GetDisplay. Return 0 rifts."); + return NULL; + } + + if (localHandle->extended) + { + if (index >= 0 && index < (int)localHandle->extendedDisplayCount) + { + return *new Linux::LinuxDisplayGeneric(localHandle->cachedDescriptorArray[index]); + } + + index -= localHandle->extendedDisplayCount; + } + + if (localHandle->application) + { + OVR::LogError("[Linux Display] Mac does not support application displays."); + } + + return result; +} + + +} // namespace OVR diff --git a/LibOVR/Src/Displays/OVR_Linux_Display.h b/LibOVR/Src/Displays/OVR_Linux_Display.h new file mode 100644 index 0000000..f685e6b --- /dev/null +++ b/LibOVR/Src/Displays/OVR_Linux_Display.h @@ -0,0 +1,133 @@ +/************************************************************************************ + +Filename : OVR_Linux_Display.h +Content : Linux-specific Display declarations +Created : July 2, 2014 +Authors : James Hughes + +Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved. + +Licensed under the Oculus VR Rift SDK License Version 3.2 (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.2 + +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. + +*************************************************************************************/ + +#ifndef OVR_Linux_Display_h +#define OVR_Linux_Display_h + +#include "OVR_Display.h" + +namespace OVR { namespace Linux { + + +//------------------------------------------------------------------------------------- +// DisplayDesc + +// Display information enumerable through OS . +// TBD: Should we just move this to public header, so it's a const member of Display? +struct DisplayDesc +{ + HmdTypeEnum DeviceTypeGuess; + String DisplayID; // This is the device identifier string from MONITORINFO (for app usage) + String ModelName; // This is a "DK2" type string + String EdidSerialNumber; + Sizei LogicalResolutionInPixels; + Sizei NativeResolutionInPixels; + Vector2i DesktopDisplayOffset; +}; + + +//------------------------------------------------------------------------------------- +// DisplayEDID + +// Describes EDID information as reported from our display driver. +struct DisplayEDID +{ + DisplayEDID() : + ModelNumber(0) + {} + + String MonitorName; + UInt16 ModelNumber; + String VendorName; + String SerialNumber; +}; + + +//------------------------------------------------------------------------------------- +// Linux Display Search Handle +class LinuxDisplaySearchHandle : public DisplaySearchHandle +{ +public: + LinuxDisplaySearchHandle() : + extended(false), + application(false), + extendedDisplayCount(0), + applicationDisplayCount(0), + displayCount(0) + {} + virtual ~LinuxDisplaySearchHandle() {} + + static const int DescArraySize = 16; + + Linux::DisplayDesc cachedDescriptorArray[DescArraySize]; + bool extended; + bool application; + int extendedDisplayCount; + int applicationDisplayCount; + int displayCount; +}; + +//------------------------------------------------------------------------------------- +// LinuxDisplayGeneric + +// Describes Linux display in Compatibility mode, containing basic data +class LinuxDisplayGeneric : public Display +{ +public: + LinuxDisplayGeneric( const DisplayDesc& dd ) : + Display(dd.DeviceTypeGuess, + dd.DisplayID, + dd.ModelName, + dd.EdidSerialNumber, + dd.LogicalResolutionInPixels, + dd.NativeResolutionInPixels, + dd.DesktopDisplayOffset, + 0, + 0, + false) + { + } + + virtual ~LinuxDisplayGeneric() + { + } + + virtual bool InCompatibilityMode() const + { + return true; + } + + // Generic displays are not capable of mirroring + virtual MirrorMode SetMirrorMode( MirrorMode newMode ) + { + OVR_UNUSED( newMode ); + return MirrorDisabled; + } +}; + +}} // namespace OVR::Linux + +#endif // OVR_Linux_Display_h diff --git a/LibOVR/Src/Displays/OVR_Linux_SDKWindow.cpp b/LibOVR/Src/Displays/OVR_Linux_SDKWindow.cpp new file mode 100644 index 0000000..3d76f69 --- /dev/null +++ b/LibOVR/Src/Displays/OVR_Linux_SDKWindow.cpp @@ -0,0 +1,649 @@ +/******************************************************************************* + +Filename : OVR_Linux_SDKWindow.cpp +Content : SDK generated Linux window. +Created : October 1, 2014 +Authors : James Hughes + +Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved. + +Licensed under the Oculus VR Rift SDK License Version 3.2 (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.2 + +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. + +*******************************************************************************/ + +#include "OVR_Linux_SDKWindow.h" +#include "../Kernel/OVR_Log.h" +#include "../Kernel/OVR_Log.h" +#include "../../../3rdParty/EDID/edid.h" + +namespace OVR { + +// Forward declarations +static Window constructWindow(struct _XDisplay* display, int xscreen, + XVisualInfo* xvisual, + const LinuxDeviceScreen& screen); + +static XRRModeInfo* findModeByXID(XRRScreenResources* screen, RRMode xid) +{ + for (int m = 0; m < screen->nmode; ++m) + { + XRRModeInfo* mode = &screen->modes[m]; + if (xid == mode->id) + { + return mode; + } + } + return NULL; +} + +/// Retrieves a list of available device screens on which we can build +/// SDK windows. Returns number of devices found. +/// screens Array which this function will populate. +/// maxNumScreens Maximum number of screens to store in screens. +static int getDeviceScreens(LinuxDeviceScreen* screens, int maxNumDevices) +{ + struct _XDisplay* disp = XOpenDisplay(NULL); + if (!disp) + { + OVR::LogError("[SDKWindow] Unable to open X Display."); + return 0; + } + + int numDevices = 0; + int numScreens = XScreenCount(disp); + for (int i = 0; i < numScreens; ++i) + { + // Screen root is used to detect what video output the crtc is using. + Window sr = XRootWindow(disp, i); + XRRScreenResources* screen = XRRGetScreenResources(disp, sr); + + for (int ii = 0; ii < screen->ncrtc; ++ii) + { + XRRCrtcInfo* crtcInfo = XRRGetCrtcInfo(disp, screen, screen->crtcs[ii]); + + if (0 == crtcInfo->noutput) + { + XRRFreeCrtcInfo(crtcInfo); + continue; + } + + bool foundOutput = false; + RROutput output = crtcInfo->outputs[0]; + for (int k = 0; k < crtcInfo->noutput; ++k) + { + XRROutputInfo* outputInfo = + XRRGetOutputInfo(disp, screen, crtcInfo->outputs[k]); + for (int kk = 0 ; kk < outputInfo->nmode; ++kk) + { + if (outputInfo->modes[kk] == crtcInfo->mode) + { + output = crtcInfo->outputs[k]; + foundOutput = true; + break; + } + } + XRRFreeOutputInfo(outputInfo); + if (foundOutput) { break; } + } + + if (!foundOutput) + { + XRRFreeCrtcInfo(crtcInfo); + continue; + } + + XRROutputInfo* outputInfo = XRRGetOutputInfo(disp, screen, output); + if (RR_Connected != outputInfo->connection) + { + XRRFreeOutputInfo(outputInfo); + XRRFreeCrtcInfo(crtcInfo); + continue; + } + + // Read EDID associated with crtc. + MonitorInfo* mi = read_edid_data(disp, output); + if (mi == NULL) + { + XRRFreeOutputInfo(outputInfo); + XRRFreeCrtcInfo(crtcInfo); + continue; + } + + if (strcmp(mi->manufacturer_code, "OVR") == 0) + { + XRRModeInfo* modeInfo = findModeByXID(screen, crtcInfo->mode); + + DistortionRotation desiredRot = DistRotateNone; + if (mi->product_code == 3) + { + // This is a DK2, we may have to rotate our output. + // If we don't have to, we should alert the user that + // rotating the display using the DM or graphics + // card settings is highly non-optimal. + desiredRot = DistRotateCCW90; + if (crtcInfo->rotation != RR_Rotate_0) + { + OVR::LogError("Please do not rotate your rift's screen."); + + if (crtcInfo->rotation == RR_Rotate_90) + { + // The user has manually rotated the screen. + // So apply no rotation on our end. + desiredRot = DistRotateNone; + } + } + } + else + { + if (crtcInfo->rotation != RR_Rotate_0) + { + OVR::LogError("Please do not rotate your rift's screen."); + } + } + + int width = modeInfo->width; + int height = modeInfo->height; + + // Swap width / height if display is rotated (shouldn't be on linux). + if ( crtcInfo->rotation == RR_Rotate_90 + || crtcInfo->rotation == RR_Rotate_270) + { + width = modeInfo->height; + height = modeInfo->width; + } + + // Push detected monitor. + screens[numDevices].set(i, screen->crtcs[ii], desiredRot, + mi->product_code, width, height, + crtcInfo->x, crtcInfo->y); + ++numDevices; + } + + delete mi; + + if (numDevices == maxNumDevices) + { + XRRFreeOutputInfo(outputInfo); + XRRFreeCrtcInfo(crtcInfo); + XRRFreeScreenResources(screen); + OVR::LogError("[SDKWindow] Maxed out number of devices.."); + XCloseDisplay(disp); + return numDevices; + } + + XRRFreeOutputInfo(outputInfo); + XRRFreeCrtcInfo(crtcInfo); + } + + XRRFreeScreenResources(screen); + } + XCloseDisplay(disp); + return numDevices; +} + + +LinuxDeviceScreen SDKWindow::findDevScreenForHMD(const ovrHmd& hmd) +{ + return findDevScreenForDevID(hmd->DisplayDeviceName); +} + +LinuxDeviceScreen SDKWindow::findDevScreenForDevID(const char* deviceIDIn) +{ + const int maxNumDevices = 5; + LinuxDeviceScreen screens[maxNumDevices]; + int numDevices = getDeviceScreens(screens, maxNumDevices); + + if (numDevices > 0) + { + // Identify target for SDK window via hmd info. + for (int i = 0; i < numDevices; ++i) + { + LinuxDeviceScreen& screen = screens[i]; + + char deviceID[32]; + OVR_sprintf(deviceID, 32, "OVR%04d-%d", + screen.productCode, screen.crtcid); + + if (strcmp(deviceIDIn, deviceID) == 0) + { + return screen; + } + } + } + + return LinuxDeviceScreen(); +} + +DistortionRotation SDKWindow::getRotation(const ovrHmd& hmd) +{ + LinuxDeviceScreen screen = findDevScreenForHMD(hmd); + if (screen.isValid()) + { + return screen.rotation; + } + else + { + return DistRotateNone; + } +} + + +bool SDKWindow::getVisualFromDrawable(GLXDrawable drawable, XVisualInfo* vinfoOut) +{ + struct _XDisplay* display = glXGetCurrentDisplay(); + + unsigned int value; + glXQueryDrawable(display, drawable, GLX_FBCONFIG_ID, &value); + const int attribs[] = {GLX_FBCONFIG_ID, (int)value, None}; + int screen; + glXQueryContext(display, glXGetCurrentContext(), GLX_SCREEN, &screen); + int numElems; + GLXFBConfig* config = glXChooseFBConfig(display, screen, attribs, &numElems); + if (numElems > 0) + { + XVisualInfo* chosen = glXGetVisualFromFBConfig(display, *config); + *vinfoOut = *chosen; + XFree(config); + return true; + } + return false; +} + +SDKWindow::SDKWindow(const ovrHmd& hmd) : + mXDisplay(NULL), + mXScreen(-1), + mXVisual(NULL), + mXUniqueContext(-1), + mXWindow(0), + mFBConfigID(0) +{ + OVR_UNUSED(hmd); +} + +SDKWindow::~SDKWindow() +{ + if (mXWindow) + { + XDeleteContext(mXDisplay, mXWindow, mXUniqueContext); + XUnmapWindow(mXDisplay, mXWindow); + XDestroyWindow(mXDisplay, mXWindow); + mXWindow = static_cast<Window>(0); + } + + if (mXVisual) + { + XFree(mXVisual); + mXVisual = NULL; + } + + if (mXDisplay) + { + XCloseDisplay(mXDisplay); + } +} + +void SDKWindow::buildVisualAndWindow(const LinuxDeviceScreen& devScreen) +{ + mXDisplay = XOpenDisplay(NULL); + mXUniqueContext = XUniqueContext(); + mXScreen = devScreen.screen; + mFBConfigID = chooseFBConfigID(mXDisplay, mXScreen); + + mXVisual = getVisual(mXDisplay, mFBConfigID, mXScreen); + if (mXVisual != NULL) + { + mXWindow = constructWindow(mXDisplay, mXScreen, mXVisual, devScreen); + mDeviceScreen = devScreen; + } +} + +// Used in chooseVisual. May need to expose this to the end use so they can +// choose an appropriate framebuffer configuration. +struct FBConfig +{ + FBConfig() : + redBits(8), + greenBits(8), + blueBits(8), + alphaBits(8), + depthBits(8), + stencilBits(-1), + doubleBuffer(true), + auxBuffers(-1) + {} + + int redBits; + int greenBits; + int blueBits; + int alphaBits; + int depthBits; + int stencilBits; + bool doubleBuffer; + int auxBuffers; + + int xcfg; +}; + +static int fbCalcContrib(int desired, int current) +{ + int diff = desired - current; + if (current != -1) { return diff * diff; } + else { return 0; } +} + +// Choose frame buffer configuration and return fbConfigID. +int SDKWindow::chooseFBConfigID(struct _XDisplay* display, int xscreen) +{ + int nativeCount = 0; + GLXFBConfig* nativeConfigs = + glXGetFBConfigs(display, xscreen, &nativeCount); + if (!nativeCount) + { + OVR::LogError("[SDKWindow] No valid frame buffer configurations found."); + return 0; + } + + FBConfig* usables = static_cast<FBConfig*>(calloc(nativeCount, sizeof(FBConfig))); + int numUsables = 0; + + for (int i = 0; i < nativeCount; ++i) + { + GLXFBConfig native = nativeConfigs[i]; + FBConfig* usable = &usables[numUsables]; + int v = 0; + + // Only frame buffer configcs with attached visuals. + glXGetFBConfigAttrib(display, native, GLX_VISUAL_ID, &v); + if (!v) { continue; } + + // Only RGBA frame buffers. + glXGetFBConfigAttrib(display, native, GLX_RENDER_TYPE, &v); + if (!(v & GLX_RGBA_BIT)) { continue; } + + glXGetFBConfigAttrib(display, native, GLX_DRAWABLE_TYPE, &v); + if (!(v & GLX_WINDOW_BIT)) { continue; } + + glXGetFBConfigAttrib(display, native, GLX_DEPTH_SIZE, &usable->depthBits); + glXGetFBConfigAttrib(display, native, GLX_STENCIL_SIZE, &usable->stencilBits); + + glXGetFBConfigAttrib(display, native, GLX_RED_SIZE, &usable->redBits); + glXGetFBConfigAttrib(display, native, GLX_GREEN_SIZE, &usable->greenBits); + glXGetFBConfigAttrib(display, native, GLX_BLUE_SIZE, &usable->blueBits); + glXGetFBConfigAttrib(display, native, GLX_ALPHA_SIZE, &usable->alphaBits); + + glXGetFBConfigAttrib(display, native, GLX_ALPHA_SIZE, &usable->auxBuffers); + + glXGetFBConfigAttrib(display, native, GLX_DOUBLEBUFFER, &v); + usable->doubleBuffer = v ? true : false; + + glXGetFBConfigAttrib(display, native, GLX_FBCONFIG_ID, &usable->xcfg); + + ++numUsables; + } + + // We really want std::numeric_limits<int>::max() instead of hardcoded vals. + const int MostMissing = 100; + int leastMissing = MostMissing; + int leastBias = MostMissing; + + const FBConfig* closest = NULL; + + // Desired is currently the default config built by constructor. + FBConfig desired; + + for (int i = 0; i < numUsables; ++i) + { + const FBConfig* cur = &usables[i]; + + if (desired.doubleBuffer != cur->doubleBuffer) { continue; } + + int missing = 0; + if (desired.alphaBits > 0 && cur->alphaBits == 0) { ++missing; } + if (desired.depthBits > 0 && cur->depthBits == 0) { ++missing; } + if (desired.stencilBits > 0 && cur->stencilBits == 0) { ++missing; } + if (desired.redBits > 0 && desired.redBits != cur->redBits) { ++missing; } + if (desired.greenBits > 0 && desired.greenBits != cur->greenBits) { ++missing; } + if (desired.blueBits > 0 && desired.blueBits != cur->blueBits) { ++missing; } + + int bias = fbCalcContrib(desired.redBits, cur->redBits) + + fbCalcContrib(desired.greenBits, cur->greenBits) + + fbCalcContrib(desired.blueBits, cur->blueBits) + + fbCalcContrib(desired.alphaBits, cur->alphaBits) + + fbCalcContrib(desired.depthBits, cur->depthBits) + + fbCalcContrib(desired.stencilBits, cur->stencilBits); + + if (missing < leastMissing) + { + closest = cur; + } + else if (missing == leastMissing) + { + // Now select against squared differences. + if (bias < leastBias) + { + closest = cur; + } + } + + if (closest == cur) + { + leastMissing = missing; + leastBias = bias; + } + } + + if (closest == NULL) + { + OVR::LogError("[SDKWindow] Failed to select appropriate frame buffer."); + XFree(nativeConfigs); + free(usables); + return 0; + } + + int retVal = closest->xcfg; + + XFree(nativeConfigs); + free(usables); + + return retVal; +} + +// Obtain visual from frame buffer configuration ID. +XVisualInfo* SDKWindow::getVisual(struct _XDisplay* display, + int fbConfigID, int xscreen) +{ + GLXFBConfig* cfg = getGLXFBConfig(display, fbConfigID, xscreen); + XVisualInfo* viOut = NULL; + if (cfg != NULL) + { + viOut = glXGetVisualFromFBConfig(display, *cfg); + XFree(cfg); + cfg = NULL; + } + else + { + OVR::LogError("Unable to find fb config ID."); + } + return viOut; +} + +// GLXFBConfig pointer from frame buffer configuration ID. You must call +// XFree on the GLXFBConfig pointer. +GLXFBConfig* SDKWindow::getGLXFBConfig(struct _XDisplay* display, + int fbConfigID, int xscreen) +{ + const int attribs[] = {GLX_FBCONFIG_ID, (int)fbConfigID, None}; + int numElems; + + GLXFBConfig* config = glXChooseFBConfig(display, xscreen, attribs, &numElems); + if (numElems > 0) + { + return config; + } + else + { + return NULL; + } +} + + +static int gXLastError = -1; +static int handleXError(struct _XDisplay* display, XErrorEvent* event) +{ + OVR_UNUSED(display); + gXLastError = event->error_code; + return 0; +} + +static void obtainXErrorHandler() +{ + gXLastError = Success; + XSetErrorHandler(handleXError); +} + +static void releaseXErrorHandler(struct _XDisplay* display) +{ + XSync(display, False); + XSetErrorHandler(NULL); +} + +// Returns 0 on error, otherwise a valid X window is returned. +static Window constructWindow(struct _XDisplay* xDisp, int xScreen, + XVisualInfo* xVisual, + const LinuxDeviceScreen& devScreen) +{ + XSetWindowAttributes wa; + + Window root = XRootWindow(xDisp, xScreen); + Window xWindowOut = 0; + + // Create Window + { + Colormap xWinColorMapOut = XCreateColormap( + xDisp, root, xVisual->visual, AllocNone); + unsigned long wamask = CWBorderPixel | CWColormap | CWEventMask; + + wa.colormap = xWinColorMapOut; + wa.border_pixel = 0; + wa.event_mask = StructureNotifyMask | ExposureMask | FocusChangeMask + | VisibilityChangeMask | EnterWindowMask | LeaveWindowMask + | PropertyChangeMask; + + obtainXErrorHandler(); + + xWindowOut = XCreateWindow(xDisp, root, + 0, 0, + devScreen.width, devScreen.height, + 0, + xVisual->depth, + InputOutput, + xVisual->visual, + wamask, + &wa); + + releaseXErrorHandler(xDisp); + + if (!xWindowOut) + { + OVR::LogError("[SDKWindow] Failed to create SDK window."); + return 0; + } + + XFreeColormap(xDisp, xWinColorMapOut); + } + + // OVERRIDE REDIRECT. + XSetWindowAttributes attributes; + attributes.override_redirect = True; + XChangeWindowAttributes(xDisp, xWindowOut, + CWOverrideRedirect, &attributes); + + // Show the window (do this in full screen or windowed). + XMapRaised(xDisp, xWindowOut); + XFlush(xDisp); + + // Position ourselves manually since there should be no WM managing us. + XRaiseWindow(xDisp, xWindowOut); + XMoveWindow(xDisp, xWindowOut, devScreen.offsetX, devScreen.offsetY); + XResizeWindow(xDisp, xWindowOut, devScreen.width, devScreen.height); + + XFlush(xDisp); + + // WM Backup in case there still exists a WM managing us... + Atom NET_WM_BYPASS_COMPOSITOR = + XInternAtom(xDisp, "_NET_WM_BYPASS_COMPOSITOR", False); + Atom NET_WM_STATE = + XInternAtom(xDisp, "_NET_WM_STATE", False); + Atom NET_WM_STATE_FULLSCREEN = + XInternAtom(xDisp, "_NET_WM_STATE_FULLSCREEN", False); + Atom NET_ACTIVE_WINDOW = + XInternAtom(xDisp, "_NET_ACTIVE_WINDOW", False); + + // Bypass compositor if we are under a compositing WM. + // Just in case a WM ignores our override_redirect. + if (NET_WM_BYPASS_COMPOSITOR) + { + const unsigned long bypass = 1; + XChangeProperty(xDisp, xWindowOut, + NET_WM_BYPASS_COMPOSITOR, + XA_CARDINAL, 32, PropModeReplace, + (unsigned char*)&bypass, 1); + } + + if (NET_WM_STATE && NET_WM_STATE_FULLSCREEN) + { + // BACKUP: If we are still managed by a WM we want fullscreen. + const int EWMH_STATE_ADD = 1; + + if (NET_ACTIVE_WINDOW) + { + XEvent event; + memset(&event, 0, sizeof(event)); + + event.type = ClientMessage; + event.xclient.window = xWindowOut; + event.xclient.format = 32; + event.xclient.message_type = NET_ACTIVE_WINDOW; + event.xclient.data.l[0] = 1; + event.xclient.data.l[1] = 0; + + XSendEvent(xDisp, root, False, + SubstructureNotifyMask | SubstructureRedirectMask, + &event); + } + + XEvent event; + memset(&event, 0, sizeof(event)); + + event.type = ClientMessage; + event.xclient.window = xWindowOut; + event.xclient.format = 32; + event.xclient.message_type = NET_WM_STATE; + event.xclient.data.l[0] = EWMH_STATE_ADD; + event.xclient.data.l[1] = NET_WM_STATE_FULLSCREEN; + event.xclient.data.l[2] = 0; + event.xclient.data.l[3] = 1; + + XSendEvent(xDisp, root, False, + SubstructureNotifyMask | SubstructureRedirectMask, + &event); + } + + return xWindowOut; +} + +} // namespace OVR + diff --git a/LibOVR/Src/Displays/OVR_Linux_SDKWindow.h b/LibOVR/Src/Displays/OVR_Linux_SDKWindow.h new file mode 100644 index 0000000..70b95dd --- /dev/null +++ b/LibOVR/Src/Displays/OVR_Linux_SDKWindow.h @@ -0,0 +1,147 @@ +/******************************************************************************* + +Filename : OVR_Linux_SDKWindow.h +Content : SDK generated Linux window. +Created : October 1, 2014 +Authors : James Hughes + +Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved. + +Licensed under the Oculus VR Rift SDK License Version 3.2 (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.2 + +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. + +*******************************************************************************/ + +#ifndef OVR_Linux_SDKWindow_h +#define OVR_Linux_SDKWindow_h + +#include "../OVR_CAPI.h" +#include "../CAPI/GL/CAPI_GL_Util.h" + +#include <X11/Xlib.h> +#include <X11/Xatom.h> +#include <X11/extensions/Xrandr.h> +#include <X11/Xresource.h> +#include <GL/glx.h> + +namespace OVR { + +enum DistortionRotation +{ + DistRotateNone, + DistRotateCCW90 +}; + +struct LinuxDeviceScreen +{ + LinuxDeviceScreen() : + screen(-1), + crtcid(0), + rotation(DistRotateNone), + productCode(-1), + width(-1), + height(-1), + offsetX(-1), + offsetY(-1) + {} + + void set(int xScreen, XID xid, DistortionRotation rot, int prodCode, + int w, int h, int x, int y) + { + screen = xScreen; + crtcid = xid; + rotation = rot; + productCode = prodCode; + + width = w; + height = h; + offsetX = x; + offsetY = y; + } + + bool isValid() {return (screen != -1);} + + int screen; ///< X Screen this device occupies. + XID crtcid; ///< XID uniquely identifying this device on XDisplay. + DistortionRotation rotation; + int productCode; + + // Actual width and height of screen. + int width; + int height; + + // Offset if using twinview + int offsetX; + int offsetY; +}; + +class SDKWindow +{ +public: + + SDKWindow(const ovrHmd& hmd); + ~SDKWindow(); + + /// Rotation necessary to correctly orient this SDK window. + DistortionRotation GetDistortionRotation() {return mDeviceScreen.rotation;} + + struct _XDisplay* GetDisplay() {return mXDisplay;} + XVisualInfo* GetVisual() {return mXVisual;} + Window GetDrawable() {return mXWindow;} + bool HasValidWindow() {return (mXWindow != 0);} + + // Choose frame buffer configuration and return fbConfigID. Returns -1 if + // a failure occurs. + static int chooseFBConfigID(struct _XDisplay* display, int xscreen); + + // Obtain visual from frame buffer configuration ID. You must call XFree + // on the XVisualInfo* pointer. + static XVisualInfo* getVisual(struct _XDisplay* display, + int fbConfigID, int xscreen); + + // GLXFBConfig pointer from frame buffer configuration ID. You must call + // XFree on the GLXFBConfig pointer. + static GLXFBConfig* getGLXFBConfig(struct _XDisplay* display, + int fbConfigID, int xscreen); + + static LinuxDeviceScreen findDevScreenForHMD(const ovrHmd& hmd); + static LinuxDeviceScreen findDevScreenForDevID(const char* deviceID); + + static DistortionRotation getRotation(const ovrHmd& hmd); + + // Obtains XVisualInfo for currently bound context. Returns true if a + // visual was successfully obtained. False otherwise. + static bool getVisualFromDrawable(GLXDrawable drawable, XVisualInfo* vinfoOut); + +private: + + /// Constructs SDK window on the given device screen. + void buildVisualAndWindow(const LinuxDeviceScreen& devScreen); + + // Added m in front of variables so as to not conflict with X names. + struct _XDisplay* mXDisplay; + int mXScreen; + XVisualInfo* mXVisual; + XContext mXUniqueContext; + Window mXWindow; + int mFBConfigID; + + LinuxDeviceScreen mDeviceScreen; +}; + + +} // namespace OVR + +#endif // OVR_Linux_SDKWindow_h diff --git a/LibOVR/Src/Displays/OVR_OSX_Display.cpp b/LibOVR/Src/Displays/OVR_OSX_Display.cpp new file mode 100644 index 0000000..67df51d --- /dev/null +++ b/LibOVR/Src/Displays/OVR_OSX_Display.cpp @@ -0,0 +1,372 @@ +/************************************************************************************ + +Filename : OVR_OSX_Display.cpp +Content : OSX-specific Display declarations +Created : July 2, 2014 +Authors : James Hughes + +Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved. + +Licensed under the Oculus VR Rift SDK License Version 3.2 (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.2 + +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. + +*************************************************************************************/ + +#include "OVR_OSX_Display.h" +#include "../Kernel/OVR_Log.h" + +#include <ApplicationServices/ApplicationServices.h> +#include <CoreFoundation/CoreFoundation.h> +#include <CoreFoundation/CFString.h> +#include <IOKit/graphics/IOGraphicsLib.h> + +//------------------------------------------------------------------------------------- +// ***** Display enumeration Helpers + +namespace OVR { + +// FIXME Code duplication with windows. +#define EDID_LENGTH 0x80 + +#define EDID_HEADER 0x00 +#define EDID_HEADER_END 0x07 + +#define ID_MANUFACTURER_NAME 0x08 +#define ID_MANUFACTURER_NAME_END 0x09 + +#define EDID_STRUCT_VERSION 0x12 +#define EDID_STRUCT_REVISION 0x13 + +#define ESTABLISHED_TIMING_1 0x23 +#define ESTABLISHED_TIMING_2 0x24 +#define MANUFACTURERS_TIMINGS 0x25 + +#define DETAILED_TIMING_DESCRIPTIONS_START 0x36 +#define DETAILED_TIMING_DESCRIPTION_SIZE 18 +#define NO_DETAILED_TIMING_DESCRIPTIONS 4 + +#define DETAILED_TIMING_DESCRIPTION_1 0x36 +#define DETAILED_TIMING_DESCRIPTION_2 0x48 +#define DETAILED_TIMING_DESCRIPTION_3 0x5a +#define DETAILED_TIMING_DESCRIPTION_4 0x6c + +#define MONITOR_NAME 0xfc +#define MONITOR_LIMITS 0xfd +#define MONITOR_SERIAL 0xff + +#define UNKNOWN_DESCRIPTOR -1 +#define DETAILED_TIMING_BLOCK -2 + +#define DESCRIPTOR_DATA 5 + +const UByte edid_v1_header[] = { 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00 }; + +const UByte edid_v1_descriptor_flag[] = { 0x00, 0x00 }; + +// FIXME Code duplication with windows. Refactor. +static int blockType( UByte* block ) +{ + if ( !strncmp( (const char*)edid_v1_descriptor_flag, (const char*)block, 2 ) ) + { + // descriptor + if ( block[ 2 ] != 0 ) + return UNKNOWN_DESCRIPTOR; + return block[ 3 ]; + } + else + { + return DETAILED_TIMING_BLOCK; + } +} + +static char* getMonitorName( UByte const* block ) +{ + static char name[ 13 ]; + unsigned i; + UByte const* ptr = block + DESCRIPTOR_DATA; + + for( i = 0; i < 13; i++, ptr++ ) + { + if ( *ptr == 0xa ) + { + name[ i ] = 0; + return name; + } + + name[ i ] = *ptr; + } + + return name; +} + +// FIXME Code duplication with windows. Refactor. +static bool parseEdid( UByte* edid, OVR::OSX::DisplayEDID& edidResult ) +{ + unsigned i; + UByte* block; + const char* monitor_name = "Unknown"; + UByte checksum = 0; + + for( i = 0; i < EDID_LENGTH; i++ ) + checksum += edid[ i ]; + + // Bad checksum, fail EDID + if ( checksum != 0 ) + return false; + + if ( strncmp( (const char*)edid+EDID_HEADER, (const char*)edid_v1_header, EDID_HEADER_END+1 ) ) + { + // First bytes don't match EDID version 1 header + return false; + } + + + // OVR_DEBUG_LOG_TEXT(( "\n# EDID version %d revision %d\n", + // (int)edid[EDID_STRUCT_VERSION],(int)edid[EDID_STRUCT_REVISION] )); + + // Monitor name and timings + + char serialNumber[14]; + memset( serialNumber, 0, 14 ); + + block = edid + DETAILED_TIMING_DESCRIPTIONS_START; + + for( i = 0; i < NO_DETAILED_TIMING_DESCRIPTIONS; i++, + block += DETAILED_TIMING_DESCRIPTION_SIZE ) + { + + if ( blockType( block ) == MONITOR_NAME ) + { + monitor_name = getMonitorName( block ); + } + + if( blockType( block ) == MONITOR_SERIAL ) + { + memcpy( serialNumber, block + 5, 13 ); + break; + } + } + + UByte vendorString[4] = {0}; + + vendorString[0] = (edid[8] >> 2 & 31) + 64; + vendorString[1] = ((edid[8] & 3) << 3) | (edid[9] >> 5) + 64; + vendorString[2] = (edid[9] & 31) + 64; + + edidResult.ModelNumber = *(UInt16*)&edid[10]; + edidResult.MonitorName = OVR::String(monitor_name); + edidResult.VendorName = OVR::String((const char*)vendorString); + edidResult.SerialNumber = OVR::String(serialNumber); + + // printf( "\tIdentifier \"%s\"\n", monitor_name ); + // printf( "\tVendorName \"%s\"\n", vendorString ); + // printf( "\tModelName \"%s\"\n", monitor_name ); + // printf( "\tModelNumber %d\n", edidResult.ModelNumber ); + // printf( "\tSerialNumber \"%s\"\n", edidResult.SerialNumber.ToCStr() ); + + // FIXME: Get timings as well, though they aren't very useful here + // except for the vertical refresh rate, presumably + + return true; +} + +static int discoverExtendedRifts(OVR::OSX::DisplayDesc* descriptorArray, int inputArraySize, bool edidInfo) +{ + OVR_UNUSED(edidInfo); + int result = 0; + + static bool reportDiscovery = true; + OVR_UNUSED(reportDiscovery); + + CGDirectDisplayID Displays[32]; + uint32_t NDisplays = 0; + CGGetOnlineDisplayList(32, Displays, &NDisplays); + + for (unsigned int i = 0; i < NDisplays; i++) + { + io_service_t port = CGDisplayIOServicePort(Displays[i]); + CFDictionaryRef DispInfo = IODisplayCreateInfoDictionary(port, kNilOptions); + + // Display[i] + + uint32_t vendor = CGDisplayVendorNumber(Displays[i]); + uint32_t product = CGDisplayModelNumber(Displays[i]); + + CGRect desktop = CGDisplayBounds(Displays[i]); + Vector2i desktopOffset(desktop.origin.x, desktop.origin.y); + + if (vendor == 16082 && ( (product == 1)||(product == 2)||(product == 3) ) ) // 7" or HD + { + if( result >= inputArraySize ) + { + CFRelease(DispInfo); + return result; + } + + Sizei monitorResolution(1280, 800); + + // Obtain and parse EDID data. + CFDataRef data = + (CFDataRef)CFDictionaryGetValue(DispInfo, CFSTR(kIODisplayEDIDKey)); + if (!data) + { + CFRelease(DispInfo); + OVR::LogError("[OSX Display] Unable to obtain EDID for Oculus product %d", product); + continue; + } + UByte* edid = (UByte*)CFDataGetBytePtr(data); + OSX::DisplayEDID edidResult; + parseEdid( edid, edidResult ); + + OVR::OSX::DisplayDesc& desc = descriptorArray[result++]; + desc.DisplayID = Displays[i]; + desc.ModelName = edidResult.MonitorName; // User friendly string. + desc.EdidSerialNumber = edidResult.SerialNumber; + desc.LogicalResolutionInPixels = monitorResolution; + desc.DesktopDisplayOffset = desktopOffset; + + switch (product) + { + case 3: desc.DeviceTypeGuess = HmdType_DK2; break; + case 2: desc.DeviceTypeGuess = HmdType_DKHDProto; break; + case 1: desc.DeviceTypeGuess = HmdType_DK1; break; + + default: + case 0: desc.DeviceTypeGuess = HmdType_Unknown; break; + } + + // Hard-coded defaults in case the device doesn't have the data itself. + // DK2 prototypes (0003) or DK HD Prototypes (0002) + if (product == 3 || product == 2) + { + desc.LogicalResolutionInPixels = Sizei(1920, 1080); + desc.NativeResolutionInPixels = Sizei(1080, 1920); + } + else + { + desc.LogicalResolutionInPixels = monitorResolution; + desc.NativeResolutionInPixels = monitorResolution; + } + + //OVR_DEBUG_LOG_TEXT(("Display Found %x:%x\n", vendor, product)); + } + CFRelease(DispInfo); + } + + return result; +} + + +//------------------------------------------------------------------------------------- +// ***** Display + +bool Display::Initialize() +{ + // Nothing to initialize. OS X only supports compatibility mode. + return true; +} + + +bool Display::GetDriverMode(bool& driverInstalled, bool& compatMode, bool& hideDK1Mode) +{ + driverInstalled = false; + compatMode = true; + hideDK1Mode = false; + return true; +} + +bool Display::SetDriverMode(bool /*compatMode*/, bool /*hideDK1Mode*/) +{ + return false; +} + +DisplaySearchHandle* Display::GetDisplaySearchHandle() +{ + return new OSX::OSXDisplaySearchHandle(); +} + +bool Display::InCompatibilityMode( bool displaySearch ) +{ + OVR_UNUSED( displaySearch ); + return true; +} + +int Display::GetDisplayCount( DisplaySearchHandle* handle, bool extended, bool applicationOnly, bool edidInfo ) +{ + OVR_UNUSED(applicationOnly); + + static int extendedCount = -1; + + OSX::OSXDisplaySearchHandle* localHandle = (OSX::OSXDisplaySearchHandle*)handle; + if (localHandle == NULL) + { + OVR::LogError("[OSX Display] No search handle passed into GetDisplayCount. Return 0 rifts."); + return 0; + } + + if (extendedCount == -1 || extended) + { + extendedCount = discoverExtendedRifts(localHandle->cachedDescriptorArray, OSX::OSXDisplaySearchHandle::DescArraySize, edidInfo); + } + + localHandle->extended = true; + localHandle->extendedDisplayCount = extendedCount; + int totalCount = extendedCount; + + /// FIXME: Implement application mode for OS X. + localHandle->application = false; + localHandle->applicationDisplayCount = 0; + + localHandle->displayCount = totalCount; + + return totalCount; +} + +Ptr<Display> Display::GetDisplay( int index, DisplaySearchHandle* handle ) +{ + Ptr<Display> result = NULL; + + if (index < 0) + { + OVR::LogError("[OSX Display] Invalid index given to GetDisplay."); + return NULL; + } + + OSX::OSXDisplaySearchHandle* localHandle = (OSX::OSXDisplaySearchHandle*)handle; + if (localHandle == NULL) + { + OVR::LogError("[OSX Display] No search handle passed into GetDisplay. Return 0 rifts."); + return NULL; + } + + if (localHandle->extended) + { + if (index >= 0 && index < (int)localHandle->extendedDisplayCount) + { + return *new OSX::OSXDisplayGeneric(localHandle->cachedDescriptorArray[index]); + } + + // index -= localHandle->extendedDisplayCount; + } + + if (localHandle->application) + { + OVR::LogError("[OSX Display] Mac does not support application displays."); + } + + return result; +} +} // namespace OVR diff --git a/LibOVR/Src/Displays/OVR_OSX_Display.h b/LibOVR/Src/Displays/OVR_OSX_Display.h new file mode 100644 index 0000000..a69c955 --- /dev/null +++ b/LibOVR/Src/Displays/OVR_OSX_Display.h @@ -0,0 +1,139 @@ +/************************************************************************************ + +Filename : OVR_OSX_Display.h +Content : OSX-specific Display declarations +Created : July 2, 2014 +Authors : James Hughes + +Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved. + +Licensed under the Oculus VR Rift SDK License Version 3.2 (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.2 + +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. + +*************************************************************************************/ + +#ifndef OVR_OSX_Display_h +#define OVR_OSX_Display_h + +#include "OVR_Display.h" + +namespace OVR { namespace OSX { + + +//------------------------------------------------------------------------------------- +// DisplayDesc + +// Display information enumerable through OS . +// TBD: Should we just move this to public header, so it's a const member of Display? +struct DisplayDesc +{ + DisplayDesc() : + DeviceTypeGuess(HmdType_None), + DisplayID(0), + LogicalResolutionInPixels(0), + NativeResolutionInPixels(0) + {} + + HmdTypeEnum DeviceTypeGuess; + uint32_t DisplayID; // This is the device identifier string from MONITORINFO (for app usage) + String ModelName; // This is a "DK2" type string + String EdidSerialNumber; + Sizei LogicalResolutionInPixels; + Sizei NativeResolutionInPixels; + Vector2i DesktopDisplayOffset; +}; + + +//------------------------------------------------------------------------------------- +// DisplayEDID + +// Describes EDID information as reported from our display driver. +struct DisplayEDID +{ + DisplayEDID() : + ModelNumber(0) + {} + + String MonitorName; + UInt16 ModelNumber; + String VendorName; + String SerialNumber; +}; + +//------------------------------------------------------------------------------------- +// OSX Display Search Handle +class OSXDisplaySearchHandle : public DisplaySearchHandle +{ +public: + OSXDisplaySearchHandle() : + extended(false), + application(false), + extendedDisplayCount(0), + applicationDisplayCount(0), + displayCount(0) + {} + virtual ~OSXDisplaySearchHandle() {} + + static const int DescArraySize = 16; + + OSX::DisplayDesc cachedDescriptorArray[DescArraySize]; + bool extended; + bool application; + int extendedDisplayCount; + int applicationDisplayCount; + int displayCount; +}; + +//------------------------------------------------------------------------------------- +// OSXDisplayGeneric + +// Describes OSX display in Compatibility mode, containing basic data +class OSXDisplayGeneric : public Display +{ +public: + OSXDisplayGeneric( const DisplayDesc& dd ) : + Display(dd.DeviceTypeGuess, + dd.DisplayID, + dd.ModelName, + dd.EdidSerialNumber, + dd.LogicalResolutionInPixels, + dd.NativeResolutionInPixels, + dd.DesktopDisplayOffset, + 0, + 0, + false) + { + } + + virtual ~OSXDisplayGeneric() + { + } + + virtual bool InCompatibilityMode() const + { + return true; + } + + // Generic displays are not capable of mirroring + virtual MirrorMode SetMirrorMode( MirrorMode newMode ) + { + OVR_UNUSED( newMode ); + return MirrorDisabled; + } +}; + +}} // namespace OVR::OSX + +#endif // OVR_OSX_Display_h diff --git a/LibOVR/Src/Displays/OVR_OSX_FocusObserver.h b/LibOVR/Src/Displays/OVR_OSX_FocusObserver.h new file mode 100644 index 0000000..e2f28e3 --- /dev/null +++ b/LibOVR/Src/Displays/OVR_OSX_FocusObserver.h @@ -0,0 +1,75 @@ +/************************************************************************************ + +Filename : OVR_OSX_FocusObserver.h +Content : Observer for app focus on OSX +Created : August 5, 2014 +Authors : Jordan Tritell + +Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved. + +Licensed under the Oculus VR Rift SDK License Version 3.2 (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.2 + +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. + +*************************************************************************************/ + +OVR_PRIVATE_FILE + +#ifndef OVR_OSX_FocusObserver_h +#define OVR_OSX_FocusObserver_h + +#include "../Kernel/OVR_Threads.h" +#include "../Kernel/OVR_System.h" +#include "../Kernel/OVR_Lockless.h" + +#include "../Service/Service_NetServer.h" + +namespace OVR { namespace OSX{ + + struct FocusNotifierImpl; + +class AppFocusObserver : public SystemSingletonBase<AppFocusObserver> +{ + OVR_DECLARE_SINGLETON(AppFocusObserver); + +public: + Lock ListLock; + Array<pid_t> AppList; + Service::NetServerListener *listener; + FocusNotifierImpl* impl; + + void OnProcessFocus(pid_t pid); + void SetListener(Service::NetServerListener *_listener); + + pid_t LastProcessId; + pid_t ActiveProcessId; + void AddProcess(pid_t pid); + void nextProcess(); + void RemoveProcess(pid_t pid); + + +protected: + void onAppFocus(pid_t pid); + + pid_t LastAppFocus; + +}; + + + +}} // namespace OVR, OSX + + +#endif /* OVR_OSX_FocusObserver_h */ + diff --git a/LibOVR/Src/Displays/OVR_OSX_FocusObserver.mm b/LibOVR/Src/Displays/OVR_OSX_FocusObserver.mm new file mode 100644 index 0000000..3dd77a8 --- /dev/null +++ b/LibOVR/Src/Displays/OVR_OSX_FocusObserver.mm @@ -0,0 +1,245 @@ +/************************************************************************************
+
+Filename : OVR_OSX_FocusObserver.mm
+Content : Observer for app focus on OSX
+Created : August 5, 2014
+Authors : Jordan Tritell
+
+Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved.
+
+Licensed under the Oculus VR Rift SDK License Version 3.2 (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.2
+
+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.
+
+*************************************************************************************/
+
+OVR_PRIVATE_FILE
+
+#include "OVR_OSX_FocusObserver.h"
+
+#include "../Service/Service_NetServer.h"
+#include "OVR_DisplayEnumerator.h"
+
+#include <Cocoa/Cocoa.h>
+
+OVR_DEFINE_SINGLETON(OVR::OSX::AppFocusObserver);
+
+extern bool ServiceRunningFlag;
+
+@interface FocusNotifier : NSObject <NSApplicationDelegate>{
+ NSWindow *window;
+}
+
+- (void)start;
+
+@property (assign) IBOutlet NSWindow *window;
+
+@end
+
+
+@implementation FocusNotifier
+
+@synthesize window;
+
+- (void) addActivationObserver
+{
+ //subscribe to focus notifications from the workspace
+ [[[NSWorkspace sharedWorkspace] notificationCenter] addObserver:self
+ selector:@selector(activated:)
+ name:NSWorkspaceDidActivateApplicationNotification
+ object:nil];
+
+ //subscribe to termination notifications from the workspace
+ [[[NSWorkspace sharedWorkspace] notificationCenter] addObserver:self
+ selector:@selector(terminated:)
+ name:NSWorkspaceDidTerminateApplicationNotification
+ object:nil];
+}
+
+-(void) activated:(NSNotification *)notification
+{
+ NSRunningApplication *app = [[notification userInfo] objectForKey:@"NSWorkspaceApplicationKey"];
+ pid_t pid = [app processIdentifier];
+ OVR::OSX::AppFocusObserver::GetInstance()->OnProcessFocus(pid);
+ // NSLog(@"Activated: %@", [activatedApp bundleIdentifier]);
+}
+
+-(void) terminated:(NSNotification *)notification
+{
+ NSRunningApplication *app = [[notification userInfo] objectForKey:@"NSWorkspaceApplicationKey"];
+ pid_t pid = [app processIdentifier];
+ OVR::OSX::AppFocusObserver::GetInstance()->RemoveProcess(pid);
+ // NSLog(@"Activated: %@", [activatedApp bundleIdentifier]);
+}
+
+- (void)start
+{
+ //initialize with relevant variables
+ [self addActivationObserver];
+}
+
+@end
+
+
+namespace OVR { namespace OSX{
+
+struct FocusNotifierImpl
+{
+ FocusNotifier* wrapped;
+};
+
+AppFocusObserver::AppFocusObserver():
+ impl(new FocusNotifierImpl),
+ listener(NULL)
+{
+ //initialize with correct values
+ impl->wrapped = [[FocusNotifier alloc] init];
+ [impl->wrapped start];
+ ActiveProcessId = 0;
+}
+
+AppFocusObserver::~AppFocusObserver()
+{
+ [impl->wrapped dealloc];
+ delete impl;
+}
+
+void AppFocusObserver::SetListener(Service::NetServerListener *_listener)
+{
+ listener = _listener;
+}
+
+void AppFocusObserver::OnSystemDestroy()
+{
+}
+
+void AppFocusObserver::OnProcessFocus(pid_t pid)
+{
+ // If the process changed,
+ if (pid != LastProcessId)
+ {
+ LastProcessId = pid;
+
+ Lock::Locker locker(&ListLock);
+
+ // Find the process id in the list
+ const int count = AppList.GetSizeI();
+ for (int i = 0; i < count; ++i)
+ {
+ // If it is a rift process,
+ if (AppList[i] == pid)
+ {
+ onAppFocus(pid);
+ OVR_DEBUG_LOG(("[AppFocusObserver] Oculus Process getting focus: pid=%d", pid));
+ return;
+ }
+ }
+
+ OVR_DEBUG_LOG(("[AppFocusObserver] Focus change: %d (non-Oculus process)", pid));
+ }
+}
+
+void AppFocusObserver::AddProcess(pid_t pid)
+{
+ Lock::Locker locker(&ListLock);
+
+ // If it already exists in the array,
+ const int count = AppList.GetSizeI();
+ for (int i = 0; i < count; ++i)
+ {
+ // If we found it,
+ if (AppList[i] == pid)
+ {
+ return;
+ }
+ }
+
+ // If the process being added is already in focus,
+ if (pid == LastProcessId)
+ {
+ // Set the active process
+ OVR_DEBUG_LOG(("[AppFocusObserver] AddProcess: Recognizing the newly added process as in-focus pid=%d", pid));
+ }
+
+ // Add it to the list
+ AppList.PushBack(pid);
+}
+
+void AppFocusObserver::nextProcess()
+{
+ Lock::Locker locker(&ListLock);
+
+ int count = AppList.GetSizeI();
+
+ // Pick the next available rift process
+ if (count > 0)
+ {
+ ActiveProcessId = AppList[0];
+ OVR_DEBUG_LOG(("[AppFocusObserver] NextProcess: Switching active rift process to pid=%d", ActiveProcessId));
+ onAppFocus(ActiveProcessId);
+ return;
+ }
+
+ // No process to use
+ onAppFocus(ActiveProcessId);
+ OVR_DEBUG_LOG(("[AppFocusObserver] NextProcess: No remaining rift processes"));
+}
+
+
+void AppFocusObserver::onAppFocus(pid_t pid)
+{
+ // Note: This is not necessarily the same as the FocusState->ActiveProcessId.
+
+ ActiveProcessId = pid;
+
+ if (ActiveProcessId == 0) return;
+
+ if (pid != LastAppFocus)
+ {
+ LastAppFocus = pid;
+ if(listener){
+ listener->onFocusChange(pid);
+ }
+// FocusSubject->Call(pid);
+ }
+}
+
+void AppFocusObserver::RemoveProcess(pid_t pid)
+{
+ Lock::Locker locker(&ListLock);
+
+ // Find the pid in the app list:
+ const int count = AppList.GetSizeI();
+ for (int i = 0; i < count; ++i)
+ {
+ // If the app was found,
+ if (AppList[i] == pid)
+ {
+ // Remove from list here
+ AppList.RemoveAtUnordered(i);
+
+ // If the removed process is the active one,
+ if (ActiveProcessId == pid)
+ {
+ OVR_DEBUG_LOG(("[AppFocusObserver] RemoveProcess: Active process going away"));
+ // Find a new active process
+ nextProcess();
+ }
+
+ break;
+ }
+ }
+}
+}} //namespace OVR::OSX
+
diff --git a/LibOVR/Src/Displays/OVR_OSX_FocusReader.h b/LibOVR/Src/Displays/OVR_OSX_FocusReader.h new file mode 100644 index 0000000..dbfe9f6 --- /dev/null +++ b/LibOVR/Src/Displays/OVR_OSX_FocusReader.h @@ -0,0 +1,45 @@ +/************************************************************************************ + +Filename : OVR_OSX_FocusReader.h +Content : Reader for current app with focus on OSX +Created : August 5, 2014 +Authors : Jordan Tritell + +Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved. + +Licensed under the Oculus VR Rift SDK License Version 3.2 (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.2 + +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. + +*************************************************************************************/ + +OVR_PRIVATE_FILE + +#ifndef OVR_OSX_FocusReader_h +#define OVR_OSX_FocusReader_h + +#import <Cocoa/Cocoa.h> + +@interface FocusReader : NSObject <NSApplicationDelegate>{ + NSWindow *window; +} + +- (void)start; + +@property (assign) IBOutlet NSWindow *window; + +@end + +#endif /* OVR_OSX_FocusReader_h */ + diff --git a/LibOVR/Src/Displays/OVR_OSX_FocusReader.mm b/LibOVR/Src/Displays/OVR_OSX_FocusReader.mm new file mode 100644 index 0000000..bed95d6 --- /dev/null +++ b/LibOVR/Src/Displays/OVR_OSX_FocusReader.mm @@ -0,0 +1,75 @@ +/************************************************************************************
+
+Filename : OVR_OSX_FocusReader.mm
+Content : Reader for current app with focus on OSX
+Created : August 5, 2014
+Authors : Jordan Tritell
+
+Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved.
+
+Licensed under the Oculus VR Rift SDK License Version 3.2 (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.2
+
+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.
+
+*************************************************************************************/
+
+OVR_PRIVATE_FILE
+
+#import "OVR_OSX_FocusReader.h"
+#import "OVR_OSX_FocusObserver.h"
+
+@implementation FocusReader
+
+@synthesize window;
+
+- (void) addActivationObserver
+{
+ //subscribe to focus notifications from the workspace
+ [[[NSWorkspace sharedWorkspace] notificationCenter] addObserver:self
+ selector:@selector(activated:)
+ name:NSWorkspaceDidActivateApplicationNotification
+ object:nil];
+
+ //subscribe to focus notifications from the workspace
+ [[[NSWorkspace sharedWorkspace] notificationCenter] addObserver:self
+ selector:@selector(terminated:)
+ name:NSWorkspaceDidTerminateApplicationNotification
+ object:nil];
+}
+
+-(void) activated:(NSNotification *)notification
+{
+ NSRunningApplication *app = [[notification userInfo] objectForKey:@"NSWorkspaceApplicationKey"];
+ pid_t pid = [app processIdentifier];
+ OVR::OSX::AppFocusObserver::GetInstance()->OnProcessFocus(pid);
+ // NSLog(@"Activated: %@", [activatedApp bundleIdentifier]);
+}
+
+-(void) terminated:(NSNotification *)notification
+{
+ NSRunningApplication *app = [[notification userInfo] objectForKey:@"NSWorkspaceApplicationKey"];
+ pid_t pid = [app processIdentifier];
+ OVR::OSX::AppFocusObserver::GetInstance()->RemoveProcess(pid);
+ // NSLog(@"Activated: %@", [activatedApp bundleIdentifier]);
+}
+
+- (void)start
+{
+ //initialize with relevant variables
+ [self addActivationObserver];
+}
+
+@end
+
+
diff --git a/LibOVR/Src/Displays/OVR_Win32_Display.cpp b/LibOVR/Src/Displays/OVR_Win32_Display.cpp new file mode 100644 index 0000000..677c619 --- /dev/null +++ b/LibOVR/Src/Displays/OVR_Win32_Display.cpp @@ -0,0 +1,1323 @@ +/************************************************************************************
+
+Filename : OVR_Win32_Display.cpp
+Content : Win32 Display implementation
+Created : May 6, 2014
+Authors : Dean Beeler
+
+Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved.
+
+Licensed under the Oculus VR Rift SDK License Version 3.2 (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.2
+
+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.
+
+*************************************************************************************/
+
+#include <Windows.h>
+
+#include "OVR_Win32_Display.h"
+#include "OVR_Win32_Dxgi_Display.h"
+
+#include <stdio.h>
+#include <tchar.h>
+#include <string.h>
+#include <stdlib.h>
+#include <winioctl.h>
+#include <SetupAPI.h>
+#include <Mmsystem.h>
+#include <conio.h>
+
+#ifdef OVR_COMPAT_EDID_VIA_WMI
+# pragma comment(lib, "wbemuuid.lib")
+#include <wbemidl.h>
+#else // OVR_COMPAT_EDID_VIA_WMI
+#include <setupapi.h>
+#include <initguid.h>
+#endif // OVR_COMPAT_EDID_VIA_WMI
+
+// WIN32_LEAN_AND_MEAN included in OVR_Atomic.h may break 'byte' declaration.
+#ifdef WIN32_LEAN_AND_MEAN
+ typedef unsigned char byte;
+#endif
+
+#include "../Kernel/OVR_String.h"
+#include "../Kernel/OVR_Log.h"
+
+typedef struct
+{
+ HANDLE hDevice;
+ UINT ExpectedWidth;
+ UINT ExpectedHeight;
+ HWND hWindow;
+ bool CompatibilityMode;
+ bool HideDK1Mode;
+} ContextStruct;
+
+static ContextStruct GlobalDisplayContext = {0};
+
+
+//-------------------------------------------------------------------------------------
+// ***** Display enumeration Helpers
+
+// THere are two ways to enumerate display: through our driver (DeviceIoControl)
+// and through Win32 EnumDisplayMonitors (compatibility mode).
+
+
+namespace OVR {
+
+ULONG getRiftCount( HANDLE hDevice )
+{
+ ULONG riftCount = 0;
+ DWORD bytesReturned = 0;
+
+ BOOL result = DeviceIoControl( hDevice, IOCTL_RIFTMGR_GET_RIFT_COUNT, NULL, 0,
+ &riftCount, sizeof( ULONG ), &bytesReturned, NULL );
+
+ if( result )
+ return riftCount;
+ else
+ return 0;
+}
+
+ULONG getRift( HANDLE hDevice, int index )
+{
+ ULONG riftCount = getRiftCount( hDevice );
+ DWORD bytesReturned = 0;
+ BOOL result;
+
+ if( riftCount >= (ULONG)index )
+ {
+ RIFT_STATUS riftStatus[16] = {0};
+
+ result = DeviceIoControl( hDevice, IOCTL_RIFTMGR_GET_RIFT_ARRAY, riftStatus,
+ riftCount * sizeof( RIFT_STATUS ), &riftCount,
+ sizeof( ULONG ), &bytesReturned, NULL );
+ if( result )
+ {
+ PRIFT_STATUS tmpRift;
+ unsigned int i;
+ for( i = 0, tmpRift = riftStatus; i < riftCount; ++i, ++tmpRift )
+ {
+ if( i == (unsigned int)index )
+ return tmpRift->childUid;
+ }
+ }
+ else
+ {
+ printf("Failed to get array of rift devices\n");
+ }
+ }
+
+ return 0;
+}
+
+#define EDID_LENGTH 0x80
+
+#define EDID_HEADER 0x00
+#define EDID_HEADER_END 0x07
+
+#define ID_MANUFACTURER_NAME 0x08
+#define ID_MANUFACTURER_NAME_END 0x09
+
+#define EDID_STRUCT_VERSION 0x12
+#define EDID_STRUCT_REVISION 0x13
+
+#define ESTABLISHED_TIMING_1 0x23
+#define ESTABLISHED_TIMING_2 0x24
+#define MANUFACTURERS_TIMINGS 0x25
+
+#define DETAILED_TIMING_DESCRIPTIONS_START 0x36
+#define DETAILED_TIMING_DESCRIPTION_SIZE 18
+#define NO_DETAILED_TIMING_DESCRIPTIONS 4
+
+#define DETAILED_TIMING_DESCRIPTION_1 0x36
+#define DETAILED_TIMING_DESCRIPTION_2 0x48
+#define DETAILED_TIMING_DESCRIPTION_3 0x5a
+#define DETAILED_TIMING_DESCRIPTION_4 0x6c
+
+#define MONITOR_NAME 0xfc
+#define MONITOR_LIMITS 0xfd
+#define MONITOR_SERIAL 0xff
+
+#define UNKNOWN_DESCRIPTOR -1
+#define DETAILED_TIMING_BLOCK -2
+
+#define DESCRIPTOR_DATA 5
+
+const byte edid_v1_header[] = { 0x00, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0x00 };
+
+const byte edid_v1_descriptor_flag[] = { 0x00, 0x00 };
+
+
+static int blockType( byte* block )
+{
+ if ( !strncmp( (const char*)edid_v1_descriptor_flag, (const char*)block, 2 ) )
+ {
+ // descriptor
+ if ( block[ 2 ] != 0 )
+ return UNKNOWN_DESCRIPTOR;
+ return block[ 3 ];
+ }
+ else
+ {
+ return DETAILED_TIMING_BLOCK;
+ }
+}
+
+static char* getMonitorName( byte const* block )
+{
+ static char name[ 13 ];
+ unsigned i;
+ byte const* ptr = block + DESCRIPTOR_DATA;
+
+ for( i = 0; i < 13; i++, ptr++ )
+ {
+ if ( *ptr == 0xa )
+ {
+ name[ i ] = 0;
+ return name;
+ }
+
+ name[ i ] = *ptr;
+ }
+
+ return name;
+}
+
+
+static bool parseEdid( byte* edid, OVR::Win32::DisplayEDID& edidResult )
+{
+ unsigned i;
+ byte* block;
+ char* monitor_name = "Unknown";
+ byte checksum = 0;
+
+ for( i = 0; i < EDID_LENGTH; i++ )
+ checksum += edid[ i ];
+
+ // Bad checksum, fail EDID
+ if ( checksum != 0 )
+ return false;
+
+ if ( strncmp( (const char*)edid+EDID_HEADER, (const char*)edid_v1_header, EDID_HEADER_END+1 ) )
+ {
+ // First bytes don't match EDID version 1 header
+ return false;
+ }
+
+ //printf( "\n# EDID version %d revision %d\n", (int)edid[EDID_STRUCT_VERSION],(int)edid[EDID_STRUCT_REVISION] );
+
+ // Monitor name and timings
+
+ char serialNumber[14];
+ memset( serialNumber, 0, 14 );
+
+ block = edid + DETAILED_TIMING_DESCRIPTIONS_START;
+
+ for( i = 0; i < NO_DETAILED_TIMING_DESCRIPTIONS; i++,
+ block += DETAILED_TIMING_DESCRIPTION_SIZE )
+ {
+
+ if ( blockType( block ) == MONITOR_NAME )
+ {
+ monitor_name = getMonitorName( block );
+ }
+
+ if( blockType( block ) == MONITOR_SERIAL )
+ {
+ memcpy( serialNumber, block + 5, 13 );
+ break;
+ }
+ }
+
+ BYTE vendorString[4] = {0};
+
+ vendorString[0] = (edid[8] >> 2 & 31) + 64;
+ vendorString[1] = ((edid[8] & 3) << 3) | (edid[9] >> 5) + 64;
+ vendorString[2] = (edid[9] & 31) + 64;
+
+ edidResult.ModelNumber = *(UINT16*)&edid[10];
+ edidResult.MonitorName = OVR::String(monitor_name);
+ edidResult.VendorName = OVR::String((const char*)vendorString);
+ edidResult.SerialNumber = OVR::String(serialNumber);
+
+#if 0
+ printf( "\tIdentifier \"%s\"\n", monitor_name );
+ printf( "\tVendorName \"%s\"\n", vendorString );
+ printf( "\tModelName \"%s\"\n", monitor_name );
+ printf( "\tModelNumber %d\n", modelNumber );
+ printf( "\tSerialNumber \"%x\"\n", *serialPointer );
+#endif
+
+ // FIXME: Get timings as well, though they aren't very useful here
+ // except for the vertical refresh rate, presumably
+
+ return true;
+}
+
+static bool getEdid(HANDLE hDevice, ULONG uid, OVR::Win32::DisplayEDID& edidResult)
+{
+ ULONG riftCount = 0;
+ DWORD bytesReturned = 0;
+ RIFT_STATUS riftStatus[16] = {0};
+
+ BOOL result = DeviceIoControl( hDevice, IOCTL_RIFTMGR_GET_RIFT_COUNT, NULL, 0,
+ &riftCount, sizeof( ULONG ), &bytesReturned, NULL );
+
+ if (!result)
+ {
+ return false;
+ }
+
+ result = DeviceIoControl( hDevice, IOCTL_RIFTMGR_GET_RIFT_ARRAY, &riftStatus,
+ riftCount * sizeof( RIFT_STATUS ), &riftCount, sizeof(ULONG),
+ &bytesReturned, NULL );
+ if (!result)
+ {
+ return false;
+ }
+
+ for (ULONG i = 0; i < riftCount; ++i)
+ {
+ ULONG riftUid = riftStatus[i].childUid;
+ if (riftUid == uid)
+ {
+ char edidBuffer[512];
+
+ result = DeviceIoControl(hDevice, IOCTL_RIFTMGR_GETEDID, &riftUid, sizeof(ULONG),
+ edidBuffer, 512, &bytesReturned, NULL);
+
+ if (result)
+ {
+ if (parseEdid((byte*)edidBuffer, edidResult))
+ {
+ return true;
+ }
+ else
+ {
+ OVR_DEBUG_LOG(("[Win32Display] WARNING: The driver was not able to return EDID for a display"));
+ }
+ }
+
+ break;
+ }
+ }
+
+ return false;
+}
+
+
+// Used to capture all the active monitor handles
+struct MonitorSet
+{
+ enum { MaxMonitors = 8 };
+ HMONITOR Monitors[MaxMonitors];
+ int MonitorCount;
+ int PrimaryCount;
+};
+
+static 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;
+};
+
+#ifdef OVR_COMPAT_EDID_VIA_WMI
+
+static bool getCompatDisplayEDID( WCHAR* displayName, String& serialNumberStr, String& userFriendlyNameStr )
+{
+ IWbemLocator *pLoc = NULL;
+ IWbemServices *pSvc = NULL;
+ HRESULT hres;
+
+ static bool initialized = false;
+ static bool selfInitialized = true;
+ if (!initialized)
+ {
+ hres = CoInitializeEx(0, COINIT_MULTITHREADED);
+ if (FAILED(hres))
+ {
+
+ LogError("{ERR-082} [Display] WARNING: Failed to initialize COM library. Error code = 0x%x", hres);
+ OVR_ASSERT(false);
+ return false;
+ }
+
+ hres = CoInitializeSecurity(
+ NULL,
+ -1, // COM authentication
+ NULL, // Authentication services
+ NULL, // Reserved
+ RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication
+ RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation
+ NULL, // Authentication info
+ EOAC_NONE, // Additional capabilities
+ NULL // Reserved
+ );
+
+ if (FAILED(hres))
+ {
+ LogError("{ERR-083} [Display] WARNING: Failed to initialize security. Error code = 0x%x", hres);
+ OVR_ASSERT(false);
+ selfInitialized = false;
+ }
+
+ initialized = true;
+ }
+
+ hres = CoCreateInstance(
+ CLSID_WbemLocator,
+ 0,
+ CLSCTX_INPROC_SERVER,
+ IID_IWbemLocator, (LPVOID *)&pLoc);
+
+ if (FAILED(hres))
+ {
+ LogError("{ERR-084} [Display] WARNING: Failed to create IWbemLocator object.Err code = 0x%x", hres);
+ OVR_ASSERT(false);
+ return false;
+ }
+
+ BSTR AbackB = SysAllocString(L"root\\WMI");
+ // Connect to the root\cimv2 namespace with
+ // the current user and obtain pointer pSvc
+ // to make IWbemServices calls.
+ hres = pLoc->ConnectServer(
+ AbackB, // Object path of WMI namespace
+ NULL, // User name. NULL = current user
+ NULL, // User password. NULL = current
+ 0, // Locale. NULL indicates current
+ NULL, // Security flags.
+ 0, // Authority (e.g. Kerberos)
+ 0, // Context object
+ &pSvc // pointer to IWbemServices proxy
+ );
+ SysFreeString(AbackB);
+
+ if (FAILED(hres))
+ {
+ LogError("{ERR-085} [Display] WARNING: Could not connect to root\\WMI. Error code = 0x%x", hres);
+ OVR_ASSERT(false);
+ pLoc->Release();
+ return false;
+ }
+
+ hres = CoSetProxyBlanket(
+ pSvc, // Indicates the proxy to set
+ RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx
+ RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx
+ NULL, // Server principal name
+ RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx
+ RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
+ NULL, // client identity
+ EOAC_NONE // proxy capabilities
+ );
+
+ if (FAILED(hres))
+ {
+ LogError("{ERR-086} [Display] WARNING: Could not set proxy blanket. Error code = 0x%x", hres);
+ OVR_ASSERT(false);
+ pSvc->Release();
+ pLoc->Release();
+ return false;
+ }
+
+
+ BSTR wql = SysAllocString(L"WQL");
+ BSTR select = SysAllocString(L"SELECT * FROM WmiMonitorID");
+ IEnumWbemClassObject* pEnumerator = NULL;
+ hres = pSvc->ExecQuery(
+ wql,
+ select,
+ WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
+ NULL,
+ &pEnumerator);
+ SysFreeString(wql);
+ SysFreeString(select);
+
+ if (FAILED(hres))
+ {
+ LogError("{ERR-087} [Display] WARNING: Query for operating system name failed. Error code = 0x%x", hres);
+ OVR_ASSERT(false);
+ pSvc->Release();
+ pLoc->Release();
+ return false;
+ }
+
+ int enumeratedCount = 0;
+ bool found = false;
+
+ IWbemClassObject *pclsObj = 0;
+ while (pEnumerator)
+ {
+ ULONG uReturn = 0;
+ HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);
+
+ if (FAILED(hr) || !uReturn)
+ {
+ break;
+ }
+
+ ++enumeratedCount;
+
+ VARIANT vtProp;
+ hr = pclsObj->Get(L"InstanceName", 0, &vtProp, 0, 0);
+
+ WCHAR* instanceName = vtProp.bstrVal;
+ WCHAR* nextToken = NULL;
+ if (SUCCEEDED(hr) &&
+ wcstok_s(instanceName, L"\\", &nextToken) != NULL)
+ {
+ WCHAR* aToken = wcstok_s(NULL, L"\\", &nextToken);
+
+ if (aToken != NULL)
+ {
+ VariantClear(&vtProp);
+
+ if (wcscmp(aToken, displayName) != 0)
+ {
+ pclsObj->Release();
+ continue;
+ }
+
+ // Read serial
+
+ hr = pclsObj->Get(L"SerialNumberID", 0, &vtProp, 0, 0);
+
+ if (SUCCEEDED(hr))
+ {
+ if (vtProp.vt != VT_NULL && vtProp.parray != NULL)
+ {
+ static const int MaxSerialBytes = 14;
+ char serialNumber[MaxSerialBytes] = { 0 };
+
+ UINT32* serialArray = (UINT32*)vtProp.parray->pvData;
+ for (int i = 0; i < MaxSerialBytes; ++i)
+ {
+ serialNumber[i] = (BYTE)(serialArray[i] & 0xff);
+ }
+
+ serialNumber[sizeof(serialNumber)-1] = '\0';
+ serialNumberStr = serialNumber;
+ }
+ else
+ {
+ LogError("{ERR-088} [Display] WARNING: Wrong data format for SerialNumberID");
+ }
+
+ VariantClear(&vtProp);
+ }
+ else
+ {
+ LogError("{ERR-089} [Display] WARNING: Failure getting display SerialNumberID: %d", (int)hr);
+ }
+
+ // Read length of name
+
+ int userFriendlyNameLen = 0;
+
+ hr = pclsObj->Get(L"UserFriendlyNameLength", 0, &vtProp, 0, 0);
+
+ if (SUCCEEDED(hr))
+ {
+ if (vtProp.vt != VT_NULL)
+ {
+ userFriendlyNameLen = vtProp.iVal;
+
+ if (userFriendlyNameLen <= 0)
+ {
+ userFriendlyNameLen = 0;
+
+ LogError("{ERR-090} [Display] WARNING: UserFriendlyNameLength = 0");
+ }
+ }
+ else
+ {
+ LogError("{ERR-091} [Display] WARNING: Wrong data format for UserFriendlyNameLength");
+ }
+
+ VariantClear(&vtProp);
+ }
+ else
+ {
+ LogError("{ERR-092} [Display] WARNING: Failure getting display UserFriendlyNameLength: %d", (int)hr);
+ }
+
+ // Read name
+
+ hr = pclsObj->Get(L"UserFriendlyName", 0, &vtProp, 0, 0);
+
+ if (SUCCEEDED(hr) && userFriendlyNameLen > 0)
+ {
+ if (vtProp.vt != VT_NULL && vtProp.parray != NULL)
+ {
+ static const int MaxNameBytes = 64;
+ char userFriendlyName[MaxNameBytes] = { 0 };
+
+ UINT32* nameArray = (UINT32*)vtProp.parray->pvData;
+ for (int i = 0; i < MaxNameBytes && i < userFriendlyNameLen; ++i)
+ {
+ userFriendlyName[i] = (BYTE)(nameArray[i] & 0xff);
+ }
+
+ userFriendlyName[sizeof(userFriendlyName)-1] = '\0';
+ userFriendlyNameStr = userFriendlyName;
+ }
+ else
+ {
+ // See: https://developer.oculusvr.com/forums/viewtopic.php?f=34&t=10961
+ // This can happen if someone has an EDID override in the registry.
+ LogError("{ERR-093} [Display] WARNING: Wrong data format for UserFriendlyName");
+ }
+
+ VariantClear(&vtProp);
+ }
+ else
+ {
+ LogError("{ERR-094} [Display] WARNING: Failure getting display UserFriendlyName: %d", (int)hr);
+ }
+ }
+
+ found = true;
+ pclsObj->Release();
+ break;
+ }
+
+ pclsObj->Release();
+ }
+
+ HMODULE hModule = GetModuleHandleA("wbemuuid");
+ if (hModule)
+ {
+ DisableThreadLibraryCalls(hModule);
+ }
+
+ pSvc->Release();
+ pLoc->Release();
+ pEnumerator->Release();
+
+ if (!found)
+ {
+ LogError("{ERR-095} [Display] WARNING: Unable to enumerate the rift via WMI (found %d monitors). This is not normally an issue. Running as a user with Administrator privileges has fixed this problem in the past.", enumeratedCount);
+ OVR_ASSERT(false);
+ }
+
+ return found;
+}
+
+#else // OVR_COMPAT_EDID_VIA_WMI
+
+#define NAME_SIZE 128
+
+DEFINE_GUID(GUID_CLASS_MONITOR,
+ 0x4d36e96e, 0xe325, 0x11ce, 0xbf, 0xc1, 0x08, 0x00, 0x2b, 0xe1,
+ 0x03, 0x18);
+
+static void truncateNonalphanum(char* str, int len)
+{
+ for (int i = 0; i < len; ++i)
+ {
+ char ch = str[i];
+
+ if ((ch < 'A' || ch > 'Z') &&
+ (ch < 'a' || ch > 'z') &&
+ (ch < '0' || ch > '9') &&
+ ch != ' ')
+ {
+ str[i] = '\0';
+ break;
+ }
+ }
+}
+
+static bool AccessDeviceRegistry(IN HDEVINFO devInfo, IN PSP_DEVINFO_DATA devInfoData,
+ const WCHAR* displayName, String& serialNumberStr, String& userFriendlyNameStr)
+{
+ // Match hardware id to display name
+ WCHAR hardwareId[128];
+ if (!SetupDiGetDeviceRegistryProperty(
+ devInfo,
+ devInfoData,
+ SPDRP_HARDWAREID,
+ NULL,
+ (PBYTE)hardwareId,
+ sizeof(hardwareId),
+ NULL))
+ {
+ LogError("{ERR-096} [Display] WARNING: SetupDiGetDeviceRegistryProperty for SPDRP_HARDWAREID failed. LastErr=%d", GetLastError());
+ OVR_ASSERT(false);
+ return false;
+ }
+ hardwareId[127] = 0;
+
+ // If the hardware id did not match,
+ if (!wcsstr(hardwareId, displayName))
+ {
+ // Stop here
+ return false;
+ }
+
+ // Grab hardware info registry key
+ HKEY hDevRegKey = SetupDiOpenDevRegKey(
+ devInfo,
+ devInfoData,
+ DICS_FLAG_GLOBAL,
+ 0,
+ DIREG_DEV,
+ KEY_READ); // Only read permissions so it can be run without Administrator privs
+
+ if (hDevRegKey == INVALID_HANDLE_VALUE)
+ {
+ LogError("{ERR-097} [Display] WARNING: SetupDiOpenDevRegKey failed. LastErr=%d", GetLastError());
+ OVR_ASSERT(false);
+ return false;
+ }
+
+ // Enumerate keys in registry
+ bool found = false;
+
+ // For each key,
+ for (int i = 0;; i++)
+ {
+ BYTE EDIDdata[1024];
+ DWORD edidsize = sizeof(EDIDdata);
+
+ DWORD dwType, ActualValueNameLength = NAME_SIZE;
+ CHAR valueName[NAME_SIZE];
+
+ // Read the key value data
+ LSTATUS retValue = RegEnumValueA(
+ hDevRegKey,
+ i,
+ &valueName[0],
+ &ActualValueNameLength,
+ NULL,
+ &dwType,
+ EDIDdata,
+ &edidsize);
+
+ // If no more items in the enumeration,
+ if (retValue == ERROR_NO_MORE_ITEMS)
+ {
+ // Stop here
+ break;
+ }
+
+ // If the request failed,
+ if (FAILED(retValue))
+ {
+ LogError("{ERR-098} [Display] WARNING: RegEnumValueA failed to read a key. LastErr=%d", retValue);
+ OVR_ASSERT(false);
+ }
+ else if (0 == strcmp(valueName, "EDID")) // Value is EDID:
+ {
+ // Tested working for DK1 and DK2:
+
+ char friendlyString[9];
+ memcpy(friendlyString, EDIDdata + 77, 8);
+ truncateNonalphanum(friendlyString, 8);
+ friendlyString[8] = '\0';
+
+ char edidString[14];
+ memcpy(edidString, EDIDdata + 95, 13);
+ truncateNonalphanum(edidString, 13);
+ edidString[13] = '\0';
+
+ serialNumberStr = edidString;
+ userFriendlyNameStr = friendlyString;
+
+ found = true;
+ break;
+ }
+ }
+
+ RegCloseKey(hDevRegKey);
+
+ return found;
+}
+
+static bool getCompatDisplayEDID(const WCHAR* displayName, String& serialNumberStr, String& userFriendlyNameStr)
+{
+ HDEVINFO devInfo = NULL;
+
+ devInfo = SetupDiGetClassDevsEx(
+ &GUID_CLASS_MONITOR, //class GUID
+ NULL, //enumerator
+ NULL, //HWND
+ DIGCF_PRESENT, // Flags //DIGCF_ALLCLASSES|
+ NULL, // device info, create a new one.
+ NULL, // machine name, local machine
+ NULL);// reserved
+
+ if (NULL == devInfo)
+ {
+ return false;
+ }
+
+ DWORD lastError = 0;
+
+ // For each display,
+ for (int i = 0;; i++)
+ {
+ SP_DEVINFO_DATA devInfoData = {};
+ devInfoData.cbSize = sizeof(devInfoData);
+
+ // Grab device info
+ if (SetupDiEnumDeviceInfo(devInfo, i, &devInfoData))
+ {
+ // Access device info from registry
+ if (AccessDeviceRegistry(devInfo, &devInfoData, displayName, serialNumberStr, userFriendlyNameStr))
+ {
+ return true;
+ }
+ }
+ else
+ {
+ lastError = GetLastError();
+
+ // If no more items found,
+ if (lastError != ERROR_NO_MORE_ITEMS)
+ {
+ LogError("{ERR-099} [Display] WARNING: SetupDiEnumDeviceInfo failed. LastErr=%d", lastError);
+ OVR_ASSERT(false);
+ }
+
+ break;
+ }
+ }
+
+ LogError("{ERR-100} [Display] WARNING: SetupDiEnumDeviceInfo did not return the rift display. LastErr=%d", lastError);
+ OVR_ASSERT(false);
+
+ return false;
+}
+
+#endif // OVR_COMPAT_EDID_VIA_WMI
+
+// This is function that's used
+bool anyRiftsInExtendedMode()
+{
+ bool result = false;
+
+ MonitorSet monitors;
+ monitors.MonitorCount = 0;
+ // Get all the monitor handles
+ EnumDisplayMonitors(NULL, NULL, MonitorEnumProc, (LPARAM)&monitors);
+
+ DISPLAY_DEVICE dd, ddm;
+ UINT i, j;
+
+ for( i = 0;
+ (ZeroMemory(&dd, sizeof(dd)), dd.cb = sizeof(dd),
+ EnumDisplayDevices(0, i, &dd, 0)) != 0; i++ )
+ {
+ for( j = 0;
+ (ZeroMemory(&ddm, sizeof(ddm)), ddm.cb = sizeof(ddm),
+ EnumDisplayDevices(dd.DeviceName, j, &ddm, 0)) != 0; j++ )
+ {
+ // Our monitor hardware has string "RTD2205" in it
+ // Nate's device "CVT0003"
+ if( wcsstr(ddm.DeviceID, L"RTD2205") ||
+ wcsstr(ddm.DeviceID, L"CVT0003") ||
+ wcsstr(ddm.DeviceID, L"MST0030") ||
+ wcsstr(ddm.DeviceID, L"OVR00") ) // Part of Oculus EDID.
+ {
+ result = true;
+ }
+ }
+ }
+
+ return result;
+}
+
+static int discoverExtendedRifts(OVR::Win32::DisplayDesc* descriptorArray, int inputArraySize, bool includeEDID)
+{
+ static bool reportDiscovery = true;
+
+ int result = 0;
+
+ MonitorSet monitors;
+ monitors.MonitorCount = 0;
+ // Get all the monitor handles
+ EnumDisplayMonitors(NULL, NULL, MonitorEnumProc, (LPARAM)&monitors);
+
+ DISPLAY_DEVICE dd, ddm;
+ UINT i, j;
+
+ for (i = 0;
+ (ZeroMemory(&dd, sizeof(dd)), dd.cb = sizeof(dd),
+ EnumDisplayDevices(0, i, &dd, 0)) != 0; i++)
+ {
+ for (j = 0;
+ (ZeroMemory(&ddm, sizeof(ddm)), ddm.cb = sizeof(ddm),
+ EnumDisplayDevices(dd.DeviceName, j, &ddm, 0)) != 0; j++)
+ {
+ if( result >= inputArraySize )
+ return result;
+
+ // Our monitor hardware has string "RTD2205" in it
+ // Nate's device "CVT0003"
+ if (wcsstr(ddm.DeviceID, L"RTD2205") ||
+ wcsstr(ddm.DeviceID, L"CVT0003") ||
+ wcsstr(ddm.DeviceID, L"MST0030") ||
+ wcsstr(ddm.DeviceID, L"OVR00") ) // Part of Oculus EDID.
+ {
+ String deviceId(ddm.DeviceID);
+ String displayDeviceName(ddm.DeviceName);
+ Vector2i desktopOffset(0, 0);
+ Sizei monitorResolution(1280, 800);
+
+ // Make a device type guess
+ HmdTypeEnum deviceTypeGuess = HmdType_Unknown;
+ if (wcsstr(ddm.DeviceID, L"OVR0003"))
+ {
+ // DK2 prototypes and variants
+ deviceTypeGuess = HmdType_DK2;
+ // Could also be:
+ // HmdType_CrystalCoveProto
+ }
+ else if (wcsstr(ddm.DeviceID, L"OVR0002"))
+ { // HD Prototypes
+ deviceTypeGuess = HmdType_DKHDProto;
+ // Could also be:
+ // HmdType_DKHD2Proto
+ // HmdType_DKHDProto566Mi
+ }
+ else if (wcsstr(ddm.DeviceID, L"OVR0001"))
+ { // DK1
+ deviceTypeGuess = HmdType_DK1;
+ }
+ else if (wcsstr(ddm.DeviceID, L"OVR00"))
+ { // Future Oculus HMD devices
+ deviceTypeGuess = HmdType_Unknown;
+ }
+ else
+ {
+ deviceTypeGuess = HmdType_DKProto;
+ }
+
+ // Find the matching MONITORINFOEX for this device so we can get the
+ // screen coordinates
+ MONITORINFOEX info;
+ for (int m=0; m < monitors.MonitorCount; m++)
+ {
+ info.cbSize = sizeof(MONITORINFOEX);
+ GetMonitorInfo(monitors.Monitors[m], &info);
+ if (_tcsstr(ddm.DeviceName, info.szDevice) == ddm.DeviceName)
+ { // If the device name starts with the monitor name
+ // then we found the matching DISPLAY_DEVICE and MONITORINFO
+ // so we can gather the monitor coordinates
+ desktopOffset = Vector2i(info.rcMonitor.left, info.rcMonitor.top);
+ break;
+ }
+ }
+
+ WCHAR* instanceBuffer = (WCHAR*)calloc(wcslen(ddm.DeviceID) + 1, sizeof(WCHAR));
+ wcscpy_s(instanceBuffer, wcslen(ddm.DeviceID) + 1, ddm.DeviceID);
+ WCHAR* instanceName = instanceBuffer;
+ WCHAR* nextToken = NULL;
+ if (wcstok_s(instanceName, L"\\", &nextToken))
+ {
+ WCHAR* aToken = wcstok_s(NULL, L"\\", &nextToken);
+
+ if (aToken)
+ {
+ String serialNumberStr, userFriendlyNameStr;
+ if (!includeEDID || getCompatDisplayEDID(aToken, serialNumberStr, userFriendlyNameStr))
+ {
+ // Set descriptor
+ OVR::Win32::DisplayDesc& desc = descriptorArray[result++];
+
+ // If not including EDID,
+ if (!includeEDID)
+ {
+ // If DK2 id,
+ if (wcsstr(ddm.DeviceID, L"OVR0003"))
+ {
+ userFriendlyNameStr = "Rift DK2";
+ }
+ else // Assume DK1 for now:
+ {
+ userFriendlyNameStr = "Rift DK1";
+ }
+ }
+
+ desc.DeviceTypeGuess = deviceTypeGuess;
+ desc.DisplayID = displayDeviceName;
+ desc.ModelName = userFriendlyNameStr;
+ desc.EdidSerialNumber = serialNumberStr;
+ desc.LogicalResolutionInPixels = monitorResolution;
+ desc.DesktopDisplayOffset = desktopOffset;
+
+ // Hard-coded defaults in case the device doesn't have the data itself.
+ // DK2 prototypes (0003) or DK HD Prototypes (0002)
+ if (wcsstr(ddm.DeviceID, L"OVR0003") || wcsstr(ddm.DeviceID, L"OVR0002"))
+ {
+ desc.LogicalResolutionInPixels = Sizei(1920, 1080);
+ desc.NativeResolutionInPixels = Sizei(1080, 1920);
+ }
+ else
+ {
+ desc.LogicalResolutionInPixels = monitorResolution;
+ desc.NativeResolutionInPixels = monitorResolution;
+ }
+ }
+ }
+ }
+
+ if (reportDiscovery)
+ {
+ // Only report once per run
+ OVR_DEBUG_LOG_TEXT(("Display Found %s - %s\n",
+ deviceId.ToCStr(), displayDeviceName.ToCStr()));
+ reportDiscovery = false;
+ }
+
+ free(instanceBuffer);
+
+ break;
+ }
+ }
+ }
+
+ return result;
+}
+
+
+//-------------------------------------------------------------------------------------
+// ***** Display
+
+bool Display::InCompatibilityMode( bool displaySearch )
+{
+ bool result = false;
+ if( displaySearch )
+ {
+ OVR::Win32::DisplayDesc displayArray[8];
+
+ int extendedRiftCount = discoverExtendedRifts(displayArray, 8, false);
+ if( extendedRiftCount )
+ {
+ result = true;
+ }
+ else
+ {
+ result = GlobalDisplayContext.CompatibilityMode;
+ }
+ }
+ else
+ {
+ result = GlobalDisplayContext.CompatibilityMode;
+ }
+
+ return result;
+}
+
+#define OVR_FLAG_COMPATIBILITY_MODE 1
+#define OVR_FLAG_HIDE_DK1 2
+
+bool Display::Initialize()
+{
+ HANDLE hDevice = INVALID_HANDLE_VALUE;
+
+ if (GlobalDisplayContext.hDevice == 0)
+ {
+ hDevice = CreateFile( L"\\\\.\\ovr_video" ,
+ GENERIC_READ | GENERIC_WRITE, NULL,
+ NULL, OPEN_EXISTING, NULL, NULL);
+ }
+ else
+ { // The device has already been created
+ hDevice = GlobalDisplayContext.hDevice;
+ }
+
+ if (hDevice != NULL && hDevice != INVALID_HANDLE_VALUE)
+ {
+ GlobalDisplayContext.hDevice = hDevice;
+ GlobalDisplayContext.CompatibilityMode = false;
+
+ DWORD bytesReturned = 0;
+ LONG compatiblityResult = OVR_STATUS_SUCCESS;
+
+ BOOL result = DeviceIoControl( hDevice, IOCTL_RIFTMGR_GETCOMPATIBILITYMODE, NULL, 0,
+ &compatiblityResult, sizeof( LONG ), &bytesReturned, NULL );
+ if (result)
+ {
+ GlobalDisplayContext.CompatibilityMode = (compatiblityResult & OVR_FLAG_COMPATIBILITY_MODE) != 0;
+ GlobalDisplayContext.HideDK1Mode = (compatiblityResult & OVR_FLAG_HIDE_DK1) != 0;
+ }
+ else
+ {
+ // If calling our driver fails in any way, assume compatibility mode as well
+ GlobalDisplayContext.CompatibilityMode = true;
+ }
+
+ if (!GlobalDisplayContext.CompatibilityMode)
+ {
+ Ptr<DisplaySearchHandle> searchHandle = *Display::GetDisplaySearchHandle();
+
+ // If a display is actually connected, bring up the shim layers so we can actually use it
+ if (GetDisplayCount(searchHandle) > 0)
+ {
+ // FIXME: Initializing DX9 with landscape numbers rather than portrait
+ GlobalDisplayContext.ExpectedWidth = 1080;
+ GlobalDisplayContext.ExpectedHeight = 1920;
+ }
+ else
+ {
+ GlobalDisplayContext.CompatibilityMode = true;
+ }
+
+ }
+ }
+ else
+ {
+ GlobalDisplayContext.CompatibilityMode = true;
+ }
+
+ return true;
+}
+
+bool Display::GetDriverMode(bool& driverInstalled, bool& compatMode, bool& hideDK1Mode)
+{
+ if (GlobalDisplayContext.hDevice == NULL)
+ {
+ driverInstalled = false;
+ compatMode = true;
+ hideDK1Mode = false;
+ }
+ else
+ {
+ driverInstalled = true;
+ compatMode = GlobalDisplayContext.CompatibilityMode;
+ hideDK1Mode = GlobalDisplayContext.HideDK1Mode;
+ }
+
+ return true;
+}
+
+bool Display::SetDriverMode(bool compatMode, bool hideDK1Mode)
+{
+ // If device is not initialized,
+ if (GlobalDisplayContext.hDevice == NULL)
+ {
+ OVR_ASSERT(false);
+ return false;
+ }
+
+ // If no change,
+ if ((compatMode == GlobalDisplayContext.CompatibilityMode) &&
+ (hideDK1Mode == GlobalDisplayContext.HideDK1Mode))
+ {
+ return true;
+ }
+
+ LONG mode_flags = 0;
+ if (compatMode)
+ {
+ mode_flags |= OVR_FLAG_COMPATIBILITY_MODE;
+ }
+ if (hideDK1Mode)
+ {
+ mode_flags |= OVR_FLAG_HIDE_DK1;
+ }
+
+ DWORD bytesReturned = 0;
+ LONG err = 1;
+
+ if (!DeviceIoControl(GlobalDisplayContext.hDevice,
+ IOCTL_RIFTMGR_SETCOMPATIBILITYMODE,
+ &mode_flags,
+ sizeof(LONG),
+ &err,
+ sizeof(LONG),
+ &bytesReturned,
+ NULL) ||
+ (err != 0 && err != -3))
+ {
+ LogError("{ERR-001w} [Win32Display] Unable to set device mode to (compat=%d dk1hide=%d): err=%d",
+ (int)compatMode, (int)hideDK1Mode, (int)err);
+ return false;
+ }
+
+ OVR_DEBUG_LOG(("[Win32Display] Set device mode to (compat=%d dk1hide=%d)",
+ (int)compatMode, (int)hideDK1Mode));
+
+ GlobalDisplayContext.HideDK1Mode = hideDK1Mode;
+ GlobalDisplayContext.CompatibilityMode = compatMode;
+ return true;
+}
+
+DisplaySearchHandle* Display::GetDisplaySearchHandle()
+{
+ return new Win32::Win32DisplaySearchHandle();
+}
+
+// FIXME: The handle parameter will be used to unify GetDisplayCount and GetDisplay calls
+// The handle will be written to the 64-bit value pointed and will store the enumerated
+// display list. This will allow the indexes to be meaningful between obtaining
+// the count. With a single handle the count should be stable
+int Display::GetDisplayCount(DisplaySearchHandle* handle, bool extended, bool applicationOnly, bool extendedEDIDSerials)
+{
+ static int extendedCount = -1;
+ static int applicationCount = -1;
+
+ Win32::Win32DisplaySearchHandle* localHandle = (Win32::Win32DisplaySearchHandle*)handle;
+
+ if( localHandle == NULL )
+ return 0;
+
+ if( extendedCount == -1 || extended )
+ {
+ extendedCount = discoverExtendedRifts(localHandle->cachedDescriptorArray, 16, extendedEDIDSerials);
+ }
+
+ localHandle->extended = true;
+ localHandle->extendedDisplayCount = extendedCount;
+ int totalCount = extendedCount;
+
+ if( applicationCount == -1 || applicationOnly )
+ {
+ applicationCount = getRiftCount(GlobalDisplayContext.hDevice);
+ localHandle->application = true;
+ }
+
+ totalCount += applicationCount;
+ localHandle->applicationDisplayCount = applicationCount;
+ localHandle->displayCount = totalCount;
+
+ return totalCount;
+}
+
+Ptr<Display> Display::GetDisplay(int index, DisplaySearchHandle* handle)
+{
+ Ptr<Display> result;
+
+ if( index < 0 )
+ return result;
+
+ Win32::Win32DisplaySearchHandle* localHandle = (Win32::Win32DisplaySearchHandle*)handle;
+
+ if( localHandle == NULL )
+ return NULL;
+
+ if (localHandle->extended)
+ {
+ if (index >= 0 && index < (int)localHandle->extendedDisplayCount)
+ {
+ return *new Win32::Win32DisplayGeneric(localHandle->cachedDescriptorArray[index]);
+ }
+
+ index -= localHandle->extendedDisplayCount;
+ }
+
+ if(localHandle->application)
+ {
+ if (index >= 0 && index < (int)getRiftCount(GlobalDisplayContext.hDevice))
+ {
+ ULONG riftChildId = getRift(GlobalDisplayContext.hDevice, index);
+ Win32::DisplayEDID dEdid;
+
+ if (!getEdid(GlobalDisplayContext.hDevice, riftChildId, dEdid))
+ {
+ return NULL;
+ }
+
+ // FIXME: We have the EDID. Let's just use that instead.
+ uint32_t nativeWidth = 1080, nativeHeight = 1920;
+ uint32_t logicalWidth = 1920, logicalHeight = 1080;
+ uint32_t rotation = 0;
+
+ switch (dEdid.ModelNumber)
+ {
+ case 0:
+ case 1:
+ nativeWidth = 1280;
+ nativeHeight = 800;
+ logicalWidth = nativeWidth;
+ logicalHeight = nativeHeight;
+ break;
+ case 2:
+ case 3:
+ default:
+ rotation = 90;
+ break;
+ }
+
+ HmdTypeEnum deviceTypeGuess = HmdType_Unknown;
+ switch (dEdid.ModelNumber)
+ {
+ case 3: deviceTypeGuess = HmdType_DK2; break;
+ case 2: deviceTypeGuess = HmdType_DKHDProto; break;
+ case 1: deviceTypeGuess = HmdType_DK1; break;
+ default: break;
+ }
+
+ result = *new Win32::Win32DisplayDriver(
+ deviceTypeGuess,
+ "",
+ dEdid.MonitorName,
+ dEdid.SerialNumber,
+ Sizei(logicalWidth, logicalHeight),
+ Sizei(nativeWidth, nativeHeight),
+ Vector2i(0),
+ dEdid,
+ GlobalDisplayContext.hDevice,
+ riftChildId,
+ rotation);
+ }
+ }
+ return result;
+}
+
+Display::MirrorMode Win32::Win32DisplayDriver::SetMirrorMode( Display::MirrorMode newMode )
+{
+ return newMode;
+}
+
+static bool SetDisplayPower(HANDLE hDevice, ULONG childId, int mode)
+{
+ ULONG_PTR longArray[2];
+
+ longArray[0] = childId;
+ longArray[1] = mode;
+
+ ULONG localResult = 0;
+ DWORD bytesReturned = 0;
+
+ BOOL result = DeviceIoControl(hDevice,
+ IOCTL_RIFTMGR_DISPLAYPOWER,
+ longArray,
+ 2 * sizeof(ULONG_PTR),
+ &localResult,
+ sizeof(ULONG),
+ &bytesReturned,
+ NULL);
+
+ // Note: bytesReturned does not seem to be set
+ return result != FALSE /* && bytesReturned == sizeof(ULONG) */ && mode == (int)localResult;
+}
+
+bool Win32::Win32DisplayDriver::SetDisplaySleep(bool sleep)
+{
+ return SetDisplayPower(hDevice, ChildId, sleep ? 2 : 1);
+}
+
+
+} // namespace OVR
diff --git a/LibOVR/Src/Displays/OVR_Win32_Display.h b/LibOVR/Src/Displays/OVR_Win32_Display.h new file mode 100644 index 0000000..4517d44 --- /dev/null +++ b/LibOVR/Src/Displays/OVR_Win32_Display.h @@ -0,0 +1,182 @@ +/************************************************************************************
+
+Filename : OVR_Win32_Display.h
+Content : Win32-specific Display declarations
+Created : May 6, 2014
+Authors : Dean Beeler
+
+Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved.
+
+Licensed under the Oculus VR Rift SDK License Version 3.2 (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.2
+
+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.
+
+*************************************************************************************/
+
+#ifndef OVR_Win32_Display_h
+#define OVR_Win32_Display_h
+
+#include "OVR_Display.h"
+
+OVR_DISABLE_MSVC_WARNING(4351) // new behavior: elements of array will be default initialized
+
+namespace OVR { namespace Win32 {
+
+
+//-------------------------------------------------------------------------------------
+// DisplayDesc
+
+// Display information enumerable through Win32.
+// TBD: Should we just move this to public header, so it's a const member of Display?
+struct DisplayDesc
+{
+ HmdTypeEnum DeviceTypeGuess; // This is a guess about what type of HMD it is connected to
+ String DisplayID; // This is the device identifier string from MONITORINFO (for app usage)
+ String ModelName; // This is a "DK2" type string
+ String EdidSerialNumber;
+ Sizei LogicalResolutionInPixels;
+ Sizei NativeResolutionInPixels;
+ Vector2i DesktopDisplayOffset;
+};
+
+
+//-------------------------------------------------------------------------------------
+// DisplayEDID
+
+// Describes EDID information as reported from our display driver.
+struct DisplayEDID
+{
+ String MonitorName;
+ UINT16 ModelNumber;
+ String VendorName;
+ String SerialNumber;
+};
+
+class Win32DisplaySearchHandle : public DisplaySearchHandle
+{
+public:
+ static const int ArraySize = 16;
+
+ Win32::DisplayDesc cachedDescriptorArray[ArraySize];
+ bool extended;
+ bool application;
+ int extendedDisplayCount;
+ int applicationDisplayCount;
+ int displayCount;
+
+ Win32DisplaySearchHandle()
+ : cachedDescriptorArray(),
+ extended(),
+ application(false),
+ extendedDisplayCount(0),
+ applicationDisplayCount(0),
+ displayCount(0)
+ {
+ }
+
+ virtual ~Win32DisplaySearchHandle()
+ {
+ }
+};
+
+//-------------------------------------------------------------------------------------
+// Win32DisplayGeneric
+
+// Describes Win32 display in Compatibility mode, containing basic data
+class Win32DisplayGeneric : public Display
+{
+public:
+ Win32DisplayGeneric( const DisplayDesc& dd ) :
+ Display(dd.DeviceTypeGuess,
+ dd.DisplayID,
+ dd.ModelName,
+ dd.EdidSerialNumber,
+ dd.LogicalResolutionInPixels,
+ dd.NativeResolutionInPixels,
+ dd.DesktopDisplayOffset,
+ 0,
+ 0,
+ false)
+ {
+ }
+
+ virtual ~Win32DisplayGeneric()
+ {
+ }
+
+ // Generic displays are not capable of mirroring
+ virtual MirrorMode SetMirrorMode( MirrorMode newMode )
+ {
+ OVR_UNUSED( newMode );
+ return MirrorDisabled;
+ }
+};
+
+
+//-------------------------------------------------------------------------------------
+// Win32DisplayDriver
+
+// Oculus driver based display object.
+class Win32DisplayDriver : public Display
+{
+ HANDLE hDevice;
+ ULONG ChildId;
+ DisplayEDID Edid;
+
+public:
+ Win32DisplayDriver(const HmdTypeEnum deviceTypeGuess,
+ const String& displayID,
+ const String& modelName,
+ const String& edidSerial,
+ const Sizei& logicalRes,
+ const Sizei& nativeRes,
+ const Vector2i& displayOffset,
+ const DisplayEDID& edid,
+ HANDLE hdevice,
+ ULONG child,
+ uint32_t rotation) :
+ Display(deviceTypeGuess,
+ displayID,
+ modelName,
+ edidSerial,
+ logicalRes,
+ nativeRes,
+ displayOffset,
+ child,
+ rotation,
+ true),
+ hDevice(hdevice),
+ ChildId(child),
+ Edid(edid)
+ {
+ }
+
+ virtual ~Win32DisplayDriver()
+ {
+ }
+
+ virtual MirrorMode SetMirrorMode( MirrorMode newMode );
+
+ // Support sleep/wake
+ virtual bool SetDisplaySleep(bool off);
+};
+
+
+}} // namespace OVR::Win32
+
+
+OVR_RESTORE_MSVC_WARNING()
+
+
+#endif // OVR_Win32_Display_h
diff --git a/LibOVR/Src/Displays/OVR_Win32_Dxgi_Display.h b/LibOVR/Src/Displays/OVR_Win32_Dxgi_Display.h new file mode 100644 index 0000000..e801f4a --- /dev/null +++ b/LibOVR/Src/Displays/OVR_Win32_Dxgi_Display.h @@ -0,0 +1,429 @@ +/************************************************************************************
+
+PublicHeader: None
+Filename : dxgi_ovr_filter.h
+Content : Shared usermode/kernel mode definitions for IOCTL functionality.
+ Also used from LibOVR to access the driver.
+Created : January 27, 2014
+Authors : Dean Beeler
+
+Copyright : Copyright 2013 Oculus, LLC. 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_dxgi_ovr_filter_h
+#define OVR_dxgi_ovr_filter_h
+
+#include <Windows.h>
+#include <InitGuid.h>
+
+#define USERMODE_TEST_ROTATION 1
+
+#if USERMODE_TEST_ROTATION // Used only by the um test application
+#define USERMODE_SURFACE_WIDTH 1920
+#define USERMODE_SURFACE_HEIGHT 1080
+#else
+#define USERMODE_SURFACE_WIDTH 1080
+#define USERMODE_SURFACE_HEIGHT 1920
+#endif
+
+#define TEST_ROTATION 0 // Kernel-mode parameters
+
+#if TEST_ROTATION
+#define SURFACE_WIDTH 1920
+#define SURFACE_HEIGHT 1080
+#else
+#define SURFACE_WIDTH 1080
+#define SURFACE_HEIGHT 1920
+#endif
+
+// {46231713-49FD-4922-84E3-9FF907C06803}
+DEFINE_GUID(GUID_DEVINTERFACE_OVRRIFTMGR,
+ 0x46231713, 0x49fd, 0x4922, 0x84, 0xe3, 0x9f, 0xf9, 0x7, 0xc0, 0x68, 0x3);
+
+#define QUERYADAPTER_MAGICSIZE 17836
+#define QUERYADAPTER_MAGICHEADER 0x4f565246 // OVRF
+#define QUERYADAPTER_MAXPATH 2048
+
+#define FUNCTION_INDEX 0xb800
+
+#pragma pack(push,1)
+
+#define OVR_RIFT_MODE_OFF 0 // Disabled
+#define OVR_RIFT_MODE_ENABLED 1 // Enabled
+#define OVR_RIFT_MODE_EXTEND 2 // Extending 2D displays. Without this flag
+ // 2D displays are disabled when the Rift
+ // is active
+#define OVR_RIFT_MODE_FRONTBUFFER 4 // Enable front buffer only for Rift
+#define OVR_RIFT_MODE_LOCKMOUSE 8 // Prevent mouse from entering bounds
+
+#define OVR_ESCAPE_TYPE_HANDLE 1 // Escape to notify driver of our collected handles
+
+#define OVR_FlipImmediate 0x2
+#define OVR_FlipOnNextVSync 0x4
+
+//-----------------------------------------------------------------------------------
+// Structures for application to UM driver
+
+// Kernel32.dll functionality
+typedef HMODULE (WINAPI *WinLoadLibraryA) ( LPCSTR );
+typedef HMODULE (WINAPI *WinLoadLibraryW) ( LPCWSTR );
+typedef HMODULE (WINAPI *WinLoadLibraryExA) ( LPCSTR, HANDLE, DWORD );
+typedef HMODULE (WINAPI *WinLoadLibraryExW) ( LPCWSTR, HANDLE, DWORD );
+typedef BOOL (WINAPI *WinGetModuleHandleExA)( DWORD, LPCSTR, HMODULE* );
+typedef BOOL (WINAPI *WinGetModuleHandleExW)( DWORD, LPCWSTR, HMODULE* );
+
+// Overridden DirectX 9 entry points
+typedef void* (WINAPI *WinDirect3DCreate9)(UINT SDKVersion);
+typedef HRESULT (WINAPI *WinDirect3DCreate9Ex)(UINT SDKVersion, void** aDevice);
+
+// Overridden DXGI entry points
+typedef HRESULT (WINAPI *WinCreateDXGIFactory)(
+ __in REFIID riid,
+ __out void **ppFactory
+ );
+
+typedef HRESULT (WINAPI *WinCreateDXGIFactory1)(
+ __in REFIID riid,
+ __out void **ppFactory
+ );
+
+typedef HRESULT (WINAPI *WinCreateDXGIFactory2)(
+ __in UINT flags,
+ __in const IID &riid,
+ __out void **ppFactory
+ );
+
+// Application usermode callbacks from usermode driver. These
+// functions are all provided by the calling application that uses
+// the filter mode driver
+
+// IsInitializingDisplay is used at runtime to validate that
+// the created resource (RT or bind_present) matches the resolution
+// of our expected backbuffer. If the application returns true,
+// our usermode driver will convert this to a primary
+typedef BOOL (WINAPI *IsInitializingDisplay) ( PVOID, UINT, UINT );
+// RiftForContext is a function that will return the Rift device of
+// the concerned context. This is for targeting a particular
+// device instance with a particular Rift for rendering
+typedef ULONG (WINAPI *RiftForContext)( PVOID, HANDLE );
+// CloseRiftForContext is a function that informs the application
+// the created device is shutting down and the context
+// can freedly disassociate with the particular
+typedef BOOL (WINAPI *CloseRiftForContext)( PVOID, HANDLE, ULONG );
+typedef BOOL (WINAPI *WindowDisplayResolution)( PVOID, UINT*, UINT*, UINT*, UINT*, BOOL* );
+// IsCreatingBackBuffer is a function directed at the runtime shim
+// to confirm that the runtime is actively creating the additional
+// swapchain for rotation and display out to the rift.
+// When creating the original swapchain this function should return false
+// so the orignal swapchain isn't inadvertantly coopted.
+typedef BOOL (WINAPI *IsCreatingBackBuffer)( PVOID );
+// Callback from the usermode driver to obtain the desire to see debug statements from
+// the usermode drivers on the output console. Only called one per usermode driver shim
+// and usermode runtime.
+typedef BOOL (WINAPI *ShouldEnableDebug)( VOID );
+// Callback from the usermode driver to the runtime obtain the vsync status
+typedef BOOL (WINAPI *ShouldVSync)( VOID );
+// Callback from usermode mode and runtime driver to obtain expected native width,
+// height and degrees rotation of the rift
+typedef BOOL (WINAPI *ExpectedResolution)( PVOID, UINT*, UINT*, UINT* );
+// Usermode callback that reports whether or not mirroring is enabled
+typedef BOOL (WINAPI *MirroringEnabled)( PVOID );
+// Callback from the shim for Unity and other plugins used to
+// report the swapchain that was created by the application
+typedef void* (WINAPI *GetDX11SwapChain)( PVOID );
+// Callback to report the HWND associated with this context
+typedef HWND (WINAPI* GetWindowForContext)( PVOID );
+// Should present Rift on context
+typedef BOOL (WINAPI* PresentRiftOnContext)( PVOID );
+// Used by a pre-loaded shim (d3d9, dxgi, opengl32) to
+// identify which api version we loaded
+// 1 = OpenGL
+// 9 = DirectX 9
+// 10 = DirectX 1X
+typedef int (WINAPI* ActiveAPIVersion)( PVOID );
+
+// Get the version of the runtime filter.
+typedef ULONG (WINAPI* GetRTFilterVersion)();
+
+#pragma warning(push)
+#pragma warning(disable: 4201)
+
+typedef struct _LINK_APPLICATION_DRIVER
+{
+ UINT32 version;
+ PVOID context;
+
+ union
+ {
+ struct
+ {
+ IsInitializingDisplay pfnInitializingDisplay;
+ RiftForContext pfnRiftForContext;
+ CloseRiftForContext pfnCloseRiftForContext;
+ WindowDisplayResolution pfnWindowDisplayResolution;
+ IsCreatingBackBuffer pfnIsCreatingBackBuffer;
+ ShouldEnableDebug pfnShouldEnableDebug;
+ ShouldVSync pfnShouldVSync;
+ ExpectedResolution pfnExpectedResolution;
+ MirroringEnabled pfnMirroringEnabled;
+ GetDX11SwapChain pfnGetDX11SwapChain;
+ GetWindowForContext pfnGetWindowForContext;
+ PresentRiftOnContext pfnPresentRiftOnContext;
+ ActiveAPIVersion pfnActiveAPIVersion;
+ };
+
+ PROC placeholders[128];
+ };
+
+
+ // Used by Runtime filter for linking with original libraries
+ WinDirect3DCreate9 pfnDirect3DCreate9;
+ WinDirect3DCreate9Ex pfnDirect3DCreate9Ex;
+ WinCreateDXGIFactory pfnCreateDXGIFactory;
+ WinCreateDXGIFactory1 pfnCreateDXGIFactory1;
+ WinCreateDXGIFactory2 pfnCreateDXGIFactory2;
+} LINK_APPLICATION_DRIVER, *PLINK_APPLICATION_DRIVER;
+
+#pragma warning(pop)
+
+
+// OVRDisplay.dll functionality
+typedef HRESULT (WINAPI *PreloadLibraryFn) ( WinLoadLibraryA , LPCSTR, PLINK_APPLICATION_DRIVER appDriver );
+typedef HRESULT (WINAPI *PreloadLibraryRTFn) ( PLINK_APPLICATION_DRIVER appDriver );
+
+//-----------------------------------------------------------------------------------
+// Structures for UM driver to KM driver
+
+typedef struct _QUERY_KM_DRIVER
+{
+ UINT32 magic; // Friend or foe identifier for our filter driver
+ // See: QUERYADAPTER_MAGICHEADER
+ UINT32 maxVidPnSources; // Returns the maximum number of video present network sources
+} QUERY_KM_DRIVER, *PQUERY_KM_DRIVER;
+
+#ifndef _D3DUKMDT_H_
+typedef UINT D3DKMT_HANDLE;
+#endif
+
+typedef struct _HandleNotepad
+{
+ // These are assigned around CreateResource
+ HANDLE hUsermodeInResource;
+ HANDLE hUsermodeOutResource;
+
+ // These are assigned within the kernel with
+ // DxgkDdiCreateAllocation and
+ // DxgkDdiOpenAllocation
+ D3DKMT_HANDLE hAllocation;
+ PVOID hDeviceSpecificHandle;
+ PVOID hKernelDriverHandle;
+
+ // These are assigned around pfnAllocateCb
+ HANDLE hUsermodeSharedResource;
+ D3DKMT_HANDLE hKernelModeSharedResource;
+
+ ULONG childUid;
+
+ UINT pitch;
+
+} HandleNotepad, *PHandleNotepad;
+
+
+typedef struct _ALLOC_PRIVATE_STRUCTURE
+{
+ UINT32 magic; // Friend or foe identifier for our filter driver
+
+ PVOID originalPrivataDataPtr; // Location in usermode of the original private data structure
+ UINT originalPrivateSize; // Size of private data structure at the end of this header
+
+ PVOID hAllocationHandle; // User-mode-assigned allocation handle for CreateAllocation
+ PVOID hDeviceSpecificHandle; // Assigned in kernal OpenAllocation
+ PVOID hInternalHandle; // Assigned in kernal CreateAllocation
+ UINT pitch; // Hinted surface pitch
+
+ BYTE originalPrivateData[1]; // Variable length
+
+
+} ALLOC_PRIVATE_STRUCTURE, *PALLOC_PRIVATE_STRUCTURE;
+
+typedef struct _ESCAPE_STRUCTURE
+{
+ UINT32 magic; // Friend or foe identifier for our filter driver
+
+ UINT32 escapeType; // Specifier for individual type of escape message
+ // Type 1 for notepad
+ union {
+ HandleNotepad notepad;
+ };
+} ESCAPE_STRUCTURE, *PESCAPE_STRUCTURE;
+
+// Structures for internal operation of KM driver
+
+typedef struct _RIFT_SYNC
+{
+ ULONG childUid; // ChildUid as reported by RIFT_STATUS
+ ULONG vsync; // 1 for vsync, 0 for immediate
+} RIFT_SYNC, *PRIFT_SYNC;
+
+typedef struct _RIFT_MODE
+{
+ ULONG childUid; // ChildUid as reported by RIFT_STATUS
+ ULONG mode; // Bitmap of mode values, defined by OVR_RIFT_HOME_*
+ HANDLE userModeHandle; // Handle of render target created in user mode
+ // that's usable as a primary
+} RIFT_MODE, *PRIFT_MODE;
+
+typedef struct _RIFT_STATUS
+{
+ ULONG childUid; // Display driver assigned Uid for this display
+ ULONG mode; // Active rift mode, see OVR_RIFT_MODE_*
+ ULONG serialNumber; // Serial number as reported in the Rift's EDID
+ ULONG textureHandle; // Handle of shared render resource -- NULL if not shared
+} RIFT_STATUS, *PRIFT_STATUS;
+
+typedef struct _RIFT_STATUS_ARRAY
+{
+ ULONG arraySize; // Size of pre-allocated RIFT_STATUS structures.
+ RIFT_STATUS status[1]; // Array of status blocks containing connection information on each Rift
+} RIFT_STATUS_ARRAY, *PRIFT_STATUS_ARRAY;
+
+#pragma pack(pop)
+
+// IOCTL for UM application to KM driver
+
+#define OVR_STATUS_SUCCESS 0
+#define OVR_STATUS_FAIL -1
+#define OVR_STATUS_DRIVER_IN_USE -2
+#define OVR_STATUS_MODE_ALREADY_ACTIVE -3
+#define OVR_STATUS_RIFT_NOT_PRESENT -4
+
+//
+// Returns the number of Rift displays attached to the video adapter
+// If 0, no Rift displays have been connected.
+// If greater than 0, use this size to pre-allocate space for an array
+// of rift statuses
+//
+// Input Buffer: Nothing
+// Output Buffer: LONG - count of Rift displays attached to video adapter
+//
+#define IOCTL_RIFTMGR_GET_RIFT_COUNT CTL_CODE(FILE_DEVICE_VIDEO, \
+ FUNCTION_INDEX, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+//
+// Fills out a pre-allocated array with information on the individually attached
+// screens.
+//
+// On Input, specify the arraySize as the size of the allocation.
+//
+// On Output, the arraySize will be updated with the actual number of Rifts
+// reported. Use IOCTL_RIFTMGR_GET_RIFT_COUNT to query the number of Rifts.
+// If the count changes (added or removed) between calls, the function will either fail
+// due to the buffer being too small, or the arraySize count will be updated
+// with a new count of devices along with their respective parameters.
+//
+// Input Buffer: PRIFT_STATUS - Pointer to allocated status array
+// Output Buffer: LONG - Count of Rift displays reported in the structure. -1 if out of
+// memory
+//
+#define IOCTL_RIFTMGR_GET_RIFT_ARRAY CTL_CODE(FILE_DEVICE_VIDEO, \
+ FUNCTION_INDEX + 1, METHOD_NEITHER, FILE_ANY_ACCESS)
+
+// Changes the mode of an attached Rift (DEPRECATED)
+// Input Buffer: PRIFT_MODE - Pointer to a mode structure specifying the childUid and
+// mode for a particular Rift
+// Output Buffer: LONG - Non-zero on error, 0 on successful mode change
+//
+#define IOCTL_RIFTMGR_SET_RIFT_MODE CTL_CODE(FILE_DEVICE_VIDEO, \
+ FUNCTION_INDEX + 2, METHOD_NEITHER, FILE_ANY_ACCESS)
+
+// Lock the primary of the rift and obtain an address
+// Input Buffer: ULONG - ChildUid of a Rift as previously discovered
+// Output Buffer: ULONG_PTR - Pointer to a usermode mapped address of the primary
+#define IOCTL_RIFTMGR_GET_RIFT_PRIMARY CTL_CODE(FILE_DEVICE_VIDEO, \
+ FUNCTION_INDEX + 3, METHOD_NEITHER, FILE_ANY_ACCESS)
+
+// Release Rift primary
+// Input Buffer: PULONG_PTR - ChildUid of a Rift as previously discovered and virtual pointer
+// Output Buffer: NOTHING
+#define IOCTL_RIFTMGR_RELEASE_RIFT_PRIMARY CTL_CODE(FILE_DEVICE_VIDEO, \
+ FUNCTION_INDEX + 4, METHOD_NEITHER, FILE_ANY_ACCESS)
+
+
+// Point the rift to another render target
+// Input Buffer: PHANDLE - Array of handles, rift and the render target resource
+// Output Buffer: NOTHING
+#define IOCTL_RIFTMGR_SETRIFTBUFFER CTL_CODE(FILE_DEVICE_VIDEO, \
+ FUNCTION_INDEX + 5, METHOD_NEITHER, FILE_ANY_ACCESS)
+
+// Enable or disable vsync on Rift present
+// Input Buffer: PRIFT_SYNC - Pointer to a mode structure specifying the childUid and
+// and sync
+// Output Buffer: NOTHING
+#define IOCTL_RIFTMGR_SETVSYNCMODE CTL_CODE(FILE_DEVICE_VIDEO, \
+ FUNCTION_INDEX + 6, METHOD_NEITHER, FILE_ANY_ACCESS)
+
+// Get scan line
+// Input Buffer: ULONG - ChildUid of a Rift as previously discovered
+// Output Buffer: ULONG - 31st bit is set if in vertical blank, high 15 bits has per second
+// frame number (0-74), low 16 bits has scanline (0-1919)
+#define IOCTL_RIFTMGR_GETSCANLINE CTL_CODE(FILE_DEVICE_VIDEO, \
+ FUNCTION_INDEX + 7, METHOD_NEITHER, FILE_ANY_ACCESS)
+
+// Enable or disable compatibility mode. Entering compatibility mode will fail if
+// the Rift is already actively scanning out a surface
+// Input Buffer: LONG - Bit assignments:
+// LSB (bit 0) is a flag for compatibility mode itself.
+// 1 means compatibility mode.
+// 0 means application direct mode.
+// Bit 1 means "Hide DK1's".
+// 1 means operate DK1's in synchronous with the compatibility mode exactly.
+// 0 means operate in DK1 legacy mode.
+// Output Buffer: LONG - Result value (see OVR statuses)
+// 0 = success
+// -1 = general failure
+// -2 = failure, rift scanning out
+// -3 = already active
+// -4 = rift not present
+#define IOCTL_RIFTMGR_SETCOMPATIBILITYMODE CTL_CODE(FILE_DEVICE_VIDEO, \
+ FUNCTION_INDEX + 8, METHOD_NEITHER, FILE_ANY_ACCESS)
+
+// Call to obtain the current status of compatibility mode
+// Input Buffer: NOTHING
+// Output Buffer: LONG - Bit assignments:
+// LSB (bit 0) is a flag for compatibility mode itself.
+// 1 means compatibility mode.
+// 0 means application direct mode.
+// Bit 1 means "Hide DK1's".
+// 1 means operate DK1's in synchronous with the compatibility mode exactly.
+// 0 means operate in DK1 legacy mode.
+#define IOCTL_RIFTMGR_GETCOMPATIBILITYMODE CTL_CODE(FILE_DEVICE_VIDEO, \
+ FUNCTION_INDEX + 9, METHOD_NEITHER, FILE_ANY_ACCESS)
+
+// Call to set the power mode of a particular Rift
+// Input Buffer: PULONG_PTR - ChildUid of a Rift as previously discovered and ULONG value
+// second ULONG has value of
+// 0 to simply obtain the power status of the display
+// 1 to set the display into a full power state (needs a primary to fully scan out)
+// 2 to set the display into sleep mode
+// 3 to set the display into full power off mode (WARNING: Will potentially trash primary)
+// Output Buffer: LONG - Result value
+// 0 = Failure to obtain power status
+// 1 = Full power
+// 2 = Sleep
+// 3 = Power off
+#define IOCTL_RIFTMGR_DISPLAYPOWER CTL_CODE(FILE_DEVICE_VIDEO, \
+ FUNCTION_INDEX + 10, METHOD_NEITHER, FILE_ANY_ACCESS)
+
+// Return the EDID of the display in the output buffer. The driver
+// will copy as many bytes as possible to fill the buffer.
+// Input Buffer: ULONG - ChildUid of a Rift as previously discovered
+// Output Buffer: PCHAR - Preallocated buffer of a variable size to store the EDID from the display
+#define IOCTL_RIFTMGR_GETEDID CTL_CODE(FILE_DEVICE_VIDEO, \
+ FUNCTION_INDEX + 11, METHOD_NEITHER, FILE_ANY_ACCESS)
+
+#endif
diff --git a/LibOVR/Src/Displays/OVR_Win32_FocusReader.cpp b/LibOVR/Src/Displays/OVR_Win32_FocusReader.cpp new file mode 100644 index 0000000..7c3c7a3 --- /dev/null +++ b/LibOVR/Src/Displays/OVR_Win32_FocusReader.cpp @@ -0,0 +1,79 @@ +/************************************************************************************
+
+Filename : OVR_Win32_FocusReader.cpp
+Content : Reader for current app with focus on Windows
+Created : July 2, 2014
+Authors : Chris Taylor
+
+Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved.
+
+Licensed under the Oculus VR Rift SDK License Version 3.2 (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.2
+
+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.
+
+*************************************************************************************/
+
+#include "OVR_Win32_FocusReader.h"
+#include "../Kernel/OVR_Log.h"
+#include "../Service/Service_NetClient.h"
+
+OVR_DEFINE_SINGLETON(OVR::Win32::RenderFocusReader);
+
+namespace OVR { namespace Win32 {
+
+
+HWND RenderFocusReader::ReadActiveWindow()
+{
+ const LocklessFocusState* focusState = Reader.Get();
+
+ if (!focusState || NoSharedMemory)
+ {
+ if (!Reader.Open(OVR_FOCUS_OBSERVER_SHARE_NAME))
+ {
+ OVR_DEBUG_LOG(("[Win32ShimFunctions] Unable to open the shared memory space"));
+ // Note: This should only warn and not assert because it is normal behavior when the server is not running.
+ NoSharedMemory = true;
+ return 0;
+ }
+
+ focusState = Reader.Get();
+ if (!focusState)
+ {
+ OVR_DEBUG_LOG(("[Win32ShimFunctions] Unable to get the shared memory space"));
+ NoSharedMemory = true;
+ return 0;
+ }
+ }
+
+ return (HWND)Ptr64ToPtr(focusState->ActiveWindowHandle);
+}
+
+RenderFocusReader::RenderFocusReader() :
+ NoSharedMemory(false)
+{
+ // Must be at end of function
+ PushDestroyCallbacks();
+}
+
+RenderFocusReader::~RenderFocusReader()
+{
+}
+
+void RenderFocusReader::OnSystemDestroy()
+{
+ delete this;
+}
+
+
+}} // namespace OVR::Win32
diff --git a/LibOVR/Src/Displays/OVR_Win32_FocusReader.h b/LibOVR/Src/Displays/OVR_Win32_FocusReader.h new file mode 100644 index 0000000..358ab38 --- /dev/null +++ b/LibOVR/Src/Displays/OVR_Win32_FocusReader.h @@ -0,0 +1,81 @@ +/************************************************************************************
+
+Filename : OVR_Win32_FocusReader.h
+Content : Reader for current app with focus on Windows
+Created : July 2, 2014
+Authors : Chris Taylor
+
+Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved.
+
+Licensed under the Oculus VR Rift SDK License Version 3.2 (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.2
+
+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.
+
+*************************************************************************************/
+
+#ifndef OVR_Win32_FocusReader_h
+#define OVR_Win32_FocusReader_h
+
+#include "../Kernel/OVR_System.h"
+#include "../Kernel/OVR_Lockless.h"
+#include "../Kernel/OVR_Array.h"
+#include "../Kernel/OVR_SharedMemory.h"
+
+namespace OVR { namespace Win32 {
+
+
+#define OVR_FOCUS_OBSERVER_SHARE_NAME "OVRAppFocus"
+
+//-----------------------------------------------------------------------------
+// LocklessFocusState
+
+#pragma pack(push, 8)
+
+// Focus state data
+struct LocklessFocusState
+{
+ LocklessFocusState(DWORD pid = 0) :
+ ActiveProcessId(pid),
+ ActiveWindowHandle(NULL)
+ {
+ }
+
+ DWORD ActiveProcessId;
+ void * POINTER_64 ActiveWindowHandle;
+};
+
+#pragma pack(pop)
+
+typedef SharedObjectWriter< LocklessFocusState > SharedFocusWriter;
+typedef SharedObjectReader< LocklessFocusState > SharedFocusReader;
+
+
+//-----------------------------------------------------------------------------
+// RenderFocusReader
+
+class RenderFocusReader : public OVR::SystemSingletonBase<RenderFocusReader>, public NewOverrideBase
+{
+ OVR_DECLARE_SINGLETON(RenderFocusReader);
+
+ SharedFocusReader Reader; // Shared memory reader
+ bool NoSharedMemory; // Flag reporting that no shared memory has been detected;
+
+public:
+ HWND ReadActiveWindow();
+};
+
+
+}} // namespace OVR::Win32
+
+#endif // OVR_Win32_FocusReader_h
diff --git a/LibOVR/Src/Displays/OVR_Win32_RenderShim.cpp b/LibOVR/Src/Displays/OVR_Win32_RenderShim.cpp new file mode 100644 index 0000000..a74ab75 --- /dev/null +++ b/LibOVR/Src/Displays/OVR_Win32_RenderShim.cpp @@ -0,0 +1,974 @@ +/************************************************************************************
+
+Filename : OVR_Win32_DisplayShim.cpp
+Content : Shared static functions for inclusion that allow for an application
+ to inject the usermode driver into an application
+Created : March 21, 2014
+Authors : Dean Beeler
+
+Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved.
+
+Use of this software is subject to the terms of the Oculus Inc license
+agreement provided at the time of installation or download, or which
+otherwise accompanies this software in either electronic or hard copy form.
+
+************************************************************************************/
+
+#include "../../Include/OVR_Version.h"
+
+#ifndef AVOID_LIB_OVR
+#include "../Kernel/OVR_Types.h" // Without this we can get warnings (due to VC++ bugs) about _malloca being redefined, and miss LibOVR overrides.
+#endif
+
+#include <windows.h>
+#include <DbgHelp.h>
+#include <malloc.h>
+
+#include "OVR_Win32_Dxgi_Display.h"
+#include "OVR_Win32_ShimVersion.h"
+
+#if AVOID_LIB_OVR
+#define IN_COMPATIBILITY_MODE() (0)
+#else
+#include "OVR_Win32_Display.h"
+#define IN_COMPATIBILITY_MODE() OVR::Display::InCompatibilityMode()
+#endif
+
+#pragma comment(lib, "DbgHelp.lib")
+
+#define WIDE_TO_MB(wideString) \
+ int wideString ## _slen = (int)wcslen(wideString); \
+ char* wideString ## _cstr = (char*)alloca(wideString ## _slen * 2); \
+ int count = WideCharToMultiByte(GetACP(), 0, wideString, -1, wideString ## _cstr, wideString ## _slen * 2, NULL, NULL); \
+ wideString ## _cstr[count] = '\0';
+
+// Forward declarations
+// These functions are implemented in OVR_Win32_DisplayDevice.cpp.
+
+BOOL WINAPI OVRIsInitializingDisplay( PVOID context, UINT width, UINT height );
+BOOL WINAPI OVRIsCreatingBackBuffer( PVOID context );
+BOOL WINAPI OVRShouldVSync( );
+ULONG WINAPI OVRRiftForContext( PVOID context, HANDLE driverHandle );
+BOOL WINAPI OVRCloseRiftForContext( PVOID context, HANDLE driverHandle, ULONG rift );
+BOOL WINAPI OVRWindowDisplayResolution( PVOID context, UINT* width, UINT* height,
+ UINT* titleHeight, UINT* borderWidth,
+ BOOL* vsyncEnabled );
+BOOL WINAPI OVRExpectedResolution( PVOID context, UINT* width, UINT* height, UINT* rotationInDegrees );
+BOOL WINAPI OVRShouldEnableDebug();
+BOOL WINAPI OVRMirroringEnabled( PVOID context );
+HWND WINAPI OVRGetWindowForContext(PVOID context);
+BOOL WINAPI OVRShouldPresentOnContext(PVOID context);
+
+static const char* GFX_DRIVER_KEY_FMT = "SYSTEM\\CurrentControlSet\\Control\\Class\\{4d36e968-e325-11ce-bfc1-08002be10318}\\%04d";
+#ifdef _WIN64
+static const char* RTFilter = "OVRDisplayRT64.dll";
+static const char* UMFilter = "OVRDisplay64.dll";
+#else
+static const char* RTFilter = "OVRDisplayRT32.dll";
+static const char* UMFilter = "OVRDisplay32.dll";
+#endif
+static const char* OptimusDrivers = "nvumdshimx.dll nvumdshim.dll";
+
+typedef enum OVRTargetAPI
+{
+ DirectX,
+ OpenGL
+};
+
+static PVOID lastContext = NULL;
+LINK_APPLICATION_DRIVER appDriver = {0};
+static INT apiVersion = 10;
+
+static CHAR* ReadRegStr(HKEY keySub, const char* keyName, const char* valName)
+{
+ CHAR *val = NULL;
+ REGSAM access = KEY_READ;
+ HKEY hKey;
+
+TryAgainWOW64:
+ NTSTATUS res = RegOpenKeyExA( keySub, keyName, 0, access, &hKey );
+ if ( res == ERROR_SUCCESS )
+ {
+ DWORD valLen;
+ res = RegQueryValueExA( hKey, valName, NULL, NULL, NULL, &valLen );
+ if( res == ERROR_SUCCESS ) {
+ val = (CHAR*)calloc( valLen + 1, sizeof(CHAR) );
+ res = RegQueryValueExA( hKey, valName, NULL, NULL, (LPBYTE)val, &valLen );
+
+ if( res == ERROR_SUCCESS )
+ {
+ CHAR* byte = val;
+ for( DWORD j = 0; j < valLen; ++j )
+ {
+ if( byte[j] == 0 )
+ byte[j] = ' ';
+ }
+ }
+ else
+ {
+ free( val );
+ val = NULL;
+ }
+ }
+ RegCloseKey( hKey );
+ }
+
+ if( res == ERROR_FILE_NOT_FOUND && keySub == HKEY_LOCAL_MACHINE && access == KEY_READ ) {
+#ifdef _WIN64
+ access = KEY_READ | KEY_WOW64_32KEY;
+#else
+ access = KEY_READ | KEY_WOW64_64KEY;
+#endif
+ goto TryAgainWOW64;
+ }
+ return val;
+}
+
+#define OLD_DATA_BACKUP_SIZE 16
+
+static WinLoadLibraryA oldProcA = NULL; // Note: This is used to indicate that the shim is in place
+static WinLoadLibraryExA oldProcExA = NULL;
+static WinLoadLibraryW oldProcW = NULL;
+static WinLoadLibraryExW oldProcExW = NULL;
+static WinGetModuleHandleExA oldProcModExA = NULL;
+static WinGetModuleHandleExW oldProcModExW = NULL;
+static WinDirect3DCreate9 oldDirectX9Create = NULL;
+static BYTE oldDirectX9CreateData[OLD_DATA_BACKUP_SIZE];
+static WinDirect3DCreate9Ex oldDirectX9ExCreate = NULL;
+static BYTE oldDirectX9ExCreateData[OLD_DATA_BACKUP_SIZE];
+static WinCreateDXGIFactory oldCreateDXGIFactory = NULL;
+static BYTE oldCreateDXGIFactoryData[OLD_DATA_BACKUP_SIZE];
+static WinCreateDXGIFactory1 oldCreateDXGIFactory1 = NULL;
+static BYTE oldCreateDXGIFactory1Data[OLD_DATA_BACKUP_SIZE];
+static WinCreateDXGIFactory2 oldCreateDXGIFactory2 = NULL;
+static BYTE oldCreateDXGIFactory2Data[OLD_DATA_BACKUP_SIZE];
+
+#define NUM_LOADER_LIBS 4
+
+static const char* loaderLibraryList[NUM_LOADER_LIBS] = {
+ "kernel32.dll",
+ "api-ms-win-core-libraryloader-l1-2-0.dll",
+ "api-ms-win-core-libraryloader-l1-1-0.dll",
+ "api-ms-win-core-libraryloader-l1-1-1.dll"
+};
+
+enum ShimedLibraries
+{
+ ShimLibDXGI = 0,
+ ShimLibD3D9 = 1,
+ ShimLibD3D11 = 2,
+ ShimLibDXGIDebug = 3,
+ ShimLibD3D10Core = 4,
+ ShimLibD3D10 = 5,
+ ShimLibGL = 6,
+ ShimCountMax = 7
+};
+
+static const char* dllList[ShimCountMax] = {
+ "dxgi.dll",
+ "d3d9.dll",
+ "d3d11.dll",
+ "dxgidebug.dll",
+ "d3d10core.dll",
+ "d3d10.dll",
+ "opengl32.dll"
+};
+
+static HINSTANCE oldLoaderInstances[ShimCountMax] = { NULL };
+static PROC oldLoaderProcA[ShimCountMax][NUM_LOADER_LIBS] = { { NULL } };
+static PROC oldLoaderProcW[ShimCountMax][NUM_LOADER_LIBS] = { { NULL } };
+static PROC oldLoaderProcExA[ShimCountMax][NUM_LOADER_LIBS] = { { NULL } };
+static PROC oldLoaderProcExW[ShimCountMax][NUM_LOADER_LIBS] = { { NULL } };
+static PROC oldLoaderProcModExA[ShimCountMax][NUM_LOADER_LIBS] = { { NULL } };
+static PROC oldLoaderProcModExW[ShimCountMax][NUM_LOADER_LIBS] = { { NULL } };
+
+static HMODULE rtFilterModule = NULL;
+
+static bool checkForOverride( LPCSTR libFileName, OVRTargetAPI& targetApi )
+{
+ for (int i=0; ; i++)
+ {
+ CHAR keyString[256] = {0};
+
+ sprintf_s( keyString, 256, GFX_DRIVER_KEY_FMT, i );
+
+ CHAR* infSection = ReadRegStr( HKEY_LOCAL_MACHINE, keyString, "InfSection" );
+
+ // No provider name means we're out of display enumerations
+ if( infSection == NULL )
+ break;
+
+ free(infSection);
+
+ // Check 64-bit driver names followed by 32-bit driver names
+ const char* driverKeys[] = {"UserModeDriverName", "UserModeDriverNameWoW", "OpenGLDriverName", "OpenGLDriverNameWoW", "InstalledDisplayDrivers" };
+ for( int j = 0; j < 6; ++j )
+ {
+ CHAR userModeList[4096] = {0};
+
+ switch(j)
+ {
+ case 5:
+ strcpy_s( userModeList, 4095, OptimusDrivers );
+ break;
+ default:
+ {
+ CHAR* regString = ReadRegStr( HKEY_LOCAL_MACHINE, keyString, driverKeys[j] );
+ if( regString )
+ {
+ strcpy_s( userModeList, 4095, regString );
+ free( regString );
+ }
+
+ }
+ break;
+ }
+
+ char *nextToken = NULL;
+
+ if( userModeList )
+ {
+ char* first = strtok_s( userModeList, " ", &nextToken );
+ while( first )
+ {
+ if( strstr( libFileName, first ) != 0 )
+ {
+ if( j < 2 )
+ targetApi = DirectX;
+ else
+ targetApi = OpenGL;
+
+ return true;
+ }
+ first = strtok_s( NULL, " ", &nextToken );
+ }
+ }
+ }
+ }
+
+ return false;
+}
+
+static HMODULE createShim( LPCSTR lpLibFileName, OVRTargetAPI targetAPI )
+{
+ //Sleep(10000);
+ if( IN_COMPATIBILITY_MODE() )
+ {
+ return (*oldProcA)( lpLibFileName );
+ }
+
+ UNREFERENCED_PARAMETER( targetAPI );
+
+ HMODULE result = NULL;
+
+ result = (*oldProcA)( UMFilter );
+
+ if( result )
+ {
+ PreloadLibraryFn loadFunc = (PreloadLibraryFn)GetProcAddress( result, "PreloadLibrary" );
+ if( loadFunc )
+ {
+ HRESULT localRes = (*loadFunc)( oldProcA, lpLibFileName, &appDriver );
+ if( localRes != S_OK )
+ result = NULL;
+ }
+ }
+
+ if( !result )
+ {
+ MessageBox(nullptr, L"Unable to find the Rift Display Driver.", L"Configuration Error", MB_OK | MB_ICONERROR);
+ result = (*oldProcA)( lpLibFileName );
+ }
+ return result;
+}
+
+static HMODULE
+ WINAPI
+ OVRLoadLibraryA(
+ __in LPCSTR lpLibFileName
+ )
+{
+ OVRTargetAPI targetAPI = DirectX;
+ bool needShim = checkForOverride( lpLibFileName, targetAPI );
+ if( !needShim )
+ return (*oldProcA)( lpLibFileName );
+
+ return createShim( lpLibFileName, targetAPI );
+}
+
+static HMODULE
+ WINAPI
+ OVRLoadLibraryW(
+ __in LPCWSTR lpLibFileName
+ )
+{
+ WIDE_TO_MB(lpLibFileName); // Convert lpLibFileName -> lpLibFileName_cstr
+
+ OVRTargetAPI targetAPI = DirectX;
+
+ bool needShim = checkForOverride( lpLibFileName_cstr, targetAPI );
+ if( !needShim )
+ return (*oldProcW)( lpLibFileName );
+
+ return createShim( lpLibFileName_cstr, targetAPI );
+}
+
+static HMODULE
+ WINAPI
+ OVRLoadLibraryExA(
+ __in LPCSTR lpLibFileName,
+ __reserved HANDLE hFile,
+ __in DWORD dwFlags
+
+ )
+{
+ OVRTargetAPI targetAPI = DirectX;
+
+ bool needShim = checkForOverride( lpLibFileName, targetAPI );
+ if( !needShim )
+ return (*oldProcExA)( lpLibFileName, hFile, dwFlags );
+
+ // FIXME: Don't throw away the flags parameter
+ return createShim( lpLibFileName, targetAPI );
+}
+
+static HMODULE
+ WINAPI
+ OVRLoadLibraryExW(
+ __in LPCWSTR lpLibFileName,
+ __reserved HANDLE hFile,
+ __in DWORD dwFlags
+ )
+{
+ WIDE_TO_MB(lpLibFileName); // Convert lpLibFileName -> lpLibFileName_cstr
+
+ OVRTargetAPI targetAPI = DirectX;
+
+ bool needShim = checkForOverride( lpLibFileName_cstr, targetAPI );
+ if( !needShim )
+ return (*oldProcExW)( lpLibFileName, hFile, dwFlags );
+
+ // FIXME: Don't throw away the flags parameter
+ return createShim( lpLibFileName_cstr, targetAPI );
+}
+
+static BOOL WINAPI OVRGetModuleHandleExA(
+ __in DWORD dwFlags,
+ __in_opt LPCSTR lpModuleName,
+ __out HMODULE *phModule
+ )
+{
+ OVRTargetAPI targetAPI = DirectX;
+
+ bool needShim = checkForOverride( lpModuleName, targetAPI );
+ if( !needShim )
+ {
+ return (*oldProcModExA)( dwFlags, lpModuleName, phModule );
+ }
+
+ *phModule = createShim( lpModuleName, targetAPI );
+
+ return TRUE;
+}
+
+static BOOL WINAPI OVRGetModuleHandleExW(
+ __in DWORD dwFlags,
+ __in_opt LPCWSTR lpModuleName,
+ __out HMODULE *phModule
+ )
+{
+ WIDE_TO_MB(lpModuleName); // Convert lpModuleName -> lpModuleName_cstr
+
+ OVRTargetAPI targetAPI = DirectX;
+
+ bool needShim = checkForOverride( lpModuleName_cstr, targetAPI );
+ if( !needShim )
+ {
+ return (*oldProcModExW)( dwFlags, lpModuleName, phModule );
+ }
+
+ *phModule = createShim( lpModuleName_cstr, targetAPI );
+
+ return TRUE;
+}
+
+#ifdef _AMD64_
+static void restoreFunction( PROC pfnHookAPIAddr, PBYTE oldData )
+{
+ static const LONGLONG addressSize = sizeof(PROC);
+ static const LONGLONG jmpSize = addressSize + 6;
+
+ DWORD oldProtect;
+ VirtualProtect((LPVOID)pfnHookAPIAddr, OLD_DATA_BACKUP_SIZE,
+ PAGE_EXECUTE_READWRITE, &oldProtect);
+
+ memcpy(pfnHookAPIAddr, oldData, OLD_DATA_BACKUP_SIZE);
+
+ VirtualProtect((LPVOID)pfnHookAPIAddr, OLD_DATA_BACKUP_SIZE, oldProtect, NULL);
+}
+
+static void setFunction( PROC pfnHookAPIAddr, PROC replacementFunction, PBYTE oldData )
+{
+ static const LONGLONG addressSize = sizeof(PROC);
+ static const LONGLONG jmpSize = addressSize + 6;
+
+ INT_PTR jumpOffset = (INT_PTR)replacementFunction;
+
+ DWORD oldProtect;
+ VirtualProtect((LPVOID)pfnHookAPIAddr, OLD_DATA_BACKUP_SIZE,
+ PAGE_EXECUTE_READWRITE, &oldProtect);
+
+ memcpy(oldData, pfnHookAPIAddr, OLD_DATA_BACKUP_SIZE);
+
+ PBYTE functionData = (PBYTE)pfnHookAPIAddr;
+ functionData[0] = 0xff; // JMP [RIP+0]
+ functionData[1] = 0x25; //
+ functionData[2] = 0x00; //
+ functionData[3] = 0x00; //
+ functionData[4] = 0x00; //
+ functionData[5] = 0x00; //
+ memcpy( functionData + 6, &jumpOffset, sizeof( INT_PTR ) );
+
+ VirtualProtect((LPVOID)pfnHookAPIAddr, OLD_DATA_BACKUP_SIZE, oldProtect, NULL);
+}
+#else
+static void restoreFunction( PROC pfnHookAPIAddr, PBYTE oldData )
+{
+ static const LONGLONG addressSize = sizeof(PROC);
+ static const LONGLONG jmpSize = addressSize + 1;
+
+ DWORD oldProtect;
+ VirtualProtect((LPVOID)pfnHookAPIAddr, jmpSize,
+ PAGE_EXECUTE_READWRITE, &oldProtect);
+
+ memcpy(pfnHookAPIAddr, oldData, jmpSize);
+
+ VirtualProtect((LPVOID)pfnHookAPIAddr, jmpSize, oldProtect, NULL);
+}
+
+static void setFunction( PROC pfnHookAPIAddr, PROC replacementFunction, PBYTE oldData )
+{
+ static const LONGLONG addressSize = sizeof(PROC);
+ static const LONGLONG jmpSize = addressSize + 1;
+
+ INT_PTR jumpOffset = (INT_PTR)replacementFunction - (INT_PTR)pfnHookAPIAddr - jmpSize;
+
+ DWORD oldProtect;
+ VirtualProtect((LPVOID)pfnHookAPIAddr, jmpSize,
+ PAGE_EXECUTE_READWRITE, &oldProtect);
+
+ memcpy(oldData, pfnHookAPIAddr, jmpSize);
+
+ PBYTE functionData = (PBYTE)pfnHookAPIAddr;
+ memcpy( oldData, functionData, jmpSize );
+ functionData[0] = 0xe9;
+ memcpy( functionData + 1, &jumpOffset, sizeof( INT_PTR ) );
+
+ VirtualProtect((LPVOID)pfnHookAPIAddr, jmpSize, oldProtect, NULL);
+}
+#endif
+
+static BOOL WINAPI OVRLocalIsInitializingDisplay( PVOID context, UINT width, UINT height )
+{
+ UINT expectedWidth, expectedHeight, rotation;
+
+ OVRExpectedResolution( context, &expectedWidth, &expectedHeight, &rotation );
+
+ if( appDriver.pfnActiveAPIVersion )
+ apiVersion = (*appDriver.pfnActiveAPIVersion)( context );
+
+ switch( apiVersion )
+ {
+ case 1: // OpenGL
+ case 10: // DirectX 1X
+ if( width == expectedWidth && height == expectedHeight )
+ return TRUE;
+ break;
+ case 9: // DirectX 9
+ if( rotation == 90 || rotation == 270 )
+ {
+ if( width == expectedHeight && height == expectedWidth )
+ return TRUE;
+ }
+ else
+ {
+ if( width == expectedWidth && height == expectedHeight )
+ return TRUE;
+ }
+ break;
+ default:
+ break;
+ }
+
+ return FALSE;
+}
+
+
+HRESULT APIENTRY OVRDirect3DCreate9Ex(UINT SDKVersion, void** aDevice)
+{
+ apiVersion = 9;
+
+ HRESULT result = S_OK;
+
+ restoreFunction( (PROC)oldDirectX9ExCreate, oldDirectX9ExCreateData );
+
+ if (IN_COMPATIBILITY_MODE())
+ {
+ result = (*oldDirectX9ExCreate)(SDKVersion, aDevice);
+ }
+ else
+ {
+ WinDirect3DCreate9Ex createFunction = (WinDirect3DCreate9Ex)GetProcAddress(rtFilterModule, "Direct3DCreate9Ex");
+ result = (*createFunction)(SDKVersion, aDevice);
+ }
+
+ setFunction( (PROC)oldDirectX9ExCreate, (PROC)OVRDirect3DCreate9Ex, oldDirectX9ExCreateData );
+
+ printf("%s result 0x%x\n", __FUNCTION__, result);
+
+ return result;
+}
+
+void* APIENTRY OVRDirect3DCreate9(UINT SDKVersion)
+{
+ void* result = NULL;
+
+ OVRDirect3DCreate9Ex( SDKVersion, &result );
+
+ return result;
+}
+
+HRESULT APIENTRY OVRCreateDXGIFactory(
+ __in REFIID riid,
+ __out void **ppFactory
+ )
+{
+ HRESULT result = E_FAIL;
+
+ restoreFunction( (PROC)oldCreateDXGIFactory, oldCreateDXGIFactoryData );
+
+ if (IN_COMPATIBILITY_MODE())
+ {
+ result = (*oldCreateDXGIFactory)(riid, ppFactory);
+ }
+ else
+ {
+ WinCreateDXGIFactory createFunction = (WinCreateDXGIFactory)GetProcAddress(rtFilterModule, "CreateDXGIFactory");
+ result = (*createFunction)(riid, ppFactory);
+ }
+
+ setFunction( (PROC)oldCreateDXGIFactory, (PROC)OVRCreateDXGIFactory, oldCreateDXGIFactoryData );
+
+ printf("%s result 0x%x\n", __FUNCTION__, result);
+
+ return result;
+}
+
+HRESULT APIENTRY OVRCreateDXGIFactory1(
+ __in REFIID riid,
+ __out void **ppFactory
+ )
+{
+ HRESULT result = E_FAIL;
+
+ restoreFunction( (PROC)oldCreateDXGIFactory1, oldCreateDXGIFactory1Data );
+
+ if (IN_COMPATIBILITY_MODE())
+ {
+ result = (*oldCreateDXGIFactory1)(riid, ppFactory);
+ }
+ else
+ {
+ WinCreateDXGIFactory1 createFunction = (WinCreateDXGIFactory1)GetProcAddress(rtFilterModule, "CreateDXGIFactory1");
+ result = (*createFunction)(riid, ppFactory);
+ }
+
+ setFunction( (PROC)oldCreateDXGIFactory1, (PROC)OVRCreateDXGIFactory1, oldCreateDXGIFactory1Data );
+
+ printf("%s result 0x%x\n", __FUNCTION__, result);
+
+ return result;
+}
+
+HRESULT APIENTRY OVRCreateDXGIFactory2(
+ __in UINT flags,
+ __in const IID &riid,
+ __out void **ppFactory
+ )
+{
+ HRESULT result = E_FAIL;
+
+ restoreFunction( (PROC)oldCreateDXGIFactory2, oldCreateDXGIFactory2Data );
+
+ if (IN_COMPATIBILITY_MODE())
+ {
+ result = (*oldCreateDXGIFactory2)(flags, riid, ppFactory);
+ }
+ else
+ {
+ WinCreateDXGIFactory2 createFunction = (WinCreateDXGIFactory2)GetProcAddress(rtFilterModule, "CreateDXGIFactory2");
+ result = (*createFunction)(flags, riid, ppFactory);
+ }
+
+ setFunction( (PROC)oldCreateDXGIFactory2, (PROC)OVRCreateDXGIFactory2, oldCreateDXGIFactory2Data );
+
+ printf("%s result 0x%x\n", __FUNCTION__, result);
+
+ return result;
+}
+
+static PROC SetProcAddressDirect(
+ __in HINSTANCE hInstance,
+ __in LPCSTR lpProcName,
+ __in PROC newFunction,
+ __inout BYTE* oldData
+ )
+{
+ static const LONGLONG addressSize = sizeof(PROC);
+ static const LONGLONG jmpSize = addressSize + 1;
+
+ PROC result = NULL;
+
+ PROC pfnHookAPIAddr = GetProcAddress( hInstance, lpProcName );
+
+ if( pfnHookAPIAddr )
+ {
+ result = pfnHookAPIAddr;
+
+ setFunction( pfnHookAPIAddr, newFunction, oldData );
+ }
+
+ return result;
+}
+
+static PROC SetProcAddressA(
+ __in HINSTANCE targetModule,
+ __in LPCSTR lpLibFileName,
+ __in LPCSTR lpProcName,
+ __in PROC newFunction
+ )
+{
+ HMODULE hModule = LoadLibraryA( lpLibFileName );
+ if(hModule == NULL)
+ return NULL;
+
+ // To do: call FreeLibrary(hModule) at the appropriate time.
+ PROC pfnHookAPIAddr = GetProcAddress(hModule, lpProcName );
+
+ HINSTANCE hInstance = targetModule;
+
+ ULONG ulSize;
+ PIMAGE_IMPORT_DESCRIPTOR pImportDesc =
+ (PIMAGE_IMPORT_DESCRIPTOR)ImageDirectoryEntryToData(
+ hInstance,
+ TRUE,
+ IMAGE_DIRECTORY_ENTRY_IMPORT,
+ &ulSize
+ );
+
+ while (pImportDesc->Name)
+ {
+ PSTR pszModName = (PSTR)((PBYTE) hInstance + pImportDesc->Name);
+ if (_stricmp(pszModName, lpLibFileName) == 0)
+ break;
+ pImportDesc++;
+ }
+
+ PIMAGE_THUNK_DATA pThunk =
+ (PIMAGE_THUNK_DATA)((PBYTE) hInstance + pImportDesc->FirstThunk);
+
+ while (pThunk->u1.Function)
+ {
+ PROC* ppfn = (PROC*) &pThunk->u1.Function;
+ BOOL bFound = (*ppfn == pfnHookAPIAddr);
+
+ if (bFound)
+ {
+ MEMORY_BASIC_INFORMATION mbi;
+ VirtualQuery(
+ ppfn,
+ &mbi,
+ sizeof(MEMORY_BASIC_INFORMATION)
+ );
+ VirtualProtect(
+ mbi.BaseAddress,
+ mbi.RegionSize,
+ PAGE_READWRITE,
+ &mbi.Protect);
+
+ *ppfn = *newFunction;
+
+ DWORD dwOldProtect;
+ VirtualProtect(
+ mbi.BaseAddress,
+ mbi.RegionSize,
+ mbi.Protect,
+ &dwOldProtect
+ );
+ break;
+ }
+ pThunk++;
+ }
+
+ return pfnHookAPIAddr;
+}
+
+
+bool checkUMDriverOverrides(void* context)
+{
+ lastContext = context;
+ if (oldProcA != NULL)
+ return true;
+
+ PreloadLibraryRTFn loadFunc = NULL;
+ for( int i = 0; i < ShimCountMax; ++i )
+ {
+ HINSTANCE hInst = NULL;
+ try
+ {
+ hInst = LoadLibraryA(dllList[i]);
+ }
+ catch(...)
+ {
+ }
+
+ oldLoaderInstances[i] = hInst;
+
+ if (hInst == NULL)
+ continue;
+
+ ShimedLibraries libCount = (ShimedLibraries)i;
+ switch( libCount )
+ {
+ case ShimLibDXGI:
+ oldCreateDXGIFactory = (WinCreateDXGIFactory)SetProcAddressDirect( hInst, "CreateDXGIFactory", (PROC)OVRCreateDXGIFactory, oldCreateDXGIFactoryData );
+ oldCreateDXGIFactory1 = (WinCreateDXGIFactory1)SetProcAddressDirect( hInst, "CreateDXGIFactory1", (PROC)OVRCreateDXGIFactory1, oldCreateDXGIFactory1Data );
+ oldCreateDXGIFactory2 = (WinCreateDXGIFactory2)SetProcAddressDirect( hInst, "CreateDXGIFactory2", (PROC)OVRCreateDXGIFactory2, oldCreateDXGIFactory2Data );
+ break;
+ case ShimLibD3D9:
+ oldDirectX9Create = (WinDirect3DCreate9)SetProcAddressDirect( hInst, "Direct3DCreate9", (PROC)OVRDirect3DCreate9, oldDirectX9CreateData );
+ oldDirectX9ExCreate = (WinDirect3DCreate9Ex)SetProcAddressDirect( hInst, "Direct3DCreate9Ex", (PROC)OVRDirect3DCreate9Ex, oldDirectX9ExCreateData );
+ break;
+ default:
+ break;
+ }
+
+ for (int j = 0; j < NUM_LOADER_LIBS; ++j)
+ {
+ const char* loaderLibrary = loaderLibraryList[j];
+
+ PROC temp = NULL;
+ temp = SetProcAddressA(hInst, loaderLibrary, "LoadLibraryA", (PROC)OVRLoadLibraryA);
+ if (!oldProcA)
+ {
+ oldProcA = (WinLoadLibraryA)temp;
+ }
+ oldLoaderProcA[i][j] = temp;
+
+ temp = SetProcAddressA(hInst, loaderLibrary, "LoadLibraryW", (PROC)OVRLoadLibraryW);
+ if (!oldProcW)
+ {
+ oldProcW = (WinLoadLibraryW)temp;
+ }
+ oldLoaderProcW[i][j] = temp;
+
+ temp = SetProcAddressA(hInst, loaderLibrary, "LoadLibraryExA", (PROC)OVRLoadLibraryExA);
+ if (!oldProcExA)
+ {
+ oldProcExA = (WinLoadLibraryExA)temp;
+ }
+ oldLoaderProcExA[i][j] = temp;
+
+ temp = SetProcAddressA(hInst, loaderLibrary, "LoadLibraryExW", (PROC)OVRLoadLibraryExW);
+ if (!oldProcExW)
+ {
+ oldProcExW = (WinLoadLibraryExW)temp;
+ }
+ oldLoaderProcExW[i][j] = temp;
+
+ temp = SetProcAddressA(hInst, loaderLibrary, "GetModuleHandleExA", (PROC)OVRGetModuleHandleExA);
+ if (!oldProcModExA)
+ {
+ oldProcModExA = (WinGetModuleHandleExA)temp;
+ }
+ oldLoaderProcModExA[i][j] = temp;
+
+ temp = SetProcAddressA(hInst, loaderLibrary, "GetModuleHandleExW", (PROC)OVRGetModuleHandleExW);
+ if (!oldProcModExW)
+ {
+ oldProcModExW = (WinGetModuleHandleExW)temp;
+ }
+ oldLoaderProcModExW[i][j] = temp;
+ }
+
+ if (loadFunc == NULL)
+ {
+ loadFunc = (PreloadLibraryRTFn)GetProcAddress(hInst, "PreloadLibraryRT");
+ }
+ }
+
+ rtFilterModule = oldProcA ? (*oldProcA)(RTFilter) : NULL;
+
+ IsCreatingBackBuffer backBufferFunc = NULL;
+ ShouldVSync shouldVSyncFunc = NULL;
+ GetRTFilterVersion getRTFilterVersionFunc = NULL;
+
+ if (rtFilterModule != NULL)
+ {
+ loadFunc = (PreloadLibraryRTFn)GetProcAddress(rtFilterModule, "PreloadLibraryRT");
+ backBufferFunc = (IsCreatingBackBuffer)GetProcAddress(rtFilterModule, "OVRIsCreatingBackBuffer");
+ shouldVSyncFunc = (ShouldVSync)GetProcAddress(rtFilterModule, "OVRShouldVSync");
+ getRTFilterVersionFunc = (GetRTFilterVersion)GetProcAddress(rtFilterModule, "OVRGetRTFilterVersion");
+ }
+
+ if (loadFunc == NULL)
+ {
+ MessageBox(nullptr, L"Unable to load the Oculus Display Driver. Please reinstall the Oculus Runtime.", L"Configuration Error", MB_OK | MB_ICONERROR);
+ return false;
+ }
+
+ if (getRTFilterVersionFunc == NULL)
+ {
+ WCHAR message[1000] = {};
+ swprintf_s(message, L"This app requires the %d.%d.%d version of the Oculus Runtime.", OVR_MAJOR_VERSION, OVR_MINOR_VERSION, OVR_BUILD_VERSION);
+ MessageBox(nullptr, message, L"Configuration Error", MB_OK | MB_ICONERROR);
+ return false;
+ }
+
+ // Verify that we are running with the appropriate display driver
+ {
+ const ULONG rtFilterVersion = (*getRTFilterVersionFunc)();
+ const ULONG rtFilterMajor = OVR_GET_VERSION_MAJOR(rtFilterVersion);
+ const ULONG rtFilterMinor = OVR_GET_VERSION_MINOR(rtFilterVersion);
+
+ if ((rtFilterMajor != OVR_RTFILTER_VERSION_MAJOR) || (rtFilterMinor < OVR_RTFILTER_VERSION_MINOR))
+ {
+ WCHAR message[1000] = {};
+ swprintf_s(message, L"This app requires the %d.%d.%d version of the Oculus Runtime.", OVR_MAJOR_VERSION, OVR_MINOR_VERSION, OVR_BUILD_VERSION);
+ MessageBox(nullptr, message, L"Configuration Error", MB_OK | MB_ICONERROR);
+ return false;
+ }
+ }
+
+ appDriver.version = OVR_RENDER_SHIM_VERSION_MAJOR;
+ appDriver.context = lastContext;
+
+// appDriver.pfnInitializingDisplay = OVRIsInitializingDisplay;
+ appDriver.pfnInitializingDisplay = OVRLocalIsInitializingDisplay;
+ appDriver.pfnRiftForContext = OVRRiftForContext;
+ appDriver.pfnCloseRiftForContext = OVRCloseRiftForContext;
+ appDriver.pfnWindowDisplayResolution = OVRWindowDisplayResolution;
+ appDriver.pfnShouldEnableDebug = OVRShouldEnableDebug;
+ appDriver.pfnIsCreatingBackBuffer = (backBufferFunc == NULL) ? OVRIsCreatingBackBuffer : backBufferFunc;
+ appDriver.pfnShouldVSync = (shouldVSyncFunc == NULL) ? OVRShouldVSync : shouldVSyncFunc;
+ appDriver.pfnExpectedResolution = OVRExpectedResolution;
+ appDriver.pfnMirroringEnabled = OVRMirroringEnabled;
+ appDriver.pfnGetWindowForContext = OVRGetWindowForContext;
+ appDriver.pfnPresentRiftOnContext = OVRShouldPresentOnContext;
+
+ appDriver.pfnDirect3DCreate9 = oldDirectX9Create;
+ appDriver.pfnDirect3DCreate9Ex = oldDirectX9ExCreate;
+ appDriver.pfnCreateDXGIFactory = oldCreateDXGIFactory;
+ appDriver.pfnCreateDXGIFactory1 = oldCreateDXGIFactory1;
+ appDriver.pfnCreateDXGIFactory2 = oldCreateDXGIFactory2;
+
+ (*loadFunc)( &appDriver );
+
+ return true;
+}
+
+void clearUMDriverOverrides()
+{
+ if (oldProcA != NULL)
+ {
+ // Unpatch all the things.
+
+ if (oldCreateDXGIFactory)
+ {
+ restoreFunction((PROC)oldCreateDXGIFactory, oldCreateDXGIFactoryData);
+ }
+ if (oldCreateDXGIFactory1)
+ {
+ restoreFunction((PROC)oldCreateDXGIFactory1, oldCreateDXGIFactory1Data);
+ }
+ if (oldCreateDXGIFactory2)
+ {
+ restoreFunction((PROC)oldCreateDXGIFactory2, oldCreateDXGIFactory2Data);
+ }
+ if (oldDirectX9Create)
+ {
+ restoreFunction((PROC)oldDirectX9Create, oldDirectX9CreateData);
+ }
+ if (oldDirectX9ExCreate)
+ {
+ restoreFunction((PROC)oldDirectX9ExCreate, oldDirectX9ExCreateData);
+ }
+ if (oldCreateDXGIFactory2)
+ {
+ restoreFunction((PROC)oldCreateDXGIFactory2, oldCreateDXGIFactory2Data);
+ }
+
+ for (int i = 0; i < ShimCountMax; ++i)
+ {
+ HINSTANCE hInst = oldLoaderInstances[i];
+
+ if (hInst != NULL)
+ {
+ for (int j = 0; j < NUM_LOADER_LIBS; ++j)
+ {
+ const char* loaderLibrary = loaderLibraryList[j];
+
+ if (oldLoaderProcA[j])
+ {
+ SetProcAddressA(hInst, loaderLibrary, "LoadLibraryA", oldLoaderProcA[i][j]);
+ }
+ if (oldLoaderProcW[j])
+ {
+ SetProcAddressA(hInst, loaderLibrary, "LoadLibraryW", oldLoaderProcW[i][j]);
+ }
+ if (oldLoaderProcExA[j])
+ {
+ SetProcAddressA(hInst, loaderLibrary, "LoadLibraryExA", oldLoaderProcExA[i][j]);
+ }
+ if (oldLoaderProcExW[j])
+ {
+ SetProcAddressA(hInst, loaderLibrary, "LoadLibraryExW", oldLoaderProcExW[i][j]);
+ }
+ if (oldLoaderProcModExA[j])
+ {
+ SetProcAddressA(hInst, loaderLibrary, "GetModuleHandleExA", oldLoaderProcModExA[i][j]);
+ }
+ if (oldLoaderProcModExW[j])
+ {
+ SetProcAddressA(hInst, loaderLibrary, "GetModuleHandleExW", oldLoaderProcModExW[i][j]);
+ }
+ }
+
+ FreeLibrary(hInst);
+ }
+ }
+
+ if (rtFilterModule != NULL)
+ {
+ LPFNCANUNLOADNOW pfnCanUnloadNow = (LPFNCANUNLOADNOW)GetProcAddress(rtFilterModule, "DllCanUnloadNow");
+ if (pfnCanUnloadNow && pfnCanUnloadNow() == S_OK)
+ {
+ FreeLibrary(rtFilterModule);
+ rtFilterModule = NULL;
+ }
+ }
+
+ oldProcA = NULL;
+ oldProcExA = NULL;
+ oldProcW = NULL;
+ oldProcExW = NULL;
+ oldProcModExA = NULL;
+ oldProcModExW = NULL;
+ oldDirectX9Create = NULL;
+ oldDirectX9ExCreate = NULL;
+ oldCreateDXGIFactory = NULL;
+ oldCreateDXGIFactory1 = NULL;
+ oldCreateDXGIFactory2 = NULL;
+ lastContext = NULL;
+ }
+}
diff --git a/LibOVR/Src/Displays/OVR_Win32_ShimFunctions.cpp b/LibOVR/Src/Displays/OVR_Win32_ShimFunctions.cpp new file mode 100644 index 0000000..602df98 --- /dev/null +++ b/LibOVR/Src/Displays/OVR_Win32_ShimFunctions.cpp @@ -0,0 +1,234 @@ +/************************************************************************************
+
+Filename : OVR_Win32_ShimFunctions.cpp
+Content : Client-side shim callbacks for usermode/rt hooks
+Created : May 6, 2014
+Authors : Dean Beeler
+
+Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved.
+
+Licensed under the Oculus VR Rift SDK License Version 3.2 (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.2
+
+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.
+
+*************************************************************************************/
+
+#include "OVR_Win32_Display.h"
+#include "OVR_Win32_ShimFunctions.h"
+#include "OVR_Win32_Dxgi_Display.h"
+#include "../OVR_Stereo.h"
+#include "OVR_Win32_FocusReader.h"
+
+// Exported
+extern bool checkUMDriverOverrides(void* context);
+extern void clearUMDriverOverrides();
+
+#include <stdio.h>
+#include <tchar.h>
+#include <string.h>
+#include <stdlib.h>
+#include <WinSock2.h>
+#include <WS2tcpip.h>
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#include <winioctl.h>
+#include <SetupAPI.h>
+#include <Mmsystem.h>
+#include <conio.h>
+
+
+//-------------------------------------------------------------------------------------
+// ***** User-mode Callbacks
+//
+// See IsInitializingDisplay, etc in Dxgi_Display.h for details
+//
+
+extern LINK_APPLICATION_DRIVER appDriver;
+
+BOOL WINAPI OVRIsInitializingDisplay(PVOID context, UINT width, UINT height)
+{
+ OVR::Win32::DisplayShim* con = (OVR::Win32::DisplayShim*)context;
+ if (con->ExpectedWidth == (int)width && con->ExpectedHeight == (int)height)
+ return TRUE;
+
+ return FALSE;
+}
+
+BOOL WINAPI OVRExpectedResolution( PVOID context, UINT* width, UINT* height, UINT* rotationInDegrees )
+{
+ OVR::Win32::DisplayShim* con = (OVR::Win32::DisplayShim*)context;
+
+ *width = con->ExpectedWidth;
+ *height = con->ExpectedHeight;
+ *rotationInDegrees = con->Rotation;
+ return TRUE;
+}
+
+BOOL WINAPI OVRIsCreatingBackBuffer(PVOID context)
+{
+ OVR::Win32::DisplayShim* con = (OVR::Win32::DisplayShim*)context;
+ if( con->ExpectedWidth != -1 && con->ExpectedHeight != -1 )
+ return TRUE;
+
+ return FALSE;
+}
+
+BOOL WINAPI OVRShouldVSync( )
+{
+ return FALSE;
+}
+
+
+ULONG WINAPI OVRRiftForContext(PVOID context, HANDLE driverHandle)
+{
+ OVR_UNUSED( driverHandle );
+ OVR::Win32::DisplayShim* con = (OVR::Win32::DisplayShim*)context;
+
+ return con->ChildUid;
+}
+
+HWND WINAPI OVRGetWindowForContext(PVOID context)
+{
+ OVR::Win32::DisplayShim* con = (OVR::Win32::DisplayShim*)context;
+
+ if( con->Active )
+ {
+ return con->hWindow;
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+BOOL WINAPI OVRShouldPresentOnContext(PVOID context)
+{
+ OVR::Win32::DisplayShim* con = (OVR::Win32::DisplayShim*)context;
+
+ return con->Active && ( con->hWindow == OVR::Win32::RenderFocusReader::GetInstance()->ReadActiveWindow() );
+}
+
+BOOL WINAPI OVRCloseRiftForContext( PVOID context, HANDLE driverHandle, ULONG rift )
+{
+ OVR_UNUSED( context ); OVR_UNUSED( driverHandle ); OVR_UNUSED( rift );
+ // TODO
+ return TRUE;
+}
+
+BOOL WINAPI OVRWindowDisplayResolution( PVOID context, UINT* width, UINT* height,
+ UINT* titleHeight, UINT* borderWidth,
+ BOOL* vsyncEnabled )
+{
+ OVR::Win32::DisplayShim* con = (OVR::Win32::DisplayShim*)context;
+ void* handle = con->hWindow;
+
+ if( handle )
+ {
+ RECT winRect = { 0 };
+ GetWindowRect( (HWND)handle, &winRect );
+
+ RECT rect = {0};
+ if( GetClientRect( (HWND)handle, &rect ) )
+ {
+ LONG barHeight = (winRect.bottom - winRect.top) - (rect.bottom - rect.top);
+ LONG borderSize = (winRect.right - winRect.left) - (rect.right - rect.left);
+
+ *titleHeight = barHeight - borderSize + (borderSize / 2 );
+ *borderWidth = borderSize / 2;
+ *width = rect.right - rect.left + (borderSize / 2);
+ *height = rect.bottom - rect.top + *titleHeight;
+ }
+ else
+ {
+ return FALSE;
+ }
+ }
+ else
+ {
+ return FALSE;
+ }
+
+ *vsyncEnabled = TRUE;
+
+ return TRUE;
+}
+
+BOOL WINAPI OVRShouldEnableDebug()
+{
+ return FALSE;
+}
+
+BOOL WINAPI OVRMirroringEnabled( PVOID context )
+{
+ OVR::Win32::DisplayShim* con = (OVR::Win32::DisplayShim*)context;
+
+ return con->UseMirroring;
+}
+
+namespace OVR { namespace Win32 {
+
+DisplayShim::DisplayShim() :
+ ChildUid( 0 ),
+ ExpectedWidth( 1280 ),
+ ExpectedHeight( 800 ),
+ Rotation( 0 ),
+ hWindow( 0 ),
+ UseMirroring( true ),
+ Active( false )
+{
+
+}
+
+DisplayShim::~DisplayShim()
+{
+
+}
+
+bool DisplayShim::Initialize( bool inCompatibility )
+{
+ if (inCompatibility)
+ return false;
+
+ return checkUMDriverOverrides( this );
+}
+
+bool DisplayShim::Shutdown()
+{
+ clearUMDriverOverrides();
+
+ return true;
+}
+
+bool DisplayShim::Update(Win32ShimInfo* shimInfo)
+{
+ ChildUid = shimInfo->DeviceNumber;
+ ExpectedWidth = shimInfo->NativeWidth;
+ ExpectedHeight = shimInfo->NativeHeight;
+ Rotation = shimInfo->Rotation;
+ UseMirroring = shimInfo->UseMirroring != 0;
+ return true;
+}
+
+void* DisplayShim::GetDX11SwapChain()
+{
+ if( appDriver.pfnGetDX11SwapChain )
+ {
+ return (*appDriver.pfnGetDX11SwapChain)(this);
+ }
+
+ return NULL;
+}
+
+
+} } // OVR::Win32
diff --git a/LibOVR/Src/Displays/OVR_Win32_ShimFunctions.h b/LibOVR/Src/Displays/OVR_Win32_ShimFunctions.h new file mode 100644 index 0000000..1339de4 --- /dev/null +++ b/LibOVR/Src/Displays/OVR_Win32_ShimFunctions.h @@ -0,0 +1,79 @@ +/************************************************************************************
+
+Filename : OVR_Win32_ShimFunctions.h
+Content : Client-side shim callbacks for usermode/rt hooks
+Created : May 6, 2014
+Authors : Dean Beeler
+
+Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved.
+
+Licensed under the Oculus VR Rift SDK License Version 3.2 (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.2
+
+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.
+
+*************************************************************************************/
+
+#ifndef OVR_Win32_ShimFunctions_h
+#define OVR_Win32_ShimFunctions_h
+
+#include "OVR_Win32_Display.h"
+
+namespace OVR {
+
+struct Win32ShimInfo;
+
+namespace Win32 {
+
+
+class DisplayShim
+{
+public:
+
+public:
+ static DisplayShim& GetInstance()
+ {
+ static DisplayShim instance;
+ return instance;
+ }
+
+ bool Initialize( bool inCompatibility );
+ bool Shutdown();
+
+ bool Update( Win32ShimInfo* shimInfo );
+
+ void* GetDX11SwapChain();
+
+ ULONG ChildUid;
+ int ExpectedWidth;
+ int ExpectedHeight;
+ int Rotation;
+ HWND hWindow;
+ bool UseMirroring;
+ bool Active;
+
+private:
+
+ DisplayShim();
+
+ virtual ~DisplayShim();
+
+ DisplayShim(DisplayShim const&); // Don't Implement
+ void operator=(DisplayShim const&); // Don't implement
+
+};
+
+
+}} // namespace OVR::Win32
+
+#endif
diff --git a/LibOVR/Src/Displays/OVR_Win32_ShimVersion.h b/LibOVR/Src/Displays/OVR_Win32_ShimVersion.h new file mode 100644 index 0000000..f5eaa7c --- /dev/null +++ b/LibOVR/Src/Displays/OVR_Win32_ShimVersion.h @@ -0,0 +1,47 @@ +/************************************************************************************
+
+Filename : OVR_Win32_ShimVersion.h
+Content : Versioning info for our display shim
+Created : Nov 4, 2014
+Authors : Scott Bassett
+
+Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved.
+
+Licensed under the Oculus VR Rift SDK License Version 3.2 (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.2
+
+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.
+
+*************************************************************************************/
+
+#define STRINGIZE_(x) #x
+#define STRINGIZE(x) STRINGIZE_(x)
+
+#define OVR_MAKE_VERSION(major, minor, patch) (ULONG)(((major) << 24) | ((minor) << 16) | patch)
+#define OVR_GET_VERSION_MAJOR(x) (ULONG)(((x) >> 24) & 0x000000FF)
+#define OVR_GET_VERSION_MINOR(x) (ULONG)(((x) >> 16) & 0x000000FF)
+#define OVR_GET_VERSION_PATCH(x) (ULONG)((x) & 0x0000FFFF)
+
+#define OVR_RENDER_SHIM_VERSION_MAJOR 1
+#define OVR_RENDER_SHIM_VERSION_MINOR 0
+#define OVR_RENDER_SHIM_VERSION_PATCH 0
+#define OVR_RENDER_SHIM_VERSION OVR_MAKE_VERSION(OVR_RENDER_SHIM_VERSION_MAJOR, OVR_RENDER_SHIM_VERSION_MINOR, OVR_RENDER_SHIM_VERSION_PATCH)
+#define OVR_RENDER_SHIM_VERSION_STRING (STRINGIZE(OVR_RENDER_SHIM_VERSION_MAJOR) "." STRINGIZE(OVR_RENDER_SHIM_VERSION_MINOR) "." STRINGIZE(OVR_RENDER_SHIM_VERSION_PATCH))
+
+// IF YOU CHANGE ANY OF THESE NUMBERS YOU MUST UPDATE MULTIPLE FILES.
+// PLEASE LOOK AT CHANGELIST 31947 TO SEE THE FULL LIST.
+#define OVR_RTFILTER_VERSION_MAJOR 1
+#define OVR_RTFILTER_VERSION_MINOR 2
+#define OVR_RTFILTER_VERSION_PATCH 2
+#define OVR_RTFILTER_VERSION OVR_MAKE_VERSION(OVR_RTFILTER_VERSION_MAJOR, OVR_RTFILTER_VERSION_MINOR, OVR_RTFILTER_VERSION_PATCH)
+#define OVR_RTFILTER_VERSION_STRING (STRINGIZE(OVR_RTFILTER_VERSION_MAJOR) "." STRINGIZE(OVR_RTFILTER_VERSION_MINOR) "." STRINGIZE(OVR_RTFILTER_VERSION_PATCH))
|