Exemple #1
0
        void Shutdown(bool finalizing = false)
        {
            if (editor != this)
            {
                return;
            }

            editor = null;
            CSGSceneManagerRedirector.Interface = null;
            if (!initialized)
            {
                return;
            }

            EditorApplication.update -= OnFirstUpdate;
            EditorApplication.hierarchyWindowChanged   -= OnHierarchyWindowChanged;
            EditorApplication.hierarchyWindowItemOnGUI -= HierarchyWindowItemGUI.OnHierarchyWindowItemOnGUI;
            SceneView.onSceneGUIDelegate -= SceneViewEventHandler.OnScene;
            Undo.undoRedoPerformed       -= UndoRedoPerformed;

            initialized = false;

            // make sure the C++ side of things knows to clear the method pointers
            // so that we don't accidentally use them while closing unity
            NativeMethodBindings.ClearUnityMethods();
            NativeMethodBindings.ClearExternalMethods();

            if (!finalizing)
            {
                SceneToolRenderer.Cleanup();
            }
        }
        static void RunEditorUpdate()
        {
            if (!RealtimeCSG.CSGSettings.EnableRealtimeCSG)
            {
                return;
            }

            if (EditorApplication.isPlayingOrWillChangePlaymode)
            {
                return;
            }

            UpdateLoop.UpdateOnSceneChange();

            try
            {
                if (!ColorSettings.isInitialized)
                {
                    ColorSettings.Update();
                }
                InternalCSGModelManager.CheckForChanges(forceHierarchyUpdate: false);
                TooltipUtility.CleanCache();
            }
            catch (Exception ex)
            {
                Debug.LogException(ex);
            }
        }
        public bool DragUpdated(Transform transformInInspector, Rect selectionRect)
        {
            try
            {
                DragAndDrop.visualMode = DragAndDropVisualMode.Copy;

                hoverBrushSurface = null;
                hoverParent       = (transformInInspector == null) ? null : transformInInspector.parent;
                hoverSiblingIndex = (transformInInspector == null) ? int.MaxValue : transformInInspector.transform.GetSiblingIndex();

                float middle = (selectionRect.yMax + selectionRect.yMin) * 0.5f;
                if (Event.current.mousePosition.y > middle)
                {
                    hoverSiblingIndex++;
                }

                hoverRotation = MathConstants.identityQuaternion;
                hoverPosition = MathConstants.zeroVector3;
                haveNoParent  = true;
                return(true);
            }
            finally
            {
                if (!UpdateLoop.IsActive())
                {
                    UpdateLoop.ResetUpdateRoutine();
                }
            }
        }
 static UpdateLoop()
 {
     if (editor != null)
     {
         editor.Shutdown();
         editor = null;
     }
     editor = new UpdateLoop();
     editor.Initialize();
 }
Exemple #5
0
        void OnSceneUnloaded()
        {
            if (this.initialized)
            {
                this.Shutdown();
            }

            MeshInstanceManager.Shutdown();
            InternalCSGModelManager.Shutdown();

            editor = new UpdateLoop();
            editor.Initialize();
        }
        public bool DragUpdated(SceneView sceneView)
        {
            try
            {
                DisableVisualObjects();
                DragAndDrop.visualMode = DragAndDropVisualMode.Copy;

                var camera       = sceneView.camera;
                var intersection = SceneQueryUtility.FindMeshIntersection(camera, Event.current.mousePosition);
                var normal       = intersection.worldPlane.normal;

                hoverPosition     = intersection.worldIntersection;
                hoverParent       = SelectionUtility.FindParentToAssignTo(intersection);
                hoverBrushSurface = intersection.brush != null ? new SelectedBrushSurface(intersection.brush, intersection.surfaceIndex, intersection.worldPlane) : null;
                hoverRotation     = SelectionUtility.FindDragOrientation(sceneView, normal, sourceSurfaceAlignment, destinationSurfaceAlignment);
                haveNoParent      = (hoverParent == null);
                hoverSiblingIndex = int.MaxValue;

                RealtimeCSG.CSGGrid.SetForcedGrid(camera, intersection.worldPlane);

                // Since we're snapping points to grid and do not have a relative distance, relative snapping makes no sense
                var doGridSnapping = RealtimeCSG.CSGSettings.ActiveSnappingMode != SnapMode.None;
                if (doGridSnapping)
                {
                    var localPoints = new Vector3[8];
                    var localPlane  = intersection.worldPlane;
                    for (var i = 0; i < localPoints.Length; i++)
                    {
                        localPoints[i] = GeometryUtility.ProjectPointOnPlane(localPlane, (hoverRotation * projectedBounds[i]) + hoverPosition);
                    }

                    hoverPosition += RealtimeCSG.CSGGrid.SnapDeltaToGrid(camera, MathConstants.zeroVector3, localPoints);
                }
                hoverPosition = GeometryUtility.ProjectPointOnPlane(intersection.worldPlane, hoverPosition);                  // + (normal * 0.01f);

                EnableVisualObjects();
                return(true);
            }
            finally
            {
                if (!UpdateLoop.IsActive())
                {
                    UpdateLoop.ResetUpdateRoutine();
                }
            }
        }
Exemple #7
0
        public bool DragUpdated()
        {
            try
            {
                DisableVisualObjects();
                DragAndDrop.visualMode = DragAndDropVisualMode.Copy;

                var intersection = SceneQueryUtility.FindMeshIntersection(Event.current.mousePosition);
                var normal       = intersection.plane.normal;

                hoverPosition     = intersection.worldIntersection;
                hoverParent       = SelectionUtility.FindParentToAssignTo(intersection);
                hoverBrushSurface = intersection.brush != null ? new SelectedBrushSurface(intersection.brush, intersection.surfaceIndex) : null;
                hoverRotation     = SelectionUtility.FindDragOrientation(normal, sourceSurfaceAlignment, destinationSurfaceAlignment);
                haveNoParent      = (hoverParent == null);
                hoverSiblingIndex = int.MaxValue;

                RealtimeCSG.CSGGrid.SetForcedGrid(intersection.plane);

                var toggleSnapping = (Event.current.modifiers & EventModifiers.Control) == EventModifiers.Control;
                var doSnapping     = RealtimeCSG.CSGSettings.SnapToGrid ^ toggleSnapping;
                if (doSnapping)
                {
                    var localPoints = new Vector3[8];
                    var localPlane  = intersection.plane;
                    for (var i = 0; i < localPoints.Length; i++)
                    {
                        localPoints[i] = GeometryUtility.ProjectPointOnPlane(localPlane, (hoverRotation * projectedBounds[i]) + hoverPosition);
                    }

                    hoverPosition += RealtimeCSG.CSGGrid.SnapDeltaToGrid(MathConstants.zeroVector3, localPoints);
                }
                hoverPosition = GeometryUtility.ProjectPointOnPlane(intersection.plane, hoverPosition) + (normal * 0.01f);

                EnableVisualObjects();
                return(true);
            }
            finally
            {
                if (!UpdateLoop.IsActive())
                {
                    UpdateLoop.ResetUpdateRoutine();
                }
            }
        }
        void OnSceneUnloaded()
        {
            if (EditorApplication.isPlayingOrWillChangePlaymode)
            {
                return;
            }

            if (this.initialized)
            {
                this.Shutdown();
            }

            MeshInstanceManager.Shutdown();
            InternalCSGModelManager.Shutdown();

            editor = new UpdateLoop();
            editor.Initialize();
        }
        public static void ResetUpdateRoutine()
        {
            if (EditorApplication.isPlayingOrWillChangePlaymode)
            {
                return;
            }

            if (editor != null &&
                !editor.initialized)
            {
                editor = null;
            }
            if (editor == null)
            {
                editor = new UpdateLoop();
                editor.Initialize();
            }

            EditorApplication.update -= RunEditorUpdate;
            EditorApplication.update += RunEditorUpdate;
            InternalCSGModelManager.skipCheckForChanges = false;
        }
        internal static void OnScene(SceneView sceneView)
        {
            if (!RealtimeCSG.CSGSettings.EnableRealtimeCSG)
            {
                return;
            }

            if (EditorApplication.isPlayingOrWillChangePlaymode)
            {
                return;
            }
            UpdateLoop.UpdateOnSceneChange();

            if (!RealtimeCSG.CSGSettings.EnableRealtimeCSG)
            {
                ColorSettings.isInitialized = false;
            }
            else
            if (!ColorSettings.isInitialized)
            {
                if (Event.current.type == EventType.Repaint)
                {
                    ColorSettings.Update();
                }
            }

            if (!UpdateLoop.IsActive())
            {
                UpdateLoop.ResetUpdateRoutine();
            }

            if (Event.current.type == EventType.MouseDown ||
                Event.current.type == EventType.MouseDrag)
            {
                mousePressed = true;
            }
            else if (Event.current.type == EventType.MouseUp ||
                     Event.current.type == EventType.MouseMove)
            {
                mousePressed = false;
            }

            SceneDragToolManager.OnHandleDragAndDrop(sceneView);
            RectangleSelectionManager.Update(sceneView);
            EditModeManager.InitSceneGUI(sceneView);

            if (Event.current.type == EventType.Repaint)
            {
                MeshInstanceManager.RenderHelperSurfaces(sceneView);
            }

            if (Event.current.type == EventType.Repaint)
            {
                SceneToolRenderer.OnPaint(sceneView);
            }
            else
            //if (fallbackGUI)
            {
                SceneViewBottomBarGUI.ShowGUI(sceneView);
                SceneViewInfoGUI.DrawInfoGUI(sceneView);
            }

            EditModeManager.OnSceneGUI(sceneView);

            //if (fallbackGUI)
            {
                TooltipUtility.InitToolTip(sceneView);
                if (Event.current.type == EventType.Repaint)
                {
                    SceneViewBottomBarGUI.ShowGUI(sceneView);
                    SceneViewInfoGUI.DrawInfoGUI(sceneView);
                }
                if (!mousePressed)
                {
                    Handles.BeginGUI();
                    TooltipUtility.DrawToolTip(getLastRect: false);
                    Handles.EndGUI();
                }
            }

            if (Event.current.type == EventType.Layout)
            {
                var currentFocusControl = CSGHandles.FocusControl;
                if (prevFocusControl != currentFocusControl)
                {
                    prevFocusControl = currentFocusControl;
                    HandleUtility.Repaint();
                }
            }
        }
        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;
                    }
                    //(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;
                    }
                    //(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;
                    }
                    //(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);
                }

                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(sceneView, 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.RepaintAll();
            }
            #endregion
        }
        public static void OnInspectorGUI(UnityEngine.Object[] targets)
        {
            InitReflection();
            if (!localStyles)
            {
                popupStyle = new GUIStyle(EditorStyles.popup);
                //popupStyle.padding.top += 2;
                popupStyle.margin.top += 2;
                localStyles            = true;
            }


            bool updateMeshes = false;

            var models = new CSGModel[targets.Length];

            for (int i = targets.Length - 1; i >= 0; i--)
            {
                models[i] = targets[i] as CSGModel;
                if (!models[i])
                {
                    ArrayUtility.RemoveAt(ref models, i);
                }
            }

            if (models.Length == 0)
            {
                return;
            }


            var               settings                    = models[0].Settings;
            var               vertexChannels              = models[0].VertexChannels;
            ExportType?       exportType                  = models[0].exportType;
            OriginType?       originType                  = models[0].originType;
            bool?             exportColliders             = models[0].exportColliders;
            bool?             VertexChannelColor          = (vertexChannels & VertexChannelFlags.Color) == VertexChannelFlags.Color;
            bool?             VertexChannelTangent        = (vertexChannels & VertexChannelFlags.Tangent) == VertexChannelFlags.Tangent;
            bool?             VertexChannelNormal         = (vertexChannels & VertexChannelFlags.Normal) == VertexChannelFlags.Normal;
            bool?             VertexChannelUV0            = (vertexChannels & VertexChannelFlags.UV0) == VertexChannelFlags.UV0;
            bool?             InvertedWorld               = (settings & ModelSettingsFlags.InvertedWorld) == ModelSettingsFlags.InvertedWorld;
            bool?             NoCollider                  = (settings & ModelSettingsFlags.NoCollider) == ModelSettingsFlags.NoCollider;
            bool?             IsTrigger                   = (settings & ModelSettingsFlags.IsTrigger) == ModelSettingsFlags.IsTrigger;
            bool?             SetToConvex                 = (settings & ModelSettingsFlags.SetColliderConvex) == ModelSettingsFlags.SetColliderConvex;
            bool?             AutoGenerateRigidBody       = (settings & ModelSettingsFlags.AutoUpdateRigidBody) == ModelSettingsFlags.AutoUpdateRigidBody;
            bool?             DoNotRender                 = (settings & ModelSettingsFlags.DoNotRender) == ModelSettingsFlags.DoNotRender;
            bool?             ReceiveShadows              = !((settings & ModelSettingsFlags.DoNotReceiveShadows) == ModelSettingsFlags.DoNotReceiveShadows);
            bool?             AutoRebuildUVs              = (settings & ModelSettingsFlags.AutoRebuildUVs) == ModelSettingsFlags.AutoRebuildUVs;
            bool?             AutoRebuildColliders        = (settings & ModelSettingsFlags.NoAutoRebuildColliders) != ModelSettingsFlags.NoAutoRebuildColliders;
            bool?             PreserveUVs                 = (settings & ModelSettingsFlags.PreserveUVs) == ModelSettingsFlags.PreserveUVs;
            bool?             ShowGeneratedMeshes         = models[0].ShowGeneratedMeshes;
            ShadowCastingMode?ShadowCastingMode           = (ShadowCastingMode)(settings & ModelSettingsFlags.ShadowCastingModeFlags);
            var               defaultPhysicsMaterial      = models[0].DefaultPhysicsMaterial;
            var               defaultPhysicsMaterialMixed = false;

            for (int i = 1; i < models.Length; i++)
            {
                settings       = models[i].Settings;
                vertexChannels = models[i].VertexChannels;
                ExportType        currExportType             = models[i].exportType;
                OriginType        currOriginType             = models[i].originType;
                bool              currExportColliders        = models[i].exportColliders;
                bool              currVertexChannelColor     = (vertexChannels & VertexChannelFlags.Color) == VertexChannelFlags.Color;
                bool              currVertexChannelTangent   = (vertexChannels & VertexChannelFlags.Tangent) == VertexChannelFlags.Tangent;
                bool              currVertexChannelNormal    = (vertexChannels & VertexChannelFlags.Normal) == VertexChannelFlags.Normal;
                bool              currVertexChannelUV0       = (vertexChannels & VertexChannelFlags.UV0) == VertexChannelFlags.UV0;
                bool              currInvertedWorld          = (settings & ModelSettingsFlags.InvertedWorld) == ModelSettingsFlags.InvertedWorld;
                bool              currNoCollider             = (settings & ModelSettingsFlags.NoCollider) == ModelSettingsFlags.NoCollider;
                bool              currIsTrigger              = (settings & ModelSettingsFlags.IsTrigger) == ModelSettingsFlags.IsTrigger;
                bool              currSetToConvex            = (settings & ModelSettingsFlags.SetColliderConvex) == ModelSettingsFlags.SetColliderConvex;
                bool              currAutoGenerateRigidBody  = (settings & ModelSettingsFlags.AutoUpdateRigidBody) == ModelSettingsFlags.AutoUpdateRigidBody;
                bool              currDoNotRender            = (settings & ModelSettingsFlags.DoNotRender) == ModelSettingsFlags.DoNotRender;
                bool              currReceiveShadows         = !((settings & ModelSettingsFlags.DoNotReceiveShadows) == ModelSettingsFlags.DoNotReceiveShadows);
                bool              currAutoRebuildUVs         = (settings & ModelSettingsFlags.AutoRebuildUVs) == ModelSettingsFlags.AutoRebuildUVs;
                bool              currAutoRebuildColliders   = (settings & ModelSettingsFlags.NoAutoRebuildColliders) != ModelSettingsFlags.NoAutoRebuildColliders;
                bool              currPreserveUVs            = (settings & ModelSettingsFlags.PreserveUVs) == ModelSettingsFlags.PreserveUVs;
                bool              currShowGeneratedMeshes    = models[i].ShowGeneratedMeshes;
                var               currdefaultPhysicsMaterial = models[i].DefaultPhysicsMaterial;
                ShadowCastingMode currShadowCastingMode      = (ShadowCastingMode)(settings & ModelSettingsFlags.ShadowCastingModeFlags);

                if (VertexChannelColor.HasValue && VertexChannelColor.Value != currVertexChannelColor)
                {
                    VertexChannelColor = null;
                }
                if (VertexChannelTangent.HasValue && VertexChannelTangent.Value != currVertexChannelTangent)
                {
                    VertexChannelTangent = null;
                }
                if (VertexChannelNormal.HasValue && VertexChannelNormal.Value != currVertexChannelNormal)
                {
                    VertexChannelNormal = null;
                }
                if (VertexChannelUV0.HasValue && VertexChannelUV0.Value != currVertexChannelUV0)
                {
                    VertexChannelUV0 = null;
                }

                if (exportType.HasValue && exportType.Value != currExportType)
                {
                    exportType = null;
                }
                if (originType.HasValue && originType.Value != currOriginType)
                {
                    originType = null;
                }
                if (exportColliders.HasValue && exportColliders.Value != currExportColliders)
                {
                    exportColliders = null;
                }

                if (InvertedWorld.HasValue && InvertedWorld.Value != currInvertedWorld)
                {
                    InvertedWorld = null;
                }
                if (NoCollider.HasValue && NoCollider.Value != currNoCollider)
                {
                    NoCollider = null;
                }
                if (IsTrigger.HasValue && IsTrigger.Value != currIsTrigger)
                {
                    IsTrigger = null;
                }
                if (SetToConvex.HasValue && SetToConvex.Value != currSetToConvex)
                {
                    SetToConvex = null;
                }
                if (AutoGenerateRigidBody.HasValue && AutoGenerateRigidBody.Value != currAutoGenerateRigidBody)
                {
                    AutoGenerateRigidBody = null;
                }
                if (DoNotRender.HasValue && DoNotRender.Value != currDoNotRender)
                {
                    DoNotRender = null;
                }
                if (ReceiveShadows.HasValue && ReceiveShadows.Value != currReceiveShadows)
                {
                    ReceiveShadows = null;
                }
                if (ShadowCastingMode.HasValue && ShadowCastingMode.Value != currShadowCastingMode)
                {
                    ShadowCastingMode = null;
                }
                if (AutoRebuildUVs.HasValue && AutoRebuildUVs.Value != currAutoRebuildUVs)
                {
                    AutoRebuildUVs = null;
                }
                if (AutoRebuildColliders.HasValue && AutoRebuildColliders.Value != currAutoRebuildColliders)
                {
                    AutoRebuildColliders = null;
                }
                if (PreserveUVs.HasValue && PreserveUVs.Value != currPreserveUVs)
                {
                    PreserveUVs = null;
                }
                if (ShowGeneratedMeshes.HasValue && ShowGeneratedMeshes.Value != currShowGeneratedMeshes)
                {
                    ShowGeneratedMeshes = null;
                }

                if (defaultPhysicsMaterial != currdefaultPhysicsMaterial)
                {
                    defaultPhysicsMaterialMixed = true;
                }
            }

            GUILayout.BeginVertical(GUI.skin.box);
            {
                EditorGUILayout.LabelField("Behaviour");
                EditorGUI.indentLevel++;
                {
                    bool inverted_world = InvertedWorld.HasValue ? InvertedWorld.Value : false;
                    EditorGUI.BeginChangeCheck();
                    {
                        EditorGUI.showMixedValue = !InvertedWorld.HasValue;
                        inverted_world           = EditorGUILayout.Toggle(InvertedWorldContent, inverted_world);
                    }
                    if (EditorGUI.EndChangeCheck())
                    {
                        for (int i = 0; i < models.Length; i++)
                        {
                            if (inverted_world)
                            {
                                models[i].Settings |= ModelSettingsFlags.InvertedWorld;
                            }
                            else
                            {
                                models[i].Settings &= ~ModelSettingsFlags.InvertedWorld;
                            }
                        }
                        GUI.changed   = true;
                        InvertedWorld = inverted_world;
                    }
                }
                EditorGUI.indentLevel--;
            }
            GUILayout.EndVertical();
            if (models != null && models.Length == 1)
            {
                GUILayout.Space(10);
                GUILayout.BeginVertical(GUI.skin.box);
                {
                    EditorGUILayout.LabelField(ExportLabel);
                    {
                        GUILayout.BeginHorizontal();
                        {
                            GUILayout.Space(20);
                            EditorGUI.BeginChangeCheck();
                            {
                                EditorGUI.showMixedValue = !originType.HasValue;
                                originType = (OriginType)EditorGUILayout.EnumPopup(ExportOriginLabel, originType ?? OriginType.ModelCenter, popupStyle);
                                EditorGUI.showMixedValue = false;
                            }
                            if (EditorGUI.EndChangeCheck() && originType.HasValue)
                            {
                                for (int i = 0; i < models.Length; i++)
                                {
                                    models[i].originType = originType.Value;
                                }
                            }
                        }
                        GUILayout.EndHorizontal();
                        GUILayout.BeginHorizontal();
                        {
                            GUILayout.Space(20);
                            var exportColliderToggle = exportColliders ?? true;
                            EditorGUI.BeginChangeCheck();
                            {
                                EditorGUI.showMixedValue = !originType.HasValue;
                                exportColliderToggle     = EditorGUILayout.Toggle(ExportColliderLabel, exportColliderToggle);
                                EditorGUI.showMixedValue = false;
                            }
                            if (EditorGUI.EndChangeCheck() && originType.HasValue)
                            {
                                for (int i = 0; i < models.Length; i++)
                                {
                                    models[i].exportColliders = exportColliderToggle;
                                }
                                exportColliders = exportColliderToggle;
                            }
                        }
                        GUILayout.EndHorizontal();
                        GUILayout.BeginHorizontal();
                        {
                            GUILayout.Space(20);
                            EditorGUI.BeginDisabledGroup(!exportType.HasValue);
                            {
                                if (GUILayout.Button(ExportToButtonLabel) && exportType.HasValue)
                                {
#if !EVALUATION
                                    MeshInstanceManager.Export(models[0], exportType.Value, exportColliders ?? true);
#else
                                    Debug.LogWarning("Export is disabled in evaluation version");
#endif
                                }
                            }
                            EditorGUI.EndDisabledGroup();
                            EditorGUI.BeginChangeCheck();
                            {
                                EditorGUI.showMixedValue = !exportType.HasValue;
                                exportType = (ExportType)EditorGUILayout.EnumPopup(exportType ?? ExportType.FBX, popupStyle);
                                EditorGUI.showMixedValue = false;
                            }
                            if (EditorGUI.EndChangeCheck() && exportType.HasValue)
                            {
                                for (int i = 0; i < models.Length; i++)
                                {
                                    models[i].exportType = exportType.Value;
                                }
                            }
                        }
                        GUILayout.EndHorizontal();
                    }
                }
                GUILayout.EndVertical();
            }
            GUILayout.Space(10);
            GUILayout.BeginVertical(GUI.skin.box);
            {
                EditorGUILayout.LabelField("Physics");
                EditorGUI.indentLevel++;
                {
                    bool collider_value = NoCollider.HasValue ? NoCollider.Value : false;
                    EditorGUI.BeginChangeCheck();
                    {
                        EditorGUI.showMixedValue = !NoCollider.HasValue;
                        collider_value           = !EditorGUILayout.Toggle(GenerateColliderContent, !collider_value);
                    }
                    if (EditorGUI.EndChangeCheck())
                    {
                        for (int i = 0; i < models.Length; i++)
                        {
                            if (collider_value)
                            {
                                models[i].Settings |= ModelSettingsFlags.NoCollider;
                            }
                            else
                            {
                                models[i].Settings &= ~ModelSettingsFlags.NoCollider;
                            }
                        }
                        GUI.changed  = true;
                        NoCollider   = collider_value;
                        updateMeshes = true;
                    }
                }
                {
                    EditorGUI.indentLevel++;
                    var autoRebuildColliders = AutoRebuildColliders ?? false;
                    EditorGUI.BeginChangeCheck();
                    {
                        EditorGUI.showMixedValue = !AutoRebuildUVs.HasValue;
                        autoRebuildColliders     = EditorGUILayout.Toggle(AutoRebuildCollidersContent, autoRebuildColliders);
                    }
                    if (EditorGUI.EndChangeCheck())
                    {
                        for (int i = 0; i < models.Length; i++)
                        {
                            if (autoRebuildColliders)
                            {
                                models[i].Settings &= ~ModelSettingsFlags.NoAutoRebuildColliders;
                            }
                            else
                            {
                                models[i].Settings |= ModelSettingsFlags.NoAutoRebuildColliders;
                            }
                        }
                        GUI.changed          = true;
                        AutoRebuildColliders = autoRebuildColliders;
                        updateMeshes         = true;
                    }
                    EditorGUI.indentLevel--;
                }
                var have_no_collider = NoCollider.HasValue && NoCollider.Value;
                EditorGUI.BeginDisabledGroup(have_no_collider);
                {
                    bool trigger_value_mixed = have_no_collider ? true : !IsTrigger.HasValue;
                    bool trigger_value       = IsTrigger.HasValue ? IsTrigger.Value : false;
                    {
                        EditorGUI.BeginChangeCheck();
                        {
                            EditorGUI.showMixedValue = trigger_value_mixed;
                            trigger_value            = EditorGUILayout.Toggle(ModelIsTriggerContent, trigger_value);
                        }
                        if (EditorGUI.EndChangeCheck())
                        {
                            for (int i = 0; i < models.Length; i++)
                            {
                                if (trigger_value)
                                {
                                    models[i].Settings |= ModelSettingsFlags.IsTrigger;
                                }
                                else
                                {
                                    models[i].Settings &= ~ModelSettingsFlags.IsTrigger;
                                }
                            }
                            GUI.changed  = true;
                            IsTrigger    = trigger_value;
                            updateMeshes = true;
                        }
                    }
                    bool set_convex_value_mixed = have_no_collider ? true : !SetToConvex.HasValue;
                    bool set_convex_value       = have_no_collider ? false : (SetToConvex.HasValue ? SetToConvex.Value : false);
                    {
                        EditorGUI.BeginChangeCheck();
                        {
                            EditorGUI.showMixedValue = set_convex_value_mixed;
                            var prevColor = GUI.color;
                            if (!set_convex_value && trigger_value)
                            {
                                var color = new Color(1, 0.25f, 0.25f);
                                GUI.color = color;
                            }
                            set_convex_value = EditorGUILayout.Toggle(ColliderSetToConvexContent, set_convex_value);
                            GUI.color        = prevColor;
                        }
                        if (EditorGUI.EndChangeCheck())
                        {
                            for (int i = 0; i < models.Length; i++)
                            {
                                if (set_convex_value)
                                {
                                    models[i].Settings |= ModelSettingsFlags.SetColliderConvex;
                                }
                                else
                                {
                                    models[i].Settings &= ~ModelSettingsFlags.SetColliderConvex;
                                }
                            }
                            GUI.changed  = true;
                            SetToConvex  = set_convex_value;
                            updateMeshes = true;
                        }
                    }
                    {
                        EditorGUI.BeginChangeCheck();
                        {
                            EditorGUI.showMixedValue = defaultPhysicsMaterialMixed;
                            GUILayout.BeginHorizontal();
                            EditorGUILayout.PrefixLabel(DefaultPhysicsMaterialContent);
                            defaultPhysicsMaterial = EditorGUILayout.ObjectField(defaultPhysicsMaterial, typeof(PhysicMaterial), true) as PhysicMaterial;
                            GUILayout.EndHorizontal();
                        }
                        if (EditorGUI.EndChangeCheck())
                        {
                            for (int i = 0; i < models.Length; i++)
                            {
                                models[i].DefaultPhysicsMaterial = defaultPhysicsMaterial;
                            }
                            GUI.changed = true;
                            //MeshInstanceManager.Clear();
                            updateMeshes = true;
                        }
                    }
                    if (!have_no_collider && !set_convex_value && trigger_value)
                    {
                        var prevColor = GUI.color;
                        var color     = new Color(1, 0.25f, 0.25f);
                        GUI.color = color;
                        GUILayout.Label("Warning:\r\nFor performance reasons colliders need to\r\nbe convex!");

                        GUI.color = prevColor;
                    }
                }
                EditorGUI.EndDisabledGroup();
                {
                    bool autoRigidbody = (AutoGenerateRigidBody.HasValue ? AutoGenerateRigidBody.Value : false);
                    EditorGUI.BeginChangeCheck();
                    {
                        EditorGUI.showMixedValue = !AutoGenerateRigidBody.HasValue;
                        autoRigidbody            = !EditorGUILayout.Toggle(ColliderAutoRigidBodyContent, !autoRigidbody);
                    }
                    if (EditorGUI.EndChangeCheck())
                    {
                        for (int i = 0; i < models.Length; i++)
                        {
                            if (autoRigidbody)
                            {
                                models[i].Settings |= ModelSettingsFlags.AutoUpdateRigidBody;
                            }
                            else
                            {
                                models[i].Settings &= ~ModelSettingsFlags.AutoUpdateRigidBody;
                            }
                        }
                        GUI.changed           = true;
                        AutoGenerateRigidBody = autoRigidbody;
                    }
                }
                EditorGUI.indentLevel--;
            }
            GUILayout.EndVertical();
            GUILayout.Space(10);
            GUILayout.BeginVertical(GUI.skin.box);
            {
                ShadowCastingMode shadowcastingValue = ShadowCastingMode.HasValue ? ShadowCastingMode.Value : UnityEngine.Rendering.ShadowCastingMode.On;
                var castOnlyShadow = (shadowcastingValue == UnityEngine.Rendering.ShadowCastingMode.ShadowsOnly);
                EditorGUILayout.LabelField("Rendering");
                EditorGUI.indentLevel++;
                EditorGUI.BeginDisabledGroup(castOnlyShadow);
                {
                    bool donotrender_value = castOnlyShadow ? true : (DoNotRender.HasValue ? DoNotRender.Value : false);
                    EditorGUI.BeginChangeCheck();
                    {
                        EditorGUI.showMixedValue = castOnlyShadow ? true : !DoNotRender.HasValue;
                        donotrender_value        = EditorGUILayout.Toggle(DoNotRenderContent, donotrender_value);
                    }
                    if (EditorGUI.EndChangeCheck())
                    {
                        for (int i = 0; i < models.Length; i++)
                        {
                            if (donotrender_value)
                            {
                                models[i].Settings |= ModelSettingsFlags.DoNotRender;
                            }
                            else
                            {
                                models[i].Settings &= ~ModelSettingsFlags.DoNotRender;
                            }
                        }
                        GUI.changed  = true;
                        DoNotRender  = donotrender_value;
                        updateMeshes = true;
                    }
                }
                EditorGUI.EndDisabledGroup();
                GUILayout.Space(10);
                EditorGUI.BeginDisabledGroup(DoNotRender.HasValue && DoNotRender.Value);
                {
                    EditorGUI.BeginChangeCheck();
                    {
                        EditorGUI.showMixedValue = !ShadowCastingMode.HasValue;
                        shadowcastingValue       = (ShadowCastingMode)EditorGUILayout.EnumPopup(CastShadows, shadowcastingValue);
                    }
                    if (EditorGUI.EndChangeCheck())
                    {
                        for (int i = 0; i < models.Length; i++)
                        {
                            settings           = models[i].Settings;
                            settings          &= ~ModelSettingsFlags.ShadowCastingModeFlags;
                            settings          |= (ModelSettingsFlags)(((int)shadowcastingValue) & (int)ModelSettingsFlags.ShadowCastingModeFlags);
                            models[i].Settings = settings;
                        }
                        GUI.changed       = true;
                        ShadowCastingMode = shadowcastingValue;
                        updateMeshes      = true;
                    }

                    var isUsingDeferredRenderingPath = false;                    //IsUsingDeferredRenderingPath();
                    EditorGUI.BeginDisabledGroup(castOnlyShadow || isUsingDeferredRenderingPath);
                    {
                        var receiveshadowsValue = !castOnlyShadow && (isUsingDeferredRenderingPath || (ReceiveShadows ?? false));
                        EditorGUI.BeginChangeCheck();
                        {
                            EditorGUI.showMixedValue = (castOnlyShadow || !ReceiveShadows.HasValue) && !isUsingDeferredRenderingPath;
                            receiveshadowsValue      = EditorGUILayout.Toggle(CSGModelComponentInspectorGUI.ReceiveShadowsContent, receiveshadowsValue || isUsingDeferredRenderingPath);
                        }
                        if (EditorGUI.EndChangeCheck())
                        {
                            for (int i = 0; i < models.Length; i++)
                            {
                                if (receiveshadowsValue)
                                {
                                    models[i].Settings &= ~ModelSettingsFlags.DoNotReceiveShadows;
                                }
                                else
                                {
                                    models[i].Settings |= ModelSettingsFlags.DoNotReceiveShadows;
                                }
                            }
                            GUI.changed    = true;
                            ReceiveShadows = receiveshadowsValue;
                        }
                    }
                    EditorGUI.EndDisabledGroup();
                }
                EditorGUI.EndDisabledGroup();

                EditorGUI.BeginDisabledGroup(castOnlyShadow);
                EditorGUI.showMixedValue = false;
                UpdateTargets(models);
                if (_probesInstance != null &&
                    _probesOnGUIMethod != null &&
                    _probesTargets != null &&
                    _probesSerializedObject != null &&
                    _probesInitialized)
                {
                    GUILayout.Space(10);
                    try
                    {
#if UNITY_5_6_OR_NEWER
                        _probesSerializedObject.UpdateIfRequiredOrScript();
#else
                        _probesSerializedObject.UpdateIfDirtyOrScript();
#endif
                        _probesOnGUIMethod.Invoke(_probesInstance, new System.Object[] { _probesTargets, (Renderer)_probesTargets[0], false });
                        _probesSerializedObject.ApplyModifiedProperties();
                    }
                    catch { }
                }
                EditorGUI.EndDisabledGroup();
                EditorGUI.indentLevel--;
            }
            GUILayout.EndVertical();
            GUILayout.Space(10);
            GUILayout.BeginVertical(GUI.skin.box);
            {
                EditorGUILayout.LabelField("Lighting");
                EditorGUI.indentLevel++;
                {
                    EditorGUI.indentLevel++;
                    EditModeCommonGUI.UpdateButtons(models);
                    EditorGUI.indentLevel--;

                    EditorGUILayout.LabelField("UV Settings");
                    EditorGUI.indentLevel++;
                    {
                        var autoRebuildUvs = AutoRebuildUVs ?? false;
                        EditorGUI.BeginChangeCheck();
                        {
                            EditorGUI.showMixedValue = !AutoRebuildUVs.HasValue;
                            autoRebuildUvs           = EditorGUILayout.Toggle(AutoRebuildUVsContent, autoRebuildUvs);
                        }
                        if (EditorGUI.EndChangeCheck())
                        {
                            for (int i = 0; i < models.Length; i++)
                            {
                                if (autoRebuildUvs)
                                {
                                    models[i].Settings |= ModelSettingsFlags.AutoRebuildUVs;
                                }
                                else
                                {
                                    models[i].Settings &= ~ModelSettingsFlags.AutoRebuildUVs;
                                }
                            }
                            GUI.changed    = true;
                            AutoRebuildUVs = autoRebuildUvs;
                            updateMeshes   = true;
                        }
                    }
                    {
                        var preserveUVs = PreserveUVs ?? false;
                        EditorGUI.BeginChangeCheck();
                        {
                            EditorGUI.showMixedValue = !PreserveUVs.HasValue;
                            preserveUVs = EditorGUILayout.Toggle(PreserveUVsContent, preserveUVs);
                        }
                        if (EditorGUI.EndChangeCheck())
                        {
                            for (int i = 0; i < models.Length; i++)
                            {
                                if (preserveUVs)
                                {
                                    models[i].Settings |= ModelSettingsFlags.PreserveUVs;
                                }
                                else
                                {
                                    models[i].Settings &= ~ModelSettingsFlags.PreserveUVs;
                                }
                            }
                            GUI.changed  = true;
                            PreserveUVs  = preserveUVs;
                            updateMeshes = true;
                        }
                    }
                    EditorGUI.indentLevel--;
                }
                EditorGUI.indentLevel--;
            }
            GUILayout.EndVertical();
            GUILayout.Space(10);
            GUILayout.BeginVertical(GUI.skin.box);
            {
                EditorGUILayout.LabelField("Mesh (advanced)");
                EditorGUI.indentLevel++;
                {
                    var showGeneratedMeshes = ShowGeneratedMeshes ?? false;
                    EditorGUI.BeginChangeCheck();
                    {
                        EditorGUI.showMixedValue = !ShowGeneratedMeshes.HasValue;
                        showGeneratedMeshes      = EditorGUILayout.Toggle(ShowGeneratedMeshesContent, showGeneratedMeshes);
                    }
                    if (EditorGUI.EndChangeCheck())
                    {
                        for (int i = 0; i < models.Length; i++)
                        {
                            models[i].ShowGeneratedMeshes = showGeneratedMeshes;
                            MeshInstanceManager.UpdateGeneratedMeshesVisibility(models[i]);
                        }
                    }
                    GUILayout.Space(10);

                    EditorGUILayout.LabelField("Used Vertex Channels");
                    EditorGUI.indentLevel++;
                    {
                        var vertex_channel_color   = VertexChannelColor ?? false;
                        var vertex_channel_tangent = VertexChannelTangent ?? false;
                        var vertex_channel_normal  = VertexChannelNormal ?? false;
                        var vertex_channel_UV0     = VertexChannelUV0 ?? false;
                        EditorGUI.BeginChangeCheck();
                        {
                            EditorGUI.showMixedValue = !VertexChannelColor.HasValue;
                            vertex_channel_color     = EditorGUILayout.Toggle(VertexChannelColorContent, vertex_channel_color);

                            EditorGUI.showMixedValue = !VertexChannelTangent.HasValue;
                            vertex_channel_tangent   = EditorGUILayout.Toggle(VertexChannelTangentContent, vertex_channel_tangent);

                            EditorGUI.showMixedValue = !VertexChannelNormal.HasValue;
                            vertex_channel_normal    = EditorGUILayout.Toggle(VertexChannelNormalContent, vertex_channel_normal);

                            EditorGUI.showMixedValue = !VertexChannelUV0.HasValue;
                            vertex_channel_UV0       = EditorGUILayout.Toggle(VertexChannelUV1Content, vertex_channel_UV0);
                        }
                        if (EditorGUI.EndChangeCheck())
                        {
                            for (int i = 0; i < models.Length; i++)
                            {
                                var vertexChannel = models[i].VertexChannels;
                                vertexChannel &= ~(VertexChannelFlags.Color |
                                                   VertexChannelFlags.Tangent |
                                                   VertexChannelFlags.Normal |
                                                   VertexChannelFlags.UV0);

                                if (vertex_channel_color)
                                {
                                    vertexChannel |= VertexChannelFlags.Color;
                                }
                                if (vertex_channel_tangent)
                                {
                                    vertexChannel |= VertexChannelFlags.Tangent;
                                }
                                if (vertex_channel_normal)
                                {
                                    vertexChannel |= VertexChannelFlags.Normal;
                                }
                                if (vertex_channel_UV0)
                                {
                                    vertexChannel |= VertexChannelFlags.UV0;
                                }
                                models[i].VertexChannels = vertexChannel;
                            }
                            GUI.changed = true;
                        }
                    }
                    EditorGUI.indentLevel--;
                }
                EditorGUI.indentLevel--;
            }
            GUILayout.EndVertical();
            if (models != null && models.Length == 1)
            {
                GUILayout.Space(10);

                GUILayout.BeginVertical(GUI.skin.box);
                _showDetails = EditorGUILayout.BeginToggleGroup("Statistics", _showDetails);
                if (_showDetails)
                {
                    var model_cache = InternalCSGModelManager.GetModelCache(models[0]);
                    if (model_cache == null ||
                        model_cache.GeneratedMeshes == null ||
                        !model_cache.GeneratedMeshes)
                    {
                        GUILayout.Label("Could not find model cache for this model.");
                    }
                    else
                    {
                        var meshContainer = model_cache.GeneratedMeshes;


                        var totalTriangles = 0;
                        var totalVertices  = 0;
                        var totalMeshes    = 0;

                        var materialMeshes = new Dictionary <Material, List <MeshData> >();
                        foreach (var instance in meshContainer.meshInstances.Values)
                        {
                            var mesh = instance.SharedMesh;
                            if (!MeshInstanceManager.HasVisibleMeshRenderer(instance))
                            {
                                continue;
                            }

                            List <MeshData> meshes;
                            if (!materialMeshes.TryGetValue(instance.RenderMaterial, out meshes))
                            {
                                meshes = new List <MeshData>();
                                materialMeshes[instance.RenderMaterial] = meshes;
                            }

                            var meshData = new MeshData();
                            meshData.Mesh          = mesh;
                            meshData.VertexCount   = mesh.vertexCount;
                            meshData.TriangleCount = mesh.triangles.Length / 3;
                            meshes.Add(meshData);

                            totalVertices += meshData.VertexCount;
                            totalTriangles = meshData.TriangleCount;
                            totalMeshes++;
                        }
                        EditorGUI.indentLevel++;
                        EditorGUILayout.Space();
                        EditorGUILayout.LabelField("total:");
                        EditorGUILayout.LabelField("vertices: " + totalVertices + "  triangles: " + totalTriangles + "  materials: " + materialMeshes.Count + "  meshes: " + totalMeshes);
                        GUILayout.Space(10);
                        EditorGUILayout.LabelField("meshes:");
                        foreach (var item in materialMeshes)
                        {
                            var material = item.Key;
                            var meshes   = item.Value;

                            GUILayout.BeginHorizontal();
                            {
                                EditorGUI.BeginDisabledGroup(true);
                                {
                                    EditorGUILayout.ObjectField(material, typeof(Material), true);
                                }
                                GUILayout.BeginVertical();
                                {
                                    if (meshes.Count == 1)
                                    {
                                        EditorGUILayout.ObjectField(meshes[0].Mesh, typeof(Mesh), true);
                                        EditorGUILayout.LabelField("vertices " + meshes[0].VertexCount + "  triangles " + meshes[0].TriangleCount);
                                    }
                                    else
                                    {
                                        for (int i = 0; i < meshes.Count; i++)
                                        {
                                            EditorGUILayout.ObjectField(meshes[i].Mesh, typeof(Mesh), true);
                                            EditorGUILayout.LabelField("vertices " + meshes[i].VertexCount + "  triangles " + meshes[i].TriangleCount);
                                        }
                                    }
                                }
                                GUILayout.EndVertical();
                                EditorGUI.EndDisabledGroup();
                            }
                            GUILayout.EndHorizontal();
                            EditorGUILayout.Space();
                        }
                        EditorGUI.indentLevel--;
                    }
                }
                EditorGUILayout.EndToggleGroup();
                GUILayout.EndVertical();
            }
            EditorGUI.showMixedValue = false;
            if (updateMeshes)
            {
                InternalCSGModelManager.DoForcedMeshUpdate();
                UpdateLoop.ResetUpdateRoutine();
            }
        }
        internal static void OnScene(SceneView sceneView)
        {
            if (Event.current.type == EventType.MouseMove)
            {
                sceneView.Repaint();
            }

            sceneView.cameraSettings.dynamicClip         = false;
            sceneView.cameraSettings.easingEnabled       = false;
            sceneView.cameraSettings.accelerationEnabled = false;

            //if (sceneView.orthographic)
            //{
            //    sceneView.camera.nearClipPlane = 1;
            //    sceneView.camera.farClipPlane = 1001f;

            //    var camPos = sceneView.pivot;
            //    var camForward = sceneView.camera.transform.forward;
            //    for (int i = 0; i < 3; i++)
            //    {
            //        if (!FastApproximately(camForward[i], 0, .01f))
            //        {
            //            camPos[i] = 1000;
            //        }
            //    }
            //    sceneView.pivot = camPos;
            //}

            if (sceneView.orthographic)
            {
                if (Event.current.type == EventType.KeyDown &&
                    Event.current.keyCode == KeyCode.F)
                {
                    Event.current.Use();
                    sceneView.pivot = Vector3.zero;
                    if (TryGetSelectionBounds(out Bounds bounds))
                    {
                        var sz = bounds.extents.magnitude;
                        sz = Mathf.Clamp(sz, 0.05f, 500);
                        sceneView.pivot = bounds.center;
                        sceneView.size  = sz;
                    }
                }

                if (sceneView.size > 500)
                {
                    sceneView.size = 500;
                }

                if (sceneView.size < .05f)
                {
                    sceneView.size = .05f;
                }
            }

            CSGSettings.RegisterSceneView(sceneView);

            if (!RealtimeCSG.CSGSettings.EnableRealtimeCSG ||
                EditorApplication.isPlayingOrWillChangePlaymode)
            {
                return;
            }

            UpdateLoop.UpdateOnSceneChange();

            if (!RealtimeCSG.CSGSettings.EnableRealtimeCSG)
            {
                ColorSettings.isInitialized = false;
            }
            else if (!ColorSettings.isInitialized)
            {
                if (Event.current.type == EventType.Repaint)
                {
                    ColorSettings.Update();
                }
            }

            if (!UpdateLoop.IsActive())
            {
                UpdateLoop.ResetUpdateRoutine();
            }

            if (Event.current.type == EventType.MouseDown ||
                Event.current.type == EventType.MouseDrag)
            {
                mousePressed = true;
            }
            else if (Event.current.type == EventType.MouseUp ||
                     Event.current.type == EventType.MouseMove)
            {
                mousePressed = false;
            }

            SceneDragToolManager.OnHandleDragAndDrop(sceneView);
            RectangleSelectionManager.Update(sceneView);
            EditModeManager.InitSceneGUI(sceneView);

            if (Event.current.type == EventType.Repaint)
            {
                MeshInstanceManager.UpdateHelperSurfaces();
                SceneToolRenderer.OnPaint(sceneView);
            }
            else
            {
                SceneViewBottomBarGUI.ShowGUI(sceneView);
                SceneViewInfoGUI.DrawInfoGUI(sceneView);
            }

            //if(EditorWindow.mouseOverWindow == sceneView)
            {
                EditModeManager.OnSceneGUI(sceneView);

                TooltipUtility.InitToolTip(sceneView);

                if (!mousePressed)
                {
                    Handles.BeginGUI();
                    TooltipUtility.DrawToolTip(getLastRect: false);
                    Handles.EndGUI();
                }

                if (Event.current.type == EventType.Layout)
                {
                    var currentFocusControl = CSGHandles.FocusControl;
                    if (prevFocusControl != currentFocusControl)
                    {
                        prevFocusControl = currentFocusControl;
                        HandleUtility.Repaint();
                    }
                }
            }
        }