Exemple #1
0
            private void Validate()
            {
                EventSystem es = gameObject.FindObjectOrCreateIt <EventSystem>("EventSystem");

                es.gameObject.AddOrGetComponent <StandaloneInputModule>();
                es.gameObject.AddOrGetComponent <TouchInputModule>();

                if (CanvasObject == null)
                {
                    CanvasObject = Helper.CreateGUIGameObject(this.GetType().Name + "Canvas");
                    RectTransform rect = Helper.SetRectTransform(CanvasObject, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 1280, 800, 0, 0);
                    rect.localScale = new Vector3(0.001f, 0.001f, 0.001f);

                    Canvas canvas = CanvasObject.AddOrGetComponent <Canvas>();
                    canvas.renderMode   = RenderMode.ScreenSpaceOverlay;
                    canvas.pixelPerfect = true;

                    CanvasObject.AddOrGetComponent <CanvasScaler>();
                    CanvasObject.AddOrGetComponent <GraphicRaycaster>();
                    CanvasObject.AddOrGetComponent <CanvasRenderer>();
                }

                ValidateWindow(CanvasObject);

                _lastIsVisible    = visible;
                visibleTransition = visible ? 1.0f : 0.0f;

                if (renderModeVR == null)
                {
                    renderModeVR = CanvasObject.GetComponent <CanvasRenderModeVR>();
                }

                if (renderModeVR != null && IsVisible)
                {
                    renderModeVR.UpdateCanvasPosition();
                }
            }
            public override void OnInspectorGUI()
            {
                if (s_Styles == null)
                {
                    s_Styles = new Styles();
                }

                bool allAreRoot       = true;
                bool showWorldDiffers = false;
                bool showWorld        = ((target as CanvasRenderModeVR).GetComponent <Canvas>().renderMode == RenderMode.WorldSpace);

                for (int i = 0; i < targets.Length; i++)
                {
                    CanvasRenderModeVR scaler = targets[i] as CanvasRenderModeVR;
                    Canvas             canvas = scaler.GetComponent <Canvas>();
                    if (!canvas.isRootCanvas)
                    {
                        allAreRoot = false;
                        break;
                    }

                    if (showWorld && canvas.renderMode != RenderMode.WorldSpace || !showWorld && canvas.renderMode == RenderMode.WorldSpace)
                    {
                        showWorldDiffers = true;
                        break;
                    }
                }

                if (!allAreRoot)
                {
                    EditorGUILayout.HelpBox("Non-root Canvases will not be modified.", MessageType.Warning);
                    return;
                }

                if (!showWorld)
                {
                    EditorGUILayout.HelpBox("VR Render Mode only works if canvas is in World Space.", MessageType.Info);
                    return;
                }

                serializedObject.Update();
                EditorGUILayout.PropertyField(m_PlaneDistance);
                EditorGUILayout.PropertyField(m_UpdatePosition);
                EditorGUI.BeginDisabledGroup(m_UpdatePosition.hasMultipleDifferentValues || m_UpdatePosition.boolValue);
                if (GUILayout.Button("Update position now"))
                {
                    (target as CanvasRenderModeVR).UpdateCanvasPosition();
                }
                EditorGUI.EndDisabledGroup();
                EditorGUILayout.PropertyField(m_UiScaleMode);

                if (!showWorldDiffers && !(!showWorld && m_UiScaleMode.hasMultipleDifferentValues))
                {
                    EditorGUILayout.Space();

                    // Constant pixel size
                    if (m_UiScaleMode.enumValueIndex == (int)CanvasRenderModeVR.ScaleMode.ConstantPixelSize)
                    {
                        EditorGUILayout.PropertyField(m_ScaleFactor);
                    }
                    // Scale with screen size
                    else if (m_UiScaleMode.enumValueIndex == (int)CanvasRenderModeVR.ScaleMode.ScaleWithScreenSize)
                    {
                        EditorGUILayout.PropertyField(m_ReferenceResolution);
                        EditorGUILayout.PropertyField(m_ScreenMatchMode);
                        if (m_ScreenMatchMode.enumValueIndex == (int)CanvasRenderModeVR.ScreenMatchMode.MatchWidthOrHeight && !m_ScreenMatchMode.hasMultipleDifferentValues)
                        {
                            Rect r = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight + kSliderEndpointLabelsHeight);
                            DualLabeledSlider(r, m_MatchWidthOrHeight, s_Styles.matchContent, s_Styles.widthContent, s_Styles.heightContent);
                        }
                    }
                    // Constant physical size
                    else if (m_UiScaleMode.enumValueIndex == (int)CanvasRenderModeVR.ScaleMode.ConstantPhysicalSize)
                    {
                        EditorGUILayout.PropertyField(m_PhysicalUnit);
                        EditorGUILayout.PropertyField(m_FallbackScreenDPI);
                        EditorGUILayout.PropertyField(m_DefaultSpriteDPI);
                    }

                    EditorGUILayout.PropertyField(m_ReferencePixelsPerUnit);
                }

                serializedObject.ApplyModifiedProperties();
            }