protected override void OnEnable()
{
base.OnEnable();
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured(false))
{
return;
}
inputActionList = serializedObject.FindProperty("inputActions");
}
protected override void OnEnable()
{
base.OnEnable();
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured(false))
{
return;
}
registeredNetworkDataProviders = serializedObject.FindProperty("registeredNetworkDataProviders");
}
/// <inheritdoc />
public override void OnInspectorGUI()
{
MixedRealityInspectorUtility.RenderMixedRealityToolkitLogo();
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured())
{
return;
}
if (!MixedRealityToolkit.Instance.ActiveProfile.IsSpatialAwarenessSystemEnabled)
{
EditorGUILayout.HelpBox("The Spatial Awareness Observer Data Provider requires that the spatial awareness system be enabled.", MessageType.Error);
if (GUILayout.Button("Back to Configuration Profile"))
{
Selection.activeObject = MixedRealityToolkit.Instance.ActiveProfile;
}
return;
}
if (GUILayout.Button("Back to Spatial Awareness Profile"))
{
Selection.activeObject = MixedRealityToolkit.Instance.ActiveProfile.SpatialAwarenessProfile;
}
EditorGUILayout.Space();
EditorGUILayout.LabelField("Spatial Observer Options", EditorStyles.boldLabel);
EditorGUILayout.HelpBox("The Spatial Awareness Observer Data Provider supplies the Spatial Awareness system with all the data it needs to understand the world around you.", MessageType.Info);
EditorGUILayout.Space();
if (MixedRealityPreferences.LockProfiles && !((BaseMixedRealityProfile)target).IsCustomProfile)
{
GUI.enabled = false;
}
serializedObject.Update();
foldout = EditorGUILayout.Foldout(foldout, "General Settings", true);
if (foldout)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(startupBehavior);
EditorGUILayout.PropertyField(observationExtents);
EditorGUILayout.PropertyField(isStationaryObserver);
EditorGUILayout.PropertyField(updateInterval);
EditorGUILayout.PropertyField(physicsLayer);
EditorGUI.indentLevel--;
}
serializedObject.ApplyModifiedProperties();
}
public override void OnInspectorGUI()
{
RenderMixedRealityToolkitLogo();
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured())
{
return;
}
if (!MixedRealityToolkit.Instance.ActiveProfile.IsInputSystemEnabled)
{
EditorGUILayout.HelpBox("No input system is enabled, or you need to specify the type in the main configuration profile.", MessageType.Error);
DrawBacktrackProfileButton("Back to Configuration Profile", MixedRealityToolkit.Instance.ActiveProfile);
return;
}
if (DrawBacktrackProfileButton("Back to Input Profile", MixedRealityToolkit.Instance.ActiveProfile.InputSystemProfile))
{
return;
}
EditorGUILayout.Space();
EditorGUILayout.LabelField("Controller Input Mapping", EditorStyles.boldLabel);
EditorGUILayout.HelpBox("Use this profile to define all the controllers and their inputs your users will be able to use in your application.\n\n" +
"You'll want to define all your Input Actions first. They can then be wired up to hardware sensors, controllers, gestures, and other input devices.", MessageType.Info);
if (MixedRealityToolkit.Instance.ActiveProfile.InputSystemProfile.InputActionsProfile == null)
{
EditorGUILayout.HelpBox("No input actions found, please specify a input action profile in the main configuration.", MessageType.Error);
return;
}
CheckProfileLock(target);
if (controllerButtonStyle == null)
{
controllerButtonStyle = new GUIStyle("LargeButton")
{
imagePosition = ImagePosition.ImageAbove,
fontStyle = FontStyle.Bold,
stretchHeight = true,
stretchWidth = true,
wordWrap = true,
fontSize = 10,
};
}
serializedObject.Update();
RenderControllerList(mixedRealityControllerMappingProfiles);
serializedObject.ApplyModifiedProperties();
}
public override void OnInspectorGUI()
{
RenderMixedRealityToolkitLogo();
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured())
{
return;
}
if (DrawBacktrackProfileButton("Back to Configuration Profile", MixedRealityToolkit.Instance.ActiveProfile))
{
return;
}
CheckProfileLock(target);
serializedObject.Update();
EditorGUILayout.Space();
EditorGUILayout.LabelField("Diagnostic Visualization Options", EditorStyles.boldLabel);
EditorGUILayout.HelpBox("Diagnostic visualizations can help monitor system resources and performance inside an application.", MessageType.Info);
EditorGUILayout.Space();
showGeneralSettings = EditorGUILayout.Foldout(showGeneralSettings, "General Settings", true);
if (showGeneralSettings)
{
using (new EditorGUI.IndentLevelScope())
{
EditorGUILayout.PropertyField(showDiagnostics);
if (!showDiagnostics.boolValue)
{
EditorGUILayout.Space();
EditorGUILayout.HelpBox("Diagnostic visualizations have been globally disabled.", MessageType.Info);
EditorGUILayout.Space();
}
}
}
EditorGUILayout.Space();
showProfilerSettings = EditorGUILayout.Foldout(showProfilerSettings, "Profiler Settings", true);
if (showProfilerSettings)
{
using (new EditorGUI.IndentLevelScope())
{
EditorGUILayout.PropertyField(showProfiler);
EditorGUILayout.PropertyField(frameSampleRate);
EditorGUILayout.PropertyField(windowAnchor);
EditorGUILayout.PropertyField(windowOffset);
EditorGUILayout.PropertyField(windowScale);
EditorGUILayout.PropertyField(windowFollowSpeed);
}
}
serializedObject.ApplyModifiedProperties();
}
protected override void OnEnable()
{
base.OnEnable();
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured(false))
{
return;
}
smoothEyeTracking = serializedObject.FindProperty("smoothEyeTracking");
}
protected override void OnEnable()
{
base.OnEnable();
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured(false))
{
return;
}
mouseSpeed = serializedObject.FindProperty("mouseSpeed");
}
protected void RenderHeader()
{
MixedRealityInspectorUtility.RenderMixedRealityToolkitLogo();
if (ThisProfile.ParentProfile != null &&
GUILayout.Button("Back to parent profile"))
{
Selection.activeObject = ThisProfile.ParentProfile;
}
EditorGUILayout.Space();
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured(false))
{
return;
}
if (!MixedRealityToolkit.Instance.ActiveProfile.IsInputSystemEnabled)
{
EditorGUILayout.HelpBox("No input system is enabled, or you need to specify the type in the main configuration profile.", MessageType.Error);
return;
}
if (MixedRealityToolkit.Instance.ActiveProfile.InputSystemProfile.SpeechCommandsProfile == null)
{
EditorGUILayout.HelpBox("No Speech Commands Profile Found, be sure to specify a profile in the Input System's configuration profile.", MessageType.Error);
return;
}
if (registeredKeywords == null || registeredKeywords.Length == 0)
{
registeredKeywords = RegisteredKeywords().Distinct().ToArray();
EditorGUILayout.HelpBox("No keywords registered.\n\nKeywords can be registered via Speech Commands Profile on the Mixed Reality Toolkit's Configuration Profile.", MessageType.Error);
return;
}
serializedObject.Update();
EditorGUILayout.PropertyField(persistentKeywordsProperty);
ShowList(keywordsProperty);
serializedObject.ApplyModifiedProperties();
// error and warning messages
if (keywordsProperty.arraySize == 0)
{
EditorGUILayout.HelpBox("No keywords have been assigned!", MessageType.Warning);
}
else
{
var handler = (SpeechInputHandler)target;
string duplicateKeyword = handler.Keywords
.GroupBy(keyword => keyword.Keyword.ToLower())
.Where(group => group.Count() > 1)
.Select(group => group.Key).FirstOrDefault();
if (duplicateKeyword != null)
{
EditorGUILayout.HelpBox($"Keyword \'{duplicateKeyword}\' is assigned more than once!", MessageType.Warning);
}
}
}
protected override void OnEnable()
{
base.OnEnable();
keywordsProperty = serializedObject.FindProperty("keywords");
persistentKeywordsProperty = serializedObject.FindProperty("persistentKeywords");
if (MixedRealityInspectorUtility.CheckMixedRealityConfigured(false))
{
registeredKeywords = RegisteredKeywords().Distinct().ToArray();
}
}
protected override void OnEnable()
{
base.OnEnable();
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured(false))
{
return;
}
configurations = serializedObject.FindProperty("configurations");
configFoldouts = new bool[configurations.arraySize];
}
// todo: coming soon
// private SerializedProperty isDebugPanelVisible;
protected override void OnEnable()
{
base.OnEnable();
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured(false))
{
return;
}
showDiagnostics = serializedObject.FindProperty("showDiagnostics");
showProfiler = serializedObject.FindProperty("showProfiler");
}
/// <inheritdoc />
protected override void OnEnable()
{
base.OnEnable();
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured(false))
{
return;
}
registeredSpatialObserverDataProviders = serializedObject.FindProperty("registeredSpatialObserverDataProviders");
foldouts = new bool[registeredSpatialObserverDataProviders.arraySize];
}
/// <summary>
/// Renders a <see cref="Microsoft.MixedReality.Toolkit.BaseMixedRealityProfile"/>.
/// </summary>
/// <param name="property">the <see cref="Microsoft.MixedReality.Toolkit.BaseMixedRealityProfile"/> property.</param>
/// <param name="showAddButton">If true, draw the clone button, if false, don't</param>
/// <param name="renderProfileInBox">if true, render box around profile content, if false, don't</param>
/// <param name="serviceType">Optional service type to limit available profile types.</param>
/// <returns>True, if the profile changed.</returns>
private static bool RenderProfileInternal(SerializedProperty property, Type profileType,
bool showAddButton, bool renderProfileInBox, Type serviceType = null)
{
var profile = property.serializedObject.targetObject as BaseMixedRealityProfile;
bool changed = false;
var oldObject = property.objectReferenceValue;
if (profileType != null && !profileType.IsSubclassOf(typeof(BaseMixedRealityProfile)) && profileType != typeof(BaseMixedRealityProfile))
{
// If they've drag-and-dropped a non-profile scriptable object, set it to null.
profileType = null;
}
// If we're constraining this to a service type, check whether the profile is valid
// If it isn't, issue a warning.
if (serviceType != null && oldObject != null)
{
if (!MixedRealityProfileUtility.IsProfileForService(oldObject.GetType(), serviceType))
{
EditorGUILayout.HelpBox("This profile is not supported for " + serviceType.Name + ". Using an unsupported service may result in unexpected behavior.", MessageType.Warning);
}
}
// Find the profile type so we can limit the available object field options
if (serviceType != null)
{
// If GetProfileTypesForService has a count greater than one, then it won't be possible to use
// EditorGUILayout.ObjectField to restrict the set of profiles to a single type - in this
// case all profiles of BaseMixedRealityProfile will be visible in the picker.
//
// However in the case where there is just a single profile type for the service, we can improve
// upon the user experience by limiting the set of things that show in the picker by restricting
// the set of profiles listed to only that type.
profileType = MixedRealityProfileUtility.GetProfileTypesForService(serviceType).FirstOrDefault();
}
// If the profile type is still null, just set it to base profile type
if (profileType == null)
{
profileType = typeof(BaseMixedRealityProfile);
}
// Draw the profile dropdown
changed |= MixedRealityInspectorUtility.DrawProfileDropDownList(property, profile, oldObject, profileType, showAddButton);
Debug.Assert(profile != null, "No profile was set in OnEnable. Did you forget to call base.OnEnable in a derived profile class?");
// Draw the sub-profile editor
MixedRealityInspectorUtility.DrawSubProfileEditor(property.objectReferenceValue, renderProfileInBox);
return(changed);
}
public override void OnInspectorGUI()
{
RenderMixedRealityToolkitLogo();
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured())
{
return;
}
if (!MixedRealityToolkit.Instance.ActiveProfile.IsInputSystemEnabled)
{
EditorGUILayout.HelpBox("No input system is enabled, or you need to specify the type in the main configuration profile.", MessageType.Error);
if (GUILayout.Button("Back to Configuration Profile"))
{
Selection.activeObject = MixedRealityToolkit.Instance.ActiveProfile;
}
return;
}
if (GUILayout.Button("Back to Input Profile"))
{
Selection.activeObject = MixedRealityToolkit.Instance.ActiveProfile.InputSystemProfile;
}
EditorGUILayout.Space();
EditorGUILayout.LabelField("Gesture Input", EditorStyles.boldLabel);
EditorGUILayout.HelpBox("This gesture map is any and all movements of part the user's body, especially a hand or the head, that raise actions through the input system.\n\nNote: Defined controllers can look up the list of gestures and raise the events based on specific criteria.", MessageType.Info);
if (MixedRealityToolkit.Instance.ActiveProfile.InputSystemProfile.InputActionsProfile == null)
{
EditorGUILayout.HelpBox("No input actions found, please specify a input action profile in the main configuration.", MessageType.Error);
return;
}
CheckProfileLock(target);
serializedObject.Update();
EditorGUILayout.Space();
EditorGUILayout.LabelField("Windows Gesture Settings", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(windowsManipulationGestureSettings);
EditorGUILayout.PropertyField(windowsNavigationGestureSettings);
EditorGUILayout.PropertyField(useRailsNavigation);
EditorGUILayout.PropertyField(windowsRailsNavigationGestures);
EditorGUILayout.PropertyField(windowsGestureAutoStart);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Defined Recognizable Gestures", EditorStyles.boldLabel);
RenderList(gestures);
serializedObject.ApplyModifiedProperties();
}
protected override void OnEnable()
{
base.OnEnable();
keywordsProperty = serializedObject.FindProperty("keywords");
persistentKeywordsProperty = serializedObject.FindProperty("persistentKeywords");
speechConfirmationTooltipPrefabProperty = serializedObject.FindProperty("speechConfirmationTooltipPrefab");
if (MixedRealityInspectorUtility.CheckMixedRealityConfigured(false))
{
distinctRegisteredKeywords = GetDistinctRegisteredKeywords();
}
}
public override void OnInspectorGUI()
{
MixedRealityInspectorUtility.RenderMixedRealityToolkitLogo();
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured())
{
return;
}
if (GUILayout.Button("Back to Configuration Profile"))
{
Selection.activeObject = MixedRealityToolkit.Instance.ActiveProfile;
}
EditorGUILayout.Space();
EditorGUILayout.LabelField("Camera Profile", EditorStyles.boldLabel);
EditorGUILayout.HelpBox("The Camera Profile helps tweak camera settings no matter what platform you're building for.", MessageType.Info);
(target as BaseMixedRealityProfile).CheckProfileLock();
serializedObject.Update();
EditorGUILayout.Space();
EditorGUILayout.LabelField("Global Settings:", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(isCameraPersistent);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Opaque Display Settings:", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(opaqueNearClip, nearClipTitle);
EditorGUILayout.PropertyField(opaqueClearFlags, clearFlagsTitle);
if ((CameraClearFlags)opaqueClearFlags.intValue == CameraClearFlags.Color)
{
opaqueBackgroundColor.colorValue = EditorGUILayout.ColorField("Background Color", opaqueBackgroundColor.colorValue);
}
opaqueQualityLevel.intValue = EditorGUILayout.Popup("Quality Setting", opaqueQualityLevel.intValue, QualitySettings.names);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Transparent Display Settings:", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(transparentNearClip, nearClipTitle);
EditorGUILayout.PropertyField(transparentClearFlags, clearFlagsTitle);
if ((CameraClearFlags)transparentClearFlags.intValue == CameraClearFlags.Color)
{
transparentBackgroundColor.colorValue = EditorGUILayout.ColorField("Background Color", transparentBackgroundColor.colorValue);
}
holoLensQualityLevel.intValue = EditorGUILayout.Popup("Quality Setting", holoLensQualityLevel.intValue, QualitySettings.names);
serializedObject.ApplyModifiedProperties();
}
public override void OnInspectorGUI()
{
MixedRealityToolkit instance = (MixedRealityToolkit)target;
if (MixedRealityToolkit.Instance == null && instance.isActiveAndEnabled)
{ // See if an active instance exists at all. If it doesn't register this instance preemptively.
MixedRealityToolkit.SetActiveInstance(instance);
}
if (!instance.IsActiveInstance)
{
EditorGUILayout.HelpBox("This instance of the toolkit is inactive. There can only be one active instance loaded at any time.", MessageType.Warning);
using (new EditorGUILayout.HorizontalScope())
{
if (GUILayout.Button("Select Active Instance"))
{
UnityEditor.Selection.activeGameObject = MixedRealityToolkit.Instance.gameObject;
}
if (GUILayout.Button("Make this the Active Instance"))
{
MixedRealityToolkit.SetActiveInstance(instance);
}
}
return;
}
serializedObject.Update();
// If not profile is assigned, then warn user
if (activeProfile.objectReferenceValue == null)
{
EditorGUILayout.HelpBox("MixedRealityToolkit cannot initialize unless an Active Profile is assigned!", MessageType.Error);
}
bool changed = MixedRealityInspectorUtility.DrawProfileDropDownList(activeProfile, null, activeProfile.objectReferenceValue, typeof(MixedRealityToolkitConfigurationProfile), false);
serializedObject.ApplyModifiedProperties();
if (changed)
{
MixedRealityToolkit.Instance.ResetConfiguration((MixedRealityToolkitConfigurationProfile)activeProfile.objectReferenceValue);
}
if (activeProfile.objectReferenceValue != null)
{
// For configure, show the default inspector GUI
UnityEditor.Editor activeProfileEditor = CreateEditor(activeProfile.objectReferenceValue);
activeProfileEditor.OnInspectorGUI();
}
}
/// <inheritdoc />
protected override void OnEnable()
{
base.OnEnable();
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured(false))
{
return;
}
startupBehavior = serializedObject.FindProperty("startupBehavior");
observationExtents = serializedObject.FindProperty("observationExtents");
isStationaryObserver = serializedObject.FindProperty("isStationaryObserver");
updateInterval = serializedObject.FindProperty("updateInterval");
physicsLayer = serializedObject.FindProperty("physicsLayer");
}
private void DrawHeader()
{
MixedRealityInspectorUtility.RenderMixedRealityToolkitLogo();
using (new EditorGUILayout.HorizontalScope())
{
EditorGUILayout.LabelField("Migration Window", EditorStyles.boldLabel);
InspectorUIUtility.RenderDocumentationButton(MigrationWindowURL);
}
EditorGUILayout.LabelField(WindowDescription, EditorStyles.wordWrappedLabel);
EditorGUILayout.Space();
EditorGUILayout.Space();
}
private void OnGUI()
{
using (new EditorGUILayout.VerticalScope())
{
MixedRealityInspectorUtility.RenderMixedRealityToolkitLogo();
using (new EditorGUILayout.HorizontalScope())
{
GUILayout.FlexibleSpace();
EditorGUILayout.LabelField(FoundVersion ? $"Version {MRTKVersion}" : NotFoundMessage, EditorStyles.wordWrappedLabel);
GUILayout.FlexibleSpace();
}
}
}
private void OnGUI()
{
windowScrollPosition = EditorGUILayout.BeginScrollView(windowScrollPosition);
MixedRealityInspectorUtility.RenderMixedRealityToolkitLogo();
// Render Title
using (new EditorGUILayout.HorizontalScope())
{
EditorGUILayout.LabelField("Mixed Reality Toolkit Optimize Window", MixedRealityStylesUtility.BoldLargeTitleStyle);
InspectorUIUtility.RenderDocumentationButton(OptimizeWindow_URL);
}
EditorGUILayout.LabelField("This tool automates the process of updating your project, currently open scene, and material assets to recommended settings for Mixed Reality", EditorStyles.wordWrappedLabel);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Active Build Target: ", EditorUserBuildSettings.activeBuildTarget.ToString());
PerfTarget = (PerformanceTarget)EditorGUILayout.Popup("Performance Target", (int)this.PerfTarget, PerformanceTargetEnums);
EditorGUILayout.HelpBox(PerformanceTargetDescriptions[(int)PerfTarget], MessageType.Info);
EditorGUILayout.Space();
if (!PlayerSettings.virtualRealitySupported)
{
EditorGUILayout.HelpBox("Virtual reality support is not enabled in player settings", MessageType.Error);
if (GUILayout.Button("Enable Virtual Reality Support"))
{
PlayerSettings.virtualRealitySupported = true;
}
}
else
{
selectedToolbarIndex = GUILayout.Toolbar(selectedToolbarIndex, ToolbarTitles);
if (selectedToolbarIndex == 0)
{
RenderSettingOptimizations();
}
else if (selectedToolbarIndex == 1)
{
RenderSceneOptimizations();
}
else
{
RenderShaderOptimizations();
}
}
EditorGUILayout.EndScrollView();
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured())
{
return;
}
serializedObject.Update();
EditorGUILayout.PropertyField(pointerUpProperty, true);
EditorGUILayout.PropertyField(pointerDownProperty, true);
EditorGUILayout.PropertyField(pointerClickedProperty, true);
serializedObject.ApplyModifiedProperties();
}
protected override void OnEnable()
{
// Call base on enable so we can get proper
// copy/paste functionality of the profile
base.OnEnable();
// We check to make sure the MRTK is configured here.
// Pass false so we don't get an error for showing the help box.
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured(false))
{
return;
}
myCustomStringData = serializedObject.FindProperty("myCustomStringData");
}
public override void OnInspectorGUI()
{
// We check to make sure the MRTK is configured here.
// This will show an error help box if it's not.
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured())
{
return;
}
serializedObject.Update();
EditorGUILayout.PropertyField(myCustomStringData);
serializedObject.ApplyModifiedProperties();
}
/// <summary>
/// Render the Mixed Reality Toolkit Logo and search field.
/// </summary>
/// <returns>True if the rest of the inspector should be drawn.</returns>
protected bool RenderMRTKLogoAndSearch()
{
// If we're being rendered as a sub profile, don't show the logo
if (RenderAsSubProfile)
{
return(true);
}
if (MixedRealitySearchInspectorUtility.DrawSearchInterface(target))
{
return(false);
}
MixedRealityInspectorUtility.RenderMixedRealityToolkitLogo();
return(true);
}
protected override void OnEnable()
{
base.OnEnable();
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured(false))
{
return;
}
jointPrefab = serializedObject.FindProperty("jointPrefab");
fingertipPrefab = serializedObject.FindProperty("fingertipPrefab");
palmPrefab = serializedObject.FindProperty("palmPrefab");
handMeshPrefab = serializedObject.FindProperty("handMeshPrefab");
enableHandMeshVisualization = serializedObject.FindProperty("enableHandMeshVisualization");
enableHandJointVisualization = serializedObject.FindProperty("enableHandJointVisualization");
}
public override void OnInspectorGUI()
{
MixedRealityInspectorUtility.RenderMixedRealityToolkitLogo();
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured())
{
return;
}
if (GUILayout.Button("Back to Configuration Profile"))
{
Selection.activeObject = MixedRealityToolkit.Instance.ActiveProfile;
}
EditorGUILayout.Space();
EditorGUILayout.LabelField("Input System Profile", EditorStyles.boldLabel);
EditorGUILayout.HelpBox("The Input System Profile helps developers configure input no matter what platform you're building for.", MessageType.Info);
(target as BaseMixedRealityProfile).CheckProfileLock();
serializedObject.Update();
bool changed = false;
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(focusProviderType);
if (EditorGUI.EndChangeCheck())
{
changed = true;
}
changed |= RenderProfile(inputActionsProfile);
changed |= RenderProfile(inputActionRulesProfile);
changed |= RenderProfile(pointerProfile);
changed |= RenderProfile(gesturesProfile);
changed |= RenderProfile(speechCommandsProfile);
changed |= RenderProfile(controllerVisualizationProfile);
changed |= RenderProfile(controllerDataProvidersProfile);
changed |= RenderProfile(controllerMappingProfiles);
serializedObject.ApplyModifiedProperties();
if (changed)
{
EditorApplication.delayCall += () => MixedRealityToolkit.Instance.ResetConfiguration(MixedRealityToolkit.Instance.ActiveProfile);
}
}
public override void OnInspectorGUI()
{
MixedRealityInspectorUtility.RenderMixedRealityToolkitLogo();
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured())
{
return;
}
if (!MixedRealityToolkit.Instance.ActiveProfile.IsInputSystemEnabled)
{
EditorGUILayout.HelpBox("No input system is enabled, or you need to specify the type in the main configuration profile.", MessageType.Error);
if (GUILayout.Button("Back to Configuration Profile"))
{
Selection.activeObject = MixedRealityToolkit.Instance.ActiveProfile;
}
return;
}
if (GUILayout.Button("Back to Input Profile"))
{
Selection.activeObject = MixedRealityToolkit.Instance.ActiveProfile.InputSystemProfile;
}
(target as BaseMixedRealityProfile).CheckProfileLock();
EditorGUILayout.Space();
EditorGUILayout.LabelField("Speech Commands", EditorStyles.boldLabel);
EditorGUILayout.HelpBox("Speech Commands are any/all spoken keywords your users will be able say to raise an Input Action in your application.", MessageType.Info);
if (MixedRealityToolkit.Instance.ActiveProfile.InputSystemProfile.InputActionsProfile == null)
{
EditorGUILayout.HelpBox("No input actions found, please specify a input action profile in the main configuration.", MessageType.Error);
return;
}
serializedObject.Update();
EditorGUILayout.PropertyField(recognizerStartBehaviour);
EditorGUILayout.PropertyField(recognitionConfidenceLevel);
RenderList(speechCommands);
serializedObject.ApplyModifiedProperties();
}
/// <inheritdoc />
protected override void OnEnable()
{
base.OnEnable();
if (!MixedRealityInspectorUtility.CheckMixedRealityConfigured(false))
{
return;
}
meshPhysicsLayerOverride = serializedObject.FindProperty("meshPhysicsLayerOverride");
meshLevelOfDetail = serializedObject.FindProperty("meshLevelOfDetail");
meshTrianglesPerCubicMeter = serializedObject.FindProperty("meshTrianglesPerCubicMeter");
meshRecalculateNormals = serializedObject.FindProperty("meshRecalculateNormals");
meshDisplayOption = serializedObject.FindProperty("meshDisplayOption");
meshVisibleMaterial = serializedObject.FindProperty("meshVisibleMaterial");
meshOcclusionMaterial = serializedObject.FindProperty("meshOcclusionMaterial");
}