public bool OnGUIExportValid(ref Texture2D _targetTexture, Action DisplayNotify)
            {
                EditorGUI.LabelField(HorizontalScope.NextRect(0, 60), "Texture:");
                EditorGUI.BeginChangeCheck();
                m_ModifyTexture = (Texture2D)EditorGUI.ObjectField(HorizontalScope.NextRect(5, 65), m_ModifyTexture, typeof(Texture2D), false);

                if (m_ModifyTexture == null || !m_ModifyTexture.isReadable)
                {
                    HorizontalScope.NextLine(2, 20);
                    EditorGUI.LabelField(HorizontalScope.NextRect(0, 240), "Select Readable Texture To Begin", UEGUIStyle_Window.m_ErrorLabel);
                    return(false);
                }
                if (EditorGUI.EndChangeCheck())
                {
                    _targetTexture = new Texture2D(m_ModifyTexture.width, m_ModifyTexture.height, TextureFormat.RGBA32, true);
                    ResetModifyTexture(_targetTexture);
                    DisplayNotify();
                }

                HorizontalScope.NextLine(2, 20);
                EditorGUI.LabelField(HorizontalScope.NextRect(5, 60), "Modify:", UEGUIStyle_Window.m_TitleLabel);
                m_ChannelModify = (enum_ColorVisualize)EditorGUI.EnumPopup(HorizontalScope.NextRect(5, 120), m_ChannelModify);

                if (m_ChannelModify != enum_ColorVisualize.None)
                {
                    HorizontalScope.NextLine(2, 20);
                    if (GUI.Button(HorizontalScope.NextRect(10, 60), "Reverse"))
                    {
                        DoColorModify(_targetTexture, m_ChannelModify, value => 1 - value);
                        DisplayNotify();
                    }
                    if (GUI.Button(HorizontalScope.NextRect(10, 60), "Fill"))
                    {
                        DoColorModify(_targetTexture, m_ChannelModify, value => 1);
                        DisplayNotify();
                    }
                    if (GUI.Button(HorizontalScope.NextRect(10, 60), "Clear"))
                    {
                        DoColorModify(_targetTexture, m_ChannelModify, value => 0);
                        DisplayNotify();
                    }
                }

                if (GUI.Button(HorizontalScope.NextRect(5, 80), "Reset"))
                {
                    ResetModifyTexture(_targetTexture);
                    DisplayNotify();
                }
                return(true);
            }
예제 #2
0
        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
        {
            float width          = position.size.x;
            float propertyHeight = EditorGUI.GetPropertyHeight(property);

            HorizontalScope.Begin(position.x, position.y, propertyHeight);
            EditorGUI.PropertyField(HorizontalScope.NextRect(0f, width), property, new GUIContent(m_Name, m_ToolTip), true);
            if (!property.isExpanded)
            {
                return;
            }
            HorizontalScope.NextLine(2f, 18f);
            HorizontalScope.NextRect(0f, width * 5f / 6f);
            if (GUI.Button(HorizontalScope.NextRect(0f, width / 6f), "Edit"))
            {
                GUITransformHandles.Begin(m_PositionProperty, m_DirecitonProperty);
            }
        }
        private void OnGUI()
        {
            HorizontalScope.Begin(5, 5, 18);
            EditorGUI.LabelField(HorizontalScope.NextRect(0, 80), "Editor Mode:", UEGUIStyle_Window.m_TitleLabel);
            m_EditorMode = (enum_TextureEditorMode)EditorGUI.EnumPopup(HorizontalScope.NextRect(5, 100), m_EditorMode);

            HorizontalScope.NextLine(2, 20);
            var textureEditor = m_Editors[m_EditorMode];

            if (!textureEditor.OnGUIExportValid(ref m_TargetTexture, UpdateTexture))
            {
                return;
            }

            EditorGUI.BeginChangeCheck();
            HorizontalScope.NextLine(2, 18);
            EditorGUI.LabelField(HorizontalScope.NextRect(0, 60), "Display:", UEGUIStyle_Window.m_TitleLabel);
            HorizontalScope.NextLine(2, 18);
            EditorGUI.LabelField(HorizontalScope.NextRect(0, 60), "Visualize:");
            m_ColorVisualize = (enum_ColorVisualize)EditorGUI.EnumPopup(HorizontalScope.NextRect(5, 40), m_ColorVisualize);

            if (EditorGUI.EndChangeCheck())
            {
                UpdateDisplayTexture();
            }

            HorizontalScope.NextLine(2, 256);
            Rect textureRect = HorizontalScope.NextRect(0, 256);

            GUI.DrawTexture(textureRect, EditorGUIUtility.whiteTexture);
            GUI.DrawTexture(textureRect.Collapse(Vector2.one * 10f), m_DisplayTexture);
            HorizontalScope.NextLine(2, 20);

            HorizontalScope.NextLine(2, 18);
            EditorGUI.LabelField(HorizontalScope.NextRect(5, 50), "Export:", UEGUIStyle_Window.m_TitleLabel);
            m_TextureExportType = (enum_TextureExportType)EditorGUI.EnumPopup(HorizontalScope.NextRect(0, 50), m_TextureExportType);
            if (GUI.Button(HorizontalScope.NextRect(20, 80), "Export"))
            {
                ExportTexture(m_TargetTexture, m_TargetTexture.name, m_TextureExportType);
            }
        }
        private void OnGUI()
        {
            EditorGUI.BeginChangeCheck();
            HorizontalScope.Begin(5, 5, 20);
            EditorGUI.LabelField(HorizontalScope.NextRect(0, 60), "Type:", UEGUIStyle_Window.m_TitleLabel);
            m_NoiseType = (enum_NoiseType)EditorGUI.EnumPopup(HorizontalScope.NextRect(5, 120), m_NoiseType);

            bool noiseSampleSupported = NoiseSampleSupported(m_NoiseType);

            if (noiseSampleSupported)
            {
                HorizontalScope.NextLine(2, 20);
                EditorGUI.LabelField(HorizontalScope.NextRect(0, 60), "Sample:", UEGUIStyle_Window.m_TitleLabel);
                m_NoiseSample = (enum_NoiseSample)EditorGUI.EnumPopup(HorizontalScope.NextRect(5, 120), m_NoiseSample);
            }
            HorizontalScope.NextLine(2, 20);
            EditorGUI.LabelField(HorizontalScope.NextRect(0, 60), "Filter:", UEGUIStyle_Window.m_TitleLabel);
            m_FilterMode = (FilterMode)EditorGUI.EnumPopup(HorizontalScope.NextRect(5, 120), m_FilterMode);
            HorizontalScope.NextLine(2, 20);
            EditorGUI.LabelField(HorizontalScope.NextRect(0, 60), "Size:", UEGUIStyle_Window.m_TitleLabel);
            m_SizePower = EditorGUI.IntSlider(HorizontalScope.NextRect(5, 120), m_SizePower, 3, 10);
            int size = Mathf.RoundToInt(Mathf.Pow(2, m_SizePower));

            EditorGUI.LabelField(HorizontalScope.NextRect(5, 40), size.ToString());
            HorizontalScope.NextLine(2, 20);
            EditorGUI.LabelField(HorizontalScope.NextRect(0, 60), "Scale:", UEGUIStyle_Window.m_TitleLabel);
            m_Scale = EditorGUI.Slider(HorizontalScope.NextRect(5, 120), m_Scale, 1f, 30f);

            HorizontalScope.NextLine(2, 20);
            EditorGUI.LabelField(HorizontalScope.NextRect(0, 60), "Octave:", UEGUIStyle_Window.m_TitleLabel);
            m_Octave = EditorGUI.Toggle(HorizontalScope.NextRect(5, 20), m_Octave);
            if (m_Octave)
            {
                HorizontalScope.NextLine(2, 20);
                EditorGUI.LabelField(HorizontalScope.NextRect(0, 60), "Count:", UEGUIStyle_Window.m_TitleLabel);
                m_OctaveCount = EditorGUI.IntSlider(HorizontalScope.NextRect(5, 120), m_OctaveCount, 2, 7);
                HorizontalScope.NextLine(2, 20);
            }

            if (!m_Texture || EditorGUI.EndChangeCheck())
            {
                float   sizeF  = size;
                Color[] colors = new Color[size * size];
                for (int i = 0; i < size; i++)
                {
                    for (int j = 0; j < size; j++)
                    {
                        float noiseX = j / sizeF;
                        float noiseY = i / sizeF;
                        float noise  = m_Octave ? GetNoiseOctave(noiseX, noiseY, m_Scale, m_NoiseType, m_OctaveCount) : GetNoise(noiseX, noiseY, m_Scale, m_NoiseType);
                        if (noiseSampleSupported)
                        {
                            switch (m_NoiseSample)
                            {
                            case enum_NoiseSample.Absolute: noise = Mathf.Abs(noise); break;

                            case enum_NoiseSample._01: noise = noise / 2f + .5f; break;
                            }
                        }
                        colors[i * size + j] = new Color(noise, noise, noise, 1);
                    }
                }
                m_Texture = new Texture2D(size, size, TextureFormat.ARGB32, true)
                {
                    filterMode = m_FilterMode
                };
                m_Texture.SetPixels(colors);
                m_Texture.Apply();
                Undo.RecordObject(this, "Noise Generator Change");
            }
            HorizontalScope.NextLine(2, 256);
            Rect textureRect = HorizontalScope.NextRect(0, 256);

            GUI.DrawTexture(textureRect, EditorGUIUtility.whiteTexture);
            GUI.DrawTexture(textureRect.Collapse(Vector2.one * 10f), m_Texture);
            HorizontalScope.NextLine(2, 20);
            if (GUI.Button(HorizontalScope.NextRect(0, 80), "Export"))
            {
                if (UEAsset.SaveFilePath(out string filePath, "png", "CustomNoise_" + m_NoiseType.ToString()))
                {
                    UEAsset.CreateOrReplaceFile(filePath, m_Texture.EncodeToPNG());
                }
            }
        }
            public bool OnGUIExportValid(ref Texture2D _targetTexture, Action DisplayNotify)
            {
                EditorGUI.BeginChangeCheck();
                EditorGUI.LabelField(HorizontalScope.NextRect(0, 20), "R:");
                m_R = (Texture2D)EditorGUI.ObjectField(HorizontalScope.NextRect(5, 65), m_R, typeof(Texture2D), false);
                if (!ValidTexture(m_R))
                {
                    m_RDefault = EditorGUI.Slider(HorizontalScope.NextRect(5, 150), m_RDefault, 0f, 1f);
                }
                HorizontalScope.NextLine(2, 20);
                EditorGUI.LabelField(HorizontalScope.NextRect(0, 20), "G:");
                m_G = (Texture2D)EditorGUI.ObjectField(HorizontalScope.NextRect(5, 65), m_G, typeof(Texture2D), false);
                if (!ValidTexture(m_G))
                {
                    m_GDefault = EditorGUI.Slider(HorizontalScope.NextRect(5, 150), m_GDefault, 0f, 1f);
                }
                HorizontalScope.NextLine(2, 20);
                EditorGUI.LabelField(HorizontalScope.NextRect(0, 20), "B:");
                m_B = (Texture2D)EditorGUI.ObjectField(HorizontalScope.NextRect(5, 65), m_B, typeof(Texture2D), false);
                if (!ValidTexture(m_B))
                {
                    m_BDefault = EditorGUI.Slider(HorizontalScope.NextRect(5, 150), m_BDefault, 0f, 1f);
                }
                HorizontalScope.NextLine(2, 20);
                EditorGUI.LabelField(HorizontalScope.NextRect(0, 20), "A:");
                m_A = (Texture2D)EditorGUI.ObjectField(HorizontalScope.NextRect(5, 65), m_A, typeof(Texture2D), false);
                if (!ValidTexture(m_A))
                {
                    m_ADefault = EditorGUI.Slider(HorizontalScope.NextRect(5, 150), m_ADefault, 0f, 1f);
                }

                bool validTextures = ValidCheck(out int maxWidth, out int maxHeight, out bool rValid, out bool gValid, out bool bValid, out bool aValid);

                if (!validTextures)
                {
                    return(false);
                }

                if (EditorGUI.EndChangeCheck())
                {
                    Color[] rPixels = rValid ? m_R.GetPixels() : null;
                    Color[] gPixels = gValid ? m_G.GetPixels() : null;
                    Color[] bPixels = bValid ? m_B.GetPixels() : null;
                    Color[] aPixels = aValid ? m_A.GetPixels() : null;

                    Color[] mix = new Color[maxWidth * maxHeight];
                    for (int i = 0; i < maxWidth * maxHeight; i++)
                    {
                        mix[i] = new Color(
                            rValid ? rPixels[i].r : m_RDefault,
                            gValid ? gPixels[i].r : m_GDefault,
                            bValid ? bPixels[i].r : m_BDefault,
                            aValid ? aPixels[i].r : m_ADefault);
                    }

                    _targetTexture = new Texture2D(maxWidth, maxHeight, TextureFormat.RGBA32, true);
                    _targetTexture.SetPixels(mix);
                    _targetTexture.Apply();
                    DisplayNotify();
                }
                return(true);
            }