conflict_resolution
stringlengths 27
16k
|
|---|
<<<<<<<
if (m_MenuCanvas != null)
U.Destroy(m_MenuCanvas.gameObject);
=======
U.Object.Destroy(m_MenuCanvas.gameObject);
>>>>>>>
if (m_MenuCanvas != null)
U.Object.Destroy(m_MenuCanvas.gameObject);
<<<<<<<
var newButton = U.InstantiateAndSetActive(m_ButtonTemplate, m_Layout, false);
newButton.name = menuTool.Name;
=======
var newButton = U.Object.InstantiateAndSetActive(m_ButtonTemplate, m_Layout, false);
>>>>>>>
var newButton = U.Object.InstantiateAndSetActive(m_ButtonTemplate, m_Layout, false);
newButton.name = menuTool.Name;
<<<<<<<
AddButtonListener(button, menuTool);
=======
button.onClick.AddListener(() =>
{
if (SelectTool(this, menuTool))
U.Object.Destroy(this);
});
>>>>>>>
AddButtonListener(button, menuTool); |
<<<<<<<
public Action<GameObject, bool> setLocked { private get; set; }
public Func<GameObject, bool> isLocked { private get; set; }
=======
readonly List<IFilterUI> m_FilterUIs = new List<IFilterUI>();
readonly HashSet<string> m_ObjectTypes = new HashSet<string>();
>>>>>>>
readonly List<IFilterUI> m_FilterUIs = new List<IFilterUI>();
readonly HashSet<string> m_ObjectTypes = new HashSet<string>();
public Action<GameObject, bool> setLocked { private get; set; }
public Func<GameObject, bool> isLocked { private get; set; }
<<<<<<<
List<HierarchyData> children = null;
if (list.Count > 0)
children = list;
var hdGO = EditorUtility.InstanceIDToObject(instanceID) as GameObject;
var locked = isLocked != null && isLocked(hdGO);
=======
>>>>>>>
var hdGO = EditorUtility.InstanceIDToObject(instanceID) as GameObject;
var locked = isLocked != null && isLocked(hdGO); |
<<<<<<<
class EditorXRToolModule : MonoBehaviour, IModuleDependency<EditorVR>, IModuleDependency<LockModule>,
IModuleDependency<EditorXRMenuModule>, IModuleDependency<DeviceInputModule>,
IModuleDependency<EditorXRRayModule>, IInterfaceConnector, IUsesConnectInterfaces, IInitializableModule,
IUsesFunctionalityInjection, IProvidesSelectTool
=======
class EditorXRToolModule : MonoBehaviour, IModuleDependency<EditorXRVacuumableModule>, IModuleDependency<LockModule>,
IModuleDependency<EditorXRMenuModule>, IModuleDependency<DeviceInputModule>, IModuleDependency<EditorXRRayModule>,
IInterfaceConnector, IConnectInterfaces, IInitializableModule
>>>>>>>
class EditorXRToolModule : MonoBehaviour, IModuleDependency<LockModule>,
IModuleDependency<EditorXRMenuModule>, IModuleDependency<DeviceInputModule>,
IModuleDependency<EditorXRRayModule>, IInterfaceConnector, IUsesConnectInterfaces, IInitializableModule,
IUsesFunctionalityInjection, IProvidesSelectTool
<<<<<<<
EditorVR m_EditorVR;
=======
EditorXRVacuumableModule m_VacuumablesModule;
>>>>>>>
<<<<<<<
public void ConnectDependency(EditorVR dependency)
{
m_EditorVR = dependency;
}
=======
public void ConnectDependency(EditorXRVacuumableModule dependency)
{
m_VacuumablesModule = dependency;
}
>>>>>>>
<<<<<<<
m_MenuModule.mainMenuTools = allTools.Where(t =>
{
return !IsDefaultTool(t) && !EditorVR.HiddenTypes.Contains(t);
}).ToList(); // Don't show tools that can't be selected/toggled
=======
deviceData.Clear();
>>>>>>>
deviceData.Clear();
m_MenuModule.mainMenuTools = allTools.Where(t =>
{
return !IsDefaultTool(t) && !EditorVR.HiddenTypes.Contains(t);
}).ToList(); // Don't show tools that can't be selected/toggled
<<<<<<<
this.InjectFunctionalitySingle(toolsMenu);
deviceData.toolsMenu = toolsMenu;
=======
device.toolsMenu = toolsMenu;
>>>>>>>
this.InjectFunctionalitySingle(toolsMenu);
device.toolsMenu = toolsMenu; |
<<<<<<<
// HACK to workaround missing MonoScript serialized fields
EditorApplication.delayCall += () =>
{
mainMenu = SpawnMainMenu(typeof(MainMenu), device, false);
mainMenu.menuVisibilityChanged += OnMainMenuVisiblityChanged;
deviceData.mainMenu = mainMenu;
UpdatePlayerHandleMaps();
};
=======
mainMenu = SpawnMainMenu(typeof(MainMenu), device, true);
deviceData.mainMenu = mainMenu;
UpdatePlayerHandleMaps();
while (mainMenu == null)
yield return null;
menus.Add(mainMenu);
>>>>>>>
mainMenu = SpawnMainMenu(typeof(MainMenu), device, false);
deviceData.mainMenu = mainMenu;
UpdatePlayerHandleMaps();
<<<<<<<
Workspace workspace = (Workspace)U.Object.CreateGameObjectWithComponent(t, viewerPivot);
m_AllWorkspaces.Add(workspace);
workspace.destroyed += OnWorkspaceDestroyed;
workspace.isMiniWorldRay = IsMiniWorldRay;
ConnectInterfaces(workspace);
workspace.transform.position = position;
workspace.transform.rotation = rotation;
=======
Workspace workspace = (Workspace)U.Object.CreateGameObjectWithComponent(t, viewerPivot);
m_AllWorkspaces.Add(workspace);
workspace.destroyed += OnWorkspaceDestroyed;
ConnectInterfaces(workspace);
workspace.transform.position = position;
workspace.transform.rotation = rotation;
>>>>>>>
Workspace workspace = (Workspace)U.Object.CreateGameObjectWithComponent(t, viewerPivot);
m_AllWorkspaces.Add(workspace);
workspace.destroyed += OnWorkspaceDestroyed;
workspace.isMiniWorldRay = IsMiniWorldRay;
ConnectInterfaces(workspace);
workspace.transform.position = position;
workspace.transform.rotation = rotation;
<<<<<<<
if (createdCallback != null)
createdCallback(workspace);
var miniWorld = workspace as IMiniWorld;
if (miniWorld == null)
return;
=======
var miniWorld = workspace as IMiniWorld;
if (miniWorld == null)
return;
>>>>>>>
if (createdCallback != null)
createdCallback(workspace);
var miniWorld = workspace as IMiniWorld;
if (miniWorld == null)
return; |
<<<<<<<
using System;
using UnityEngine;
=======
using System;
>>>>>>>
using System;
<<<<<<<
public Node selfNode { get; set; }
public ActionMapInput actionMapInput { get { return m_TransformInput; } set { m_TransformInput = (TransformInput) value; } }
private TransformInput m_TransformInput;
=======
readonly Dictionary<Node, GrabData> m_GrabData = new Dictionary<Node, GrabData>();
bool m_DirectSelected;
float m_ScaleStartDistance;
Node m_ScaleFirstNode;
float m_ScaleFactor;
bool m_WasScaling;
TransformInput m_TransformInput;
public ActionMap actionMap { get { return m_TransformActionMap; } }
public ActionMapInput actionMapInput { get { return m_TransformInput; } set { m_TransformInput = (TransformInput)value; } }
public Func<Dictionary<Transform, DirectSelection>> getDirectSelection { private get; set; }
public Func<DirectSelection, Transform, bool> canGrabObject { private get; set; }
public Func<IGrabObjects, DirectSelection, Transform, bool> grabObject { private get; set; }
public Action<IGrabObjects, Transform, Transform> dropObject { private get; set; }
>>>>>>>
readonly Dictionary<Node, GrabData> m_GrabData = new Dictionary<Node, GrabData>();
bool m_DirectSelected;
float m_ScaleStartDistance;
Node m_ScaleFirstNode;
float m_ScaleFactor;
bool m_WasScaling;
TransformInput m_TransformInput;
public ActionMap actionMap { get { return m_TransformActionMap; } }
public ActionMapInput actionMapInput { get { return m_TransformInput; } set { m_TransformInput = (TransformInput)value; } }
public Func<Dictionary<Transform, DirectSelection>> getDirectSelection { private get; set; }
public Func<DirectSelection, Transform, bool> canGrabObject { private get; set; }
public Func<IGrabObjects, DirectSelection, Transform, bool> grabObject { private get; set; }
public Action<IGrabObjects, Transform, Transform> dropObject { private get; set; }
public Node selfNode { get; set; }
<<<<<<<
if (m_Mode == TransformMode.Direct)
return false;
=======
>>>>>>>
<<<<<<<
if (m_Mode == TransformMode.Direct)
return false;
=======
>>>>>>> |
<<<<<<<
m_WorkspaceUI.highlightsVisible = true;
=======
if (isMiniWorldRay(eventData.rayOrigin))
return;
>>>>>>>
if (isMiniWorldRay(eventData.rayOrigin))
return;
m_WorkspaceUI.highlightsVisible = true;
<<<<<<<
m_WorkspaceUI.highlightsVisible = false;
=======
if (isMiniWorldRay(eventData.rayOrigin))
return;
>>>>>>>
if (isMiniWorldRay(eventData.rayOrigin))
return;
m_WorkspaceUI.highlightsVisible = false; |
<<<<<<<
const float k_BLockSelectDragThreshold = 0.01f;
static readonly Vector3 k_TooltipPosition = new Vector3(0, 0.05f, -0.03f);
=======
static readonly Vector3 k_TooltipPosition = new Vector3(0, -0.15f, -0.13f);
>>>>>>>
static readonly Vector3 k_TooltipPosition = new Vector3(0, -0.15f, -0.13f);
const float k_BLockSelectDragThreshold = 0.01f; |
<<<<<<<
using UnityEngine.UI;
using UnityEngine.VR.Helpers;
using UnityEngine.VR;
=======
>>>>>>>
using UnityEngine.VR.Helpers; |
<<<<<<<
#if !FI_AUTOFILL
IProvidesFunctionalityInjection IFunctionalitySubscriber<IProvidesFunctionalityInjection>.provider { get; set; }
IProvidesConnectInterfaces IFunctionalitySubscriber<IProvidesConnectInterfaces>.provider { get; set; }
#endif
=======
public int connectInterfaceOrder { get { return 0; } }
>>>>>>>
public int connectInterfaceOrder { get { return 0; } }
#if !FI_AUTOFILL
IProvidesFunctionalityInjection IFunctionalitySubscriber<IProvidesFunctionalityInjection>.provider { get; set; }
IProvidesConnectInterfaces IFunctionalitySubscriber<IProvidesConnectInterfaces>.provider { get; set; }
#endif |
<<<<<<<
if (s_ActiveView != null)
=======
if (s_ActiveView)
{
if (!s_ActiveView.m_CustomPreviewCamera && EditingContextManager.defaultContext.copyMainCameraImageEffectsToPresentationCamera)
CopyImagesEffectsToCamera(value);
>>>>>>>
if (s_ActiveView != null)
{
if (!s_ActiveView.m_CustomPreviewCamera && EditingContextManager.defaultContext.copyMainCameraImageEffectsToPresentationCamera)
CopyImagesEffectsToCamera(value);
<<<<<<<
GameObject rigGO = null;
if (Application.isPlaying)
{
camera.nearClipPlane = nearClipPlane;
camera.farClipPlane = farClipPlane;
rigGO = new GameObject("VRCameraRig");
}
#if UNITY_EDITOR
else
=======
s_ExistingSceneMainCamera = Camera.main;
// TODO: Copy camera settings when changing contexts
var defaultContext = EditingContextManager.defaultContext;
if (defaultContext.copyMainCameraSettings && s_ExistingSceneMainCamera && s_ExistingSceneMainCamera.enabled)
>>>>>>>
GameObject rigGO = null;
if (Application.isPlaying)
{
camera.nearClipPlane = nearClipPlane;
camera.farClipPlane = farClipPlane;
rigGO = new GameObject("VRCameraRig");
}
#if UNITY_EDITOR
else |
<<<<<<<
private LayerMask? m_LayerMask;
private RenderTexture m_SceneTargetTexture;
private bool m_ShowDeviceView;
private bool m_SceneViewsEnabled;
private static VRView s_ActiveView;
private Transform m_CameraPivot;
private Quaternion m_LastHeadRotation = Quaternion.identity;
private float m_TimeSinceLastHMDChange;
private bool m_LatchHMDValues;
bool m_HMDReady;
bool m_VRInitialized;
=======
private RenderTexture m_SceneTargetTexture;
private bool m_ShowDeviceView;
private bool m_SceneViewsEnabled;
private static VRView s_ActiveView;
private Transform m_CameraPivot;
private Quaternion m_LastHeadRotation = Quaternion.identity;
private float m_TimeSinceLastHMDChange;
private bool m_LatchHMDValues;
bool m_HMDReady;
bool m_VRInitialized;
>>>>>>>
private LayerMask? m_LayerMask;
private RenderTexture m_SceneTargetTexture;
private bool m_ShowDeviceView;
private bool m_SceneViewsEnabled;
private static VRView s_ActiveView;
private Transform m_CameraPivot;
private Quaternion m_LastHeadRotation = Quaternion.identity;
private float m_TimeSinceLastHMDChange;
private bool m_LatchHMDValues;
bool m_HMDReady;
bool m_VRInitialized;
<<<<<<<
public static Coroutine StartCoroutine(IEnumerator routine)
{
if (s_ActiveView && s_ActiveView.m_CameraPivot)
{
EditorMonoBehaviour mb = s_ActiveView.m_CameraPivot.GetComponent<EditorMonoBehaviour>();
return mb.StartCoroutine(routine);
}
=======
public static Coroutine StartCoroutine(IEnumerator routine)
{
if (s_ActiveView && s_ActiveView.m_CameraPivot)
{
var mb = s_ActiveView.m_CameraPivot.GetComponent<EditorMonoBehaviour>();
return mb.StartCoroutine(routine);
}
>>>>>>>
public static Coroutine StartCoroutine(IEnumerator routine)
{
if (s_ActiveView && s_ActiveView.m_CameraPivot)
{
var mb = s_ActiveView.m_CameraPivot.GetComponent<EditorMonoBehaviour>();
return mb.StartCoroutine(routine);
}
<<<<<<<
var hdr = false; // SceneViewIsRenderingHDR();
CreateCameraTargetTexture(ref m_SceneTargetTexture, cameraRect, hdr);
=======
CreateCameraTargetTexture(cameraRect, false);
>>>>>>>
CreateCameraTargetTexture(ref m_SceneTargetTexture, cameraRect, false); |
<<<<<<<
=======
property = property.ToLower();
>>>>>>>
property = property.ToLower();
<<<<<<<
return AccessIndex(list, 0).value;
}
=======
return AccessIndex(list, 0).value;
}
>>>>>>>
return AccessIndex(list, 0).value;
}
<<<<<<<
new ExpressionEvaluator(ExpressionType.Json, Apply(args => JToken.Parse(args[0])), ReturnType.String, (expr) => ValidateOrder(expr, null, ReturnType.String)),
new ExpressionEvaluator(ExpressionType.AddProperty, Apply(args => { var newJobj = (JObject)args[0]; newJobj[args[1].ToString()] = args[2]; return newJobj; }),
ReturnType.Object, (expr) => ValidateOrder(expr, null, ReturnType.Object, ReturnType.String, ReturnType.Object)),
new ExpressionEvaluator(ExpressionType.SetProperty, Apply(args => { var newJobj = (JObject)args[0]; newJobj[args[1].ToString()] = args[2]; return newJobj; }),
ReturnType.Object, (expr) => ValidateOrder(expr, null, ReturnType.Object, ReturnType.String, ReturnType.Object)),
new ExpressionEvaluator(ExpressionType.RemoveProperty, Apply(args => { var newJobj = (JObject)args[0]; newJobj.Property(args[1].ToString()).Remove(); return newJobj; }),
ReturnType.Object, (expr) => ValidateOrder(expr, null, ReturnType.Object, ReturnType.String)),
new ExpressionEvaluator(ExpressionType.Foreach, Foreach, ReturnType.Object, ValidateForeach),
=======
// TODO
{ ExpressionType.Json,
new ExpressionEvaluator(Apply(args => JToken.Parse(args[0])), ReturnType.String, (expr) => ValidateOrder(expr, null, ReturnType.String)) },
{ ExpressionType.AddProperty,
new ExpressionEvaluator(Apply(args => {var newJobj = (JObject)args[0]; newJobj[args[1].ToString()] = args[2];return newJobj; }),
ReturnType.Object, (expr) => ValidateOrder(expr, null, ReturnType.Object, ReturnType.String, ReturnType.Object)) },
{ ExpressionType.SetProperty,
new ExpressionEvaluator(Apply(args => {var newJobj = (JObject)args[0]; newJobj[args[1].ToString()] = args[2];return newJobj; }),
ReturnType.Object, (expr) => ValidateOrder(expr, null, ReturnType.Object, ReturnType.String, ReturnType.Object)) },
{ ExpressionType.RemoveProperty,
new ExpressionEvaluator(Apply(args => {var newJobj = (JObject)args[0]; newJobj.Property(args[1].ToString()).Remove();return newJobj; }),
ReturnType.Object, (expr) => ValidateOrder(expr, null, ReturnType.Object, ReturnType.String)) },
{ ExpressionType.Foreach, new ExpressionEvaluator(Foreach, ReturnType.Object, ValidateForeach)},
>>>>>>>
new ExpressionEvaluator(ExpressionType.Json, Apply(args => JToken.Parse(args[0])), ReturnType.String, (expr) => ValidateOrder(expr, null, ReturnType.String)),
new ExpressionEvaluator(ExpressionType.AddProperty, Apply(args => { var newJobj = (JObject)args[0]; newJobj[args[1].ToString()] = args[2]; return newJobj; }),
ReturnType.Object, (expr) => ValidateOrder(expr, null, ReturnType.Object, ReturnType.String, ReturnType.Object)),
new ExpressionEvaluator(ExpressionType.SetProperty, Apply(args => { var newJobj = (JObject)args[0]; newJobj[args[1].ToString()] = args[2]; return newJobj; }),
ReturnType.Object, (expr) => ValidateOrder(expr, null, ReturnType.Object, ReturnType.String, ReturnType.Object)),
new ExpressionEvaluator(ExpressionType.RemoveProperty, Apply(args => { var newJobj = (JObject)args[0]; newJobj.Property(args[1].ToString()).Remove(); return newJobj; }),
ReturnType.Object, (expr) => ValidateOrder(expr, null, ReturnType.Object, ReturnType.String)),
new ExpressionEvaluator(ExpressionType.Foreach, Foreach, ReturnType.Object, ValidateForeach), |
<<<<<<<
=======
#endif
>>>>>>> |
<<<<<<<
class EditorXRMiniWorldModule : IModuleDependency<EditorVR>, IModuleDependency<EditorXRDirectSelectionModule>,
IModuleDependency<SpatialHashModule>, IModuleDependency<HighlightModule>, IModuleDependency<IntersectionModule>,
IModuleDependency<WorkspaceModule>, IModuleDependency<EditorXRRayModule>, IUsesPlaceSceneObjects, IUsesViewerScale,
IUsesSpatialHash, IUsesRayVisibilitySettings, IProvidesIsInMiniWorld
=======
class EditorXRMiniWorldModule : IModuleDependency<EditorXRToolModule>, IModuleDependency<EditorXRDirectSelectionModule>,
IModuleDependency<EditorXRRayModule>, IModuleDependency<SpatialHashModule>, IModuleDependency<HighlightModule>,
IModuleDependency<IntersectionModule>, IModuleDependency<WorkspaceModule>, IPlaceSceneObjects, IUsesViewerScale, IUsesSpatialHash
>>>>>>>
class EditorXRMiniWorldModule : IModuleDependency<EditorXRToolModule>, IModuleDependency<EditorXRDirectSelectionModule>,
IModuleDependency<SpatialHashModule>, IModuleDependency<HighlightModule>, IModuleDependency<IntersectionModule>,
IModuleDependency<WorkspaceModule>, IModuleDependency<EditorXRRayModule>, IUsesPlaceSceneObjects, IUsesViewerScale,
IUsesSpatialHash, IUsesRayVisibilitySettings, IProvidesIsInMiniWorld |
<<<<<<<
Actions = new List<IDialog>()
{
new SetProperty() { Property = "dialog.name", Value = "'testDialog'" },
new SendActivity("{dialog.name}"),
new AdaptiveDialog("d1")
{
InputBindings = new Dictionary<string, string>() { { "dialog.name", "$name" } },
Events = new List<IOnEvent>()
{
new OnBeginDialog()
{
Actions = new List<IDialog>()
{
new SendActivity("nested d1 {$name}"),
new SetProperty() { Property = "dialog.name", Value = "'testDialogd1'" },
new SendActivity("nested d1 {$name}"),
}
}
}
},
new BeginDialog()
{
// bind dialog.name -> adaptive dialog
Dialog = new AdaptiveDialog("d2")
{
InputBindings = new Dictionary<string, string>() { { "dialog.name", "$name" } },
Events = new List<IOnEvent>()
{
new OnBeginDialog()
{
Actions = new List<IDialog>()
{
new SendActivity("nested d2 {$name}"),
new SetProperty() { Property = "dialog.name", Value = "'testDialogd2'" },
new SendActivity("nested d2 {$name}"),
}
}
}
}
}
}
}
=======
// bind dialog.name -> adaptive dialog
DialogId = d2.Id
},
>>>>>>>
Actions = new List<IDialog>()
{
new SetProperty() { Property = "dialog.name", Value = "'testDialog'" },
new SendActivity("{dialog.name}"),
new AdaptiveDialog("d1")
{
InputBindings = new Dictionary<string, string>() { { "dialog.name", "$name" } },
Events = new List<IOnEvent>()
{
new OnBeginDialog()
{
Actions = new List<IDialog>()
{
new SendActivity("nested d1 {$name}"),
new SetProperty() { Property = "dialog.name", Value = "'testDialogd1'" },
new SendActivity("nested d1 {$name}"),
}
}
}
},
new BeginDialog(d2.Id)
}
}
}
};
testDialog.AddDialog(d2);
await CreateFlow(testDialog)
.SendConversationUpdate()
.AssertReply("testDialog")
.AssertReply("nested d1 testDialog")
.AssertReply("nested d1 testDialogd1")
.AssertReply("nested d2 testDialog")
.AssertReply("nested d2 testDialogd2")
.StartTestAsync();
}
[TestMethod]
public async Task DialogContextState_OutputBinding()
{
var d2 = new AdaptiveDialog("d2")
{
InputBindings = new Dictionary<string, string>() { { "$zzz", "dialog.name" } },
DefaultResultProperty = "$zzz",
// test output binding from adaptive dialog
OutputBinding = "dialog.name",
Events = new List<IOnEvent>()
{
new OnBeginDialog()
{
Actions = new List<IDialog>()
{
new SendActivity("nested begindialog {$zzz}"),
new SetProperty() { Property = "dialog.zzz", Value = "'newName2'" },
new SendActivity("nested begindialog {$zzz}"),
}
}
}
};
var d3 = new AdaptiveDialog("d3")
{
InputBindings = new Dictionary<string, string>() { { "$qqq", "dialog.name" } },
DefaultResultProperty = "$qqq",
Events = new List<IOnEvent>()
{
new OnBeginDialog()
{
Actions = new List<IDialog>()
{
new SendActivity("nested begindialog2 {$qqq}"),
new SetProperty() { Property = "dialog.qqq", Value = "'newName3'" },
new SendActivity("nested begindialog2 {$qqq}"),
}
}
}
};
var testDialog = new AdaptiveDialog("testDialog")
{
AutoEndDialog = false,
Events = new List<IOnEvent>()
{
new OnBeginDialog()
{
Actions = new List<IDialog>()
{
new SetProperty() { Property = "dialog.name", Value = "'testDialog'" },
new SendActivity("{dialog.name}"),
new AdaptiveDialog("d1")
{
InputBindings = new Dictionary<string, string>() { { "$xxx", "dialog.name" } },
OutputBinding = "dialog.name",
DefaultResultProperty = "$xxx",
Events = new List<IOnEvent>()
{
new OnBeginDialog()
{
Actions = new List<IDialog>()
{
new SendActivity("nested dialogCommand {$xxx}"),
new SetProperty() { Property = "dialog.xxx", Value = "'newName'" },
new SendActivity("nested dialogCommand {$xxx}"),
}
}
}
},
new SendActivity("{dialog.name}"),
new BeginDialog(d2.Id),
new SendActivity("{dialog.name}"),
new BeginDialog(d3.Id)
{
// test output binding from beginDialog
OutputBinding = "dialog.name"
},
new SendActivity("{dialog.name}"),
}
}
<<<<<<<
new OnBeginDialog()
{
Actions = new List<IDialog>()
{
new SetProperty() { Property = "dialog.name", Value = "'testDialog'" },
new SendActivity("{dialog.name}"),
new AdaptiveDialog("d1")
{
InputBindings = new Dictionary<string, string>() { { "$xxx", "dialog.name" } },
OutputBinding = "dialog.name",
DefaultResultProperty = "$xxx",
Events = new List<IOnEvent>()
{
new OnBeginDialog()
{
Actions = new List<IDialog>()
{
new SendActivity("nested dialogCommand {$xxx}"),
new SetProperty() { Property = "dialog.xxx", Value = "'newName'" },
new SendActivity("nested dialogCommand {$xxx}"),
}
}
}
},
new SendActivity("{dialog.name}"),
new BeginDialog()
{
Dialog = new AdaptiveDialog("d2")
{
InputBindings = new Dictionary<string, string>() { { "$zzz", "dialog.name" } },
DefaultResultProperty = "$zzz",
// test output binding from adaptive dialog
OutputBinding = "dialog.name",
Events = new List<IOnEvent>()
{
new OnBeginDialog()
{
Actions = new List<IDialog>()
{
new SendActivity("nested begindialog {$zzz}"),
new SetProperty() { Property = "dialog.zzz", Value = "'newName2'" },
new SendActivity("nested begindialog {$zzz}"),
}
}
}
}
},
new SendActivity("{dialog.name}"),
new BeginDialog()
{
// test output binding from beginDialog
OutputBinding = "dialog.name",
Dialog = new AdaptiveDialog("d3")
{
InputBindings = new Dictionary<string, string>() { { "$qqq", "dialog.name" } },
DefaultResultProperty = "$qqq",
Events = new List<IOnEvent>()
{
new OnBeginDialog()
{
Actions = new List<IDialog>()
{
new SendActivity("nested begindialog2 {$qqq}"),
new SetProperty() { Property = "dialog.qqq", Value = "'newName3'" },
new SendActivity("nested begindialog2 {$qqq}"),
}
}
}
}
},
new SendActivity("{dialog.name}"),
}
}
=======
new SetProperty() { Property = "dialog.name", Value = "'testDialog'" },
new SendActivity("{dialog.name}"),
new AdaptiveDialog("d1")
{
InputBindings = new Dictionary<string, string>() { { "$xxx", "dialog.name" } },
OutputBinding = "dialog.name",
DefaultResultProperty = "$xxx",
Steps = new List<IDialog>()
{
new SendActivity("nested dialogCommand {$xxx}"),
new SetProperty() { Property = "dialog.xxx", Value = "'newName'" },
new SendActivity("nested dialogCommand {$xxx}"),
}
},
new SendActivity("{dialog.name}"),
new BeginDialog(d2.Id),
new SendActivity("{dialog.name}"),
new BeginDialog(d3.Id)
{
// test output binding from beginDialog
OutputBinding = "dialog.name"
},
new SendActivity("{dialog.name}"),
>>>>>>>
new OnBeginDialog()
{
Actions = new List<IDialog>()
{
new SetProperty() { Property = "dialog.name", Value = "'testDialog'" },
new SendActivity("{dialog.name}"),
new AdaptiveDialog("d1")
{
InputBindings = new Dictionary<string, string>() { { "$xxx", "dialog.name" } },
OutputBinding = "dialog.name",
DefaultResultProperty = "$xxx",
Events = new List<IOnEvent>()
{
new OnBeginDialog()
{
Actions = new List<IDialog>()
{
new SendActivity("nested dialogCommand {$xxx}"),
new SetProperty() { Property = "dialog.xxx", Value = "'newName'" },
new SendActivity("nested dialogCommand {$xxx}"),
}
}
}
},
new SendActivity("{dialog.name}"),
new BeginDialog(d2.Id),
new SendActivity("{dialog.name}"),
new BeginDialog(d3.Id)
{
// test output binding from beginDialog
OutputBinding = "dialog.name"
},
new SendActivity("{dialog.name}"),
}
} |
<<<<<<<
class EditorXRDirectSelectionModule : IModuleDependency<EditorVR>, IModuleDependency<EditorXRRayModule>,
IModuleDependency<SceneObjectModule>, IModuleDependency<IntersectionModule>, IInitializableModule,
IInterfaceConnector, IModuleBehaviorCallbacks, IProvidesDirectSelection, IProvidesCanGrabObject, IUsesViewerBody
=======
class EditorXRDirectSelectionModule : IModuleDependency<EditorXRMiniWorldModule>, IModuleDependency<EditorXRRayModule>,
IModuleDependency<SceneObjectModule>, IModuleDependency<IntersectionModule>, IModuleDependency<EditorXRViewerModule>,
IModuleDependency<EditorXRToolModule>, IInitializableModule, IInterfaceConnector, IModuleBehaviorCallbacks
>>>>>>>
class EditorXRDirectSelectionModule : IModuleDependency<EditorXRRayModule>, IModuleDependency<EditorXRToolModule>,
IModuleDependency<SceneObjectModule>, IModuleDependency<IntersectionModule>, IInitializableModule,
IInterfaceConnector, IModuleBehaviorCallbacks, IProvidesDirectSelection, IProvidesCanGrabObject, IUsesViewerBody
<<<<<<<
event Action resetDirectSelectionState;
IProvidesViewerBody IFunctionalitySubscriber<IProvidesViewerBody>.provider { get; set; }
public void ConnectDependency(EditorVR dependency)
=======
public void ConnectDependency(EditorXRToolModule dependency)
>>>>>>>
event Action resetDirectSelectionState;
IProvidesViewerBody IFunctionalitySubscriber<IProvidesViewerBody>.provider { get; set; }
public void ConnectDependency(EditorXRToolModule dependency) |
<<<<<<<
var rayTransform = U.Object.Instantiate(m_ProxyRayPrefab.gameObject, rayOriginBase.Value).transform;
rayTransform.position = rayOriginBase.Value.position;
rayTransform.rotation = rayOriginBase.Value.rotation;
m_DefaultRays.Add(rayOriginBase.Value, rayTransform.GetComponent<DefaultProxyRay>());
var malletTransform = U.Object.Instantiate(m_KeyboardMalletPrefab.gameObject, rayOriginBase.Value).transform;
malletTransform.position = rayOriginBase.Value.position;
malletTransform.rotation = rayOriginBase.Value.rotation;
m_KeyboardMallets.Add(rayOriginBase.Value, malletTransform.GetComponent<KeyboardMallet>());
=======
var rayTransform = U.Object.Instantiate(m_ProxyRayPrefab.gameObject, rayOriginPair.Value).transform;
rayTransform.position = rayOriginPair.Value.position;
rayTransform.rotation = rayOriginPair.Value.rotation;
m_DefaultRays.Add(rayOriginPair.Value, rayTransform.GetComponent<DefaultProxyRay>());
>>>>>>>
var rayTransform = U.Object.Instantiate(m_ProxyRayPrefab.gameObject, rayOriginPair.Value).transform;
rayTransform.position = rayOriginPair.Value.position;
rayTransform.rotation = rayOriginPair.Value.rotation;
m_DefaultRays.Add(rayOriginPair.Value, rayTransform.GetComponent<DefaultProxyRay>());
var malletTransform = U.Object.Instantiate(m_KeyboardMalletPrefab.gameObject, rayOriginBase.Value).transform;
malletTransform.position = rayOriginBase.Value.position;
malletTransform.rotation = rayOriginBase.Value.rotation;
m_KeyboardMallets.Add(rayOriginBase.Value, malletTransform.GetComponent<KeyboardMallet>()); |
<<<<<<<
foreach (NumericInputField inputField in go.GetComponentsInChildren<NumericInputField>())
{
if (inputField.contentType == SerializedPropertyType.Float || inputField.contentType == SerializedPropertyType.Integer)
inputField.keyboard = SpawnNumericKeyboard;
else
inputField.keyboard = SpawnAlphaNumericKeyboard;
=======
foreach (RayInputField inputField in canvas.GetComponentsInChildren<RayInputField>())
{
if (inputField is NumericInputField)
inputField.spawnKeyboard = SpawnNumericKeyboard;
else if (inputField is StandardInputField)
inputField.spawnKeyboard = SpawnAlphaNumericKeyboard;
}
>>>>>>>
foreach (RayInputField inputField in canvas.GetComponentsInChildren<RayInputField>())
{
if (inputField is NumericInputField)
inputField.spawnKeyboard = SpawnNumericKeyboard;
else if (inputField is StandardInputField)
inputField.spawnKeyboard = SpawnAlphaNumericKeyboard; |
<<<<<<<
#if !FI_AUTOFILL
IProvidesFunctionalityInjection IFunctionalitySubscriber<IProvidesFunctionalityInjection>.provider { get; set; }
IProvidesConnectInterfaces IFunctionalitySubscriber<IProvidesConnectInterfaces>.provider { get; set; }
#endif
=======
public int connectInterfaceOrder { get { return 0; } }
>>>>>>>
public int connectInterfaceOrder { get { return 0; } }
#if !FI_AUTOFILL
IProvidesFunctionalityInjection IFunctionalitySubscriber<IProvidesFunctionalityInjection>.provider { get; set; }
IProvidesConnectInterfaces IFunctionalitySubscriber<IProvidesConnectInterfaces>.provider { get; set; }
#endif |
<<<<<<<
if (isMiniWorldRay(eventData.rayOrigin))
return;
=======
m_PanZooming = true;
m_WorkspaceUI.topHighlight.visible = true;
>>>>>>>
if (isMiniWorldRay(eventData.rayOrigin))
return;
m_PanZooming = true;
m_WorkspaceUI.topHighlight.visible = true;
<<<<<<<
if (isMiniWorldRay(eventData.rayOrigin))
return;
=======
m_PanZooming = false;
m_WorkspaceUI.topHighlight.visible = false;
>>>>>>>
if (isMiniWorldRay(eventData.rayOrigin))
return;
m_PanZooming = false;
m_WorkspaceUI.topHighlight.visible = false;
<<<<<<<
if (isMiniWorldRay(eventData.rayOrigin))
return;
setHighlight(handle.gameObject, true);
=======
m_WorkspaceUI.topHighlight.visible = true;
>>>>>>>
if (isMiniWorldRay(eventData.rayOrigin))
return;
m_WorkspaceUI.topHighlight.visible = true;
<<<<<<<
if (isMiniWorldRay(eventData.rayOrigin))
return;
setHighlight(handle.gameObject, false);
=======
if (!m_PanZooming)
m_WorkspaceUI.topHighlight.visible = false;
>>>>>>>
if (isMiniWorldRay(eventData.rayOrigin))
return;
if (!m_PanZooming)
m_WorkspaceUI.topHighlight.visible = false; |
<<<<<<<
using Unity.Labs.EditorXR.Interfaces;
=======
using Unity.Labs.EditorXR.Core;
>>>>>>>
using Unity.Labs.EditorXR.Core;
using Unity.Labs.EditorXR.Interfaces; |
<<<<<<<
public MoveCameraRigDelegate moveCameraRig { private get; set; }
public virtual string searchQuery { get { return m_FilterUI.searchQuery; } }
=======
public string searchQuery { get { return m_FilterUI.searchQuery; } }
>>>>>>>
public virtual string searchQuery { get { return m_FilterUI.searchQuery; } }
<<<<<<<
m_FilterUI = ObjectUtils.Instantiate(m_FilterPrefab, m_WorkspaceUI.frontPanel, false).GetComponent<FilterUI>();
foreach (var mb in m_FilterUI.GetComponentsInChildren<MonoBehaviour>())
{
connectInterfaces(mb);
}
m_FilterUI.filterList = m_FilterList;
=======
this.ConnectInterfaces(mb);
>>>>>>>
m_FilterUI = ObjectUtils.Instantiate(m_FilterPrefab, m_WorkspaceUI.frontPanel, false).GetComponent<FilterUI>();
foreach (var mb in m_FilterUI.GetComponentsInChildren<MonoBehaviour>())
{
this.ConnectInterfaces(mb);
}
m_FilterUI.filterList = m_FilterList;
<<<<<<<
var focusUI = ObjectUtils.Instantiate(m_FocusPrefab, m_WorkspaceUI.frontPanel, false);
foreach (var mb in focusUI.GetComponentsInChildren<MonoBehaviour>())
{
connectInterfaces(mb);
}
focusUI.GetComponentInChildren<Button>(true).onClick.AddListener(FocusSelection);
=======
this.ConnectInterfaces(mb);
>>>>>>>
var focusUI = ObjectUtils.Instantiate(m_FocusPrefab, m_WorkspaceUI.frontPanel, false);
foreach (var mb in focusUI.GetComponentsInChildren<MonoBehaviour>())
{
this.ConnectInterfaces(mb);
}
focusUI.GetComponentInChildren<Button>(true).onClick.AddListener(FocusSelection);
<<<<<<<
var createEmptyUI = ObjectUtils.Instantiate(m_CreateEmptyPrefab, m_WorkspaceUI.frontPanel, false);
foreach (var mb in createEmptyUI.GetComponentsInChildren<MonoBehaviour>())
{
connectInterfaces(mb);
}
createEmptyUI.GetComponentInChildren<Button>(true).onClick.AddListener(CreateEmptyGameObject);
=======
this.ConnectInterfaces(mb);
>>>>>>>
var createEmptyUI = ObjectUtils.Instantiate(m_CreateEmptyPrefab, m_WorkspaceUI.frontPanel, false);
foreach (var mb in createEmptyUI.GetComponentsInChildren<MonoBehaviour>())
{
this.ConnectInterfaces(mb);
}
createEmptyUI.GetComponentInChildren<Button>(true).onClick.AddListener(CreateEmptyGameObject); |
<<<<<<<
using System;
=======
#if UNITY_EDITOR
using System;
>>>>>>>
#if UNITY_EDITOR
using System;
<<<<<<<
private readonly Dictionary<Transform, RaycastSource> m_RaycastSources = new Dictionary<Transform, RaycastSource>();
public Camera eventCamera { get { return m_EventCamera; } set { m_EventCamera = value; } }
private Camera m_EventCamera;
public LayerMask layerMask { get { return s_LayerMask; } set { s_LayerMask = value; } }
private static LayerMask s_LayerMask;
public ActionMap actionMap { get { return m_UIActionMap; } }
[SerializeField]
private ActionMap m_UIActionMap;
public Func<Transform, float> getPointerLength { get; set; }
public event Action<GameObject, RayEventData> rayEntered = delegate {};
public event Action<GameObject, RayEventData> rayExited = delegate {};
public event Action<GameObject, RayEventData> dragStarted = delegate {};
public event Action<GameObject, RayEventData> dragEnded = delegate {};
public Action<Transform> preProcessRaycastSource { private get; set; }
// Local method use only -- created here to reduce garbage collection
RayEventData m_TempRayEvent;
List<RaycastSource> m_RaycastSourcesCopy = new List<RaycastSource>();
protected override void Awake()
=======
private readonly Dictionary<Transform, RaycastSource> m_RaycastSources = new Dictionary<Transform, RaycastSource>();
public Camera eventCamera { get { return m_EventCamera; } set { m_EventCamera = value; } }
private Camera m_EventCamera;
public LayerMask layerMask { get { return s_LayerMask; } set { s_LayerMask = value; } }
private static LayerMask s_LayerMask;
public ActionMap actionMap { get { return m_UIActionMap; } }
[SerializeField]
private ActionMap m_UIActionMap;
public Func<Transform, float> getPointerLength { get; set; }
public event Action<GameObject, RayEventData> rayEntered;
public event Action<GameObject, RayEventData> rayExited;
public event Action<GameObject, RayEventData> dragStarted;
public event Action<GameObject, RayEventData> dragEnded;
public Action<Transform> preProcessRaycastSource;
// Local method use only -- created here to reduce garbage collection
RayEventData m_TempRayEvent;
List<RaycastSource> m_RaycastSourcesCopy = new List<RaycastSource>();
protected override void Awake()
>>>>>>>
private readonly Dictionary<Transform, RaycastSource> m_RaycastSources = new Dictionary<Transform, RaycastSource>();
public Camera eventCamera { get { return m_EventCamera; } set { m_EventCamera = value; } }
private Camera m_EventCamera;
public LayerMask layerMask { get { return s_LayerMask; } set { s_LayerMask = value; } }
private static LayerMask s_LayerMask;
public ActionMap actionMap { get { return m_UIActionMap; } }
[SerializeField]
private ActionMap m_UIActionMap;
public Func<Transform, float> getPointerLength { get; set; }
public event Action<GameObject, RayEventData> rayEntered;
public event Action<GameObject, RayEventData> rayExited;
public event Action<GameObject, RayEventData> dragStarted;
public event Action<GameObject, RayEventData> dragEnded;
public Action<Transform> preProcessRaycastSource { private get; set; }
// Local method use only -- created here to reduce garbage collection
RayEventData m_TempRayEvent;
List<RaycastSource> m_RaycastSourcesCopy = new List<RaycastSource>();
protected override void Awake()
<<<<<<<
// We don't process with all other input modules because we need fine-grained control to consume input
}
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl)
{
=======
// We don't process with all other input modules because we need fine-grained control to consume input
}
public void ProcessInput(ActionMapInput input, Action<InputControl> consumeControl)
{
>>>>>>>
// We don't process with all other input modules because we need fine-grained control to consume input
}
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl)
{
<<<<<<<
hasScrollHandler = false;
var selectionFlags = currentObject.GetComponent<ISelectionFlags>();
if (selectionFlags != null && selectionFlags.selectionFlags == SelectionFlags.Direct && !U.UI.IsDirectEvent(eventData))
return false;
hasScrollHandler = ExecuteEvents.GetEventHandler<IScrollHandler>(currentObject);
return ExecuteEvents.GetEventHandler<IPointerClickHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IPointerDownHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IPointerUpHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IDragHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IBeginDragHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IEndDragHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IRayDragHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IRayBeginDragHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IRayEndDragHandler>(currentObject)
|| hasScrollHandler;
}
RayEventData GetTempEventDataClone(RayEventData eventData)
{
var clone = m_TempRayEvent;
=======
hasScrollHandler = false;
var selectionFlags = currentObject.GetComponent<ISelectionFlags>();
if (selectionFlags != null && selectionFlags.selectionFlags == SelectionFlags.Direct && !UIUtils.IsDirectEvent(eventData))
return false;
hasScrollHandler = ExecuteEvents.GetEventHandler<IScrollHandler>(currentObject);
return ExecuteEvents.GetEventHandler<IPointerClickHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IPointerDownHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IPointerUpHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IDragHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IBeginDragHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IEndDragHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IRayDragHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IRayBeginDragHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IRayEndDragHandler>(currentObject)
|| hasScrollHandler;
}
RayEventData GetTempEventDataClone(RayEventData eventData)
{
var clone = m_TempRayEvent;
>>>>>>>
hasScrollHandler = false;
var selectionFlags = currentObject.GetComponent<ISelectionFlags>();
if (selectionFlags != null && selectionFlags.selectionFlags == SelectionFlags.Direct && !UIUtils.IsDirectEvent(eventData))
return false;
hasScrollHandler = ExecuteEvents.GetEventHandler<IScrollHandler>(currentObject);
return ExecuteEvents.GetEventHandler<IPointerClickHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IPointerDownHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IPointerUpHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IDragHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IBeginDragHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IEndDragHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IRayDragHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IRayBeginDragHandler>(currentObject)
|| ExecuteEvents.GetEventHandler<IRayEndDragHandler>(currentObject)
|| hasScrollHandler;
}
RayEventData GetTempEventDataClone(RayEventData eventData)
{
var clone = m_TempRayEvent;
<<<<<<<
{
var hovered = cachedEventData.hovered[i];
ExecuteEvents.Execute(hovered, eventData, ExecuteRayEvents.rayExitHandler);
rayExited(hovered, eventData);
}
=======
{
ExecuteEvents.Execute(cachedEventData.hovered[i], eventData, ExecuteRayEvents.rayExitHandler);
if (rayExited != null)
rayExited(cachedEventData.hovered[i], eventData);
}
>>>>>>>
{
var hovered = cachedEventData.hovered[i];
ExecuteEvents.Execute(hovered, eventData, ExecuteRayEvents.rayExitHandler);
if (rayExited != null)
rayExited(hovered, eventData);
}
<<<<<<<
rayExited(t.gameObject, cachedEventData);
=======
if (rayExited != null)
rayExited(t.gameObject, cachedEventData);
>>>>>>>
if (rayExited != null)
rayExited(t.gameObject, cachedEventData);
<<<<<<<
rayEntered(t.gameObject, cachedEventData);
=======
if (rayEntered != null)
rayEntered(t.gameObject, cachedEventData);
>>>>>>>
if (rayEntered != null)
rayEntered(t.gameObject, cachedEventData);
<<<<<<<
// Track clicks for double-clicking, triple-clicking, etc.
float time = Time.realtimeSinceStartup;
if (newPressed == eventData.lastPress)
{
var diffTime = time - eventData.clickTime;
if (U.UI.IsDoubleClick(diffTime))
++eventData.clickCount;
else
eventData.clickCount = 1;
}
else
{
eventData.clickCount = 1;
}
eventData.clickTime = time;
=======
// Track clicks for double-clicking, triple-clicking, etc.
float time = Time.realtimeSinceStartup;
if (newPressed == eventData.lastPress)
{
var diffTime = time - eventData.clickTime;
if (UIUtils.IsDoubleClick(diffTime))
++eventData.clickCount;
else
eventData.clickCount = 1;
}
else
{
eventData.clickCount = 1;
}
eventData.clickTime = time;
>>>>>>>
// Track clicks for double-clicking, triple-clicking, etc.
float time = Time.realtimeSinceStartup;
if (newPressed == eventData.lastPress)
{
var diffTime = time - eventData.clickTime;
if (UIUtils.IsDoubleClick(diffTime))
++eventData.clickCount;
else
eventData.clickCount = 1;
}
else
{
eventData.clickCount = 1;
}
eventData.clickTime = time;
<<<<<<<
eventData.dragging = true;
dragStarted(draggedObject, eventData);
=======
eventData.dragging = true;
if (dragStarted != null)
dragStarted(draggedObject, eventData);
>>>>>>>
eventData.dragging = true;
if (dragStarted != null)
dragStarted(draggedObject, eventData);
<<<<<<<
dragEnded(draggedObject, eventData);
=======
if (dragEnded != null)
dragEnded(draggedObject, eventData);
>>>>>>>
if (dragEnded != null)
dragEnded(draggedObject, eventData);
<<<<<<<
eventSystem.RaycastAll(eventData, m_RaycastResultCache);
eventData.pointerCurrentRaycast = FindFirstRaycast(m_RaycastResultCache);
var hit = eventData.pointerCurrentRaycast.gameObject;
=======
eventSystem.RaycastAll(eventData, m_RaycastResultCache);
eventData.pointerCurrentRaycast = FindFirstRaycast(m_RaycastResultCache);
hit = eventData.pointerCurrentRaycast.gameObject;
>>>>>>>
eventSystem.RaycastAll(eventData, m_RaycastResultCache);
eventData.pointerCurrentRaycast = FindFirstRaycast(m_RaycastResultCache);
var hit = eventData.pointerCurrentRaycast.gameObject; |
<<<<<<<
[Serializable]
private struct ChessBoardUniqueSave
{
public Vector3 miniWorldRefScale;
public Vector3 miniWorldRefPos;
public float zoomSliderValue;
}
ChessBoardUniqueSave m_UniqueSave = new ChessBoardUniqueSave();
=======
public Func<Transform, object, bool> lockRay { get; set; }
public Func<Transform, object, bool> unlockRay { get; set; }
>>>>>>>
[Serializable]
private struct ChessBoardUniqueSave
{
public Vector3 miniWorldRefScale;
public Vector3 miniWorldRefPos;
public float zoomSliderValue;
}
ChessBoardUniqueSave m_UniqueSave = new ChessBoardUniqueSave();
public Func<Transform, object, bool> lockRay { get; set; }
public Func<Transform, object, bool> unlockRay { get; set; } |
<<<<<<<
public static readonly Vector3 DefaultBounds = new Vector3(0.7f, 0f, 0.4f);
public static readonly Vector3 MinBounds = new Vector3(0.55f, 0f, 0.1f);
=======
public static readonly Vector3 DefaultBounds = new Vector3(0.7f, 0.4f, 0.4f);
public static readonly Vector3 MinBounds = new Vector3(0.677f, 0f, 0.1f);
>>>>>>>
public static readonly Vector3 DefaultBounds = new Vector3(0.7f, 0f, 0.4f);
public static readonly Vector3 MinBounds = new Vector3(0.677f, 0f, 0.1f); |
<<<<<<<
if (m_FrameRevealCoroutine != null)
StopCoroutine(m_FrameRevealCoroutine);
m_FrameRevealCoroutine = StartCoroutine(AnimateFrameReveal(m_VisibilityState));
=======
foreach (var submenus in m_FaceSubmenus)
{
foreach (var submenu in submenus.Value)
U.Object.Destroy(submenu);
}
m_FaceSubmenus.Clear();
StartCoroutine(AnimateFrameReveal(m_VisibilityState));
>>>>>>>
foreach (var submenus in m_FaceSubmenus)
{
foreach (var submenu in submenus.Value)
U.Object.Destroy(submenu);
}
m_FaceSubmenus.Clear();
if (m_FrameRevealCoroutine != null)
StopCoroutine(m_FrameRevealCoroutine);
m_FrameRevealCoroutine = StartCoroutine(AnimateFrameReveal(m_VisibilityState)); |
<<<<<<<
using System.Linq;
using UnityEditor.Experimental.EditorVR.Core;
=======
using UnityEditor.Experimental.EditorVR.Helpers;
>>>>>>>
using UnityEditor.Experimental.EditorVR.Core;
using UnityEditor.Experimental.EditorVR.Helpers;
<<<<<<<
SerializedFeedback m_SerializedFeedback;
readonly List<ProxyFeedbackRequest> m_FeedbackRequests = new List<ProxyFeedbackRequest>();
readonly Dictionary<RequestKey, RequestData> m_RequestData = new Dictionary<RequestKey, RequestData>();
=======
>>>>>>>
<<<<<<<
m_FeedbackRequests.Add(proxyRequest);
ExecuteFeedback(proxyRequest);
}
}
void ExecuteFeedback(ProxyFeedbackRequest changedRequest)
{
if (!active)
return;
foreach (var proxyNode in m_Buttons)
{
if (proxyNode.Key != changedRequest.node)
continue;
foreach (var kvp in proxyNode.Value)
{
if (kvp.Key != changedRequest.control)
continue;
ProxyFeedbackRequest request = null;
foreach (var req in m_FeedbackRequests)
{
if (req.node != proxyNode.Key || req.control != kvp.Key)
continue;
if (request == null || req.priority >= request.priority)
request = req;
}
if (request == null)
continue;
var feedbackKey = new RequestKey(request);
RequestData data;
if (!m_RequestData.TryGetValue(feedbackKey, out data))
{
data = new RequestData();
m_RequestData[feedbackKey] = data;
}
var suppress = data.presentations > request.maxPresentations;
var suppressPresentation = request.suppressPresentation;
if (suppressPresentation != null)
suppress = suppressPresentation();
if (suppress)
continue;
foreach (var button in kvp.Value)
{
if (button.renderer)
this.SetHighlight(button.renderer.gameObject, !request.hideExisting, duration: k_FeedbackDuration);
var tooltipText = request.tooltipText;
if (!string.IsNullOrEmpty(tooltipText) || request.hideExisting)
{
foreach (var tooltip in button.tooltips)
{
if (tooltip)
{
tooltip.tooltipText = tooltipText;
this.ShowTooltip(tooltip, true, k_FeedbackDuration, () =>
{
if (!data.visibleThisPresentation)
data.presentations++;
data.visibleThisPresentation = true;
});
}
}
}
}
}
=======
if (proxyRequest.node == Node.LeftHand)
m_LeftProxyNode.AddFeedbackRequest(proxyRequest);
else if (proxyRequest.node == Node.RightHand)
m_RightProxyNode.AddFeedbackRequest(proxyRequest);
>>>>>>>
if (proxyRequest.node == Node.LeftHand)
m_LeftProxyNode.AddFeedbackRequest(proxyRequest);
else if (proxyRequest.node == Node.RightHand)
m_RightProxyNode.AddFeedbackRequest(proxyRequest);
<<<<<<<
var feedbackKey = new RequestKey(request);
RequestData data;
if (m_RequestData.TryGetValue(feedbackKey, out data))
data.visibleThisPresentation = false;
// If this feedback was removed, show any feedback that might have been blocked by it
if (m_FeedbackRequests.Remove(request))
ExecuteFeedback(request);
=======
>>>>>>>
<<<<<<<
var requests = caller == null ? new List<ProxyFeedbackRequest>(m_FeedbackRequests)
: m_FeedbackRequests.Where(feedbackRequest => feedbackRequest.caller == caller).ToList();
foreach (var feedbackRequest in requests)
=======
// Check for null in order to prevent MissingReferenceException when exiting EXR
if (m_LeftProxyNode && m_RightProxyNode)
>>>>>>>
// Check for null in order to prevent MissingReferenceException when exiting EXR
if (m_LeftProxyNode && m_RightProxyNode) |
<<<<<<<
using System;
using UnityEngine;
=======
using System.Collections.Generic;
using UnityEngine;
>>>>>>>
using System;
using System.Collections.Generic;
using UnityEngine; |
<<<<<<<
public Action<Vector3, Transform, bool> translate { private get; set; }
public Action<Quaternion, Transform> rotate { private get; set; }
=======
public Action<Vector3, Transform, ConstrainedAxis> translate { private get; set; }
public Action<Quaternion> rotate { private get; set; }
>>>>>>>
public Action<Vector3, Transform, ConstrainedAxis> translate { private get; set; }
public Action<Quaternion, Transform> rotate { private get; set; }
<<<<<<<
translate(rayOrigin.position + rayOrigin.rotation * m_PositionOffset - target.position, rayOrigin, false);
rotate(Quaternion.Inverse(target.rotation) * rayOrigin.rotation * m_RotationOffset, rayOrigin);
=======
translate(rayOrigin.position + rayOrigin.rotation * m_PositionOffset - target.position, rayOrigin, 0);
rotate(Quaternion.Inverse(target.rotation) * rayOrigin.rotation * m_RotationOffset);
>>>>>>>
translate(rayOrigin.position + rayOrigin.rotation * m_PositionOffset - target.position, rayOrigin, 0);
rotate(Quaternion.Inverse(target.rotation) * rayOrigin.rotation * m_RotationOffset, rayOrigin); |
<<<<<<<
using UnityEngine.VR.Modules;
=======
using UnityEngine.VR.Helpers;
>>>>>>>
using UnityEngine.VR.Modules;
<<<<<<<
m_DragObject = clone.transform;
=======
// Disable any SmoothMotion that may be applied to a cloned Asset Grid Item now referencing input device p/r/s
var smoothMotion = clone.GetComponent<SmoothMotion>();
if (smoothMotion != null)
smoothMotion.enabled = false;
m_GrabbedObject = clone.transform;
m_GrabLerp = 0;
StartCoroutine(Magnetize());
>>>>>>>
m_DragObject = clone.transform;
if (smoothMotion != null)
smoothMotion.enabled = false;
<<<<<<<
gridItem.m_Cube.sharedMaterial = null; // Drop material so it won't be destroyed (shared with cube in list)
U.Object.Destroy(m_DragObject.gameObject);
base.OnDragEnded(baseHandle, eventData);
=======
StartCoroutine(AnimatedHide(m_GrabbedObject.gameObject, gridItem.m_Cube));
}
IEnumerator AnimatedHide(GameObject itemToHide, Renderer cubeRenderer)
{
m_GrabbedObject = null;
var itemTransform = itemToHide.transform;
var currentScale = itemTransform.localScale;
var targetScale = Vector3.zero;
var transitionAmount = Time.unscaledDeltaTime;
var transitionAddMultiplier = 6;
while (transitionAmount < 1)
{
itemTransform.localScale = Vector3.Lerp(currentScale, targetScale, transitionAmount);
transitionAmount += Time.unscaledDeltaTime * transitionAddMultiplier;
yield return null;
}
cubeRenderer.sharedMaterial = null; // Drop material so it won't be destroyed (shared with cube in list)
U.Object.Destroy(itemToHide);
>>>>>>>
}
U.Object.Destroy(m_DragObject.gameObject);
base.OnDragEnded(baseHandle, eventData);
m_GrabbedObject = null;
var itemTransform = itemToHide.transform;
var currentScale = itemTransform.localScale;
var targetScale = Vector3.zero;
var transitionAmount = Time.unscaledDeltaTime;
var transitionAddMultiplier = 6;
while (transitionAmount < 1)
{
itemTransform.localScale = Vector3.Lerp(currentScale, targetScale, transitionAmount);
transitionAmount += Time.unscaledDeltaTime * transitionAddMultiplier;
yield return null;
}
cubeRenderer.sharedMaterial = null; // Drop material so it won't be destroyed (shared with cube in list)
U.Object.Destroy(itemToHide); |
<<<<<<<
[TestMethod]
public async Task JsonDialogLoad_ToDoBot()
{
string json = File.ReadAllText(samplesDirectory + @"Planning - ToDoBot\TodoBot.main.dialog");
Factory.Register("Microsoft.RuleRecognizer", typeof(RuleRecognizer));
await BuildTestFlow(json)
.Send(new Activity(ActivityTypes.ConversationUpdate, membersAdded: new List<ChannelAccount>() { new ChannelAccount("bot", "Bot") }))
.Send("hello")
.AssertReply("Hi! I'm a ToDo bot. Say \"add a todo named first\" to get started.")
.Send("add a todo named first")
.AssertReply("Successfully added a todo named \"first\"")
.Send("add a todo named second")
.AssertReply("Successfully added a todo named \"second\"")
.Send("add a todo")
.AssertReply("OK, please enter the title of your todo.")
.Send("third")
.AssertReply("Successfully added a todo named \"third\"")
.Send("show todos")
.AssertReply("Here are your todos: \n\n- first\n- second\n- third\n")
.Send("delete todo named second")
.AssertReply("Successfully removed a todo named \"second\"")
.Send("show todos")
.AssertReply("Here are your todos: \n\n- first\n- third\n")
.StartTestAsync();
}
=======
[TestMethod]
public async Task JsonDialogLoad_HttpRequest()
{
string json = File.ReadAllText(samplesDirectory + @"Planning 11 - HttpRequest\HttpRequest.main.dialog");
Factory.Register("Microsoft.RuleRecognizer", typeof(RuleRecognizer));
await BuildTestFlow(json)
.Send(new Activity(ActivityTypes.ConversationUpdate, membersAdded: new List<ChannelAccount>() { new ChannelAccount("bot", "Bot") }))
.Send("Hello")
.AssertReply("Welcome! Here is a http request sample, please enter a name for you visual pet.")
.Send("TestPetName")
.AssertReply("Great! Your pet's name is TestPetName, now please enter the id of your pet, this could help you find your pet later.")
.Send("12121")
.AssertReply("Done! You have added a pet named \"TestPetName\" with id \"12121\"")
.AssertReply("Now try to specify the id of your pet, and I will help your find it out from the store.")
.Send("12121")
.AssertReply("Great! I found your pet named \"TestPetName\"")
.StartTestAsync();
}
>>>>>>>
[TestMethod]
public async Task JsonDialogLoad_ToDoBot()
{
string json = File.ReadAllText(samplesDirectory + @"Planning - ToDoBot\TodoBot.main.dialog");
Factory.Register("Microsoft.RuleRecognizer", typeof(RuleRecognizer));
await BuildTestFlow(json)
.Send(new Activity(ActivityTypes.ConversationUpdate, membersAdded: new List<ChannelAccount>() { new ChannelAccount("bot", "Bot") }))
.Send("hello")
.AssertReply("Hi! I'm a ToDo bot. Say \"add a todo named first\" to get started.")
.Send("add a todo named first")
.AssertReply("Successfully added a todo named \"first\"")
.Send("add a todo named second")
.AssertReply("Successfully added a todo named \"second\"")
.Send("add a todo")
.AssertReply("OK, please enter the title of your todo.")
.Send("third")
.AssertReply("Successfully added a todo named \"third\"")
.Send("show todos")
.AssertReply("Here are your todos: \n\n- first\n- second\n- third\n")
.Send("delete todo named second")
.AssertReply("Successfully removed a todo named \"second\"")
.Send("show todos")
.AssertReply("Here are your todos: \n\n- first\n- third\n")
.StartTestAsync();
}
public async Task JsonDialogLoad_HttpRequest()
{
string json = File.ReadAllText(samplesDirectory + @"Planning 11 - HttpRequest\HttpRequest.main.dialog");
Factory.Register("Microsoft.RuleRecognizer", typeof(RuleRecognizer));
await BuildTestFlow(json)
.Send(new Activity(ActivityTypes.ConversationUpdate, membersAdded: new List<ChannelAccount>() { new ChannelAccount("bot", "Bot") }))
.Send("Hello")
.AssertReply("Welcome! Here is a http request sample, please enter a name for you visual pet.")
.Send("TestPetName")
.AssertReply("Great! Your pet's name is TestPetName, now please enter the id of your pet, this could help you find your pet later.")
.Send("12121")
.AssertReply("Done! You have added a pet named \"TestPetName\" with id \"12121\"")
.AssertReply("Now try to specify the id of your pet, and I will help your find it out from the store.")
.Send("12121")
.AssertReply("Great! I found your pet named \"TestPetName\"")
.StartTestAsync();
} |
<<<<<<<
RenderTexture m_TargetTexture;
private bool m_ShowDeviceView;
EditorWindow[] m_EditorWindows;
=======
RenderTexture m_SceneTargetTexture;
bool m_ShowDeviceView;
bool m_SceneViewsEnabled;
>>>>>>>
RenderTexture m_TargetTexture;
bool m_ShowDeviceView;
EditorWindow[] m_EditorWindows;
<<<<<<<
private Transform m_CameraRig;
=======
Transform m_CameraRig;
Quaternion m_LastHeadRotation = Quaternion.identity;
float m_TimeSinceLastHMDChange;
bool m_LatchHMDValues;
>>>>>>>
Transform m_CameraRig;
<<<<<<<
Camera.SetupCurrent(currentCamera);
=======
// HACK: Fix VRSettings.enabled or some other API to check for missing HMD
m_VRInitialized = false;
#if ENABLE_OVR_INPUT
m_VRInitialized |= OVRPlugin.initialized;
#endif
#if ENABLE_STEAMVR_INPUT
m_VRInitialized |= (OpenVR.IsHmdPresent() && OpenVR.Compositor != null);
#endif
>>>>>>>
Camera.SetupCurrent(currentCamera);
<<<<<<<
var e = Event.current;
if (e.type != EventType.ExecuteCommand && e.type != EventType.used)
{
var guiRect = new Rect(0, 0, position.width, position.height);
var cameraRect = EditorGUIUtility.PointsToPixels(guiRect);
PrepareCameraTargetTexture(cameraRect);
=======
SceneViewUtilities.ResetOnGUIState();
var rect = guiRect;
rect.x = 0;
rect.y = 0;
rect.width = position.width;
rect.height = position.height;
guiRect = rect;
var cameraRect = EditorGUIUtility.PointsToPixels(guiRect);
PrepareCameraTargetTexture(cameraRect);
>>>>>>>
var rect = guiRect;
rect.x = 0;
rect.y = 0;
rect.width = position.width;
rect.height = position.height;
guiRect = rect;
var cameraRect = EditorGUIUtility.PointsToPixels(guiRect);
PrepareCameraTargetTexture(cameraRect); |
<<<<<<<
readonly List<Object> m_SelectedObjects = new List<Object>(); // Keep the list to avoid allocations--we do not use it to maintain state
readonly Dictionary<GameObject, GameObject> m_GroupMap = new Dictionary<GameObject, GameObject>(); // Maps objects to their group parent
=======
>>>>>>>
readonly Dictionary<GameObject, GameObject> m_GroupMap = new Dictionary<GameObject, GameObject>(); // Maps objects to their group parent
<<<<<<<
// Local method use only -- created here to reduce garbage collection
readonly List<Transform> m_Transforms = new List<Transform>(); // Keep the list to avoid allocations--we do not use it to maintain state
=======
// Local method use only -- created here to reduce garbage collection
static readonly HashSet<Object> m_SelectedObjects = new HashSet<Object>();
static readonly List<GameObject> k_SingleObjectList = new List<GameObject>();
>>>>>>>
// Local method use only -- created here to reduce garbage collection
static readonly HashSet<Object> m_SelectedObjects = new HashSet<Object>();
static readonly List<GameObject> k_SingleObjectList = new List<GameObject>();
readonly List<Transform> m_Transforms = new List<Transform>();
<<<<<<<
var groupRoot = GetGroupRoot(hoveredObject);
if (useGrouping && groupRoot != m_CurrentGroupRoot)
m_CurrentGroupRoot = groupRoot;
=======
return;
}
>>>>>>>
return;
} |
<<<<<<<
tools = new Stack<ITool>(),
showMenuInput = (ShowMenu)CreateActionMapInput(m_ShowMenuActionMap,device),
toolMenus = new List<GameObject>()
=======
tools = new Stack<ITool>()
>>>>>>>
tools = new Stack<ITool>(),
toolMenus = new List<GameObject>()
<<<<<<<
var device = kvp.Key;
var mainMenu = m_DeviceData[device].mainMenu;
if (mainMenu != null)
{
// Toggle tool menus
foreach(GameObject go in kvp.Value.toolMenus)
go.SetActive(mainMenu.visible);
// Toggle menu
mainMenu.visible = !mainMenu.visible;
}
=======
foreach (var rayOrigin in proxy.rayOrigins.Values)
m_KeyboardMallets[rayOrigin].CheckForKeyCollision();
>>>>>>>
foreach (var rayOrigin in proxy.rayOrigins.Values)
m_KeyboardMallets[rayOrigin].CheckForKeyCollision();
<<<<<<<
private GameObject InstantiateMenuUI(Node node,MenuOrigin origin,GameObject prefab)
{
var go = U.Object.Instantiate(prefab,transform);
foreach(Canvas canvas in go.GetComponentsInChildren<Canvas>())
canvas.worldCamera = m_EventCamera;
// the menu needs to be on the opposite hand to the tool
if(node == Node.LeftHand)
node = Node.RightHand;
else if(node == Node.RightHand)
node = Node.LeftHand;
ForEachRayOrigin((proxy,rayOriginPair,device,deviceData) =>
{
Dictionary<Node,Transform> tempOrigin = null;
if(origin == MenuOrigin.Main)
tempOrigin = proxy.menuOrigins;
else if(origin == MenuOrigin.Alternate)
tempOrigin = proxy.alternateMenuOrigins;
Transform parent;
if(tempOrigin != null && tempOrigin.TryGetValue(node,out parent))
{
go.transform.SetParent(parent);
go.transform.localPosition = Vector3.zero;
go.transform.localRotation = Quaternion.identity;
deviceData.toolMenus.Add(go);
m_DeviceData[device].mainMenu.visible = false;
}
}, true);
return go;
}
=======
private KeyboardUI SpawnNumericKeyboard()
{
if(m_StandardKeyboard != null)
m_StandardKeyboard.gameObject.SetActive(false);
// Check if the prefab has already been instantiated
if (m_NumericKeyboard == null)
{
m_NumericKeyboard = U.Object.Instantiate(m_NumericKeyboardPrefab.gameObject, U.Camera.GetViewerPivot()).GetComponent<KeyboardUI>();
m_NumericKeyboard.GetComponent<Canvas>().worldCamera = m_EventCamera;
m_NumericKeyboard.orientationChanged += KeyboardOrientationChanged;
}
return m_NumericKeyboard;
}
private KeyboardUI SpawnAlphaNumericKeyboard()
{
if (m_NumericKeyboard != null)
m_NumericKeyboard.gameObject.SetActive(false);
// Check if the prefab has already been instantiated
if (m_StandardKeyboard == null)
{
m_StandardKeyboard = U.Object.Instantiate(m_StandardKeyboardPrefab.gameObject, U.Camera.GetViewerPivot()).GetComponent<KeyboardUI>();
m_StandardKeyboard.GetComponent<Canvas>().worldCamera = m_EventCamera;
m_StandardKeyboard.orientationChanged += KeyboardOrientationChanged;
}
return m_StandardKeyboard;
}
void KeyboardOrientationChanged(bool isHorizontal)
{
foreach (var kvp in m_KeyboardMallets)
{
var mallet = kvp.Value;
var dpr = kvp.Key.GetComponentInChildren<DefaultProxyRay>();
if (isHorizontal)
{
mallet.Show();
dpr.Hide();
}
else
{
mallet.Hide();
dpr.Show();
}
}
}
>>>>>>>
private GameObject InstantiateMenuUI(Node node,MenuOrigin origin,GameObject prefab)
{
var go = U.Object.Instantiate(prefab,transform);
foreach(Canvas canvas in go.GetComponentsInChildren<Canvas>())
canvas.worldCamera = m_EventCamera;
// the menu needs to be on the opposite hand to the tool
if(node == Node.LeftHand)
node = Node.RightHand;
else if(node == Node.RightHand)
node = Node.LeftHand;
ForEachRayOrigin((proxy,rayOriginPair,device,deviceData) =>
{
Dictionary<Node,Transform> tempOrigin = null;
if(origin == MenuOrigin.Main)
tempOrigin = proxy.menuOrigins;
else if(origin == MenuOrigin.Alternate)
tempOrigin = proxy.alternateMenuOrigins;
Transform parent;
if(tempOrigin != null && tempOrigin.TryGetValue(node,out parent))
{
go.transform.SetParent(parent);
go.transform.localPosition = Vector3.zero;
go.transform.localRotation = Quaternion.identity;
deviceData.toolMenus.Add(go);
m_DeviceData[device].mainMenu.visible = false;
}
}, true);
return go;
}
private KeyboardUI SpawnNumericKeyboard()
{
if(m_StandardKeyboard != null)
m_StandardKeyboard.gameObject.SetActive(false);
// Check if the prefab has already been instantiated
if (m_NumericKeyboard == null)
{
m_NumericKeyboard = U.Object.Instantiate(m_NumericKeyboardPrefab.gameObject, U.Camera.GetViewerPivot()).GetComponent<KeyboardUI>();
m_NumericKeyboard.GetComponent<Canvas>().worldCamera = m_EventCamera;
m_NumericKeyboard.orientationChanged += KeyboardOrientationChanged;
}
return m_NumericKeyboard;
}
private KeyboardUI SpawnAlphaNumericKeyboard()
{
if (m_NumericKeyboard != null)
m_NumericKeyboard.gameObject.SetActive(false);
// Check if the prefab has already been instantiated
if (m_StandardKeyboard == null)
{
m_StandardKeyboard = U.Object.Instantiate(m_StandardKeyboardPrefab.gameObject, U.Camera.GetViewerPivot()).GetComponent<KeyboardUI>();
m_StandardKeyboard.GetComponent<Canvas>().worldCamera = m_EventCamera;
m_StandardKeyboard.orientationChanged += KeyboardOrientationChanged;
}
return m_StandardKeyboard;
}
void KeyboardOrientationChanged(bool isHorizontal)
{
foreach (var kvp in m_KeyboardMallets)
{
var mallet = kvp.Value;
var dpr = kvp.Key.GetComponentInChildren<DefaultProxyRay>();
if (isHorizontal)
{
mallet.Show();
dpr.Hide();
}
else
{
mallet.Hide();
dpr.Show();
}
}
}
<<<<<<<
var iTool = obj as ITool;
if(iTool != null)
{
iTool.node = node.Value;
}
Transform rayOrigin;
if (proxy.rayOrigins.TryGetValue(node.Value, out rayOrigin))
=======
// Specific proxy ray setting
DefaultProxyRay dpr = null;
var customRay = obj as ICustomRay;
if (customRay != null)
>>>>>>>
// Specific proxy ray setting
DefaultProxyRay dpr = null;
var customRay = obj as ICustomRay;
if (customRay != null) |
<<<<<<<
public FolderData[] folderData { set { m_ProjectUI.folderListView.data = value; } }
=======
public FolderData[] folderData
{
private get { return m_FolderData; }
set
{
m_FolderData = value;
if (m_ProjectUI)
{
var oldData = m_ProjectUI.folderListView.data;
if (oldData != null && oldData.Length > 0)
CopyExpandStates(oldData[0], value[0]);
m_ProjectUI.folderListView.data = value;
if (value.Length > 0)
SelectFolder(m_OpenFolder != null ? GetFolderDataByInstanceID(value[0], m_OpenFolder.instanceID) : value[0]);
}
}
}
FolderData[] m_FolderData;
>>>>>>>
public FolderData[] folderData
{
set
{
m_FolderData = value;
if (m_ProjectUI)
m_ProjectUI.folderListView.data = value;
}
}
FolderData[] m_FolderData; |
<<<<<<<
StandardManipulator m_Manipulator;
Vector3 m_OriginalManipulatorScale;
=======
IGrabObjects m_TransformTool;
>>>>>>>
StandardManipulator m_Manipulator;
Vector3 m_OriginalManipulatorScale;
IGrabObjects m_TransformTool;
<<<<<<<
miniWorld.preProcessRender = PreProcessMiniWorldRender;
miniWorld.postProcessRender = PostProcessMiniWorldRender;
ForEachRayOrigin((proxy, rayOriginPair, device, deviceData) =>
=======
m_MiniWorldRays[miniWorldRayOrigin] = new MiniWorldRay
>>>>>>>
m_MiniWorldRays[miniWorldRayOrigin] = new MiniWorldRay
<<<<<<<
bool PreProcessRaycastSources()
{
if (!m_Manipulator)
m_Manipulator = GetComponentInChildren<StandardManipulator>();
if (m_Manipulator)
m_OriginalManipulatorScale = m_Manipulator.transform.localScale;
return true;
}
bool PreProcessRaycastSource(Transform rayOrigin)
{
if (m_Manipulator)
{
MiniWorldRay ray;
if (m_MiniWorldRays.TryGetValue(rayOrigin, out ray))
m_Manipulator.transform.localScale = ray.miniWorld.miniWorldScale * kMiniWorldManipulatorScale;
else
m_Manipulator.transform.localScale = m_OriginalManipulatorScale;
}
return true;
}
void PostProcessRaycastSources()
{
if (m_Manipulator)
m_Manipulator.transform.localScale = m_OriginalManipulatorScale;
}
bool PreProcessMiniWorldRender(IMiniWorld miniWorld)
{
if (m_Manipulator)
m_Manipulator.transform.localScale = miniWorld.miniWorldScale * kMiniWorldManipulatorScale;
return true;
}
void PostProcessMiniWorldRender(IMiniWorld miniWorld)
{
if (m_Manipulator)
m_Manipulator.transform.localScale = m_OriginalManipulatorScale;
}
=======
void AddPlayerModel()
{
var playerModel = U.Object.Instantiate(m_PlayerModelPrefab, U.Camera.GetMainCamera().transform, false).GetComponent<Renderer>();
m_SpatialHashModule.spatialHash.AddObject(playerModel, playerModel.bounds);
}
>>>>>>>
bool PreProcessRaycastSources()
{
if (!m_Manipulator)
m_Manipulator = GetComponentInChildren<StandardManipulator>();
if (m_Manipulator)
m_OriginalManipulatorScale = m_Manipulator.transform.localScale;
return true;
}
bool PreProcessRaycastSource(Transform rayOrigin)
{
if (m_Manipulator)
{
MiniWorldRay ray;
if (m_MiniWorldRays.TryGetValue(rayOrigin, out ray))
m_Manipulator.transform.localScale = ray.miniWorld.miniWorldScale * kMiniWorldManipulatorScale;
else
m_Manipulator.transform.localScale = m_OriginalManipulatorScale;
}
return true;
}
void PostProcessRaycastSources()
{
if (m_Manipulator)
m_Manipulator.transform.localScale = m_OriginalManipulatorScale;
}
bool PreProcessMiniWorldRender(IMiniWorld miniWorld)
{
if (m_Manipulator)
m_Manipulator.transform.localScale = miniWorld.miniWorldScale * kMiniWorldManipulatorScale;
return true;
}
void PostProcessMiniWorldRender(IMiniWorld miniWorld)
{
if (m_Manipulator)
m_Manipulator.transform.localScale = m_OriginalManipulatorScale;
}
void AddPlayerModel()
{
var playerModel = U.Object.Instantiate(m_PlayerModelPrefab, U.Camera.GetMainCamera().transform, false).GetComponent<Renderer>();
m_SpatialHashModule.spatialHash.AddObject(playerModel, playerModel.bounds);
} |
<<<<<<<
using Microsoft.Bot.Builder.Core.Extensions;
using Microsoft.Azure.CognitiveServices.Language.LUIS.Runtime;
using Microsoft.Azure.CognitiveServices.Language.LUIS.Runtime.Models;
=======
using Microsoft.Cognitive.LUIS;
using Microsoft.Cognitive.LUIS.Models;
>>>>>>>
using Microsoft.Azure.CognitiveServices.Language.LUIS.Runtime;
using Microsoft.Azure.CognitiveServices.Language.LUIS.Runtime.Models; |
<<<<<<<
IUsesProxyType, IMenuIcon, IUsesPointer, IRayVisibilitySettings, IUsesViewerScale, ICheckBounds,
ISettingsMenuItemProvider, ISerializePreferences, IStandardIgnoreList, IBlockUIInteraction, IRequestFeedback
=======
IUsesDeviceType, IMenuIcon, IRequestFeedback
>>>>>>>
IUsesDeviceType, IMenuIcon, IUsesPointer, IRayVisibilitySettings, IUsesViewerScale, ICheckBounds,
ISettingsMenuItemProvider, ISerializePreferences, IStandardIgnoreList, IBlockUIInteraction, IRequestFeedback
<<<<<<<
bool m_BlockSelect;
Vector3 m_SelectStartPosition;
Renderer m_BlockSelectCubeRenderer;
=======
bool m_HasDirectHover;
>>>>>>>
bool m_HasDirectHover;
bool m_BlockSelect;
Vector3 m_SelectStartPosition;
Renderer m_BlockSelectCubeRenderer;
<<<<<<<
if (selectionTool.m_BlockSelect)
continue;
=======
selectionTool.m_HasDirectHover = false; // Clear old hover state
var selectionRayOrigin = selectionTool.rayOrigin;
>>>>>>>
selectionTool.m_HasDirectHover = false; // Clear old hover state
if (selectionTool.m_BlockSelect)
continue;
<<<<<<<
GameObject hoveredObject = null;
var rayActive = IsRayActive();
if (rayActive)
{
// Need to call GetFirstGameObject a second time because we do not guarantee shared updater executes first
hoveredObject = this.GetFirstGameObject(rayOrigin);
=======
if (!m_HasDirectHover)
HideDirectSelectFeedback();
else if (m_DirectSelectFeedback.Count == 0)
ShowDirectSelectFeedback();
if (!IsRayActive())
{
HideSelectFeedback();
return;
}
>>>>>>>
if (!m_HasDirectHover)
HideDirectSelectFeedback();
else if (m_DirectSelectFeedback.Count == 0)
ShowDirectSelectFeedback();
GameObject hoveredObject = null;
var rayActive = IsRayActive();
if (rayActive)
{
// Need to call GetFirstGameObject a second time because we do not guarantee shared updater executes first
hoveredObject = this.GetFirstGameObject(rayOrigin);
<<<<<<<
public object OnSerializePreferences()
{
if (this.IsSharedUpdater(this))
{
// Share one preferences object across all instances
foreach (var linkedObject in linkedObjects)
{
((SelectionTool)linkedObject).m_Preferences = m_Preferences;
}
return m_Preferences;
}
return null;
}
public void OnDeserializePreferences(object obj)
{
if (this.IsSharedUpdater(this))
{
var preferences = obj as Preferences;
if (preferences != null)
m_Preferences = preferences;
// Share one preferences object across all instances
foreach (var linkedObject in linkedObjects)
{
((SelectionTool)linkedObject).m_Preferences = m_Preferences;
}
m_SphereToggle.isOn = m_Preferences.sphereMode;
m_CubeToggle.isOn = !m_Preferences.sphereMode;
}
}
void ShowSelectFeedback()
=======
void ShowFeedback(List<ProxyFeedbackRequest> requests, string controlName, string tooltipText = null)
>>>>>>>
public object OnSerializePreferences()
{
if (this.IsSharedUpdater(this))
{
// Share one preferences object across all instances
foreach (var linkedObject in linkedObjects)
{
((SelectionTool)linkedObject).m_Preferences = m_Preferences;
}
return m_Preferences;
}
return null;
}
public void OnDeserializePreferences(object obj)
{
if (this.IsSharedUpdater(this))
{
var preferences = obj as Preferences;
if (preferences != null)
m_Preferences = preferences;
// Share one preferences object across all instances
foreach (var linkedObject in linkedObjects)
{
((SelectionTool)linkedObject).m_Preferences = m_Preferences;
}
m_SphereToggle.isOn = m_Preferences.sphereMode;
m_CubeToggle.isOn = !m_Preferences.sphereMode;
}
}
void ShowFeedback(List<ProxyFeedbackRequest> requests, string controlName, string tooltipText = null) |
<<<<<<<
sealed class MainMenu : MonoBehaviour, IMainMenu, IConnectInterfaces, IInstantiateUI, ICreateWorkspace,
ICustomActionMap, IUsesMenuOrigins, IUsesProxyType, IControlHaptics, IUsesNode, IRayToNode
=======
sealed class MainMenu : MonoBehaviour, IMainMenu, IConnectInterfaces, IInstantiateUI, ICreateWorkspace,
ICustomActionMap, IUsesMenuOrigins, IUsesProxyType, IControlHaptics, IUsesNode, IRayToNode, IUsesRayOrigin
>>>>>>>
sealed class MainMenu : MonoBehaviour, IMainMenu, IConnectInterfaces, IInstantiateUI, ICreateWorkspace,
ICustomActionMap, IUsesMenuOrigins, IUsesProxyType, IControlHaptics, IUsesNode, IRayToNode, IUsesRayOrigin
<<<<<<<
public float hideDistance { get { return m_MainMenuUI.menuHeight; } }
=======
public Transform rayOrigin { private get; set; }
>>>>>>>
public Transform rayOrigin { private get; set; }
public float hideDistance { get { return m_MainMenuUI.menuHeight; } } |
<<<<<<<
m_RadialMenuUI.SelectionOccurred();
itemSelected(node);
=======
if(itemSelected != null)
itemSelected(node);
>>>>>>>
itemSelected(node); |
<<<<<<<
StandardManipulator m_Manipulator;
Vector3 m_OriginalManipulatorScale;
=======
class FolderDataIteration
{
public FolderData data;
public bool hasNext;
}
readonly List<IProjectFolderList> m_ProjectFolderLists = new List<IProjectFolderList>();
FolderData[] m_FolderData;
readonly HashSet<string> m_AssetTypes = new HashSet<string>();
float m_LastFolderYieldTime;
readonly List<IFilterUI> m_FilterUIs = new List<IFilterUI>();
>>>>>>>
StandardManipulator m_Manipulator;
Vector3 m_OriginalManipulatorScale;
class FolderDataIteration
{
public FolderData data;
public bool hasNext;
}
readonly List<IProjectFolderList> m_ProjectFolderLists = new List<IProjectFolderList>();
FolderData[] m_FolderData;
readonly HashSet<string> m_AssetTypes = new HashSet<string>();
float m_LastFolderYieldTime;
readonly List<IFilterUI> m_FilterUIs = new List<IFilterUI>();
<<<<<<<
var snapping = obj as ISnapping;
if (snapping != null)
{
snapping.onSnapEnded = m_SnappingModule.OnSnapEnded;
snapping.onSnapHeld = m_SnappingModule.OnSnapHeld;
snapping.onSnapStarted = m_SnappingModule.OnSnapStarted;
snapping.onSnapUpdate = m_SnappingModule.OnSnapUpdate;
}
var mainMenu = obj as IMainMenu;
=======
var folderList = obj as IProjectFolderList;
if (folderList != null)
folderList.getFolderData = GetFolderData;
var filterUI = obj as IFilterUI;
if (filterUI != null)
filterUI.getFilterList = GetFilterList;
>>>>>>>
var snapping = obj as ISnapping;
if (snapping != null)
{
snapping.onSnapEnded = m_SnappingModule.OnSnapEnded;
snapping.onSnapHeld = m_SnappingModule.OnSnapHeld;
snapping.onSnapStarted = m_SnappingModule.OnSnapStarted;
snapping.onSnapUpdate = m_SnappingModule.OnSnapUpdate;
}
var folderList = obj as IProjectFolderList;
if (folderList != null)
folderList.getFolderData = GetFolderData;
var filterUI = obj as IFilterUI;
if (filterUI != null)
filterUI.getFilterList = GetFilterList;
var mainMenu = obj as IMainMenu;
<<<<<<<
bool PreProcessRaycastSources()
{
if (!m_Manipulator)
m_Manipulator = GetComponentInChildren<StandardManipulator>();
if (m_Manipulator)
m_OriginalManipulatorScale = m_Manipulator.transform.localScale;
return true;
}
bool PreProcessRaycastSource(Transform rayOrigin)
{
if (m_Manipulator)
{
MiniWorldRay ray;
if (m_MiniWorldRays.TryGetValue(rayOrigin, out ray))
m_Manipulator.transform.localScale = ray.miniWorld.miniWorldScale * kMiniWorldManipulatorScale;
else
m_Manipulator.transform.localScale = m_OriginalManipulatorScale;
}
return true;
}
void PostProcessRaycastSources()
{
if (m_Manipulator)
m_Manipulator.transform.localScale = m_OriginalManipulatorScale;
}
bool PreProcessMiniWorldRender(IMiniWorld miniWorld)
{
if (m_Manipulator)
m_Manipulator.transform.localScale = miniWorld.miniWorldScale * kMiniWorldManipulatorScale;
return true;
}
void PostProcessMiniWorldRender(IMiniWorld miniWorld)
{
if (m_Manipulator)
m_Manipulator.transform.localScale = m_OriginalManipulatorScale;
}
=======
List<string> GetFilterList()
{
return m_AssetTypes.ToList();
}
FolderData[] GetFolderData()
{
if (m_FolderData == null)
return null;
var assetsFolder = new FolderData(m_FolderData[0]) { expanded = true };
return new[] { assetsFolder };
}
IEnumerator LoadProjectFolders(bool quickStart = true)
{
FolderDataIteration iteration = null;
if (quickStart)
{
//Start with a quick pass to get assets without types
foreach (var e in CreateFolderData())
{
iteration = e;
}
m_FolderData = new[] { iteration.data };
yield return null;
}
m_AssetTypes.Clear();
//Create a new list with actual types
foreach (var e in CreateFolderData(m_AssetTypes))
{
iteration = e;
yield return null;
}
m_FolderData = new[] { iteration.data };
// Send new data to existing folderLists
foreach (var list in m_ProjectFolderLists)
{
list.folderData = GetFolderData();
}
// Send new data to existing filterUIs
foreach (var filterUI in m_FilterUIs)
{
filterUI.filterList = GetFilterList();
}
}
// Call with no assetTypes for quick load (and no types)
IEnumerable<FolderDataIteration> CreateFolderData(HashSet<string> assetTypes = null, bool hasNext = true, HierarchyProperty hp = null)
{
if (hp == null)
{
hp = new HierarchyProperty(HierarchyType.Assets);
hp.SetSearchFilter("t:object", 0);
}
var name = hp.name;
var instanceID = hp.instanceID;
var depth = hp.depth;
var folderList = new List<FolderData>();
var assetList = new List<AssetData>();
if (hasNext)
{
hasNext = hp.Next(null);
while (hasNext && hp.depth > depth)
{
if (hp.isFolder)
{
FolderDataIteration folder = null;
foreach (var e in CreateFolderData(assetTypes, hasNext, hp))
{
folder = e;
if (assetTypes != null)
yield return e;
}
folderList.Add(folder.data);
hasNext = folder.hasNext;
}
else if (hp.isMainRepresentation) // Ignore sub-assets (mixer children, terrain splats, etc.)
assetList.Add(CreateAssetData(hp, assetTypes));
if (hasNext)
hasNext = hp.Next(null);
if (assetTypes != null && Time.realtimeSinceStartup - m_LastFolderYieldTime > kMaxFrameTime)
{
m_LastFolderYieldTime = Time.realtimeSinceStartup;
yield return null;
}
}
if (hasNext)
hp.Previous(null);
}
yield return new FolderDataIteration
{
data = new FolderData(name, folderList.Count > 0 ? folderList.ToArray() : null, assetList.ToArray(), instanceID),
hasNext = hasNext
};
}
AssetData CreateAssetData(HierarchyProperty hp, HashSet<string> assetTypes = null)
{
var type = "";
if (assetTypes != null)
{
type = hp.pptrValue.GetType().Name;
switch (type)
{
case "GameObject":
switch (PrefabUtility.GetPrefabType(EditorUtility.InstanceIDToObject(hp.instanceID)))
{
case PrefabType.ModelPrefab:
type = "Model";
break;
default:
type = "Prefab";
break;
}
break;
case "MonoScript":
type = "Script";
break;
case "SceneAsset":
type = "Scene";
break;
case "AudioMixerController":
type = "AudioMixer";
break;
}
assetTypes.Add(type);
}
return new AssetData(hp.name, hp.instanceID, hp.icon, type);
}
>>>>>>>
bool PreProcessRaycastSources()
{
if (!m_Manipulator)
m_Manipulator = GetComponentInChildren<StandardManipulator>();
if (m_Manipulator)
m_OriginalManipulatorScale = m_Manipulator.transform.localScale;
return true;
}
bool PreProcessRaycastSource(Transform rayOrigin)
{
if (m_Manipulator)
{
MiniWorldRay ray;
if (m_MiniWorldRays.TryGetValue(rayOrigin, out ray))
m_Manipulator.transform.localScale = ray.miniWorld.miniWorldScale * kMiniWorldManipulatorScale;
else
m_Manipulator.transform.localScale = m_OriginalManipulatorScale;
}
return true;
}
void PostProcessRaycastSources()
{
if (m_Manipulator)
m_Manipulator.transform.localScale = m_OriginalManipulatorScale;
}
bool PreProcessMiniWorldRender(IMiniWorld miniWorld)
{
if (m_Manipulator)
m_Manipulator.transform.localScale = miniWorld.miniWorldScale * kMiniWorldManipulatorScale;
return true;
}
void PostProcessMiniWorldRender(IMiniWorld miniWorld)
{
if (m_Manipulator)
m_Manipulator.transform.localScale = m_OriginalManipulatorScale;
}
List<string> GetFilterList()
{
return m_AssetTypes.ToList();
}
FolderData[] GetFolderData()
{
if (m_FolderData == null)
return null;
var assetsFolder = new FolderData(m_FolderData[0]) { expanded = true };
return new[] { assetsFolder };
}
IEnumerator LoadProjectFolders(bool quickStart = true)
{
FolderDataIteration iteration = null;
if (quickStart)
{
//Start with a quick pass to get assets without types
foreach (var e in CreateFolderData())
{
iteration = e;
}
m_FolderData = new[] { iteration.data };
yield return null;
}
m_AssetTypes.Clear();
//Create a new list with actual types
foreach (var e in CreateFolderData(m_AssetTypes))
{
iteration = e;
yield return null;
}
m_FolderData = new[] { iteration.data };
// Send new data to existing folderLists
foreach (var list in m_ProjectFolderLists)
{
list.folderData = GetFolderData();
}
// Send new data to existing filterUIs
foreach (var filterUI in m_FilterUIs)
{
filterUI.filterList = GetFilterList();
}
}
// Call with no assetTypes for quick load (and no types)
IEnumerable<FolderDataIteration> CreateFolderData(HashSet<string> assetTypes = null, bool hasNext = true, HierarchyProperty hp = null)
{
if (hp == null)
{
hp = new HierarchyProperty(HierarchyType.Assets);
hp.SetSearchFilter("t:object", 0);
}
var name = hp.name;
var instanceID = hp.instanceID;
var depth = hp.depth;
var folderList = new List<FolderData>();
var assetList = new List<AssetData>();
if (hasNext)
{
hasNext = hp.Next(null);
while (hasNext && hp.depth > depth)
{
if (hp.isFolder)
{
FolderDataIteration folder = null;
foreach (var e in CreateFolderData(assetTypes, hasNext, hp))
{
folder = e;
if (assetTypes != null)
yield return e;
}
folderList.Add(folder.data);
hasNext = folder.hasNext;
}
else if (hp.isMainRepresentation) // Ignore sub-assets (mixer children, terrain splats, etc.)
assetList.Add(CreateAssetData(hp, assetTypes));
if (hasNext)
hasNext = hp.Next(null);
if (assetTypes != null && Time.realtimeSinceStartup - m_LastFolderYieldTime > kMaxFrameTime)
{
m_LastFolderYieldTime = Time.realtimeSinceStartup;
yield return null;
}
}
if (hasNext)
hp.Previous(null);
}
yield return new FolderDataIteration
{
data = new FolderData(name, folderList.Count > 0 ? folderList.ToArray() : null, assetList.ToArray(), instanceID),
hasNext = hasNext
};
}
AssetData CreateAssetData(HierarchyProperty hp, HashSet<string> assetTypes = null)
{
var type = "";
if (assetTypes != null)
{
type = hp.pptrValue.GetType().Name;
switch (type)
{
case "GameObject":
switch (PrefabUtility.GetPrefabType(EditorUtility.InstanceIDToObject(hp.instanceID)))
{
case PrefabType.ModelPrefab:
type = "Model";
break;
default:
type = "Prefab";
break;
}
break;
case "MonoScript":
type = "Script";
break;
case "SceneAsset":
type = "Scene";
break;
case "AudioMixerController":
type = "AudioMixer";
break;
}
assetTypes.Add(type);
}
return new AssetData(hp.name, hp.instanceID, hp.icon, type);
} |
<<<<<<<
using UnityEngine.InputNew;
=======
using Button = UnityEngine.UI.Button;
>>>>>>>
using Button = UnityEngine.UI.Button;
using UnityEngine.InputNew;
<<<<<<<
private GameObject m_ZoomSliderPrefab;
public ActionMap actionMap { get { return m_MiniWorldActionMap; } }
[SerializeField]
ActionMap m_MiniWorldActionMap;
=======
private GameObject m_ZoomSliderPrefab;
>>>>>>>
private GameObject m_ZoomSliderPrefab;
public ActionMap actionMap { get { return m_MiniWorldActionMap; } }
[SerializeField]
ActionMap m_MiniWorldActionMap;
<<<<<<<
// Set up Zoom Slider
var sliderObject = U.Object.Instantiate(m_ZoomSliderPrefab, m_WorkspaceUI.frontPanel, false);
m_ZoomSliderUI = sliderObject.GetComponentInChildren<ZoomSliderUI>();
=======
// Set up ControlBox
var panZoomHandle = m_MiniWorldUI.panZoomHandle;
// ControlBox shouldn't move with miniWorld
panZoomHandle.transform.parent = m_WorkspaceUI.sceneContainer;
panZoomHandle.transform.localPosition = Vector3.down * panZoomHandle.transform.localScale.y * 0.5f;
panZoomHandle.dragStarted += OnPanZoomDragStarted;
panZoomHandle.dragging += OnPanZoomDragging;
panZoomHandle.dragEnded += OnPanZoomDragEnded;
panZoomHandle.hoverStarted += OnPanZoomHoverStarted;
panZoomHandle.hoverEnded += OnPanZoomHoverEnded;
// Set up Zoom Slider
var sliderObject = U.Object.Instantiate(m_ZoomSliderPrefab, m_WorkspaceUI.frontPanel, false);
m_ZoomSliderUI = sliderObject.GetComponentInChildren<ZoomSliderUI>();
>>>>>>>
// Set up Zoom Slider
var sliderObject = U.Object.Instantiate(m_ZoomSliderPrefab, m_WorkspaceUI.frontPanel, false);
m_ZoomSliderUI = sliderObject.GetComponentInChildren<ZoomSliderUI>(); |
<<<<<<<
var directSelection = evr.GetNestedModule<DirectSelection>();
var pinnedTools = evr.GetNestedModule<PinnedToolButtons>();
=======
>>>>>>>
var pinnedTools = evr.GetNestedModule<PinnedToolButtons>(); |
<<<<<<<
ITransformer m_Transformer;
IGrabObject m_ObjectGrabber;
=======
IGrabObject m_ObjectGrabber;
>>>>>>>
ITransformer m_Transformer;
IGrabObject m_ObjectGrabber;
<<<<<<<
readonly List<SelectionInput> m_SelectionInputs = new List<SelectionInput>();
byte stencilRef
{
get { return m_StencilRef; }
set
=======
byte stencilRef
>>>>>>>
readonly List<SelectionInput> m_SelectionInputs = new List<SelectionInput>();
byte stencilRef
<<<<<<<
private void SpawnDefaultTools()
{
// Spawn default tools
HashSet<InputDevice> devices;
ToolData toolData;
var transformTool = SpawnTool(typeof(TransformTool), out devices);
m_ObjectGrabber = transformTool.tool as IGrabObject;
m_Transformer = transformTool.tool as ITransformer;
foreach (var deviceDataPair in m_DeviceData)
{
var inputDevice = deviceDataPair.Key;
var deviceData = deviceDataPair.Value;
// Skip keyboard, mouse, gamepads. Selection, blink, and vacuum tools should only be on left and right hands (tagged 0 and 1)
if (inputDevice.tagIndex == -1)
continue;
toolData = SpawnTool(typeof(SelectionTool), out devices, inputDevice);
AddToolToDeviceData(toolData, devices);
var selectionTool = (SelectionTool)toolData.tool;
selectionTool.selected += SetLastSelectionRayOrigin; // when a selection occurs in the selection tool, call show in the alternate menu, allowing it to show/hide itself.
selectionTool.hovered += m_LockModule.OnHovered;
selectionTool.isRayActive = IsRayActive;
m_SelectionInputs.Add((SelectionInput)toolData.input);
toolData = SpawnTool(typeof(VacuumTool), out devices, inputDevice);
AddToolToDeviceData(toolData, devices);
var vacuumTool = (VacuumTool)toolData.tool;
vacuumTool.defaultOffset = kDefaultWorkspaceOffset;
vacuumTool.vacuumables = m_Vacuumables;
// Using a shared instance of the transform tool across all device tool stacks
AddToolToStack(inputDevice, transformTool);
toolData = SpawnTool(typeof(BlinkLocomotionTool), out devices, inputDevice);
AddToolToDeviceData(toolData, devices);
var mainMenuActivator = SpawnMainMenuActivator(inputDevice);
deviceData.mainMenuActivator = mainMenuActivator;
mainMenuActivator.selected += OnMainMenuActivatorSelected;
mainMenuActivator.hoverStarted += OnMainMenuActivatorHoverStarted;
mainMenuActivator.hoverEnded += OnMainMenuActivatorHoverEnded;
var pinnedToolButton = SpawnPinnedToolButton(inputDevice);
deviceData.previousToolButton = pinnedToolButton;
var pinnedToolButtonTransform = pinnedToolButton.transform;
pinnedToolButtonTransform.SetParent(mainMenuActivator.transform, false);
pinnedToolButtonTransform.localPosition = new Vector3(0f, 0f, -0.035f); // Offset from the main menu activator
var alternateMenu = SpawnAlternateMenu(typeof(RadialMenu), inputDevice, out deviceData.alternateMenuInput);
deviceData.alternateMenu = alternateMenu;
deviceData.menuHideFlags[alternateMenu] = MenuHideFlags.Hidden;
alternateMenu.itemWasSelected += UpdateAlternateMenuOnSelectionChanged;
=======
toolMaps.Add(t, actionMaps);
>>>>>>>
toolMaps.Add(t, actionMaps); |
<<<<<<<
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
using System;
using System.Collections.Generic;
using System.Linq;
using Newtonsoft.Json;
namespace Microsoft.Bot.Builder.Ai.Luis
{
/// <summary>
/// Type for LUIS builtin_datetime.
/// </summary>
/// <remarks>
/// LUIS recognizes time expressions like "next monday" and converts those to a type and set of timex expressions.
/// More information on timex can be found here: http://www.timeml.org/publications/timeMLdocs/timeml_1.2.1.html#timex3.
/// More information on the library which does the recognition can be found here: https://github.com/Microsoft/Recognizers-Text.
/// </remarks>
public class DateTimeSpec
{
/// <summary>
/// Initializes a new instance of the <see cref="DateTimeSpec"/> class.
/// </summary>
/// <param name="type">Type of time expression, <see cref="Type"/>.</param>
/// <param name="expressions">Sequence of timex expressions <see cref="DateTimeSpec"/>.</param>
public DateTimeSpec(string type, IEnumerable<string> expressions)
{
if (string.IsNullOrWhiteSpace(type))
{
throw new ArgumentNullException(nameof(type));
}
if (expressions == null)
{
throw new ArgumentNullException(nameof(expressions));
}
Type = type;
Expressions = expressions.ToList();
}
/// <summary>
/// Gets type of expression.
/// </summary>
/// <remarks>Example types include:
/// <list type="*">
/// <item>time -- simple time expression like "3pm".</item>
/// <item>date -- simple date like "july 3rd".</item>
/// <item>datetime -- combination of date and time like "march 23 2pm".</item>
/// <item>timerange -- a range of time like "2pm to 4pm".</item>
/// <item>daterange -- a range of dates like "march 23rd to 24th".</item>
/// <item>datetimerang -- a range of dates and times like "july 3rd 2pm to 5th 4pm".</item>
/// <item>set -- a recurrence like "every monday".</item>
/// </list>
/// </remarks>
/// <value>
/// The type of expression.
/// </value>
[JsonProperty("type")]
public string Type { get; }
/// <summary>
/// Gets Timex expressions.
/// </summary>
/// <value>
/// Timex expressions.
/// </value>
[JsonProperty("timex")]
public IReadOnlyList<string> Expressions { get; }
/// <inheritdoc/>
public override string ToString() => $"DateTimeSpec({Type}, [{string.Join(", ", Expressions)}]";
}
}
=======
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
using System;
using System.Collections.Generic;
using System.Linq;
using Newtonsoft.Json;
namespace Microsoft.Bot.Builder.Ai.LUIS
{
/// <summary>
/// Represents the built-in LUIS date-time type.
/// </summary>
/// <remarks>
/// LUIS recognizes time expressions like "next monday" and converts those to a type and set of timex expressions.
/// More information on timex can be found here: http://www.timeml.org/publications/timeMLdocs/timeml_1.2.1.html#timex3
/// More information on the library which does the recognition can be found here: https://github.com/Microsoft/Recognizers-Text.
/// </remarks>
public class DateTimeSpec
{
/// <summary>
/// Initializes a new instance of the <see cref="DateTimeSpec"/> class.
/// </summary>
/// <param name="type">The type of TIMEX expression.</param>
/// <param name="expressions">The TIMEX expression.</param>
/// <exception cref="ArgumentNullException"><paramref name="type"/> is null or contains only white space,
/// or <paramref name="expressions"/> is null.</exception>
public DateTimeSpec(string type, IEnumerable<string> expressions)
{
if (string.IsNullOrWhiteSpace(type))
{
throw new ArgumentNullException(nameof(type));
}
if (expressions == null)
{
throw new ArgumentNullException(nameof(expressions));
}
Type = type;
Expressions = expressions.ToList();
}
/// <summary>
/// Gets the type of expression.
/// </summary>
/// <remarks>Example types include:
/// <list type="*">
/// <item>time -- simple time expression like "3pm".</item>
/// <item>date -- simple date like "july 3rd".</item>
/// <item>datetime -- combination of date and time like "march 23 2pm".</item>
/// <item>timerange -- a range of time like "2pm to 4pm".</item>
/// <item>daterange -- a range of dates like "march 23rd to 24th".</item>
/// <item>datetimerang -- a range of dates and times like "july 3rd 2pm to 5th 4pm".</item>
/// <item>set -- a recurrence like "every monday".</item>
/// </list>
/// </remarks>
/// <value>
/// The type of expression.
/// </value>
[JsonProperty("type")]
public string Type { get; }
/// <summary>
/// Gets timex expressions.
/// </summary>
/// <value>
/// Timex expressions.
/// </value>
[JsonProperty("timex")]
public IList<string> Expressions { get; }
/// <inheritdoc/>
public override string ToString() => $"DateTimeSpec({Type}, [{string.Join(", ", Expressions)}]";
}
}
>>>>>>>
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
using System;
using System.Collections.Generic;
using System.Linq;
using Newtonsoft.Json;
namespace Microsoft.Bot.Builder.Ai.Luis
{
/// <summary>
/// Represents the built-in LUIS date-time type.
/// </summary>
/// <remarks>
/// LUIS recognizes time expressions like "next monday" and converts those to a type and set of timex expressions.
/// More information on timex can be found here: http://www.timeml.org/publications/timeMLdocs/timeml_1.2.1.html#timex3.
/// More information on the library which does the recognition can be found here: https://github.com/Microsoft/Recognizers-Text.
/// </remarks>
public class DateTimeSpec
{
/// <summary>
/// Initializes a new instance of the <see cref="DateTimeSpec"/> class.
/// </summary>
/// <param name="type">The type of TIMEX expression.</param>
/// <param name="expressions">The TIMEX expression.</param>
/// <exception cref="ArgumentNullException"><paramref name="type"/> is null or contains only white space,
/// or <paramref name="expressions"/> is null.</exception>
public DateTimeSpec(string type, IEnumerable<string> expressions)
{
if (string.IsNullOrWhiteSpace(type))
{
throw new ArgumentNullException(nameof(type));
}
if (expressions == null)
{
throw new ArgumentNullException(nameof(expressions));
}
Type = type;
Expressions = expressions.ToList();
}
/// <summary>
/// Gets type of expression.
/// </summary>
/// <remarks>Example types include:
/// <list type="*">
/// <item>time -- simple time expression like "3pm".</item>
/// <item>date -- simple date like "july 3rd".</item>
/// <item>datetime -- combination of date and time like "march 23 2pm".</item>
/// <item>timerange -- a range of time like "2pm to 4pm".</item>
/// <item>daterange -- a range of dates like "march 23rd to 24th".</item>
/// <item>datetimerang -- a range of dates and times like "july 3rd 2pm to 5th 4pm".</item>
/// <item>set -- a recurrence like "every monday".</item>
/// </list>
/// </remarks>
/// <value>
/// The type of expression.
/// </value>
[JsonProperty("type")]
public string Type { get; }
/// <summary>
/// Gets Timex expressions.
/// </summary>
/// <value>
/// Timex expressions.
/// </value>
[JsonProperty("timex")]
public IReadOnlyList<string> Expressions { get; }
/// <inheritdoc/>
public override string ToString() => $"DateTimeSpec({Type}, [{string.Join(", ", Expressions)}]";
}
} |
<<<<<<<
bool leftAffordanceRenderersVisible { set { m_LeftProxyHelper.affordanceRenderersVisible = value; } }
bool rightAffordanceRenderersVisible { set { m_RightProxyHelper.affordanceRenderersVisible = value; } }
bool leftBodyRenderersVisible { set { m_LeftProxyHelper.bodyRenderersVisible = value; } }
bool rightBodyRenderersVisible { set { m_RightProxyHelper.bodyRenderersVisible = value; } }
=======
// Local method use only -- created here to reduce garbage collection
static readonly List<Tooltip> k_TooltipList = new List<Tooltip>();
>>>>>>>
bool leftAffordanceRenderersVisible { set { m_LeftProxyHelper.affordanceRenderersVisible = value; } }
bool rightAffordanceRenderersVisible { set { m_RightProxyHelper.affordanceRenderersVisible = value; } }
bool leftBodyRenderersVisible { set { m_LeftProxyHelper.bodyRenderersVisible = value; } }
bool rightBodyRenderersVisible { set { m_RightProxyHelper.bodyRenderersVisible = value; } }
// Local method use only -- created here to reduce garbage collection
static readonly List<Tooltip> k_TooltipList = new List<Tooltip>();
<<<<<<<
foreach (var proxyNode in m_Affordances)
=======
if (!active)
return;
foreach (var proxyNode in m_Buttons)
>>>>>>>
if (!active)
return;
foreach (var proxyNode in m_Affordances)
<<<<<<<
var node = req.node;
var matchChanged = node == changedRequest.node && req.control == changedRequest.control;
var matchButton = node == proxyNode.Key && req.control == kvp.Key;
var sameCaller = req.caller == changedRequest.caller;
var priority = request == null || req.priority >= request.priority;
if (matchButton && priority && (matchChanged || sameCaller))
=======
if (req.node != proxyNode.Key || req.control != kvp.Key)
continue;
if (request == null || req.priority >= request.priority)
>>>>>>>
if (req.node != proxyNode.Key || req.control != kvp.Key)
continue;
if (request == null || req.priority >= request.priority) |
<<<<<<<
var recognizedIntents = context.Services.Get<IRecognizedIntents>();
switch (context.Request.Type)
=======
var recognizedIntents = context.Get<IRecognizedIntents>();
switch (context.Activity.Type)
>>>>>>>
var recognizedIntents = context.Services.Get<IRecognizedIntents>();
switch (context.Activity.Type) |
<<<<<<<
using UnityEngine.VR.Data;
=======
using UnityEngine.VR;
using UnityEngine.VR.Menus;
using UnityEngine.VR.Modules;
>>>>>>>
using UnityEngine.VR.Data;
using UnityEngine.VR;
using UnityEngine.VR.Menus;
using UnityEngine.VR.Modules; |
<<<<<<<
var localScale = transform.localScale;
var aspect = localScale.x/localScale.y;
localScale.y *= aspect/texAspect;
transform.localScale = localScale;
}
=======
var localScale = transform.localScale;
if (m_LockAspect)
{
var aspect = localScale.x / localScale.y;
localScale.y *= aspect / texAspect;
}
transform.localScale = localScale;
>>>>>>>
var localScale = transform.localScale;
if (m_LockAspect)
{
var aspect = localScale.x / localScale.y;
localScale.y *= aspect / texAspect;
}
transform.localScale = localScale;
} |
<<<<<<<
b.button.onClick.AddListener(() =>
{
var provider = settingsMenuProviders[selectedType];
provider.settingsMenuInstance = m_MainMenuUI.AddSubmenu(buttonData.sectionName, provider.settingsMenuPrefab);
});
}
});
}
=======
var provider = settingsMenuProviders[selectedType];
provider.settingsMenuInstance = m_MainMenuUI.AddSubmenu(buttonData.sectionName, provider.settingsMenuPrefab);
});
}
if (customMenuAttribute != null && customMenuAttribute.tooltip != null)
b.tooltipText = customMenuAttribute.tooltip.tooltipText;
});
>>>>>>>
b.button.onClick.AddListener(() =>
{
var provider = settingsMenuProviders[selectedType];
provider.settingsMenuInstance = m_MainMenuUI.AddSubmenu(buttonData.sectionName, provider.settingsMenuPrefab);
});
}
if (customMenuAttribute != null && customMenuAttribute.tooltip != null)
b.tooltipText = customMenuAttribute.tooltip.tooltipText;
});
} |
<<<<<<<
// TODO: Uncomment IBlockUIInput after merge with dev/schoen/bugfix-b
public class SelectionTool : MonoBehaviour, ITool, IRay, IRaycaster, ICustomActionMap, IHighlight, IMenuOrigins //, IBlockUIInput
=======
public class SelectionTool : MonoBehaviour, ITool, IRay, IRaycaster, ICustomActionMap, IHighlight, IMenuOrigins, ILocking
>>>>>>>
public class SelectionTool : MonoBehaviour, ITool, IRay, IRaycaster, ICustomActionMap, IHighlight, IMenuOrigins, ILocking
<<<<<<<
=======
public Func<Transform, GameObject> getFirstGameObject { private get; set; }
public Transform rayOrigin { private get; set; }
public Action<GameObject, bool> setHighlight { private get; set; }
public Transform menuOrigin { get; set; }
public Node? node { private get; set; }
public Func<bool> toggleLocked { get; set; }
public Func<GameObject, bool> getLocked { get; set; }
public Action<GameObject, Node?> checkHover { get; set; }
>>>>>>>
<<<<<<<
if (newPrefabRoot)
{
if (newPrefabRoot != s_CurrentPrefabOpened)
newHoverGameObject = newPrefabRoot;
}
=======
if (newPrefabRoot != s_CurrentPrefabOpened)
newHoverGameObject = newPrefabRoot;
if (newHoverGameObject.isStatic)
return;
>>>>>>>
if (newPrefabRoot)
{
if (newPrefabRoot != s_CurrentPrefabOpened)
newHoverGameObject = newPrefabRoot;
}
if (newHoverGameObject.isStatic)
return; |
<<<<<<<
using UnityEngine.VR.Actions;
=======
using UnityEngine.VR.Helpers;
>>>>>>>
using UnityEngine.VR.Actions;
using UnityEngine.VR.Helpers;
<<<<<<<
const string kShowInMiniWorldTag = "ShowInMiniWorld";
=======
/// <summary>
/// Tag applied to player head model which tracks the camera (for MiniWorld locomotion)
/// </summary>
const string kVRPlayerTag = "VRPlayer";
>>>>>>>
const string kShowInMiniWorldTag = "ShowInMiniWorld";
/// <summary>
/// Tag applied to player head model which tracks the camera (for MiniWorld locomotion)
/// </summary>
const string kVRPlayerTag = "VRPlayer";
<<<<<<<
public MainMenuActivator mainMenuActivator;
=======
public ActionMapInput directSelectInput;
>>>>>>>
public MainMenuActivator mainMenuActivator;
public ActionMapInput directSelectInput;
<<<<<<<
VRSmoothCamera m_SmoothCamera;
=======
IGrabObjects m_TransformTool;
>>>>>>>
VRSmoothCamera m_SmoothCamera;
IGrabObjects m_TransformTool;
<<<<<<<
while (!m_HMDReady)
yield return null;
// In case we have anything selected at start, set up manipulators, inspector, etc.
EditorApplication.delayCall += OnSelectionChanged;
=======
>>>>>>>
while (!m_HMDReady)
yield return null;
// In case we have anything selected at start, set up manipulators, inspector, etc.
EditorApplication.delayCall += OnSelectionChanged;
<<<<<<<
var toolActions = obj as IToolActions;
if (toolActions != null)
{
var actions = toolActions.toolActions;
foreach (var action in actions)
{
var actionMenuData = new ActionMenuData()
{
name = action.GetType().Name,
sectionName = ActionMenuItemAttribute.kDefaultActionSectionName,
priority = int.MaxValue,
action = action,
};
m_MenuActions.Add(actionMenuData);
}
UpdateAlternateMenuActions();
}
var mainMenu = obj as IMainMenu;
=======
var directSelection = obj as IDirectSelection;
if (directSelection != null)
directSelection.getDirectSelection = GetDirectSelection;
var grabObjects = obj as IGrabObjects;
if (grabObjects != null)
{
grabObjects.canGrabObject = CanGrabObject;
grabObjects.grabObject = GrabObject;
grabObjects.dropObject = DropObject;
}
>>>>>>>
var toolActions = obj as IToolActions;
if (toolActions != null)
{
var actions = toolActions.toolActions;
foreach (var action in actions)
{
var actionMenuData = new ActionMenuData()
{
name = action.GetType().Name,
sectionName = ActionMenuItemAttribute.kDefaultActionSectionName,
priority = int.MaxValue,
action = action,
};
m_MenuActions.Add(actionMenuData);
}
UpdateAlternateMenuActions();
}
var directSelection = obj as IDirectSelection;
if (directSelection != null)
directSelection.getDirectSelection = GetDirectSelection;
var grabObjects = obj as IGrabObjects;
if (grabObjects != null)
{
grabObjects.canGrabObject = CanGrabObject;
grabObjects.grabObject = GrabObject;
grabObjects.dropObject = DropObject;
}
var mainMenu = obj as IMainMenu;
<<<<<<<
// Update ignore list
var renderers = GetComponentsInChildren<Renderer>(true);
var ignoreList = new List<Renderer>(renderers.Length);
foreach (var renderer in renderers)
{
// TODO: Uncomment this when dev/schoen/bugfix-b lands
//if (renderer.tag == kVRPlayer)
// continue;
if (renderer.tag == kShowInMiniWorldTag)
continue;
ignoreList.Add(renderer);
}
foreach (var miniWorld in m_MiniWorlds)
{
miniWorld.ignoreList = ignoreList;
}
// Update MiniWorldRays
=======
var directSelection = m_TransformTool;
>>>>>>>
// Update ignore list
var renderers = GetComponentsInChildren<Renderer>(true);
var ignoreList = new List<Renderer>(renderers.Length);
foreach (var renderer in renderers)
{
if (renderer.tag == kVRPlayerTag)
continue;
if (renderer.tag == kShowInMiniWorldTag)
continue;
ignoreList.Add(renderer);
}
var directSelection = m_TransformTool;
foreach (var miniWorld in m_MiniWorlds)
{
miniWorld.ignoreList = ignoreList;
}
// Update MiniWorldRays
<<<<<<<
bool IsMiniWorldRay(Transform rayOrigin)
{
return m_MiniWorldRays.ContainsKey(rayOrigin);
}
=======
void AddPlayerModel()
{
var playerModel = U.Object.Instantiate(m_PlayerModelPrefab, U.Camera.GetMainCamera().transform, false).GetComponent<Renderer>();
m_SpatialHashModule.spatialHash.AddObject(playerModel, playerModel.bounds);
}
>>>>>>>
bool IsMiniWorldRay(Transform rayOrigin)
{
return m_MiniWorldRays.ContainsKey(rayOrigin);
}
void AddPlayerModel()
{
var playerModel = U.Object.Instantiate(m_PlayerModelPrefab, U.Camera.GetMainCamera().transform, false).GetComponent<Renderer>();
m_SpatialHashModule.spatialHash.AddObject(playerModel, playerModel.bounds);
} |
<<<<<<<
var moveWorkspaces = obj as IMoveWorkspaces;
if (moveWorkspaces != null)
moveWorkspaces.resetWorkspaces = ResetWorkspacePositions;
var placeObjects = obj as IPlaceObjects;
=======
var placeObjects = obj as IPlaceObject;
>>>>>>>
var moveWorkspaces = obj as IMoveWorkspaces;
if (moveWorkspaces != null)
moveWorkspaces.resetWorkspaces = ResetWorkspacePositions;
var placeObjects = obj as IPlaceObject; |
<<<<<<<
// Assign pinned tool button preview properties
b.toolType = selectedType;
b.previewToolInPinnedToolButton = previewToolInPinnedToolButton;
=======
if (customMenuAttribute != null && customMenuAttribute.tooltip != null)
b.tooltipText = customMenuAttribute.tooltip.tooltipText;
>>>>>>>
if (customMenuAttribute != null && customMenuAttribute.tooltip != null)
b.tooltipText = customMenuAttribute.tooltip.tooltipText;
// Assign pinned tool button preview properties
b.toolType = selectedType;
b.previewToolInPinnedToolButton = previewToolInPinnedToolButton; |
<<<<<<<
public event Action closeClicked = delegate { };
public event Action lockClicked = delegate { };
public event Action resetSizeClicked = delegate { };
=======
public event Action closeClicked = delegate {};
public event Action lockClicked = delegate {};
public event Action resetSizeClicked = delegate {};
>>>>>>>
public event Action closeClicked = delegate {};
public event Action lockClicked = delegate {};
public event Action resetSizeClicked = delegate {};
<<<<<<<
Vector3 m_OriginalFrontHandleLocalPosition;
=======
float m_HandleScale;
float m_FrontHandleYLocalPosition;
float m_BackHandleYLocalPosition;
float m_LeftHandleYLocalPosition;
float m_RightHandleYLocalPosition;
>>>>>>>
Vector3 m_OriginalFrontHandleLocalPosition;
<<<<<<<
public bool amplifyTopHighlight
{
set
{
this.StopCoroutine(ref m_TopFaceVisibleCoroutine);
m_TopFaceVisibleCoroutine = value ? StartCoroutine(HideTopFace()) : StartCoroutine(ShowTopFace());
}
}
=======
public bool amplifyTopHighlight
{
set
{
this.StopCoroutine(ref m_TopFaceVisibleCoroutine);
m_TopFaceVisibleCoroutine = value ? StartCoroutine(HideTopFace()) : StartCoroutine(ShowTopFace());
}
}
>>>>>>>
public bool amplifyTopHighlight
{
set
{
this.StopCoroutine(ref m_TopFaceVisibleCoroutine);
m_TopFaceVisibleCoroutine = value ? StartCoroutine(HideTopFace()) : StartCoroutine(ShowTopFace());
}
}
<<<<<<<
=======
// Resize handles
m_LeftHandleTransform.localPosition = new Vector3(-extents.x + m_HandleScale * 0.5f - kSideHandleOffset, m_LeftHandleYLocalPosition, 0);
m_LeftHandleTransform.localScale = preventLeftRightResize ? Vector3.zero : new Vector3(boundsSize.z, m_HandleScale, m_HandleScale);
m_FrontHandleTransform.localScale = preventFrontBackResize ? Vector3.zero : new Vector3(boundsSize.x, m_HandleScale, m_HandleScale);
m_RightHandleTransform.localPosition = new Vector3(extents.x - m_HandleScale * 0.5f + kSideHandleOffset, m_RightHandleYLocalPosition, 0);
m_RightHandleTransform.localScale = preventLeftRightResize ? Vector3.zero : new Vector3(boundsSize.z, m_HandleScale, m_HandleScale);
m_BackHandleTransform.localPosition = new Vector3(0, m_BackHandleYLocalPosition, extents.z - m_HandleScale - kBackHandleOffset);
m_BackHandleTransform.localScale = preventFrontBackResize ? Vector3.zero : new Vector3(boundsSize.x, m_HandleScale, m_HandleScale);
>>>>>>>
<<<<<<<
IEnumerator ShowTopFace()
{
const string kMaterialHighlightAlphaProperty = "_Alpha";
const float kTargetAlpha = 1f;
const float kTargetDuration = 0.35f;
var currentDuration = 0f;
var currentAlpha = m_TopFaceMaterial.GetFloat(kMaterialHighlightAlphaProperty);
var currentVelocity = 0f;
while (currentDuration < kTargetDuration)
{
currentDuration += Time.unscaledDeltaTime;
currentAlpha = U.Math.SmoothDamp(currentAlpha, kTargetAlpha, ref currentVelocity, kTargetDuration, Mathf.Infinity, Time.unscaledDeltaTime);
m_TopFaceMaterial.SetFloat(kMaterialHighlightAlphaProperty, currentAlpha);
yield return null;
}
m_TopFaceVisibleCoroutine = null;
}
IEnumerator HideTopFace()
{
const string kMaterialHighlightAlphaProperty = "_Alpha";
const float kTargetAlpha = 0f;
const float kTargetDuration = 0.2f;
var currentDuration = 0f;
var currentAlpha = m_TopFaceMaterial.GetFloat(kMaterialHighlightAlphaProperty);
var currentVelocity = 0f;
while (currentDuration < kTargetDuration)
{
currentDuration += Time.unscaledDeltaTime;
currentAlpha = U.Math.SmoothDamp(currentAlpha, kTargetAlpha, ref currentVelocity, kTargetDuration, Mathf.Infinity, Time.unscaledDeltaTime);
m_TopFaceMaterial.SetFloat(kMaterialHighlightAlphaProperty, currentAlpha);
yield return null;
}
m_TopFaceVisibleCoroutine = null;
}
=======
IEnumerator ShowTopFace()
{
const string kMaterialHighlightAlphaProperty = "_Alpha";
const float kTargetAlpha = 1f;
const float kTargetDuration = 0.35f;
var currentDuration = 0f;
var currentAlpha = m_TopFaceMaterial.GetFloat(kMaterialHighlightAlphaProperty);
var currentVelocity = 0f;
while (currentDuration < kTargetDuration)
{
currentDuration += Time.unscaledDeltaTime;
currentAlpha = U.Math.SmoothDamp(currentAlpha, kTargetAlpha, ref currentVelocity, kTargetDuration, Mathf.Infinity, Time.unscaledDeltaTime);
m_TopFaceMaterial.SetFloat(kMaterialHighlightAlphaProperty, currentAlpha);
yield return null;
}
m_TopFaceVisibleCoroutine = null;
}
IEnumerator HideTopFace()
{
const string kMaterialHighlightAlphaProperty = "_Alpha";
const float kTargetAlpha = 0f;
const float kTargetDuration = 0.2f;
var currentDuration = 0f;
var currentAlpha = m_TopFaceMaterial.GetFloat(kMaterialHighlightAlphaProperty);
var currentVelocity = 0f;
while (currentDuration < kTargetDuration)
{
currentDuration += Time.unscaledDeltaTime;
currentAlpha = U.Math.SmoothDamp(currentAlpha, kTargetAlpha, ref currentVelocity, kTargetDuration, Mathf.Infinity, Time.unscaledDeltaTime);
m_TopFaceMaterial.SetFloat(kMaterialHighlightAlphaProperty, currentAlpha);
yield return null;
}
m_TopFaceVisibleCoroutine = null;
}
>>>>>>>
IEnumerator ShowTopFace()
{
const string kMaterialHighlightAlphaProperty = "_Alpha";
const float kTargetAlpha = 1f;
const float kTargetDuration = 0.35f;
var currentDuration = 0f;
var currentAlpha = m_TopFaceMaterial.GetFloat(kMaterialHighlightAlphaProperty);
var currentVelocity = 0f;
while (currentDuration < kTargetDuration)
{
currentDuration += Time.unscaledDeltaTime;
currentAlpha = U.Math.SmoothDamp(currentAlpha, kTargetAlpha, ref currentVelocity, kTargetDuration, Mathf.Infinity, Time.unscaledDeltaTime);
m_TopFaceMaterial.SetFloat(kMaterialHighlightAlphaProperty, currentAlpha);
yield return null;
}
m_TopFaceVisibleCoroutine = null;
}
IEnumerator HideTopFace()
{
const string kMaterialHighlightAlphaProperty = "_Alpha";
const float kTargetAlpha = 0f;
const float kTargetDuration = 0.2f;
var currentDuration = 0f;
var currentAlpha = m_TopFaceMaterial.GetFloat(kMaterialHighlightAlphaProperty);
var currentVelocity = 0f;
while (currentDuration < kTargetDuration)
{
currentDuration += Time.unscaledDeltaTime;
currentAlpha = U.Math.SmoothDamp(currentAlpha, kTargetAlpha, ref currentVelocity, kTargetDuration, Mathf.Infinity, Time.unscaledDeltaTime);
m_TopFaceMaterial.SetFloat(kMaterialHighlightAlphaProperty, currentAlpha);
yield return null;
}
m_TopFaceVisibleCoroutine = null;
} |
<<<<<<<
// If we ever support multiple mini-worlds, then we could collect them all and render them in one loop here
m_RenderingMiniWorlds = true;
if (m_MainCamera && miniWorld)
{
m_MiniCamera.CopyFrom(m_MainCamera);
m_MiniCamera.cullingMask = cullingMask;
m_MiniCamera.clearFlags = CameraClearFlags.Nothing;
m_MiniCamera.worldToCameraMatrix = m_MainCamera.worldToCameraMatrix * miniWorld.miniToReferenceMatrix;
Shader shader = Shader.Find("Custom/Custom Clip Planes");
Shader.SetGlobalVector("_GlobalClipCenter", miniWorld.referenceBounds.center);
Shader.SetGlobalVector("_GlobalClipExtents", miniWorld.referenceBounds.extents);
for (var i = 0; i < m_IgnoreList.Count; i++)
{
var hiddenRenderer = m_IgnoreList[i];
m_RendererPreviousEnable[i] = hiddenRenderer.enabled;
hiddenRenderer.enabled = false;
}
m_MiniCamera.RenderWithShader(shader, string.Empty);
for (var i = 0; i < m_IgnoreList.Count; i++)
{
m_IgnoreList[i].enabled = m_RendererPreviousEnable[i];
}
}
m_RenderingMiniWorlds = false;
=======
m_MiniCamera.CopyFrom(m_MainCamera);
m_MiniCamera.cullingMask = cullingMask;
m_MiniCamera.clearFlags = CameraClearFlags.Nothing;
m_MiniCamera.worldToCameraMatrix = m_MainCamera.worldToCameraMatrix * miniWorld.miniToReferenceMatrix;
Shader shader = Shader.Find("Custom/Custom Clip Planes");
Shader.SetGlobalVector("_GlobalClipCenter", miniWorld.referenceBounds.center);
Shader.SetGlobalVector("_GlobalClipExtents", miniWorld.referenceBounds.extents);
m_MiniCamera.RenderWithShader(shader, string.Empty);
>>>>>>>
m_MiniCamera.CopyFrom(m_MainCamera);
m_MiniCamera.cullingMask = cullingMask;
m_MiniCamera.clearFlags = CameraClearFlags.Nothing;
m_MiniCamera.worldToCameraMatrix = m_MainCamera.worldToCameraMatrix * miniWorld.miniToReferenceMatrix;
Shader shader = Shader.Find("Custom/Custom Clip Planes");
Shader.SetGlobalVector("_GlobalClipCenter", miniWorld.referenceBounds.center);
Shader.SetGlobalVector("_GlobalClipExtents", miniWorld.referenceBounds.extents);
for (var i = 0; i < m_IgnoreList.Count; i++)
{
var hiddenRenderer = m_IgnoreList[i];
m_RendererPreviousEnable[i] = hiddenRenderer.enabled;
hiddenRenderer.enabled = false;
}
m_MiniCamera.RenderWithShader(shader, string.Empty);
for (var i = 0; i < m_IgnoreList.Count; i++)
{
m_IgnoreList[i].enabled = m_RendererPreviousEnable[i];
} |
<<<<<<<
public static GameObject ClonePrefab(GameObject prefab, GameObject parent = null)
{
GameObject obj = InstantiateAndSetActive(prefab);
if (parent != null) SetParent(obj, parent);
obj.transform.localPosition = new Vector3();
return obj;
}
=======
>>>>>>>
<<<<<<<
public static IEnumerable<Type> GetExtensionsOfClass(Type type)
{
if (type.IsClass)
{
return AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(s => s.GetTypes())
.Where(p => type.IsAssignableFrom(p) && !p.IsInterface && !p.IsAbstract);
}
return new List<Type>();
}
public static void Destroy(UObject o, float t = 0f)
=======
public static void Destroy(UnityObject o, float t = 0f)
>>>>>>>
public static IEnumerable<Type> GetExtensionsOfClass(Type type)
{
if (type.IsClass)
{
return AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(s => s.GetTypes())
.Where(p => type.IsAssignableFrom(p) && !p.IsInterface && !p.IsAbstract);
}
return new List<Type>();
}
public static void Destroy(UnityObject o, float t = 0f) |
<<<<<<<
public Func<Dictionary<Transform, DirectSelection>> getDirectSelection { private get; set; }
public Func<DirectSelection, Transform, bool> canGrabObject { private get; set; }
public Func<IGrabObjects, DirectSelection, Transform, bool> grabObject { private get; set; }
public Action<IGrabObjects, Transform, Transform> dropObject { private get; set; }
=======
public ActionMapInput actionMapInput { get { return m_TransformInput; } set { m_TransformInput = (TransformInput) value; } }
public Action<Transform, Vector3, Transform[]> onSnapStarted { private get; set; }
public Action<Transform, Vector3, Transform[]> onSnapEnded { private get; set; }
public Action<Transform, Vector3, Transform[]> onSnapHeld { private get; set; }
public Action<Transform> onSnapUpdate { private get; set; }
bool m_IsDragging;
private TransformInput m_TransformInput;
>>>>>>>
public Func<Dictionary<Transform, DirectSelection>> getDirectSelection { private get; set; }
public Func<DirectSelection, Transform, bool> canGrabObject { private get; set; }
public Func<IGrabObjects, DirectSelection, Transform, bool> grabObject { private get; set; }
public Action<IGrabObjects, Transform, Transform> dropObject { private get; set; }
public Action<Transform, Vector3, Transform[]> onSnapStarted { private get; set; }
public Action<Transform, Vector3, Transform[]> onSnapEnded { private get; set; }
public Action<Transform, Vector3, Transform[]> onSnapHeld { private get; set; }
public Action<Transform> onSnapUpdate { private get; set; }
bool m_IsDragging;
<<<<<<<
var manipulatorTransform = manipulatorGameObject.transform;
=======
var manipulatorTransform = m_CurrentManipulator.transform;
Vector3 prevPos = manipulatorTransform.position;
>>>>>>>
var manipulatorTransform = manipulatorGameObject.transform;
var prevPos = manipulatorTransform.position;
<<<<<<<
public void DropHeldObject(Transform obj)
{
Vector3 position;
Quaternion rotation;
DropHeldObject(obj, out position, out rotation);
}
public void DropHeldObject(Transform obj, out Vector3 positionOffset, out Quaternion rotationOffset)
{
foreach (var kvp in m_GrabData)
{
var grabData = kvp.Value;
if (grabData.grabbedObject == obj)
{
positionOffset = grabData.positionOffset;
rotationOffset = grabData.rotationOffset;
DropObject(kvp.Key);
return;
}
}
positionOffset = Vector3.zero;
rotationOffset = Quaternion.identity;
}
public Transform GetHeldObject(Transform rayOrigin)
{
foreach (var grabData in m_GrabData.Values)
{
if (grabData.rayOrigin == rayOrigin)
return grabData.grabbedObject;
}
return null;
}
public void TransferHeldObject(Transform rayOrigin, ActionMapInput input, Transform destRayOrigin, Vector3 deltaOffset)
{
foreach (var grabData in m_GrabData.Values)
{
if (grabData.rayOrigin == rayOrigin)
{
grabData.rayOrigin = destRayOrigin;
grabData.positionOffset += deltaOffset;
grabData.input = (DirectSelectInput)input;
grabData.PositionObject();
return;
}
}
}
public void AddHeldObject(Node node, Transform rayOrigin, Transform grabbedObject, ActionMapInput input)
{
m_GrabData[node] = new GrabData(rayOrigin, grabbedObject, (DirectSelectInput)input);
}
void DropObject(Node inputNode)
{
var grabData = m_GrabData[inputNode];
dropObject(this, grabData.grabbedObject, grabData.rayOrigin);
m_GrabData.Remove(inputNode);
}
=======
private void HandleSnap(IManipulator manipulator, Transform trans, Vector3 deltaMovement, Transform[] ignoreList)
{
if (manipulator != null)
{
if (manipulator.dragging)
{
if (!m_IsDragging)
{
m_IsDragging = true;
onSnapStarted(trans, deltaMovement, ignoreList);
}
else
onSnapHeld(trans, deltaMovement, ignoreList);
}
else
{
if (m_IsDragging)
{
m_IsDragging = false;
onSnapEnded(trans, deltaMovement, ignoreList);
}
else
onSnapUpdate(trans);
}
}
}
>>>>>>>
public void DropHeldObject(Transform obj)
{
Vector3 position;
Quaternion rotation;
DropHeldObject(obj, out position, out rotation);
}
public void DropHeldObject(Transform obj, out Vector3 positionOffset, out Quaternion rotationOffset)
{
foreach (var kvp in m_GrabData)
{
var grabData = kvp.Value;
if (grabData.grabbedObject == obj)
{
positionOffset = grabData.positionOffset;
rotationOffset = grabData.rotationOffset;
DropObject(kvp.Key);
return;
}
}
positionOffset = Vector3.zero;
rotationOffset = Quaternion.identity;
}
public Transform GetHeldObject(Transform rayOrigin)
{
foreach (var grabData in m_GrabData.Values)
{
if (grabData.rayOrigin == rayOrigin)
return grabData.grabbedObject;
}
return null;
}
public void TransferHeldObject(Transform rayOrigin, ActionMapInput input, Transform destRayOrigin, Vector3 deltaOffset)
{
foreach (var grabData in m_GrabData.Values)
{
if (grabData.rayOrigin == rayOrigin)
{
grabData.rayOrigin = destRayOrigin;
grabData.positionOffset += deltaOffset;
grabData.input = (DirectSelectInput)input;
grabData.PositionObject();
return;
}
}
}
public void AddHeldObject(Node node, Transform rayOrigin, Transform grabbedObject, ActionMapInput input)
{
m_GrabData[node] = new GrabData(rayOrigin, grabbedObject, (DirectSelectInput)input);
}
void DropObject(Node inputNode)
{
var grabData = m_GrabData[inputNode];
dropObject(this, grabData.grabbedObject, grabData.rayOrigin);
m_GrabData.Remove(inputNode);
}
private void HandleSnap(IManipulator manipulator, Transform trans, Vector3 deltaMovement, Transform[] ignoreList)
{
if (manipulator != null)
{
if (manipulator.dragging)
{
if (!m_IsDragging)
{
m_IsDragging = true;
onSnapStarted(trans, deltaMovement, ignoreList);
}
else
onSnapHeld(trans, deltaMovement, ignoreList);
}
else
{
if (m_IsDragging)
{
m_IsDragging = false;
onSnapEnded(trans, deltaMovement, ignoreList);
}
else
onSnapUpdate(trans);
}
}
} |
<<<<<<<
using System.Collections.Generic;
using System;
using UnityEngine;
=======
using System;
using System.Collections.Generic;
using UnityEngine;
>>>>>>>
using System;
using System.Collections.Generic;
using UnityEngine;
<<<<<<<
private Camera m_MiniCamera;
=======
static int s_DefaultLayer;
public List<Renderer> ignoreList
{
set
{
m_IgnoreList = value;
var count = m_IgnoreList == null ? 0 : m_IgnoreList.Count;
if (m_IgnoreObjectRendererEnabled == null || count > m_IgnoreObjectRendererEnabled.Length)
{
m_IgnoredObjectLayer = new int[count];
m_IgnoreObjectRendererEnabled = new bool[count];
}
}
}
List<Renderer> m_IgnoreList = new List<Renderer>();
Camera m_MainCamera;
Camera m_MiniCamera;
int[] m_IgnoredObjectLayer;
bool[] m_IgnoreObjectRendererEnabled;
>>>>>>>
static int s_DefaultLayer;
public List<Renderer> ignoreList
{
set
{
m_IgnoreList = value;
var count = m_IgnoreList == null ? 0 : m_IgnoreList.Count;
if (m_IgnoreObjectRendererEnabled == null || count > m_IgnoreObjectRendererEnabled.Length)
{
m_IgnoredObjectLayer = new int[count];
m_IgnoreObjectRendererEnabled = new bool[count];
}
}
}
List<Renderer> m_IgnoreList = new List<Renderer>();
Camera m_MiniCamera;
int[] m_IgnoredObjectLayer;
<<<<<<<
private void RenderMiniWorld(Camera camera)
=======
private void OnPreRender()
{
if (!m_MainCamera)
m_MainCamera = U.Camera.GetMainCamera();
}
private void OnPostRender()
>>>>>>>
void RenderMiniWorld(Camera camera)
<<<<<<<
m_MiniCamera.cullingMask = cullingMask;
m_MiniCamera.clearFlags = CameraClearFlags.Nothing;
m_MiniCamera.worldToCameraMatrix = camera.worldToCameraMatrix * miniWorld.miniToReferenceMatrix;
Shader shader = Shader.Find("Custom/Custom Clip Planes");
Shader.SetGlobalVector("_GlobalClipCenter", miniWorld.referenceBounds.center);
Shader.SetGlobalVector("_GlobalClipExtents", miniWorld.referenceBounds.extents);
for (var i = 0; i < m_IgnoreList.Count; i++)
{
var hiddenRenderer = m_IgnoreList[i];
if (hiddenRenderer)
{
m_RendererPreviousEnable[i] = hiddenRenderer.enabled;
hiddenRenderer.enabled = false;
}
}
if(preProcessRender())
m_MiniCamera.RenderWithShader(shader, string.Empty);
postProcessRender();
for (var i = 0; i < m_IgnoreList.Count; i++)
{
var hiddenRenderer = m_IgnoreList[i];
if (hiddenRenderer)
hiddenRenderer.enabled = m_RendererPreviousEnable[i];
}
=======
if (m_MainCamera && miniWorld)
{
m_MiniCamera.CopyFrom(m_MainCamera);
m_MiniCamera.cullingMask = cullingMask;
m_MiniCamera.clearFlags = CameraClearFlags.Nothing;
m_MiniCamera.worldToCameraMatrix = worldToCameraMatrix;
Shader shader = Shader.Find("Custom/Custom Clip Planes");
Shader.SetGlobalVector("_GlobalClipCenter", miniWorld.referenceBounds.center);
Shader.SetGlobalVector("_GlobalClipExtents", miniWorld.referenceBounds.extents);
for (var i = 0; i < m_IgnoreList.Count; i++)
{
var hiddenRenderer = m_IgnoreList[i];
if (hiddenRenderer.CompareTag(kShowInMiniWorldTag))
{
m_IgnoredObjectLayer[i] = hiddenRenderer.gameObject.layer;
hiddenRenderer.gameObject.layer = s_DefaultLayer;
}
else
{
m_IgnoreObjectRendererEnabled[i] = hiddenRenderer.enabled;
hiddenRenderer.enabled = false;
}
}
m_MiniCamera.SetReplacementShader(shader, null);
m_MiniCamera.Render();
for (var i = 0; i < m_IgnoreList.Count; i++)
{
var hiddenRenderer = m_IgnoreList[i];
if (hiddenRenderer.CompareTag(kShowInMiniWorldTag))
hiddenRenderer.gameObject.layer = m_IgnoredObjectLayer[i];
else
m_IgnoreList[i].enabled = m_IgnoreObjectRendererEnabled[i];
}
}
>>>>>>>
m_MiniCamera.cullingMask = cullingMask;
m_MiniCamera.clearFlags = CameraClearFlags.Nothing;
m_MiniCamera.worldToCameraMatrix = GetWorldToCameraMatrix(camera);
Shader shader = Shader.Find("Custom/Custom Clip Planes");
Shader.SetGlobalVector("_GlobalClipCenter", miniWorld.referenceBounds.center);
Shader.SetGlobalVector("_GlobalClipExtents", miniWorld.referenceBounds.extents);
for (var i = 0; i < m_IgnoreList.Count; i++)
{
var hiddenRenderer = m_IgnoreList[i];
if (hiddenRenderer.CompareTag(kShowInMiniWorldTag))
{
m_IgnoredObjectLayer[i] = hiddenRenderer.gameObject.layer;
hiddenRenderer.gameObject.layer = s_DefaultLayer;
}
else
{
m_IgnoreObjectRendererEnabled[i] = hiddenRenderer.enabled;
hiddenRenderer.enabled = false;
}
}
m_MiniCamera.SetReplacementShader(shader, null);
m_MiniCamera.Render();
for (var i = 0; i < m_IgnoreList.Count; i++)
{
var hiddenRenderer = m_IgnoreList[i];
if (hiddenRenderer.CompareTag(kShowInMiniWorldTag))
hiddenRenderer.gameObject.layer = m_IgnoredObjectLayer[i];
else
m_IgnoreList[i].enabled = m_IgnoreObjectRendererEnabled[i];
} |
<<<<<<<
using UnityEngine.UI;
using UnityEngine.VR.Actions;
using UnityEngine.VR.Handles;
=======
>>>>>>>
using UnityEngine.VR.Actions;
using UnityEngine.VR.Handles;
<<<<<<<
public class MainMenu : MonoBehaviour, IMainMenu, IInstantiateUI, ICustomActionMap, ICustomRay, ILockRay, IMenuOrigins
=======
public class MainMenu : MonoBehaviour, IMainMenu, IConnectInterfaces, IInstantiateUI, ICreateWorkspace, ICustomActionMap, ICustomRay, ILockRay
>>>>>>>
public class MainMenu : MonoBehaviour, IMainMenu, IConnectInterfaces, IInstantiateUI, ICreateWorkspace, ICustomActionMap, ICustomRay, ILockRay, IMenuOrigins
<<<<<<<
public Action<Type> createWorkspace { private get; set; }
public List<ActionMenuData> menuActions { get; set; }
=======
public CreateWorkspaceDelegate createWorkspace { private get; set; }
>>>>>>>
public List<ActionMenuData> menuActions { get; set; }
public CreateWorkspaceDelegate createWorkspace { private get; set; } |
<<<<<<<
using System;
using UnityEditor.Experimental.EditorVR.Modules;
=======
using UnityEditor.Experimental.EditorVR.Modules;
>>>>>>>
using System;
using UnityEditor.Experimental.EditorVR.Modules;
<<<<<<<
IPinnedToolButton m_HighlightedPinnedToolbutton;
/// <summary>
/// Highlights a pinned tool button when this menu button is highlighted
/// </summary>
public Func<Transform, Type, IPinnedToolButton> previewToolInPinnedToolButton { private get; set; }
=======
Transform m_RayOrigin;
>>>>>>>
IPinnedToolButton m_HighlightedPinnedToolbutton;
Transform m_RayOrigin;
/// <summary>
/// Highlights a pinned tool button when this menu button is highlighted
/// </summary>
public Func<Transform, Type, IPinnedToolButton> previewToolInPinnedToolButton { private get; set; }
<<<<<<<
public Type toolType { get; set; }
=======
public void OnPointerClick(PointerEventData eventData)
{
this.Pulse(m_RayOrigin, 0.5f, 0.095f, true, true);
}
>>>>>>>
public Type toolType { get; set; }
public void OnPointerClick(PointerEventData eventData)
{
this.Pulse(m_RayOrigin, 0.5f, 0.095f, true, true);
}
<<<<<<<
public void OnRayEnter(RayEventData eventData)
{
// Track which pointer is over us, so this information can supply context (e.g. selecting a tool for a different hand)
m_HoveringRayOrigin = eventData.rayOrigin;
// Enable preview-mode on a pinned tool button; Display on the opposite proxy device via the HoveringRayOrigin
m_HighlightedPinnedToolbutton = previewToolInPinnedToolButton(m_HoveringRayOrigin, toolType);
}
public void OnRayExit(RayEventData eventData)
{
if (m_HoveringRayOrigin == eventData.rayOrigin)
m_HoveringRayOrigin = null;
// Disable preview-mode on pinned tool button
if (m_HighlightedPinnedToolbutton != null)
m_HighlightedPinnedToolbutton.previewToolType = null;
}
=======
public void OnRayEnter(RayEventData eventData)
{
m_RayOrigin = eventData.rayOrigin;
this.Pulse(eventData.rayOrigin, 0.005f, 0.175f);
}
public void OnRayExit(RayEventData eventData)
{
m_RayOrigin = null;
}
>>>>>>>
public void OnRayEnter(RayEventData eventData)
{
// Track which pointer is over us, so this information can supply context (e.g. selecting a tool for a different hand)
m_HoveringRayOrigin = eventData.rayOrigin;
// Enable preview-mode on a pinned tool button; Display on the opposite proxy device via the HoveringRayOrigin
m_HighlightedPinnedToolbutton = previewToolInPinnedToolButton(m_HoveringRayOrigin, toolType);
m_RayOrigin = eventData.rayOrigin;
this.Pulse(eventData.rayOrigin, 0.005f, 0.175f);
}
public void OnRayExit(RayEventData eventData)
{
if (m_HoveringRayOrigin == eventData.rayOrigin)
m_HoveringRayOrigin = null;
// Disable preview-mode on pinned tool button
if (m_HighlightedPinnedToolbutton != null)
m_HighlightedPinnedToolbutton.previewToolType = null;
m_RayOrigin = null;
} |
<<<<<<<
=======
if (dragEnded != null)
dragEnded(draggedObject, eventData);
>>>>>>> |
<<<<<<<
if (constrained)
m_TargetPosition += delta;
else
this.ManipulatorSnap(rayOrigin, Selection.transforms, ref m_TargetPosition, ref m_TargetRotation, delta);
this.Pulse(requestNodeFromRayOrigin(rayOrigin), m_DragPulse);
=======
switch (constraints)
{
case ConstrainedAxis.X | ConstrainedAxis.Y:
case ConstrainedAxis.Y | ConstrainedAxis.Z:
case ConstrainedAxis.X | ConstrainedAxis.Z:
m_TargetPosition += delta;
break;
default:
m_CurrentlySnapping = this.ManipulatorSnap(rayOrigin, Selection.transforms, ref m_TargetPosition, ref m_TargetRotation, delta, constraints, m_PivotMode);
if (constraints == 0)
m_CurrentlySnapping = false;
break;
}
>>>>>>>
switch (constraints)
{
case ConstrainedAxis.X | ConstrainedAxis.Y:
case ConstrainedAxis.Y | ConstrainedAxis.Z:
case ConstrainedAxis.X | ConstrainedAxis.Z:
m_TargetPosition += delta;
break;
default:
m_CurrentlySnapping = this.ManipulatorSnap(rayOrigin, Selection.transforms, ref m_TargetPosition, ref m_TargetRotation, delta, constraints, m_PivotMode);
if (constraints == 0)
m_CurrentlySnapping = false;
break;
}
this.Pulse(requestNodeFromRayOrigin(rayOrigin), m_DragPulse); |
<<<<<<<
=======
Material m_FrameGradientMaterial;
>>>>>>>
<<<<<<<
Coroutine m_FrameThicknessCoroutine;
Coroutine m_TopFaceVisibleCoroutine;
Material m_TopFaceMaterial;
=======
Coroutine m_FrameThicknessCoroutine;
>>>>>>>
Coroutine m_FrameThicknessCoroutine;
Coroutine m_TopFaceVisibleCoroutine;
Material m_TopFaceMaterial;
<<<<<<<
[SerializeField]
WorkspaceButton m_LockButton;
[SerializeField]
Transform m_TopFaceContainer;
[SerializeField]
Transform m_TopHighlightContainer;
[SerializeField]
WorkspaceHighlight m_FrontHighlight;
public WorkspaceHighlight topHighlight { get { return m_TopHighlight; } }
[SerializeField]
WorkspaceHighlight m_TopHighlight;
=======
[SerializeField]
WorkspaceHighlight m_TopHighlight;
[SerializeField]
Transform m_TopHighlightContainer;
[SerializeField]
WorkspaceHighlight m_FrontHighlight;
>>>>>>>
[SerializeField]
WorkspaceButton m_LockButton;
[SerializeField]
Transform m_TopFaceContainer;
[SerializeField]
Transform m_TopHighlightContainer;
[SerializeField]
WorkspaceHighlight m_FrontHighlight;
public WorkspaceHighlight topHighlight { get { return m_TopHighlight; } }
[SerializeField]
WorkspaceHighlight m_TopHighlight;
<<<<<<<
public bool highlightsVisible
{
set
{
if (m_TopHighlight.visible == value) // All highlights will be set with this value; checking highlight visibility of one highlight is all that is needed
return;
m_TopHighlight.visible = value;
m_FrontHighlight.visible = value;
this.StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = value ? StartCoroutine(IncreaseFrameThickness()) : StartCoroutine(ResetFrameThickness());
}
}
public bool frontHighlightVisible
{
set
{
if (m_FrontHighlight.visible == value)
return;
m_FrontHighlight.visible = value;
this.StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = !value ? StartCoroutine(ResetFrameThickness()) : StartCoroutine(IncreaseFrameThickness());
}
}
public bool amplifyTopHighlight
{
set
{
this.StopCoroutine(ref m_TopFaceVisibleCoroutine);
m_TopFaceVisibleCoroutine = value ? StartCoroutine(HideTopFace()) : StartCoroutine(ShowTopFace());
}
}
=======
public bool highlightsVisible
{
set
{
if (m_TopHighlight.visible == value && m_FrontHighlight.visible == value)
return;
m_TopHighlight.visible = value;
m_FrontHighlight.visible = value;
StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = !value ? StartCoroutine(ResetFrameThickness()) : StartCoroutine(IncreaseFrameThickness());
}
}
public bool frontHighlightVisible
{
set
{
if (m_FrontHighlight.visible == value)
return;
m_FrontHighlight.visible = value;
StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = !value ? StartCoroutine(ResetFrameThickness()) : StartCoroutine(IncreaseFrameThickness());
}
}
>>>>>>>
public bool highlightsVisible
{
set
{
if (m_TopHighlight.visible == value && m_FrontHighlight.visible == value)
return;
m_TopHighlight.visible = value;
m_FrontHighlight.visible = value;
this.StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = value ? StartCoroutine(IncreaseFrameThickness()) : StartCoroutine(ResetFrameThickness());
}
}
public bool frontHighlightVisible
{
set
{
if (m_FrontHighlight.visible == value)
return;
m_FrontHighlight.visible = value;
this.StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = !value ? StartCoroutine(ResetFrameThickness()) : StartCoroutine(IncreaseFrameThickness());
}
}
public bool amplifyTopHighlight
{
set
{
this.StopCoroutine(ref m_TopFaceVisibleCoroutine);
m_TopFaceVisibleCoroutine = value ? StartCoroutine(HideTopFace()) : StartCoroutine(ShowTopFace());
}
}
<<<<<<<
// Scale the Top Face and the Top Face Highlight
const float kHighlightDepthCompensation = 0.14f;
const float kHighlightWidthCompensation = 0.01f;
const float kTopFaceDepthCompensation = 0.144f;
const float kTopFaceWidthCompensation = 0.014f;
m_TopHighlightContainer.localScale = new Vector3(boundsSize.x - kHighlightWidthCompensation, 1f, boundsSize.z - kHighlightDepthCompensation);
m_TopFaceContainer.localScale = new Vector3(boundsSize.x - kTopFaceWidthCompensation, 1f, boundsSize.z - kTopFaceDepthCompensation);
=======
const float kHighlightDepthCompensation = 0.14f;
const float kHighlightWidthCompensation = 0.01f;
m_TopHighlightContainer.localScale = new Vector3(boundsSize.x - kHighlightWidthCompensation, 1f, boundsSize.z - kHighlightDepthCompensation);
>>>>>>>
// Scale the Top Face and the Top Face Highlight
const float kHighlightDepthCompensation = 0.14f;
const float kHighlightWidthCompensation = 0.01f;
const float kTopFaceDepthCompensation = 0.144f;
const float kTopFaceWidthCompensation = 0.014f;
m_TopHighlightContainer.localScale = new Vector3(boundsSize.x - kHighlightWidthCompensation, 1f, boundsSize.z - kHighlightDepthCompensation);
m_TopFaceContainer.localScale = new Vector3(boundsSize.x - kTopFaceWidthCompensation, 1f, boundsSize.z - kTopFaceDepthCompensation);
<<<<<<<
this.StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = StartCoroutine(IncreaseFrameThickness());
=======
StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = StartCoroutine(IncreaseFrameThickness());
>>>>>>>
this.StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = StartCoroutine(IncreaseFrameThickness());
<<<<<<<
this.StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = StartCoroutine(ResetFrameThickness());
=======
StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = StartCoroutine(ResetFrameThickness());
>>>>>>>
this.StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = StartCoroutine(ResetFrameThickness());
<<<<<<<
// a second additional value added to the y offset of the front panel when it is in mid-reveal,
// lerped in at the middle of the rotation/reveal, and lerped out at the beginning & end of the rotation/reveal
const float kCorrectiveMidFrontPanelLocalYOffset = 0.01f;
const int kRevealCompensationBlendShapeIndex = 5;
const float kMaxAlternateFrontPanelLocalZOffset = 0.0035f;
const float kMaxAlternateFrontPanelLocalYOffset = 0.0325f;
const float kLerpPadding = 1.2f; // pad lerp values increasingly as it increases, displaying the "front face reveal" sooner
const float kCorrectiveRevealShapeMultiplier = 1.85f;
var angledAmount = Mathf.Clamp(Mathf.DeltaAngle(currentXRotation, 0f), 0f, 90f);
var midRevealCorrectiveShapeAmount = Mathf.PingPong(angledAmount * kCorrectiveRevealShapeMultiplier, 90);
// blend between the target fully-revealed offset, and the rotationally mid-point-only offset for precise positioning of the front panel
const float kMidRevealCorrectiveShapeMultiplier = 0.01f;
var totalAlternateFrontPanelLocalYOffset = Mathf.Lerp(kMaxAlternateFrontPanelLocalYOffset, kCorrectiveMidFrontPanelLocalYOffset, midRevealCorrectiveShapeAmount * kMidRevealCorrectiveShapeMultiplier);
// add lerp padding to reach and maintain the target value sooner
var lerpAmount = (angledAmount / 90f) * kLerpPadding;
// offset front panel according to workspace rotation angle
const float kAdditionalFrontPanelLerpPadding = 1.1f;
m_FrontPanel.localRotation = Quaternion.Euler(Vector3.Lerp(m_BaseFrontPanelRotation, m_MaxFrontPanelRotation, lerpAmount * kAdditionalFrontPanelLerpPadding));
m_FrontPanel.localPosition = new Vector3(0f, Mathf.Lerp(m_OriginalFontPanelLocalPosition.y, totalAlternateFrontPanelLocalYOffset, lerpAmount), Mathf.Lerp(kPanelOffset, kMaxAlternateFrontPanelLocalZOffset, lerpAmount));
// change blendshapes according to workspace rotation angle
m_Frame.SetBlendShapeWeight(kAngledFaceBlendShapeIndex, angledAmount * kLerpPadding);
m_Frame.SetBlendShapeWeight(kRevealCompensationBlendShapeIndex, midRevealCorrectiveShapeAmount);
// offset the front resize icons to accommodate for the blendshape extending outwards
m_FrontResizeIconsContainer.localPosition = Vector3.Lerp(m_FrontResizeIconsContainerOriginalLocalPosition, m_FrontResizeIconsContainerAngledLocalPosition, lerpAmount);
// offset front handle position according to workspace rotation angle
const float kFrontHandleLocalYAngledOffset = 0.1f;
const float kFrontHandleLocalZNormalOfset = 0.5f;
const float kFrontHandleLocalZAngledOfset = 0.3f;
var lerpedFrontHandleZAngledOffset = Mathf.Lerp(kFrontHandleLocalZNormalOfset, kFrontHandleLocalZAngledOfset, lerpAmount);
var lerpedFrontHandleYLocalPosition = Mathf.Lerp(m_FrontHandleYLocalPosition, m_FrontHandleYLocalPosition + kFrontHandleLocalYAngledOffset, lerpAmount);
m_FrontHandleTransform.localPosition = new Vector3(0, lerpedFrontHandleYLocalPosition, -m_Bounds.size.z - m_HandleScale + lerpedFrontHandleZAngledOffset);
}
private void OnDestroy()
{
U.Object.Destroy(m_TopFaceMaterial);
=======
// a second additional value added to the y offset of the front panel when it is in mid-reveal,
// lerped in at the middle of the rotation/reveal, and lerped out at the beginning & end of the rotation/reveal
const float kCorrectiveMidFrontPanelLocalYOffset = 0.01f;
const int kRevealCompensationBlendShapeIndex = 5;
const float kMaxAlternateFrontPanelLocalZOffset = 0.0035f;
const float kMaxAlternateFrontPanelLocalYOffset = 0.0325f;
const float kLerpPadding = 1.2f; // pad lerp values increasingly as it increases, displaying the "front face reveal" sooner
const float kCorrectiveRevealShapeMultiplier = 1.85f;
var angledAmount = Mathf.Clamp(Mathf.DeltaAngle(currentXRotation, 0f), 0f, 90f);
var midRevealCorrectiveShapeAmount = Mathf.PingPong(angledAmount * kCorrectiveRevealShapeMultiplier, 90);
// blend between the target fully-revealed offset, and the rotationally mid-point-only offset for precise positioning of the front panel
const float kMidRevealCorrectiveShapeMultiplier = 0.01f;
var totalAlternateFrontPanelLocalYOffset = Mathf.Lerp(kMaxAlternateFrontPanelLocalYOffset, kCorrectiveMidFrontPanelLocalYOffset, midRevealCorrectiveShapeAmount * kMidRevealCorrectiveShapeMultiplier);
// add lerp padding to reach and maintain the target value sooner
var lerpAmount = (angledAmount / 90f) * kLerpPadding;
// offset front panel according to workspace rotation angle
const float kAdditionalFrontPanelLerpPadding = 1.1f;
m_FrontPanel.localRotation = Quaternion.Euler(Vector3.Lerp(m_BaseFrontPanelRotation, m_MaxFrontPanelRotation, lerpAmount * kAdditionalFrontPanelLerpPadding));
m_FrontPanel.localPosition = new Vector3(0f, Mathf.Lerp(m_OriginalFontPanelLocalPosition.y, totalAlternateFrontPanelLocalYOffset, lerpAmount), Mathf.Lerp(kPanelOffset, kMaxAlternateFrontPanelLocalZOffset, lerpAmount));
// change blendshapes according to workspace rotation angle
m_Frame.SetBlendShapeWeight(kAngledFaceBlendShapeIndex, angledAmount * kLerpPadding);
m_Frame.SetBlendShapeWeight(kRevealCompensationBlendShapeIndex, midRevealCorrectiveShapeAmount);
// offset the front resize icons to accommodate for the blendshape extending outwards
m_FrontResizeIconsContainer.localPosition = Vector3.Lerp(m_FrontResizeIconsContainerOriginalLocalPosition, m_FrontResizeIconsContainerAngledLocalPosition, lerpAmount);
// offset front handle position according to workspace rotation angle
const float kFrontHandleLocalYAngledOffset = 0.1f;
const float kFrontHandleLocalZNormalOfset = 0.5f;
const float kFrontHandleLocalZAngledOfset = 0.3f;
var lerpedFrontHandleZAngledOffset = Mathf.Lerp(kFrontHandleLocalZNormalOfset, kFrontHandleLocalZAngledOfset, lerpAmount);
var lerpedFrontHandleYLocalPosition = Mathf.Lerp(m_FrontHandleYLocalPosition, m_FrontHandleYLocalPosition + kFrontHandleLocalYAngledOffset, lerpAmount);
m_FrontHandleTransform.localPosition = new Vector3(0, lerpedFrontHandleYLocalPosition, -m_Bounds.size.z - m_HandleScale + lerpedFrontHandleZAngledOffset);
>>>>>>>
// a second additional value added to the y offset of the front panel when it is in mid-reveal,
// lerped in at the middle of the rotation/reveal, and lerped out at the beginning & end of the rotation/reveal
const float kCorrectiveMidFrontPanelLocalYOffset = 0.01f;
const int kRevealCompensationBlendShapeIndex = 5;
const float kMaxAlternateFrontPanelLocalZOffset = 0.0035f;
const float kMaxAlternateFrontPanelLocalYOffset = 0.0325f;
const float kLerpPadding = 1.2f; // pad lerp values increasingly as it increases, displaying the "front face reveal" sooner
const float kCorrectiveRevealShapeMultiplier = 1.85f;
var angledAmount = Mathf.Clamp(Mathf.DeltaAngle(currentXRotation, 0f), 0f, 90f);
var midRevealCorrectiveShapeAmount = Mathf.PingPong(angledAmount * kCorrectiveRevealShapeMultiplier, 90);
// blend between the target fully-revealed offset, and the rotationally mid-point-only offset for precise positioning of the front panel
const float kMidRevealCorrectiveShapeMultiplier = 0.01f;
var totalAlternateFrontPanelLocalYOffset = Mathf.Lerp(kMaxAlternateFrontPanelLocalYOffset, kCorrectiveMidFrontPanelLocalYOffset, midRevealCorrectiveShapeAmount * kMidRevealCorrectiveShapeMultiplier);
// add lerp padding to reach and maintain the target value sooner
var lerpAmount = (angledAmount / 90f) * kLerpPadding;
// offset front panel according to workspace rotation angle
const float kAdditionalFrontPanelLerpPadding = 1.1f;
m_FrontPanel.localRotation = Quaternion.Euler(Vector3.Lerp(m_BaseFrontPanelRotation, m_MaxFrontPanelRotation, lerpAmount * kAdditionalFrontPanelLerpPadding));
m_FrontPanel.localPosition = new Vector3(0f, Mathf.Lerp(m_OriginalFontPanelLocalPosition.y, totalAlternateFrontPanelLocalYOffset, lerpAmount), Mathf.Lerp(kPanelOffset, kMaxAlternateFrontPanelLocalZOffset, lerpAmount));
// change blendshapes according to workspace rotation angle
m_Frame.SetBlendShapeWeight(kAngledFaceBlendShapeIndex, angledAmount * kLerpPadding);
m_Frame.SetBlendShapeWeight(kRevealCompensationBlendShapeIndex, midRevealCorrectiveShapeAmount);
// offset the front resize icons to accommodate for the blendshape extending outwards
m_FrontResizeIconsContainer.localPosition = Vector3.Lerp(m_FrontResizeIconsContainerOriginalLocalPosition, m_FrontResizeIconsContainerAngledLocalPosition, lerpAmount);
// offset front handle position according to workspace rotation angle
const float kFrontHandleLocalYAngledOffset = 0.1f;
const float kFrontHandleLocalZNormalOfset = 0.5f;
const float kFrontHandleLocalZAngledOfset = 0.3f;
var lerpedFrontHandleZAngledOffset = Mathf.Lerp(kFrontHandleLocalZNormalOfset, kFrontHandleLocalZAngledOfset, lerpAmount);
var lerpedFrontHandleYLocalPosition = Mathf.Lerp(m_FrontHandleYLocalPosition, m_FrontHandleYLocalPosition + kFrontHandleLocalYAngledOffset, lerpAmount);
m_FrontHandleTransform.localPosition = new Vector3(0, lerpedFrontHandleYLocalPosition, -m_Bounds.size.z - m_HandleScale + lerpedFrontHandleZAngledOffset);
}
private void OnDestroy()
{
U.Object.Destroy(m_TopFaceMaterial); |
<<<<<<<
public class FeedbackModule : ScriptableSettings<FeedbackModule>, IInitializableModule, ISettingsMenuItemProvider,
ISerializePreferences, IInterfaceConnector, IProvidesRequestFeedback
=======
public abstract class FeedbackRequest
{
public IRequestFeedback caller;
public abstract void Reset();
}
public class FeedbackModule : ScriptableSettings<FeedbackModule>, IDelayedInitializationModule, ISettingsMenuItemProvider,
ISerializePreferences, IInterfaceConnector
>>>>>>>
public class FeedbackModule : ScriptableSettings<FeedbackModule>, IDelayedInitializationModule, ISettingsMenuItemProvider,
ISerializePreferences, IInterfaceConnector, IProvidesRequestFeedback |
<<<<<<<
using System;
using UnityEngine;
=======
using System.Collections.Generic;
using UnityEngine;
>>>>>>>
using System;
using System.Collections.Generic;
using UnityEngine;
<<<<<<<
public Func<bool> preProcessRender { private get; set; }
public Action postProcessRender { private get; set; }
=======
void Awake()
{
s_DefaultLayer = LayerMask.NameToLayer("Default");
}
>>>>>>>
public Func<bool> preProcessRender { private get; set; }
public Action postProcessRender { private get; set; }
void Awake()
{
s_DefaultLayer = LayerMask.NameToLayer("Default");
}
<<<<<<<
if(preProcessRender())
m_MiniCamera.RenderWithShader(shader, string.Empty);
postProcessRender();
}
=======
for (var i = 0; i < m_IgnoreList.Count; i++)
{
var hiddenRenderer = m_IgnoreList[i];
if (hiddenRenderer.CompareTag(kShowInMiniWorldTag))
{
m_IgnoredObjectLayer[i] = hiddenRenderer.gameObject.layer;
hiddenRenderer.gameObject.layer = s_DefaultLayer;
}
else
{
m_IgnoreObjectRendererEnabled[i] = hiddenRenderer.enabled;
hiddenRenderer.enabled = false;
}
}
m_MiniCamera.RenderWithShader(shader, string.Empty);
>>>>>>>
for (var i = 0; i < m_IgnoreList.Count; i++)
{
var hiddenRenderer = m_IgnoreList[i];
if (hiddenRenderer.CompareTag(kShowInMiniWorldTag))
{
m_IgnoredObjectLayer[i] = hiddenRenderer.gameObject.layer;
hiddenRenderer.gameObject.layer = s_DefaultLayer;
}
else
{
m_IgnoreObjectRendererEnabled[i] = hiddenRenderer.enabled;
hiddenRenderer.enabled = false;
}
}
if(preProcessRender())
m_MiniCamera.RenderWithShader(shader, string.Empty);
postProcessRender(); |
<<<<<<<
float m_LastPointerLength;
=======
IntersectionTester m_Tester;
>>>>>>>
IntersectionTester m_Tester;
float m_LastPointerLength; |
<<<<<<<
=======
#endif
s_Instance = this; // Used only by PreferencesGUI
>>>>>>>
#endif
<<<<<<<
=======
#if UNITY_EDITOR
[PreferenceItem("EditorXR")]
static void PreferencesGUI()
{
EditorGUILayout.BeginVertical();
EditorGUILayout.Space();
// Show EditorXR GameObjects
{
const string title = "Show EditorXR GameObjects";
const string tooltip = "Normally, EditorXR GameObjects are hidden in the Hierarchy. Would you like to show them?";
EditorGUI.BeginChangeCheck();
showGameObjects = EditorGUILayout.Toggle(new GUIContent(title, tooltip), showGameObjects);
if (EditorGUI.EndChangeCheck() && s_Instance)
s_Instance.SetHideFlags(defaultHideFlags);
}
// Preserve Layout
{
const string title = "Preserve Layout";
const string tooltip = "Check this to preserve your layout and location in EditorXR";
preserveLayout = EditorGUILayout.Toggle(new GUIContent(title, tooltip), preserveLayout);
}
// Include in Builds
{
const string title = "Include in Player Builds";
const string tooltip = "Normally, EditorXR will override its assembly definitions to keep its assemblies out of Player builds. Check this if you would like to skip this step and include EditorXR in Player builds";
includeInBuilds = EditorGUILayout.Toggle(new GUIContent(title, tooltip), includeInBuilds);
}
GUILayout.FlexibleSpace();
if (GUILayout.Button("Reset to Defaults", GUILayout.Width(140)))
ResetPreferences();
EditorGUILayout.EndVertical();
}
#endif
>>>>>>> |
<<<<<<<
var serializableTypes = new HashSet<SerializableType>();
var tool = U.AddComponent(toolType, gameObject) as ITool;
=======
HashSet<SerializableType> serializableTypes = new HashSet<SerializableType>();
var tool = U.Object.AddComponent(toolType, gameObject) as ITool;
>>>>>>>
var serializableTypes = new HashSet<SerializableType>();
var tool = U.Object.AddComponent(toolType, gameObject) as ITool;
<<<<<<<
usedDevices.UnionWith(standardMap.StandardInput.GetCurrentlyUsedDevices());
U.CollectSerializableTypesFromActionMapInput(standardMap.StandardInput, ref serializableTypes);
=======
U.Input.CollectSerializableTypesFromActionMapInput(standardMap.StandardInput, ref serializableTypes);
>>>>>>>
usedDevices.UnionWith(standardMap.StandardInput.GetCurrentlyUsedDevices());
U.Input.CollectSerializableTypesFromActionMapInput(standardMap.StandardInput, ref serializableTypes); |
<<<<<<<
const int kHiddenFacesBlendShapeIndex = 4;
const float kFaceWidthMatchMultiplier = 7.1375f; // Multiplier that sizes the face to the intended width
=======
const float kFaceWidthMatchMultiplier = 7.1375f; // Multiplier that sizes the face to the intended width
>>>>>>>
const float kFaceWidthMatchMultiplier = 7.1375f; // Multiplier that sizes the face to the intended width
<<<<<<<
=======
Material m_FrameGradientMaterial;
>>>>>>>
<<<<<<<
Coroutine m_FrameThicknessCoroutine;
Coroutine m_TopFaceVisibleCoroutine;
Material m_TopFaceMaterial;
=======
Coroutine m_FrameThicknessCoroutine;
>>>>>>>
Coroutine m_FrameThicknessCoroutine;
Coroutine m_TopFaceVisibleCoroutine;
Material m_TopFaceMaterial;
<<<<<<<
[SerializeField]
WorkspaceButton m_LockButton;
[SerializeField]
GameObject m_ResetButton;
public Transform topFaceContainer { get { return m_TopFaceContainer; } }
[SerializeField]
Transform m_TopFaceContainer;
[SerializeField]
Transform m_TopHighlightContainer;
[SerializeField]
WorkspaceHighlight m_FrontHighlight;
public WorkspaceHighlight topHighlight { get { return m_TopHighlight; } }
[SerializeField]
WorkspaceHighlight m_TopHighlight;
public bool dynamicFaceAdjustment { get { return m_dynamicFaceAdjustment; } set { m_dynamicFaceAdjustment = value; } }
bool m_dynamicFaceAdjustment = true;
public bool highlightsVisible
{
set
{
if (m_TopHighlight.visible == value) // All highlights will be set with this value; checking highlight visibility of one highlight is all that is needed
return;
m_TopHighlight.visible = value;
m_FrontHighlight.visible = value;
this.StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = value ? StartCoroutine(IncreaseFrameThickness()) : StartCoroutine(ResetFrameThickness());
}
}
public bool frontHighlightVisible
{
set
{
if (m_FrontHighlight.visible == value)
return;
m_FrontHighlight.visible = value;
this.StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = !value ? StartCoroutine(ResetFrameThickness()) : StartCoroutine(IncreaseFrameThickness());
}
}
public bool amplifyTopHighlight
{
set
{
this.StopCoroutine(ref m_TopFaceVisibleCoroutine);
m_TopFaceVisibleCoroutine = value ? StartCoroutine(HideTopFace()) : StartCoroutine(ShowTopFace());
}
}
=======
[SerializeField]
WorkspaceHighlight m_TopHighlight;
[SerializeField]
Transform m_TopHighlightContainer;
[SerializeField]
WorkspaceHighlight m_FrontHighlight;
public bool dynamicFaceAdjustment { get; set; }
>>>>>>>
[SerializeField]
WorkspaceButton m_LockButton;
[SerializeField]
GameObject m_ResetButton;
public Transform topFaceContainer { get { return m_TopFaceContainer; } }
[SerializeField]
Transform m_TopFaceContainer;
[SerializeField]
Transform m_TopHighlightContainer;
[SerializeField]
WorkspaceHighlight m_FrontHighlight;
public WorkspaceHighlight topHighlight { get { return m_TopHighlight; } }
[SerializeField]
WorkspaceHighlight m_TopHighlight;
public bool dynamicFaceAdjustment { get { return m_dynamicFaceAdjustment; } set { m_dynamicFaceAdjustment = value; } }
bool m_dynamicFaceAdjustment = true;
<<<<<<<
m_FrontHandleTransform.localScale = !preventFrontBackResize ? new Vector3(boundsSize.x, m_HandleScale, m_HandleScale) : Vector3.zero;
=======
m_FrontHandleTransform.localScale = preventFrontBackResize == false ? new Vector3(boundsSize.x, m_HandleScale, m_HandleScale) : Vector3.zero;
>>>>>>>
m_FrontHandleTransform.localScale = !preventFrontBackResize ? new Vector3(boundsSize.x, m_HandleScale, m_HandleScale) : Vector3.zero;
<<<<<<<
// Scale the Top Face and the Top Face Highlight
const float kHighlightDepthCompensation = 0.14f;
const float kHighlightWidthCompensation = 0.01f;
const float kTopFaceDepthCompensation = 0.144f;
const float kTopFaceWidthCompensation = 0.014f;
m_TopHighlightContainer.localScale = new Vector3(boundsSize.x - kHighlightWidthCompensation, 1f, boundsSize.z - kHighlightDepthCompensation);
m_TopFaceContainer.localScale = new Vector3(boundsSize.x - kTopFaceWidthCompensation, 1f, boundsSize.z - kTopFaceDepthCompensation);
=======
const float kHighlightDepthCompensation = 0.14f;
const float kHighlightWidthCompensation = 0.01f;
m_TopHighlightContainer.localScale = new Vector3(boundsSize.x - kHighlightWidthCompensation, 1f, boundsSize.z - kHighlightDepthCompensation);
>>>>>>>
// Scale the Top Face and the Top Face Highlight
const float kHighlightDepthCompensation = 0.14f;
const float kHighlightWidthCompensation = 0.01f;
const float kTopFaceDepthCompensation = 0.144f;
const float kTopFaceWidthCompensation = 0.014f;
m_TopHighlightContainer.localScale = new Vector3(boundsSize.x - kHighlightWidthCompensation, 1f, boundsSize.z - kHighlightDepthCompensation);
m_TopFaceContainer.localScale = new Vector3(boundsSize.x - kTopFaceWidthCompensation, 1f, boundsSize.z - kTopFaceDepthCompensation);
<<<<<<<
this.StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = StartCoroutine(IncreaseFrameThickness());
=======
StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = StartCoroutine(IncreaseFrameThickness());
>>>>>>>
this.StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = StartCoroutine(IncreaseFrameThickness());
<<<<<<<
this.StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = StartCoroutine(ResetFrameThickness());
=======
StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = StartCoroutine(ResetFrameThickness());
>>>>>>>
this.StopCoroutine(ref m_FrameThicknessCoroutine);
m_FrameThicknessCoroutine = StartCoroutine(ResetFrameThickness());
<<<<<<<
// a second additional value added to the y offset of the front panel when it is in mid-reveal,
// lerped in at the middle of the rotation/reveal, and lerped out at the beginning & end of the rotation/reveal
const float kCorrectiveMidFrontPanelLocalYOffset = 0.01f;
const int kRevealCompensationBlendShapeIndex = 5;
const float kMaxAlternateFrontPanelLocalZOffset = 0.0035f;
const float kMaxAlternateFrontPanelLocalYOffset = 0.0325f;
const float kLerpPadding = 1.2f; // pad lerp values increasingly as it increases, displaying the "front face reveal" sooner
const float kCorrectiveRevealShapeMultiplier = 1.85f;
var angledAmount = Mathf.Clamp(Mathf.DeltaAngle(currentXRotation, 0f), 0f, 90f);
var midRevealCorrectiveShapeAmount = Mathf.PingPong(angledAmount * kCorrectiveRevealShapeMultiplier, 90);
// blend between the target fully-revealed offset, and the rotationally mid-point-only offset for precise positioning of the front panel
const float kMidRevealCorrectiveShapeMultiplier = 0.01f;
var totalAlternateFrontPanelLocalYOffset = Mathf.Lerp(kMaxAlternateFrontPanelLocalYOffset, kCorrectiveMidFrontPanelLocalYOffset, midRevealCorrectiveShapeAmount * kMidRevealCorrectiveShapeMultiplier);
// add lerp padding to reach and maintain the target value sooner
var lerpAmount = (angledAmount / 90f) * kLerpPadding;
// offset front panel according to workspace rotation angle
const float kAdditionalFrontPanelLerpPadding = 1.1f;
m_FrontPanel.localRotation = Quaternion.Euler(Vector3.Lerp(m_BaseFrontPanelRotation, m_MaxFrontPanelRotation, lerpAmount * kAdditionalFrontPanelLerpPadding));
m_FrontPanel.localPosition = new Vector3(0f, Mathf.Lerp(m_OriginalFontPanelLocalPosition.y, totalAlternateFrontPanelLocalYOffset, lerpAmount), Mathf.Lerp(kPanelOffset, kMaxAlternateFrontPanelLocalZOffset, lerpAmount));
// change blendshapes according to workspace rotation angle
m_Frame.SetBlendShapeWeight(kAngledFaceBlendShapeIndex, angledAmount * kLerpPadding);
m_Frame.SetBlendShapeWeight(kRevealCompensationBlendShapeIndex, midRevealCorrectiveShapeAmount);
// offset the front resize icons to accommodate for the blendshape extending outwards
m_FrontResizeIconsContainer.localPosition = Vector3.Lerp(m_FrontResizeIconsContainerOriginalLocalPosition, m_FrontResizeIconsContainerAngledLocalPosition, lerpAmount);
// offset front handle position according to workspace rotation angle
const float kFrontHandleLocalYAngledOffset = 0.1f;
const float kFrontHandleLocalZNormalOfset = 0.5f;
const float kFrontHandleLocalZAngledOfset = 0.3f;
var lerpedFrontHandleZAngledOffset = Mathf.Lerp(kFrontHandleLocalZNormalOfset, kFrontHandleLocalZAngledOfset, lerpAmount);
var lerpedFrontHandleYLocalPosition = Mathf.Lerp(m_FrontHandleYLocalPosition, m_FrontHandleYLocalPosition + kFrontHandleLocalYAngledOffset, lerpAmount);
m_FrontHandleTransform.localPosition = new Vector3(0, lerpedFrontHandleYLocalPosition, -m_Bounds.size.z - m_HandleScale + lerpedFrontHandleZAngledOffset);
}
private void OnDestroy()
{
U.Object.Destroy(m_TopFaceMaterial);
=======
// a second additional value added to the y offset of the front panel when it is in mid-reveal,
// lerped in at the middle of the rotation/reveal, and lerped out at the beginning & end of the rotation/reveal
const float kCorrectiveMidFrontPanelLocalYOffset = 0.01f;
const int kRevealCompensationBlendShapeIndex = 5;
const float kMaxAlternateFrontPanelLocalZOffset = 0.0035f;
const float kMaxAlternateFrontPanelLocalYOffset = 0.0325f;
const float kLerpPadding = 1.2f; // pad lerp values increasingly as it increases, displaying the "front face reveal" sooner
const float kCorrectiveRevealShapeMultiplier = 1.85f;
var angledAmount = Mathf.Clamp(Mathf.DeltaAngle(currentXRotation, 0f), 0f, 90f);
var midRevealCorrectiveShapeAmount = Mathf.PingPong(angledAmount * kCorrectiveRevealShapeMultiplier, 90);
// blend between the target fully-revealed offset, and the rotationally mid-point-only offset for precise positioning of the front panel
const float kMidRevealCorrectiveShapeMultiplier = 0.01f;
var totalAlternateFrontPanelLocalYOffset = Mathf.Lerp(kMaxAlternateFrontPanelLocalYOffset, kCorrectiveMidFrontPanelLocalYOffset, midRevealCorrectiveShapeAmount * kMidRevealCorrectiveShapeMultiplier);
// add lerp padding to reach and maintain the target value sooner
var lerpAmount = (angledAmount / 90f) * kLerpPadding;
// offset front panel according to workspace rotation angle
const float kAdditionalFrontPanelLerpPadding = 1.1f;
m_FrontPanel.localRotation = Quaternion.Euler(Vector3.Lerp(m_BaseFrontPanelRotation, m_MaxFrontPanelRotation, lerpAmount * kAdditionalFrontPanelLerpPadding));
m_FrontPanel.localPosition = new Vector3(0f, Mathf.Lerp(m_OriginalFontPanelLocalPosition.y, totalAlternateFrontPanelLocalYOffset, lerpAmount), Mathf.Lerp(kPanelOffset, kMaxAlternateFrontPanelLocalZOffset, lerpAmount));
// change blendshapes according to workspace rotation angle
m_Frame.SetBlendShapeWeight(kAngledFaceBlendShapeIndex, angledAmount * kLerpPadding);
m_Frame.SetBlendShapeWeight(kRevealCompensationBlendShapeIndex, midRevealCorrectiveShapeAmount);
// offset the front resize icons to accommodate for the blendshape extending outwards
m_FrontResizeIconsContainer.localPosition = Vector3.Lerp(m_FrontResizeIconsContainerOriginalLocalPosition, m_FrontResizeIconsContainerAngledLocalPosition, lerpAmount);
// offset front handle position according to workspace rotation angle
const float kFrontHandleLocalYAngledOffset = 0.1f;
const float kFrontHandleLocalZNormalOfset = 0.5f;
const float kFrontHandleLocalZAngledOfset = 0.3f;
var lerpedFrontHandleZAngledOffset = Mathf.Lerp(kFrontHandleLocalZNormalOfset, kFrontHandleLocalZAngledOfset, lerpAmount);
var lerpedFrontHandleYLocalPosition = Mathf.Lerp(m_FrontHandleYLocalPosition, m_FrontHandleYLocalPosition + kFrontHandleLocalYAngledOffset, lerpAmount);
m_FrontHandleTransform.localPosition = new Vector3(0, lerpedFrontHandleYLocalPosition, -m_Bounds.size.z - m_HandleScale + lerpedFrontHandleZAngledOffset);
>>>>>>>
// a second additional value added to the y offset of the front panel when it is in mid-reveal,
// lerped in at the middle of the rotation/reveal, and lerped out at the beginning & end of the rotation/reveal
const float kCorrectiveMidFrontPanelLocalYOffset = 0.01f;
const int kRevealCompensationBlendShapeIndex = 5;
const float kMaxAlternateFrontPanelLocalZOffset = 0.0035f;
const float kMaxAlternateFrontPanelLocalYOffset = 0.0325f;
const float kLerpPadding = 1.2f; // pad lerp values increasingly as it increases, displaying the "front face reveal" sooner
const float kCorrectiveRevealShapeMultiplier = 1.85f;
var angledAmount = Mathf.Clamp(Mathf.DeltaAngle(currentXRotation, 0f), 0f, 90f);
var midRevealCorrectiveShapeAmount = Mathf.PingPong(angledAmount * kCorrectiveRevealShapeMultiplier, 90);
// blend between the target fully-revealed offset, and the rotationally mid-point-only offset for precise positioning of the front panel
const float kMidRevealCorrectiveShapeMultiplier = 0.01f;
var totalAlternateFrontPanelLocalYOffset = Mathf.Lerp(kMaxAlternateFrontPanelLocalYOffset, kCorrectiveMidFrontPanelLocalYOffset, midRevealCorrectiveShapeAmount * kMidRevealCorrectiveShapeMultiplier);
// add lerp padding to reach and maintain the target value sooner
var lerpAmount = (angledAmount / 90f) * kLerpPadding;
// offset front panel according to workspace rotation angle
const float kAdditionalFrontPanelLerpPadding = 1.1f;
m_FrontPanel.localRotation = Quaternion.Euler(Vector3.Lerp(m_BaseFrontPanelRotation, m_MaxFrontPanelRotation, lerpAmount * kAdditionalFrontPanelLerpPadding));
m_FrontPanel.localPosition = new Vector3(0f, Mathf.Lerp(m_OriginalFontPanelLocalPosition.y, totalAlternateFrontPanelLocalYOffset, lerpAmount), Mathf.Lerp(kPanelOffset, kMaxAlternateFrontPanelLocalZOffset, lerpAmount));
// change blendshapes according to workspace rotation angle
m_Frame.SetBlendShapeWeight(kAngledFaceBlendShapeIndex, angledAmount * kLerpPadding);
m_Frame.SetBlendShapeWeight(kRevealCompensationBlendShapeIndex, midRevealCorrectiveShapeAmount);
// offset the front resize icons to accommodate for the blendshape extending outwards
m_FrontResizeIconsContainer.localPosition = Vector3.Lerp(m_FrontResizeIconsContainerOriginalLocalPosition, m_FrontResizeIconsContainerAngledLocalPosition, lerpAmount);
// offset front handle position according to workspace rotation angle
const float kFrontHandleLocalYAngledOffset = 0.1f;
const float kFrontHandleLocalZNormalOfset = 0.5f;
const float kFrontHandleLocalZAngledOfset = 0.3f;
var lerpedFrontHandleZAngledOffset = Mathf.Lerp(kFrontHandleLocalZNormalOfset, kFrontHandleLocalZAngledOfset, lerpAmount);
var lerpedFrontHandleYLocalPosition = Mathf.Lerp(m_FrontHandleYLocalPosition, m_FrontHandleYLocalPosition + kFrontHandleLocalYAngledOffset, lerpAmount);
m_FrontHandleTransform.localPosition = new Vector3(0, lerpedFrontHandleYLocalPosition, -m_Bounds.size.z - m_HandleScale + lerpedFrontHandleZAngledOffset);
}
private void OnDestroy()
{
U.Object.Destroy(m_TopFaceMaterial); |
<<<<<<<
=======
const byte k_MinStencilRef = 5;
>>>>>>>
const byte k_MinStencilRef = 5;
<<<<<<<
if (m_ConnectedInterfaces != null)
m_ConnectInterfaces(obj, rayOrigin);
=======
var evrRays = evr.m_Rays;
var evrWorkspaceModule = evr.m_WorkspaceModule;
var evrMenus = evr.m_Menus;
var evrHighlightModule = evr.m_HighlightModule;
var evrSceneObjectModule = evr.m_SceneObjectModule;
var evrLockModule = evr.m_LockModule;
var evrActionsModule = evr.m_ActionsModule;
var evrDirectSelection = evr.m_DirectSelection;
var evrSpatialHashModule = evr.m_SpatialHashModule;
var evrViewer = evr.m_Viewer;
var evrTools = evr.m_Tools;
var evrProjectFolderModule = evr.m_ProjectFolderModule;
var evrHierarchyModule = evr.m_HierarchyModule;
var evrDeviceInputModule = evr.m_DeviceInputModule;
var evrSelectionModule = evr.m_SelectionModule;
var evrUI = evr.m_UI;
var evrDeviceData = evr.m_DeviceData;
var tooltipModule = evr.m_TooltipModule;
if (rayOrigin)
{
var ray = obj as IUsesRayOrigin;
if (ray != null)
ray.rayOrigin = rayOrigin;
var deviceData = evrDeviceData.FirstOrDefault(dd => dd.rayOrigin == rayOrigin);
var handedRay = obj as IUsesNode;
if (handedRay != null && deviceData != null)
handedRay.node = deviceData.node;
var usesProxy = obj as IUsesProxyType;
if (usesProxy != null && deviceData != null)
usesProxy.proxyType = deviceData.proxy.GetType();
var menuOrigins = obj as IUsesMenuOrigins;
if (menuOrigins != null)
{
Transform mainMenuOrigin;
var proxy = evrRays.GetProxyForRayOrigin(rayOrigin);
if (proxy != null && proxy.menuOrigins.TryGetValue(rayOrigin, out mainMenuOrigin))
{
menuOrigins.menuOrigin = mainMenuOrigin;
Transform alternateMenuOrigin;
if (proxy.alternateMenuOrigins.TryGetValue(rayOrigin, out alternateMenuOrigin))
menuOrigins.alternateMenuOrigin = alternateMenuOrigin;
}
}
}
// Specific proxy ray setting
var customRay = obj as ICustomRay;
if (customRay != null)
{
customRay.showDefaultRay = Rays.ShowRay;
customRay.hideDefaultRay = Rays.HideRay;
}
var lockableRay = obj as IUsesRayLocking;
if (lockableRay != null)
{
lockableRay.lockRay = Rays.LockRay;
lockableRay.unlockRay = Rays.UnlockRay;
}
var locomotion = obj as ILocomotor;
if (locomotion != null)
locomotion.cameraRig = VRView.cameraRig;
var instantiateUI = obj as IInstantiateUI;
if (instantiateUI != null)
instantiateUI.instantiateUI = evrUI.InstantiateUI;
var createWorkspace = obj as ICreateWorkspace;
if (createWorkspace != null)
createWorkspace.createWorkspace = evrWorkspaceModule.CreateWorkspace;
var instantiateMenuUI = obj as IInstantiateMenuUI;
if (instantiateMenuUI != null)
instantiateMenuUI.instantiateMenuUI = evrMenus.InstantiateMenuUI;
var raycaster = obj as IUsesRaycastResults;
if (raycaster != null)
raycaster.getFirstGameObject = evrRays.GetFirstGameObject;
var highlight = obj as ISetHighlight;
if (highlight != null)
highlight.setHighlight = evrHighlightModule.SetHighlight;
var placeObjects = obj as IPlaceObject;
if (placeObjects != null)
placeObjects.placeObject = evrSceneObjectModule.PlaceSceneObject;
var locking = obj as IUsesGameObjectLocking;
if (locking != null)
{
locking.setLocked = evrLockModule.SetLocked;
locking.isLocked = evrLockModule.IsLocked;
}
var getPreviewOrigin = obj as IGetPreviewOrigin;
if (getPreviewOrigin != null)
getPreviewOrigin.getPreviewOriginForRayOrigin = evrRays.GetPreviewOriginForRayOrigin;
var getFieldGrabOrigin = obj as IGetFieldGrabOrigin;
if (getFieldGrabOrigin != null)
getFieldGrabOrigin.getFieldGrabOriginForRayOrigin = evrRays.GetFieldGrabOriginForRayOrigin;
var selectionChanged = obj as ISelectionChanged;
if (selectionChanged != null)
evr.m_SelectionChanged += selectionChanged.OnSelectionChanged;
var toolActions = obj as IActions;
if (toolActions != null)
{
var actions = toolActions.actions;
foreach (var action in actions)
{
var actionMenuData = new ActionMenuData()
{
name = action.GetType().Name,
sectionName = ActionMenuItemAttribute.DefaultActionSectionName,
priority = int.MaxValue,
action = action,
};
evrActionsModule.menuActions.Add(actionMenuData);
}
evrMenus.UpdateAlternateMenuActions();
}
var directSelection = obj as IUsesDirectSelection;
if (directSelection != null)
directSelection.getDirectSelection = () => evrDirectSelection.directSelections;
var grabObjects = obj as IGrabObjects;
if (grabObjects != null)
{
grabObjects.canGrabObject = evrDirectSelection.CanGrabObject;
grabObjects.objectGrabbed += evrDirectSelection.OnObjectGrabbed;
grabObjects.objectsDropped += evrDirectSelection.OnObjectsDropped;
}
var spatialHash = obj as IUsesSpatialHash;
if (spatialHash != null)
{
spatialHash.addToSpatialHash = evrSpatialHashModule.AddObject;
spatialHash.removeFromSpatialHash = evrSpatialHashModule.RemoveObject;
}
var deleteSceneObjects = obj as IDeleteSceneObject;
if (deleteSceneObjects != null)
deleteSceneObjects.deleteSceneObject = evrSceneObjectModule.DeleteSceneObject;
var usesViewerBody = obj as IUsesViewerBody;
if (usesViewerBody != null)
usesViewerBody.isOverShoulder = evrViewer.IsOverShoulder;
var mainMenu = obj as IMainMenu;
if (mainMenu != null)
{
mainMenu.menuTools = evrMenus.mainMenuTools;
mainMenu.menuWorkspaces = WorkspaceModule.workspaceTypes;
mainMenu.isToolActive = evrTools.IsToolActive;
}
var alternateMenu = obj as IAlternateMenu;
if (alternateMenu != null)
alternateMenu.menuActions = evrActionsModule.menuActions;
var usesProjectFolderData = obj as IUsesProjectFolderData;
if (usesProjectFolderData != null)
{
evrProjectFolderModule.AddConsumer(usesProjectFolderData);
var filterUI = obj as IFilterUI;
if (filterUI != null)
evrProjectFolderModule.AddConsumer(filterUI);
}
var usesHierarchyData = obj as IUsesHierarchyData;
if (usesHierarchyData != null)
{
evrHierarchyModule.AddConsumer(usesHierarchyData);
var filterUI = obj as IFilterUI;
if (filterUI != null)
evrHierarchyModule.AddConsumer(filterUI);
}
// Tracked Object action maps shouldn't block each other so we share an instance
var trackedObjectMap = obj as ITrackedObjectActionMap;
if (trackedObjectMap != null)
trackedObjectMap.trackedObjectInput = evrDeviceInputModule.trackedObjectInput;
var selectTool = obj as ISelectTool;
if (selectTool != null)
selectTool.selectTool = evrTools.SelectTool;
var usesCameraRig = obj as IUsesCameraRig;
if (usesCameraRig != null)
usesCameraRig.cameraRig = CameraUtils.GetCameraRig();
var usesStencilRef = obj as IUsesStencilRef;
if (usesStencilRef != null)
{
byte? stencilRef = null;
var mb = obj as MonoBehaviour;
if (mb)
{
var parent = mb.transform.parent;
if (parent)
{
// For workspaces and tools, it's likely that the stencil ref should be shared internally
var parentStencilRef = parent.GetComponentInParent<IUsesStencilRef>();
if (parentStencilRef != null)
stencilRef = parentStencilRef.stencilRef;
}
}
usesStencilRef.stencilRef = stencilRef ?? RequestStencilRef();
}
var selectObject = obj as ISelectObject;
if (selectObject != null)
{
selectObject.getSelectionCandidate = evrSelectionModule.GetSelectionCandidate;
selectObject.selectObject = evrSelectionModule.SelectObject;
}
var manipulatorVisiblity = obj as IManipulatorVisibility;
if (manipulatorVisiblity != null)
evrUI.manipulatorVisibilities.Add(manipulatorVisiblity);
var setManipulatorsVisible = obj as ISetManipulatorsVisible;
if (setManipulatorsVisible != null)
setManipulatorsVisible.setManipulatorsVisible = evrUI.SetManipulatorsVisible;
var requestStencilRef = obj as IRequestStencilRef;
if (requestStencilRef != null)
requestStencilRef.requestStencilRef = RequestStencilRef;
var moveCameraRig = obj as IMoveCameraRig;
if (moveCameraRig != null)
moveCameraRig.moveCameraRig = Viewer.MoveCameraRig;
var usesViewerScale = obj as IUsesViewerScale;
if (usesViewerScale != null)
usesViewerScale.getViewerScale = Viewer.GetViewerScale;
var usesTooltip = obj as ISetTooltipVisibility;
if (usesTooltip != null)
{
usesTooltip.showTooltip = tooltipModule.ShowTooltip;
usesTooltip.hideTooltip = tooltipModule.HideTooltip;
}
var linkedObject = obj as ILinkedObject;
if (linkedObject != null)
{
var type = obj.GetType();
var linkedObjects = evrTools.linkedObjects;
List<ILinkedObject> linkedObjectList;
if (!linkedObjects.TryGetValue(type, out linkedObjectList))
{
linkedObjectList = new List<ILinkedObject>();
linkedObjects[type] = linkedObjectList;
}
linkedObjectList.Add(linkedObject);
linkedObject.linkedObjects = linkedObjectList;
linkedObject.isSharedUpdater = IsSharedUpdater;
}
var isHoveringOverUI = obj as IIsHoveringOverUI;
if (isHoveringOverUI != null)
isHoveringOverUI.isHoveringOverUI = evr.m_InputModule.IsHoveringOverUI;
var customHighlight = obj as ICustomHighlight;
if (customHighlight != null)
evrHighlightModule.customHighlight += customHighlight.OnHighlight;
// Internal interfaces
var forEachRayOrigin = obj as IForEachRayOrigin;
if (forEachRayOrigin != null && IsSameAssembly<IForEachRayOrigin>(obj))
forEachRayOrigin.forEachRayOrigin = evrRays.ForEachRayOrigin;
}
bool IsSharedUpdater(ILinkedObject linkedObject)
{
var type = linkedObject.GetType();
return evr.m_Tools.linkedObjects[type].IndexOf(linkedObject) == 0;
}
static bool IsSameAssembly<T>(object obj)
{
// Until we move EditorVR into it's own assembly, this is a way to enforce 'internal' on interfaces
var objType = obj.GetType();
return objType.Assembly == typeof(T).Assembly;
>>>>>>>
if (m_ConnectedInterfaces != null)
m_ConnectInterfaces(obj, rayOrigin);
<<<<<<<
if (m_DisconnectInterfaces != null)
m_DisconnectInterfaces(obj);
=======
var selectionChanged = obj as ISelectionChanged;
if (selectionChanged != null)
evr.m_SelectionChanged -= selectionChanged.OnSelectionChanged;
var toolActions = obj as IActions;
if (toolActions != null)
{
evr.m_ActionsModule.RemoveActions(toolActions.actions);
evr.m_Menus.UpdateAlternateMenuActions();
}
var grabObjects = obj as IGrabObjects;
if (grabObjects != null)
{
var directSelection = evr.m_DirectSelection;
grabObjects.objectGrabbed -= directSelection.OnObjectGrabbed;
grabObjects.objectsDropped -= directSelection.OnObjectsDropped;
}
var usesProjectFolderData = obj as IUsesProjectFolderData;
if (usesProjectFolderData != null)
evr.m_ProjectFolderModule.RemoveConsumer(usesProjectFolderData);
var usesHierarchy = obj as IUsesHierarchyData;
if (usesHierarchy != null)
evr.m_HierarchyModule.RemoveConsumer(usesHierarchy);
var filterUI = obj as IFilterUI;
if (filterUI != null)
evr.m_ProjectFolderModule.RemoveConsumer(filterUI);
var manipulatorVisiblity = obj as IManipulatorVisibility;
if (manipulatorVisiblity != null)
evr.m_UI.manipulatorVisibilities.Remove(manipulatorVisiblity);
var customHighlight = obj as ICustomHighlight;
if (customHighlight != null)
evr.m_HighlightModule.customHighlight -= customHighlight.OnHighlight;
}
byte RequestStencilRef()
{
return stencilRef++;
>>>>>>>
if (m_DisconnectInterfaces != null)
m_DisconnectInterfaces(obj); |
<<<<<<<
{
selectionToolData = toolData;
=======
>>>>>>>
{
selectionToolData = toolData;
<<<<<<<
=======
var mainMenuActivator = Menus.SpawnMainMenuActivator(inputDevice);
deviceData.mainMenuActivator = mainMenuActivator;
mainMenuActivator.selected += Menus.OnMainMenuActivatorSelected;
var pinnedToolButton = Menus.SpawnPinnedToolButton(inputDevice);
deviceData.previousToolButton = pinnedToolButton;
var pinnedToolButtonTransform = pinnedToolButton.transform;
pinnedToolButtonTransform.SetParent(mainMenuActivator.transform, false);
pinnedToolButtonTransform.localPosition = new Vector3(0f, 0f, -0.035f); // Offset from the main menu activator
>>>>>>>
<<<<<<<
=======
else
{
deviceData.menuHideData[deviceData.mainMenu].hideFlags |= MenuHideFlags.Hidden;
}
>>>>>>>
else
{
deviceData.menuHideData[deviceData.mainMenu].hideFlags |= MenuHideFlags.Hidden;
}
<<<<<<<
var pinnedToolsMenu = deviceData.ToolMenu;
var pinnedToolsMenuInput = deviceData.pinnedToolsMenuInput;
if (pinnedToolsMenu != null && pinnedToolsMenuInput != null)
{
// PinnedToolsMenu visibility is handled internally, not via hide flags
if (!maps.Contains(pinnedToolsMenuInput))
maps.Add(pinnedToolsMenuInput);
}
maps.Add(deviceData.directSelectInput);
=======
>>>>>>>
var pinnedToolsMenu = deviceData.ToolMenu;
var pinnedToolsMenuInput = deviceData.pinnedToolsMenuInput;
if (pinnedToolsMenu != null && pinnedToolsMenuInput != null)
{
// PinnedToolsMenu visibility is handled internally, not via hide flags
if (!maps.Contains(pinnedToolsMenuInput))
maps.Add(pinnedToolsMenuInput);
} |
<<<<<<<
using System;
using System.Collections.Generic;
using UnityEditor;
=======
#if UNITY_EDITOR
using ListView;
using System;
using UnityEditor.Experimental.EditorVR.Handles;
using UnityEditor.Experimental.EditorVR.Utilities;
>>>>>>>
#if UNITY_EDITOR
using System;
using System.Collections.Generic;
using UnityEditor.Experimental.EditorVR.Handles;
using UnityEditor.Experimental.EditorVR.Utilities;
<<<<<<<
void OnDropHoverStarted(BaseHandle handle)
{
var color = dropZoneMaterial.color;
color.a = m_DropZoneHighlightAlpha;
dropZoneMaterial.color = color;
}
void OnDropHoverEnded(BaseHandle handle)
{
var color = dropZoneMaterial.color;
color.a = 0;
dropZoneMaterial.color = color;
}
object GetDropObject(BaseHandle handle)
{
return m_DragObject ? data : null;
}
bool CanDrop(BaseHandle handle, object dropObject)
{
var dropData = dropObject as HierarchyData;
if (dropData == null)
return false;
// Dropping on own zone would otherwise move object down
if (dropObject == data)
return false;
if (handle == m_Cube)
return true;
var index = data.index;
if (isExpanded(index))
return true;
var gameObject = (GameObject)EditorUtility.InstanceIDToObject(index);
var dropGameObject = (GameObject)EditorUtility.InstanceIDToObject(dropData.index);
var transform = gameObject.transform;
var dropTransform = dropGameObject.transform;
var siblings = (transform.parent == null && dropTransform.parent == null)
|| (transform.parent && dropTransform.parent == transform.parent);
// Dropping on previous sibling's zone has no effect
if (siblings && transform.GetSiblingIndex() == dropTransform.GetSiblingIndex() - 1)
return false;
return true;
}
void ReceiveDrop(BaseHandle handle, object dropObject)
{
if (m_Settling)
return;
var dropData = dropObject as HierarchyData;
if (dropData != null)
{
var thisIndex = data.index;
var dropIndex = dropData.index;
var gameObject = (GameObject)EditorUtility.InstanceIDToObject(thisIndex);
var dropGameObject = (GameObject)EditorUtility.InstanceIDToObject(dropIndex);
var transform = gameObject.transform;
var dropTransform = dropGameObject.transform;
if (handle == m_Cube)
{
dropTransform.SetParent(transform);
dropTransform.SetAsLastSibling();
EditorApplication.delayCall += () => { setExpanded(thisIndex, true); };
}
else if (handle == m_DropZone)
{
if (isExpanded(thisIndex))
{
dropTransform.SetParent(transform);
dropTransform.SetAsFirstSibling();
}
else if (transform.parent)
{
dropTransform.SetParent(transform.parent);
dropTransform.SetSiblingIndex(transform.GetSiblingIndex() + 1);
}
else
{
var targetIndex = transform.GetSiblingIndex() + 1;
if (dropTransform.parent == transform.parent && dropTransform.GetSiblingIndex() < targetIndex)
targetIndex--;
dropTransform.SetParent(null);
dropTransform.SetSiblingIndex(targetIndex);
}
}
else
{
Debug.Log("huh??");
}
}
else
{
Debug.Log("huh??");
}
}
void OnDestroy()
{
U.Object.Destroy(cubeMaterial);
U.Object.Destroy(dropZoneMaterial);
=======
void ToggleExpanded(BaseHandle handle, HandleEventData eventData)
{
toggleExpanded(data);
}
void SelectFolder(BaseHandle baseHandle, HandleEventData eventData)
{
selectRow(data.instanceID);
}
void OnHoverStarted(BaseHandle baseHandle, HandleEventData eventData)
{
m_Hovering = true;
}
void OnHoverEnded(BaseHandle baseHandle, HandleEventData eventData)
{
m_Hovering = false;
}
void OnDestroy()
{
if (m_CubeRenderer)
ObjectUtils.Destroy(m_CubeRenderer.sharedMaterial);
}
>>>>>>>
public void OnStartSettling()
{
m_Settling = true;
}
public void OnEndSettling()
{
m_Settling = false;
}
protected override void OnSingleClick(BaseHandle handle, HandleEventData eventData)
{
if (m_Settling)
return;
SelectFolder();
ToggleExpanded(handle, eventData);
}
protected override void OnDoubleClick(BaseHandle handle, HandleEventData eventData)
{
var row = handle.transform.parent;
if (row)
{
m_DragObject = transform;
StartCoroutine(Magnetize());
m_VisibleChildren.Clear();
OnGrabRecursive(m_VisibleChildren);
startSettling(null);
}
}
void OnGrabRecursive(List<HierarchyListItem> visibleChildren)
{
m_OldMaterials.Clear();
var graphics = GetComponentsInChildren<Graphic>(true);
foreach (var graphic in graphics)
{
m_OldMaterials[graphic] = graphic.material;
graphic.material = null;
}
m_ExpandArrow.GetComponent<Renderer>().sharedMaterial = m_NoClipExpandArrow;
m_Cube.GetComponent<Renderer>().sharedMaterial = m_NoClipBackingCube;
m_Text.transform.localRotation = Quaternion.AngleAxis(90, Vector3.right);
m_DropZone.gameObject.SetActive(false);
m_Cube.GetComponent<Collider>().enabled = false;
setRowGrabbed(data.index, true);
if (data.children != null)
{
foreach (var child in data.children)
{
var item = getListItem(child.index);
if (item)
{
visibleChildren.Add(item);
item.OnGrabRecursive(visibleChildren);
}
}
}
}
protected override void OnDragging(BaseHandle handle, HandleEventData eventData)
{
base.OnDragging(handle, eventData);
if (m_DragObject)
{
var previewOrigin = getPreviewOriginForRayOrigin(eventData.rayOrigin);
MagnetizeTransform(previewOrigin, m_DragObject);
var offset = 0f;
foreach (var child in m_VisibleChildren)
{
offset += m_Cube.GetComponent<Renderer>().bounds.size.y * m_StackingFraction;
MagnetizeTransform(previewOrigin, child.transform, offset);
}
}
}
void MagnetizeTransform(Transform previewOrigin, Transform transform, float offset = 0)
{
var rotation = MathUtilsExt.ConstrainYawRotation(CameraUtils.GetMainCamera().transform.rotation)
* Quaternion.AngleAxis(90, Vector3.left);
var offsetDirection = rotation * Vector3.one;
MathUtilsExt.LerpTransform(transform, previewOrigin.position - offsetDirection * offset, rotation, m_DragLerp);
}
protected override void OnDragEnded(BaseHandle baseHandle, HandleEventData eventData)
{
if (m_DragObject)
{
OnDragEndRecursive();
startSettling(OnDragEndAfterSettling);
}
base.OnDragEnded(baseHandle, eventData);
}
void OnDragEndRecursive()
{
m_DragLerp = 0;
// OnHierarchyChanged doesn't happen until next frame--delay un-grab so the object doesn't start moving to the wrong spot
EditorApplication.delayCall += () =>
{
setRowGrabbed(data.index, false);
};
foreach (var child in m_VisibleChildren)
{
child.OnDragEndRecursive();
}
}
void OnDragEndAfterSettling()
{
SetClipMaterialsAfterSettling();
foreach (var child in m_VisibleChildren)
{
child.SetClipMaterialsAfterSettling();
}
}
void SetClipMaterialsAfterSettling()
{
foreach (var kvp in m_OldMaterials)
{
kvp.Key.material = kvp.Value;
}
m_Cube.GetComponent<Renderer>().sharedMaterial = cubeMaterial;
m_ExpandArrow.GetComponent<Renderer>().sharedMaterial = m_ExpandArrowMaterial;
m_DropZone.gameObject.SetActive(true);
m_Cube.GetComponent<Collider>().enabled = true;
m_Hovering = false;
}
void ToggleExpanded(BaseHandle handle, HandleEventData eventData)
{
toggleExpanded(data.index);
}
void SelectFolder()
{
selectRow(data.index);
}
void OnHoverStarted(BaseHandle baseHandle, HandleEventData eventData)
{
m_Hovering = true;
}
void OnHoverEnded(BaseHandle baseHandle, HandleEventData eventData)
{
m_Hovering = false;
}
void OnDropHoverStarted(BaseHandle handle)
{
var color = dropZoneMaterial.color;
color.a = m_DropZoneHighlightAlpha;
dropZoneMaterial.color = color;
}
void OnDropHoverEnded(BaseHandle handle)
{
var color = dropZoneMaterial.color;
color.a = 0;
dropZoneMaterial.color = color;
}
object GetDropObject(BaseHandle handle)
{
return m_DragObject ? data : null;
}
bool CanDrop(BaseHandle handle, object dropObject)
{
var dropData = dropObject as HierarchyData;
if (dropData == null)
return false;
// Dropping on own zone would otherwise move object down
if (dropObject == data)
return false;
if (handle == m_Cube)
return true;
var index = data.index;
if (isExpanded(index))
return true;
var gameObject = (GameObject)EditorUtility.InstanceIDToObject(index);
var dropGameObject = (GameObject)EditorUtility.InstanceIDToObject(dropData.index);
var transform = gameObject.transform;
var dropTransform = dropGameObject.transform;
var siblings = (transform.parent == null && dropTransform.parent == null)
|| (transform.parent && dropTransform.parent == transform.parent);
// Dropping on previous sibling's zone has no effect
if (siblings && transform.GetSiblingIndex() == dropTransform.GetSiblingIndex() - 1)
return false;
return true;
}
void ReceiveDrop(BaseHandle handle, object dropObject)
{
if (m_Settling)
return;
var dropData = dropObject as HierarchyData;
if (dropData != null)
{
var thisIndex = data.index;
var dropIndex = dropData.index;
var gameObject = (GameObject)EditorUtility.InstanceIDToObject(thisIndex);
var dropGameObject = (GameObject)EditorUtility.InstanceIDToObject(dropIndex);
var transform = gameObject.transform;
var dropTransform = dropGameObject.transform;
if (handle == m_Cube)
{
dropTransform.SetParent(transform);
dropTransform.SetAsLastSibling();
EditorApplication.delayCall += () => { setExpanded(thisIndex, true); };
}
else if (handle == m_DropZone)
{
if (isExpanded(thisIndex))
{
dropTransform.SetParent(transform);
dropTransform.SetAsFirstSibling();
}
else if (transform.parent)
{
dropTransform.SetParent(transform.parent);
dropTransform.SetSiblingIndex(transform.GetSiblingIndex() + 1);
}
else
{
var targetIndex = transform.GetSiblingIndex() + 1;
if (dropTransform.parent == transform.parent && dropTransform.GetSiblingIndex() < targetIndex)
targetIndex--;
dropTransform.SetParent(null);
dropTransform.SetSiblingIndex(targetIndex);
}
}
else
{
Debug.Log("huh??");
}
}
else
{
Debug.Log("huh??");
}
}
void OnDestroy()
{
ObjectUtils.Destroy(cubeMaterial);
ObjectUtils.Destroy(dropZoneMaterial);
} |
<<<<<<<
sealed class WorkspaceUI : MonoBehaviour, IUsesStencilRef, IUsesViewerScale, IUsesPointer, IUsesNode
=======
sealed class WorkspaceUI : MonoBehaviour, IUsesStencilRef, IUsesViewerScale, IGetPointerLength, IRequestFeedback
>>>>>>>
sealed class WorkspaceUI : MonoBehaviour, IUsesStencilRef, IUsesViewerScale, IUsesPointer, IRequestFeedback
<<<<<<<
[Flags]
enum ResizeDirection
{
Front = 1,
Back = 2,
Left = 4,
Right = 8
}
class DragState
{
public Transform rayOrigin { get; private set; }
bool m_Resizing;
Vector3 m_PositionOffset;
Quaternion m_RotationOffset;
WorkspaceUI m_WorkspaceUI;
Vector3 m_DragStart;
Vector3 m_PositionStart;
Vector3 m_BoundsSizeStart;
ResizeDirection m_Direction;
public DragState(WorkspaceUI workspaceUI, Transform rayOrigin, bool resizing)
{
m_WorkspaceUI = workspaceUI;
m_Resizing = resizing;
this.rayOrigin = rayOrigin;
if (resizing)
{
var pointerPosition = m_WorkspaceUI.GetPointerPosition(rayOrigin);
m_DragStart = pointerPosition;
m_PositionStart = workspaceUI.transform.parent.position;
m_BoundsSizeStart = workspaceUI.bounds.size;
var localPosition = m_WorkspaceUI.transform.InverseTransformPoint(pointerPosition);
m_Direction = m_WorkspaceUI.GetResizeDirectionForLocalPosition(localPosition);
}
else
{
MathUtilsExt.GetTransformOffset(rayOrigin, m_WorkspaceUI.transform.parent, out m_PositionOffset, out m_RotationOffset);
}
}
public void OnDragging()
{
if (m_Resizing)
{
var viewerScale = m_WorkspaceUI.GetViewerScale();
var pointerPosition = m_WorkspaceUI.GetPointerPosition(rayOrigin);
var dragVector = (pointerPosition - m_DragStart) / viewerScale;
var bounds = m_WorkspaceUI.bounds;
var transform = m_WorkspaceUI.transform;
var positionOffsetForward = Vector3.Dot(dragVector, transform.forward) * 0.5f;
var positionOffsetRight = Vector3.Dot(dragVector, transform.right) * 0.5f;
switch (m_Direction)
{
default:
bounds.size = m_BoundsSizeStart + Vector3.back * Vector3.Dot(dragVector, transform.forward);
positionOffsetRight = 0;
break;
case ResizeDirection.Back:
bounds.size = m_BoundsSizeStart + Vector3.forward * Vector3.Dot(dragVector, transform.forward);
positionOffsetRight = 0;
break;
case ResizeDirection.Left:
bounds.size = m_BoundsSizeStart + Vector3.left * Vector3.Dot(dragVector, transform.right);
positionOffsetForward = 0;
break;
case ResizeDirection.Right:
bounds.size = m_BoundsSizeStart + Vector3.right * Vector3.Dot(dragVector, transform.right);
positionOffsetForward = 0;
break;
case ResizeDirection.Front | ResizeDirection.Left:
bounds.size = m_BoundsSizeStart + Vector3.left * Vector3.Dot(dragVector, transform.right)
+ Vector3.back * Vector3.Dot(dragVector, transform.forward);
break;
case ResizeDirection.Front | ResizeDirection.Right:
bounds.size = m_BoundsSizeStart + Vector3.right * Vector3.Dot(dragVector, transform.right)
+ Vector3.back * Vector3.Dot(dragVector, transform.forward);
break;
case ResizeDirection.Back | ResizeDirection.Left:
bounds.size = m_BoundsSizeStart + Vector3.left * Vector3.Dot(dragVector, transform.right)
+ Vector3.forward * Vector3.Dot(dragVector, transform.forward);
break;
case ResizeDirection.Back | ResizeDirection.Right:
bounds.size = m_BoundsSizeStart + Vector3.right * Vector3.Dot(dragVector, transform.right)
+ Vector3.forward * Vector3.Dot(dragVector, transform.forward);
break;
}
if (m_WorkspaceUI.resize != null)
m_WorkspaceUI.resize(bounds);
var currentExtents = m_WorkspaceUI.bounds.extents;
var extents = bounds.extents;
var absRight = Mathf.Abs(positionOffsetRight);
var absForward = Mathf.Abs(positionOffsetForward);
var positionOffset = transform.right * (absRight - (currentExtents.x - extents.x)) * Mathf.Sign(positionOffsetRight)
+ transform.forward * (absForward - (currentExtents.z - extents.z)) * Mathf.Sign(positionOffsetForward);
m_WorkspaceUI.transform.parent.position = m_PositionStart + positionOffset * viewerScale;
m_WorkspaceUI.OnResizing(rayOrigin);
}
else
{
MathUtilsExt.SetTransformOffset(rayOrigin, m_WorkspaceUI.transform.parent, m_PositionOffset, m_RotationOffset);
m_WorkspaceUI.OnMoving(rayOrigin);
}
}
}
=======
>>>>>>>
<<<<<<<
if (m_HovereringRayOrigins.Contains(rayOrigin))
{
var localPosition = transform.InverseTransformPoint(this.GetPointerPosition(rayOrigin));
var direction = GetResizeDirectionForLocalPosition(localPosition);
GetResizeIconForDirection(direction);
}
=======
>>>>>>>
<<<<<<<
var leftPointerPosition = transform.InverseTransformPoint(this.GetPointerPosition(leftRayOrigin));
if (moveResizeLeft.wasJustPressed && (adjustedBounds.Contains(leftPosition) || adjustedBounds.Contains(leftPointerPosition)))
=======
var leftPointerPosition = transform.InverseTransformPoint(GetPointerPositionForRayOrigin(leftRayOrigin));
if (adjustedBounds.Contains(leftPosition) || adjustedBounds.Contains(leftPointerPosition))
{
if (m_LeftMoveFeedback.Count == 0)
ShowLeftMoveFeedback();
if (moveResizeLeft.wasJustPressed)
{
dragRayOrigin = leftRayOrigin;
m_LastResizeIcons.TryGetValue(dragRayOrigin, out dragResizeIcon);
consumeControl(moveResizeLeft);
}
}
else
>>>>>>>
var leftPointerPosition = transform.InverseTransformPoint(this.GetPointerPosition(leftRayOrigin));
if (adjustedBounds.Contains(leftPosition) || adjustedBounds.Contains(leftPointerPosition))
{
if (m_LeftMoveFeedback.Count == 0)
ShowLeftMoveFeedback();
if (moveResizeLeft.wasJustPressed)
{
dragRayOrigin = leftRayOrigin;
m_LastResizeIcons.TryGetValue(dragRayOrigin, out dragResizeIcon);
consumeControl(moveResizeLeft);
}
}
else
<<<<<<<
var rightPointerPosition = transform.InverseTransformPoint(this.GetPointerPosition(rightRayOrigin));
if (moveResizeRight.wasJustPressed && (adjustedBounds.Contains(rightPosition) || adjustedBounds.Contains(rightPointerPosition)))
=======
var rightPointerPosition = transform.InverseTransformPoint(GetPointerPositionForRayOrigin(rightRayOrigin));
if (adjustedBounds.Contains(rightPosition) || adjustedBounds.Contains(rightPointerPosition))
{
if (m_RightMoveFeedback.Count == 0)
ShowRightMoveFeedback();
if (moveResizeRight.wasJustPressed)
{
dragRayOrigin = rightRayOrigin;
m_LastResizeIcons.TryGetValue(dragRayOrigin, out dragResizeIcon);
consumeControl(moveResizeRight);
}
}
else
>>>>>>>
var rightPointerPosition = transform.InverseTransformPoint(this.GetPointerPosition(rightRayOrigin));
if (adjustedBounds.Contains(rightPosition) || adjustedBounds.Contains(rightPointerPosition))
{
if (m_RightMoveFeedback.Count == 0)
ShowRightMoveFeedback();
if (moveResizeRight.wasJustPressed)
{
dragRayOrigin = rightRayOrigin;
m_LastResizeIcons.TryGetValue(dragRayOrigin, out dragResizeIcon);
consumeControl(moveResizeRight);
}
}
else |
<<<<<<<
using System;
using UnityEditor.Experimental.EditorVR.Modules;
=======
>>>>>>>
using System;
using UnityEditor.Experimental.EditorVR.Modules;
<<<<<<<
public void OnRayEnter(RayEventData eventData)
{
// Track which pointer is over us, so this information can supply context (e.g. selecting a tool for a different hand)
m_HoveringRayOrigin = eventData.rayOrigin;
// Enable preview-mode on a pinned tool button; Display on the opposite proxy device via the HoveringRayOrigin
m_HighlightedPinnedToolbutton = previewToolInPinnedToolButton(m_HoveringRayOrigin, toolType);
}
public void OnRayExit(RayEventData eventData)
{
if (m_HoveringRayOrigin == eventData.rayOrigin)
m_HoveringRayOrigin = null;
// Disable preview-mode on pinned tool button
if (m_HighlightedPinnedToolbutton != null)
m_HighlightedPinnedToolbutton.previewToolType = null;
}
=======
>>>>>>>
public void OnRayEnter(RayEventData eventData)
{
// Track which pointer is over us, so this information can supply context (e.g. selecting a tool for a different hand)
m_HoveringRayOrigin = eventData.rayOrigin;
// Enable preview-mode on a pinned tool button; Display on the opposite proxy device via the HoveringRayOrigin
m_HighlightedPinnedToolbutton = previewToolInPinnedToolButton(m_HoveringRayOrigin, toolType);
}
public void OnRayExit(RayEventData eventData)
{
if (m_HoveringRayOrigin == eventData.rayOrigin)
m_HoveringRayOrigin = null;
// Disable preview-mode on pinned tool button
if (m_HighlightedPinnedToolbutton != null)
m_HighlightedPinnedToolbutton.previewToolType = null;
} |
<<<<<<<
=======
[SerializeField]
private MainMenuUI m_MainMenuPrefab;
private MainMenuUI m_MainMenuUI;
private float m_RotationInputStartTime;
private float m_RotationInputStartValue;
private float m_RotationInputIdleTime;
private float m_LastRotationInput;
public Func<GameObject, GameObject> instantiateUI { private get; set; }
public Transform rayOrigin { private get; set; }
public Action hideDefaultRay { private get; set; }
public Action showDefaultRay { private get; set; }
public Func<object, bool> lockRay { private get; set; }
public Func<object, bool> unlockRay { private get; set; }
public List<Type> menuTools { private get; set; }
public List<IModule> menuModules { private get; set; }
public Func<Node, Type, bool> selectTool { private get; set; }
public List<Type> menuWorkspaces { private get; set; }
public Action<Type> createWorkspace { private get; set; }
public Node? node { private get; set; }
public Action setup { get { return Setup; } }
>>>>>>> |
<<<<<<<
var input = deviceData.directSelectInput;
Vector3 contactPoint;
var obj = GetDirectSelectionForRayOrigin(rayOrigin, out contactPoint);
=======
var obj = GetDirectSelectionForRayOrigin(rayOrigin);
>>>>>>>
Vector3 contactPoint;
var obj = GetDirectSelectionForRayOrigin(rayOrigin, out contactPoint);
<<<<<<<
{
m_DirectSelections[rayOrigin] = new DirectSelectionData
{
gameObject = obj,
node = deviceData.node,
input = input,
contactPoint = contactPoint
};
}
=======
m_DirectSelections[rayOrigin] = obj;
>>>>>>>
{
m_DirectSelections[rayOrigin] = new DirectSelectionData
{
gameObject = obj,
contactPoint = contactPoint
};
}
<<<<<<<
var miniWorldRay = ray.Value;
var input = miniWorldRay.directSelectInput;
Vector3 contactPoint;
var go = GetDirectSelectionForRayOrigin(rayOrigin, out contactPoint);
=======
var go = GetDirectSelectionForRayOrigin(rayOrigin);
>>>>>>>
Vector3 contactPoint;
var go = GetDirectSelectionForRayOrigin(rayOrigin, out contactPoint);
<<<<<<<
{
m_DirectSelections[rayOrigin] = new DirectSelectionData
{
gameObject = go,
node = ray.Value.node,
input = input,
contactPoint = contactPoint
};
}
=======
m_DirectSelections[rayOrigin] = go;
>>>>>>>
{
m_DirectSelections[rayOrigin] = new DirectSelectionData
{
gameObject = go,
contactPoint = contactPoint
};
} |
<<<<<<<
public class SelectionTool : MonoBehaviour, ITool, IRay, IRaycaster, ICustomActionMap, IHighlight, IMenuOrigins, ILocking
=======
public class SelectionTool : MonoBehaviour, ITool, IRay, IRaycaster, ICustomActionMap, IHighlight
>>>>>>>
public class SelectionTool : MonoBehaviour, ITool, IRay, IRaycaster, ICustomActionMap, IHighlight, ILocking
<<<<<<<
private ActionMap m_ActionMap;
public Func<Transform, GameObject> getFirstGameObject { private get; set; }
public Transform rayOrigin { private get; set; }
public Action<GameObject, bool> setHighlight { private get; set; }
public Transform menuOrigin { get; set; }
public Node? node { private get; set; }
public Func<bool> toggleLocked { get; set; }
public Func<GameObject, bool> getLocked { get; set; }
public Action<GameObject, Node?> checkHover { get; set; }
=======
ActionMap m_ActionMap;
>>>>>>>
ActionMap m_ActionMap;
<<<<<<<
if (newPrefabRoot != s_CurrentPrefabOpened)
newHoverGameObject = newPrefabRoot;
if (newHoverGameObject.isStatic)
return;
=======
if (newPrefabRoot)
{
if (newPrefabRoot != s_CurrentPrefabOpened)
newHoverGameObject = newPrefabRoot;
}
>>>>>>>
if (newPrefabRoot)
{
if (newPrefabRoot != s_CurrentPrefabOpened)
newHoverGameObject = newPrefabRoot;
}
if (newHoverGameObject.isStatic)
return; |
<<<<<<<
internal void UpdateAlternateMenuOnSelectionChanged(Transform rayOrigin)
=======
internal static void OnMainMenuActivatorHoverStarted(Transform rayOrigin)
{
var deviceData = evr.m_DeviceData.FirstOrDefault(dd => dd.rayOrigin == rayOrigin);
if (deviceData != null)
{
var menus = new List<IMenu>(deviceData.menuHideFlags.Keys);
foreach (var menu in menus)
{
deviceData.menuHideFlags[menu] |= MenuHideFlags.OverActivator;
}
}
}
internal static void OnMainMenuActivatorHoverEnded(Transform rayOrigin)
{
var deviceData = evr.m_DeviceData.FirstOrDefault(dd => dd.rayOrigin == rayOrigin);
if (deviceData != null)
{
var menus = new List<IMenu>(deviceData.menuHideFlags.Keys);
foreach (var menu in menus)
{
deviceData.menuHideFlags[menu] &= ~MenuHideFlags.OverActivator;
}
}
}
internal static void UpdateAlternateMenuOnSelectionChanged(Transform rayOrigin)
>>>>>>>
internal static void UpdateAlternateMenuOnSelectionChanged(Transform rayOrigin)
<<<<<<<
internal GameObject InstantiateMenuUI(Transform rayOrigin, IMenu prefab)
=======
internal static void OnMainMenuActivatorSelected(Transform rayOrigin, Transform targetRayOrigin)
{
var deviceData = evr.m_DeviceData.FirstOrDefault(dd => dd.rayOrigin == rayOrigin);
if (deviceData != null)
{
var mainMenu = deviceData.mainMenu;
if (mainMenu != null)
{
var menuHideFlags = deviceData.menuHideFlags;
menuHideFlags[mainMenu] ^= MenuHideFlags.Hidden;
var customMenu = deviceData.customMenu;
if (customMenu != null)
menuHideFlags[customMenu] &= ~MenuHideFlags.Hidden;
mainMenu.targetRayOrigin = targetRayOrigin;
}
}
}
static GameObject InstantiateMenuUI(Transform rayOrigin, IMenu prefab)
>>>>>>>
static GameObject InstantiateMenuUI(Transform rayOrigin, IMenu prefab)
<<<<<<<
internal void UpdateAlternateMenuActions()
=======
internal static MainMenuActivator SpawnMainMenuActivator(InputDevice device)
{
var mainMenuActivator = ObjectUtils.Instantiate(evr.m_MainMenuActivatorPrefab.gameObject).GetComponent<MainMenuActivator>();
evr.m_Interfaces.ConnectInterfaces(mainMenuActivator, device);
return mainMenuActivator;
}
public static PinnedToolButton SpawnPinnedToolButton(InputDevice device)
{
var button = ObjectUtils.Instantiate(evr.m_PinnedToolButtonPrefab.gameObject).GetComponent<PinnedToolButton>();
evr.m_Interfaces.ConnectInterfaces(button, device);
return button;
}
internal static void UpdateAlternateMenuActions()
>>>>>>>
internal static void UpdateAlternateMenuActions() |
<<<<<<<
/// <summary>
/// You must implement and call this event when the visibility of the menu changes
/// Parameters: main menu instance
/// </summary>
event Action<IMainMenu> menuVisibilityChanged;
// HACK: Awake/Start get called together in ExecuteInEditMode, so calling this method after is a workaround for order of operations
Action setup { get; }
=======
>>>>>>>
/// <summary>
/// You must implement and call this event when the visibility of the menu changes
/// Parameters: main menu instance
/// </summary>
event Action<IMainMenu> menuVisibilityChanged; |
<<<<<<<
using UnityEngine.VR.Actions;
=======
using UnityEngine.VR.Helpers;
using UnityEngine.VR.Manipulators;
>>>>>>>
using UnityEngine.VR.Actions;
using UnityEngine.VR.Helpers;
using UnityEngine.VR.Manipulators;
<<<<<<<
public MainMenuActivator mainMenuActivator;
=======
public ActionMapInput directSelectInput;
>>>>>>>
public MainMenuActivator mainMenuActivator;
public ActionMapInput directSelectInput;
<<<<<<<
while (!m_HMDReady)
yield return null;
// In case we have anything selected at start, set up manipulators, inspector, etc.
EditorApplication.delayCall += OnSelectionChanged;
=======
>>>>>>>
<<<<<<<
// HACK to workaround missing MonoScript serialized fields
EditorApplication.delayCall += () =>
{
mainMenu = SpawnMainMenu(typeof(MainMenu), device, false);
mainMenu.menuVisibilityChanged += OnMainMenuVisiblityChanged;
deviceData.mainMenu = mainMenu;
UpdatePlayerHandleMaps();
};
=======
mainMenu = SpawnMainMenu(typeof(MainMenu), device, true);
deviceData.mainMenu = mainMenu;
UpdatePlayerHandleMaps();
while (mainMenu == null)
yield return null;
menus.Add(mainMenu);
>>>>>>>
mainMenu = SpawnMainMenu(typeof(MainMenu), device, false);
mainMenu.menuVisibilityChanged += OnMainMenuVisiblityChanged;
deviceData.mainMenu = mainMenu;
UpdatePlayerHandleMaps();
<<<<<<<
var toolActions = obj as IToolActions;
if (toolActions != null)
{
var actions = toolActions.toolActions;
foreach (var action in actions)
{
var actionMenuData = new ActionMenuData()
{
name = action.GetType().Name,
sectionName = ActionMenuItemAttribute.kDefaultActionSectionName,
priority = int.MaxValue,
action = action,
};
m_MenuActions.Add(actionMenuData);
}
UpdateAlternateMenuActions();
}
var mainMenu = obj as IMainMenu;
=======
var directSelection = obj as IDirectSelection;
if (directSelection != null)
directSelection.getDirectSelection = GetDirectSelection;
var grabObjects = obj as IGrabObjects;
if (grabObjects != null)
{
grabObjects.canGrabObject = CanGrabObject;
grabObjects.grabObject = GrabObject;
grabObjects.dropObject = DropObject;
}
>>>>>>>
var toolActions = obj as IToolActions;
if (toolActions != null)
{
var actions = toolActions.toolActions;
foreach (var action in actions)
{
var actionMenuData = new ActionMenuData()
{
name = action.GetType().Name,
sectionName = ActionMenuItemAttribute.kDefaultActionSectionName,
priority = int.MaxValue,
action = action,
};
m_MenuActions.Add(actionMenuData);
}
UpdateAlternateMenuActions();
}
var directSelection = obj as IDirectSelection;
if (directSelection != null)
directSelection.getDirectSelection = GetDirectSelection;
var grabObjects = obj as IGrabObjects;
if (grabObjects != null)
{
grabObjects.canGrabObject = CanGrabObject;
grabObjects.grabObject = GrabObject;
grabObjects.dropObject = DropObject;
}
var mainMenu = obj as IMainMenu; |
<<<<<<<
public IMoveWorkspaces moveWorkspacesModule;
=======
public List<GameObject> customMenus;
>>>>>>>
public List<GameObject> customMenus;
public IMoveWorkspaces moveWorkspacesModule; |
<<<<<<<
transform.localScale = Vector3.one * scale;
m_AlternateMenuOrigin.localScale = m_AlternateMenuOriginOriginalLocalScale * scale;
scale = Mathf.SmoothDamp(scale, kTargetScale, ref smoothVelocity, 0.125f, Mathf.Infinity, Time.unscaledDeltaTime);
=======
menuOrigin.localScale = Vector3.one * scale;
alternateMenuOrigin.localScale = m_AlternateMenuOriginOriginalLocalScale * scale;
scale = U.Math.SmoothDamp(scale, kTargetScale, ref smoothVelocity, kSmoothTime, Mathf.Infinity, Time.unscaledDeltaTime);
>>>>>>>
transform.localScale = Vector3.one * scale;
m_AlternateMenuOrigin.localScale = m_AlternateMenuOriginOriginalLocalScale * scale;
scale = U.Math.SmoothDamp(scale, kTargetScale, ref smoothVelocity, kSmoothTime, Mathf.Infinity, Time.unscaledDeltaTime);
<<<<<<<
transform.localScale = Vector3.one * scale;
m_AlternateMenuOrigin.localScale = m_AlternateMenuOriginOriginalLocalScale * scale;
scale = Mathf.SmoothDamp(scale, kTargetScale, ref smoothVelocity, 0.06875f, Mathf.Infinity, Time.unscaledDeltaTime);
=======
menuOrigin.localScale = Vector3.one * scale;
alternateMenuOrigin.localScale = m_AlternateMenuOriginOriginalLocalScale * scale;
scale = U.Math.SmoothDamp(scale, kTargetScale, ref smoothVelocity, kSmoothTime, Mathf.Infinity, Time.unscaledDeltaTime);
>>>>>>>
transform.localScale = Vector3.one * scale;
m_AlternateMenuOrigin.localScale = m_AlternateMenuOriginOriginalLocalScale * scale;
scale = U.Math.SmoothDamp(scale, kTargetScale, ref smoothVelocity, kSmoothTime, Mathf.Infinity, Time.unscaledDeltaTime); |
<<<<<<<
using Shawn.Ulits.PageHost;
=======
//using System.Drawing; //添加引用
//using System.Windows.Forms;
using PRM.Core.Base;
//添加引用，必须用到的
>>>>>>>
using Shawn.Ulits.PageHost;
//添加引用，必须用到的
<<<<<<<
//PageHost.Show(new ServerListPage());
=======
InitTaskTray();
>>>>>>>
InitTaskTray();
<<<<<<<
=======
private void BtnAllServer_Click(object sender, RoutedEventArgs e)
{
((VmMain)this.DataContext).SelectedGroup = "";
}
>>>>>>> |
<<<<<<<
if (activityAdapter == null)
{
string applicationId = configuration.GetSection(MicrosoftAppCredentials.MicrosoftAppIdKey)?.Value;
string applicationPassword = configuration.GetSection(MicrosoftAppCredentials.MicrosoftAppPasswordKey)?.Value;
// create the activity adapter that I will use to send/receive Activity objects with the user
activityAdapter = new BotFrameworkAdapter(applicationId, applicationPassword);
// pick your flavor of Key/Value storage
IStorage storage = new FileStorage(System.IO.Path.GetTempPath());
//IStorage storage = new MemoryStorage();
//IStorage storage = new AzureTableStorage((System.Diagnostics.Debugger.IsAttached) ? "UseDevelopmentStorage=true;" : configuration.GetSection("DataConnectionString")?.Value, tableName: "AlarmBot");
// create bot hooked up to the activity adapater
bot = new Bot(activityAdapter)
.Use(new ConversationStateManagerMiddleware(storage)) // Automatically persist and load the context.State.Conversation
.Use(new UserStateManagerMiddleware(storage)) // Automatically persist and load the context.State.User objects
.Use(new DefaultTopicView())
.Use(new ShowAlarmsTopicView())
.Use(new AddAlarmTopicView())
.Use(new DeleteAlarmTopicView())
.Use(new RegExpRecognizerMiddleware()
.AddIntent("showAlarms", new Regex("show alarms(.*)", RegexOptions.IgnoreCase))
.AddIntent("addAlarm", new Regex("add alarm(.*)", RegexOptions.IgnoreCase))
.AddIntent("deleteAlarm", new Regex("delete alarm(.*)", RegexOptions.IgnoreCase))
.AddIntent("help", new Regex("help(.*)", RegexOptions.IgnoreCase))
.AddIntent("cancel", new Regex("cancel(.*)", RegexOptions.IgnoreCase))
.AddIntent("confirmYes", new Regex("(yes|yep|yessir|^y$)", RegexOptions.IgnoreCase))
.AddIntent("confirmNo", new Regex("(no|nope|^n$)", RegexOptions.IgnoreCase)));
bot.OnReceive(BotReceiveHandler);
}
=======
>>>>>>>
<<<<<<<
// Get the current ActiveTopic from my conversation state
var activeTopic = context.State.ConversationProperties[ConversationProperties.ACTIVETOPIC] as ITopic;
=======
// Get the current ActiveTopic from my persisted conversation state
var activeTopic = context.State.Conversation[ConversationProperties.ACTIVETOPIC] as ITopic;
>>>>>>>
// Get the current ActiveTopic from my persisted conversation state
var activeTopic = context.State.ConversationProperties[ConversationProperties.ACTIVETOPIC] as ITopic; |
<<<<<<<
public Perspex.Controls.WindowState WindowState
{
get
{
switch (GdkWindow.State)
{
case Gdk.WindowState.Iconified:
return Controls.WindowState.Minimized;
case Gdk.WindowState.Maximized:
return Controls.WindowState.Maximized;
default:
return Controls.WindowState.Normal;
}
}
set
{
switch (value)
{
case Controls.WindowState.Minimized:
GdkWindow.Iconify();
break;
case Controls.WindowState.Maximized:
GdkWindow.Maximize();
break;
case Controls.WindowState.Normal:
GdkWindow.Deiconify();
GdkWindow.Unmaximize();
break;
}
}
}
=======
public double Scaling => 1;
>>>>>>>
public Perspex.Controls.WindowState WindowState
{
get
{
switch (GdkWindow.State)
{
case Gdk.WindowState.Iconified:
return Controls.WindowState.Minimized;
case Gdk.WindowState.Maximized:
return Controls.WindowState.Maximized;
default:
return Controls.WindowState.Normal;
}
}
set
{
switch (value)
{
case Controls.WindowState.Minimized:
GdkWindow.Iconify();
break;
case Controls.WindowState.Maximized:
GdkWindow.Maximize();
break;
case Controls.WindowState.Normal:
GdkWindow.Deiconify();
GdkWindow.Unmaximize();
break;
}
}
}
public double Scaling => 1; |
<<<<<<<
return _tl.PointToClient(point / ScalingFactor) * ScalingFactor;
=======
return _tl.PointToScreen(point*Scaling)/Scaling;
>>>>>>>
return _tl.PointToClient(point / Scaling) * Scaling;
<<<<<<<
public WindowState WindowState
{
get { return _window.WindowState; }
set { _window.WindowState = value; }
}
=======
public Action<double> ScalingChanged
{
get { return _tl.ScalingChanged; }
set { _tl.ScalingChanged = value; }
}
>>>>>>>
public WindowState WindowState
{
get { return _window.WindowState; }
set { _window.WindowState = value; }
}
public Action<double> ScalingChanged
{
get { return _tl.ScalingChanged; }
set { _tl.ScalingChanged = value; }
} |
<<<<<<<
private AvaloniaXamlIlCompiler(AvaloniaXamlIlCompilerConfiguration configuration) : base(configuration, true)
=======
private AvaloniaXamlIlCompiler(TransformerConfiguration configuration, XamlLanguageEmitMappings<IXamlILEmitter, XamlILNodeEmitResult> emitMappings)
: base(configuration, emitMappings, true)
>>>>>>>
private AvaloniaXamlIlCompiler(TransformerConfiguration configuration, XamlLanguageEmitMappings<IXamlILEmitter, XamlILNodeEmitResult> emitMappings)
: base(configuration, emitMappings, true)
<<<<<<<
InsertBefore<XamlIlPropertyReferenceResolver>(
new AvaloniaXamlIlTransformInstanceAttachedProperties(),
new AvaloniaXamlIlTransformSyntheticCompiledBindingMembers());
InsertAfter<XamlIlPropertyReferenceResolver>(new AvaloniaXamlIlAvaloniaPropertyResolver());
=======
InsertBefore<PropertyReferenceResolver>(new AvaloniaXamlIlTransformInstanceAttachedProperties());
InsertAfter<PropertyReferenceResolver>(new AvaloniaXamlIlAvaloniaPropertyResolver());
>>>>>>>
InsertBefore<PropertyReferenceResolver>(
new AvaloniaXamlIlTransformInstanceAttachedProperties(),
new AvaloniaXamlIlTransformSyntheticCompiledBindingMembers());
InsertAfter<PropertyReferenceResolver>(new AvaloniaXamlIlAvaloniaPropertyResolver());
<<<<<<<
InsertBefore<XamlIlContentConvertTransformer>(
new AvaloniaXamlIlBindingPathParser(),
=======
InsertBefore<ContentConvertTransformer>(
>>>>>>>
InsertBefore<ContentConvertTransformer>(
new AvaloniaXamlIlBindingPathParser(),
<<<<<<<
public AvaloniaXamlIlCompiler(AvaloniaXamlIlCompilerConfiguration configuration,
IXamlIlType contextType) : this(configuration)
=======
public AvaloniaXamlIlCompiler(TransformerConfiguration configuration,
XamlLanguageEmitMappings<IXamlILEmitter, XamlILNodeEmitResult> emitMappings,
IXamlType contextType) : this(configuration, emitMappings)
>>>>>>>
public AvaloniaXamlIlCompiler(TransformerConfiguration configuration,
XamlLanguageEmitMappings<IXamlILEmitter, XamlILNodeEmitResult> emitMappings,
IXamlType contextType) : this(configuration, emitMappings)
<<<<<<<
public bool DefaultCompileBindings
{
get => _bindingTransformer.CompileBindingsByDefault;
set => _bindingTransformer.CompileBindingsByDefault = value;
}
public void ParseAndCompile(string xaml, string baseUri, IFileSource fileSource, IXamlIlTypeBuilder tb, IXamlIlType overrideRootType)
=======
public void ParseAndCompile(string xaml, string baseUri, IFileSource fileSource, IXamlTypeBuilder<IXamlILEmitter> tb, IXamlType overrideRootType)
>>>>>>>
public bool DefaultCompileBindings
{
get => _bindingTransformer.CompileBindingsByDefault;
set => _bindingTransformer.CompileBindingsByDefault = value;
}
public void ParseAndCompile(string xaml, string baseUri, IFileSource fileSource, IXamlTypeBuilder<IXamlILEmitter> tb, IXamlType overrideRootType) |
<<<<<<<
/// <summary>
/// Gets the entry property.
/// </summary>
/// <value>Array containing event data.</value>
public List<FacebookEntry> Entry { get; } = new List<FacebookEntry>();
=======
public List<FacebookEntry> Entry { get; } = new List<FacebookEntry>();
public bool ShouldSerializeEntry()
{
return Entry.Count > 0;
}
>>>>>>>
/// <summary>
/// Gets the entry property.
/// </summary>
/// <value>Array containing event data.</value>
public List<FacebookEntry> Entry { get; } = new List<FacebookEntry>();
public bool ShouldSerializeEntry()
{
return Entry.Count > 0;
} |
<<<<<<<
IBinding, cfg.WellKnownTypes.Object);
UnsetValueType = cfg.TypeSystem.GetType("Avalonia.UnsetValueType");
=======
IBinding, ctx.Configuration.WellKnownTypes.Object);
UnsetValueType = ctx.Configuration.TypeSystem.GetType("Avalonia.UnsetValueType");
StyledElement = ctx.Configuration.TypeSystem.GetType("Avalonia.StyledElement");
INameScope = ctx.Configuration.TypeSystem.GetType("Avalonia.Controls.INameScope");
INameScopeRegister = INameScope.GetMethod(
new FindMethodMethodSignature("Register", XamlIlTypes.Void,
XamlIlTypes.String, XamlIlTypes.Object)
{
IsStatic = false, DeclaringOnly = true, IsExactMatch = true
});
INameScopeComplete = INameScope.GetMethod(
new FindMethodMethodSignature("Complete", XamlIlTypes.Void)
{
IsStatic = false, DeclaringOnly = true, IsExactMatch = true
});
NameScope = ctx.Configuration.TypeSystem.GetType("Avalonia.Controls.NameScope");
NameScopeSetNameScope = NameScope.GetMethod(new FindMethodMethodSignature("SetNameScope",
XamlIlTypes.Void, StyledElement, INameScope) {IsStatic = true});
>>>>>>>
IBinding, cfg.WellKnownTypes.Object);
UnsetValueType = cfg.TypeSystem.GetType("Avalonia.UnsetValueType");
StyledElement = cfg.TypeSystem.GetType("Avalonia.StyledElement");
INameScope = cfg.TypeSystem.GetType("Avalonia.Controls.INameScope");
INameScopeRegister = INameScope.GetMethod(
new FindMethodMethodSignature("Register", XamlIlTypes.Void,
XamlIlTypes.String, XamlIlTypes.Object)
{
IsStatic = false,
DeclaringOnly = true,
IsExactMatch = true
});
INameScopeComplete = INameScope.GetMethod(
new FindMethodMethodSignature("Complete", XamlIlTypes.Void)
{
IsStatic = false,
DeclaringOnly = true,
IsExactMatch = true
});
NameScope = cfg.TypeSystem.GetType("Avalonia.Controls.NameScope");
NameScopeSetNameScope = NameScope.GetMethod(new FindMethodMethodSignature("SetNameScope",
XamlIlTypes.Void, StyledElement, INameScope)
{ IsStatic = true });
<<<<<<<
IPropertyInfo = cfg.TypeSystem.GetType("Avalonia.Data.Core.IPropertyInfo");
ClrPropertyInfo = cfg.TypeSystem.GetType("Avalonia.Data.Core.ClrPropertyInfo");
PropertyPath = cfg.TypeSystem.GetType("Avalonia.Data.Core.PropertyPath");
PropertyPathBuilder = cfg.TypeSystem.GetType("Avalonia.Data.Core.PropertyPathBuilder");
NotifyingPropertyInfoHelpers = cfg.TypeSystem.GetType("Avalonia.Markup.Xaml.MarkupExtensions.CompiledBindings.NotifyingPropertyInfoHelpers");
CompiledBindingPathBuilder = cfg.TypeSystem.GetType("Avalonia.Markup.Xaml.MarkupExtensions.CompiledBindings.CompiledBindingPathBuilder");
CompiledBindingPath = cfg.TypeSystem.GetType("Avalonia.Markup.Xaml.MarkupExtensions.CompiledBindings.CompiledBindingPath");
CompiledBindingExtension = cfg.TypeSystem.GetType("Avalonia.Markup.Xaml.MarkupExtensions.CompiledBindingExtension");
=======
>>>>>>>
IPropertyInfo = cfg.TypeSystem.GetType("Avalonia.Data.Core.IPropertyInfo");
ClrPropertyInfo = cfg.TypeSystem.GetType("Avalonia.Data.Core.ClrPropertyInfo");
PropertyPath = cfg.TypeSystem.GetType("Avalonia.Data.Core.PropertyPath");
PropertyPathBuilder = cfg.TypeSystem.GetType("Avalonia.Data.Core.PropertyPathBuilder");
NotifyingPropertyInfoHelpers = cfg.TypeSystem.GetType("Avalonia.Markup.Xaml.MarkupExtensions.CompiledBindings.NotifyingPropertyInfoHelpers");
CompiledBindingPathBuilder = cfg.TypeSystem.GetType("Avalonia.Markup.Xaml.MarkupExtensions.CompiledBindings.CompiledBindingPathBuilder");
CompiledBindingPath = cfg.TypeSystem.GetType("Avalonia.Markup.Xaml.MarkupExtensions.CompiledBindings.CompiledBindingPath");
CompiledBindingExtension = cfg.TypeSystem.GetType("Avalonia.Markup.Xaml.MarkupExtensions.CompiledBindingExtension"); |
<<<<<<<
/// <summary>
/// Render Avalonia to a Texture inside the Windows.UI.Composition tree.
/// </summary>
/// <remarks>
/// Supported on Windows 10 build 16299 and above. Ignored on other versions.
/// This is recommended if you need to use AcrylicBlur or acrylic in your applications.
/// </remarks>
public bool UseWindowsUIComposition { get; set; } = true;
=======
public bool UseWgl { get; set; }
public IList<GlVersion> WglProfiles { get; set; } = new List<GlVersion>
{
new GlVersion(GlProfileType.OpenGL, 4, 0),
new GlVersion(GlProfileType.OpenGL, 3, 2),
};
>>>>>>>
public bool UseWgl { get; set; }
public IList<GlVersion> WglProfiles { get; set; } = new List<GlVersion>
{
new GlVersion(GlProfileType.OpenGL, 4, 0),
new GlVersion(GlProfileType.OpenGL, 3, 2),
};
/// <summary>
/// Render Avalonia to a Texture inside the Windows.UI.Composition tree.
/// </summary>
/// <remarks>
/// Supported on Windows 10 build 16299 and above. Ignored on other versions.
/// This is recommended if you need to use AcrylicBlur or acrylic in your applications.
/// </remarks>
public bool UseWindowsUIComposition { get; set; } = true; |
<<<<<<<
public static IList<string> Parse(Reader r, char open, char close, char delimiter = ',')
=======
public static IList<string> Parse(CharacterReader r, char open, char close)
>>>>>>>
public static IList<string> Parse(CharacterReader r, char open, char close, char delimiter = ',') |
<<<<<<<
[Fact]
public void RetainSelectionOnReset_Retains_Selection_On_Reset()
{
var data = new ResettingList<string> { "foo", "bar", "baz" };
var target = new SelectionModel { Source = data, RetainSelectionOnReset = true };
target.SelectRange(new IndexPath(1), new IndexPath(2));
data.Reset();
Assert.Equal(new[] { new IndexPath(1), new IndexPath(2) }, target.SelectedIndices);
Assert.Equal(new[] { "bar", "baz" }, target.SelectedItems);
}
[Fact]
public void RetainSelectionOnReset_Retains_Correct_Selection_After_Deselect()
{
var data = new ResettingList<string> { "foo", "bar", "baz" };
var target = new SelectionModel { Source = data, RetainSelectionOnReset = true };
target.SelectRange(new IndexPath(1), new IndexPath(2));
target.Deselect(2);
data.Reset();
Assert.Equal(new[] { new IndexPath(1) }, target.SelectedIndices);
Assert.Equal(new[] { "bar" }, target.SelectedItems);
}
[Fact]
public void RetainSelectionOnReset_Retains_Correct_Selection_After_Remove_1()
{
var data = new ResettingList<string> { "foo", "bar", "baz" };
var target = new SelectionModel { Source = data, RetainSelectionOnReset = true };
target.SelectRange(new IndexPath(1), new IndexPath(2));
data.RemoveAt(2);
data.Reset(new[] { "foo", "bar", "baz" });
Assert.Equal(new[] { new IndexPath(1) }, target.SelectedIndices);
Assert.Equal(new[] { "bar" }, target.SelectedItems);
}
[Fact]
public void RetainSelectionOnReset_Retains_Correct_Selection_After_Remove_2()
{
var data = new ResettingList<string> { "foo", "bar", "baz" };
var target = new SelectionModel { Source = data, RetainSelectionOnReset = true };
target.SelectRange(new IndexPath(1), new IndexPath(2));
data.RemoveAt(0);
data.Reset(new[] { "foo", "bar", "baz" });
Assert.Equal(new[] { new IndexPath(1), new IndexPath(2) }, target.SelectedIndices);
Assert.Equal(new[] { "bar", "baz" }, target.SelectedItems);
}
[Fact]
public void RetainSelectionOnReset_Retains_No_Selection_After_Clear()
{
var data = new ResettingList<string> { "foo", "bar", "baz" };
var target = new SelectionModel { Source = data, RetainSelectionOnReset = true };
target.SelectRange(new IndexPath(1), new IndexPath(2));
target.ClearSelection();
data.Reset();
Assert.Empty(target.SelectedIndices);
Assert.Empty(target.SelectedItems);
}
[Fact]
public void RetainSelectionOnReset_Retains_Correct_Selection_After_Two_Resets()
{
var data = new ResettingList<string> { "foo", "bar", "baz" };
var target = new SelectionModel { Source = data, RetainSelectionOnReset = true };
target.SelectRange(new IndexPath(1), new IndexPath(2));
data.Reset(new[] { "foo", "bar" });
data.Reset(new[] { "foo", "bar", "baz" });
Assert.Equal(new[] { new IndexPath(1) }, target.SelectedIndices);
Assert.Equal(new[] { "bar", }, target.SelectedItems);
}
[Fact]
public void RetainSelectionOnReset_Raises_Empty_SelectionChanged_On_Reset_With_No_Changes()
{
var data = new ResettingList<string> { "foo", "bar", "baz" };
var target = new SelectionModel { Source = data, RetainSelectionOnReset = true };
var raised = 0;
target.SelectRange(new IndexPath(1), new IndexPath(2));
target.SelectionChanged += (s, e) =>
{
Assert.Empty(e.DeselectedIndices);
Assert.Empty(e.DeselectedItems);
Assert.Empty(e.SelectedIndices);
Assert.Empty(e.SelectedItems);
++raised;
};
data.Reset();
Assert.Equal(1, raised);
}
[Fact]
public void RetainSelectionOnReset_Raises_SelectionChanged_On_Reset_With_Removed_Items()
{
var data = new ResettingList<string> { "foo", "bar", "baz" };
var target = new SelectionModel { Source = data, RetainSelectionOnReset = true };
var raised = 0;
target.SelectRange(new IndexPath(1), new IndexPath(2));
target.SelectionChanged += (s, e) =>
{
Assert.Empty(e.DeselectedIndices);
Assert.Equal(new[] { "bar" }, e.DeselectedItems);
Assert.Empty(e.SelectedIndices);
Assert.Empty(e.SelectedItems);
++raised;
};
data.Reset(new[] { "foo", "baz" });
Assert.Equal(1, raised);
}
[Fact]
public void RetainSelectionOnReset_Handles_Null_Source()
{
var data = new ResettingList<string> { "foo", "bar", "baz" };
var target = new SelectionModel { RetainSelectionOnReset = true };
var raised = 0;
target.SelectionChanged += (s, e) =>
{
if (raised == 0)
{
Assert.Empty(e.DeselectedIndices);
Assert.Empty(e.DeselectedItems);
Assert.Equal(new[] { new IndexPath(1) }, e.SelectedIndices);
Assert.Empty(e.SelectedItems);
}
else if (raised == 1)
{
Assert.Empty(e.DeselectedIndices);
Assert.Empty(e.DeselectedItems);
Assert.Equal(new[] { new IndexPath(1) }, e.SelectedIndices);
Assert.Equal(new[] { "bar" }, e.SelectedItems);
}
else if (raised == 3)
{
Assert.Empty(e.DeselectedIndices);
Assert.Empty(e.DeselectedItems);
Assert.Empty(e.SelectedIndices);
Assert.Empty(e.SelectedItems);
}
++raised;
};
target.Select(1);
Assert.Equal(1, raised);
target.Source = data;
Assert.Equal(2, raised);
Assert.Equal(new[] { new IndexPath(1) }, target.SelectedIndices);
data.Reset(new[] { "qux", "foo", "bar", "baz" });
Assert.Equal(3, raised);
Assert.Equal(new[] { new IndexPath(2) }, target.SelectedIndices);
}
=======
[Fact]
public void Can_Batch_Update()
{
var target = new SelectionModel();
var raised = 0;
target.Source = Enumerable.Range(0, 10).ToList();
target.Select(1);
target.SelectionChanged += (s, e) =>
{
Assert.Equal(new[] { new IndexPath(1) }, e.DeselectedIndices);
Assert.Equal(new object[] { 1 }, e.DeselectedItems);
Assert.Equal(new[] { new IndexPath(4) }, e.SelectedIndices);
Assert.Equal(new object[] { 4 }, e.SelectedItems);
++raised;
};
using (target.Update())
{
target.Deselect(1);
target.Select(4);
}
Assert.Equal(1, raised);
}
>>>>>>>
[Fact]
public void RetainSelectionOnReset_Retains_Selection_On_Reset()
{
var data = new ResettingList<string> { "foo", "bar", "baz" };
var target = new SelectionModel { Source = data, RetainSelectionOnReset = true };
target.SelectRange(new IndexPath(1), new IndexPath(2));
data.Reset();
Assert.Equal(new[] { new IndexPath(1), new IndexPath(2) }, target.SelectedIndices);
Assert.Equal(new[] { "bar", "baz" }, target.SelectedItems);
}
[Fact]
public void RetainSelectionOnReset_Retains_Correct_Selection_After_Deselect()
{
var data = new ResettingList<string> { "foo", "bar", "baz" };
var target = new SelectionModel { Source = data, RetainSelectionOnReset = true };
target.SelectRange(new IndexPath(1), new IndexPath(2));
target.Deselect(2);
data.Reset();
Assert.Equal(new[] { new IndexPath(1) }, target.SelectedIndices);
Assert.Equal(new[] { "bar" }, target.SelectedItems);
}
[Fact]
public void RetainSelectionOnReset_Retains_Correct_Selection_After_Remove_1()
{
var data = new ResettingList<string> { "foo", "bar", "baz" };
var target = new SelectionModel { Source = data, RetainSelectionOnReset = true };
target.SelectRange(new IndexPath(1), new IndexPath(2));
data.RemoveAt(2);
data.Reset(new[] { "foo", "bar", "baz" });
Assert.Equal(new[] { new IndexPath(1) }, target.SelectedIndices);
Assert.Equal(new[] { "bar" }, target.SelectedItems);
}
[Fact]
public void RetainSelectionOnReset_Retains_Correct_Selection_After_Remove_2()
{
var data = new ResettingList<string> { "foo", "bar", "baz" };
var target = new SelectionModel { Source = data, RetainSelectionOnReset = true };
target.SelectRange(new IndexPath(1), new IndexPath(2));
data.RemoveAt(0);
data.Reset(new[] { "foo", "bar", "baz" });
Assert.Equal(new[] { new IndexPath(1), new IndexPath(2) }, target.SelectedIndices);
Assert.Equal(new[] { "bar", "baz" }, target.SelectedItems);
}
[Fact]
public void RetainSelectionOnReset_Retains_No_Selection_After_Clear()
{
var data = new ResettingList<string> { "foo", "bar", "baz" };
var target = new SelectionModel { Source = data, RetainSelectionOnReset = true };
target.SelectRange(new IndexPath(1), new IndexPath(2));
target.ClearSelection();
data.Reset();
Assert.Empty(target.SelectedIndices);
Assert.Empty(target.SelectedItems);
}
[Fact]
public void RetainSelectionOnReset_Retains_Correct_Selection_After_Two_Resets()
{
var data = new ResettingList<string> { "foo", "bar", "baz" };
var target = new SelectionModel { Source = data, RetainSelectionOnReset = true };
target.SelectRange(new IndexPath(1), new IndexPath(2));
data.Reset(new[] { "foo", "bar" });
data.Reset(new[] { "foo", "bar", "baz" });
Assert.Equal(new[] { new IndexPath(1) }, target.SelectedIndices);
Assert.Equal(new[] { "bar", }, target.SelectedItems);
}
[Fact]
public void RetainSelectionOnReset_Raises_Empty_SelectionChanged_On_Reset_With_No_Changes()
{
var data = new ResettingList<string> { "foo", "bar", "baz" };
var target = new SelectionModel { Source = data, RetainSelectionOnReset = true };
var raised = 0;
target.SelectRange(new IndexPath(1), new IndexPath(2));
target.SelectionChanged += (s, e) =>
{
Assert.Empty(e.DeselectedIndices);
Assert.Empty(e.DeselectedItems);
Assert.Empty(e.SelectedIndices);
Assert.Empty(e.SelectedItems);
++raised;
};
data.Reset();
Assert.Equal(1, raised);
}
[Fact]
public void RetainSelectionOnReset_Raises_SelectionChanged_On_Reset_With_Removed_Items()
{
var data = new ResettingList<string> { "foo", "bar", "baz" };
var target = new SelectionModel { Source = data, RetainSelectionOnReset = true };
var raised = 0;
target.SelectRange(new IndexPath(1), new IndexPath(2));
target.SelectionChanged += (s, e) =>
{
Assert.Empty(e.DeselectedIndices);
Assert.Equal(new[] { "bar" }, e.DeselectedItems);
Assert.Empty(e.SelectedIndices);
Assert.Empty(e.SelectedItems);
++raised;
};
data.Reset(new[] { "foo", "baz" });
Assert.Equal(1, raised);
}
[Fact]
public void RetainSelectionOnReset_Handles_Null_Source()
{
var data = new ResettingList<string> { "foo", "bar", "baz" };
var target = new SelectionModel { RetainSelectionOnReset = true };
var raised = 0;
target.SelectionChanged += (s, e) =>
{
if (raised == 0)
{
Assert.Empty(e.DeselectedIndices);
Assert.Empty(e.DeselectedItems);
Assert.Equal(new[] { new IndexPath(1) }, e.SelectedIndices);
Assert.Empty(e.SelectedItems);
}
else if (raised == 1)
{
Assert.Empty(e.DeselectedIndices);
Assert.Empty(e.DeselectedItems);
Assert.Equal(new[] { new IndexPath(1) }, e.SelectedIndices);
Assert.Equal(new[] { "bar" }, e.SelectedItems);
}
else if (raised == 3)
{
Assert.Empty(e.DeselectedIndices);
Assert.Empty(e.DeselectedItems);
Assert.Empty(e.SelectedIndices);
Assert.Empty(e.SelectedItems);
}
++raised;
};
target.Select(1);
Assert.Equal(1, raised);
target.Source = data;
Assert.Equal(2, raised);
Assert.Equal(new[] { new IndexPath(1) }, target.SelectedIndices);
data.Reset(new[] { "qux", "foo", "bar", "baz" });
Assert.Equal(3, raised);
Assert.Equal(new[] { new IndexPath(2) }, target.SelectedIndices);
}
[Fact]
public void Can_Batch_Update()
{
var target = new SelectionModel();
var raised = 0;
target.Source = Enumerable.Range(0, 10).ToList();
target.Select(1);
target.SelectionChanged += (s, e) =>
{
Assert.Equal(new[] { new IndexPath(1) }, e.DeselectedIndices);
Assert.Equal(new object[] { 1 }, e.DeselectedItems);
Assert.Equal(new[] { new IndexPath(4) }, e.SelectedIndices);
Assert.Equal(new object[] { 4 }, e.SelectedItems);
++raised;
};
using (target.Update())
{
target.Deselect(1);
target.Select(4);
}
Assert.Equal(1, raised);
} |
<<<<<<<
var wasNull = _rootNode.Source == null;
if (_rootNode.Source != null)
{
using (var operation = new Operation(this))
{
ClearSelection(resetAnchor: true);
}
}
_rootNode.Source = value;
RaisePropertyChanged("Source");
if (wasNull)
{
var e = new SelectionModelSelectionChangedEventArgs(
null,
SelectedIndices,
null,
SelectedItems);
OnSelectionChanged(e);
}
=======
if (_rootNode.Source != value)
{
ClearSelection(resetAnchor: true, raiseSelectionChanged: false);
_rootNode.Source = value;
OnSelectionChanged();
RaisePropertyChanged("Source");
}
>>>>>>>
if (_rootNode.Source != value)
{
var wasNull = _rootNode.Source == null;
if (_rootNode.Source != null)
{
using (var operation = new Operation(this))
{
ClearSelection(resetAnchor: true);
}
}
_rootNode.Source = value;
RaisePropertyChanged("Source");
if (wasNull)
{
var e = new SelectionModelSelectionChangedEventArgs(
null,
SelectedIndices,
null,
SelectedItems);
OnSelectionChanged(e);
ClearSelection(resetAnchor: true);
_rootNode.Source = value;
OnSelectionChanged();
RaisePropertyChanged("Source");
}
}
<<<<<<<
ClearSelection(resetAnchor: false);
_rootNode?.Dispose();
=======
ClearSelection(resetAnchor: false, raiseSelectionChanged: false);
_rootNode.Dispose();
>>>>>>>
ClearSelection(resetAnchor: false);
_rootNode.Dispose(); |
<<<<<<<
=======
IKeyboardNavigationHandler keyboardNavigation = null,
ILayoutManager layoutManager = null,
Func<IMouseDevice> mouseDevice = null,
>>>>>>>
IKeyboardNavigationHandler keyboardNavigation = null,
Func<IMouseDevice> mouseDevice = null,
<<<<<<<
=======
KeyboardNavigation = keyboardNavigation;
LayoutManager = layoutManager;
MouseDevice = mouseDevice;
>>>>>>>
KeyboardNavigation = keyboardNavigation;
MouseDevice = mouseDevice;
<<<<<<<
=======
public IKeyboardNavigationHandler KeyboardNavigation { get; }
public ILayoutManager LayoutManager { get; }
public Func<IMouseDevice> MouseDevice { get; }
>>>>>>>
public IKeyboardNavigationHandler KeyboardNavigation { get; }
public Func<IMouseDevice> MouseDevice { get; }
<<<<<<<
=======
IKeyboardNavigationHandler keyboardNavigation = null,
ILayoutManager layoutManager = null,
Func<IMouseDevice> mouseDevice = null,
>>>>>>>
IKeyboardNavigationHandler keyboardNavigation = null,
Func<IMouseDevice> mouseDevice = null,
<<<<<<<
=======
keyboardNavigation: keyboardNavigation ?? KeyboardNavigation,
layoutManager: layoutManager ?? LayoutManager,
mouseDevice: mouseDevice ?? MouseDevice,
>>>>>>>
keyboardNavigation: keyboardNavigation ?? KeyboardNavigation,
mouseDevice: mouseDevice ?? MouseDevice, |
<<<<<<<
using Avalonia.OpenGL.Angle;
=======
using Avalonia.OpenGL.Egl;
using Avalonia.OpenGL.Surfaces;
>>>>>>>
using Avalonia.OpenGL.Angle;
using Avalonia.OpenGL.Egl;
using Avalonia.OpenGL.Surfaces;
<<<<<<<
if (Win32GlManager.EglFeature != null)
{
if (_isUsingComposition)
{
var cgl = new CompositionEglGlPlatformSurface(Win32GlManager.EglFeature.DeferredContext, this);
_blurHost = cgl.AttachToCompositionTree(_hwnd);
_gl = cgl;
_isUsingComposition = true;
}
else
{
_gl = new EglGlPlatformSurface(Win32GlManager.EglFeature.DeferredContext, this);
}
}
=======
if (Win32GlManager.EglPlatformInterface != null)
_gl = new EglGlPlatformSurface(Win32GlManager.EglPlatformInterface, this);
>>>>>>>
if (Win32GlManager.EglPlatformInterface != null)
{
if (_isUsingComposition)
{
var cgl = new CompositionEglGlPlatformSurface(Win32GlManager.EglPlatformInterface, this);
_blurHost = cgl.AttachToCompositionTree(_hwnd);
_gl = cgl;
_isUsingComposition = true;
}
else
{
_gl = new EglGlPlatformSurface(Win32GlManager.EglPlatformInterface, this);
}
} |
<<<<<<<
UpdatePseudoClasses(IsChecked);
=======
PseudoClass<ToggleButton, bool?>(IsCheckedProperty, c => c == true, ":checked");
PseudoClass<ToggleButton, bool?>(IsCheckedProperty, c => c == false, ":unchecked");
PseudoClass<ToggleButton, bool?>(IsCheckedProperty, c => c == null, ":indeterminate");
IsCheckedProperty.Changed.AddClassHandler<ToggleButton>((x, e) => x.OnIsCheckedChanged(e));
}
/// <summary>
/// Raised when a <see cref="ToggleButton"/> is checked.
/// </summary>
public event EventHandler<RoutedEventArgs> Checked
{
add => AddHandler(CheckedEvent, value);
remove => RemoveHandler(CheckedEvent, value);
}
/// <summary>
/// Raised when a <see cref="ToggleButton"/> is unchecked.
/// </summary>
public event EventHandler<RoutedEventArgs> Unchecked
{
add => AddHandler(UncheckedEvent, value);
remove => RemoveHandler(UncheckedEvent, value);
}
/// <summary>
/// Raised when a <see cref="ToggleButton"/> is neither checked nor unchecked.
/// </summary>
public event EventHandler<RoutedEventArgs> Indeterminate
{
add => AddHandler(IndeterminateEvent, value);
remove => RemoveHandler(IndeterminateEvent, value);
>>>>>>>
UpdatePseudoClasses(IsChecked);
IsCheckedProperty.Changed.AddClassHandler<ToggleButton>((x, e) => x.OnIsCheckedChanged(e));
}
/// <summary>
/// Raised when a <see cref="ToggleButton"/> is checked.
/// </summary>
public event EventHandler<RoutedEventArgs> Checked
{
add => AddHandler(CheckedEvent, value);
remove => RemoveHandler(CheckedEvent, value);
}
/// <summary>
/// Raised when a <see cref="ToggleButton"/> is unchecked.
/// </summary>
public event EventHandler<RoutedEventArgs> Unchecked
{
add => AddHandler(UncheckedEvent, value);
remove => RemoveHandler(UncheckedEvent, value);
}
/// <summary>
/// Raised when a <see cref="ToggleButton"/> is neither checked nor unchecked.
/// </summary>
public event EventHandler<RoutedEventArgs> Indeterminate
{
add => AddHandler(IndeterminateEvent, value);
remove => RemoveHandler(IndeterminateEvent, value);
<<<<<<<
get { return _isChecked; }
set
{
SetAndRaise(IsCheckedProperty, ref _isChecked, value);
UpdatePseudoClasses(value);
}
=======
get => _isChecked;
set => SetAndRaise(IsCheckedProperty, ref _isChecked, value);
>>>>>>>
get => _isChecked;
set
{
SetAndRaise(IsCheckedProperty, ref _isChecked, value);
UpdatePseudoClasses(value);
} |
<<<<<<<
public IntPtr OrphanedWindow { get; private set; }
=======
public X11Globals Globals { get; private set; }
>>>>>>>
public IntPtr OrphanedWindow { get; private set; }
public X11Globals Globals { get; private set; } |
<<<<<<<
/// <summary>
/// Handles a paint notification from <see cref="ITopLevelImpl.Resized"/>.
/// </summary>
/// <param name="rect">The dirty area.</param>
protected virtual void HandlePaint(Rect rect)
{
Renderer?.Paint(rect);
}
=======
/// <summary>
/// Handles a closed notification from <see cref="ITopLevelImpl.Closed"/>.
/// </summary>
protected virtual void HandleClosed()
{
Closed?.Invoke(this, EventArgs.Empty);
Renderer?.Dispose();
Renderer = null;
_applicationLifecycle.OnExit -= OnApplicationExiting;
}
>>>>>>>
/// <summary>
/// Handles a paint notification from <see cref="ITopLevelImpl.Resized"/>.
/// </summary>
/// <param name="rect">The dirty area.</param>
protected virtual void HandlePaint(Rect rect)
{
Renderer?.Paint(rect);
}
/// <summary>
/// Handles a closed notification from <see cref="ITopLevelImpl.Closed"/>.
/// </summary>
protected virtual void HandleClosed()
{
Closed?.Invoke(this, EventArgs.Empty);
Renderer?.Dispose();
Renderer = null;
_applicationLifecycle.OnExit -= OnApplicationExiting;
}
<<<<<<<
/// <summary>
/// Handles a closed notification from <see cref="ITopLevelImpl.Closed"/>.
/// </summary>
private void HandleClosed()
{
IsVisible = false;
Closed?.Invoke(this, EventArgs.Empty);
Renderer?.Dispose();
Renderer = null;
_applicationLifecycle.OnExit -= OnApplicationExiting;
}
=======
>>>>>>> |
<<<<<<<
var luisRecognizer = this.GetLuisRecognizer(verbose: true);
var result = await luisRecognizer.Recognize("My name is Emad", CancellationToken.None);
=======
var luisRecognizer = GetLuisRecognizer(verbose: true);
var result = await luisRecognizer.RecognizeAsync("My name is Emad", CancellationToken.None);
>>>>>>>
var luisRecognizer = this.GetLuisRecognizer(verbose: true);
var result = await luisRecognizer.RecognizeAsync("My name is Emad", CancellationToken.None);
<<<<<<<
var luisRecognizer = this.GetLuisRecognizer(verbose: true, luisOptions: new LuisPredictionOptions { Verbose = true });
var result = await luisRecognizer.Recognize("Please deliver February 2nd 2001", CancellationToken.None);
=======
var luisRecognizer = GetLuisRecognizer(verbose: true, luisOptions: new LuisRequest { Verbose = true });
var result = await luisRecognizer.RecognizeAsync("Please deliver February 2nd 2001", CancellationToken.None);
>>>>>>>
var luisRecognizer = this.GetLuisRecognizer(verbose: true, luisOptions: new LuisPredictionOptions { Verbose = true });
var result = await luisRecognizer.RecognizeAsync("Please deliver February 2nd 2001", CancellationToken.None);
<<<<<<<
var luisRecognizer = this.GetLuisRecognizer(verbose: true, luisOptions: new LuisPredictionOptions { Verbose = true });
var result = await luisRecognizer.Recognize("Please deliver February 2nd 2001 in room 201", CancellationToken.None);
=======
var luisRecognizer = GetLuisRecognizer(verbose: true, luisOptions: new LuisRequest { Verbose = true });
var result = await luisRecognizer.RecognizeAsync("Please deliver February 2nd 2001 in room 201", CancellationToken.None);
>>>>>>>
var luisRecognizer = this.GetLuisRecognizer(verbose: true, luisOptions: new LuisPredictionOptions { Verbose = true });
var result = await luisRecognizer.RecognizeAsync("Please deliver February 2nd 2001 in room 201", CancellationToken.None);
<<<<<<<
var luisRecognizer = this.GetLuisRecognizer(verbose: true, luisOptions: new LuisPredictionOptions { Verbose = true });
var result = await luisRecognizer.Recognize("I want to travel on united", CancellationToken.None);
=======
var luisRecognizer = GetLuisRecognizer(verbose: true, luisOptions: new LuisRequest { Verbose = true });
var result = await luisRecognizer.RecognizeAsync("I want to travel on united", CancellationToken.None);
>>>>>>>
var luisRecognizer = this.GetLuisRecognizer(verbose: true, luisOptions: new LuisPredictionOptions { Verbose = true });
var result = await luisRecognizer.RecognizeAsync("I want to travel on united", CancellationToken.None);
<<<<<<<
var luisRecognizer = this.GetLuisRecognizer(verbose: true, luisOptions: new LuisPredictionOptions { Verbose = true });
var result = await luisRecognizer.Recognize("I want to travel on DL", CancellationToken.None);
=======
var luisRecognizer = GetLuisRecognizer(verbose: true, luisOptions: new LuisRequest { Verbose = true });
var result = await luisRecognizer.RecognizeAsync("I want to travel on DL", CancellationToken.None);
>>>>>>>
var luisRecognizer = this.GetLuisRecognizer(verbose: true, luisOptions: new LuisPredictionOptions { Verbose = true });
var result = await luisRecognizer.RecognizeAsync("I want to travel on DL", CancellationToken.None);
<<<<<<<
var luisRecognizer = this.GetLuisRecognizer(verbose: true, luisOptions: new LuisPredictionOptions { Verbose = true });
var result = await luisRecognizer.Recognize("Please deliver it to 98033 WA", CancellationToken.None);
=======
var luisRecognizer = GetLuisRecognizer(verbose: true, luisOptions: new LuisRequest { Verbose = true });
var result = await luisRecognizer.RecognizeAsync("Please deliver it to 98033 WA", CancellationToken.None);
>>>>>>>
var luisRecognizer = this.GetLuisRecognizer(verbose: true, luisOptions: new LuisPredictionOptions { Verbose = true });
var result = await luisRecognizer.RecognizeAsync("Please deliver it to 98033 WA", CancellationToken.None);
<<<<<<<
var luisRecognizer = this.GetLuisRecognizer(verbose: true, luisOptions: new LuisPredictionOptions { Verbose = true });
var result = await luisRecognizer.Recognize("Book a table on Friday or tomorrow at 5 or tomorrow at 4", CancellationToken.None);
=======
var luisRecognizer = GetLuisRecognizer(verbose: true, luisOptions: new LuisRequest { Verbose = true });
var result = await luisRecognizer.RecognizeAsync("Book a table on Friday or tomorrow at 5 or tomorrow at 4", CancellationToken.None);
>>>>>>>
var luisRecognizer = this.GetLuisRecognizer(verbose: true, luisOptions: new LuisPredictionOptions { Verbose = true });
var result = await luisRecognizer.RecognizeAsync("Book a table on Friday or tomorrow at 5 or tomorrow at 4", CancellationToken.None);
<<<<<<<
=> (JObject)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(result, new JsonSerializerSettings { Formatting = Formatting.Indented, NullValueHandling = NullValueHandling.Ignore }));
=======
{
return (JObject)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(result, new JsonSerializerSettings { Formatting = Formatting.Indented, NullValueHandling = NullValueHandling.Ignore }));
}
// To create a file to test:
// 1) Create a <name>.json file with an object { Text:<query> } in it.
// 2) Run this test which will fail and generate a <name>.json.new file.
// 3) Check the .new file and if correct, replace the original .json file with it.
public async Task TestJson<T>(string file)
where T : IRecognizerConvert, new()
{
if (!EnvironmentVariablesDefined())
{
Assert.Inconclusive("Missing Luis Environment variables - Skipping test");
return;
}
var expectedPath = Path.Combine(@"..\..\..\TestData\", file);
var newPath = expectedPath + ".new";
var luisRecognizer = GetLuisRecognizer(verbose: true, luisOptions: new LuisRequest { Verbose = true });
var expected = new StreamReader(expectedPath).ReadToEnd();
dynamic expectedJson = JsonConvert.DeserializeObject(expected);
var query = (string)expectedJson.text ?? (string)expectedJson.Text;
var typedResult = await luisRecognizer.RecognizeAsync<T>(query, CancellationToken.None);
var typedJson = Json<T>(typedResult);
if (!WithinDelta(expectedJson, typedJson, 0.1))
{
using (var writer = new StreamWriter(newPath))
{
writer.Write(typedJson);
}
Assert.Fail($"Returned JSON in {newPath} != expected JSON in {expectedPath}");
}
else
{
File.Delete(expectedPath + ".new");
}
}
[TestMethod]
public async Task Composite1()
{
await TestJson<RecognizerResult>("Composite1.json");
}
[TestMethod]
public async Task Composite2()
{
await TestJson<RecognizerResult>("Composite2.json");
}
[TestMethod]
public async Task PrebuiltDomains()
{
await TestJson<RecognizerResult>("Prebuilt.json");
}
[TestMethod]
public async Task Patterns()
{
await TestJson<RecognizerResult>("Patterns.json");
}
[TestMethod]
public async Task TypedEntities()
{
await TestJson<Contoso_App>("Typed.json");
}
[TestMethod]
public async Task TypedPrebuiltDomains()
{
await TestJson<Contoso_App>("TypedPrebuilt.json");
}
>>>>>>>
=> (JObject)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(result, new JsonSerializerSettings { Formatting = Formatting.Indented, NullValueHandling = NullValueHandling.Ignore }));
var typedResult = await luisRecognizer.RecognizeAsync<T>(query, CancellationToken.None); |
Subsets and Splits