vr-space-station/Assets/Oculus/Spatializer/editor/ONSPPropagationMaterialEditor.cs

/************************************************************************************
Filename    :   ONSPPropagationMaterialEditor.cs
Content     :   Propagation material editor class
                Attach to geometry to define material properties
Copyright   :   Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.

Licensed under the Oculus SDK Version 3.5 (the "License"); 
you may not use the Oculus SDK except in compliance with the License, 
which is provided at the time of installation or download, or which 
otherwise accompanies this software in either electronic or hard copy form.

You may obtain a copy of the License at

https://developer.oculus.com/licenses/sdk-3.5/

Unless required by applicable law or agreed to in writing, the Oculus SDK 
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
************************************************************************************/
using UnityEditor;
using UnityEngine;

using Spectrum = ONSPPropagationMaterial.Spectrum;
using Point = ONSPPropagationMaterial.Point;

[CustomEditor(typeof(ONSPPropagationMaterial))]
internal sealed class ONSPPropagationMaterialEditor : Editor{
  
  private enum AxisScale{ Lin, Log, Sqr }

  private sealed class SpectrumDrawer{

    private const float cutoff = 20000f;

    private static readonly Texture2D texture = EditorGUIUtility.whiteTexture;
    
    private static readonly GUIStyle textStyle = new GUIStyle{

      alignment = TextAnchor.MiddleLeft,
      clipping = TextClipping.Overflow,
      fontSize = 8,
      fontStyle = FontStyle.Bold,
      wordWrap = false,
      normal = new GUIStyleState{ textColor = Color.grey },
      focused = new GUIStyleState{ textColor = Color.grey }

    };

    private static int focus;

    private readonly string label;

    private readonly AxisScale scale;
    private readonly Spectrum spectrum;
    
    private bool dragInitiated;
    private bool isDragging;

    private bool displaySpectrum;
    private bool displayPoints;

    internal bool IsFocus{

      get{

        return focus == spectrum.GetHashCode();

      }

    }

    internal SpectrumDrawer(string label, Spectrum spectrum, AxisScale scale){
      
      this.label = label;
      this.spectrum = spectrum;
      this.scale = scale;

    }

    internal void Draw(Event e){

      displaySpectrum = EditorGUILayout.Foldout(displaySpectrum, label);
      
      if(displaySpectrum){

        EditorGUI.indentLevel++;
        DrawSpectrum(e);

        displayPoints = EditorGUILayout.Foldout(displayPoints, "Points");

        if(displayPoints){

          EditorGUI.indentLevel++;
          DrawPoints();
          EditorGUI.indentLevel--;

        }

        EditorGUI.indentLevel--;

      }

    }

    internal void LoadFoldoutState(){

      displaySpectrum = EditorPrefs.GetBool(label + "Spectrum", true);
      displayPoints = EditorPrefs.GetBool(label + "Points", false);

    }

    internal void SaveFoldoutState(){

      EditorPrefs.SetBool(label + "Spectrum", displaySpectrum);
      EditorPrefs.SetBool(label + "Points", displayPoints);

    }

    private void DrawSpectrum(Event e){

      float height = 10 * EditorGUIUtility.singleLineHeight;
      Rect r = EditorGUILayout.GetControlRect(true, height);

      r.width -= rightMargin;
      DrawDataTicks(r);
      r = AudioCurveRendering.BeginCurveFrame(r);

      AudioCurveRendering.DrawFilledCurve(r, EvaluateCurve, AudioCurveRendering.kAudioOrange);

      DrawFrequencyTicks(r);

      HandleEvent(r, e);
      if(IsFocus) DrawSelected(r);

      AudioCurveRendering.EndCurveFrame();

    }
        
    private void DrawPoints(){
      
      var points = spectrum.points;
      int lines = points.Count > 0 ? points.Count + 2 : 1;
      float height = EditorGUIUtility.singleLineHeight * lines;
      Rect r1 = EditorGUILayout.GetControlRect(true, height);
      r1.width -= rightMargin;
      r1.height = EditorGUIUtility.singleLineHeight;

      {

        int oldCount = points.Count;
        int newCount = EditorGUI.DelayedIntField(r1, "Size", oldCount);
        r1.y += r1.height;

        if(newCount < points.Count){

          points.RemoveRange(newCount, oldCount - newCount);
          Undo.SetCurrentGroupName("Points Removed");
          GUI.changed = true;

        } else if(newCount > oldCount){

          if(newCount > points.Capacity)
            points.Capacity = newCount;

          for(int i = oldCount; i < newCount; i++)
            points.Add(new Point(125 * (1 << i)));

          Undo.SetCurrentGroupName("Points Added");
          GUI.changed = true;

        }

      }

      if(points.Count > 0){

        Rect r2 = new Rect(r1.xMax + 9, r1.y + r1.height * 1.125f, 24, r1.height * .75f);
        
        r1.width /= 2;
        EditorGUI.LabelField(r1, "Frequency");
        r1.x += r1.width;
        EditorGUI.LabelField(r1, "Data");
        r1.x -= r1.width;
        r1.y += r1.height;

        for(int i = 0; i < points.Count; i++){

          points[i].frequency = EditorGUI.FloatField(r1, points[i].frequency);
          points[i].frequency = Mathf.Clamp(points[i].frequency, 0f, cutoff);
          r1.x += r1.width;
          points[i].data = EditorGUI.FloatField(r1, points[i].data);
          points[i].data = Mathf.Clamp01(points[i].data);
          r1.x -= r1.width;
          r1.y += r1.height;

          if(GUI.Button(r2, "–")){

            RemovePointAt(i);
            break;

          }

          r2.y += r1.height;

        }

      }

    }

    private void DrawDataTicks(Rect r){

      const int ticks = 10;
      Rect label = new Rect(r.xMax + 9, r.y - r.height / (2 * ticks), 24, r.height / ticks);
      Rect tick = new Rect(r.xMax + 2, r.y - 1, 4.5f, 2);

      for(int i = 0; i <= ticks; i++){
        
        float value = MapData(1 - (float)i / ticks, false);
        
        EditorGUI.DrawRect(tick, textStyle.normal.textColor);
        GUI.Label(label, value.ToString("0.000"), textStyle);
        tick.y += label.height;
        label.y += label.height;

      }

    }

    private void DrawFrequencyTicks(Rect r){
      
      Rect tick = new Rect(r.x, r.y, 1, r.height);
      Rect label = new Rect(r.x, r.yMax - 1.5f * EditorGUIUtility.singleLineHeight, 32, EditorGUIUtility.singleLineHeight);

      for(int i = 1; i < 30; i++){

        float frequency;

        if(MapFrequencyTick(i, out frequency)){

          tick.x = MapFrequency(frequency) * r.width;
          tick.height = label.y - r.y;
          tick.width = 2;
          EditorGUI.DrawRect(tick, textStyle.normal.textColor);

          tick.y = label.yMax;
          tick.height = r.yMax - label.yMax;
          EditorGUI.DrawRect(tick, textStyle.normal.textColor);

          label.x = tick.x - 2;
          GUI.Label(label, FrequencyToString(frequency), textStyle);

          tick.y = r.y;
          tick.height = r.height;
          tick.width = 1;

        } else{

          tick.x = MapFrequency(frequency) * r.width;
          EditorGUI.DrawRect(tick, textStyle.normal.textColor);

        }

      }

    }

    private void DrawSelected(Rect r){
      
      if(spectrum.points.Count > spectrum.selection){

        const float radius = 12;
        Vector2 position = MapPointPosition(r, spectrum.points[spectrum.selection]);
        Vector2 size = new Vector2(radius, radius);
        r = new Rect(position - size / 2, size);

#if UNITY_5
        GUI.DrawTexture(r, texture, ScaleMode.StretchToFill, false, 0);
        GUI.DrawTexture(r, texture, ScaleMode.StretchToFill, false, 0);
#else
        GUI.DrawTexture(r, texture, ScaleMode.StretchToFill, false, 0, Color.white, 0, radius);
        GUI.DrawTexture(r, texture, ScaleMode.StretchToFill, false, 0, Color.black, 2, radius);
#endif

        }
    }

    private void HandleEvent(Rect r, Event e){

      Vector2 position = e.mousePosition;

      switch(e.type){

        case EventType.MouseDown:

          if(r.Contains(position)){

            if(e.clickCount == 2){

              spectrum.selection = spectrum.points.Count;
              spectrum.points.Add(MapMouseEvent(r, position));
              Undo.SetCurrentGroupName("Point Added");
              GUI.changed = true;

            } else{

              int selection = spectrum.selection;
              float minDistance = float.MaxValue;

              for(int i = 0; i < spectrum.points.Count; i++){

                float distance = Vector2.Distance(MapPointPosition(r, spectrum.points[i]), position);

                if(distance < minDistance){

                  selection = i;
                  minDistance = distance;

                }

              }

              if(selection != spectrum.selection){

                spectrum.selection = selection;
                Undo.SetCurrentGroupName("Point Selected");
                GUI.changed = true;

              }

            }

            focus = spectrum.GetHashCode();
            dragInitiated = true;

          } else{

            isDragging = false;
            focus = 0;

          }

          e.Use();

          break;

        case EventType.MouseDrag:

          if(dragInitiated){

            dragInitiated = false;
            isDragging = true;

          }

          if(isDragging && spectrum.selection < spectrum.points.Count){

            spectrum.points[spectrum.selection] = MapMouseEvent(r, position);
            e.Use();

          }

          break;

        case EventType.Ignore:
        case EventType.MouseUp:

          dragInitiated = false;

          if(isDragging){

            isDragging = false;
            Undo.SetCurrentGroupName("Point Moved");
            GUI.changed = true;
            e.Use();

          }

          break;

        case EventType.KeyDown:

          switch(e.keyCode){

            case KeyCode.Delete:
            case KeyCode.Backspace:

              if(spectrum.selection < spectrum.points.Count){

                RemovePointAt(spectrum.selection);
                e.Use();

              }

              break;

          }

          break;

      }

    }

    private void RemovePointAt(int index){

      spectrum.points.RemoveAt(index);

      if(spectrum.selection == index)
        spectrum.selection = spectrum.points.Count;

      Undo.SetCurrentGroupName("Point Removed");
      GUI.changed = true;

    }

    private float EvaluateCurve(float f){

      return 2 * MapData(spectrum[MapFrequency(f, false)]) - 1;

    }

    private Vector2 MapPointPosition(Rect r, Point point){

      return new Vector2{

        x = r.x + r.width * MapFrequency(point.frequency),
        y = r.y + r.height * (1 - MapData(point.data))

      };

    }

    private Point MapMouseEvent(Rect r, Vector2 v){

      return new Point{

        frequency = v.x < r.xMin ? 0 : v.x > r.xMax ? cutoff : MapFrequency((v.x - r.x) / r.width, false),
        data = v.y < r.yMin ? 1 : v.y > r.yMax ? 0 : MapData(1 - (v.y - r.y) / r.height, false)

      };

    }

    private float MapData(float f, bool forward = true){

      switch(scale){

        case AxisScale.Log:
          return forward ? f < 1e-3f ? 0 : 1 + Mathf.Log10(f) / 3 : Mathf.Pow(10, -3 * (1 - f));

        case AxisScale.Sqr:
          return forward ? Mathf.Sqrt(f) : f * f;

        default:
        case AxisScale.Lin:
          return f;

      }

    }
    
    public static bool MapFrequencyTick(int i, out float frequency){

      int power = i / 9 + 1;
      int multiplier = i % 9 + 1;

      frequency = multiplier * Mathf.Pow(10, power);

      return multiplier == 1;

    } 

    public static float MapFrequency(float f, bool forward = true){

      return forward ? f < 10 ? 0 : Mathf.Log(f / 10, cutoff / 10) : 10 * Mathf.Pow(cutoff / 10, f);

    }

    private static string FrequencyToString(float frequency){

      if(frequency < 1000)
        return string.Format("{0:F0} Hz", frequency);
      else
        return string.Format("{0:F0} kHz", frequency * .001f);

    }

  }

  private const float rightMargin = 36;

  private SpectrumDrawer absorption, scattering, transmission;

  private void OnEnable(){

    GetSpectra(out absorption, out scattering, out transmission);

    absorption.LoadFoldoutState();
    scattering.LoadFoldoutState();
    transmission.LoadFoldoutState();
    
  }

  private void OnDisable(){
    
    absorption.SaveFoldoutState();
    scattering.SaveFoldoutState();
    transmission.SaveFoldoutState();

  }

  public override void OnInspectorGUI(){

    ONSPPropagationMaterial material = target as ONSPPropagationMaterial;

    EditorGUI.BeginChangeCheck();

    Rect r = EditorGUILayout.GetControlRect();
    r.width -= rightMargin;

       ONSPPropagationMaterial.Preset newPreset =
      (ONSPPropagationMaterial.Preset)EditorGUI.EnumPopup(r, "Preset", material.preset);

    Event e = Event.current;
    EventType type = e.type;
    absorption.Draw(e);
    scattering.Draw(e);
    transmission.Draw(e);
    
    if(EditorGUI.EndChangeCheck()){

      string groupName = Undo.GetCurrentGroupName();

      Undo.RegisterCompleteObjectUndo(material, groupName);

      if(groupName == "Point Added")
        Undo.CollapseUndoOperations(Undo.GetCurrentGroup() - 1);

      if(material.preset != newPreset)
        material.preset = newPreset;
      else
        material.preset = ONSPPropagationMaterial.Preset.Custom;

      if(Application.isPlaying)
        material.UploadMaterial();

    }

  }

  private void GetSpectra(out SpectrumDrawer absorption,
                          out SpectrumDrawer scattering,
                          out SpectrumDrawer transmission){

    ONSPPropagationMaterial material = target as ONSPPropagationMaterial;

    absorption = new SpectrumDrawer("Absorption", material.absorption, AxisScale.Sqr);
    scattering = new SpectrumDrawer("Scattering", material.scattering, AxisScale.Lin);
    transmission = new SpectrumDrawer("Transmission", material.transmission, AxisScale.Sqr);

  }

}