ApplyWireMaterial() static private method

static private ApplyWireMaterial ( ) : void
return void
        public override void OnPreviewGUI(Rect r, GUIStyle background)
        {
            if (Event.current.type == EventType.Repaint)
            {
                background.Draw(r, false, false, false, false);
            }
            Texture       texture       = this.target as Texture;
            RenderTexture renderTexture = texture as RenderTexture;

            if (renderTexture != null)
            {
                if (!SystemInfo.SupportsRenderTextureFormat(renderTexture.format))
                {
                    return;
                }
                renderTexture.Create();
            }
            if (this.IsCubemap())
            {
                this.m_CubemapPreview.OnPreviewGUI(texture, r, background);
                return;
            }
            int   num  = Mathf.Max(texture.width, 1);
            int   num2 = Mathf.Max(texture.height, 1);
            float mipLevelForRendering = this.GetMipLevelForRendering();
            float num3 = Mathf.Min(Mathf.Min(r.width / (float)num, r.height / (float)num2), 1f);
            Rect  rect = new Rect(r.x, r.y, (float)num * num3, (float)num2 * num3);

            PreviewGUI.BeginScrollView(r, this.m_Pos, rect, "PreHorizontalScrollbar", "PreHorizontalScrollbarThumb");
            float mipMapBias = texture.mipMapBias;

            TextureUtil.SetMipMapBiasNoDirty(texture, mipLevelForRendering - this.Log2((float)num / rect.width));
            FilterMode filterMode = texture.filterMode;

            TextureUtil.SetFilterModeNoDirty(texture, FilterMode.Point);
            if (this.m_ShowAlpha)
            {
                EditorGUI.DrawTextureAlpha(rect, texture);
            }
            else
            {
                Texture2D texture2D = texture as Texture2D;
                if (texture2D != null && texture2D.alphaIsTransparency)
                {
                    EditorGUI.DrawTextureTransparent(rect, texture);
                }
                else
                {
                    EditorGUI.DrawPreviewTexture(rect, texture);
                }
            }
            if (rect.width > 32f && rect.height > 32f)
            {
                string           assetPath       = AssetDatabase.GetAssetPath(texture);
                TextureImporter  textureImporter = AssetImporter.GetAtPath(assetPath) as TextureImporter;
                SpriteMetaData[] array           = (!(textureImporter != null)) ? null : textureImporter.spritesheet;
                if (array != null && textureImporter.spriteImportMode == SpriteImportMode.Multiple)
                {
                    Rect rect2 = default(Rect);
                    Rect rect3 = default(Rect);
                    GUI.CalculateScaledTextureRects(rect, ScaleMode.StretchToFill, (float)texture.width / (float)texture.height, ref rect2, ref rect3);
                    int width  = texture.width;
                    int height = texture.height;
                    textureImporter.GetWidthAndHeight(ref width, ref height);
                    float num4 = (float)texture.width / (float)width;
                    HandleUtility.ApplyWireMaterial();
                    GL.PushMatrix();
                    GL.MultMatrix(Handles.matrix);
                    GL.Begin(1);
                    GL.Color(new Color(1f, 1f, 1f, 0.5f));
                    SpriteMetaData[] array2 = array;
                    for (int i = 0; i < array2.Length; i++)
                    {
                        SpriteMetaData spriteMetaData = array2[i];
                        Rect           rect4          = spriteMetaData.rect;
                        this.DrawRect(new Rect
                        {
                            xMin = rect2.xMin + rect2.width * (rect4.xMin / (float)texture.width * num4),
                            xMax = rect2.xMin + rect2.width * (rect4.xMax / (float)texture.width * num4),
                            yMin = rect2.yMin + rect2.height * (1f - rect4.yMin / (float)texture.height * num4),
                            yMax = rect2.yMin + rect2.height * (1f - rect4.yMax / (float)texture.height * num4)
                        });
                    }
                    GL.End();
                    GL.PopMatrix();
                }
            }
            TextureUtil.SetMipMapBiasNoDirty(texture, mipMapBias);
            TextureUtil.SetFilterModeNoDirty(texture, filterMode);
            this.m_Pos = PreviewGUI.EndScrollView();
            if (mipLevelForRendering != 0f)
            {
                EditorGUI.DropShadowLabel(new Rect(r.x, r.y, r.width, 20f), "Mip " + mipLevelForRendering);
            }
        }
        public override void OnPreviewGUI(Rect r, GUIStyle background)
        {
            if (Event.current.type == EventType.Repaint)
            {
                background.Draw(r, false, false, false, false);
            }

            // show texture
            Texture t = target as Texture;

            if (t == null) // texture might be gone by now, in case this code is used for floating texture preview
            {
                return;
            }

            // Render target must be created before we can display it (case 491797)
            RenderTexture rt = t as RenderTexture;

            if (rt != null)
            {
                if (!SystemInfo.IsFormatSupported(rt.graphicsFormat, FormatUsage.Render))
                {
                    return; // can't do this RT format
                }
                rt.Create();
            }

            if (IsCubemap())
            {
                m_CubemapPreview.OnPreviewGUI(t, r, background);
                return;
            }

            // target can report zero sizes in some cases just after a parameter change;
            // guard against that.
            int texWidth  = Mathf.Max(t.width, 1);
            int texHeight = Mathf.Max(t.height, 1);

            float mipLevel   = GetMipLevelForRendering();
            float zoomLevel  = Mathf.Min(Mathf.Min(r.width / texWidth, r.height / texHeight), 1);
            Rect  wantedRect = new Rect(r.x, r.y, texWidth * zoomLevel, texHeight * zoomLevel);

            PreviewGUI.BeginScrollView(r, m_Pos, wantedRect, "PreHorizontalScrollbar", "PreHorizontalScrollbarThumb");
            FilterMode oldFilter = t.filterMode;

            TextureUtil.SetFilterModeNoDirty(t, FilterMode.Point);
            Texture2D      t2d            = t as Texture2D;
            ColorWriteMask colorWriteMask = ColorWriteMask.All;

            switch (m_PreviewMode)
            {
            case PreviewMode.R:
                colorWriteMask = ColorWriteMask.Red | ColorWriteMask.Alpha;
                break;

            case PreviewMode.G:
                colorWriteMask = ColorWriteMask.Green | ColorWriteMask.Alpha;
                break;

            case PreviewMode.B:
                colorWriteMask = ColorWriteMask.Blue | ColorWriteMask.Alpha;
                break;
            }

            if (m_PreviewMode == PreviewMode.A)
            {
                EditorGUI.DrawTextureAlpha(wantedRect, t, ScaleMode.StretchToFill, 0, mipLevel);
            }
            else
            {
                if (t2d != null && t2d.alphaIsTransparency)
                {
                    EditorGUI.DrawTextureTransparent(wantedRect, t, ScaleMode.StretchToFill, 0, mipLevel, colorWriteMask, GetExposureValueForTexture(t));
                }
                else
                {
                    EditorGUI.DrawPreviewTexture(wantedRect, t, null, ScaleMode.StretchToFill, 0, mipLevel, colorWriteMask, GetExposureValueForTexture(t));
                }
            }

            // TODO: Less hacky way to prevent sprite rects to not appear in smaller previews like icons.
            if ((wantedRect.width > 32 && wantedRect.height > 32) && Event.current.type == EventType.Repaint)
            {
                string           path            = AssetDatabase.GetAssetPath(t);
                TextureImporter  textureImporter = AssetImporter.GetAtPath(path) as TextureImporter;
                SpriteMetaData[] spritesheet     = textureImporter != null ? textureImporter.spritesheet : null;

                if (spritesheet != null && textureImporter.spriteImportMode == SpriteImportMode.Multiple)
                {
                    Rect screenRect = new Rect();
                    Rect sourceRect = new Rect();
                    GUI.CalculateScaledTextureRects(wantedRect, ScaleMode.StretchToFill, (float)t.width / (float)t.height, ref screenRect, ref sourceRect);

                    int origWidth  = t.width;
                    int origHeight = t.height;
                    textureImporter.GetWidthAndHeight(ref origWidth, ref origHeight);
                    float definitionScale = (float)t.width / (float)origWidth;

                    HandleUtility.ApplyWireMaterial();
                    GL.PushMatrix();
                    GL.MultMatrix(Handles.matrix);
                    GL.Begin(GL.LINES);
                    GL.Color(new Color(1f, 1f, 1f, 0.5f));
                    foreach (SpriteMetaData sprite in spritesheet)
                    {
                        Rect spriteRect       = sprite.rect;
                        Rect spriteScreenRect = new Rect();
                        spriteScreenRect.xMin = screenRect.xMin + screenRect.width * (spriteRect.xMin / t.width * definitionScale);
                        spriteScreenRect.xMax = screenRect.xMin + screenRect.width * (spriteRect.xMax / t.width * definitionScale);
                        spriteScreenRect.yMin = screenRect.yMin + screenRect.height * (1f - spriteRect.yMin / t.height * definitionScale);
                        spriteScreenRect.yMax = screenRect.yMin + screenRect.height * (1f - spriteRect.yMax / t.height * definitionScale);
                        DrawRect(spriteScreenRect);
                    }
                    GL.End();
                    GL.PopMatrix();
                }
            }

            TextureUtil.SetFilterModeNoDirty(t, oldFilter);

            m_Pos = PreviewGUI.EndScrollView();
            if (mipLevel != 0)
            {
                EditorGUI.DropShadowLabel(new Rect(r.x, r.y, r.width, 20), "Mip " + mipLevel);
            }
        }
        static bool CurveDisplay(IAudioEffectPlugin plugin, Rect r0, ref float threshold, ref float ratio, ref float makeupGain, ref float attackTime, ref float releaseTime, ref float knee, float sidechainLevel, float outputLevel, float blend)
        {
            Event evt       = Event.current;
            int   controlID = GUIUtility.GetControlID(FocusType.Passive);

            Rect r = AudioCurveRendering.BeginCurveFrame(r0);

            const float thresholdActiveWidth = 10f;
            float       vuWidth = 10f;

            float minThreshold, maxThreshold, defThreshold; plugin.GetFloatParameterInfo(kThresholdName, out minThreshold, out maxThreshold, out defThreshold);
            float minRatio, maxRatio, defRatio; plugin.GetFloatParameterInfo(kRatioName, out minRatio, out maxRatio, out defRatio);
            float minMakeupGain, maxMakeupGain, defMakeupGain; plugin.GetFloatParameterInfo(kMakeupGainName, out minMakeupGain, out maxMakeupGain, out defMakeupGain);
            float minKnee, maxKnee, defKnee; plugin.GetFloatParameterInfo(kKneeName, out minKnee, out maxKnee, out defKnee);

            float dbRange = 100.0f, dbMin = -80.0f;
            float thresholdPosX = r.width * (threshold - dbMin) / dbRange;

            bool modifiedValue = false;

            switch (evt.GetTypeForControl(controlID))
            {
            case EventType.MouseDown:
                if (r.Contains(Event.current.mousePosition) && evt.button == 0)
                {
                    dragtype = DragType.None;
                    GUIUtility.hotControl = controlID;
                    EditorGUIUtility.SetWantsMouseJumping(1);
                    evt.Use();

                    // Ensure visible state change on mousedown to make it clear that interaction is possible
                    if ((Mathf.Abs(r.x + thresholdPosX - evt.mousePosition.x) >= thresholdActiveWidth))
                    {
                        dragtype = (evt.mousePosition.x < r.x + thresholdPosX) ? DragType.MakeupGain : DragType.Ratio;
                    }
                    else
                    {
                        dragtype = DragType.ThresholdAndKnee;
                    }
                }
                break;

            case EventType.MouseUp:
                if (GUIUtility.hotControl == controlID && evt.button == 0)
                {
                    dragtype = DragType.None;
                    GUIUtility.hotControl = 0;
                    EditorGUIUtility.SetWantsMouseJumping(0);
                    evt.Use();
                }
                break;

            case EventType.MouseDrag:
                if (GUIUtility.hotControl == controlID)
                {
                    float dragAcceleration = evt.alt ? .25f : 1f;
                    if (dragtype == DragType.ThresholdAndKnee)
                    {
                        bool dragKnee = Mathf.Abs(evt.delta.x) < Mathf.Abs(evt.delta.y);
                        if (dragKnee)
                        {
                            knee = Mathf.Clamp(knee + evt.delta.y * 0.5f * dragAcceleration, minKnee, maxKnee);
                        }
                        else
                        {
                            threshold = Mathf.Clamp(threshold + evt.delta.x * 0.1f * dragAcceleration, minThreshold, maxThreshold);
                        }
                    }
                    else if (dragtype == DragType.Ratio)
                    {
                        ratio = Mathf.Clamp(ratio + evt.delta.y * (ratio > 1.0f ? 0.05f : 0.003f) * dragAcceleration, minRatio, maxRatio);
                    }
                    else if (dragtype == DragType.MakeupGain)
                    {
                        makeupGain = Mathf.Clamp(makeupGain - evt.delta.y * 0.5f * dragAcceleration, minMakeupGain, maxMakeupGain);
                    }
                    else
                    {
                        Debug.LogError("Drag: Unhandled enum");
                    }

                    modifiedValue = true;
                    evt.Use();
                }
                break;
            }

            if (evt.type == EventType.Repaint)
            {
                // Curve
                HandleUtility.ApplyWireMaterial();

                //float sidechainPosX = r.width * (sidechainLevel - dbMin) / dbRange;
                float thresholdPosY  = r.height * (1.0f - ((threshold - dbMin + makeupGain) / dbRange));
                Color thresholdColor = new Color(0.7f, 0.7f, 0.7f);
                Color sidechainColor = Color.black;


                float duckGradient       = 1.0f / ratio;
                float duckThreshold      = threshold;
                float duckSidechainLevel = sidechainLevel;
                float duckMakeupGain     = makeupGain;
                float duckKnee           = knee;
                float duckKneeC1         = (knee > 0.0f) ? ((duckGradient - 1.0f) / (4.0f * knee)) : 0.0f;
                float duckKneeC2         = duckThreshold - knee;

                // Main filled curve
                AudioCurveRendering.DrawFilledCurve(
                    r,
                    delegate(float x, out Color col)
                {
                    float level = x * dbRange + dbMin;
                    float gain  = level;
                    float t     = level - duckThreshold;
                    col         = ScaleAlpha(duckSidechainLevel > level ? AudioCurveRendering.kAudioOrange : Color.grey, blend);
                    if (t > -duckKnee && t < duckKnee)
                    {
                        t   += duckKnee;
                        gain = t * (duckKneeC1 * t + 1.0f) + duckKneeC2;

                        if (dragtype == DragType.ThresholdAndKnee)
                        {
                            const float mult = 1.2f;
                            col = new Color(col.r * mult, col.g * mult, col.b * mult);
                        }
                    }
                    else if (t > 0.0f)
                    {
                        gain = duckThreshold + duckGradient * t;
                    }
                    return((2.0f * (gain + duckMakeupGain - dbMin) / dbRange) - 1.0f);
                }
                    );

                // Curve shown when modifying MakeupGain
                if (dragtype == DragType.MakeupGain)
                {
                    AudioCurveRendering.DrawCurve(
                        r,
                        delegate(float x)
                    {
                        float level = x * dbRange + dbMin;
                        float gain  = level;
                        float t     = level - duckThreshold;
                        if (t > -duckKnee && t < duckKnee)
                        {
                            t   += duckKnee;
                            gain = t * (duckKneeC1 * t + 1.0f) + duckKneeC2;
                        }
                        else if (t > 0.0f)
                        {
                            gain = duckThreshold + duckGradient * t;
                        }
                        return((2.0f * (gain + duckMakeupGain - dbMin) / dbRange) - 1.0f);
                    },
                        Color.white
                        );
                }


                // Threshold text and line
                textStyle10.normal.textColor = ScaleAlpha(thresholdColor, blend);
                EditorGUI.DrawRect(new Rect(r.x + thresholdPosX, r.y, 1, r.height), textStyle10.normal.textColor);
                DrawText(r.x + thresholdPosX + 4, r.y + 6, string.Format(CultureInfo.InvariantCulture.NumberFormat, "Threshold: {0:F1} dB", threshold));

                // Sidechain text and line
                textStyle10.normal.textColor = ScaleAlpha(sidechainColor, blend);
                DrawText(r.x + 4, r.y + r.height - 10, sidechainLevel < -80 ? "Input: None" : string.Format(CultureInfo.InvariantCulture.NumberFormat, "Input: {0:F1} dB", sidechainLevel));

                if (dragtype == DragType.Ratio)
                {
                    float aspect = (float)r.height / (float)r.width;
                    Handles.DrawAAPolyLine(2.0f,
                                           new Color[] { Color.black, Color.black },
                                           new Vector3[]
                    {
                        new Vector3(r.x + thresholdPosX + r.width, r.y + thresholdPosY - aspect * r.width, 0.0f),
                        new Vector3(r.x + thresholdPosX - r.width, r.y + thresholdPosY + aspect * r.width, 0.0f)
                    });
                    Handles.DrawAAPolyLine(3.0f,
                                           new Color[] { Color.white, Color.white },
                                           new Vector3[]
                    {
                        new Vector3(r.x + thresholdPosX + r.width, r.y + thresholdPosY - aspect * duckGradient * r.width, 0.0f),
                        new Vector3(r.x + thresholdPosX - r.width, r.y + thresholdPosY + aspect * duckGradient * r.width, 0.0f)
                    });
                }
                else if (dragtype == DragType.ThresholdAndKnee)
                {
                    // Knee min and max lines
                    float normalizedKnee1 = (threshold - knee - dbMin) / dbRange;
                    float normalizedKnee2 = (threshold + knee - dbMin) / dbRange;
                    float y1        = EvaluateDuckingVolume(normalizedKnee1, ratio, threshold, makeupGain, knee, dbRange, dbMin);
                    float y2        = EvaluateDuckingVolume(normalizedKnee2, ratio, threshold, makeupGain, knee, dbRange, dbMin);
                    float knee1PosY = r.yMax - (y1 + 1f) * 0.5f * r.height;
                    float knee2PosY = r.yMax - (y2 + 1f) * 0.5f * r.height;
                    EditorGUI.DrawRect(new Rect(r.x + normalizedKnee1 * r.width, knee1PosY, 1, r.height - knee1PosY), new Color(0, 0, 0, 0.5f));
                    EditorGUI.DrawRect(new Rect(r.x + normalizedKnee2 * r.width - 1, knee2PosY, 1, r.height - knee2PosY), new Color(0, 0, 0, 0.5f));

                    // Enhanced threshold
                    EditorGUI.DrawRect(new Rect(r.x + thresholdPosX - 1, r.y, 3, r.height), Color.white);
                }

                outputLevel = (Mathf.Clamp(outputLevel - makeupGain, dbMin, dbMin + dbRange) - dbMin) / dbRange;
                if (EditorApplication.isPlaying)
                {
                    const int margin = 2;
                    Rect      vuRect = new Rect(r.x + r.width - vuWidth + margin, r.y + margin, vuWidth - 2 * margin, r.height - 2 * margin);
                    DrawVU(vuRect, outputLevel, blend, true);
                }
            }

            AudioCurveRendering.EndCurveFrame();

            return(modifiedValue);
        }
Beispiel #4
0
        public void TimeRuler(Rect position, float frameRate, bool labels, bool useEntireHeight, float alpha,
                              TimeFormat timeFormat)
        {
            Color backupCol = GUI.color;

            GUI.BeginGroup(position);
            InitStyles();

            HandleUtility.ApplyWireMaterial();

            Color tempBackgroundColor = GUI.backgroundColor;

            SetTickMarkerRanges();
            hTicks.SetTickStrengths(kTickRulerDistMin, kTickRulerDistFull, true);

            Color baseColor = timeAreaStyles.timelineTick.normal.textColor;

            baseColor.a = 0.75f * alpha;

            if (Event.current.type == EventType.Repaint)
            {
                if (Application.platform == RuntimePlatform.WindowsEditor)
                {
                    GL.Begin(GL.QUADS);
                }
                else
                {
                    GL.Begin(GL.LINES);
                }

                // Draw tick markers of various sizes

                Rect cachedShowArea = shownArea;
                for (int l = 0; l < hTicks.tickLevels; l++)
                {
                    float strength = hTicks.GetStrengthOfLevel(l) * .9f;
                    m_TickCache.Clear();
                    hTicks.GetTicksAtLevel(l, true, m_TickCache);
                    for (int i = 0; i < m_TickCache.Count; i++)
                    {
                        if (m_TickCache[i] < hRangeMin || m_TickCache[i] > hRangeMax)
                        {
                            continue;
                        }
                        int frame = Mathf.RoundToInt(m_TickCache[i] * frameRate);

                        float height = useEntireHeight
                            ? position.height
                            : position.height * Mathf.Min(1, strength) * kTickRulerHeightMax;
                        float x = FrameToPixel(frame, frameRate, position, cachedShowArea);

                        // Draw line
                        DrawVerticalLineFast(x, position.height - height + 0.5f, position.height - 0.5f,
                                             new Color(1, 1, 1, strength / kTickRulerFatThreshold) * baseColor);
                    }
                }

                GL.End();
            }

            if (labels)
            {
                // Draw tick labels
                int labelLevel = hTicks.GetLevelWithMinSeparation(kTickRulerDistLabel);
                m_TickCache.Clear();
                hTicks.GetTicksAtLevel(labelLevel, false, m_TickCache);
                for (int i = 0; i < m_TickCache.Count; i++)
                {
                    if (m_TickCache[i] < hRangeMin || m_TickCache[i] > hRangeMax)
                    {
                        continue;
                    }

                    int frame = Mathf.RoundToInt(m_TickCache[i] * frameRate);
                    // Important to take floor of positions of GUI stuff to get pixel correct alignment of
                    // stuff drawn with both GUI and Handles/GL. Otherwise things are off by one pixel half the time.

                    float  labelpos = Mathf.Floor(FrameToPixel(frame, frameRate, position));
                    string label    = FormatTickTime(m_TickCache[i], frameRate, timeFormat);
                    GUI.Label(new Rect(labelpos + 3, -1, 40, 20), label, timeAreaStyles.timelineTick);
                }
            }
            GUI.EndGroup();

            GUI.backgroundColor = tempBackgroundColor;
            GUI.color           = backupCol;
        }
        static bool ParamEqualizerCurveEditor(IAudioEffectPlugin plugin, Rect r, ref float centerFreq, ref float bandwidth, ref float gain, float blend)
        {
            Event evt       = Event.current;
            int   controlID = GUIUtility.GetControlID(FocusType.Passive);

            r = AudioCurveRendering.BeginCurveFrame(r);

            float minCenterFreq, maxCenterFreq, defCenterFreq; plugin.GetFloatParameterInfo(kCenterFreqName, out minCenterFreq, out maxCenterFreq, out defCenterFreq);
            float minOctaveRange, maxOctaveRange, defOctaveRange; plugin.GetFloatParameterInfo(kOctaveRangeName, out minOctaveRange, out maxOctaveRange, out defOctaveRange);
            float minGain, maxGain, defGain; plugin.GetFloatParameterInfo(kFrequencyGainName, out minGain, out maxGain, out defGain);

            bool modifiedValue = false;

            switch (evt.GetTypeForControl(controlID))
            {
            case EventType.MouseDown:
                if (r.Contains(Event.current.mousePosition) && evt.button == 0)
                {
                    GUIUtility.hotControl = controlID;
                    EditorGUIUtility.SetWantsMouseJumping(1);
                    evt.Use();
                }
                break;

            case EventType.MouseUp:
                if (GUIUtility.hotControl == controlID && evt.button == 0)
                {
                    GUIUtility.hotControl = 0;
                    EditorGUIUtility.SetWantsMouseJumping(0);
                    evt.Use();
                }
                break;

            case EventType.MouseDrag:
                if (GUIUtility.hotControl == controlID)
                {
                    float dragAcceleration = Event.current.alt ? .25f : 1f;
                    centerFreq = Mathf.Clamp((float)MapNormalizedFrequency(MapNormalizedFrequency(centerFreq, plugin.GetSampleRate(), useLogScale, false) + evt.delta.x / r.width, plugin.GetSampleRate(), useLogScale, true), minCenterFreq, maxCenterFreq);
                    if (Event.current.shift)
                    {
                        bandwidth = Mathf.Clamp(bandwidth - evt.delta.y * 0.02f * dragAcceleration, minOctaveRange, maxOctaveRange);
                    }
                    else
                    {
                        gain = Mathf.Clamp(gain - evt.delta.y * 0.01f * dragAcceleration, minGain, maxGain);
                    }
                    modifiedValue = true;
                    evt.Use();
                }
                break;
            }

            if (Event.current.type == EventType.Repaint)
            {
                // Mark CenterFreq with a vertical line
                float c = (float)MapNormalizedFrequency(centerFreq, plugin.GetSampleRate(), useLogScale, false);
                EditorGUI.DrawRect(new Rect(c * r.width + r.x, r.y, 1f, r.height), GUIUtility.hotControl == controlID ? new Color(0.6f, 0.6f, 0.6f) : new Color(0.4f, 0.4f, 0.4f));

                // Curve
                HandleUtility.ApplyWireMaterial();
                double kPI   = 3.1415926;
                double wm    = -2.0f * kPI / plugin.GetSampleRate();
                double w0    = 2.0 * kPI * centerFreq / plugin.GetSampleRate();
                double Q     = 1.0 / bandwidth;
                double A     = gain;
                double alpha = Math.Sin(w0) / (2.0 * Q);
                double b0    = 1.0 + alpha * A;
                double b1    = -2.0 * Math.Cos(w0);
                double b2    = 1.0 - alpha * A;
                double a0    = 1.0 + alpha / A;
                double a1    = -2.0 * Math.Cos(w0);
                double a2    = 1.0 - alpha / A;
                AudioCurveRendering.DrawCurve(
                    r,
                    delegate(float x)
                {
                    double f   = MapNormalizedFrequency((double)x, plugin.GetSampleRate(), useLogScale, true);
                    ComplexD w = ComplexD.Exp(wm * f);
                    ComplexD n = w * (w * b2 + b1) + b0;
                    ComplexD d = w * (w * a2 + a1) + a0;
                    ComplexD h = n / d;
                    double mag = Math.Log10(h.Mag2());
                    return((float)(0.5 * mag));    // 20 dB range
                },
                    ScaleAlpha(AudioCurveRendering.kAudioOrange, blend)
                    );
            }

            DrawFrequencyTickMarks(r, plugin.GetSampleRate(), useLogScale, new Color(1.0f, 1.0f, 1.0f, 0.3f * blend));

            AudioCurveRendering.EndCurveFrame();

            return(modifiedValue);
        }
Beispiel #6
0
        private static bool ParamEqualizerCurveEditor(IAudioEffectPlugin plugin, Rect r, ref float centerFreq, ref float bandwidth, ref float gain, float blend)
        {
            Event current   = Event.current;
            int   controlID = GUIUtility.GetControlID(FocusType.Passive);

            r = AudioCurveRendering.BeginCurveFrame(r);
            float min;
            float max;
            float num;

            plugin.GetFloatParameterInfo(ParamEqGUI.kCenterFreqName, out min, out max, out num);
            float min2;
            float max2;
            float num2;

            plugin.GetFloatParameterInfo(ParamEqGUI.kOctaveRangeName, out min2, out max2, out num2);
            float min3;
            float max3;
            float num3;

            plugin.GetFloatParameterInfo(ParamEqGUI.kFrequencyGainName, out min3, out max3, out num3);
            bool result = false;

            switch (current.GetTypeForControl(controlID))
            {
            case EventType.MouseDown:
                if (r.Contains(Event.current.mousePosition) && current.button == 0)
                {
                    GUIUtility.hotControl = controlID;
                    EditorGUIUtility.SetWantsMouseJumping(1);
                    current.Use();
                }
                break;

            case EventType.MouseUp:
                if (GUIUtility.hotControl == controlID && current.button == 0)
                {
                    GUIUtility.hotControl = 0;
                    EditorGUIUtility.SetWantsMouseJumping(0);
                    current.Use();
                }
                break;

            case EventType.MouseDrag:
                if (GUIUtility.hotControl == controlID)
                {
                    float num4 = (!Event.current.alt) ? 1f : 0.25f;
                    centerFreq = Mathf.Clamp((float)ParamEqGUI.MapNormalizedFrequency(ParamEqGUI.MapNormalizedFrequency((double)centerFreq, (double)plugin.GetSampleRate(), true, false) + (double)(current.delta.x / r.width), (double)plugin.GetSampleRate(), true, true), min, max);
                    if (Event.current.shift)
                    {
                        bandwidth = Mathf.Clamp(bandwidth - current.delta.y * 0.02f * num4, min2, max2);
                    }
                    else
                    {
                        gain = Mathf.Clamp(gain - current.delta.y * 0.01f * num4, min3, max3);
                    }
                    result = true;
                    current.Use();
                }
                break;
            }
            if (Event.current.type == EventType.Repaint)
            {
                float num5 = (float)ParamEqGUI.MapNormalizedFrequency((double)centerFreq, (double)plugin.GetSampleRate(), true, false);
                EditorGUI.DrawRect(new Rect(num5 * r.width + r.x, r.y, 1f, r.height), (GUIUtility.hotControl != controlID) ? new Color(0.4f, 0.4f, 0.4f) : new Color(0.6f, 0.6f, 0.6f));
                HandleUtility.ApplyWireMaterial();
                double num6  = 3.1415926;
                double wm    = -2.0 * num6 / (double)plugin.GetSampleRate();
                double num7  = 2.0 * num6 * (double)centerFreq / (double)plugin.GetSampleRate();
                double num8  = 1.0 / (double)bandwidth;
                double num9  = (double)gain;
                double num10 = Math.Sin(num7) / (2.0 * num8);
                double b0    = 1.0 + num10 * num9;
                double b1    = -2.0 * Math.Cos(num7);
                double b2    = 1.0 - num10 * num9;
                double a0    = 1.0 + num10 / num9;
                double a1    = -2.0 * Math.Cos(num7);
                double a2    = 1.0 - num10 / num9;
                AudioCurveRendering.DrawCurve(r, delegate(float x)
                {
                    double num11      = ParamEqGUI.MapNormalizedFrequency((double)x, (double)plugin.GetSampleRate(), true, true);
                    ComplexD a        = ComplexD.Exp(wm * num11);
                    ComplexD a2       = a * (a * b2 + b1) + b0;
                    ComplexD b        = a * (a * a2 + a1) + a0;
                    ComplexD complexD = a2 / b;
                    double num12      = Math.Log10(complexD.Mag2());
                    return((float)(0.5 * num12));
                }, ParamEqGUI.ScaleAlpha(AudioCurveRendering.kAudioOrange, blend));
            }
            ParamEqGUI.DrawFrequencyTickMarks(r, (float)plugin.GetSampleRate(), true, new Color(1f, 1f, 1f, 0.3f * blend));
            AudioCurveRendering.EndCurveFrame();
            return(result);
        }
 public static void DrawMinMaxFilledCurve(Rect r, AudioMinMaxCurveAndColorEvaluator eval)
 {
     HandleUtility.ApplyWireMaterial();
     DrawMinMaxFilledCurveInternal(r, eval);
 }
Beispiel #8
0
        public void TimeRuler(Rect position, float frameRate, bool labels, bool useEntireHeight, float alpha)
        {
            Color color = GUI.color;

            GUI.BeginGroup(position);
            if (Event.current.type != EventType.Repaint)
            {
                GUI.EndGroup();
            }
            else
            {
                InitStyles();
                HandleUtility.ApplyWireMaterial();
                if (Application.platform == RuntimePlatform.WindowsEditor)
                {
                    GL.Begin(7);
                }
                else
                {
                    GL.Begin(1);
                }
                Color backgroundColor = GUI.backgroundColor;
                this.SetTickMarkerRanges();
                this.hTicks.SetTickStrengths(3f, 80f, true);
                Color textColor = styles.TimelineTick.normal.textColor;
                textColor.a = 0.75f * alpha;
                for (int i = 0; i < this.hTicks.tickLevels; i++)
                {
                    float   b            = this.hTicks.GetStrengthOfLevel(i) * 0.9f;
                    float[] ticksAtLevel = this.hTicks.GetTicksAtLevel(i, true);
                    for (int j = 0; j < ticksAtLevel.Length; j++)
                    {
                        if ((ticksAtLevel[j] >= base.hRangeMin) && (ticksAtLevel[j] <= base.hRangeMax))
                        {
                            int   num4 = Mathf.RoundToInt(ticksAtLevel[j] * frameRate);
                            float num5 = !useEntireHeight ? ((position.height * Mathf.Min(1f, b)) * 0.7f) : position.height;
                            DrawVerticalLineFast(this.FrameToPixel((float)num4, frameRate, position), (position.height - num5) + 0.5f, position.height - 0.5f, new Color(1f, 1f, 1f, b / 0.5f) * textColor);
                        }
                    }
                }
                GL.End();
                if (labels)
                {
                    int     levelWithMinSeparation = this.hTicks.GetLevelWithMinSeparation(40f);
                    float[] numArray2 = this.hTicks.GetTicksAtLevel(levelWithMinSeparation, false);
                    for (int k = 0; k < numArray2.Length; k++)
                    {
                        if ((numArray2[k] >= base.hRangeMin) && (numArray2[k] <= base.hRangeMax))
                        {
                            int    frame = Mathf.RoundToInt(numArray2[k] * frameRate);
                            float  num10 = Mathf.Floor(this.FrameToPixel((float)frame, frameRate, position));
                            string text  = this.FormatFrame(frame, frameRate);
                            GUI.Label(new Rect(num10 + 3f, -3f, 40f, 20f), text, styles.TimelineTick);
                        }
                    }
                }
                GUI.EndGroup();
                GUI.backgroundColor = backgroundColor;
                GUI.color           = color;
            }
        }
        private static void DrawGrid(Vector3 pos, Vector3 axis1, Vector3 axis2, Vector3 normal, Color color)
        {
            if (Event.current.type != EventType.Repaint)
            {
                return;
            }

            HandleUtility.ApplyWireMaterial();

            if (color.a > 0)
            {
                GL.Begin(GL.LINES);

                float lineLength = 10f;
                int   numLines   = 11;

                lineLength *= m_ScaleGrid;
                numLines    = (int)lineLength;
                numLines    = Mathf.Clamp(numLines, 10, 40);
                if (numLines % 2 == 0)
                {
                    numLines++;
                }

                float halfLength = lineLength * 0.5f;

                float   distBetweenLines = lineLength / (numLines - 1);
                Vector3 v1       = axis1 * lineLength;
                Vector3 v2       = axis2 * lineLength;
                Vector3 dist1    = axis1 * distBetweenLines;
                Vector3 dist2    = axis2 * distBetweenLines;
                Vector3 startPos = pos - axis1 * halfLength - axis2 * halfLength;

                for (int i = 0; i < numLines; i++)
                {
                    if (i % 2 == 0)
                    {
                        GL.Color(color * 0.7f);
                    }
                    else
                    {
                        GL.Color(color);
                    }

                    // Axis1
                    GL.Vertex(startPos + i * dist1);
                    GL.Vertex(startPos + i * dist1 + v2);

                    // Axis2
                    GL.Vertex(startPos + i * dist2);
                    GL.Vertex(startPos + i * dist2 + v1);
                }

                GL.Color(color);
                GL.Vertex(pos);
                GL.Vertex(pos + normal);


                GL.End();
            }
        }
        private static bool CurveDisplay(IAudioEffectPlugin plugin, Rect r0, ref float threshold, ref float ratio, ref float makeupGain, ref float attackTime, ref float releaseTime, ref float knee, float sidechainLevel, float outputLevel, float blend)
        {
            Event current   = Event.current;
            int   controlID = GUIUtility.GetControlID(FocusType.Passive);
            Rect  r         = AudioCurveRendering.BeginCurveFrame(r0);
            float num       = 10f;
            float min;
            float max;
            float num2;

            plugin.GetFloatParameterInfo(DuckVolumeGUI.kThresholdName, out min, out max, out num2);
            float min2;
            float max2;
            float num3;

            plugin.GetFloatParameterInfo(DuckVolumeGUI.kRatioName, out min2, out max2, out num3);
            float min3;
            float max3;
            float num4;

            plugin.GetFloatParameterInfo(DuckVolumeGUI.kMakeupGainName, out min3, out max3, out num4);
            float min4;
            float max4;
            float num5;

            plugin.GetFloatParameterInfo(DuckVolumeGUI.kKneeName, out min4, out max4, out num5);
            float     dbRange        = 100f;
            float     dbMin          = -80f;
            float     num6           = r.width * (threshold - dbMin) / dbRange;
            bool      result         = false;
            EventType typeForControl = current.GetTypeForControl(controlID);

            if (typeForControl != EventType.MouseDown)
            {
                if (typeForControl != EventType.MouseUp)
                {
                    if (typeForControl == EventType.MouseDrag)
                    {
                        if (GUIUtility.hotControl == controlID)
                        {
                            float num7 = (!current.alt) ? 1f : 0.25f;
                            if (DuckVolumeGUI.dragtype == DuckVolumeGUI.DragType.ThresholdAndKnee)
                            {
                                bool flag = Mathf.Abs(current.delta.x) < Mathf.Abs(current.delta.y);
                                if (flag)
                                {
                                    knee = Mathf.Clamp(knee + current.delta.y * 0.5f * num7, min4, max4);
                                }
                                else
                                {
                                    threshold = Mathf.Clamp(threshold + current.delta.x * 0.1f * num7, min, max);
                                }
                            }
                            else if (DuckVolumeGUI.dragtype == DuckVolumeGUI.DragType.Ratio)
                            {
                                ratio = Mathf.Clamp(ratio + current.delta.y * ((ratio <= 1f) ? 0.003f : 0.05f) * num7, min2, max2);
                            }
                            else if (DuckVolumeGUI.dragtype == DuckVolumeGUI.DragType.MakeupGain)
                            {
                                makeupGain = Mathf.Clamp(makeupGain - current.delta.y * 0.5f * num7, min3, max3);
                            }
                            else
                            {
                                Debug.LogError("Drag: Unhandled enum");
                            }
                            result = true;
                            current.Use();
                        }
                    }
                }
                else if (GUIUtility.hotControl == controlID && current.button == 0)
                {
                    DuckVolumeGUI.dragtype = DuckVolumeGUI.DragType.None;
                    GUIUtility.hotControl  = 0;
                    EditorGUIUtility.SetWantsMouseJumping(0);
                    current.Use();
                }
            }
            else if (r.Contains(Event.current.mousePosition) && current.button == 0)
            {
                DuckVolumeGUI.dragtype = DuckVolumeGUI.DragType.None;
                GUIUtility.hotControl  = controlID;
                EditorGUIUtility.SetWantsMouseJumping(1);
                current.Use();
                if (Mathf.Abs(r.x + num6 - current.mousePosition.x) >= 10f)
                {
                    DuckVolumeGUI.dragtype = ((current.mousePosition.x >= r.x + num6) ? DuckVolumeGUI.DragType.Ratio : DuckVolumeGUI.DragType.MakeupGain);
                }
                else
                {
                    DuckVolumeGUI.dragtype = DuckVolumeGUI.DragType.ThresholdAndKnee;
                }
            }
            if (current.type == EventType.Repaint)
            {
                HandleUtility.ApplyWireMaterial();
                float num8               = r.height * (1f - (threshold - dbMin + makeupGain) / dbRange);
                Color col2               = new Color(0.7f, 0.7f, 0.7f);
                Color black              = Color.black;
                float duckGradient       = 1f / ratio;
                float duckThreshold      = threshold;
                float duckSidechainLevel = sidechainLevel;
                float duckMakeupGain     = makeupGain;
                float duckKnee           = knee;
                float duckKneeC1         = (knee <= 0f) ? 0f : ((duckGradient - 1f) / (4f * knee));
                float duckKneeC2         = duckThreshold - knee;
                AudioCurveRendering.DrawFilledCurve(r, delegate(float x, out Color col)
                {
                    float num16 = x * dbRange + dbMin;
                    float num17 = num16;
                    float num18 = num16 - duckThreshold;
                    col         = DuckVolumeGUI.ScaleAlpha((duckSidechainLevel <= num16) ? Color.grey : AudioCurveRendering.kAudioOrange, blend);
                    if (num18 > -duckKnee && num18 < duckKnee)
                    {
                        num18 += duckKnee;
                        num17  = num18 * (duckKneeC1 * num18 + 1f) + duckKneeC2;
                        if (DuckVolumeGUI.dragtype == DuckVolumeGUI.DragType.ThresholdAndKnee)
                        {
                            col = new Color(col.r * 1.2f, col.g * 1.2f, col.b * 1.2f);
                        }
                    }
                    else if (num18 > 0f)
                    {
                        num17 = duckThreshold + duckGradient * num18;
                    }
                    return(2f * (num17 + duckMakeupGain - dbMin) / dbRange - 1f);
                });
                if (DuckVolumeGUI.dragtype == DuckVolumeGUI.DragType.MakeupGain)
                {
                    AudioCurveRendering.DrawCurve(r, delegate(float x)
                    {
                        float num16 = x * dbRange + dbMin;
                        float num17 = num16;
                        float num18 = num16 - duckThreshold;
                        if (num18 > -duckKnee && num18 < duckKnee)
                        {
                            num18 += duckKnee;
                            num17  = num18 * (duckKneeC1 * num18 + 1f) + duckKneeC2;
                        }
                        else if (num18 > 0f)
                        {
                            num17 = duckThreshold + duckGradient * num18;
                        }
                        return(2f * (num17 + duckMakeupGain - dbMin) / dbRange - 1f);
                    }, Color.white);
                }
                DuckVolumeGUI.textStyle10.normal.textColor = DuckVolumeGUI.ScaleAlpha(col2, blend);
                EditorGUI.DrawRect(new Rect(r.x + num6, r.y, 1f, r.height), DuckVolumeGUI.textStyle10.normal.textColor);
                DuckVolumeGUI.DrawText(r.x + num6 + 4f, r.y + 6f, string.Format("Threshold: {0:F1} dB", threshold));
                DuckVolumeGUI.textStyle10.normal.textColor = DuckVolumeGUI.ScaleAlpha(black, blend);
                DuckVolumeGUI.DrawText(r.x + 4f, r.y + r.height - 10f, (sidechainLevel >= -80f) ? string.Format("Input: {0:F1} dB", sidechainLevel) : "Input: None");
                if (DuckVolumeGUI.dragtype == DuckVolumeGUI.DragType.Ratio)
                {
                    float num9 = r.height / r.width;
                    Handles.DrawAAPolyLine(2f, new Color[]
                    {
                        Color.black,
                        Color.black
                    }, new Vector3[]
                    {
                        new Vector3(r.x + num6 + r.width, r.y + num8 - num9 * r.width, 0f),
                        new Vector3(r.x + num6 - r.width, r.y + num8 + num9 * r.width, 0f)
                    });
                    Handles.DrawAAPolyLine(3f, new Color[]
                    {
                        Color.white,
                        Color.white
                    }, new Vector3[]
                    {
                        new Vector3(r.x + num6 + r.width, r.y + num8 - num9 * duckGradient * r.width, 0f),
                        new Vector3(r.x + num6 - r.width, r.y + num8 + num9 * duckGradient * r.width, 0f)
                    });
                }
                else if (DuckVolumeGUI.dragtype == DuckVolumeGUI.DragType.ThresholdAndKnee)
                {
                    float num10 = (threshold - knee - dbMin) / dbRange;
                    float num11 = (threshold + knee - dbMin) / dbRange;
                    float num12 = DuckVolumeGUI.EvaluateDuckingVolume(num10, ratio, threshold, makeupGain, knee, dbRange, dbMin);
                    float num13 = DuckVolumeGUI.EvaluateDuckingVolume(num11, ratio, threshold, makeupGain, knee, dbRange, dbMin);
                    float num14 = r.yMax - (num12 + 1f) * 0.5f * r.height;
                    float num15 = r.yMax - (num13 + 1f) * 0.5f * r.height;
                    EditorGUI.DrawRect(new Rect(r.x + num10 * r.width, num14, 1f, r.height - num14), new Color(0f, 0f, 0f, 0.5f));
                    EditorGUI.DrawRect(new Rect(r.x + num11 * r.width - 1f, num15, 1f, r.height - num15), new Color(0f, 0f, 0f, 0.5f));
                    EditorGUI.DrawRect(new Rect(r.x + num6 - 1f, r.y, 3f, r.height), Color.white);
                }
                outputLevel = (Mathf.Clamp(outputLevel - makeupGain, dbMin, dbMin + dbRange) - dbMin) / dbRange;
                if (EditorApplication.isPlaying)
                {
                    Rect r2 = new Rect(r.x + r.width - num + 2f, r.y + 2f, num - 4f, r.height - 4f);
                    DuckVolumeGUI.DrawVU(r2, outputLevel, blend, true);
                }
            }
            AudioCurveRendering.EndCurveFrame();
            return(result);
        }
Beispiel #11
0
        public void TimeRuler(Rect position, float frameRate)
        {
            Color color = GUI.color;

            GUI.BeginGroup(position);
            if (Event.current.type != EventType.Repaint)
            {
                GUI.EndGroup();
                return;
            }
            TimeArea.InitStyles();
            HandleUtility.ApplyWireMaterial();
            GL.Begin(1);
            Color backgroundColor = GUI.backgroundColor;

            this.SetTickMarkerRanges();
            this.hTicks.SetTickStrengths(3f, 80f, true);
            Color textColor = TimeArea.styles.TimelineTick.normal.textColor;

            textColor.a = 0.75f;
            for (int i = 0; i < this.hTicks.tickLevels; i++)
            {
                float   num          = this.hTicks.GetStrengthOfLevel(i) * 0.9f;
                float[] ticksAtLevel = this.hTicks.GetTicksAtLevel(i, true);
                for (int j = 0; j < ticksAtLevel.Length; j++)
                {
                    if (ticksAtLevel[j] >= base.hRangeMin && ticksAtLevel[j] <= base.hRangeMax)
                    {
                        int   num2 = Mathf.RoundToInt(ticksAtLevel[j] * frameRate);
                        float num3 = position.height * Mathf.Min(1f, num) * 0.7f;
                        float num4 = this.FrameToPixel((float)num2, frameRate, position);
                        GL.Color(new Color(1f, 1f, 1f, num / 0.5f) * textColor);
                        GL.Vertex(new Vector3(num4, position.height - num3 + 0.5f, 0f));
                        GL.Vertex(new Vector3(num4, position.height - 0.5f, 0f));
                        if (num > 0.5f)
                        {
                            GL.Color(new Color(1f, 1f, 1f, num / 0.5f - 1f) * textColor);
                            GL.Vertex(new Vector3(num4 + 1f, position.height - num3 + 0.5f, 0f));
                            GL.Vertex(new Vector3(num4 + 1f, position.height - 0.5f, 0f));
                        }
                    }
                }
            }
            GL.End();
            int levelWithMinSeparation = this.hTicks.GetLevelWithMinSeparation(40f);

            float[] ticksAtLevel2 = this.hTicks.GetTicksAtLevel(levelWithMinSeparation, false);
            for (int k = 0; k < ticksAtLevel2.Length; k++)
            {
                if (ticksAtLevel2[k] >= base.hRangeMin && ticksAtLevel2[k] <= base.hRangeMax)
                {
                    int    num5 = Mathf.RoundToInt(ticksAtLevel2[k] * frameRate);
                    float  num6 = Mathf.Floor(this.FrameToPixel((float)num5, frameRate, base.rect));
                    string text = this.FormatFrame(num5, frameRate);
                    GUI.Label(new Rect(num6 + 3f, -3f, 40f, 20f), text, TimeArea.styles.TimelineTick);
                }
            }
            GUI.EndGroup();
            GUI.backgroundColor = backgroundColor;
            GUI.color           = color;
        }
Beispiel #12
0
        private static bool CurveDisplay(IAudioEffectPlugin plugin, Rect r0, ref float threshold, ref float ratio, ref float makeupGain, ref float attackTime, ref float releaseTime, ref float knee, float sidechainLevel, float outputLevel, float blend)
        {
            // ISSUE: object of a compiler-generated type is created
            // ISSUE: variable of a compiler-generated type
            DuckVolumeGUI.\u003CCurveDisplay\u003Ec__AnonStorey5C displayCAnonStorey5C = new DuckVolumeGUI.\u003CCurveDisplay\u003Ec__AnonStorey5C();
            // ISSUE: reference to a compiler-generated field
            displayCAnonStorey5C.blend = blend;
            Event current   = Event.current;
            int   controlId = GUIUtility.GetControlID(FocusType.Passive);
            Rect  r         = AudioCurveRendering.BeginCurveFrame(r0);
            float num1      = 10f;
            float minRange1;
            float maxRange1;
            float defaultValue1;

            plugin.GetFloatParameterInfo(DuckVolumeGUI.kThresholdName, out minRange1, out maxRange1, out defaultValue1);
            float minRange2;
            float maxRange2;
            float defaultValue2;

            plugin.GetFloatParameterInfo(DuckVolumeGUI.kRatioName, out minRange2, out maxRange2, out defaultValue2);
            float minRange3;
            float maxRange3;
            float defaultValue3;

            plugin.GetFloatParameterInfo(DuckVolumeGUI.kMakeupGainName, out minRange3, out maxRange3, out defaultValue3);
            float minRange4;
            float maxRange4;
            float defaultValue4;

            plugin.GetFloatParameterInfo(DuckVolumeGUI.kKneeName, out minRange4, out maxRange4, out defaultValue4);
            // ISSUE: reference to a compiler-generated field
            displayCAnonStorey5C.dbRange = 100f;
            // ISSUE: reference to a compiler-generated field
            displayCAnonStorey5C.dbMin = -80f;
            // ISSUE: reference to a compiler-generated field
            // ISSUE: reference to a compiler-generated field
            float num2 = r.width * (threshold - displayCAnonStorey5C.dbMin) / displayCAnonStorey5C.dbRange;
            bool  flag = false;

            switch (current.GetTypeForControl(controlId))
            {
            case EventType.MouseDown:
                if (r.Contains(Event.current.mousePosition) && current.button == 0)
                {
                    DuckVolumeGUI.dragtype = DuckVolumeGUI.DragType.None;
                    GUIUtility.hotControl  = controlId;
                    EditorGUIUtility.SetWantsMouseJumping(1);
                    current.Use();
                    DuckVolumeGUI.dragtype = (double)Mathf.Abs(r.x + num2 - current.mousePosition.x) < 10.0 ? DuckVolumeGUI.DragType.ThresholdAndKnee : ((double)current.mousePosition.x >= (double)r.x + (double)num2 ? DuckVolumeGUI.DragType.Ratio : DuckVolumeGUI.DragType.MakeupGain);
                    break;
                }
                break;

            case EventType.MouseUp:
                if (GUIUtility.hotControl == controlId && current.button == 0)
                {
                    DuckVolumeGUI.dragtype = DuckVolumeGUI.DragType.None;
                    GUIUtility.hotControl  = 0;
                    EditorGUIUtility.SetWantsMouseJumping(0);
                    current.Use();
                    break;
                }
                break;

            case EventType.MouseDrag:
                if (GUIUtility.hotControl == controlId)
                {
                    float num3 = !current.alt ? 1f : 0.25f;
                    if (DuckVolumeGUI.dragtype == DuckVolumeGUI.DragType.ThresholdAndKnee)
                    {
                        if ((double)Mathf.Abs(current.delta.x) < (double)Mathf.Abs(current.delta.y))
                        {
                            knee = Mathf.Clamp(knee + current.delta.y * 0.5f * num3, minRange4, maxRange4);
                        }
                        else
                        {
                            threshold = Mathf.Clamp(threshold + current.delta.x * 0.1f * num3, minRange1, maxRange1);
                        }
                    }
                    else if (DuckVolumeGUI.dragtype == DuckVolumeGUI.DragType.Ratio)
                    {
                        ratio = Mathf.Clamp(ratio + current.delta.y * ((double)ratio <= 1.0 ? 3f / 1000f : 0.05f) * num3, minRange2, maxRange2);
                    }
                    else if (DuckVolumeGUI.dragtype == DuckVolumeGUI.DragType.MakeupGain)
                    {
                        makeupGain = Mathf.Clamp(makeupGain - current.delta.y * 0.5f * num3, minRange3, maxRange3);
                    }
                    else
                    {
                        Debug.LogError((object)"Drag: Unhandled enum");
                    }
                    flag = true;
                    current.Use();
                    break;
                }
                break;
            }
            if (current.type == EventType.Repaint)
            {
                // ISSUE: object of a compiler-generated type is created
                // ISSUE: variable of a compiler-generated type
                DuckVolumeGUI.\u003CCurveDisplay\u003Ec__AnonStorey5D displayCAnonStorey5D = new DuckVolumeGUI.\u003CCurveDisplay\u003Ec__AnonStorey5D();
                // ISSUE: reference to a compiler-generated field
                displayCAnonStorey5D.\u003C\u003Ef__ref\u002492 = displayCAnonStorey5C;
                HandleUtility.ApplyWireMaterial();
                // ISSUE: reference to a compiler-generated field
                // ISSUE: reference to a compiler-generated field
                float num3  = r.height * (float)(1.0 - ((double)threshold - (double)displayCAnonStorey5C.dbMin + (double)makeupGain) / (double)displayCAnonStorey5C.dbRange);
                Color col   = new Color(0.7f, 0.7f, 0.7f);
                Color black = Color.black;
                // ISSUE: reference to a compiler-generated field
                displayCAnonStorey5D.duckGradient = 1f / ratio;
                // ISSUE: reference to a compiler-generated field
                displayCAnonStorey5D.duckThreshold = threshold;
                // ISSUE: reference to a compiler-generated field
                displayCAnonStorey5D.duckSidechainLevel = sidechainLevel;
                // ISSUE: reference to a compiler-generated field
                displayCAnonStorey5D.duckMakeupGain = makeupGain;
                // ISSUE: reference to a compiler-generated field
                displayCAnonStorey5D.duckKnee = knee;
                // ISSUE: reference to a compiler-generated field
                // ISSUE: reference to a compiler-generated field
                displayCAnonStorey5D.duckKneeC1 = (double)knee <= 0.0 ? 0.0f : (float)(((double)displayCAnonStorey5D.duckGradient - 1.0) / (4.0 * (double)knee));
                // ISSUE: reference to a compiler-generated field
                // ISSUE: reference to a compiler-generated field
                displayCAnonStorey5D.duckKneeC2 = displayCAnonStorey5D.duckThreshold - knee;
                // ISSUE: reference to a compiler-generated method
                AudioCurveRendering.DrawFilledCurve(r, new AudioCurveRendering.AudioCurveAndColorEvaluator(displayCAnonStorey5D.\u003C\u003Em__9D));
                if (DuckVolumeGUI.dragtype == DuckVolumeGUI.DragType.MakeupGain)
                {
                    // ISSUE: reference to a compiler-generated method
                    AudioCurveRendering.DrawCurve(r, new AudioCurveRendering.AudioCurveEvaluator(displayCAnonStorey5D.\u003C\u003Em__9E), Color.white);
                }
                // ISSUE: reference to a compiler-generated field
                DuckVolumeGUI.textStyle10.normal.textColor = DuckVolumeGUI.ScaleAlpha(col, displayCAnonStorey5C.blend);
                EditorGUI.DrawRect(new Rect(r.x + num2, r.y, 1f, r.height), DuckVolumeGUI.textStyle10.normal.textColor);
                DuckVolumeGUI.DrawText((float)((double)r.x + (double)num2 + 4.0), r.y + 6f, string.Format("Threshold: {0:F1} dB", (object)threshold));
                // ISSUE: reference to a compiler-generated field
                DuckVolumeGUI.textStyle10.normal.textColor = DuckVolumeGUI.ScaleAlpha(black, displayCAnonStorey5C.blend);
                DuckVolumeGUI.DrawText(r.x + 4f, (float)((double)r.y + (double)r.height - 10.0), (double)sidechainLevel >= -80.0 ? string.Format("Input: {0:F1} dB", (object)sidechainLevel) : "Input: None");
                if (DuckVolumeGUI.dragtype == DuckVolumeGUI.DragType.Ratio)
                {
                    float num4 = r.height / r.width;
                    Handles.DrawAAPolyLine(2f, new Color[2]
                    {
                        Color.black,
                        Color.black
                    }, new Vector3[2]
                    {
                        new Vector3(r.x + num2 + r.width, (float)((double)r.y + (double)num3 - (double)num4 * (double)r.width), 0.0f),
                        new Vector3(r.x + num2 - r.width, (float)((double)r.y + (double)num3 + (double)num4 * (double)r.width), 0.0f)
                    });
                    // ISSUE: reference to a compiler-generated field
                    // ISSUE: reference to a compiler-generated field
                    Handles.DrawAAPolyLine(3f, new Color[2]
                    {
                        Color.white,
                        Color.white
                    }, new Vector3[2]
                    {
                        new Vector3(r.x + num2 + r.width, (float)((double)r.y + (double)num3 - (double)num4 * (double)displayCAnonStorey5D.duckGradient * (double)r.width), 0.0f),
                        new Vector3(r.x + num2 - r.width, (float)((double)r.y + (double)num3 + (double)num4 * (double)displayCAnonStorey5D.duckGradient * (double)r.width), 0.0f)
                    });
                }
                else if (DuckVolumeGUI.dragtype == DuckVolumeGUI.DragType.ThresholdAndKnee)
                {
                    // ISSUE: reference to a compiler-generated field
                    // ISSUE: reference to a compiler-generated field
                    float x1 = (threshold - knee - displayCAnonStorey5C.dbMin) / displayCAnonStorey5C.dbRange;
                    // ISSUE: reference to a compiler-generated field
                    // ISSUE: reference to a compiler-generated field
                    float x2 = (threshold + knee - displayCAnonStorey5C.dbMin) / displayCAnonStorey5C.dbRange;
                    // ISSUE: reference to a compiler-generated field
                    // ISSUE: reference to a compiler-generated field
                    float duckingVolume1 = DuckVolumeGUI.EvaluateDuckingVolume(x1, ratio, threshold, makeupGain, knee, displayCAnonStorey5C.dbRange, displayCAnonStorey5C.dbMin);
                    // ISSUE: reference to a compiler-generated field
                    // ISSUE: reference to a compiler-generated field
                    float duckingVolume2 = DuckVolumeGUI.EvaluateDuckingVolume(x2, ratio, threshold, makeupGain, knee, displayCAnonStorey5C.dbRange, displayCAnonStorey5C.dbMin);
                    float y1             = r.yMax - (float)(((double)duckingVolume1 + 1.0) * 0.5) * r.height;
                    float y2             = r.yMax - (float)(((double)duckingVolume2 + 1.0) * 0.5) * r.height;
                    EditorGUI.DrawRect(new Rect(r.x + x1 * r.width, y1, 1f, r.height - y1), new Color(0.0f, 0.0f, 0.0f, 0.5f));
                    EditorGUI.DrawRect(new Rect((float)((double)r.x + (double)x2 * (double)r.width - 1.0), y2, 1f, r.height - y2), new Color(0.0f, 0.0f, 0.0f, 0.5f));
                    EditorGUI.DrawRect(new Rect((float)((double)r.x + (double)num2 - 1.0), r.y, 3f, r.height), Color.white);
                }
                // ISSUE: reference to a compiler-generated field
                // ISSUE: reference to a compiler-generated field
                // ISSUE: reference to a compiler-generated field
                // ISSUE: reference to a compiler-generated field
                // ISSUE: reference to a compiler-generated field
                outputLevel = (Mathf.Clamp(outputLevel - makeupGain, displayCAnonStorey5C.dbMin, displayCAnonStorey5C.dbMin + displayCAnonStorey5C.dbRange) - displayCAnonStorey5C.dbMin) / displayCAnonStorey5C.dbRange;
                if (EditorApplication.isPlaying)
                {
                    // ISSUE: reference to a compiler-generated field
                    DuckVolumeGUI.DrawVU(new Rect((float)((double)r.x + (double)r.width - (double)num1 + 2.0), r.y + 2f, num1 - 4f, r.height - 4f), outputLevel, displayCAnonStorey5C.blend, true);
                }
            }
            AudioCurveRendering.EndCurveFrame();
            return(flag);
        }
        public static void DrawSymmetricFilledCurve(Rect r, AudioCurveRendering.AudioCurveAndColorEvaluator eval)
        {
            if (Event.current.type != EventType.Repaint)
            {
                return;
            }
            HandleUtility.ApplyWireMaterial();
            GL.Begin(1);
            float num  = 1f / (r.width - 1f);
            float num2 = r.height * 0.5f;
            float y    = r.y;
            float num3 = r.y + r.height;
            Color c;
            float num4 = Mathf.Clamp(num2 - num2 * eval(0.0001f, out c), 0f, num2);
            int   num5 = 0;

            while ((float)num5 < r.width)
            {
                float num6 = (float)((int)r.x + num5);
                float num7 = Mathf.Clamp(num2 - num2 * eval((float)num5 * num, out c), 0f, num2);
                GL.Color(c);
                AudioMixerDrawUtils.Vertex(num6, y + (float)((int)Mathf.Ceil(num7)));
                AudioMixerDrawUtils.Vertex(num6, num3 - (float)((int)Mathf.Ceil(num7)));
                if (Mathf.Abs(num4 - num7) <= 1f)
                {
                    GL.Color(new Color(c.r, c.g, c.b, c.a * (Mathf.Ceil(num7) - num7)));
                    AudioMixerDrawUtils.Vertex(num6, y + Mathf.Ceil(num7) - 1f);
                    AudioMixerDrawUtils.Vertex(num6, y + Mathf.Ceil(num7));
                    AudioMixerDrawUtils.Vertex(num6, num3 - Mathf.Ceil(num7) + 1f);
                    AudioMixerDrawUtils.Vertex(num6, num3 - Mathf.Ceil(num7));
                }
                else
                {
                    if (num4 < num7)
                    {
                        GL.Color(new Color(c.r, c.g, c.b, 0f));
                        AudioMixerDrawUtils.Vertex(num6, y + Mathf.Ceil(num4));
                        GL.Color(c);
                        AudioMixerDrawUtils.Vertex(num6, y + Mathf.Ceil(num7));
                        GL.Color(new Color(c.r, c.g, c.b, 0f));
                        AudioMixerDrawUtils.Vertex(num6, num3 - Mathf.Ceil(num4) - 1f);
                        GL.Color(c);
                        AudioMixerDrawUtils.Vertex(num6, num3 - Mathf.Ceil(num7) - 1f);
                    }
                    else
                    {
                        GL.Color(new Color(c.r, c.g, c.b, 0f));
                        AudioMixerDrawUtils.Vertex(num6 - 1f, y + Mathf.Ceil(num7));
                        GL.Color(c);
                        AudioMixerDrawUtils.Vertex(num6 - 1f, y + Mathf.Ceil(num4));
                        GL.Color(new Color(c.r, c.g, c.b, 0f));
                        AudioMixerDrawUtils.Vertex(num6 - 1f, num3 - Mathf.Ceil(num7) - 1f);
                        GL.Color(c);
                        AudioMixerDrawUtils.Vertex(num6 - 1f, num3 - Mathf.Ceil(num4) - 1f);
                    }
                }
                num4 = num7;
                num5++;
            }
            GL.End();
        }
Beispiel #14
0
        public void TimeRuler(Rect position, float frameRate, bool labels, bool useEntireHeight, float alpha, bool showTimeAsFrames)
        {
            Color color = GUI.color;

            GUI.BeginGroup(position);
            TimeArea.InitStyles();
            HandleUtility.ApplyWireMaterial();
            Color backgroundColor = GUI.backgroundColor;

            this.SetTickMarkerRanges();
            this.hTicks.SetTickStrengths(3f, 80f, true);
            Color textColor = TimeArea.styles.TimelineTick.normal.textColor;

            textColor.a = 0.75f * alpha;
            if (Event.current.type == EventType.Repaint)
            {
                if (Application.platform == RuntimePlatform.WindowsEditor)
                {
                    GL.Begin(7);
                }
                else
                {
                    GL.Begin(1);
                }
                Rect shownArea = base.shownArea;
                for (int i = 0; i < this.hTicks.tickLevels; i++)
                {
                    float   num          = this.hTicks.GetStrengthOfLevel(i) * 0.9f;
                    float[] ticksAtLevel = this.hTicks.GetTicksAtLevel(i, true);
                    for (int j = 0; j < ticksAtLevel.Length; j++)
                    {
                        if (ticksAtLevel[j] >= base.hRangeMin && ticksAtLevel[j] <= base.hRangeMax)
                        {
                            int   num2 = Mathf.RoundToInt(ticksAtLevel[j] * frameRate);
                            float num3 = (!useEntireHeight) ? (position.height * Mathf.Min(1f, num) * 0.7f) : position.height;
                            float x    = this.FrameToPixel((float)num2, frameRate, position, shownArea);
                            TimeArea.DrawVerticalLineFast(x, position.height - num3 + 0.5f, position.height - 0.5f, new Color(1f, 1f, 1f, num / 0.5f) * textColor);
                        }
                    }
                }
                GL.End();
            }
            if (labels)
            {
                int     levelWithMinSeparation = this.hTicks.GetLevelWithMinSeparation(40f);
                float[] ticksAtLevel2          = this.hTicks.GetTicksAtLevel(levelWithMinSeparation, false);
                for (int k = 0; k < ticksAtLevel2.Length; k++)
                {
                    if (ticksAtLevel2[k] >= base.hRangeMin && ticksAtLevel2[k] <= base.hRangeMax)
                    {
                        int    num4 = Mathf.RoundToInt(ticksAtLevel2[k] * frameRate);
                        float  num5 = Mathf.Floor(this.FrameToPixel((float)num4, frameRate, position));
                        string text = (!showTimeAsFrames) ? this.FormatFrame(num4, frameRate) : num4.ToString();
                        GUI.Label(new Rect(num5 + 3f, -3f, 40f, 20f), text, TimeArea.styles.TimelineTick);
                    }
                }
            }
            GUI.EndGroup();
            GUI.backgroundColor = backgroundColor;
            GUI.color           = color;
        }
Beispiel #15
0
        public override void OnPreviewGUI(Rect r, GUIStyle background)
        {
            if (Event.current.type == EventType.Repaint)
            {
                background.Draw(r, false, false, false, false);
            }
            Texture       target   = this.target as Texture;
            RenderTexture texture2 = target as RenderTexture;

            if (texture2 != null)
            {
                if (!SystemInfo.SupportsRenderTextureFormat(texture2.format))
                {
                    return;
                }
                texture2.Create();
            }
            if (this.IsCubemap())
            {
                this.m_CubemapPreview.OnPreviewGUI(target, r, background);
            }
            else
            {
                int   num  = Mathf.Max(target.width, 1);
                int   num2 = Mathf.Max(target.height, 1);
                float mipLevelForRendering = this.GetMipLevelForRendering();
                float num4     = Mathf.Min(Mathf.Min((float)(r.width / ((float)num)), (float)(r.height / ((float)num2))), 1f);
                Rect  viewRect = new Rect(r.x, r.y, num * num4, num2 * num4);
                PreviewGUI.BeginScrollView(r, this.m_Pos, viewRect, "PreHorizontalScrollbar", "PreHorizontalScrollbarThumb");
                float mipMapBias = target.mipMapBias;
                TextureUtil.SetMipMapBiasNoDirty(target, mipLevelForRendering - this.Log2(((float)num) / viewRect.width));
                UnityEngine.FilterMode filterMode = target.filterMode;
                TextureUtil.SetFilterModeNoDirty(target, UnityEngine.FilterMode.Point);
                if (this.m_ShowAlpha)
                {
                    EditorGUI.DrawTextureAlpha(viewRect, target);
                }
                else
                {
                    Texture2D textured = target as Texture2D;
                    if ((textured != null) && textured.alphaIsTransparency)
                    {
                        EditorGUI.DrawTextureTransparent(viewRect, target);
                    }
                    else
                    {
                        EditorGUI.DrawPreviewTexture(viewRect, target);
                    }
                }
                if ((viewRect.width > 32f) && (viewRect.height > 32f))
                {
                    TextureImporter  atPath    = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(target)) as TextureImporter;
                    SpriteMetaData[] dataArray = (atPath == null) ? null : atPath.spritesheet;
                    if ((dataArray != null) && (atPath.spriteImportMode == SpriteImportMode.Multiple))
                    {
                        Rect outScreenRect = new Rect();
                        Rect outSourceRect = new Rect();
                        GUI.CalculateScaledTextureRects(viewRect, ScaleMode.StretchToFill, ((float)target.width) / ((float)target.height), ref outScreenRect, ref outSourceRect);
                        int width  = target.width;
                        int height = target.height;
                        atPath.GetWidthAndHeight(ref width, ref height);
                        float num8 = ((float)target.width) / ((float)width);
                        HandleUtility.ApplyWireMaterial();
                        GL.PushMatrix();
                        GL.MultMatrix(Handles.matrix);
                        GL.Begin(1);
                        GL.Color(new Color(1f, 1f, 1f, 0.5f));
                        foreach (SpriteMetaData data in dataArray)
                        {
                            Rect rect  = data.rect;
                            Rect rect5 = new Rect {
                                xMin = outScreenRect.xMin + (outScreenRect.width * ((rect.xMin / ((float)target.width)) * num8)),
                                xMax = outScreenRect.xMin + (outScreenRect.width * ((rect.xMax / ((float)target.width)) * num8)),
                                yMin = outScreenRect.yMin + (outScreenRect.height * (1f - ((rect.yMin / ((float)target.height)) * num8))),
                                yMax = outScreenRect.yMin + (outScreenRect.height * (1f - ((rect.yMax / ((float)target.height)) * num8)))
                            };
                            this.DrawRect(rect5);
                        }
                        GL.End();
                        GL.PopMatrix();
                    }
                }
                TextureUtil.SetMipMapBiasNoDirty(target, mipMapBias);
                TextureUtil.SetFilterModeNoDirty(target, filterMode);
                this.m_Pos = PreviewGUI.EndScrollView();
                if (mipLevelForRendering != 0f)
                {
                    EditorGUI.DropShadowLabel(new Rect(r.x, r.y, r.width, 20f), "Mip " + mipLevelForRendering);
                }
            }
        }
Beispiel #16
0
        internal static void ApplyWireMaterial()
        {
            CompareFunction zTest = CompareFunction.Always;

            HandleUtility.ApplyWireMaterial(zTest);
        }