Esempio n. 1
0
        public void OnSceneGUI(SceneView sceneView)
        {
            var camera = sceneView.camera;

            // defer surface updates when it's not currently visible
            if ((VisualizationMode & (VisualizationMode.Outline | VisualizationMode.SimpleOutline)) != VisualizationMode.None)
            {
                UpdateBrushState();
                brushOutlineRenderer.RenderAll(camera);
            }

            if ((VisualizationMode & VisualizationMode.Surface) == VisualizationMode.Surface)
            {
                UpdateSurfaceState();
                surfaceOutlineRenderer.RenderAll(camera);
            }

            handleRenderer.End();
            handleRenderer.RenderAll(camera);
            handleRenderer.Begin();

            var focus = UnitySceneExtensions.SceneHandleUtility.focusControl;

            if (prevFocus != focus)
            {
                prevFocus = focus;
                SceneView.RepaintAll();
            }
        }
Esempio n. 2
0
        void UpdateSurfaceState()
        {
            if (updateSurfaceSelection)
            {
                updateSurfaceSelection = false;
                UpdateSurfaceSelection();
                updateSurfaceWireframe = true;
            }
            if (updateSurfaceWireframe)
            {
                updateSurfaceWireframe = false;
                UpdateSurfaceWireframe();
                updateSurfaceLineCache = true;
            }
            if (updateSurfaceLineCache)
            {
                var selection = ChiselSurfaceSelectionManager.Selection;
                var hovered   = ChiselSurfaceSelectionManager.Hovered;
                updateSurfaceLineCache = false;
                surfaceOutlineRenderer.Begin();
                foreach (var pair in surfaceOutlines)
                {
                    var wireframe = pair.Value;
                    if (wireframe == null)
                    {
                        continue;
                    }

                    var outline = pair.Key;
                    var surface = outline.surface;
                    if (hovered.Contains(surface))
                    {
                        continue;
                    }

                    var brush = surface.TreeBrush;
                    if (!brush.Valid)
                    {
                        continue;
                    }

                    var modelTransform = outline.transform;

                    Matrix4x4 transformation;
                    if (modelTransform)
                    {
                        transformation = modelTransform.localToWorldMatrix * brush.NodeToTreeSpaceMatrix;
                    }
                    else
                    {
                        transformation = brush.NodeToTreeSpaceMatrix;
                    }

                    if (selection.Contains(surface))
                    {
                        surfaceOutlineRenderer.DrawOutlines(transformation, wireframe, ColorManager.kSelectedOutlineColor, thickness: 3);
                    }
                }
                foreach (var pair in surfaceOutlines)
                {
                    var wireframe = pair.Value;
                    if (wireframe == null)
                    {
                        continue;
                    }

                    var outline = pair.Key;
                    var surface = outline.surface;
                    if (!hovered.Contains(surface))
                    {
                        continue;
                    }

                    var brush = surface.TreeBrush;
                    if (!brush.Valid)
                    {
                        continue;
                    }

                    var modelTransform = outline.transform;

                    Matrix4x4 transformation;
                    if (modelTransform)
                    {
                        transformation = modelTransform.localToWorldMatrix * brush.NodeToTreeSpaceMatrix;
                    }
                    else
                    {
                        transformation = brush.NodeToTreeSpaceMatrix;
                    }

                    if (selection.Contains(surface))
                    {
                        surfaceOutlineRenderer.DrawOutlines(transformation, wireframe, ColorManager.kSelectedHoverOutlineColor, thickness: 3);
                    }
                    else
                    {
                        surfaceOutlineRenderer.DrawOutlines(transformation, wireframe, ColorManager.kPreSelectedOutlineColor, thickness: 3);
                    }
                }
                surfaceOutlineRenderer.End();
            }
        }
Esempio n. 3
0
        void UpdateBrushState()
        {
            if (updateBrushSelection)
            {
                updateBrushSelection = false;
                UpdateBrushSelection();
                updateBrushWireframe = true;
            }
            if (updateBrushWireframe)
            {
                updateBrushWireframe = false;
                UpdateBrushWireframe();
                updateBrushLineCache = true;
            }
            if (updateBrushLineCache)
            {
                updateBrushLineCache = false;
                brushOutlineRenderer.Begin();

                foreach (var pair in brushOutlines)
                {
                    var wireframe = pair.Value;
                    if (wireframe == null)
                    {
                        continue;
                    }

                    var outline = pair.Key;
                    if (!outline.brush.Valid)
                    {
                        continue;
                    }

                    // TODO: simplify this
                    var wireframeValue = pair.Value;
                    var modelTransform = outline.transform;
                    //var brushes		= outline.brush.AllSynchronizedVariants;
                    //var anySelected	= ChiselSyncSelection.IsAnyBrushVariantSelected(brushes);

                    //foreach (var brush in brushes)
                    var brush       = outline.brush;
                    var anySelected = ChiselSyncSelection.IsBrushVariantSelected(brush);
                    {
                        Matrix4x4 transformation;
                        if (modelTransform)
                        {
                            transformation = modelTransform.localToWorldMatrix * brush.NodeToTreeSpaceMatrix;
                        }
                        else
                        {
                            transformation = brush.NodeToTreeSpaceMatrix;
                        }

                        if ((VisualizationMode & VisualizationMode.Outline) == VisualizationMode.Outline)
                        {
                            var directSelect = !ChiselEditModeManager.EditMode.ShowCompleteOutline &&
                                               ((brush == outline.brush && !anySelected) || (anySelected && ChiselSyncSelection.IsBrushVariantSelected(brush)));

                            // TODO: tweak look of selection, figure out how to do backfaced lighting of edges, for clarity
                            // TODO: support selecting surfaces/edges/points (without showing the entire object selection)
                            if (directSelect)
                            {
                                brushOutlineRenderer.DrawOutlines(transformation, wireframeValue, ColorManager.kSelectedOutlineColor, thickness: 3.0f, onlyInnerLines: false);
                            }
                            else
                            {
                                brushOutlineRenderer.DrawOutlines(transformation, wireframeValue, ColorManager.kUnselectedOutlineColor, thickness: 1.0f, onlyInnerLines: false);// (ChiselEditModeManager.EditMode == CSGEditMode.ShapeEdit));
                            }
                        }

                        if ((VisualizationMode & VisualizationMode.SimpleOutline) == VisualizationMode.SimpleOutline)
                        {
                            brushOutlineRenderer.DrawSimpleOutlines(transformation, wireframeValue, ColorManager.kUnselectedOutlineColor);
                        }
                    }
                }
                brushOutlineRenderer.End();
            }
        }