diff options
| -rw-r--r-- | LibOVR/Src/OVR_Linux_HMDDevice.cpp | 11 | ||||
| -rw-r--r-- | LibOVR/Src/OVR_Linux_HMDDevice.h | 12 | ||||
| -rw-r--r-- | LibOVR/Src/OVR_Profile.cpp | 1013 | ||||
| -rw-r--r-- | LibOVR/Src/OVR_Profile.h | 385 |
4 files changed, 705 insertions, 716 deletions
diff --git a/LibOVR/Src/OVR_Linux_HMDDevice.cpp b/LibOVR/Src/OVR_Linux_HMDDevice.cpp index cce37d5..52f537d 100644 --- a/LibOVR/Src/OVR_Linux_HMDDevice.cpp +++ b/LibOVR/Src/OVR_Linux_HMDDevice.cpp @@ -234,14 +234,13 @@ Profile* HMDDeviceCreateDesc::GetProfileAddRef() const { // Create device may override profile name, so get it from there is possible. ProfileManager* profileManager = GetManagerImpl()->GetProfileManager(); - ProfileType profileType = GetProfileType(); const char * profileName = pDevice ? ((HMDDevice*)pDevice)->GetProfileName() : - profileManager->GetDefaultProfileName(profileType); + profileManager->GetDefaultProfileName(); return profileName ? - profileManager->LoadProfile(profileType, profileName) : - profileManager->GetDeviceDefaultProfile(profileType); + profileManager->LoadProfile(profileName) : + profileManager->GetDefaultProfile(); } @@ -341,7 +340,7 @@ bool HMDDevice::Initialize(DeviceBase* parent) // Initialize user profile to default for device. ProfileManager* profileManager = GetManager()->GetProfileManager(); - ProfileName = profileManager->GetDefaultProfileName(getDesc()->GetProfileType()); + ProfileName = profileManager->GetDefaultProfileName(); return true; } @@ -372,7 +371,7 @@ bool HMDDevice::SetProfileName(const char* name) ProfileName.Clear(); return 0; } - if (GetManager()->GetProfileManager()->HasProfile(getDesc()->GetProfileType(), name)) + if (GetManager()->GetProfileManager()->HasProfile(name)) { ProfileName = name; return true; diff --git a/LibOVR/Src/OVR_Linux_HMDDevice.h b/LibOVR/Src/OVR_Linux_HMDDevice.h index d0585d1..2350958 100644 --- a/LibOVR/Src/OVR_Linux_HMDDevice.h +++ b/LibOVR/Src/OVR_Linux_HMDDevice.h @@ -84,10 +84,10 @@ public: virtual bool GetDeviceInfo(DeviceInfo* info) const; // Requests the currently used default profile. This profile affects the - // settings reported by HMDInfo. + // settings reported by HMDInfo. Profile* GetProfileAddRef() const; - ProfileType GetProfileType() const + ProfileDeviceType GetProfileType() const { return (HResolution >= 1920) ? Profile_RiftDKHD : Profile_RiftDK1; } @@ -120,26 +120,26 @@ public: // HMDDevice represents an Oculus HMD device unit. An instance of this class // is typically created from the DeviceManager. -// After HMD device is created, we its sensor data can be obtained by +// After HMD device is created, we its sensor data can be obtained by // first creating a Sensor object and then wrappig it in SensorFusion. class HMDDevice : public DeviceImpl<OVR::HMDDevice> { public: HMDDevice(HMDDeviceCreateDesc* createDesc); - ~HMDDevice(); + ~HMDDevice(); virtual bool Initialize(DeviceBase* parent); virtual void Shutdown(); // Requests the currently used default profile. This profile affects the - // settings reported by HMDInfo. + // settings reported by HMDInfo. virtual Profile* GetProfile() const; virtual const char* GetProfileName() const; virtual bool SetProfileName(const char* name); // Query associated sensor. - virtual OVR::SensorDevice* GetSensor(); + virtual OVR::SensorDevice* GetSensor(); protected: HMDDeviceCreateDesc* getDesc() const { return (HMDDeviceCreateDesc*)pCreateDesc.GetPtr(); } diff --git a/LibOVR/Src/OVR_Profile.cpp b/LibOVR/Src/OVR_Profile.cpp index 3be43db..bf8906e 100644 --- a/LibOVR/Src/OVR_Profile.cpp +++ b/LibOVR/Src/OVR_Profile.cpp @@ -5,9 +5,9 @@ Filename : OVR_Profile.cpp Content : Structs and functions for loading and storing device profile settings Created : February 14, 2013 Notes : - + Profiles are used to store per-user settings that can be transferred and used - across multiple applications. For example, player IPD can be configured once + across multiple applications. For example, player IPD can be configured once and reused for a unified experience across games. Configuration and saving of profiles can be accomplished in game via the Profile API or by the official Oculus Configuration Utility. @@ -21,12 +21,13 @@ otherwise accompanies this software in either electronic or hard copy form. ************************************************************************************/ #include "OVR_Profile.h" -#include "OVR_JSON.h" +#include "OVR_Log.h" #include "Kernel/OVR_Types.h" #include "Kernel/OVR_SysFile.h" #include "Kernel/OVR_Allocator.h" #include "Kernel/OVR_Array.h" - +#include <json/json.h> +#include <fstream> #ifdef OVR_OS_WIN32 #include <Shlobj.h> #else @@ -40,8 +41,33 @@ otherwise accompanies this software in either electronic or hard copy form. #endif -#define PROFILE_VERSION 1.0 -#define MAX_PROFILE_MAJOR_VERSION 1 + +#define PROFILE_VERSION 2 +#define MAX_PROFILE_MAJOR_VERSION 2 + +// Many hard coded strings used in numerous locations have been +// repositioned here, so that there's no chance of a misspelling +// causing a problem. Not every string has been moved, but most of the +// repeated ones have. +#define KEY_PROFILE_VERSION "Oculus Profile Version" +#define KEY_CURRENT_PROFILE "CurrentProfile" +#define KEY_PROFILES "Profiles" +#define KEY_DEVICES "Devices" +#define KEY_GENDER "Gender" +#define KEY_PLAYER_HEIGHT "PlayerHeight" +#define KEY_IPD "IPD" +#define KEY_STRABISMUS_CORRECTION "StrabismusCorrection" + +#define KEY_LL "LL" +#define KEY_LR "LR" +#define KEY_RL "RL" +#define KEY_RR "RR" +#define KEY_EYECUP "EyeCup" +#define EPSILON 0.00001f +// 5'10" inch man +#define DEFAULT_HEIGHT 1.778f +#define DEFAULT_IPD 0.064f + namespace OVR { @@ -56,7 +82,7 @@ String GetBaseOVRPath(bool create_dir) TCHAR data_path[MAX_PATH]; SHGetFolderPath(0, CSIDL_LOCAL_APPDATA, NULL, 0, data_path); path = String(data_path); - + path += "/Oculus"; if (create_dir) @@ -67,11 +93,11 @@ String GetBaseOVRPath(bool create_dir) DWORD attrib = GetFileAttributes(wpath); bool exists = attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_DIRECTORY); if (!exists) - { + { CreateDirectory(wpath, NULL); } } - + #elif defined(OVR_OS_MAC) const char* home = getenv("HOME"); @@ -92,11 +118,21 @@ String GetBaseOVRPath(bool create_dir) } #else - - passwd* pwd = getpwuid(getuid()); - const char* home = pwd->pw_dir; - path = home; - path += "/.config/Oculus"; + // Updated the config folder location logic to rely on the + // XDG specification for config locations (the XDK location was being + // used anyway, but was hardcoded). This is analgous to using + // SHGetFolderPath in the windows implementation, rather than + // hardcoding %HOME%/AppData/Local + const char * config_home = getenv("XDG_CONFIG_HOME"); + if (NULL != config_home) { + path = config_home; + } else { + // only if XDG_CONFIG_HOME is unses does the specification say to + // fallback on the default of $HOME/.config + path = getenv("HOME"); + path += "/.config"; + } + path += "/Oculus"; if (create_dir) { // Create the Oculus directory if it doesn't exist @@ -129,7 +165,7 @@ String GetProfilePath(bool create_dir) ProfileManager::ProfileManager() { Changed = false; - CacheDevice = Profile_Unknown; + Loaded = false; } ProfileManager::~ProfileManager() @@ -146,410 +182,423 @@ ProfileManager* ProfileManager::Create() return new ProfileManager(); } -Profile* ProfileManager::CreateProfileObject(const char* user, - ProfileType device, - const char** device_name) -{ - Lock::Locker lockScope(&ProfileLock); - - Profile* profile = NULL; - switch (device) - { - case Profile_GenericHMD: - *device_name = NULL; - profile = new HMDProfile(Profile_GenericHMD, user); - break; - case Profile_RiftDK1: - *device_name = "RiftDK1"; - profile = new RiftDK1Profile(user); - break; - case Profile_RiftDKHD: - *device_name = "RiftDKHD"; - profile = new RiftDKHDProfile(user); - break; - case Profile_Unknown: - break; - } - - return profile; -} - - // Clear the local profile cache void ProfileManager::ClearCache() { Lock::Locker lockScope(&ProfileLock); - ProfileCache.Clear(); - CacheDevice = Profile_Unknown; + Loaded = false; } +// Profile loader is an intermediary that allows me to break down the +// serialization into smaller pieces that work directly against the +// new native JSON container type. This can't be done in the +// ProfileManager because it can't declare functions referencing the +// new type without polluting the header with knowledge of the JSON +// implementation +class ProfileLoader { +public: + static void loadHmd(HmdDevice & device, const Json::Value & node) { + if (node.isNull()) { + return; + } + if (node.isMember(KEY_LL)) { + device.LL = node.get(KEY_LL, 0).asInt(); + } + if (node.isMember(KEY_LR)) { + device.LR = node.get(KEY_LR, 0).asInt(); + } + if (node.isMember(KEY_RL)) { + device.RL = node.get(KEY_RL, 0).asInt(); + } + if (node.isMember(KEY_RR)) { + device.RR = node.get(KEY_RR, 0).asInt(); + } + } + + static void loadRift(RiftDevice & device, const Json::Value & node) { + if (node.isNull()) { + return; + } + String eyeCups = node.get(KEY_EYECUP, "A").asCString(); + char c = eyeCups.GetSize() ? eyeCups.GetCharAt(0) : 'A'; + switch (eyeCups.GetCharAt(0)) { + case 'A': + device.EyeCups = EyeCupType::EyeCup_A; + break; + case 'B': + device.EyeCups = EyeCupType::EyeCup_B; + break; + case 'C': + device.EyeCups = EyeCupType::EyeCup_C; + break; + } + loadHmd(device, node); + } + + // TODO migrate all the string constants up + static void loadV1Profile(Profile & out, const Json::Value & node) { + if (node.isNull()) { + return; + } + String gender = node.get(KEY_GENDER, "Unknown").asCString(); + if (gender == "Male") { + out.Gender = Profile::GenderType::Gender_Male; + } else if (gender == "Female") { + out.Gender = Profile::GenderType::Gender_Female; + } else { + out.Gender = Profile::GenderType::Gender_Unspecified; + } + + out.PlayerHeight = node.get(KEY_PLAYER_HEIGHT, DEFAULT_HEIGHT).asFloat(); + out.IPD = node.get(KEY_IPD, DEFAULT_IPD).asFloat(); + loadHmd(out.Generic, node.get("GenericHMD", Json::Value::null)); + loadRift(out.RiftDK1, node.get("RiftDK1", Json::Value::null)); + loadRift(out.RiftDKHD, node.get("RiftDKHD", Json::Value::null)); + } + + static void loadProfile(Profile & out, const Json::Value & node) { + if (node.isNull()) { + return; + } + loadV1Profile(out, node); + if (node.isMember(KEY_STRABISMUS_CORRECTION)) { + loadQuaternion(out.StrabismusCorrection, node[KEY_STRABISMUS_CORRECTION]); + } + } + + static void loadQuaternion(Quatf & out, const Json::Value & node) { + if (node.isNull()) { + return; + } + out.x = node.get("X", 0).asInt(); + out.y = node.get("Y", 0).asInt(); + out.z = node.get("Z", 0).asInt(); + out.w = node.get("W", 1).asInt(); + } + + static void saveQuaternion(Json::Value & out, const Quatf & q) { + out["X"] = q.x; + out["Y"] = q.y; + out["Z"] = q.z; + out["W"] = q.w; + } + + // TODO implement, and migrate the Devices.json parsing code to use this + static void loadMatrix(Matrix4f & out, const Json::Value & node) { + } + + // + // The general pattern on writing Json is to write the node only if + // it differs from the default, and to explicitly remove the node if it + // is the same as the default. This is important, because the load / save + // mechanism is designed to preserve any pre-existing content and not + // to touch any fields it's not aware of. + // + // Therefore, failing to write out a default value doesn't mean there's + // not already a non-default value there, hence the explicit removes. + // It gets a little verbose but the result is greater extensibility of the + // profile data by third parties. + static void writeHmdDevice(Json::Value & out, const HmdDevice & device) { + if (device.LL != 0) { + out[KEY_LL] = device.LL; + } else { + out.removeMember(KEY_LL); + } + if (device.LR != 0) { + out[KEY_LR] = device.LR; + } else { + out.removeMember(KEY_LR); + } + if (device.RL != 0) { + out[KEY_RL] = device.RL; + } else { + out.removeMember(KEY_RL); + } + if (device.RR != 0) { + out[KEY_RR] = device.RR; + } else { + out.removeMember(KEY_RR); + } + } + + static void writeRiftDevice(Json::Value & deviceNode, const RiftDevice & device) { + switch (device.EyeCups) + { + case EyeCup_B: deviceNode[KEY_EYECUP] = "B"; break; + case EyeCup_C: deviceNode[KEY_EYECUP] = "C"; break; + // A is the default, so no need to serialize it + case EyeCup_A: deviceNode.removeMember(KEY_EYECUP); break; + } + writeHmdDevice(deviceNode, device); + } + + // Applying the "remove nodes if they're empty" logic here is a little + // arduous, but it makes the resulting JSON cleaner + static void updateDeviceProfile(Json::Value & parent, const HmdDevice & device) { + String name; + Json::Value newChild; + switch (device.GetDeviceType()) { + case Profile_RiftDK1: + name = "RiftDK1"; + newChild = parent[name]; + writeRiftDevice(newChild, (RiftDevice&)device); + break; + + case Profile_RiftDKHD: + name = "RiftDKHD"; + newChild = parent[name]; + writeRiftDevice(newChild, (RiftDevice&)device); + break; + + case Profile_GenericHMD: + name = "GenericHMD"; + newChild = parent[name]; + writeHmdDevice(newChild, device); + break; + } + + // Don't write empty children + if (newChild.getMemberNames().size()) { + parent[name] = newChild; + } else { + parent.removeMember(name); + } + } + + static void writeProfile(Json::Value & parent, const Profile & profile) { + Json::Value & out = parent[profile.Name]; + + switch (profile.GetGender()) { + case Profile::Gender_Male: + out[KEY_GENDER] = "Male"; + break; + case Profile::Gender_Female: + out[KEY_GENDER] = "Female"; + break; + default: + out.removeMember(KEY_GENDER); + } + + // Epsilon is 10 micrometers. Smaller than a human hair + if (abs(profile.PlayerHeight - DEFAULT_HEIGHT) > EPSILON) { + out[KEY_PLAYER_HEIGHT] = profile.PlayerHeight; + } else { + out.removeMember(KEY_PLAYER_HEIGHT); + } + + if (abs(profile.IPD - DEFAULT_IPD) > EPSILON) { + out[KEY_IPD] = profile.IPD; + } else { + out.removeMember(KEY_IPD); + } + + if (profile.StrabismusCorrection.Distance(Quatf()) > EPSILON) { + saveQuaternion(out[KEY_STRABISMUS_CORRECTION], + profile.StrabismusCorrection); + } else { + out.removeMember(KEY_STRABISMUS_CORRECTION); + } + + Json::Value & devicesNode = out[KEY_DEVICES]; + updateDeviceProfile(devicesNode, profile.Generic); + updateDeviceProfile(devicesNode, profile.RiftDK1); + updateDeviceProfile(devicesNode, profile.RiftDKHD); + if (!devicesNode.getMemberNames().size()) { + out.removeMember(KEY_DEVICES); + } + } +}; + +// Use of STL IO is potentially avoidable with jsoncpp, if you wanted +// to load the file into a String instead and use the char* interface for +// parsing JSON in memory. Linking to C++ standard library is unavoidable +// though, but it might not take much work to remove iostream usage from +// the jsoncpp lib and make it use std::string only. +bool parseJsonFile(const String & file, Json::Value & root) { + Json::Reader reader; + String path = GetProfilePath(false); + std::ifstream in(path.ToCStr()); + if (!reader.parse(in, root)) { + // report to the user the failure and their locations in the document. + LogError("Failed to parse json file: %s\n %s", + file.ToCStr(), + reader.getFormattedErrorMessages().c_str()); + return false; + } + return true; + +} // Poplulates the local profile cache. This occurs on the first access of the profile // data. All profile operations are performed against the local cache until the // ProfileManager is released or goes out of scope at which time the cache is serialized // to disk. -void ProfileManager::LoadCache(ProfileType device) -{ - Lock::Locker lockScope(&ProfileLock); - - ClearCache(); - - String path = GetProfilePath(false); - - Ptr<JSON> root = *JSON::Load(path); - if (!root || root->GetItemCount() < 3) +void ProfileManager::LoadCache() { + if (Loaded) { + return; + } + + Lock::Locker lockScope(&ProfileLock); + ClearCache(); + + Json::Value root; + if (!parseJsonFile(GetProfilePath(false), root)) { + LogError("Failed to parse configuration"); + return; + } + + if (!root.isMember(KEY_PROFILE_VERSION)) { + LogError("Profile JSON is malformed, missing version number"); + return; + } + + int major = root[KEY_PROFILE_VERSION].asInt(); + switch (major) { + case 1: { + if (root.size() < 3) { + LogError("Profile JSON is malformed, insufficient keys"); return; - - // First read the file type and version to make sure this is a valid file - JSON* item0 = root->GetFirstItem(); - JSON* item1 = root->GetNextItem(item0); - JSON* item2 = root->GetNextItem(item1); - - if (item0->Name == "Oculus Profile Version") - { - int major = atoi(item0->Value.ToCStr()); - if (major > MAX_PROFILE_MAJOR_VERSION) - return; // don't parse the file on unsupported major version number - } - else - { + } + DefaultProfile = root[KEY_CURRENT_PROFILE].asCString(); + const Json::Value & profileNode = root["Profile"]; + String name = profileNode["Name"].asCString(); + // The profile having to know it's own name is a symptom of the lack + // of a proper associative array class in the OVR codebase. + Profile * profile = new Profile(name); + ProfileLoader::loadV1Profile(*profile, profileNode); + ProfileCache.PushBack(profile); + } + break; + + case 2: { + if (!root.isMember(KEY_PROFILES)) { + LogError("Missing profile data"); return; - } - - DefaultProfile = item1->Value; - - // Read the number of profiles - int profileCount = (int)item2->dValue; - JSON* profileItem = item2; - - for (int p=0; p<profileCount; p++) - { - profileItem = root->GetNextItem(profileItem); - if (profileItem == NULL) - break; - - if (profileItem->Name == "Profile") - { - // Read the required Name field - const char* profileName; - JSON* item = profileItem->GetFirstItem(); - - if (item && (item->Name == "Name")) - { - profileName = item->Value; - } - else - { - return; // invalid field - } - - const char* deviceName = 0; - bool deviceFound = false; - Ptr<Profile> profile = *CreateProfileObject(profileName, device, &deviceName); - - // Read the base profile fields. - if (profile) - { - while (item = profileItem->GetNextItem(item), item) - { - if (item->Type != JSON_Object) - { - profile->ParseProperty(item->Name, item->Value); - } - else - { // Search for the matching device to get device specific fields - if (!deviceFound && deviceName && OVR_strcmp(item->Name, deviceName) == 0) - { - deviceFound = true; - - for (JSON* deviceItem = item->GetFirstItem(); deviceItem; - deviceItem = item->GetNextItem(deviceItem)) - { - profile->ParseProperty(deviceItem->Name, deviceItem->Value); - } - } - } - } - } - - // Add the new profile - ProfileCache.PushBack(profile); - } - } - - CacheDevice = device; + } + + const Json::Value & profiles = root[KEY_PROFILES]; + Json::Value::const_iterator itr; + for (itr = profiles.begin(); itr != profiles.end(); ++itr) { + String profileName = itr.memberName(); + Profile * profile = new Profile(profileName); + ProfileLoader::loadProfile(*profile, root[profileName]); + ProfileCache.PushBack(profile); + } + + if (!root.isMember(KEY_CURRENT_PROFILE)) { + LogError("Missing current profile"); + } else { + DefaultProfile = root[KEY_CURRENT_PROFILE].asCString(); + } + } + break; + + default: + LogError("Usupported profile version %d", major); + return; // don't parse the file on unsupported major version number + } + Loaded = true; } - // Serializes the profiles to disk. void ProfileManager::SaveCache() { - String path = GetProfilePath(true); - Lock::Locker lockScope(&ProfileLock); - - Ptr<JSON> oldroot = *JSON::Load(path); - if (oldroot) + // Limit scope of reader + Json::Value root; + String path = GetProfilePath(false); + if (!parseJsonFile(path, root)) { - if (oldroot->GetItemCount() >= 3) - { - JSON* item0 = oldroot->GetFirstItem(); - JSON* item1 = oldroot->GetNextItem(item0); - oldroot->GetNextItem(item1); - - if (item0->Name == "Oculus Profile Version") - { - int major = atoi(item0->Value.ToCStr()); - if (major > MAX_PROFILE_MAJOR_VERSION) - oldroot.Clear(); // don't use the file on unsupported major version number - } - else - { - oldroot.Clear(); - } - } - else - { - oldroot.Clear(); - } + root = Json::Value(); } - - // Create a new json root - Ptr<JSON> root = *JSON::CreateObject(); - root->AddNumberItem("Oculus Profile Version", PROFILE_VERSION); - root->AddStringItem("CurrentProfile", DefaultProfile); - root->AddNumberItem("ProfileCount", (double) ProfileCache.GetSize()); - - // Generate a JSON subtree for each profile - for (unsigned int i=0; i<ProfileCache.GetSize(); i++) - { - Profile* profile = ProfileCache[i]; - - // Write the base profile information - JSON* json_profile = JSON::CreateObject(); - json_profile->Name = "Profile"; - json_profile->AddStringItem("Name", profile->Name); - const char* gender; - switch (profile->GetGender()) - { - case Profile::Gender_Male: gender = "Male"; break; - case Profile::Gender_Female: gender = "Female"; break; - default: gender = "Unspecified"; - } - json_profile->AddStringItem("Gender", gender); - json_profile->AddNumberItem("PlayerHeight", profile->PlayerHeight); - json_profile->AddNumberItem("IPD", profile->IPD); - - char* device_name = NULL; - // Create a device-specific subtree for the cached device - if (profile->Type == Profile_RiftDK1) - { - device_name = "RiftDK1"; - - RiftDK1Profile* rift = (RiftDK1Profile*)profile; - JSON* json_rift = JSON::CreateObject(); - json_profile->AddItem(device_name, json_rift); - - const char* eyecup = "A"; - switch (rift->EyeCups) - { - case EyeCup_A: eyecup = "A"; break; - case EyeCup_B: eyecup = "B"; break; - case EyeCup_C: eyecup = "C"; break; - } - json_rift->AddStringItem("EyeCup", eyecup); - json_rift->AddNumberItem("LL", rift->LL); - json_rift->AddNumberItem("LR", rift->LR); - json_rift->AddNumberItem("RL", rift->RL); - json_rift->AddNumberItem("RR", rift->RR); - } - else if (profile->Type == Profile_RiftDKHD) - { - device_name = "RiftDKHD"; - - RiftDKHDProfile* rift = (RiftDKHDProfile*)profile; - JSON* json_rift = JSON::CreateObject(); - json_profile->AddItem(device_name, json_rift); - - const char* eyecup = "A"; - switch (rift->EyeCups) - { - case EyeCup_A: eyecup = "A"; break; - case EyeCup_B: eyecup = "B"; break; - case EyeCup_C: eyecup = "C"; break; - } - json_rift->AddStringItem("EyeCup", eyecup); - //json_rift->AddNumberItem("LL", rift->LL); - //json_rift->AddNumberItem("LR", rift->LR); - //json_rift->AddNumberItem("RL", rift->RL); - //json_rift->AddNumberItem("RR", rift->RR); - } - - // There may be multiple devices stored per user, but only a single - // device is represented by this root. We don't want to overwrite - // the other devices so we need to examine the older root - // and merge previous devices into new json root - if (oldroot) - { - JSON* old_profile = oldroot->GetFirstItem(); - while (old_profile) - { - if (old_profile->Name == "Profile") - { - JSON* profile_name = old_profile->GetItemByName("Name"); - if (profile_name && OVR_strcmp(profile->Name, profile_name->Value) == 0) - { // Now that we found the user in the older root, add all the - // object children to the new root - except for the one for the - // current device - JSON* old_item = old_profile->GetFirstItem(); - while (old_item) - { - if (old_item->Type == JSON_Object - && (device_name == NULL || OVR_strcmp(old_item->Name, device_name) != 0)) - { - JSON* old_device = old_item; - old_item = old_profile->GetNextItem(old_item); - - // remove the node from the older root to avoid multiple reference - old_device->RemoveNode(); - // add the node pointer to the new root - json_profile->AddItem(old_device->Name, old_device); - } - else - { - old_item = old_profile->GetNextItem(old_item); - } - } - - break; - } - } - - old_profile = oldroot->GetNextItem(old_profile); - } - } - // Add the completed user profile to the new root - root->AddItem("Profile", json_profile); + // If the file is V1, we don't want to preserve it. + // Technically, we could make an effort to preserve it but explcitly + // remove the V1 tokens we don't use in V2, but that's a bunch of + // effort that will likely serve no useful purpose. Since the file + // isn't valid JSON if it has multiple profiles, I doubt anyone is + // extending it yet + if (root.isMember(KEY_PROFILE_VERSION) && + PROFILE_VERSION != root[KEY_PROFILE_VERSION].asInt()) { + root = Json::Value(); } - // Save the profile to disk - root->Save(path); -} - -// Returns the number of stored profiles for this device type -int ProfileManager::GetProfileCount(ProfileType device) -{ - Lock::Locker lockScope(&ProfileLock); - - if (CacheDevice == Profile_Unknown) - LoadCache(device); - - return (int)ProfileCache.GetSize(); -} - -// Returns the profile name of a specific profile in the list. The returned -// memory is locally allocated and should not be stored or deleted. Returns NULL -// if the index is invalid -const char* ProfileManager::GetProfileName(ProfileType device, unsigned int index) -{ - Lock::Locker lockScope(&ProfileLock); - - if (CacheDevice == Profile_Unknown) - LoadCache(device); + root[KEY_PROFILE_VERSION] = PROFILE_VERSION; + if (!DefaultProfile.IsEmpty()) { + root[KEY_CURRENT_PROFILE] = DefaultProfile.ToCStr(); + } - if (index < ProfileCache.GetSize()) - { - Profile* profile = ProfileCache[index]; - OVR_strcpy(NameBuff, Profile::MaxNameLen, profile->Name); - return NameBuff; + // Generate a JSON object of 'profile name' to 'profile data' + Json::Value & profiles = root[KEY_PROFILES]; + for (unsigned int i=0; i<ProfileCache.GetSize(); i++) { + const Profile * profile = ProfileCache[i]; + ProfileLoader::writeProfile(profiles, *profile); } - else + { - return NULL; + Json::StyledWriter writer; + std::string output = writer.write( root ); + SysFile f; + if (!f.Open(path, File::Open_Write | File::Open_Create | File::Open_Truncate, File::Mode_Write)) { + LogError("Unable to open %s for writing", path.ToCStr()); + return; + } + int written = f.Write((const unsigned char*)output.c_str(), + output.length()); + if (written != output.length()) { + LogError("Short write, only %d of %d bytes written", + written, (int)output.length()); + } + f.Close(); } } -bool ProfileManager::HasProfile(ProfileType device, const char* name) +// Returns the number of stored profiles for this device type +unsigned int ProfileManager::GetProfileCount() { Lock::Locker lockScope(&ProfileLock); - - if (CacheDevice == Profile_Unknown) - LoadCache(device); - - for (unsigned i = 0; i< ProfileCache.GetSize(); i++) - { - if (ProfileCache[i] && OVR_strcmp(ProfileCache[i]->Name, name) == 0) - return true; - } - return false; + return ProfileCache.GetSize(); } - -// Returns a specific profile object in the list. The returned memory should be -// encapsulated in a Ptr<> object or released after use. Returns NULL if the index -// is invalid -Profile* ProfileManager::LoadProfile(ProfileType device, unsigned int index) +bool ProfileManager::HasProfile(const char* name) { - Lock::Locker lockScope(&ProfileLock); - - if (CacheDevice == Profile_Unknown) - LoadCache(device); - - if (index < ProfileCache.GetSize()) - { - Profile* profile = ProfileCache[index]; - return profile->Clone(); - } - else - { - return NULL; - } + return NULL != ProfileCache.at(name); } -// Returns a profile object for a particular device and user name. The returned -// memory should be encapsulated in a Ptr<> object or released after use. Returns +// Returns a profile object for a particular device and user name. The returned +// memory should be encapsulated in a Ptr<> object or released after use. Returns // NULL if the profile is not found -Profile* ProfileManager::LoadProfile(ProfileType device, const char* user) +Profile* ProfileManager::LoadProfile(const char* user) { + // Maybe 'null' should be interpreted as 'return the default?' if (user == NULL) return NULL; Lock::Locker lockScope(&ProfileLock); - - if (CacheDevice == Profile_Unknown) - LoadCache(device); - - for (unsigned int i=0; i<ProfileCache.GetSize(); i++) - { - if (OVR_strcmp(user, ProfileCache[i]->Name) == 0) - { // Found the requested user profile - Profile* profile = ProfileCache[i]; - return profile->Clone(); - } + LoadCache(); + Profile * result = ProfileCache.at(user); + if (!result) { + return NULL; } - - return NULL; + // Never give the caller memory that we ourselves are managing. + return result->Clone(); } // Returns a profile with all system default values -Profile* ProfileManager::GetDeviceDefaultProfile(ProfileType device) +Profile* ProfileManager::GetDefaultProfile() { - const char* device_name = NULL; - return CreateProfileObject("default", device, &device_name); + return new Profile("default"); } // Returns the name of the profile that is marked as the current default user. -const char* ProfileManager::GetDefaultProfileName(ProfileType device) +const char* ProfileManager::GetDefaultProfileName() { Lock::Locker lockScope(&ProfileLock); - - if (CacheDevice == Profile_Unknown) - LoadCache(device); + LoadCache(); if (ProfileCache.GetSize() > 0) { - OVR_strcpy(NameBuff, Profile::MaxNameLen, DefaultProfile); + OVR_strcpy(NameBuff, 32, DefaultProfile); return NameBuff; } else @@ -558,14 +607,12 @@ const char* ProfileManager::GetDefaultProfileName(ProfileType device) } } + // Marks a particular user as the current default user. -bool ProfileManager::SetDefaultProfileName(ProfileType device, const char* name) -{ +bool ProfileManager::SetDefaultProfileName(const char* name) { Lock::Locker lockScope(&ProfileLock); - - if (CacheDevice == Profile_Unknown) - LoadCache(device); -// TODO: I should verify that the user is valid + LoadCache(); + // TODO: I should verify that the user is valid if (ProfileCache.GetSize() > 0) { DefaultProfile = name; @@ -581,132 +628,67 @@ bool ProfileManager::SetDefaultProfileName(ProfileType device, const char* name) // Saves a new or existing profile. Returns true on success or false on an // invalid or failed save. -bool ProfileManager::Save(const Profile* profile) +bool ProfileManager::Save(const Profile * profile) { - Lock::Locker lockScope(&ProfileLock); + if (NULL == profile) { + return false; + } if (OVR_strcmp(profile->Name, "default") == 0) return false; // don't save a default profile - // TODO: I should also verify that this profile type matches the current cache - if (CacheDevice == Profile_Unknown) - LoadCache(profile->Type); + Lock::Locker lockScope(&ProfileLock); + LoadCache(); // Look for the pre-existence of this profile - bool added = false; - for (unsigned int i=0; i<ProfileCache.GetSize(); i++) - { - int compare = OVR_strcmp(profile->Name, ProfileCache[i]->Name); - - if (compare == 0) - { - // TODO: I should do a proper field comparison to avoid unnecessary - // overwrites and file saves - - // Replace the previous instance with the new profile - ProfileCache[i] = *profile->Clone(); - added = true; - Changed = true; - break; - } - } - - if (!added) - { - ProfileCache.PushBack(*profile->Clone()); - if (ProfileCache.GetSize() == 1) - CacheDevice = profile->Type; + int index = ProfileCache.IndexOf(profile->Name); + if (Map::npos == index) { + // TODO: I should do a proper field comparison to avoid unnecessary + // overwrites and file saves - Changed = true; + // Replace the previous instance with the new profile + ProfileCache[index] = profile->Clone(); + } else { + ProfileCache.PushBack(profile->Clone()); } - + Changed = true; return true; } // Removes an existing profile. Returns true if the profile was found and deleted // and returns false otherwise. -bool ProfileManager::Delete(const Profile* profile) +bool ProfileManager::Delete(const Profile * profile) { + if (NULL == profile) { + return false; + } Lock::Locker lockScope(&ProfileLock); - - if (OVR_strcmp(profile->Name, "default") == 0) - return false; // don't delete a default profile - - if (CacheDevice == Profile_Unknown) - LoadCache(profile->Type); - - // Look for the existence of this profile - for (unsigned int i=0; i<ProfileCache.GetSize(); i++) - { - if (OVR_strcmp(profile->Name, ProfileCache[i]->Name) == 0) - { - if (OVR_strcmp(profile->Name, DefaultProfile) == 0) - DefaultProfile.Clear(); - - ProfileCache.RemoveAt(i); - Changed = true; - return true; - } + int index = ProfileCache.IndexOf(profile->Name); + if (Map::npos == index) { + return false; } - - return false; + ProfileCache.RemoveAt(index); + return true; } - - //----------------------------------------------------------------------------- // ***** Profile -Profile::Profile(ProfileType device, const char* name) +Profile::Profile(const char* name) { - Type = device; Gender = Gender_Unspecified; - PlayerHeight = 1.778f; // 5'10" inch man - IPD = 0.064f; - OVR_strcpy(Name, MaxNameLen, name); -} - - -bool Profile::ParseProperty(const char* prop, const char* sval) -{ - if (OVR_strcmp(prop, "Name") == 0) - { - OVR_strcpy(Name, MaxNameLen, sval); - return true; - } - else if (OVR_strcmp(prop, "Gender") == 0) - { - if (OVR_strcmp(sval, "Male") == 0) - Gender = Gender_Male; - else if (OVR_strcmp(sval, "Female") == 0) - Gender = Gender_Female; - else - Gender = Gender_Unspecified; - - return true; - } - else if (OVR_strcmp(prop, "PlayerHeight") == 0) - { - PlayerHeight = (float)atof(sval); - return true; - } - else if (OVR_strcmp(prop, "IPD") == 0) - { - IPD = (float)atof(sval); - return true; - } - - return false; + PlayerHeight = DEFAULT_HEIGHT; + IPD = DEFAULT_IPD; + Name = name; } - // Computes the eye height from the metric head height -float Profile::GetEyeHeight() +float Profile::GetEyeHeight() const { const float EYE_TO_HEADTOP_RATIO = 0.44538f; const float MALE_AVG_HEAD_HEIGHT = 0.232f; const float FEMALE_AVG_HEAD_HEIGHT = 0.218f; - + // compute distance from top of skull to the eye float head_height; if (Gender == Gender_Female) @@ -720,107 +702,4 @@ float Profile::GetEyeHeight() return eye_height; } -//----------------------------------------------------------------------------- -// ***** HMDProfile - -HMDProfile::HMDProfile(ProfileType type, const char* name) : Profile(type, name) -{ - LL = 0; - LR = 0; - RL = 0; - RR = 0; -} - -bool HMDProfile::ParseProperty(const char* prop, const char* sval) -{ - if (OVR_strcmp(prop, "LL") == 0) - { - LL = atoi(sval); - return true; - } - else if (OVR_strcmp(prop, "LR") == 0) - { - LR = atoi(sval); - return true; - } - else if (OVR_strcmp(prop, "RL") == 0) - { - RL = atoi(sval); - return true; - } - else if (OVR_strcmp(prop, "RR") == 0) - { - RR = atoi(sval); - return true; - } - - return Profile::ParseProperty(prop, sval); -} - -Profile* HMDProfile::Clone() const -{ - HMDProfile* profile = new HMDProfile(*this); - return profile; -} - -//----------------------------------------------------------------------------- -// ***** RiftDK1Profile - -RiftDK1Profile::RiftDK1Profile(const char* name) : HMDProfile(Profile_RiftDK1, name) -{ - EyeCups = EyeCup_A; -} - -bool RiftDK1Profile::ParseProperty(const char* prop, const char* sval) -{ - if (OVR_strcmp(prop, "EyeCup") == 0) - { - switch (sval[0]) - { - case 'C': EyeCups = EyeCup_C; break; - case 'B': EyeCups = EyeCup_B; break; - default: EyeCups = EyeCup_A; break; - } - return true; - } - - return HMDProfile::ParseProperty(prop, sval); -} - -Profile* RiftDK1Profile::Clone() const -{ - RiftDK1Profile* profile = new RiftDK1Profile(*this); - return profile; -} - -//----------------------------------------------------------------------------- -// ***** RiftDKHDProfile - -RiftDKHDProfile::RiftDKHDProfile(const char* name) : HMDProfile(Profile_RiftDKHD, name) -{ - EyeCups = EyeCup_A; -} - -bool RiftDKHDProfile::ParseProperty(const char* prop, const char* sval) -{ - if (OVR_strcmp(prop, "EyeCup") == 0) - { - switch (sval[0]) - { - case 'C': EyeCups = EyeCup_C; break; - case 'B': EyeCups = EyeCup_B; break; - default: EyeCups = EyeCup_A; break; - } - return true; - } - - return HMDProfile::ParseProperty(prop, sval); -} - -Profile* RiftDKHDProfile::Clone() const -{ - RiftDKHDProfile* profile = new RiftDKHDProfile(*this); - return profile; -} - } // OVR diff --git a/LibOVR/Src/OVR_Profile.h b/LibOVR/Src/OVR_Profile.h index df25fea..2c5e4c2 100644 --- a/LibOVR/Src/OVR_Profile.h +++ b/LibOVR/Src/OVR_Profile.h @@ -6,7 +6,7 @@ Content : Structs and functions for loading and storing device profile set Created : February 14, 2013 Notes : Profiles are used to store per-user settings that can be transferred and used - across multiple applications. For example, player IPD can be configured once + across multiple applications. For example, player IPD can be configured once and reused for a unified experience across games. Configuration and saving of profiles can be accomplished in game via the Profile API or by the official Oculus Configuration Utility. @@ -25,11 +25,12 @@ otherwise accompanies this software in either electronic or hard copy form. #include "Kernel/OVR_String.h" #include "Kernel/OVR_RefCount.h" #include "Kernel/OVR_Array.h" +#include "Kernel/OVR_Math.h" namespace OVR { // Defines the profile object for each device type -enum ProfileType +enum ProfileDeviceType { Profile_Unknown = 0, Profile_GenericHMD = 10, @@ -37,119 +38,17 @@ enum ProfileType Profile_RiftDKHD = 12, }; -class Profile; - -// ----------------------------------------------------------------------------- -// ***** ProfileManager - -// Profiles are interfaced through a ProfileManager object. Applications should -// create a ProfileManager each time they intend to read or write user profile data. -// The scope of the ProfileManager object defines when disk I/O is performed. Disk -// reads are performed on the first profile access and disk writes are performed when -// the ProfileManager goes out of scope. All profile interactions between these times -// are performed in local memory and are fast. A typical profile interaction might -// look like this: // -// { -// Ptr<ProfileManager> pm = *ProfileManager::Create(); -// Ptr<Profile> profile = pm->LoadProfile(Profile_RiftDK1, -// pm->GetDefaultProfileName(Profile_RiftDK1)); -// if (profile) -// { // Retrieve the current profile settings -// } -// } // Profile will be destroyed and any disk I/O completed when going out of scope - -class ProfileManager : public RefCountBase<ProfileManager> -{ -protected: - // Synchronize ProfileManager access since it may be accessed from multiple threads, - // as it's shared through DeviceManager. - Lock ProfileLock; - Array<Ptr<Profile> > ProfileCache; - ProfileType CacheDevice; - String DefaultProfile; - bool Changed; - char NameBuff[32]; - -public: - static ProfileManager* Create(); - - // Static interface functions - int GetProfileCount(ProfileType device); - const char* GetProfileName(ProfileType device, unsigned int index); - bool HasProfile(ProfileType device, const char* name); - Profile* LoadProfile(ProfileType device, unsigned int index); - Profile* LoadProfile(ProfileType device, const char* name); - Profile* GetDeviceDefaultProfile(ProfileType device); - const char* GetDefaultProfileName(ProfileType device); - bool SetDefaultProfileName(ProfileType device, const char* name); - bool Save(const Profile* profile); - bool Delete(const Profile* profile); - -protected: - ProfileManager(); - ~ProfileManager(); - void LoadCache(ProfileType device); - void SaveCache(); - void ClearCache(); - Profile* CreateProfileObject(const char* user, - ProfileType device, - const char** device_name); -}; - -//------------------------------------------------------------------- -// ***** Profile - -// The base profile for all users. This object is not created directly. -// Instead derived device objects provide add specific device members to -// the base profile - -class Profile : public RefCountBase<Profile> -{ -public: - enum { MaxNameLen = 32 }; - - enum GenderType - { - Gender_Unspecified = 0, - Gender_Male = 1, - Gender_Female = 2 - }; - - ProfileType Type; // The type of device profile - char Name[MaxNameLen]; // The name given to this profile - -protected: - GenderType Gender; // The gender of the user - float PlayerHeight; // The height of the user in meters - float IPD; // Distance between eyes in meters - -public: - virtual Profile* Clone() const = 0; - - // These are properties which are intrinsic to the user and affect scene setup - GenderType GetGender() { return Gender; }; - float GetPlayerHeight() { return PlayerHeight; }; - float GetIPD() { return IPD; }; - float GetEyeHeight(); - - void SetGender(GenderType gender) { Gender = gender; }; - void SetPlayerHeight(float height) { PlayerHeight = height; }; - void SetIPD(float ipd) { IPD = ipd; }; - -protected: - Profile(ProfileType type, const char* name); - - virtual bool ParseProperty(const char* prop, const char* sval); - - friend class ProfileManager; -}; +// HMDProfile and it's child classes, RiftProfile, RiftDk1Profile and +// RiftDKHDProfile represent the intersection of 'per-user' and 'per-device' +// settings. +// //----------------------------------------------------------------------------- // ***** HMDProfile // The generic HMD profile is used for properties that are common to all headsets -class HMDProfile : public Profile +class HmdDevice { protected: // FOV extents in pixels measured by a user @@ -159,8 +58,7 @@ protected: int RR; // right eye outer extent public: - virtual Profile* Clone() const; - + virtual ~HmdDevice() {} void SetLL(int val) { LL = val; }; void SetLR(int val) { LR = val; }; void SetRL(int val) { RL = val; }; @@ -170,13 +68,19 @@ public: int GetLR() { return LR; }; int GetRL() { return RL; }; int GetRR() { return RR; }; + virtual ProfileDeviceType GetDeviceType() const { + return Profile_GenericHMD; + } protected: - HMDProfile(ProfileType type, const char* name); - - virtual bool ParseProperty(const char* prop, const char* sval); - - friend class ProfileManager; + HmdDevice() { + LL = 0; + LR = 0; + RL = 0; + RR = 0; + } + friend class ProfileLoader; + friend class Profile; }; // For headsets that use eye cups @@ -187,52 +91,259 @@ enum EyeCupType EyeCup_C = 2 }; -//----------------------------------------------------------------------------- -// ***** RiftDK1Profile - -// This profile is specific to the Rift Dev Kit 1 and contains overrides specific -// to that device and lens cup settings. -class RiftDK1Profile : public HMDProfile -{ +class RiftDevice : public HmdDevice { protected: EyeCupType EyeCups; // Which eye cup does the player use public: - virtual Profile* Clone() const; - EyeCupType GetEyeCup() { return EyeCups; }; void SetEyeCup(EyeCupType cup) { EyeCups = cup; }; protected: - RiftDK1Profile(const char* name); + RiftDevice() { + EyeCups = EyeCup_A; + } + friend class ProfileLoader; + friend class Profile; +}; - virtual bool ParseProperty(const char* prop, const char* sval); +//----------------------------------------------------------------------------- +// ***** RiftDK1Profile - friend class ProfileManager; +// This profile is specific to the Rift Dev Kit 1 and contains overrides specific +// to that device and lens cup settings. +class RiftDK1Device : public RiftDevice +{ +public: + virtual ProfileDeviceType GetDeviceType() const { + return Profile_RiftDK1; + } + +protected: + RiftDK1Device() { + + } + friend class ProfileLoader; + friend class Profile; }; //----------------------------------------------------------------------------- // ***** RiftDKHDProfile -// This profile is specific to the Rift HD Dev Kit and contains overrides specific +// This profile is specific to the Rift HD Dev Kit and contains overrides specific // to that device and lens cup settings. -class RiftDKHDProfile : public HMDProfile +class RiftDKHDDevice : public RiftDevice { +public: + virtual ProfileDeviceType GetDeviceType() const { + return Profile_RiftDKHD; + } + protected: - EyeCupType EyeCups; // Which eye cup does the player use + RiftDKHDDevice() { + } + friend class ProfileLoader; + friend class Profile; +}; +template <class KeyType> +class KeyedObject { public: - virtual Profile* Clone() const; + virtual ~KeyedObject() { + } + virtual const KeyType & GetKey() const = 0; +}; +//------------------------------------------------------------------- +// ***** Profile - EyeCupType GetEyeCup() { return EyeCups; }; - void SetEyeCup(EyeCupType cup) { EyeCups = cup; }; +// The base profile for all users. This object is not created directly. +// +class Profile : public RefCountBase<Profile>, KeyedObject<String> +{ +public: + enum GenderType + { + Gender_Unspecified = 0, + Gender_Male = 1, + Gender_Female = 2 + }; + + String Name; // The name given to this profile protected: - RiftDKHDProfile(const char* name); + GenderType Gender; // The gender of the user + float PlayerHeight; // The height of the user in meters + float IPD; // Distance between eyes in meters + Quatf StrabismusCorrection; // Amount to rotate modelview matrix to correct for corss-eyed vision + // Should be applied as is to the left eye, and inverted to apply to the + // right eye + HmdDevice Generic; + RiftDK1Device RiftDK1; + RiftDKHDDevice RiftDKHD; - virtual bool ParseProperty(const char* prop, const char* sval); +public: + const String & GetKey() const { return Name; }; + // These are properties which are intrinsic to the user and affect scene setup + GenderType GetGender() const { return Gender; }; + float GetPlayerHeight() const { return PlayerHeight; }; + float GetIPD() const { return IPD; }; + float GetEyeHeight() const; + const Quatf & GetStrabismusCorrection() const { return StrabismusCorrection; }; + HmdDevice & GetGenericDevice() { return Generic; } + RiftDK1Device & GetRiftDK1Device() { return RiftDK1; } + RiftDKHDDevice & GetRiftDKHDDevice() { return RiftDKHD; } + const HmdDevice & GetGenericDevice() const { return Generic; } + const RiftDK1Device& GetRiftDK1Device() const { return RiftDK1; } + const RiftDKHDDevice&GetRiftDKHDDevice() const { return RiftDKHD; } + + void SetGender(GenderType gender) { Gender = gender; }; + void SetPlayerHeight(float height) { PlayerHeight = height; }; + void SetIPD(float ipd) { IPD = ipd; }; + void SetStrabismusCorrection(const Quatf & quat) { StrabismusCorrection = quat; }; + Profile * Clone() const { + return new Profile(*this); + } +protected: + Profile(const char* name); friend class ProfileManager; + friend class ProfileLoader; +}; + + +/* + * A really hacky low-performing associative array, because the + * ProfileManager is attempting to mimic the functionality of one + * + * It should have the same performance characteristics as the + * previous ProfileManager embedded implementation. I'm not write a + * full treemap or hashmap implementaiton because, seriously, there are + * plenty out there in the standard libraries, and if OVR doesn't want to + * use them then I'm not going to get roped into building one just to + * support the policy of never using STL. + * + * Using at(KeyType) instead of operator[KeyType] since the latter would + * interfere with ability to access the index based base class operator[] + */ +template <class ValueType, class KeyType> +class AssociativePtrArray : public Array<Ptr<ValueType> > { +public: + enum { + npos = -1 + }; + + int IndexOf(const KeyType & key) const { + for (int i = 0; i< this->GetSize(); ++i) { + const Ptr<ValueType> & data = this->Data.Data[i]; + if (data && data->GetKey() == key) { + return i; + } + } + return -1; + } + + ValueType * at(const KeyType & key) { + int index = IndexOf(key); + if (npos == index) { + return Ptr<ValueType>(); + } + Ptr<ValueType> & ptr = this->Data.Data[index]; + return ptr; + } + + const ValueType * at(const KeyType & key) const { + int index = IndexOf(key); + if (npos == index) { + return Ptr<ValueType>(); + } + const Ptr<ValueType> & ptr = this->Data.Data[index]; + return ptr; + } +}; + +// ----------------------------------------------------------------------------- +// ***** ProfileManager + +// Profiles are interfaced through a ProfileManager object. Applications should +// create a ProfileManager each time they intend to read or write user profile data. +// The scope of the ProfileManager object defines when disk I/O is performed. Disk +// reads are performed on the first profile access and disk writes are performed when +// the ProfileManager goes out of scope. All profile interactions between these times +// are performed in local memory and are fast. A typical profile interaction might +// look like this: +// +// { +// Ptr<ProfileManager> pm = *ProfileManager::Create(); +// Ptr<Profile> profile = pm->LoadProfile(pm->GetDefaultProfileName()); +// if (profile) +// { // Retrieve the current profile settings +// } +// } // Profile will be destroyed and any disk I/O completed when going out of scope + +class ProfileManager : public RefCountBase<ProfileManager> +{ +protected: + // Synchronize ProfileManager access since it may be accessed from multiple threads, + // as it's shared through DeviceManager. + Lock ProfileLock; + typedef AssociativePtrArray<Profile, String> Map; + Map ProfileCache; + String DefaultProfile; + bool Changed; + bool Loaded; + // A container for the name data returned by GetDefaultProfileName() + // which can't be a String, because once acquired by the caller, + // it can't be allowed to be deallocated without risk. Ultimately + // this is caused by the inability to be able to safely return the + // String type from methods, which itself boils down to the problem + // with providing an explicit operator const char *() on a String + // class. Doing so makes it too easy for a caller to get a char * + // to a temporary or have the pointer become deallocated memory + // at some later point unexpectedly. + char NameBuff[32]; + +public: + static ProfileManager* Create(); + + // Static interface functions + unsigned GetProfileCount(); + bool HasProfile(const char* name); + Profile* LoadProfile(const char* name); + Profile* GetDefaultProfile(); + const char* GetDefaultProfileName(); + bool SetDefaultProfileName(const char* name); + + // The previous implementation seemed to imply that if you loaded + // some profiles for a given 'device type' and then saved changes, + // and then loaded a different device type, your changes would be lost + // because the cache would be cleared without ever being persisted to + // disk. The redesign fixes this by eliminating the 'per-device-type' + // profile mechanism. + // + // Profiles represent a users settings and they + // may have different settings for each device, so the profile should + // encapsulate all of them. + // + // Ideally, you should be able to query the top level profile for + // properties related to the hardware based on whatever you're using, + // rather than having to query specifically for generic, DK1 or DKHD + // but the class hierarchy makes that problematic. + bool Save(const Profile * profile); + bool Delete(const Profile * profile); + + // Index based fetching is completely removed. I have no idea what + // was intended to be useful for. Perhaps it was intended as a + // potential optimization since querying by name is O(N) instead of + // O(1), but it's unfathomable that the performance difference would + // ever be noticeable, unless the caller is doing something pathological + // like calling using profile manager every frame, and unlikely even + // then +protected: + ProfileManager(); + ~ProfileManager(); + void LoadCache(); + void SaveCache(); + void ClearCache(); }; @@ -240,4 +351,4 @@ String GetBaseOVRPath(bool create_dir); } -#endif // OVR_Profile_h
\ No newline at end of file +#endif // OVR_Profile_h |