private static ICtrlState <TRole> GetState <TRole>(TRole role)
{
Initialize();
var info = ViveRoleEnum.GetInfo <TRole>();
if (!info.IsValidRole(role))
{
return(RGCtrolState <TRole> .s_defaultState);
}
if (RGCtrolState <TRole> .s_roleStates == null)
{
RGCtrolState <TRole> .s_roleStates = new RGCtrolState <TRole> [info.ValidRoleLength];
}
var roleOffset = info.ToRoleOffsetFromRole(role);
if (RGCtrolState <TRole> .s_roleStates[roleOffset] == null)
{
RGCtrolState <TRole> .s_roleStates[roleOffset] = new RGCtrolState <TRole>(role);
s_roleStateTable[typeof(TRole)][roleOffset] = RGCtrolState <TRole> .s_roleStates[roleOffset];
}
return(RGCtrolState <TRole> .s_roleStates[roleOffset]);
}
public static ViveRoleProperty New(string typeFullName, string valueName)
{
var prop = new ViveRoleProperty();
prop.m_roleTypeFullName = typeFullName;
prop.m_roleValueName = valueName;
Type roleType;
if (ViveRoleEnum.ValidViveRoleTable.TryGetValue(typeFullName, out roleType))
{
var roleInfo = ViveRoleEnum.GetInfo(roleType);
var roleIndex = roleInfo.GetElementIndexByName(valueName);
if (roleIndex >= 0)
{
prop.m_roleValueInt = roleInfo.GetRoleValueByElementIndex(roleIndex);
}
else
{
prop.m_roleValueInt = roleInfo.InvalidRoleValue;
}
}
return(prop);
}
public RGCtrolState(TRole role)
{
var info = ViveRoleEnum.GetInfo <TRole>();
m_state = GetState(typeof(TRole), info.ToRoleValue(role));
m_role = role;
}
private static ICtrlState GetState(Type roleType, int roleValue)
{
Initialize();
var info = ViveRoleEnum.GetInfo(roleType);
if (!info.IsValidRoleValue(roleValue))
{
return(s_defaultState);
}
ICtrlState[] stateList;
if (!s_roleStateTable.TryGetValue(roleType, out stateList) || stateList == null)
{
s_roleStateTable[roleType] = stateList = new ICtrlState[info.ValidRoleLength];
}
var roleOffset = info.ToRoleOffset(roleValue);
if (stateList[roleOffset] == null)
{
stateList[roleOffset] = new RCtrlState(roleType, roleValue);
}
return(stateList[roleOffset]);
}
public bool IsRole <TRole>(TRole role)
{
Update();
if (m_roleType != typeof(TRole))
{
return(false);
}
var roleInfo = ViveRoleEnum.GetInfo <TRole>();
return(m_roleValue == roleInfo.ToRoleValue(role));
}
public GenericMap()
{
m_info = ViveRoleEnum.GetInfo <TRole>();
m_map = GetInternalMap(typeof(TRole));
if (s_instance == null)
{
s_instance = this;
}
else
{
UnityEngine.Debug.LogWarning("duplicated instance for RoleInfo<" + typeof(TRole).Name + ">");
}
}
public TRole ToRole <TRole>()
{
Update();
TRole role;
var roleInfo = ViveRoleEnum.GetInfo <TRole>();
if (m_roleType != typeof(TRole) || !roleInfo.TryGetRoleByName(m_roleValueName, out role))
{
// return invalid if role type not match or the value name not found in roleInfo
return(roleInfo.InvalidRole);
}
return(role);
}
public GenericMap()
{
m_info = ViveRoleEnum.GetInfo <TRole>();
m_map = GetInternalMap(typeof(TRole));
if (s_instance == null)
{
s_instance = this;
}
else
{
Debug.LogWarning("duplicated instance for RoleInfo<" + typeof(TRole).Name + ">");
}
m_map.onRoleValueMappingChanged += OnMappingChanged;
}
private static GenericMap <TRole> GetInternalMap <TRole>()
{
var roleEnumType = typeof(TRole);
if (GenericMap <TRole> .s_instance == null)
{
var validateResult = ViveRoleEnum.ValidateViveRoleEnum(roleEnumType);
if (validateResult != ViveRoleEnumValidateResult.Valid)
{
Debug.LogWarning(roleEnumType.Name + " is not valid ViveRole type. " + validateResult);
return(null);
}
new GenericMap <TRole>();
}
return(GenericMap <TRole> .s_instance);
}
public Map(Type roleType)
{
m_info = ViveRoleEnum.GetInfo(roleType);
m_role2index = new uint[m_info.ValidRoleLength];
m_index2role = new int[VRModule.MAX_DEVICE_COUNT];
m_roleBoundDevices = new IndexedSet <uint> [m_info.ValidRoleLength];
m_sn2role = new IndexedTable <string, int>(Mathf.Min(m_info.ValidRoleLength, (int)VRModule.MAX_DEVICE_COUNT));
for (int i = 0; i < m_role2index.Length; ++i)
{
m_role2index[i] = VRModule.INVALID_DEVICE_INDEX;
}
for (int i = 0; i < m_index2role.Length; ++i)
{
m_index2role[i] = m_info.InvalidRoleValue;
}
}
// update type and value if type string or value string is/are dirty
private void Update()
{
if (!m_isTypeDirty && !m_isValueDirty)
{
return;
}
var changed = false;
if (m_isTypeDirty)
{
m_isTypeDirty = false;
Type newType;
if (string.IsNullOrEmpty(m_roleTypeFullName) || !ViveRoleEnum.ValidViveRoleTable.TryGetValue(m_roleTypeFullName, out newType))
{
newType = DefaultRoleType;
}
changed = ChangeProp.Set(ref m_roleType, newType);
}
if (m_isValueDirty || changed)
{
m_isValueDirty = false;
int newValue;
var info = ViveRoleEnum.GetInfo(m_roleType);
if (string.IsNullOrEmpty(m_roleValueName) || !info.TryGetRoleValueByName(m_roleValueName, out newValue))
{
newValue = info.InvalidRoleValue;
}
changed |= ChangeProp.Set(ref m_roleValue, newValue);
}
if (changed && Changed != null)
{
Changed.Invoke();
}
}
public Map(Type roleType)
{
m_info = ViveRoleEnum.GetInfo(roleType);
m_role2index = new uint[m_info.ValidRoleLength];
m_index2role = new int[MAX_DEVICE_COUNT];
m_role2sn = new string[m_info.ValidRoleLength];
m_sn2role = new Dictionary <string, int>(Mathf.Min(m_info.ValidRoleLength, (int)MAX_DEVICE_COUNT));
for (int i = 0; i < m_role2index.Length; ++i)
{
m_role2index[i] = INVALID_DEVICE_INDEX;
m_role2sn[i] = string.Empty;
}
for (int i = 0; i < m_index2role.Length; ++i)
{
m_index2role[i] = m_info.InvalidRoleValue;
}
}
private static Map GetInternalMap(Type roleType)
{
if (s_mapTable == null)
{
s_mapTable = new IndexedTable <Type, Map>();
}
Map map;
if (!s_mapTable.TryGetValue(roleType, out map))
{
var validateResult = ViveRoleEnum.ValidateViveRoleEnum(roleType);
if (validateResult != ViveRoleEnumValidateResult.Valid)
{
Debug.LogWarning(roleType.Name + " is not valid ViveRole type. " + validateResult);
return(null);
}
map = new Map(roleType);
s_mapTable.Add(roleType, map);
}
return(map);
}
public override string ToString()
{
Update();
return(m_roleType.Name + "." + ViveRoleEnum.GetInfo(m_roleType).GetNameByRoleValue(m_roleValue));
}
public void Set(Type type, int value)
{
Set(type.FullName, ViveRoleEnum.GetInfo(type).GetNameByRoleValue(value));
}
// Draw the property inside the given rect
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
// Using BeginProperty / EndProperty on the parent property means that
// prefab override logic works on the entire property.
EditorGUI.BeginProperty(position, label, property);
// Draw label
position = EditorGUI.PrefixLabel(position, GUIUtility.GetControlID(FocusType.Passive), new GUIContent(property.displayName));
// Don't make child fields be indented
var indent = EditorGUI.indentLevel;
EditorGUI.indentLevel = 0;
// Caluculate rects
var spacing = 5.0f;
var rectWidth = Mathf.Round((position.width - spacing) * 0.5f);
var enumTypeRect = new Rect(position.x, position.y, rectWidth, position.height);
var enumValueRect = new Rect(position.x + rectWidth + spacing, position.y, rectWidth, position.height);
var roleTypeNameProp = property.FindPropertyRelative("m_roleTypeFullName");
var roleValueNameProp = property.FindPropertyRelative("m_roleValueName");
var roleValueIntProp = property.FindPropertyRelative("m_roleValueInt");
var roleTypeName = roleTypeNameProp.stringValue;
var roleValueName = roleValueNameProp.stringValue;
// find current role type / type index
Type roleType;
var roleTypeIndex = ViveRoleEnum.ValidViveRoleTable.IndexOf(roleTypeName);
if (roleTypeIndex < 0)
{
// name not found
roleType = s_defaultRoleType;
roleTypeIndex = s_defaultRoleTypeIndex;
}
else
{
roleType = ViveRoleEnum.ValidViveRoleTable.GetValueByIndex(roleTypeIndex);
}
// find current role value index
var roleTypeInfo = ViveRoleEnum.GetInfo(roleType);
var roleValueIndex = roleTypeInfo.GetElementIndexByName(roleValueName);
if (roleValueIndex < 0)
{
roleValueIndex = roleTypeInfo.InvalidRoleValueIndex;
}
// draw pupup box, get new role type index / value index
var newRoleTypeIndex = EditorGUI.Popup(enumTypeRect, roleTypeIndex, s_roleTypeNames);
var newRoleValueIndex = EditorGUI.Popup(enumValueRect, roleValueIndex, EnumUtils.GetDisplayInfo(roleType).displayedNames);
// if new role index changed
if (newRoleTypeIndex != roleTypeIndex || newRoleValueIndex != roleValueIndex)
{
var target = GetTargetObjectOfProperty(property) as ViveRoleProperty;
if (newRoleTypeIndex != roleTypeIndex)
{
roleTypeNameProp.stringValue = ViveRoleEnum.ValidViveRoleTable.GetKeyByIndex(newRoleTypeIndex);
roleType = ViveRoleEnum.ValidViveRoleTable.GetValueByIndex(newRoleTypeIndex);
roleTypeInfo = ViveRoleEnum.GetInfo(roleType);
target.SetTypeDirty();
}
if (newRoleValueIndex != roleValueIndex)
{
roleValueNameProp.stringValue = roleTypeInfo.GetNameByElementIndex(newRoleValueIndex);
roleValueIntProp.intValue = roleTypeInfo.GetRoleValueByElementIndex(newRoleValueIndex);
target.SetValueDirty();
}
}
property.serializedObject.ApplyModifiedProperties(); // will call ViveRoleProperty.OnAfterDeserialize here
// Set indent back to what it was
EditorGUI.indentLevel = indent;
EditorGUI.EndProperty();
}
public static ViveRoleProperty New(Type type, int value)
{
return(New(type.FullName, ViveRoleEnum.GetInfo(type).GetNameByRoleValue(value)));
}
