foo

1 files changed, 490 insertions, 0 deletions

diff --git a/ovr_sdk_win_23.0.0/LibOVRKernel/Src/Util/Util_SystemInfo.h b/ovr_sdk_win_23.0.0/LibOVRKernel/Src/Util/Util_SystemInfo.h
new file mode 100644
index 0000000..62e55c3
--- /dev/null
+++ b/ovr_sdk_win_23.0.0/LibOVRKernel/Src/Util/Util_SystemInfo.h
@@ -0,0 +1,490 @@
+/************************************************************************************
+
+Filename    :   Util_SystemInfo.h
+Content     :   Various operations to get information about the system
+Created     :   September 26, 2014
+Author      :   Kevin Jenkins
+
+Copyright   :   Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
+
+Licensed under the Oculus Master SDK License Version 1.0 (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
+
+https://developer.oculus.com/licenses/oculusmastersdk-1.0
+
+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_Util_SystemInfo_h
+#define OVR_Util_SystemInfo_h
+
+#include <set>
+#include <string>
+#include <vector>
+#include "Kernel/OVR_Array.h"
+#include "Kernel/OVR_DebugHelp.h"
+#include "Kernel/OVR_String.h"
+#include "Kernel/OVR_Types.h"
+
+// XCode 11 ships with std::filesystem, but std::filesystem::path is only available when setting
+// the minimum Mac OS X version to 10.15. Once the Mac builds use 10.15 as minimum version this can
+// be reverted.
+#if defined(__cpp_lib_filesystem) && !defined(__APPLE__)
+#include <filesystem>
+#define OVR_UTIL_STD_FILESYSTEM_AVAILABLE 1
+#else
+#define OVR_UTIL_STD_FILESYSTEM_AVAILABLE 0
+#endif
+
+namespace OVR {
+namespace Util {
+
+//-----------------------------------------------------------------------------
+// Utility functions
+//
+
+#if defined(_WIN32)
+bool Is64BitWindows();
+#endif
+
+const char* OSAsString();
+String OSVersionAsString();
+uint64_t GetGuidInt();
+String GetGuidString();
+const char* GetProcessInfo();
+String GetCameraDriverVersion();
+void GetGraphicsCardList(OVR::Array<OVR::String>& gpus);
+String GetProcessorInfo();
+
+enum WindowsVersion { Windows7_SP1 = 0, Windows8, Windows8_1, Windows10, Windows10_TH2 };
+
+bool IsAtLeastWindowsVersion(WindowsVersion version);
+bool IsAtMostWindowsVersion(WindowsVersion version);
+
+#if OVR_UTIL_STD_FILESYSTEM_AVAILABLE
+// Returns the current module (e.g. exe or dll) path. If executed within a DLL, it returns the
+// DLL path.
+std::filesystem::path GetCurrentModuleDirectoryPath();
+#endif // OVR_UTIL_STD_FILESYSTEM_AVAILABLE
+
+// Checks if the computer is currently locked
+bool CheckIsComputerLocked();
+
+//-----------------------------------------------------------------------------
+// SettingsManager
+//
+// This is a portable interface replacement for Windows-specific registry key functions.
+//
+// For all path-based functions:
+//   - Paths are UTF8-encoded.
+//   - Paths are case-insensitive.
+//   - Path follows Unix path conventions (e.g. /a/b/c/d).
+//
+// Windows platform:
+//   Applications may use Registry setting paths to read the Windows registry.
+//   An example Windows path is:
+//      "/HKEY_LOCAL_MACHINE/Software/Oculus/ForceGPUDriverVersionAcceptance"
+//   Windows registry path reading for Win32 apps on Win64 OSs does not change
+//   the path to insert Wow64 paths, though users of this functionality may explicitly
+//   use "WoW64" in paths.
+//
+// Example Windows usage with default paths:
+//   mgr.SetDefaultLocation("/HKEY_LOCAL_MACHINE/Software/Oculus/");
+//   ...
+//   mgr.ReadValue("EnableTimeouts", timeoutsEnabled);
+//   mgr.ReadValue("FileName", test.tga);
+//   mgr.ReadValue("Graphics/ATWEnabled", aswEnabled);
+//
+// Example Windows usage with full paths:
+//   bool result = mgr.ReadValue("/HKEY_LOCAL_MACHINE/Software/Oculus/EnablePTW", ptwEnabled);
+//   bool result = mgr.WriteValue("/HKEY_LOCAL_MACHINE/Software/Oculus/FileName", "test.tga");
+//
+class SettingsManager {
+ public:
+  SettingsManager() = default;
+  ~SettingsManager() = default;
+
+  enum Options {
+    OptionNone = 0x00,
+    OptionUse32BitDatabase = 0x01, // Windows: This means to use KEY_WOW64_32KEY
+    OptionIgnoreAlternativeLocations = 0x02
+  };
+
+  // ReadValue:
+  //   - Return true if value exists and could be read, false if doesn't exist or can't be read.
+  //   - The value is written to only if the setting could be read (true return value).
+  //   - If the value was not originally written as the requested type,
+  //     it is interpreted as the type.
+  //   - If the path is relative path (no initial '/' char) then the default location
+  //     is prefixed to path.
+  bool ReadValue(const char* path, bool& value, int options = OptionNone);
+  bool ReadValue(const char* path, int32_t& value, int options = OptionNone);
+  bool ReadValue(const char* path, uint32_t& value, int options = OptionNone);
+  bool ReadValue(const char* path, int64_t& value, int options = OptionNone);
+  bool ReadValue(const char* path, uint64_t& value, int options = OptionNone);
+  bool ReadValue(const char* path, float& value, int options = OptionNone);
+  bool ReadValue(const char* path, double& value, int options = OptionNone);
+  bool ReadValue(const char* path, std::string& value, int options = OptionNone);
+  bool ReadValue(const char* path, std::wstring& value, int options = OptionNone);
+  bool ReadValue(const char* path, std::vector<uint8_t>& value, int options = OptionNone);
+  bool ReadValue(const char* path, uint8_t* data, size_t& dataSize, int options = OptionNone);
+
+  // WriteValue:
+  //    - Creates the setting if not already present
+  //    - Return true if the setting could be created (if needed) and written.
+  //    - Writes only the given path and not alternative locations.
+  //    - A value of a given type can be overwritten with a value of a different type.
+  bool WriteValue(const char* path, bool value, int options = OptionNone);
+  bool WriteValue(const char* path, int32_t value, int options = OptionNone);
+  bool WriteValue(const char* path, uint32_t value, int options = OptionNone);
+  bool WriteValue(const char* path, int64_t value, int options = OptionNone);
+  bool WriteValue(const char* path, uint64_t value, int options = OptionNone);
+  bool WriteValue(const char* path, float value, int options = OptionNone);
+  bool WriteValue(const char* path, double value, int options = OptionNone);
+  bool WriteValue(const char* path, const char* value, size_t valStrlen, int options = OptionNone);
+  bool WriteValue(const char* path, const std::string& str, int options = OptionNone);
+  bool WriteValue(const char* path, const wchar_t* val, size_t valStrlen, int options = OptionNone);
+  bool WriteValue(const char* path, const std::wstring& str, int options = OptionNone);
+  bool WriteValue(const char* path, const uint8_t* data, size_t dataSize, int options = OptionNone);
+
+  // Returns true if the value can be read and exists.
+  bool ValueExists(const char* path, int options = OptionNone) const;
+
+  // Returns true if the value could be deleted. Returns false if the value was present but deletion
+  // failed. wasPresent indicates if the value was present before deletion was attempted. Deletion
+  // affects the path and any registered alternative locations, unless
+  // OptionIgnoreAlternativeLocations is specified.
+  bool DeleteValue(const char* path, bool* wasPresent = nullptr, int options = OptionNone);
+
+  // Sets the default location for read and written value paths.
+  // Path must be a "full path", which begins with a path separator.
+  // Path must end with trailing path separtor.
+  // Defaults to empty.
+  // Example usage:
+  //    settingsMgr.SetDefaultLocation("/HKEY_LOCAL_MACHINE/Software/Oculus/");
+  void SetDefaultLocation(const char* parentPath);
+
+#define OVR_DEFAULT_SETTINGS_LOCATION "/HKEY_LOCAL_MACHINE/Software/Oculus/"
+// OVR_XRS_SETTINGS_LOCATION Declared here because shared with OculusDebugTool
+#define OVR_XRS_SETTINGS_LOCATION "/HKEY_CURRENT_USER/Software/Oculus/RemoteHeadset/"
+
+  // Returns the default location, which can be set by SetDefaultLocation.
+  std::string GetDefaultLocation() const;
+
+  // Adds an alternative location for value reads.
+  // Path must end with trailing path separtor.
+  // This function exists for the purpose of allowing migration of old Oculus settings
+  // paths to a single unified path.
+  // This function is not thread safe. It can be called from only a single thread at a time.
+  // Example usage:
+  //    settingsMgr.AddAlternativeLocation("/HKEY_LOCAL_MACHINE/Software/Oculus2/");
+  void AddAlternativeLocation(const char* parentPath);
+
+  // This function is not thread safe. It can be called from only a single thread at a time.
+  // Example usage:
+  //    settingsMgr.RemoveAlternativeLocation("/HKEY_LOCAL_MACHINE/Software/Oculus2/");
+  void RemoveAlternativeLocation(const char* parentPath);
+
+  struct InsensitiveCompare {
+    bool operator()(const std::string& a, const std::string& b) const {
+      return OVR_stricmp(a.c_str(), b.c_str()) < 0;
+    }
+  };
+
+  typedef std::set<std::string, InsensitiveCompare> StringSet;
+
+  // Gets a set of all currently registered alternative locations.
+  StringSet GetAlternativeLocations() const;
+
+  // Sets Oculus-specific alternative locations.
+  // This function is not thread safe. It can be called from only a single thread at a time.
+  void SetDefaultAlternativeLocations();
+
+  // Returns the values present at the given parentPath.
+  // Writes a single line per enumerated value, with each line followed by a newline,
+  // including the last line.
+  // The parentPath must begin with '/' and end with '/' or be NULL to indicate usage of the
+  // default path.
+  // Example usage:
+  //    str = settingsMgr.EnumerateValues("/HKEY_LOCAL_MACHINE/Software/Oculus/");
+  // Note:
+  //    When this data is backed by the Windows registry, the enumerated types won't be the
+  //    same as the written types. For example, WriteDouble writes to the Windows registry as
+  //    a binary value, and will be enumerated by EnumerateValues as binary instead of float.
+  std::string EnumerateValues(const char* parentPath = nullptr, int options = OptionNone) const;
+
+ protected:
+  // This is a parent settings directory which acts as the default if value
+  // reads and writes do not include a parent path.
+  // Example Windows value: "/HKEY_LOCAL_MACHINE/Software/Oculus2/"
+  std::string defaultLocation;
+
+#ifdef _WIN32
+  // https://msdn.microsoft.com/en-us/library/windows/desktop/ms724884(v=vs.85).aspx
+  struct Win32RegistryAnyValue {
+    uint32_t type; // Which REG_XXX type is used.
+    std::vector<uint8_t> binaryData; // REG_BINARY
+    uint32_t dwordData; // REG_DWORD
+    uint64_t qwordData; // REG_QWORD
+    std::string stringData; // REG_SZ or REG_EXPAND_SZ
+    std::vector<std::string> stringArrayData; // REG_MULTI_SZ
+
+    Win32RegistryAnyValue();
+  };
+
+  // Reads the Windows registry at the given path to a Win32RegistryAnyValue.
+  bool Win32ReadAnyRegistryValue(const char* path, Win32RegistryAnyValue& any, int options) const;
+
+  // Reads the Windows registry value (sourceData/sourceDataSize) to a Win32RegistryAnyValue.
+  bool Win32ReadAnyRegistryValue(
+      DWORD dwType,
+      uint8_t* sourceData,
+      size_t sourceDataSize,
+      Win32RegistryAnyValue& anyValue) const;
+
+  // Oculus unfortunately has a history of divergent Windows registry key storage locations.
+  // As part of the effort to converge on a single location, we provide backward-compatible
+  // old locations to check when reading values, so existing users that have registry keys at
+  // the old locations can still have their settings work. The locations are the parent
+  // registry key "directory". So for the "/HKEY_LOCAL_MACHINE/Software/Oculus LLC/Test" key,
+  // the location would be stored here as "/HKEY_LOCAL_MACHINE/Software/Oculus LLC/"
+  StringSet RegistryAlternativeLocations;
+#endif
+};
+
+extern SettingsManager DefaultSettingsManager;
+
+#ifdef OVR_OS_MS
+
+//--------------------------------------------------------------------------------------------------
+// Windows registry functions
+//
+// Use these functions only for reading non-Oculus registry data. For Oculus settings, use the
+// SettingsManager instead, which supplants direct Windows registry usage.
+//--------------------------------------------------------------------------------------------------
+
+enum class RegistryDB {
+  normal, // KEY_WOW64_64KEY. 64 bit apps use 64 bit database, 32 bit apps use 32 bit database.
+  wow64_32 // KEY_WOW64_32KEY. Force looking at the 32 bit database even if this is a 64 bit app.
+};
+
+enum class RegistryBase {
+  localMachine, // HKEY_LOCAL_MACHINE
+  currentUser // HKEY_CURRENT_USER
+};
+
+// Returns true if a registry key of the given type is present and can be interpreted as a boolean,
+// otherwise
+// returns defaultValue. It's not possible to tell from a single call to this function if the given
+// registry key
+// was present. For Strings, boolean means (atoi(str) != 0). For DWORDs, boolean means (dw != 0).
+// If registryDB is RegistryDB::normal then KEY_WOW64_32KEY is used in the registry lookup.
+// If registryBase is RegistryBase::currentUser then the HKEY_CURRENT_USER root is used
+// instead of HKEY_LOCAL_MACHINE
+bool GetRegistryBoolW(
+    const wchar_t* pSubKey,
+    const wchar_t* stringName,
+    bool defaultValue,
+    RegistryDB registryDB = RegistryDB::normal,
+    RegistryBase registryBase = RegistryBase::localMachine);
+
+// Returns true if a DWORD-type registry key of the given name is present, else sets out to 0 and
+// returns false.
+// If registryDB is RegistryDB::normal then KEY_WOW64_32KEY is used in the registry lookup.
+// If registryBase is RegistryBase::currentUser then the HKEY_CURRENT_USER root is used
+// instead of HKEY_LOCAL_MACHINE
+bool GetRegistryDwordW(
+    const wchar_t* pSubKey,
+    const wchar_t* stringName,
+    DWORD& out,
+    RegistryDB registryDB = RegistryDB::normal,
+    RegistryBase registryBase = RegistryBase::localMachine);
+
+// Returns true if a string-type registry key of the given name is present, else sets out to empty
+// and returns false.
+// The output string will always be 0-terminated, but may be empty.
+// If registryDB is RegistryDB::normal then KEY_WOW64_32KEY is used in the registry lookup.
+// If registryBase is RegistryBase::currentUser then the HKEY_CURRENT_USER root is used
+// instead of HKEY_LOCAL_MACHINE
+bool GetRegistryStringW(
+    const wchar_t* pSubKey,
+    const wchar_t* stringName,
+    wchar_t out[MAX_PATH],
+    RegistryDB registryDB = RegistryDB::normal,
+    RegistryBase registryBase = RegistryBase::localMachine);
+
+// Returns true if the DWORD value could be successfully written to the registry.
+// If registryDB is RegistryDB::normal then KEY_WOW64_32KEY is used in the registry lookup.
+// If registryBase is RegistryBase::currentUser then the HKEY_CURRENT_USER root is used
+// instead of HKEY_LOCAL_MACHINE
+bool SetRegistryDwordW(
+    const wchar_t* pSubKey,
+    const wchar_t* stringName,
+    DWORD newValue,
+    RegistryDB registryDB = RegistryDB::normal,
+    RegistryBase registryBase = RegistryBase::localMachine);
+
+// Returns true if the value could be successfully deleted from the registry.
+// If registryDB is RegistryDB::normal then KEY_WOW64_32KEY is used in the registry lookup.
+// If registryBase is RegistryBase::currentUser then the HKEY_CURRENT_USER root is used
+// instead of HKEY_LOCAL_MACHINE
+bool DeleteRegistryValue(
+    const wchar_t* pSubKey,
+    const wchar_t* stringName,
+    RegistryDB registryDB = RegistryDB::normal,
+    RegistryBase registryBase = RegistryBase::localMachine);
+
+#endif // OVR_OS_MS
+
+//-----------------------------------------------------------------------------
+// Get the path where the Oculus runtime output is written.
+//
+// GetBaseOVRPath() returns the top level Oculus output path.
+// On Windows, this is %LOCALAPPDATA%\Oculus.
+//
+// GetBaseOVRPathW() has the identical behavior as GetBaseOVRPath(), but
+// returns its result in a std::wstring.
+//
+// GetOVRPath() returns a path that represents a subdirectory from the top-level
+// Oculus output path. (The top-level path is what GetBaseOVRPath() returns.)
+//
+// GetOVRPathW() has the identical behavior as GetOVRPath(), but returns its
+// result in a std::wstring.
+
+String GetBaseOVRPath(bool create_dir);
+std::wstring GetBaseOVRPathW(bool create_dir);
+String GetOVRPath(const wchar_t* subPath, bool create_dir);
+std::wstring GetOVRPathW(const wchar_t* subPath, bool create_dir);
+
+//-----------------------------------------------------------------------------
+// Process path information
+
+// Returns the file path for the binary associated with the given runtime process id.
+// Returns an empty string if the process id is invalid or could not be read.
+// If enableErrorResults is true then failure strings will be written to the returned
+// value in parentheses. This is useful for logging.
+std::string GetProcessPath(pid_t processId, bool fileNameOnly, bool enableErrorResults);
+
+#if defined(_WIN32)
+// Returns the file path for the binary associated with the given runtime process id.
+// Returns an empty string if the process handle is invalid or could not be read.
+// If enableErrorResults is true then failure strings will be written to the returned
+// value in parentheses. This is useful for logging.
+std::string GetProcessPath(HANDLE processHandle, bool fileNameOnly, bool enableErrorResults);
+#endif
+
+// Returns true if the process was loaded outside of our Oculus store directory.
+bool IsProcessSideLoaded(const std::string& processPath);
+
+// Same as GetProcessPath, except scrubs the returned process path string if it's something we have
+// deemed
+// cannot be reported in our log, usually due to privacy measures we have enacted.
+std::string GetLoggableProcessPath(pid_t processId, bool fileNameOnly);
+
+#if defined(_WIN32)
+// Same as GetProcessPath, except scrubs the returned process path string if it's something we have
+// deemed
+// cannot be reported in our log, usually due to privacy measures we have enacted.
+std::string GetLoggableProcessPath(HANDLE processHandle, bool fileNameOnly);
+
+// Retrives the root of the Oculus install directory
+// The returned string is a directory path and does not have a trailing path separator.
+// Example return value: L"C:\Program Files// (x86)\Oculus\Support\oculus-runtime"
+std::wstring GetOVRRuntimePathW();
+#endif
+
+// Returns a string with a comma-separated list of tags for the machine.
+// The tags are obtained from the registry.
+String GetMachineTags();
+
+#if defined(_WIN32)
+String GetFileVersionStringW(const wchar_t filePath[MAX_PATH]);
+
+String GetSystemFileVersionStringW(const wchar_t filePath[MAX_PATH]);
+#endif
+
+//-----------------------------------------------------------------------------
+// Retrieves memory usage info for the current process.
+//
+// Do not call this function frequently as it takes hundreds of microseconds to
+// execute on typical computers.
+
+struct ProcessMemoryInfo {
+  uint64_t UsedMemory; // Same as Windows working set size.
+  // https://msdn.microsoft.com/en-us/library/windows/desktop/cc441804%28v=vs.85%29.aspx
+};
+
+ProcessMemoryInfo GetCurrentProcessMemoryInfo();
+
+//-----------------------------------------------------------------------------
+// Retrieves memory info for the system (counterpart of GetCurrentProcessMemoryInfo)
+//
+// Do not call this function frequently as it takes a long time to
+// execute on typical computers.
+
+struct SystemMemoryInfo {
+  double PageFault; // System-wide hard page faults per sec
+  uint64_t CommittedTotal; // Total number of committed memory (in bytes) on the system
+};
+
+SystemMemoryInfo GetSystemMemoryInfo();
+
+enum class CPUInstructionSet {
+  Unknown,
+  Basic, // Just basic 32 bit 386.
+  SEE1,
+  SSE2,
+  SSE3,
+  SSSE3, // Supplementary SSE3
+  SSE41,
+  SSE42,
+  AVX1,
+  AVX2
+};
+
+//-----------------------------------------------------------------------------
+// Indicates the minimum instruction set that the CPU + OS support. Note that an older OS may
+// not properly support a given CPU instruction set, usually because it doesn't know how to
+// preserve its registers on context switch.
+
+CPUInstructionSet GetSupportedCPUInstructionSet(bool* popcntSupported, bool* lzcntSupported);
+
+//-----------------------------------------------------------------------------
+// Implements ModuleInfo lookup functionalitity.
+// This class is separate from the OVR::SymbolLookup class, which has some
+// similar functionality, because that class has extra wiring to support (heavy)
+// symbol lookups, which we don't want here and which would put a lot more weight
+// on the usage of this functionality (which we want to be able to call frequently
+// at runtime).
+//
+class ModuleInfoLookup {
+ public:
+  ModuleInfoLookup() = default;
+  ~ModuleInfoLookup() = default;
+
+  const OVR::ModuleInfo* GetModuleInfoForAddress(uint64_t address);
+  const OVR::ModuleInfo& GetModuleInfoForCurrentModule();
+  bool GetAddressIsFromCurrentModule(uint64_t address);
+
+  // All process ModuleInfo, sorted by address.
+  std::vector<OVR::ModuleInfo> ModuleInfoArray;
+
+  // ModuleInfo for the current module. Not necessarily the main executable module.
+  OVR::ModuleInfo CurrentModuleInfo;
+};
+
+extern ModuleInfoLookup DefaultModuleInfoLookup;
+
+} // namespace Util
+} // namespace OVR
+
+#endif // OVR_Util_SystemInfo_h