private void OnMappingChanged(ViveRole.IMap map, ViveRole.MappingChangedEventArg args)
{
if (args.roleValue == m_roleValue)
{
m_onDeviceIndexChanged(m_deviceIndex = args.currentDeviceIndex);
}
}
public void SetRole(Type roleType, int roleValue, uint selectedDevice, bool isPointed)
{
m_roleValue = roleValue;
m_map = ViveRole.GetMap(roleType);
m_isPointed = isPointed;
m_selectedDevice = selectedDevice;
m_selectedDeviceSN = VRModule.GetCurrentDeviceState(selectedDevice).serialNumber;
UpdateState();
}
public void RefreshDisplayInfo(ViveRole.IMap roleMap)
{
var roleInfo = roleMap.RoleValueInfo;
var roleValue = roleMap.GetBoundRoleValueByDevice(deviceSN);
var deviceModel = ViveRoleBindingsHelper.GetDeviceModelHint(deviceSN);
m_deviceSN.text = deviceSN;
m_roleName.text = roleInfo.GetNameByRoleValue(roleValue);
BindingInterfaceSpriteManager.SetupDeviceIcon(m_modelIcon, deviceModel, VRModule.IsDeviceConnected(deviceSN));
}
public void SelecRoleSet(ViveRole.IMap roleMap)
{
if (m_roleButtonList.Count == 0)
{
m_roleButtonList.Add(m_roleButtonItem);
m_roleButtonItem.onValueChanged += SelectRole;
}
var roleInfo = roleMap.RoleValueInfo;
// update buttons
if (m_selectedRoleMap != roleMap)
{
m_selectedRoleMap = roleMap;
m_roleButtonList[0].roleValue = roleInfo.InvalidRoleValue;
m_roleButtonList[0].roleName = roleInfo.GetNameByRoleValue(roleInfo.InvalidRoleValue);
var buttonIndex = 1;
for (int roleValue = roleInfo.MinValidRoleValue, max = roleInfo.MaxValidRoleValue; roleValue <= max; ++roleValue)
{
if (!roleInfo.IsValidRoleValue(roleValue))
{
continue;
}
BindingInterfaceRoleButtonItem item;
if (buttonIndex >= m_roleButtonList.Count)
{
var itemObj = Instantiate(m_roleButtonItem.gameObject);
itemObj.transform.SetParent(m_roleButtonItem.transform.parent, false);
m_roleButtonList.Add(item = itemObj.GetComponent <BindingInterfaceRoleButtonItem>());
item.onValueChanged += SelectRole;
}
else
{
item = m_roleButtonList[buttonIndex];
}
item.gameObject.SetActive(true);
item.roleValue = roleValue;
item.roleName = roleInfo.GetNameByRoleValue(roleValue);
++buttonIndex;
}
for (int max = m_roleButtonList.Count; buttonIndex < max; ++buttonIndex)
{
m_roleButtonList[buttonIndex].gameObject.SetActive(false);
}
}
}
// update type and value changes
public void Update()
{
if (m_lockUpdate && (m_isTypeDirty || m_isValueDirty))
{
throw new Exception("Can't change value during onChange event callback");
}
var oldRoleType = m_roleType;
var oldRoleValue = m_roleValue;
var roleTypeChanged = false;
var roleValueChanged = false;
var deviceIndexChanged = false;
if (m_isTypeDirty || m_roleType == null)
{
m_isTypeDirty = false;
if (string.IsNullOrEmpty(m_roleTypeFullName) || !ViveRoleEnum.ValidViveRoleTable.TryGetValue(m_roleTypeFullName, out m_roleType))
{
m_roleType = DefaultRoleType;
}
roleTypeChanged = oldRoleType != m_roleType;
}
// maintain m_roleMap cache
// m_roleMap could be null on first update
if (roleTypeChanged || m_roleMap == null)
{
if (m_onDeviceIndexChanged != null)
{
if (m_roleMap != null)
{
m_roleMap.onRoleValueMappingChanged -= OnMappingChanged;
m_roleMap = ViveRole.GetMap(m_roleType);
m_roleMap.onRoleValueMappingChanged += OnMappingChanged;
}
else
{
m_roleMap = ViveRole.GetMap(m_roleType);
m_deviceIndex = m_roleMap.GetMappedDeviceByRoleValue(m_roleValue); // update deviceIndex before first time listening to MappingChanged event
m_roleMap.onRoleValueMappingChanged += OnMappingChanged;
}
}
else
{
m_roleMap = ViveRole.GetMap(m_roleType);
}
}
if (m_isValueDirty || roleTypeChanged)
{
m_isValueDirty = false;
var info = m_roleMap.RoleValueInfo;
if (string.IsNullOrEmpty(m_roleValueName) || !info.TryGetRoleValueByName(m_roleValueName, out m_roleValue))
{
m_roleValue = info.IsValidRoleValue(m_roleValueInt) ? m_roleValueInt : info.InvalidRoleValue;
}
roleValueChanged = oldRoleValue != m_roleValue;
}
if (roleTypeChanged || roleValueChanged)
{
if (m_onDeviceIndexChanged != null)
{
var oldDeviceIndex = m_deviceIndex;
m_deviceIndex = m_roleMap.GetMappedDeviceByRoleValue(m_roleValue);
if (VRModule.IsValidDeviceIndex(oldDeviceIndex) || VRModule.IsValidDeviceIndex(m_deviceIndex))
{
deviceIndexChanged = oldDeviceIndex != m_deviceIndex;
}
}
m_lockUpdate = true;
if (m_onChanged != null)
{
m_onChanged();
}
if (m_onRoleChanged != null)
{
m_onRoleChanged();
}
if (m_onRoleChangedEx != null)
{
m_onRoleChangedEx(oldRoleType, oldRoleValue);
}
if (deviceIndexChanged)
{
m_onDeviceIndexChanged(m_deviceIndex);
}
m_lockUpdate = false;
}
}
public void Test(ViveRole.IMap roleMap, string deviceSN)
{
}
public RCtrlState(Type roleEnumType, int roleValue)
{
m_map = ViveRole.GetMap(roleEnumType);
m_roleValue = roleValue;
m_roleEnumType = roleEnumType;
}
public void SelecRoleSet(ViveRole.IMap roleMap)
{
m_selectedRoleMap = roleMap;
}
public void UpdateStatus()
{
if (m_isUpdating)
{
return;
}
m_isUpdating = true;
var selectedType = ViveRoleEnum.ValidViveRoleTable.GetValueByIndex(dropdownSelectRole.value);
m_selectedMap = ViveRole.GetMap(selectedType);
var info = m_selectedMap.RoleValueInfo;
// update mapping list
var boundCount = 0;
var mappedCount = 0;
var mappedUnboundCount = 0;
var itemIndex = 0;
for (int roleValue = info.MinValidRoleValue, roleValueMax = info.MaxValidRoleValue; roleValue <= roleValueMax; ++roleValue)
{
if (!info.IsValidRoleValue(roleValue))
{
continue;
}
var isBound = m_selectedMap.IsRoleValueBound(roleValue);
var isMapped = m_selectedMap.IsRoleValueMapped(roleValue);
if (isBound)
{
++boundCount;
}
if (isMapped)
{
++mappedCount;
}
if (isMapped && !isBound)
{
++mappedUnboundCount;
}
Transform itemTrans = null;
if (itemIndex < mappingItemsParent.childCount)
{
// reuse item
itemTrans = mappingItemsParent.GetChild(itemIndex);
}
else
{
// create new item
itemTrans = Instantiate(mappingItemsParent.GetChild(0));
itemTrans.SetParent(mappingItemsParent, false);
}
itemTrans.gameObject.SetActive(true);
var item = itemTrans.GetComponent <MappingItemUIController>();
item.SetRole(selectedType, roleValue, m_scannedDevice, roleValue == pointedReticle.viveRole.roleValue);
++itemIndex;
}
// trim mapping list
while (itemIndex < mappingItemsParent.childCount)
{
mappingItemsParent.GetChild(itemIndex++).gameObject.SetActive(false);
}
// update toggle button
if (VRModule.IsValidDeviceIndex(m_scannedDevice) || (mappedCount == 0 && boundCount == 0))
{
toggleBindAll.gameObject.SetActive(false);
}
else
{
toggleBindAll.gameObject.SetActive(true);
toggleBindAll.isOn = mappedUnboundCount == 0;
}
// update cancel button
btnCancelBind.SetActive(VRModule.IsValidDeviceIndex(m_scannedDevice));
m_isUpdating = false;
}
