示例#1
0
        void CreateNewGradient()
        {
            if (currentGradient.HasValue)
            {
                if (!PromptSave())
                {
                    return;
                }
            }

            currentGradient       = new ReGradientData();
            currentGradient.Size  = new Vector2Int(256, 64);
            currentGradient.Nodes = new List <ReGradientNode>();

            currentGradient.AddNode(Color.white, 0f);
            currentGradient.AddNode(Color.black, 1f);
        }
示例#2
0
        private void OnGUI()
        {
            if (gradientCompute == null)
            {
                LoadGradientCompute();
            }
            if (!currentGradient.HasValue)
            {
                CreateNewGradient();
            }
            if (previewTexture is null)
            {
                SetupPreviewTexture();
            }
            // if (selectedNode > currentGradient.Nodes.Count) selectedNode = -1;

            using (new GUILayout.HorizontalScope(EditorStyles.toolbar, GUILayout.Height(50f)))
            {
                if (GUILayout.Button("New", EditorStyles.toolbarButton))
                {
                    CreateNewGradient();
                    SetupPreviewTexture();
                    GeneratePreview();
                    selectedNode = -1;
                    lastPath     = "";
                }
                if (GUILayout.Button("Load", EditorStyles.toolbarButton))
                {
                    Load();
                    lastPath = "";
                }
                if (GUILayout.Button("Save", EditorStyles.toolbarButton))
                {
                    Save();
                }
                if (GUILayout.Button("Export", EditorStyles.toolbarButton))
                {
                    Export();
                }
            }

            if (gradientCompute == null)
            {
                EditorGUILayout.LabelField("GradientCompute is not assigned");
                return;
            }

            using (new GUILayout.VerticalScope())
            {
                EditorGUI.BeginChangeCheck();
                currentGradient.Size = EditorGUILayout.Vector2IntField("Size", currentGradient.Size);
                if (EditorGUI.EndChangeCheck())
                {
                    SetupPreviewTexture();
                    GeneratePreview();
                }

                EditorGUILayout.Space();

                float height      = position.size.y * 0.4f;
                float aspect      = (float)currentGradient.Size.x / (float)currentGradient.Size.y;
                float width       = height * aspect;
                Rect  previewRect = GUILayoutUtility.GetRect(width - 32, height);
                EditorGUI.DrawTextureTransparent(previewRect, previewTexture, ScaleMode.StretchToFill);

                Rect    sliderRect = GUILayoutUtility.GetRect(width, 32);
                Vector2 nodeSize   = Vector2.one * 32;

                bool nodeActionUsed = false;
                for (int i = currentGradient.Nodes.Count - 1; i >= 0; i--)
                {
                    var     node     = currentGradient.Nodes[i];
                    float   xpos     = node.Percent * sliderRect.width;
                    Vector2 pos      = new Vector2(xpos - 16, sliderRect.y);
                    Rect    nodeRect = new Rect(pos, nodeSize);

                    if (selectedNode == i)
                    {
                        var selectedRect = new Rect(nodeRect);
                        selectedRect.width  *= 0.5f;
                        selectedRect.x      += 8;
                        selectedRect.height *= 1.5f;
                        EditorGUI.DrawRect(selectedRect, Color.yellow);
                    }
                    EditorGUI.DrawRect(nodeRect, node.Color);

                    if (nodeRect.Contains(Event.current.mousePosition) && !nodeActionUsed)
                    {
                        if (Event.current.type == EventType.MouseDown)
                        {
                            if (Event.current.button == 0)
                            {
                                selectedNode = i;
                                draggingNode = i;
                                Repaint();
                            }
                            else if (Event.current.button == 1)
                            {
                                selectedNode = -1;
                                currentGradient.Nodes.RemoveAt(i);
                                currentGradient.Nodes = currentGradient.Nodes.OrderBy(e => e.Percent).ToList();
                                GeneratePreview();
                                Repaint();
                            }
                            nodeActionUsed = true;
                        }
                    }

                    if (Event.current.type == EventType.MouseDrag && draggingNode == i)
                    {
                        nodeActionUsed = true;

                        float mouseX = Event.current.mousePosition.x;
                        mouseX -= sliderRect.position.x;
                        float percent = Mathf.Clamp01(mouseX / sliderRect.width);

                        node.Percent             = percent;
                        currentGradient.Nodes[i] = node;

                        int nodeID = node.ID;
                        currentGradient.Nodes = currentGradient.Nodes.OrderBy(e => e.Percent).ToList();
                        selectedNode          = currentGradient.Nodes.FindIndex(e => e.ID == nodeID);
                        draggingNode          = currentGradient.Nodes.FindIndex(e => e.ID == nodeID);
                        GeneratePreview();
                        Repaint();
                    }
                }

                if (Event.current.type == EventType.MouseUp)
                {
                    draggingNode = -1;
                }

                if (!nodeActionUsed && sliderRect.Contains(Event.current.mousePosition) && Event.current.button == 0 && Event.current.type == EventType.MouseDown)
                {
                    float mouseX = Event.current.mousePosition.x;
                    mouseX -= sliderRect.position.x;
                    float percent = Mathf.Clamp01(mouseX / sliderRect.width);

                    currentGradient.AddNode(Color.white, percent);
                    currentGradient.Nodes = currentGradient.Nodes.OrderBy(e => e.Percent).ToList();
                    GeneratePreview();
                    Repaint();
                }

                EditorGUILayout.Space(25f);
                if (selectedNode != -1 && selectedNode < currentGradient.Nodes.Count && !nodeActionUsed)
                {
                    var currentNode = currentGradient.Nodes[selectedNode];
                    EditorGUI.BeginChangeCheck();
                    using (new GUILayout.HorizontalScope())
                    {
                        currentNode.Color   = EditorGUILayout.ColorField(currentNode.Color);
                        currentNode.Percent = EditorGUILayout.Slider(currentNode.Percent, 0, 1);
                    }
                    if (EditorGUI.EndChangeCheck())
                    {
                        currentGradient.Nodes[selectedNode] = currentNode;
                        currentGradient.Nodes = currentGradient.Nodes.OrderBy(e => e.Percent).ToList();
                        GeneratePreview();
                    }
                }
            }
        }