// Serializes the profiles to disk.
void ProfileManager::SaveCache()
{
String path = GetProfilePath(true);
Lock::Locker lockScope(&ProfileLock);
// TODO: Since there is only a single device type now, a full tree overwrite
// is sufficient but in the future a selective device branch replacement will
// be necessary
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];
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);
if (profile->Type == Profile_RiftDK1)
{
RiftDK1Profile* riftdk1 = (RiftDK1Profile*)profile;
JSON* json_riftdk1 = JSON::CreateObject();
json_profile->AddItem("RiftDK1", json_riftdk1);
const char* eyecup = "A";
switch (riftdk1->EyeCups)
{
case RiftDK1Profile::EyeCup_A: eyecup = "A"; break;
case RiftDK1Profile::EyeCup_B: eyecup = "B"; break;
case RiftDK1Profile::EyeCup_C: eyecup = "C"; break;
}
json_riftdk1->AddStringItem("EyeCup", eyecup);
json_riftdk1->AddNumberItem("LL", riftdk1->LL);
json_riftdk1->AddNumberItem("LR", riftdk1->LR);
json_riftdk1->AddNumberItem("RL", riftdk1->RL);
json_riftdk1->AddNumberItem("RR", riftdk1->RR);
}
root->AddItem("Profile", json_profile);
}
root->Save(path);
}
void SaveProfile(const UserProfile& profile)
{
Ptr<JSON> root = *JSON::CreateObject();
root->AddNumberItem("ipd", profile.Ipd);
root->AddNumberItem("eyeHeight", profile.EyeHeight);
root->AddNumberItem("headModelHeight", profile.HeadModelHeight);
root->AddNumberItem("headModelDepth", profile.HeadModelDepth);
if (root->Save(PROFILE_PATH))
WARN("Failed to save user profile %s", PROFILE_PATH);
}
void GyroTempCalibration::SaveFile()
{
Ptr<JSON> root = *JSON::CreateObject();
root->AddNumberItem("Calibration Version", TEMP_CALIBRATION_FILE_VERSION_2);
String str = GyroCalibrationToString();
root->AddStringItem("Data", str.ToCStr());
String path = GetCalibrationPath(true);
root->Save(path);
}
// Serializes the profiles to disk.
void ProfileManager::SaveCache()
{
String path = GetProfilePath(true);
Lock::Locker lockScope(&ProfileLock);
Ptr<JSON> oldroot = *JSON::Load(path);
if (oldroot)
{
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();
}
}
// 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);
const 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);
}
// Save the profile to disk
root->Save(path);
}
void ProfileManager::LoadV1Profiles(JSON* v1)
{
JSON* item0 = v1->GetFirstItem();
JSON* item1 = v1->GetNextItem(item0);
JSON* item2 = v1->GetNextItem(item1);
// Create the new profile database
Ptr<JSON> root = *JSON::CreateObject();
root->AddNumberItem("Oculus Profile Version", 2.0);
root->AddItem("Users", JSON::CreateArray());
root->AddItem("TaggedData", JSON::CreateArray());
ProfileCache = root;
const char* default_dk1_user = 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
}
// Read the user profile fields
if (CreateUser(profileName, profileName))
{
const char* tag_names[2] = {"User", "Product"};
const char* tags[2];
tags[0] = profileName;
Ptr<Profile> user_profile = *CreateProfile();
user_profile->SetValue(OVR_KEY_NAME, profileName);
float neckeye[2] = { 0, 0 };
item = profileItem->GetNextItem(item);
while (item)
{
if (item->Type != JSON_Object)
{
if (item->Name == OVR_KEY_PLAYER_HEIGHT)
{ // Add an explicit eye height
}
if (item->Name == "NeckEyeHori")
neckeye[0] = (float)item->dValue;
else if (item->Name == "NeckEyeVert")
neckeye[1] = (float)item->dValue;
else
user_profile->SetValue(item);
}
else
{
// Add the user/device tag values
const char* device_name = item->Name.ToCStr();
Ptr<Profile> device_profile = *CreateProfile();
JSON* device_item = item->GetFirstItem();
while (device_item)
{
device_profile->SetValue(device_item);
device_item = item->GetNextItem(device_item);
}
tags[1] = device_name;
SetTaggedProfile(tag_names, tags, 2, device_profile);
}
item = profileItem->GetNextItem(item);
}
// Add an explicit eye-height field
float player_height = user_profile->GetFloatValue(OVR_KEY_PLAYER_HEIGHT,
OVR_DEFAULT_PLAYER_HEIGHT);
if (player_height > 0)
{
char gender[16];
user_profile->GetValue(OVR_KEY_GENDER, gender, 16);
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 (OVR_strcmp(gender, "Female") == 0)
head_height = FEMALE_AVG_HEAD_HEIGHT;
else
head_height = MALE_AVG_HEAD_HEIGHT;
float skull = EYE_TO_HEADTOP_RATIO * head_height;
float eye_height = player_height - skull;
user_profile->SetFloatValue(OVR_KEY_EYE_HEIGHT, eye_height);
}
// Convert NeckEye values to an array
if (neckeye[0] > 0 && neckeye[1] > 0)
user_profile->SetFloatValues(OVR_KEY_NECK_TO_EYE_DISTANCE, neckeye, 2);
// Add the user tag values
SetTaggedProfile(tag_names, tags, 1, user_profile);
}
}
}
// since V1 profiles were only for DK1, the assign the user to all DK1's
const char* tag_names[1] = { "Product" };
const char* tags[1] = { "RiftDK1" };
Ptr<Profile> product_profile = *CreateProfile();
product_profile->SetValue("DefaultUser", default_dk1_user);
SetTaggedProfile(tag_names, tags, 1, product_profile);
}
// Populates 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(bool create)
{
Lock::Locker lockScope(&ProfileLock);
ClearProfileData();
String path = GetProfilePath();
Ptr<JSON> root = *JSON::Load(path);
if (root == NULL)
{
path = BasePath + "/Profiles.json"; // look for legacy profile
root = *JSON::Load(path);
if (root == NULL)
{
if (create)
{ // Generate a skeleton profile database
root = *JSON::CreateObject();
root->AddNumberItem("Oculus Profile Version", 2.0);
root->AddItem("Users", JSON::CreateArray());
root->AddItem("TaggedData", JSON::CreateArray());
ProfileCache = root;
}
return;
}
// Verify the legacy version
JSON* version_item = root->GetFirstItem();
if (version_item->Name == "Oculus Profile Version")
{
int major = atoi(version_item->Value.ToCStr());
if (major != 1)
return; // don't use the file on unsupported major version number
}
else
{
return; // invalid file
}
// Convert the legacy format to the new database format
LoadV1Profiles(root);
}
else
{
// Verify the file format and version
JSON* version_item = root->GetFirstItem();
if (version_item->Name == "Oculus Profile Version")
{
int major = atoi(version_item->Value.ToCStr());
if (major != 2)
return; // don't use the file on unsupported major version number
}
else
{
return; // invalid file
}
ProfileCache = root; // store the database contents for traversal
}
}
