Exemplo n.º 1
0
        static void OnBottomBarGUI(SceneView sceneView, Rect barSize)
        {
            //if (Event.current.type == EventType.Layout)
            //	return;

            var  snapMode          = RealtimeCSG.CSGSettings.SnapMode;
            var  uniformGrid       = RealtimeCSG.CSGSettings.UniformGrid;
            var  moveSnapVector    = RealtimeCSG.CSGSettings.SnapVector;
            var  rotationSnap      = RealtimeCSG.CSGSettings.SnapRotation;
            var  scaleSnap         = RealtimeCSG.CSGSettings.SnapScale;
            var  showGrid          = RealtimeCSG.CSGSettings.GridVisible;
            var  lockAxisX         = RealtimeCSG.CSGSettings.LockAxisX;
            var  lockAxisY         = RealtimeCSG.CSGSettings.LockAxisY;
            var  lockAxisZ         = RealtimeCSG.CSGSettings.LockAxisZ;
            var  distanceUnit      = RealtimeCSG.CSGSettings.DistanceUnit;
            var  helperSurfaces    = RealtimeCSG.CSGSettings.VisibleHelperSurfaces;
            var  showWireframe     = RealtimeCSG.CSGSettings.IsWireframeShown(sceneView);
            var  skin              = CSG_GUIStyleUtility.Skin;
            var  updateSurfaces    = false;
            bool wireframeModified = false;

            var viewWidth = sceneView.position.width;

            float layoutHeight = barSize.height;
            float layoutX      = 6.0f;

            bool modified = false;

            GUI.changed = false;
            {
                currentRect.width  = 27;
                currentRect.y      = 0;
                currentRect.height = layoutHeight - currentRect.y;
                currentRect.y     += barSize.y;
                currentRect.x      = layoutX;
                layoutX           += currentRect.width;

                #region "Grid" button
                if (showGrid)
                {
                    showGrid = GUI.Toggle(currentRect, showGrid, skin.gridIconOn, EditorStyles.toolbarButton);
                }
                else
                {
                    showGrid = GUI.Toggle(currentRect, showGrid, skin.gridIcon, EditorStyles.toolbarButton);
                }
                //(x:6.00, y:0.00, width:27.00, height:18.00)
                TooltipUtility.SetToolTip(showGridTooltip, currentRect);
                #endregion

                if (viewWidth >= 800)
                {
                    layoutX += 6;                     //(x:33.00, y:0.00, width:6.00, height:6.00)
                }
                var prevBackgroundColor   = GUI.backgroundColor;
                var lockedBackgroundColor = skin.lockedBackgroundColor;
                if (lockAxisX)
                {
                    GUI.backgroundColor = lockedBackgroundColor;
                }

                #region "X" lock button
                currentRect.width  = 17;
                currentRect.y      = 0;
                currentRect.height = layoutHeight - currentRect.y;
                currentRect.y     += barSize.y;
                currentRect.x      = layoutX;
                layoutX           += currentRect.width;

                lockAxisX = !GUI.Toggle(currentRect, !lockAxisX, xLabel, skin.xToolbarButton);
                //(x:39.00, y:0.00, width:17.00, height:18.00)
                if (lockAxisX)
                {
                    TooltipUtility.SetToolTip(xTooltipOn, currentRect);
                }
                else
                {
                    TooltipUtility.SetToolTip(xTooltipOff, currentRect);
                }
                GUI.backgroundColor = prevBackgroundColor;
                #endregion

                #region "Y" lock button
                currentRect.x = layoutX;
                layoutX      += currentRect.width;

                if (lockAxisY)
                {
                    GUI.backgroundColor = lockedBackgroundColor;
                }
                lockAxisY = !GUI.Toggle(currentRect, !lockAxisY, yLabel, skin.yToolbarButton);
                //(x:56.00, y:0.00, width:17.00, height:18.00)
                if (lockAxisY)
                {
                    TooltipUtility.SetToolTip(yTooltipOn, currentRect);
                }
                else
                {
                    TooltipUtility.SetToolTip(yTooltipOff, currentRect);
                }
                GUI.backgroundColor = prevBackgroundColor;
                #endregion

                #region "Z" lock button
                currentRect.x = layoutX;
                layoutX      += currentRect.width;

                if (lockAxisZ)
                {
                    GUI.backgroundColor = lockedBackgroundColor;
                }
                lockAxisZ = !GUI.Toggle(currentRect, !lockAxisZ, zLabel, skin.zToolbarButton);
                //(x:56.00, y:0.00, width:17.00, height:18.00)
                if (lockAxisZ)
                {
                    TooltipUtility.SetToolTip(zTooltipOn, currentRect);
                }
                else
                {
                    TooltipUtility.SetToolTip(zTooltipOff, currentRect);
                }
                GUI.backgroundColor = prevBackgroundColor;
                #endregion
            }
            modified = GUI.changed || modified;

            if (viewWidth >= 800)
            {
                layoutX += 6;                 // (x:91.00, y:0.00, width:6.00, height:6.00)
            }
            #region "SnapMode" button
            GUI.changed = false;
            {
                currentRect.width  = 27;
                currentRect.y      = 0;
                currentRect.height = layoutHeight - currentRect.y;
                currentRect.y     += barSize.y;
                currentRect.x      = layoutX;
                layoutX           += currentRect.width;


                switch (snapMode)
                {
                case SnapMode.GridSnapping:
                {
                    var newValue = GUI.Toggle(currentRect, snapMode == SnapMode.GridSnapping, CSG_GUIStyleUtility.Skin.gridSnapIconOn, EditorStyles.toolbarButton);
                    if (GUI.changed)
                    {
                        snapMode = newValue ? SnapMode.GridSnapping : SnapMode.RelativeSnapping;
                        //Debug.Log($"SnapMode.GridSnapping {snapMode}");
                    }
                    //(x:97.00, y:0.00, width:27.00, height:18.00)
                    TooltipUtility.SetToolTip(gridSnapModeTooltip, currentRect);
                    break;
                }

                case SnapMode.RelativeSnapping:
                {
                    var newValue = GUI.Toggle(currentRect, snapMode == SnapMode.RelativeSnapping, CSG_GUIStyleUtility.Skin.relSnapIconOn, EditorStyles.toolbarButton);
                    if (GUI.changed)
                    {
                        snapMode = newValue ? SnapMode.RelativeSnapping : SnapMode.None;
                        //Debug.Log($"SnapMode.RelativeSnapping {snapMode}");
                    }
                    //(x:97.00, y:0.00, width:27.00, height:18.00)
                    TooltipUtility.SetToolTip(relativeSnapModeTooltip, currentRect);
                    break;
                }

                default:
                case SnapMode.None:
                {
                    var newValue = GUI.Toggle(currentRect, snapMode != SnapMode.None, CSG_GUIStyleUtility.Skin.noSnapIconOn, EditorStyles.toolbarButton);
                    if (GUI.changed)
                    {
                        snapMode = newValue ? SnapMode.GridSnapping : SnapMode.None;
                        //Debug.Log($"SnapMode.None {snapMode}");
                    }
                    //(x:97.00, y:0.00, width:27.00, height:18.00)
                    TooltipUtility.SetToolTip(noSnappingModeTooltip, currentRect);
                    break;
                }
                }
            }
            modified = GUI.changed || modified;
            #endregion

            if (viewWidth >= 460)
            {
                if (snapMode != SnapMode.None)
                {
                    #region "Position" label
                    if (viewWidth >= 500)
                    {
                        if (viewWidth >= 865)
                        {
                            currentRect.width  = 44;
                            currentRect.y      = 1;
                            currentRect.height = layoutHeight - currentRect.y;
                            currentRect.y     += barSize.y;
                            currentRect.x      = layoutX;
                            layoutX           += currentRect.width;

                            uniformGrid = GUI.Toggle(currentRect, uniformGrid, positionLargeLabel, miniTextStyle);
                            //(x:128.00, y:2.00, width:44.00, height:16.00)

                            TooltipUtility.SetToolTip(positionTooltip, currentRect);
                        }
                        else
                        {
                            currentRect.width  = 22;
                            currentRect.y      = 1;
                            currentRect.height = layoutHeight - currentRect.y;
                            currentRect.y     += barSize.y;
                            currentRect.x      = layoutX;
                            layoutX           += currentRect.width;

                            uniformGrid = GUI.Toggle(currentRect, uniformGrid, positionSmallLabel, miniTextStyle);
                            //(x:127.00, y:2.00, width:22.00, height:16.00)

                            TooltipUtility.SetToolTip(positionTooltip, currentRect);
                        }
                    }
                    #endregion

                    layoutX += 2;

                    #region "Position" field
                    if (uniformGrid || viewWidth < 515)
                    {
                        EditorGUI.showMixedValue = !(moveSnapVector.x == moveSnapVector.y && moveSnapVector.x == moveSnapVector.z);
                        GUI.changed = false;
                        {
                            currentRect.width  = 70;
                            currentRect.y      = 3;
                            currentRect.height = layoutHeight - (currentRect.y - 1);
                            currentRect.y     += barSize.y;
                            currentRect.x      = layoutX;
                            layoutX           += currentRect.width;

                            moveSnapVector.x = Units.DistanceUnitToUnity(distanceUnit, EditorGUI.DoubleField(currentRect, Units.UnityToDistanceUnit(distanceUnit, moveSnapVector.x), textInputStyle));                            //, MinSnapWidth, MaxSnapWidth));
                            //(x:176.00, y:3.00, width:70.00, height:16.00)
                        }
                        if (GUI.changed)
                        {
                            modified         = true;
                            moveSnapVector.y = moveSnapVector.x;
                            moveSnapVector.z = moveSnapVector.x;
                        }
                        EditorGUI.showMixedValue = false;
                    }
                    else
                    {
                        GUI.changed = false;
                        {
                            currentRect.width  = 70;
                            currentRect.y      = 3;
                            currentRect.height = layoutHeight - (currentRect.y - 1);
                            currentRect.y     += barSize.y;
                            currentRect.x      = layoutX;
                            layoutX           += currentRect.width;
                            layoutX++;

                            moveSnapVector.x = Units.DistanceUnitToUnity(distanceUnit, EditorGUI.DoubleField(currentRect, Units.UnityToDistanceUnit(distanceUnit, moveSnapVector.x), textInputStyle));                            //, MinSnapWidth, MaxSnapWidth));
                            //(x:175.00, y:3.00, width:70.00, height:16.00)


                            currentRect.x = layoutX;
                            layoutX      += currentRect.width;
                            layoutX++;

                            moveSnapVector.y = Units.DistanceUnitToUnity(distanceUnit, EditorGUI.DoubleField(currentRect, Units.UnityToDistanceUnit(distanceUnit, moveSnapVector.y), textInputStyle));                            //, MinSnapWidth, MaxSnapWidth));
                            //(x:247.00, y:3.00, width:70.00, height:16.00)


                            currentRect.x = layoutX;
                            layoutX      += currentRect.width;

                            moveSnapVector.z = Units.DistanceUnitToUnity(distanceUnit, EditorGUI.DoubleField(currentRect, Units.UnityToDistanceUnit(distanceUnit, moveSnapVector.z), textInputStyle));                            //, MinSnapWidth, MaxSnapWidth));
                            //(x:319.00, y:3.00, width:70.00, height:16.00)
                        }
                        modified = GUI.changed || modified;
                    }
                    #endregion

                    layoutX++;

                    #region "Position" Unit
                    DistanceUnit nextUnit = Units.CycleToNextUnit(distanceUnit);
                    GUIContent   unitText = Units.GetUnitGUIContent(distanceUnit);

                    currentRect.width  = 22;
                    currentRect.y      = 2;
                    currentRect.height = layoutHeight - currentRect.y;
                    currentRect.y     += barSize.y;
                    currentRect.x      = layoutX;
                    layoutX           += currentRect.width;

                    if (GUI.Button(currentRect, unitText, miniTextStyle))                    //(x:393.00, y:2.00, width:13.00, height:16.00)
                    {
                        distanceUnit = nextUnit;
                        modified     = true;
                    }
                    #endregion

                    layoutX += 2;

                    #region "Position" +/-
                    if (viewWidth >= 700)
                    {
                        currentRect.width  = 19;
                        currentRect.y      = 2;
                        currentRect.height = layoutHeight - (currentRect.y + 1);
                        currentRect.y     += barSize.y;
                        currentRect.x      = layoutX;
                        layoutX           += currentRect.width;

                        if (GUI.Button(currentRect, positionPlusLabel, EditorStyles.miniButtonLeft))
                        {
                            GridUtility.DoubleGridSize(); moveSnapVector = RealtimeCSG.CSGSettings.SnapVector;
                        }
                        //(x:410.00, y:2.00, width:19.00, height:15.00)
                        TooltipUtility.SetToolTip(positionPlusTooltip, currentRect);

                        currentRect.width  = 17;
                        currentRect.y      = 2;
                        currentRect.height = layoutHeight - (currentRect.y + 1);
                        currentRect.y     += barSize.y;
                        currentRect.x      = layoutX;
                        layoutX           += currentRect.width;

                        if (GUI.Button(currentRect, positionMinusLabel, EditorStyles.miniButtonRight))
                        {
                            GridUtility.HalfGridSize(); moveSnapVector = RealtimeCSG.CSGSettings.SnapVector;
                        }
                        //(x:429.00, y:2.00, width:17.00, height:15.00)
                        TooltipUtility.SetToolTip(positionMinnusTooltip, currentRect);
                    }
                    #endregion

                    layoutX += 2;

                    #region "Angle" label
                    if (viewWidth >= 750)
                    {
                        if (viewWidth >= 865)
                        {
                            currentRect.width  = 31;
                            currentRect.y      = 1;
                            currentRect.height = layoutHeight - currentRect.y;
                            currentRect.y     += barSize.y;
                            currentRect.x      = layoutX;
                            layoutX           += currentRect.width;

                            GUI.Label(currentRect, angleLargeLabel, miniTextStyle);
                            //(x:450.00, y:2.00, width:31.00, height:16.00)
                        }
                        else
                        {
                            currentRect.width  = 22;
                            currentRect.y      = 1;
                            currentRect.height = layoutHeight - currentRect.y;
                            currentRect.y     += barSize.y;
                            currentRect.x      = layoutX;
                            layoutX           += currentRect.width;

                            GUI.Label(currentRect, angleSmallLabel, miniTextStyle);
                            //(x:355.00, y:2.00, width:22.00, height:16.00)
                        }
                        TooltipUtility.SetToolTip(angleTooltip, currentRect);
                    }
                    #endregion

                    layoutX += 2;

                    #region "Angle" field
                    GUI.changed = false;
                    {
                        currentRect.width  = 70;
                        currentRect.y      = 3;
                        currentRect.height = layoutHeight - (currentRect.y - 1);
                        currentRect.y     += barSize.y;
                        currentRect.x      = layoutX;
                        layoutX           += currentRect.width;

                        rotationSnap = EditorGUI.FloatField(currentRect, rotationSnap, textInputStyle);                        //, MinSnapWidth, MaxSnapWidth);
                        //(x:486.00, y:3.00, width:70.00, height:16.00)
                        if (viewWidth <= 750)
                        {
                            TooltipUtility.SetToolTip(angleTooltip, currentRect);
                        }
                    }
                    modified = GUI.changed || modified;
                    #endregion

                    layoutX++;

                    #region "Angle" Unit
                    if (viewWidth >= 370)
                    {
                        currentRect.width  = 14;
                        currentRect.y      = 1;
                        currentRect.height = layoutHeight - currentRect.y;
                        currentRect.y     += barSize.y;
                        currentRect.x      = layoutX;
                        layoutX           += currentRect.width;

                        GUI.Label(currentRect, angleUnitLabel, miniTextStyle);
                    }
                    #endregion

                    layoutX += 2;

                    #region "Angle" +/-
                    if (viewWidth >= 700)
                    {
                        currentRect.width  = 19;
                        currentRect.y      = 1;
                        currentRect.height = layoutHeight - (currentRect.y + 1);
                        currentRect.y     += barSize.y;
                        currentRect.x      = layoutX;
                        layoutX           += currentRect.width;

                        if (GUI.Button(currentRect, anglePlusLabel, EditorStyles.miniButtonLeft))
                        {
                            rotationSnap *= 2.0f; modified = true;
                        }
                        //(x:573.00, y:2.00, width:19.00, height:15.00)
                        TooltipUtility.SetToolTip(anglePlusTooltip, currentRect);


                        currentRect.width  = 17;
                        currentRect.y      = 1;
                        currentRect.height = layoutHeight - (currentRect.y + 1);
                        currentRect.y     += barSize.y;
                        currentRect.x      = layoutX;
                        layoutX           += currentRect.width;

                        if (GUI.Button(currentRect, angleMinusLabel, EditorStyles.miniButtonRight))
                        {
                            rotationSnap /= 2.0f; modified = true;
                        }
                        //(x:592.00, y:2.00, width:17.00, height:15.00)
                        TooltipUtility.SetToolTip(angleMinnusTooltip, currentRect);
                    }
                    #endregion

                    layoutX += 2;

                    #region "Scale" label
                    if (viewWidth >= 750)
                    {
                        if (viewWidth >= 865)
                        {
                            currentRect.width  = 31;
                            currentRect.y      = 1;
                            currentRect.height = layoutHeight - currentRect.y;
                            currentRect.y     += barSize.y;
                            currentRect.x      = layoutX;
                            layoutX           += currentRect.width;

                            GUI.Label(currentRect, scaleLargeLabel, miniTextStyle);
                            //(x:613.00, y:2.00, width:31.00, height:16.00)
                        }
                        else
                        {
                            currentRect.width  = 19;
                            currentRect.y      = 1;
                            currentRect.height = layoutHeight - currentRect.y;
                            currentRect.y     += barSize.y;
                            currentRect.x      = layoutX;
                            layoutX           += currentRect.width;

                            GUI.Label(currentRect, scaleSmallLabel, miniTextStyle);
                            //(x:495.00, y:2.00, width:19.00, height:16.00)
                        }
                        TooltipUtility.SetToolTip(scaleTooltip, currentRect);
                    }
                    #endregion

                    layoutX += 2;

                    #region "Scale" field
                    GUI.changed = false;
                    {
                        currentRect.width  = 70;
                        currentRect.y      = 3;
                        currentRect.height = layoutHeight - (currentRect.y - 1);
                        currentRect.y     += barSize.y;
                        currentRect.x      = layoutX;
                        layoutX           += currentRect.width;

                        scaleSnap = EditorGUI.FloatField(currentRect, scaleSnap, textInputStyle);                        //, MinSnapWidth, MaxSnapWidth);
                        //(x:648.00, y:3.00, width:70.00, height:16.00)
                        if (viewWidth <= 750)
                        {
                            TooltipUtility.SetToolTip(scaleTooltip, currentRect);
                        }
                    }
                    modified = GUI.changed || modified;
                    #endregion

                    layoutX++;

                    #region "Scale" Unit
                    if (viewWidth >= 370)
                    {
                        currentRect.width  = 15;
                        currentRect.y      = 1;
                        currentRect.height = layoutHeight - currentRect.y;
                        currentRect.y     += barSize.y;
                        currentRect.x      = layoutX;
                        layoutX           += currentRect.width;

                        GUI.Label(currentRect, scaleUnitLabel, miniTextStyle);
                        //(x:722.00, y:2.00, width:15.00, height:16.00)
                    }
                    #endregion

                    layoutX += 2;

                    #region "Scale" +/-
                    if (viewWidth >= 700)
                    {
                        currentRect.width  = 19;
                        currentRect.y      = 2;
                        currentRect.height = layoutHeight - (currentRect.y + 1);
                        currentRect.y     += barSize.y;
                        currentRect.x      = layoutX;
                        layoutX           += currentRect.width;

                        if (GUI.Button(currentRect, scalePlusLabel, EditorStyles.miniButtonLeft))
                        {
                            scaleSnap *= 10.0f; modified = true;
                        }
                        //(x:741.00, y:2.00, width:19.00, height:15.00)
                        TooltipUtility.SetToolTip(scalePlusTooltip, currentRect);


                        currentRect.width  = 17;
                        currentRect.y      = 2;
                        currentRect.height = layoutHeight - (currentRect.y + 1);
                        currentRect.y     += barSize.y;
                        currentRect.x      = layoutX;
                        layoutX           += currentRect.width;

                        if (GUI.Button(currentRect, scaleMinusLabel, EditorStyles.miniButtonRight))
                        {
                            scaleSnap /= 10.0f; modified = true;
                        }
                        //(x:760.00, y:2.00, width:17.00, height:15.00)
                        TooltipUtility.SetToolTip(scaleMinnusTooltip, currentRect);
                    }
                    #endregion
                }
            }


            var prevLayoutX = layoutX;

            layoutX = viewWidth;


            #region "Rebuild"
            currentRect.width  = 27;
            currentRect.y      = 0;
            currentRect.height = layoutHeight - currentRect.y;
            currentRect.y     += barSize.y;
            layoutX           -= currentRect.width;
            currentRect.x      = layoutX;

            if (GUI.Button(currentRect, CSG_GUIStyleUtility.Skin.rebuildIcon, EditorStyles.toolbarButton))
            {
                Debug.Log("Starting complete rebuild");

                var text = new System.Text.StringBuilder();

                MaterialUtility.ResetMaterialTypeLookup();

                InternalCSGModelManager.skipCheckForChanges = true;
                RealtimeCSG.CSGSettings.Reload();
                UnityCompilerDefineManager.UpdateUnityDefines();

                InternalCSGModelManager.registerTime          = 0.0;
                InternalCSGModelManager.validateTime          = 0.0;
                InternalCSGModelManager.hierarchyValidateTime = 0.0;
                InternalCSGModelManager.updateHierarchyTime   = 0.0;

                var startTime = EditorApplication.timeSinceStartup;
                InternalCSGModelManager.ForceRebuildAll();
                InternalCSGModelManager.OnHierarchyModified();
                var hierarchy_update_endTime = EditorApplication.timeSinceStartup;
                text.AppendFormat(CultureInfo.InvariantCulture, "Full hierarchy rebuild in {0:F} ms. ", (hierarchy_update_endTime - startTime) * 1000);


                NativeMethodBindings.RebuildAll();
                var csg_endTime = EditorApplication.timeSinceStartup;
                text.AppendFormat(CultureInfo.InvariantCulture, "Full CSG rebuild done in {0:F} ms. ", (csg_endTime - hierarchy_update_endTime) * 1000);

                InternalCSGModelManager.RemoveForcedUpdates();                 // we already did this in rebuild all
                InternalCSGModelManager.UpdateMeshes(text, forceUpdate: true);

                updateSurfaces = true;
                UpdateLoop.ResetUpdateRoutine();
                RealtimeCSG.CSGSettings.Save();
                InternalCSGModelManager.skipCheckForChanges = false;

                var scenes = new HashSet <UnityEngine.SceneManagement.Scene>();
                foreach (var model in InternalCSGModelManager.Models)
                {
                    scenes.Add(model.gameObject.scene);
                }

                foreach (var scene in scenes)
                {
                    UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty(scene);
                }

                text.AppendFormat(CultureInfo.InvariantCulture, "{0} brushes. ", Foundation.CSGManager.TreeBrushCount);

                Debug.Log(text.ToString());
            }
            //(x:1442.00, y:0.00, width:27.00, height:18.00)
            TooltipUtility.SetToolTip(rebuildTooltip, currentRect);
            #endregion

            if (viewWidth >= 800)
            {
                layoutX -= 6;                 //(x:1436.00, y:0.00, width:6.00, height:6.00)
            }
            #region "Helper Surface Flags" Mask
            if (viewWidth >= 250)
            {
                GUI.changed = false;
                {
                    prevLayoutX += 8;                      // extra space
                    prevLayoutX += 26;                     // width of "Show wireframe" button

                    currentRect.width = Mathf.Max(20, Mathf.Min(165, (viewWidth - prevLayoutX - currentRect.width)));

                    currentRect.y      = 0;
                    currentRect.height = layoutHeight - currentRect.y;
                    currentRect.y     += barSize.y;
                    layoutX           -= currentRect.width;
                    currentRect.x      = layoutX;

                    SurfaceVisibilityPopup.Button(currentRect);

                    //(x:1267.00, y:2.00, width:165.00, height:16.00)
                    TooltipUtility.SetToolTip(helperSurfacesTooltip, currentRect);
                }
                if (GUI.changed)
                {
                    updateSurfaces = true;
                    modified       = true;
                }
            }
            #endregion

            #region "Show wireframe" button
            GUI.changed        = false;
            currentRect.width  = 26;
            currentRect.y      = 0;
            currentRect.height = layoutHeight - currentRect.y;
            currentRect.y     += barSize.y;
            layoutX           -= currentRect.width;
            currentRect.x      = layoutX;

            if (showWireframe)
            {
                showWireframe = GUI.Toggle(currentRect, showWireframe, CSG_GUIStyleUtility.Skin.wireframe, EditorStyles.toolbarButton);
                //(x:1237.00, y:0.00, width:26.00, height:18.00)
            }
            else
            {
                showWireframe = GUI.Toggle(currentRect, showWireframe, CSG_GUIStyleUtility.Skin.wireframeOn, EditorStyles.toolbarButton);
                //(x:1237.00, y:0.00, width:26.00, height:18.00)
            }
            TooltipUtility.SetToolTip(showWireframeTooltip, currentRect);
            if (GUI.changed)
            {
                wireframeModified = true;
                modified          = true;
            }
            #endregion



            #region Capture mouse clicks in empty space
            var mousePoint = Event.current.mousePosition;
            int controlID  = GUIUtility.GetControlID(BottomBarEditorOverlayHash, FocusType.Passive, barSize);
            switch (Event.current.GetTypeForControl(controlID))
            {
            case EventType.MouseDown:       { if (barSize.Contains(mousePoint))
                                              {
                                                  GUIUtility.hotControl = controlID; GUIUtility.keyboardControl = controlID; Event.current.Use();
                                              }
                                              break; }

            case EventType.MouseMove:       { if (barSize.Contains(mousePoint))
                                              {
                                                  Event.current.Use();
                                              }
                                              break; }

            case EventType.MouseUp:         { if (GUIUtility.hotControl == controlID)
                                              {
                                                  GUIUtility.hotControl = 0; GUIUtility.keyboardControl = 0; Event.current.Use();
                                              }
                                              break; }

            case EventType.MouseDrag:       { if (GUIUtility.hotControl == controlID)
                                              {
                                                  Event.current.Use();
                                              }
                                              break; }

            case EventType.ScrollWheel: { if (barSize.Contains(mousePoint))
                                          {
                                              Event.current.Use();
                                          }
                                          break; }
            }
            #endregion



            #region Store modified values
            rotationSnap     = Mathf.Max(1.0f, Mathf.Abs((360 + (rotationSnap % 360))) % 360);
            moveSnapVector.x = Mathf.Max(1.0f / 1024.0f, moveSnapVector.x);
            moveSnapVector.y = Mathf.Max(1.0f / 1024.0f, moveSnapVector.y);
            moveSnapVector.z = Mathf.Max(1.0f / 1024.0f, moveSnapVector.z);

            scaleSnap = Mathf.Max(MathConstants.MinimumScale, scaleSnap);

            RealtimeCSG.CSGSettings.SnapMode     = snapMode;
            RealtimeCSG.CSGSettings.SnapVector   = moveSnapVector;
            RealtimeCSG.CSGSettings.SnapRotation = rotationSnap;
            RealtimeCSG.CSGSettings.SnapScale    = scaleSnap;
            RealtimeCSG.CSGSettings.UniformGrid  = uniformGrid;
//			RealtimeCSG.Settings.SnapVertex					= vertexSnap;
            RealtimeCSG.CSGSettings.GridVisible           = showGrid;
            RealtimeCSG.CSGSettings.LockAxisX             = lockAxisX;
            RealtimeCSG.CSGSettings.LockAxisY             = lockAxisY;
            RealtimeCSG.CSGSettings.LockAxisZ             = lockAxisZ;
            RealtimeCSG.CSGSettings.DistanceUnit          = distanceUnit;
            RealtimeCSG.CSGSettings.VisibleHelperSurfaces = helperSurfaces;

            if (wireframeModified)
            {
                RealtimeCSG.CSGSettings.SetWireframeShown(sceneView, showWireframe);
            }

            if (updateSurfaces)
            {
                MeshInstanceManager.UpdateHelperSurfaceVisibility(force: true);
            }

            if (modified)
            {
                GUI.changed = true;
                RealtimeCSG.CSGSettings.UpdateSnapSettings();
                RealtimeCSG.CSGSettings.Save();
                CSG_EditorGUIUtility.UpdateSceneViews();
            }
            #endregion
        }
Exemplo n.º 2
0
        static void OnBottomBarGUI(SceneView sceneView)
        {
            var  snapToGrid        = RealtimeCSG.CSGSettings.SnapToGrid;
            var  uniformGrid       = RealtimeCSG.CSGSettings.UniformGrid;
            var  moveSnapVector    = RealtimeCSG.CSGSettings.SnapVector;
            var  rotationSnap      = RealtimeCSG.CSGSettings.SnapRotation;
            var  scaleSnap         = RealtimeCSG.CSGSettings.SnapScale;
            var  showGrid          = RealtimeCSG.CSGSettings.GridVisible;
            var  lockAxisX         = RealtimeCSG.CSGSettings.LockAxisX;
            var  lockAxisY         = RealtimeCSG.CSGSettings.LockAxisY;
            var  lockAxisZ         = RealtimeCSG.CSGSettings.LockAxisZ;
            var  distanceUnit      = RealtimeCSG.CSGSettings.DistanceUnit;
            var  helperSurfaces    = RealtimeCSG.CSGSettings.VisibleHelperSurfaces;
            var  showWireframe     = RealtimeCSG.CSGSettings.IsWireframeShown(sceneView);
            var  updateSurfaces    = false;
            bool wireframeModified = false;

            var viewWidth = sceneView.position.width;

            bool modified = false;

            EditorGUILayout.BeginHorizontal(GUIStyleUtility.ContentEmpty);
            {
                EditorGUI.BeginChangeCheck();
                {
                    var skin = GUIStyleUtility.Skin;
                    if (showGrid)
                    {
                        showGrid = GUILayout.Toggle(showGrid, skin.gridIconOn, EditorStyles.toolbarButton);
                    }
                    else
                    {
                        showGrid = GUILayout.Toggle(showGrid, skin.gridIcon, EditorStyles.toolbarButton);
                    }
                    TooltipUtility.SetToolTip(showGridTooltip);

                    if (viewWidth >= 800)
                    {
                        EditorGUILayout.Space();
                    }

                    if (viewWidth >= 200)
                    {
                        var prevBackgroundColor   = GUI.backgroundColor;
                        var lockedBackgroundColor = skin.lockedBackgroundColor;
                        if (lockAxisX)
                        {
                            GUI.backgroundColor = lockedBackgroundColor;
                        }
                        lockAxisX = !GUILayout.Toggle(!lockAxisX, xLabel, skin.xToolbarButton);
                        if (lockAxisX)
                        {
                            TooltipUtility.SetToolTip(xTooltipOn);
                        }
                        else
                        {
                            TooltipUtility.SetToolTip(xTooltipOff);
                        }
                        GUI.backgroundColor = prevBackgroundColor;

                        if (lockAxisY)
                        {
                            GUI.backgroundColor = lockedBackgroundColor;
                        }
                        lockAxisY = !GUILayout.Toggle(!lockAxisY, yLabel, skin.yToolbarButton);
                        if (lockAxisY)
                        {
                            TooltipUtility.SetToolTip(yTooltipOn);
                        }
                        else
                        {
                            TooltipUtility.SetToolTip(yTooltipOff);
                        }
                        GUI.backgroundColor = prevBackgroundColor;

                        if (lockAxisZ)
                        {
                            GUI.backgroundColor = lockedBackgroundColor;
                        }
                        lockAxisZ = !GUILayout.Toggle(!lockAxisZ, zLabel, skin.zToolbarButton);
                        if (lockAxisZ)
                        {
                            TooltipUtility.SetToolTip(zTooltipOn);
                        }
                        else
                        {
                            TooltipUtility.SetToolTip(zTooltipOff);
                        }
                        GUI.backgroundColor = prevBackgroundColor;
                    }
                }
                modified = EditorGUI.EndChangeCheck() || modified;

                if (viewWidth >= 800)
                {
                    EditorGUILayout.Space();
                }

                EditorGUI.BeginChangeCheck();
                {
                    if (viewWidth >= 475)
                    {
                        if (snapToGrid && viewWidth >= 310)
                        {
                            snapToGrid = GUILayout.Toggle(snapToGrid, GUIStyleUtility.Skin.snappingIconOn, EditorStyles.toolbarButton);
                            TooltipUtility.SetToolTip(snapToGridTooltip);
                            if (viewWidth >= 865)
                            {
                                uniformGrid = GUILayout.Toggle(uniformGrid, positionLargeLabel, miniTextStyle);
                            }
                            else
                            {
                                uniformGrid = GUILayout.Toggle(uniformGrid, positionSmallLabel, miniTextStyle);
                            }
                            TooltipUtility.SetToolTip(positionTooltip);
                        }
                        else
                        {
                            snapToGrid = GUILayout.Toggle(snapToGrid, GUIStyleUtility.Skin.snappingIcon, EditorStyles.toolbarButton);
                            TooltipUtility.SetToolTip(snapToGridTooltip);
                        }
                    }
                }
                modified = EditorGUI.EndChangeCheck() || modified;
                if (viewWidth >= 310)
                {
                    if (snapToGrid)
                    {
                        if (uniformGrid || viewWidth < 515)
                        {
                            EditorGUI.showMixedValue = !(moveSnapVector.x == moveSnapVector.y && moveSnapVector.x == moveSnapVector.z);
                            EditorGUI.BeginChangeCheck();
                            {
                                moveSnapVector.x = Units.DistanceUnitToUnity(distanceUnit, EditorGUILayout.DoubleField(Units.UnityToDistanceUnit(distanceUnit, moveSnapVector.x), textInputStyle, MinSnapWidth, MaxSnapWidth));
                            }
                            if (EditorGUI.EndChangeCheck())
                            {
                                modified         = true;
                                moveSnapVector.y = moveSnapVector.x;
                                moveSnapVector.z = moveSnapVector.x;
                            }
                            EditorGUI.showMixedValue = false;
                        }
                        else
                        {
                            EditorGUI.BeginChangeCheck();
                            {
                                moveSnapVector.x = Units.DistanceUnitToUnity(distanceUnit, EditorGUILayout.DoubleField(Units.UnityToDistanceUnit(distanceUnit, moveSnapVector.x), textInputStyle, MinSnapWidth, MaxSnapWidth));
                                moveSnapVector.y = Units.DistanceUnitToUnity(distanceUnit, EditorGUILayout.DoubleField(Units.UnityToDistanceUnit(distanceUnit, moveSnapVector.y), textInputStyle, MinSnapWidth, MaxSnapWidth));
                                moveSnapVector.z = Units.DistanceUnitToUnity(distanceUnit, EditorGUILayout.DoubleField(Units.UnityToDistanceUnit(distanceUnit, moveSnapVector.z), textInputStyle, MinSnapWidth, MaxSnapWidth));
                            }
                            modified = EditorGUI.EndChangeCheck() || modified;
                        }
                        DistanceUnit nextUnit = Units.CycleToNextUnit(distanceUnit);
                        GUIContent   unitText = Units.GetUnitGUIContent(distanceUnit);
                        if (GUILayout.Button(unitText, miniTextStyle))
                        {
                            distanceUnit = nextUnit;
                            modified     = true;
                        }
                        if (viewWidth >= 700)
                        {
                            if (GUILayout.Button(positionPlusLabel, EditorStyles.miniButtonLeft))
                            {
                                GridUtility.DoubleGridSize(); moveSnapVector = RealtimeCSG.CSGSettings.SnapVector;
                            }
                            TooltipUtility.SetToolTip(positionPlusTooltip);
                            if (GUILayout.Button(positionMinusLabel, EditorStyles.miniButtonRight))
                            {
                                GridUtility.HalfGridSize(); moveSnapVector = RealtimeCSG.CSGSettings.SnapVector;
                            }
                            TooltipUtility.SetToolTip(positionMinnusTooltip);
                        }
                        if (viewWidth >= 750)
                        {
                            if (viewWidth >= 865)
                            {
                                GUILayout.Label(angleLargeLabel, miniTextStyle);
                            }
                            else
                            {
                                GUILayout.Label(angleSmallLabel, miniTextStyle);
                            }
                            TooltipUtility.SetToolTip(angleTooltip);
                        }
                        EditorGUI.BeginChangeCheck();
                        {
                            rotationSnap = EditorGUILayout.FloatField(rotationSnap, textInputStyle, MinSnapWidth, MaxSnapWidth);
                            if (viewWidth <= 750)
                            {
                                TooltipUtility.SetToolTip(angleTooltip);
                            }
                        }
                        modified = EditorGUI.EndChangeCheck() || modified;

                        if (viewWidth >= 370)
                        {
                            GUILayout.Label(angleUnitLabel, miniTextStyle);
                        }
                        if (viewWidth >= 700)
                        {
                            if (GUILayout.Button(anglePlusLabel, EditorStyles.miniButtonLeft))
                            {
                                rotationSnap *= 2.0f; modified = true;
                            }
                            TooltipUtility.SetToolTip(anglePlusTooltip);
                            if (GUILayout.Button(angleMinusLabel, EditorStyles.miniButtonRight))
                            {
                                rotationSnap /= 2.0f; modified = true;
                            }
                            TooltipUtility.SetToolTip(angleMinnusTooltip);
                        }

                        if (viewWidth >= 750)
                        {
                            if (viewWidth >= 865)
                            {
                                GUILayout.Label(scaleLargeLabel, miniTextStyle);
                            }
                            else
                            {
                                GUILayout.Label(scaleSmallLabel, miniTextStyle);
                            }
                            TooltipUtility.SetToolTip(scaleTooltip);
                        }
                        EditorGUI.BeginChangeCheck();
                        {
                            scaleSnap = EditorGUILayout.FloatField(scaleSnap, textInputStyle, MinSnapWidth, MaxSnapWidth);
                            if (viewWidth <= 750)
                            {
                                TooltipUtility.SetToolTip(scaleTooltip);
                            }
                        }
                        modified = EditorGUI.EndChangeCheck() || modified;
                        if (viewWidth >= 370)
                        {
                            GUILayout.Label(scaleUnitLabel, miniTextStyle);
                        }
                        if (viewWidth >= 700)
                        {
                            if (GUILayout.Button(scalePlusLabel, EditorStyles.miniButtonLeft))
                            {
                                scaleSnap *= 10.0f; modified = true;
                            }
                            TooltipUtility.SetToolTip(scalePlusTooltip);
                            if (GUILayout.Button(scaleMinusLabel, EditorStyles.miniButtonRight))
                            {
                                scaleSnap /= 10.0f; modified = true;
                            }
                            TooltipUtility.SetToolTip(scaleMinnusTooltip);
                        }
                    }
                }

                if (viewWidth >= 750)
                {
                    GUILayout.FlexibleSpace();
                }
                EditorGUI.BeginChangeCheck();
                if (showWireframe)
                {
                    showWireframe = GUILayout.Toggle(showWireframe, GUIStyleUtility.Skin.wireframe, EditorStyles.toolbarButton);
                }
                else
                {
                    showWireframe = GUILayout.Toggle(showWireframe, GUIStyleUtility.Skin.wireframeOn, EditorStyles.toolbarButton);
                }
                TooltipUtility.SetToolTip(showWireframeTooltip);
                if (EditorGUI.EndChangeCheck())
                {
                    wireframeModified = true;
                    modified          = true;
                }

                if (viewWidth >= 250)
                {
                    EditorGUI.BeginChangeCheck();
                    {
                        helperSurfaces = (HelperSurfaceFlags)EditorGUILayout.MaskField((int)helperSurfaces, helperSurfaceFlagStrings, EnumMaxWidth, EnumMinWidth);
                        TooltipUtility.SetToolTip(helperSurfacesTooltip);
                    }
                    if (EditorGUI.EndChangeCheck())
                    {
                        updateSurfaces = true;
                        modified       = true;
                    }
                }

                if (viewWidth >= 800)
                {
                    EditorGUILayout.Space();
                }

                if (GUILayout.Button(GUIStyleUtility.Skin.rebuildIcon, EditorStyles.toolbarButton))
                {
                    Debug.Log("Starting complete rebuild");
                    InternalCSGModelManager.skipRefresh = true;
                    RealtimeCSG.CSGSettings.Reload();
                    SceneViewEventHandler.UpdateDefines();

                    var startTime = EditorApplication.timeSinceStartup;
                    InternalCSGModelManager.Rebuild();
                    InternalCSGModelManager.OnHierarchyModified();
                    var hierarchy_update_endTime = EditorApplication.timeSinceStartup;

                    CSGBindings.RebuildAll();
                    var csg_endTime = EditorApplication.timeSinceStartup;

                    InternalCSGModelManager.UpdateMeshes();
                    MeshInstanceManager.UpdateHelperSurfaceVisibility();
                    var meshupdate_endTime = EditorApplication.timeSinceStartup;

                    updateSurfaces = true;
                    SceneViewEventHandler.ResetUpdateRoutine();
                    RealtimeCSG.CSGSettings.Save();
                    InternalCSGModelManager.skipRefresh = false;
                    Debug.Log(string.Format(CultureInfo.InvariantCulture,
                                            "Full hierarchy rebuild in {0:F} ms. Full CSG rebuild done in {1:F} ms. Mesh update done in {2:F} ms.",
                                            (hierarchy_update_endTime - startTime) * 1000,
                                            (csg_endTime - hierarchy_update_endTime) * 1000,
                                            (meshupdate_endTime - csg_endTime) * 1000
                                            ));
                }
                TooltipUtility.SetToolTip(rebuildTooltip);
            }
            EditorGUILayout.EndHorizontal();

            var mousePoint  = Event.current.mousePosition;
            var currentArea = GUILayoutUtility.GetLastRect();
            int controlID   = GUIUtility.GetControlID(BottomBarEditorOverlayHash, FocusType.Passive, currentArea);

            switch (Event.current.GetTypeForControl(controlID))
            {
            case EventType.MouseDown:       { if (currentArea.Contains(mousePoint))
                                              {
                                                  GUIUtility.hotControl = controlID; GUIUtility.keyboardControl = controlID; Event.current.Use();
                                              }
                                              break; }

            case EventType.MouseMove:       { if (currentArea.Contains(mousePoint))
                                              {
                                                  Event.current.Use();
                                              }
                                              break; }

            case EventType.MouseUp:         { if (GUIUtility.hotControl == controlID)
                                              {
                                                  GUIUtility.hotControl = 0; GUIUtility.keyboardControl = 0; Event.current.Use();
                                              }
                                              break; }

            case EventType.MouseDrag:       { if (GUIUtility.hotControl == controlID)
                                              {
                                                  Event.current.Use();
                                              }
                                              break; }

            case EventType.ScrollWheel: { if (currentArea.Contains(mousePoint))
                                          {
                                              Event.current.Use();
                                          }
                                          break; }
            }

            rotationSnap     = Mathf.Max(1.0f, Mathf.Abs((360 + (rotationSnap % 360))) % 360);
            moveSnapVector.x = Mathf.Max(1.0f / 1024.0f, moveSnapVector.x);
            moveSnapVector.y = Mathf.Max(1.0f / 1024.0f, moveSnapVector.y);
            moveSnapVector.z = Mathf.Max(1.0f / 1024.0f, moveSnapVector.z);

            scaleSnap = Mathf.Max(MathConstants.MinimumScale, scaleSnap);

            RealtimeCSG.CSGSettings.SnapToGrid   = snapToGrid;
            RealtimeCSG.CSGSettings.SnapVector   = moveSnapVector;
            RealtimeCSG.CSGSettings.SnapRotation = rotationSnap;
            RealtimeCSG.CSGSettings.SnapScale    = scaleSnap;
            RealtimeCSG.CSGSettings.UniformGrid  = uniformGrid;
//			RealtimeCSG.Settings.SnapVertex					= vertexSnap;
            RealtimeCSG.CSGSettings.GridVisible           = showGrid;
            RealtimeCSG.CSGSettings.LockAxisX             = lockAxisX;
            RealtimeCSG.CSGSettings.LockAxisY             = lockAxisY;
            RealtimeCSG.CSGSettings.LockAxisZ             = lockAxisZ;
            RealtimeCSG.CSGSettings.DistanceUnit          = distanceUnit;
            RealtimeCSG.CSGSettings.VisibleHelperSurfaces = helperSurfaces;

            if (wireframeModified)
            {
                RealtimeCSG.CSGSettings.SetWireframeShown(sceneView, showWireframe);
            }

            if (updateSurfaces)
            {
                MeshInstanceManager.UpdateHelperSurfaceVisibility();
            }

            if (modified)
            {
                GUI.changed = true;
                RealtimeCSG.CSGSettings.UpdateSnapSettings();
                RealtimeCSG.CSGSettings.Save();
                SceneView.RepaintAll();
            }
        }
        public static Vector3 DistanceVector3Field(Vector3 value, bool multiLine, GUILayoutOption[] options = null)
        {
            var distanceUnit = RealtimeCSG.CSGSettings.DistanceUnit;
            var nextUnit     = Units.CycleToNextUnit(distanceUnit);
            var unitText     = Units.GetUnitGUIContent(distanceUnit);

            bool modified          = false;
            bool clickedUnitButton = false;

            var areaWidth = EditorGUIUtility.currentViewWidth;

            const float minWidth         = 65;
            const float vectorLabelWidth = 12;

            var allWidth = (12 * 3) + (Width22Value * 3) + (minWidth * 3);

            Vector3 realValue = value;

            multiLine = multiLine || (allWidth >= areaWidth);
            if (multiLine)
            {
                GUILayout.BeginVertical();
            }
            var originalLabelWidth = EditorGUIUtility.labelWidth;

            EditorGUIUtility.labelWidth = vectorLabelWidth;
            GUILayout.BeginHorizontal();
            {
                EditorGUI.BeginChangeCheck();
                {
                    value.x = Units.DistanceUnitToUnity(distanceUnit, EditorGUILayout.DoubleField(VectorXContent, Units.UnityToDistanceUnit(distanceUnit, value.x), options));
                }
                if (EditorGUI.EndChangeCheck())
                {
                    realValue.x = value.x;                     // don't want to introduce math errors unless we actually modify something
                    modified    = true;
                }
                if (multiLine)
                {
                    clickedUnitButton = GUILayout.Button(unitText, EditorStyles.miniLabel, Width22) || clickedUnitButton;
                }
                if (multiLine)
                {
                    GUILayout.EndHorizontal();
                    GUILayout.BeginHorizontal();
                }
                EditorGUI.BeginChangeCheck();
                {
                    value.y = Units.DistanceUnitToUnity(distanceUnit, EditorGUILayout.DoubleField(VectorYContent, Units.UnityToDistanceUnit(distanceUnit, value.y), options));
                }
                if (EditorGUI.EndChangeCheck())
                {
                    realValue.y = value.y;                     // don't want to introduce math errors unless we actually modify something
                    modified    = true;
                }
                if (multiLine)
                {
                    clickedUnitButton = GUILayout.Button(unitText, EditorStyles.miniLabel, Width22) || clickedUnitButton;
                }
                if (multiLine)
                {
                    GUILayout.EndHorizontal();
                    GUILayout.BeginHorizontal();
                }
                EditorGUI.BeginChangeCheck();
                {
                    value.z = Units.DistanceUnitToUnity(distanceUnit, EditorGUILayout.DoubleField(VectorZContent, Units.UnityToDistanceUnit(distanceUnit, value.z), options));
                }
                if (EditorGUI.EndChangeCheck())
                {
                    realValue.z = value.z;                     // don't want to introduce math errors unless we actually modify something
                    modified    = true;
                }
                clickedUnitButton = GUILayout.Button(unitText, EditorStyles.miniLabel, Width22) || clickedUnitButton;
            }
            GUILayout.EndHorizontal();
            EditorGUIUtility.labelWidth = originalLabelWidth;
            if (multiLine)
            {
                GUILayout.EndVertical();
            }
            if (clickedUnitButton)
            {
                distanceUnit = nextUnit;
                RealtimeCSG.CSGSettings.DistanceUnit = distanceUnit;
                RealtimeCSG.CSGSettings.UpdateSnapSettings();
                RealtimeCSG.CSGSettings.Save();
                RepaintAll();
            }
            GUI.changed = modified;
            return(realValue);
        }
        public static float DistanceField(GUIContent label, float value, GUILayoutOption[] options = null)
        {
            bool modified     = false;
            var  distanceUnit = RealtimeCSG.CSGSettings.DistanceUnit;
            var  nextUnit     = Units.CycleToNextUnit(distanceUnit);
            var  unitText     = Units.GetUnitGUIContent(distanceUnit);

            float realValue = value;

            EditorGUI.BeginChangeCheck();
            {
                value = Units.DistanceUnitToUnity(distanceUnit, EditorGUILayout.DoubleField(label, Units.UnityToDistanceUnit(distanceUnit, value), options));
            }
            if (EditorGUI.EndChangeCheck())
            {
                realValue = value;                 // don't want to introduce math errors unless we actually modify something
                modified  = true;
            }
            if (GUILayout.Button(unitText, EditorStyles.miniLabel, Width22))
            {
                distanceUnit = nextUnit;
                RealtimeCSG.CSGSettings.DistanceUnit = distanceUnit;
                RealtimeCSG.CSGSettings.UpdateSnapSettings();
                RealtimeCSG.CSGSettings.Save();
                RepaintAll();
            }
            GUI.changed = modified;
            return(realValue);
        }
Exemplo n.º 5
0
        static void FreeDrawSettingsGUI(GeneratorFreeDraw generator, bool isSceneGUI)
        {
            var distanceUnit = RealtimeCSG.CSGSettings.DistanceUnit;
            var nextUnit     = Units.CycleToNextUnit(distanceUnit);
            var unitText     = Units.GetUnitGUIContent(distanceUnit);

            GUILayout.BeginVertical(CSG_GUIStyleUtility.ContentEmpty);
            {
                {
                    GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty);
                    {
                        GUILayout.Label(HeightContent, width65);
                        var height = generator.HaveHeight ? generator.Height : GeometryUtility.CleanLength(generator.DefaultHeight);
                        EditorGUI.BeginChangeCheck();
                        {
                            height = Units.DistanceUnitToUnity(distanceUnit, EditorGUILayout.DoubleField(Units.UnityToDistanceUnit(distanceUnit, height)));
                        }
                        if (EditorGUI.EndChangeCheck())
                        {
                            if (generator.HaveHeight)
                            {
                                generator.Height = height;
                            }
                            else
                            {
                                generator.DefaultHeight = height;
                            }
                        }
                        if (GUILayout.Button(unitText, EditorStyles.miniLabel, width20))
                        {
                            distanceUnit = nextUnit;
                            RealtimeCSG.CSGSettings.DistanceUnit = distanceUnit;
                            RealtimeCSG.CSGSettings.UpdateSnapSettings();
                            RealtimeCSG.CSGSettings.Save();
                            SceneView.RepaintAll();
                        }
                    }
                    GUILayout.EndHorizontal();
                    TooltipUtility.SetToolTip(HeightTooltip);
                }
#if EVALUATION
                EditorGUI.BeginDisabledGroup(true);
#endif
                {
                    GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty);
                    {
                        GUILayout.Label(CurveSidesContent, width65);
                        var subdivisions = generator.CurveSides;
                        EditorGUI.BeginChangeCheck();
                        {
                            subdivisions = (uint)Mathf.Clamp(EditorGUILayout.IntField((int)subdivisions), 0, 32);
                        }
                        if (EditorGUI.EndChangeCheck() && generator.CurveSides != subdivisions)
                        {
                            generator.CurveSides = subdivisions;
                        }
                    }
                    GUILayout.EndHorizontal();
                    TooltipUtility.SetToolTip(CurveSidesTooltip);
                }
                {
                    GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty);
                    {
                        EditorGUI.BeginDisabledGroup(!generator.HaveSelectedEdgesOrVertices);
                        {
                            var tangentState = generator.SelectedTangentState;
                            EditorGUI.BeginChangeCheck();
                            {
                                GUILayout.Label(EdgeTypeContent, width65);
                                EditorGUI.showMixedValue = !tangentState.HasValue;
                                tangentState             = (HandleConstraints)EditorGUILayout.EnumPopup(tangentState.HasValue ? tangentState.Value : HandleConstraints.Straight);
                                EditorGUI.showMixedValue = false;
                            }
                            if (EditorGUI.EndChangeCheck())
                            {
                                generator.SelectedTangentState = tangentState;
                            }
                        }
                        EditorGUI.EndDisabledGroup();
                    }
                    GUILayout.EndHorizontal();
                    TooltipUtility.SetToolTip(EdgeTypeTooltip);
                }
                EditorGUILayout.Space();
#if EVALUATION
                EditorGUI.EndDisabledGroup();
#endif

                EditorGUI.BeginDisabledGroup(!generator.HaveSelectedEdges);
                {
                    if (GUILayout.Button(SplitSelectedContent))
                    {
                        generator.SplitSelectedEdge();
                    }
                    TooltipUtility.SetToolTip(SplitSelectedTooltip);
                }
                EditorGUI.EndDisabledGroup();

                /*
                 * GUILayout.BeginHorizontal(GUIStyleUtility.ContentEmpty);
                 * {
                 *      if (isSceneGUI)
                 *              GUILayout.Label(AlphaContent, width75);
                 *      else
                 *              EditorGUILayout.PrefixLabel(AlphaContent);
                 *      var alpha = generator.Alpha;
                 *      EditorGUI.BeginChangeCheck();
                 *      {
                 *              alpha = EditorGUILayout.Slider(alpha, -1.0f, 3.0f);
                 *      }
                 *      if (EditorGUI.EndChangeCheck() && generator.Alpha != alpha)
                 *      {
                 *              generator.Alpha = alpha;
                 *      }
                 * }
                 * GUILayout.EndHorizontal();
                 */
            }
            GUILayout.EndVertical();
        }
Exemplo n.º 6
0
        static void OnGUIContents(CylinderGenerator generator, bool isSceneGUI)
        {
            //GUILayout.BeginVertical(GUIStyleUtility.ContentEmpty);
            //{
            //bool enabled = generator.HaveBrushes;
            GUILayout.BeginHorizontal(GUIStyleUtility.ContentEmpty);
            {
                /*
                 * EditorGUI.BeginDisabledGroup(!enabled);
                 * {
                 *      if (isSceneGUI)
                 *              GUILayout.BeginVertical(GUI.skin.box, width100);
                 *      else
                 *              GUILayout.BeginVertical(GUIStyle.none);
                 *      {
                 *              bool mixedValues = !enabled;
                 *              CSGOperationType operation = generator.CurrentCSGOperationType;
                 *              EditorGUI.BeginChangeCheck();
                 *              operation = GUIStyleUtility.ChooseOperation(operation, mixedValues);
                 *              if (EditorGUI.EndChangeCheck())
                 *              {
                 *                      generator.CurrentCSGOperationType = operation;
                 *              }
                 *      }
                 *      GUILayout.EndVertical();
                 * }
                 * EditorGUI.EndDisabledGroup();
                 */
                if (isSceneGUI)
                {
                    CylinderSettingsGUI(generator, isSceneGUI);
                }
            }
            GUILayout.EndHorizontal();

            GUILayout.Space(5);

            GUILayout.BeginVertical(GUIStyleUtility.ContentEmpty);
            {
                var distanceUnit = RealtimeCSG.CSGSettings.DistanceUnit;
                var nextUnit     = Units.CycleToNextUnit(distanceUnit);
                var unitText     = Units.GetUnitGUIContent(distanceUnit);
                GUILayout.BeginHorizontal(GUIStyleUtility.ContentEmpty);
                {
                    GUILayout.Label(HeightContent, width65);
                    if (isSceneGUI)
                    {
                        TooltipUtility.SetToolTip(HeightTooltip);
                    }
                    var height = generator.HaveHeight ? generator.Height : GeometryUtility.CleanLength(generator.DefaultHeight);
                    EditorGUI.BeginChangeCheck();
                    {
                        if (!isSceneGUI)
                        {
                            height = Units.DistanceUnitToUnity(distanceUnit, EditorGUILayout.DoubleField(Units.UnityToDistanceUnit(distanceUnit, height)));
                        }
                        else
                        {
                            height = Units.DistanceUnitToUnity(distanceUnit, EditorGUILayout.DoubleField(Units.UnityToDistanceUnit(distanceUnit, height), width65));
                        }
                    }
                    if (EditorGUI.EndChangeCheck())
                    {
                        if (generator.HaveHeight)
                        {
                            generator.Height = height;
                        }
                        else
                        {
                            generator.DefaultHeight = height;
                        }
                    }
                    if (GUILayout.Button(unitText, EditorStyles.miniLabel, width20))
                    {
                        distanceUnit = nextUnit;
                        RealtimeCSG.CSGSettings.DistanceUnit = distanceUnit;
                        RealtimeCSG.CSGSettings.UpdateSnapSettings();
                        RealtimeCSG.CSGSettings.Save();
                        SceneView.RepaintAll();
                    }
                }
                //if (!isSceneGUI)
                {
                    GUILayout.EndHorizontal();
                    TooltipUtility.SetToolTip(HeightTooltip);
                    GUILayout.BeginHorizontal(GUIStyleUtility.ContentEmpty);
                }
                //else
                //{
                //	GUILayout.Space(12);
                //}
                {
                    EditorGUI.BeginDisabledGroup(!generator.CanCommit);
                    {
                        GUILayout.Label(RadiusContent, width65);
                        if (isSceneGUI)
                        {
                            TooltipUtility.SetToolTip(RadiusTooltip);
                        }
                        var radius = generator.RadiusA;
                        EditorGUI.BeginChangeCheck();
                        {
                            if (!isSceneGUI)
                            {
                                radius = Units.DistanceUnitToUnity(distanceUnit, EditorGUILayout.DoubleField(Units.UnityToDistanceUnit(distanceUnit, radius)));
                            }
                            else
                            {
                                radius = Units.DistanceUnitToUnity(distanceUnit, EditorGUILayout.DoubleField(Units.UnityToDistanceUnit(distanceUnit, radius), width65));
                            }
                        }
                        if (EditorGUI.EndChangeCheck())
                        {
                            generator.RadiusA = radius;
                        }
                        if (GUILayout.Button(unitText, EditorStyles.miniLabel, width20))
                        {
                            distanceUnit = nextUnit;
                            RealtimeCSG.CSGSettings.DistanceUnit = distanceUnit;
                            RealtimeCSG.CSGSettings.UpdateSnapSettings();
                            RealtimeCSG.CSGSettings.Save();
                            SceneView.RepaintAll();
                        }
                    }
                    EditorGUI.EndDisabledGroup();
                }
                GUILayout.EndHorizontal();
                if (!isSceneGUI)
                {
                    TooltipUtility.SetToolTip(RadiusTooltip);
                }
            }
            GUILayout.EndVertical();

            {
                generator.CircleSides = IntSettingsSlider(generator.CircleSides, 3, 144, SidesContent, isSceneGUI);
                TooltipUtility.SetToolTip(SidesTooltip);
            }
            {
                generator.CircleOffset = SettingsSlider(generator.CircleOffset, 0, 360, OffsetContent, isSceneGUI);
                TooltipUtility.SetToolTip(OffsetTooltip);
            }



            if (!isSceneGUI)
            {
                GUILayout.Space(5);

                CylinderSettingsGUI(generator, isSceneGUI);

                //GUILayout.Space(10);
            }                     /*else
                                   * {
                                   *    GUILayout.Space(10);
                                   * }*/
                                  /*
                                   * EditorGUI.BeginDisabledGroup(!generator.CanCommit);
                                   * {
                                   *      GUILayout.BeginHorizontal(GUIStyleUtility.ContentEmpty);
                                   *      {
                                   *              if (GUILayout.Button(CommitContent)) { generator.DoCommit(); }
                                   *              TooltipUtility.SetToolTip(CommitTooltip);
                                   *              if (GUILayout.Button(CancelContent)) { generator.DoCancel(); }
                                   *              TooltipUtility.SetToolTip(CancelTooltip);
                                   *      }
                                   *      GUILayout.EndHorizontal();
                                   * }
                                   * EditorGUI.EndDisabledGroup();
                                   */
            //}
            //GUILayout.EndVertical();
        }
Exemplo n.º 7
0
        static float FloatUnitsSettings(float value, GUIContent content, ToolTip tooltip, bool isSceneGUI)
        {
            var distanceUnit = RealtimeCSG.CSGSettings.DistanceUnit;
            var unitText     = Units.GetUnitGUIContent(distanceUnit);

            float newValue;

            EditorGUI.BeginChangeCheck();
            {
                GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty);
                {
                    GUILayout.Label(content, width80);
                    if (isSceneGUI)
                    {
                        TooltipUtility.SetToolTip(tooltip);
                    }

                    if (!isSceneGUI)
                    {
                        newValue = Units.DistanceUnitToUnity(distanceUnit, EditorGUILayout.DoubleField(Units.UnityToDistanceUnit(distanceUnit, value)));
                    }
                    else
                    {
                        newValue = Units.DistanceUnitToUnity(distanceUnit, EditorGUILayout.DoubleField(Units.UnityToDistanceUnit(distanceUnit, value), width65));
                    }

                    if (GUILayout.Button(unitText, EditorStyles.miniLabel, width25))
                    {
                        distanceUnit = Units.CycleToNextUnit(distanceUnit);
                        RealtimeCSG.CSGSettings.DistanceUnit = distanceUnit;
                        RealtimeCSG.CSGSettings.UpdateSnapSettings();
                        RealtimeCSG.CSGSettings.Save();
                        CSG_EditorGUIUtility.UpdateSceneViews();
                    }
                }
                GUILayout.EndHorizontal();
                if (!isSceneGUI)
                {
                    TooltipUtility.SetToolTip(tooltip);
                }
            }
            if (EditorGUI.EndChangeCheck())
            {
                return(newValue);
            }
            return(value);
        }