add unityUtils

master
yuan 8 years ago
parent e0b79c3999
commit 283713b199
  1. 3
      .gitmodules
  2. 4
      Unity_2018_Frozen/Assets/Frozen/DSAsset.meta
  3. 2997
      Unity_2018_Frozen/Assets/Frozen/FrozenTwo.unity
  4. 5
      Unity_2018_Frozen/Assets/Frozen/FrozenTwo.unity.meta
  5. 16
      Unity_2018_Frozen/Assets/Frozen/Script/CharacterBehaviour.cs
  6. 4
      Unity_2018_Frozen/Assets/Frozen/Script/CharacterBehaviour.cs.meta
  7. 76
      Unity_2018_Frozen/Assets/Frozen/Script/ForzenScreenToWorldSpace.cs
  8. 4
      Unity_2018_Frozen/Assets/Frozen/Script/ForzenScreenToWorldSpace.cs.meta
  9. 38
      Unity_2018_Frozen/Assets/UC/ImageEffect/ImageEffectHelper.cs
  10. 10
      Unity_2018_Frozen/Assets/UC/Spout/Editor.meta
  11. 134
      Unity_2018_Frozen/Assets/UC/Spout/Editor/SpoutReceiverEditor.cs
  12. 8
      Unity_2018_Frozen/Assets/UC/Spout/Editor/SpoutReceiverEditor.cs.meta
  13. 162
      Unity_2018_Frozen/Assets/UC/Spout/ImageEffectSpoutSender.cs
  14. 10
      Unity_2018_Frozen/Assets/UC/Spout/Plugins.meta
  15. BIN
      Unity_2018_Frozen/Assets/UC/Spout/Plugins/NativeSpoutPlugin_2_006.dll
  16. 26
      Unity_2018_Frozen/Assets/UC/Spout/Plugins/NativeSpoutPlugin_2_006.dll.meta
  17. 10
      Unity_2018_Frozen/Assets/UC/Spout/Script.meta
  18. 31
      Unity_2018_Frozen/Assets/UC/Spout/Script/InvertCamera.cs
  19. 8
      Unity_2018_Frozen/Assets/UC/Spout/Script/InvertCamera.cs.meta
  20. 563
      Unity_2018_Frozen/Assets/UC/Spout/Script/Spout.cs
  21. 8
      Unity_2018_Frozen/Assets/UC/Spout/Script/Spout.cs.meta
  22. 201
      Unity_2018_Frozen/Assets/UC/Spout/Script/SpoutReceiver.cs
  23. 8
      Unity_2018_Frozen/Assets/UC/Spout/Script/SpoutReceiver.cs.meta
  24. 236
      Unity_2018_Frozen/Assets/UC/Spout/Script/SpoutSender.cs
  25. 8
      Unity_2018_Frozen/Assets/UC/Spout/Script/SpoutSender.cs.meta
  26. 82
      Unity_2018_Frozen/Assets/UC/Spout/Script/TextureInfo.cs
  27. 8
      Unity_2018_Frozen/Assets/UC/Spout/Script/TextureInfo.cs.meta
  28. 10
      Unity_2018_Frozen/Assets/UC/Spout/Shader.meta
  29. 63
      Unity_2018_Frozen/Assets/UC/Spout/Shader/AlphaPremultiplied.shader
  30. 9
      Unity_2018_Frozen/Assets/UC/Spout/Shader/AlphaPremultiplied.shader.meta
  31. 10
      Unity_2018_Frozen/Assets/Unity-Technologies.meta
  32. 10
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing.meta
  33. 9
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources.meta
  34. 9
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/Monitors.meta
  35. 91
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/Monitors/HistogramCompute.compute
  36. 9
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/Monitors/HistogramCompute.compute.meta
  37. 141
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/Monitors/HistogramRender.shader
  38. 9
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/Monitors/HistogramRender.shader.meta
  39. 76
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/Monitors/ParadeRender.shader
  40. 9
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/Monitors/ParadeRender.shader.meta
  41. 49
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/Monitors/VectorscopeCompute.compute
  42. 9
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/Monitors/VectorscopeCompute.compute.meta
  43. 101
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/Monitors/VectorscopeRender.shader
  44. 9
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/Monitors/VectorscopeRender.shader.meta
  45. 42
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/Monitors/WaveformCompute.compute
  46. 9
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/Monitors/WaveformCompute.compute.meta
  47. 65
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/Monitors/WaveformRender.shader
  48. 9
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/Monitors/WaveformRender.shader.meta
  49. 9
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/UI.meta
  50. 63
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/UI/CurveBackground.shader
  51. 9
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/UI/CurveBackground.shader.meta
  52. BIN
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/UI/MotionBlendingIcon.png
  53. 59
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/UI/MotionBlendingIcon.png.meta
  54. 118
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/UI/Trackball.shader
  55. 9
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/UI/Trackball.shader.meta
  56. 9
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor.meta
  57. 9
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Attributes.meta
  58. 16
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Attributes/PostProcessingModelEditorAttribute.cs
  59. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Attributes/PostProcessingModelEditorAttribute.cs.meta
  60. 9
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models.meta
  61. 42
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/AmbientOcclusionModelEditor.cs
  62. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/AmbientOcclusionModelEditor.cs.meta
  63. 71
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/AntialiasingModelEditor.cs
  64. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/AntialiasingModelEditor.cs.meta
  65. 204
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/BloomModelEditor.cs
  66. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/BloomModelEditor.cs.meta
  67. 106
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/BuiltinDebugViewsEditor.cs
  68. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/BuiltinDebugViewsEditor.cs.meta
  69. 9
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/ChromaticAberrationEditor.cs
  70. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/ChromaticAberrationEditor.cs.meta
  71. 672
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/ColorGradingModelEditor.cs
  72. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/ColorGradingModelEditor.cs.meta
  73. 22
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/DefaultPostFxModelEditor.cs
  74. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/DefaultPostFxModelEditor.cs.meta
  75. 37
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/DepthOfFieldModelEditor.cs
  76. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/DepthOfFieldModelEditor.cs.meta
  77. 16
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/DitheringModelEditor.cs
  78. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/DitheringModelEditor.cs.meta
  79. 86
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/EyeAdaptationModelEditor.cs
  80. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/EyeAdaptationModelEditor.cs.meta
  81. 24
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/FogModelEditor.cs
  82. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/FogModelEditor.cs.meta
  83. 31
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/GrainModelEditor.cs
  84. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/GrainModelEditor.cs.meta
  85. 197
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/MotionBlurModelEditor.cs
  86. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/MotionBlurModelEditor.cs.meta
  87. 100
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/ScreenSpaceReflectionModelEditor.cs
  88. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/ScreenSpaceReflectionModelEditor.cs.meta
  89. 87
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/UserLutModelEditor.cs
  90. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/UserLutModelEditor.cs.meta
  91. 118
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/VignetteModelEditor.cs
  92. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Models/VignetteModelEditor.cs.meta
  93. 9
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Monitors.meta
  94. 338
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Monitors/HistogramMonitor.cs
  95. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Monitors/HistogramMonitor.cs.meta
  96. 257
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Monitors/ParadeMonitor.cs
  97. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Monitors/ParadeMonitor.cs.meta
  98. 241
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Monitors/VectorscopeMonitor.cs
  99. 12
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Monitors/VectorscopeMonitor.cs.meta
  100. 280
      Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor/Monitors/WaveformMonitor.cs
  101. Some files were not shown because too many files have changed in this diff Show More

3
.gitmodules vendored

@ -0,0 +1,3 @@
[submodule "Unity_2018_Frozen/Assets/UnityUtils"]
path = Unity_2018_Frozen/Assets/UnityUtils
url = https://github.com/UltraCombos/UnityUtils.git

@ -1,7 +1,7 @@
fileFormatVersion: 2 fileFormatVersion: 2
guid: 3c24a6e89bc1e5845bab4a6310533a9a guid: a00c6450d99200d4f8938cb09f31039c
folderAsset: yes folderAsset: yes
timeCreated: 1519718036 timeCreated: 1524205618
licenseType: Free licenseType: Free
DefaultImporter: DefaultImporter:
externalObjects: {} externalObjects: {}

File diff suppressed because it is too large Load Diff

@ -1,7 +1,6 @@
fileFormatVersion: 2 fileFormatVersion: 2
guid: 438d30f1dd2dce645b6eeba39adebb21 guid: 1b6317c1f4756a047afe40601d11fd0f
folderAsset: yes timeCreated: 1524209993
timeCreated: 1519718036
licenseType: Free licenseType: Free
DefaultImporter: DefaultImporter:
externalObjects: {} externalObjects: {}

@ -0,0 +1,16 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class CharacterBehaviour : MonoBehaviour {
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
}

@ -1,6 +1,6 @@
fileFormatVersion: 2 fileFormatVersion: 2
guid: fda5366b87aa3934a8e5823faa38f54c guid: 12ea4d85cdda0aa4981a82e5e18fed52
timeCreated: 1519718036 timeCreated: 1524131091
licenseType: Free licenseType: Free
MonoImporter: MonoImporter:
externalObjects: {} externalObjects: {}

@ -0,0 +1,76 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class ForzenScreenToWorldSpace : MonoBehaviour {
public enum Area
{
LeftWall,
RightWall,
TopWall,
Floor
}
public float width = 1800;
public float length = 2880;
public float height = 1080;
public float blackLength = 320;
[System.Serializable]
public class RenderTextureROI
{
public float X;
public float Y;
public float ROI_X;
public float ROI_Y;
public RenderTextureROI(float x, float y, float roi_x, float roi_y)
{
X = x;
Y = y;
ROI_X = roi_x;
ROI_Y = roi_y;
}
public RenderTextureROI() { }
}
[SerializeField]
RenderTextureROI LeftWall = new RenderTextureROI();
[SerializeField]
RenderTextureROI TopWall = new RenderTextureROI();
[SerializeField]
RenderTextureROI RightWall = new RenderTextureROI();
[SerializeField]
RenderTextureROI Floor = new RenderTextureROI();
Dictionary<Area,RenderTextureROI> RenderTextureROIList = new Dictionary<Area, RenderTextureROI>();
private float totalLength;
private float totalWidth;
// Use this for initialization
void Start()
{
InitailROISetting();
}
void InitailROISetting()
{
totalLength = height * 2 + length;
totalWidth = height + width + blackLength;
LeftWall = new RenderTextureROI(0, height / totalWidth, height / totalLength, width / totalWidth);
RightWall = new RenderTextureROI((height + length) / totalLength, height / totalWidth, height / totalLength, width / totalWidth);
TopWall = new RenderTextureROI((height) / totalLength, 0, length / totalLength, height / totalWidth);
Floor = new RenderTextureROI(height / totalLength, height / totalWidth, length / totalLength, width / totalWidth);
RenderTextureROIList.Add(Area.LeftWall,LeftWall);
RenderTextureROIList.Add(Area.RightWall,RightWall);
RenderTextureROIList.Add(Area.TopWall,TopWall);
RenderTextureROIList.Add(Area.Floor,Floor);
}
public RenderTextureROI GetROI(Area area)
{
if (RenderTextureROIList.ContainsKey(area))
return RenderTextureROIList[area];
return null;
}
}

@ -1,6 +1,6 @@
fileFormatVersion: 2 fileFormatVersion: 2
guid: 4478085da62a4434092a27edc6d9ea19 guid: 459796dd748d9e144be3b07d1e653918
timeCreated: 1519718102 timeCreated: 1523936729
licenseType: Free licenseType: Free
MonoImporter: MonoImporter:
externalObjects: {} externalObjects: {}

@ -1,38 +0,0 @@
using UnityEngine;
namespace UltraCombos
{
public static class ImageEffectHelper
{
public static bool IsSupported(Shader s, bool needDepth, bool needHdr, MonoBehaviour effect)
{
if (s == null || !s.isSupported)
{
Debug.Log("shader is: " + s);
Debug.LogWarningFormat("Missing shader for image effect {0}", effect);
return false;
}
if (!SystemInfo.supportsImageEffects)
return false;
if (needDepth && !SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.Depth))
return false;
if (needHdr && !SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.ARGBHalf))
return false;
return true;
}
public static Material CheckShaderAndCreateMaterial(Shader s)
{
if (s == null || !s.isSupported)
return null;
var material = new Material(s);
material.hideFlags = HideFlags.DontSave;
return material;
}
}
}

@ -1,10 +0,0 @@
fileFormatVersion: 2
guid: a2035f0c1fe429d40aab433a48073422
folderAsset: yes
timeCreated: 1519718036
licenseType: Free
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

@ -1,134 +0,0 @@
/*
* Spout4Unity
* Copyright © 2014-2015 Benjamin Kuperberg
* Copyright © 2015 Stefan Schlupek
* All rights reserved
*/
using UnityEngine;
using System.Collections;
using UnityEditor;
using System;
namespace Spout{
[CustomEditor(typeof(SpoutReceiver))]
[CanEditMultipleObjects]
[Serializable]
public class SpoutReceiverEditor : Editor {
SpoutReceiver receiver;
[SerializeField]
private int _popupIndex;
string[] options;
string currentName;
void OnEnable()
{
if(receiver == null)
{
receiver = target as SpoutReceiver;
Spout.instance.addListener(texShared,senderStopped);
updateOptions();
}
//Debug.Log ("Enable popup Index : "+popupIndex);
}
void OnDisable(){
//if(target == null)return;
Spout.removeListener(texShared,senderStopped);
}
public void texShared(TextureInfo texInfo)
{
//Debug.Log ("Editor : senderStarted :"+texInfo.name);
updateOptions();
}
public void senderStopped(TextureInfo texInfo)
{
//Debug.Log ("Editor : senderStopped :"+texInfo.name);
updateOptions();
}
void updateOptions(bool assignNewName = true)
{
string oldSharingName = receiver.sharingName;
int newPopupIndex = 0;
bool found = false;
options = new string[Spout.instance.activeSenders.Count+2];
options[0] = "Any";
for(int i=0;i<Spout.instance.activeSenders.Count;i++)
{
string currentName = Spout.instance.activeSenders[i].name;
options[i+1] = currentName;
if(currentName == oldSharingName && oldSharingName != "Any")
{
found = true;
newPopupIndex = i+1;
}
}
options[options.Length-1] = "Other (specify)";
if(!found)
{
newPopupIndex = (oldSharingName != "Any")?options.Length-1:0;
}
popupIndex = newPopupIndex;
setNameFromPopup();
}
public override void OnInspectorGUI()
{
//if(target == null)return;
//if(Spout2.instance == null)return;
//serializedObject.Update();
int selectedIndex = EditorGUILayout.Popup("Select sender",_popupIndex,options);
if(selectedIndex == options.Length-1)//other
{
_popupIndex = selectedIndex; //silent update
receiver.sharingName = EditorGUILayout.TextField("Sender name",receiver.sharingName);
} else
{
popupIndex = selectedIndex;
}
//receiver.debugConsole = EditorGUILayout.Toggle("Debug Console",receiver.debugConsole);
serializedObject.ApplyModifiedProperties();
}
void setNameFromPopup()
{
if(popupIndex < options.Length -1)
{
receiver.sharingName = options[popupIndex];
}
}
int popupIndex
{
get { return _popupIndex;}
set {
if(popupIndex == value) return;
_popupIndex = value;
setNameFromPopup();
}
}
}
}

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: faca4b0692d8eff4fa85aa07f397b55f
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:

@ -1,162 +0,0 @@
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Spout;
namespace UltraCombos
{
public class ImageEffectSpoutSender : MonoBehaviour
{
public string sharingName = "UnitySender";
public Spout.Spout.TextureFormat textureFormat = Spout.Spout.TextureFormat.DXGI_FORMAT_R8G8B8A8_UNORM;
public bool yFlip = true;
[SerializeField]
[Header("Automatic")]
RenderTexture output;
private bool senderIsCreated;
private const int _createAttempts = 5;
private int _attempts = 0;
private bool textureSizeHasChanged = false;
[SerializeField]
private Shader m_Shader;
public Shader shader
{
get
{
if (m_Shader == null)
m_Shader = Shader.Find("Unlit/AlphaPremultiplied");
return m_Shader;
}
}
private Material m_Material;
public Material material
{
get
{
if (m_Material == null)
m_Material = ImageEffectHelper.CheckShaderAndCreateMaterial(shader);
return m_Material;
}
}
private void OnEnable()
{
if (!ImageEffectHelper.IsSupported(shader, false, false, this))
enabled = false;
}
void OnRenderImage(RenderTexture s, RenderTexture d)
{
bool isValid = (output != null) && s.width == output.width && s.height == output.height;
if (!isValid)
{
if (output != null)
output.Release();
output = new RenderTexture(s.width, s.height, s.depth, RenderTextureFormat.ARGB32);
output.Create();
}
textureSizeHasChanged = !isValid;
//if (s.format == output.format)
// Graphics.CopyTexture(s, output);
//else
material.SetInt("yFlip", yFlip?1:0);
Graphics.Blit(s, output, material);
Graphics.Blit(s, d);
}
void OnDisable()
{
_CloseSender();
if (m_Material != null)
DestroyImmediate(m_Material);
m_Material = null;
}
void Update()
{
if (output == null) return;
if (textureSizeHasChanged) _CloseSender();
if (senderIsCreated)
Spout.Spout.instance.UpdateSender(sharingName, output);
else
_CreateSender(output);
}
private void _CreateSender(Texture texture)
{
if (texture == null) return;
if (!Spout.Spout.instance.enabled) return;
if (!senderIsCreated)
{
Debug.Log("Sender is not created, creating one");
senderIsCreated = Spout.Spout.instance.CreateSender(sharingName, texture, (int)textureFormat);
}
_attempts++;
if (_attempts > _createAttempts)
Debug.LogWarning(System.String.Format("There are problems with creating the sender {0}. Please check your settings or restart Unity.", sharingName));
Spout.Spout.instance.OnSenderStopped -= OnSenderStoppedDelegate;
Spout.Spout.instance.OnSenderStopped += OnSenderStoppedDelegate;
Spout.Spout.instance.OnAllSendersStopped -= OnAllSendersStoppedDelegate;
Spout.Spout.instance.OnAllSendersStopped += OnAllSendersStoppedDelegate;
Spout.Spout.instance.OnEnabled -= _OnSpoutEnabled;
Spout.Spout.instance.OnEnabled += _OnSpoutEnabled;
}
private void _OnSpoutEnabled()
{
//Debug.Log("SpoutSender._OnSpoutEnabled");
if (enabled)
{
//force a reconnection
enabled = !enabled;
enabled = !enabled;
}
}
private void _CloseSender()
{
Debug.Log("SpoutSender._CloseSender:" + sharingName);
if (senderIsCreated) Spout.Spout.CloseSender(sharingName);
_CloseSenderCleanUpData();
}
private void OnSenderStoppedDelegate(object sender, TextureShareEventArgs e)
{
//Debug.Log("SpoutSender.OnSenderStoppedDelegate:"+e.sharingName);
if (e.sharingName == sharingName)
{
_CloseSenderCleanUpData();
}
}
private void OnAllSendersStoppedDelegate()
{
_CloseSenderCleanUpData();
}
private void _CloseSenderCleanUpData()
{
senderIsCreated = false;
}
}
}

@ -1,10 +0,0 @@
fileFormatVersion: 2
guid: 6f9e9f23a55e0a448a966afc8ab70b38
folderAsset: yes
timeCreated: 1519718036
licenseType: Free
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

@ -1,26 +0,0 @@
fileFormatVersion: 2
guid: cec45db527098eb4287a0588eb52d8b3
timeCreated: 1519718037
licenseType: Free
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
isPreloaded: 0
isOverridable: 0
platformData:
- first:
Any:
second:
enabled: 1
settings: {}
- first:
Editor: Editor
second:
enabled: 0
settings:
DefaultValueInitialized: true
userData:
assetBundleName:
assetBundleVariant:

@ -1,10 +0,0 @@
fileFormatVersion: 2
guid: 522a75675411ba843961da4d443d11b8
folderAsset: yes
timeCreated: 1519718036
licenseType: Free
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

@ -1,31 +0,0 @@
//http://docs.unity3d.com/412/Documentation/ScriptReference/Camera.OnPreCull.html
using UnityEngine;
using System.Collections;
namespace Spout{
[RequireComponent (typeof(Camera))]
[ExecuteInEditMode]
public class InvertCamera : MonoBehaviour {
//public Camera camera;
void Start () {
//camera = get
}
void OnPreCull () {
GetComponent<Camera>().ResetWorldToCameraMatrix();
GetComponent<Camera>().ResetProjectionMatrix();
GetComponent<Camera>().projectionMatrix = GetComponent<Camera>().projectionMatrix * Matrix4x4.Scale(new Vector3(1, -1, 1));
}
void OnPreRender () {
GL.invertCulling = true;
}
void OnPostRender () {
GL.invertCulling = false;
}
}
}

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: b88f1d1faa35b574594171c19a0f6d30
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:

@ -1,563 +0,0 @@
/*
* Spout4Unity
* Copyright © 2014-2015 Benjamin Kuperberg
* Copyright © 2015 Stefan Schlupek
* All rights reserved
*/
using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Linq;
namespace Spout
{
[ExecuteInEditMode]
public class Spout : MonoBehaviour
{
#region public
public event EventHandler<TextureShareEventArgs> OnSenderStopped;
public event Action OnEnabled;
public event Action OnAllSendersStopped;
public delegate void TextureSharedDelegate(TextureInfo texInfo);
public TextureSharedDelegate texSharedDelegate;
public delegate void SenderStoppedDelegate(TextureInfo texInfo);
public SenderStoppedDelegate senderStoppedDelegate;
public List<TextureInfo> activeSenders;
public List<TextureInfo> activeLocalSenders;
public HashSet<string> localSenderNames;
public static bool isInit
{
get { return _isInit; }
}
public static bool isEnabledInEditor
{
get
{
return _instance == null ? false : _instance._isEnabledInEditor;
//return _isEnabledInEditor;
}
}
//You can use a fakeName of your choice .It's just to force an update in the Spout Receiver at start even if the 'offical' sharingName doesn't change.
public static string fakeName = "SpoutIsSuperCoolAndMakesFun";
public enum TextureFormat { DXGI_FORMAT_R32G32B32A32_FLOAT = 2, DXGI_FORMAT_R10G10B10A2_UNORM = 24, DXGI_FORMAT_R8G8B8A8_UNORM = 28, DXGI_FORMAT_B8G8R8A8_UNORM = 87 }
#endregion
#region private
private IntPtr intptr_senderUpdate_delegate;
private IntPtr intptr_senderStarted_delegate;
private IntPtr intptr_senderStopped_delegate;
// Use GCHandle to hold the delegate object in memory.
private GCHandle handleSenderUpdate;
private GCHandle handleSenderStarted;
private GCHandle handleSenderStopped;
#pragma warning disable 414
[SerializeField]
private static bool _isInit;
[SerializeField]
private bool _isEnabledInEditor;
#pragma warning restore 414
private static bool isReceiving;
private List<TextureInfo> newSenders;
private List<TextureInfo> stoppedSenders;
[SerializeField]
private static Spout _instance;
#pragma warning disable 414
//In EditMode we have to force the camera to render.But as this is called 100 times per second beware of your performance, so we only render at a special interval
private int _editorUpdateFrameInterval = 3;
#pragma warning restore 414
private int _frameCounter;
#endregion
[SerializeField]
private static Texture2D _nullTexture;
public static Texture2D nullTexture
{
get { return _nullTexture; }
}
public static Spout instance
{
get
{
if (_instance == null)
{
_instance = GameObject.FindObjectOfType<Spout>();
if (_instance == null)
{
GameObject _go = new GameObject("Spout");
_instance = _go.AddComponent<Spout>();
}
//DontDestroyOnLoad(_instance.gameObject);
}
return _instance;
}
private set { _instance = value; }
}
//
public void Awake()
{
Debug.Log("Spout.Awake");
if (_instance != null && _instance != this)
{
//Debug.Log("Spout.Awake.Destroy");
#if UNITY_EDITOR
DestroyImmediate(this.gameObject);
#else
Destroy(this.gameObject);
#endif
return;
}
newSenders = new List<TextureInfo>();
stoppedSenders = new List<TextureInfo>();
activeSenders = new List<TextureInfo>();
activeLocalSenders = new List<TextureInfo>();
localSenderNames = new HashSet<string>();
_nullTexture = new Texture2D(32, 32);
_nullTexture.hideFlags = HideFlags.HideAndDontSave;
}
public void OnEnable()
{
//Debug.Log("Spout.OnEnable");
if (_instance != null && _instance != this)
{
//Debug.Log("Spout.OnEnable.Destroy");
#if UNITY_EDITOR
DestroyImmediate(this.gameObject);
#else
Destroy(this.gameObject);
#endif
return;
}
newSenders = new List<TextureInfo>();
stoppedSenders = new List<TextureInfo>();
activeSenders = new List<TextureInfo>();
activeLocalSenders = new List<TextureInfo>();
localSenderNames = new HashSet<string>();
#if UNITY_EDITOR
if (_isEnabledInEditor || Application.isPlaying)
{
_Enable();
}
#else
_Enable();
#endif
}
private void _Enable()
{
//Debug.Log("Spout._Enable");
#if UNITY_EDITOR
if (!Application.isPlaying)
{
UnityEditor.EditorApplication.update -= _Update;
UnityEditor.EditorApplication.update += _Update;
}
#endif
_Init();
//notify others so they can re-initialize
if (OnEnabled != null) OnEnabled();
}
private void _Disable()
{
}
private void _Init()
{
//Debug.Log("Spout._Init");
initNative();
//Debug.Log("isReceiving:+"+isReceiving);
_startReceiving();
_isInit = true;
//if(debug) initDebugConsole();
}
void Update()
{
//if(_instance == null || _instance != this ) return;
_Update();
}
private void _Update()
{
#if UNITY_EDITOR
_frameCounter++;
_frameCounter %= _editorUpdateFrameInterval;
if (_frameCounter == 0)
{
UnityEditor.SceneView.RepaintAll();
}
#endif
if (isReceiving)
{
//Debug.Log("checkReceivers");
checkReceivers();
}
lock (this)
{
foreach (TextureInfo s in newSenders)
{
//Debug.Log("texSharedDelegate");
activeSenders.Add(s);
if (texSharedDelegate != null) texSharedDelegate(s);
}
newSenders.Clear();
foreach (TextureInfo s in stoppedSenders)
{
foreach (TextureInfo t in activeSenders)
{
if (s.name == t.name)
{
activeSenders.Remove(t);
break;
}
}
//Debug.Log ("Stopped sender from Spout :"+s.name);
if (senderStoppedDelegate != null) senderStoppedDelegate(s);
}
stoppedSenders.Clear();
}//lock
}
public void OnDisable()
{
//Debug.Log("Spout.OnDisable");
if (_instance != this) return;
#if UNITY_EDITOR
UnityEditor.EditorApplication.update -= _Update;
#endif
StopAllLocalSenders();
//Force the Plugin to check. Otherwise we don't get a SenderStopped delegate call
Update();
//Debug.Log("Spout.OnDisable.End");
}
void OnDestroy()
{
//Debug.Log("Spout.OnDestroy");
if (_instance != this) return;
if (_isInit)
{
_CleanUpResources();
}
isReceiving = false;
_isInit = false;
newSenders = null;
stoppedSenders = null;
activeSenders = null;
activeLocalSenders = null;
localSenderNames = null;
OnEnabled = null;
OnSenderStopped = null;
_instance = null;
GC.Collect();//??
}
private void _CleanUpResources()
{
clean();
_instance.texSharedDelegate = null;
_instance.senderStoppedDelegate = null;
_instance.handleSenderUpdate.Free();
_instance.handleSenderStarted.Free();
_instance.handleSenderStopped.Free();
intptr_senderUpdate_delegate = IntPtr.Zero;
intptr_senderStarted_delegate = IntPtr.Zero;
intptr_senderStopped_delegate = IntPtr.Zero;
}
public void addListener(TextureSharedDelegate sharedCallback, SenderStoppedDelegate stoppedCallback)
{
// Debug.Log ("Spout.addListener");
if (_instance == null) return;
_instance.texSharedDelegate += sharedCallback;
_instance.senderStoppedDelegate += stoppedCallback;
}
public static void removeListener(TextureSharedDelegate sharedCallback, SenderStoppedDelegate stoppedCallback)
{
// Debug.Log ("Spout.removeListener");
if (_instance == null) return;
_instance.texSharedDelegate -= sharedCallback;
_instance.senderStoppedDelegate -= stoppedCallback;
}
public bool CreateSender(string sharingName, Texture tex, int texFormat = 1)
{
if (!enabled) return false;
if (!_isInit) return false;
#if UNITY_EDITOR
if (!Application.isPlaying && !_isEnabledInEditor) return false;
#endif
IntPtr p_tex = tex.GetNativeTexturePtr();
if (p_tex == IntPtr.Zero)
{
Debug.Log("[WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING]");
Debug.Log("Spout.UpdateSender:" + sharingName + " NativeTexturePtr is NULL !!!");
Debug.Log("[WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING]");
return false;
}
Debug.Log("Spout.CreateSender:" + sharingName + "::" + p_tex.ToInt32());
bool result = createSenderNative(sharingName, p_tex, texFormat);
if (result)
{
//Debug.Log (String.Format("Spout sender creation with name {0} success !",sharingName));
localSenderNames.Add(sharingName);
}
else
{
Debug.LogWarning(String.Format("createSenderNative(): Spout sender creation with name {0} failed !", sharingName));
}
return result;
}
public bool UpdateSender(string sharingName, Texture tex)
{
if (enabled == false || gameObject.activeInHierarchy == false || _isInit == false) return false;
//Debug.Log("Spout.UpdateSender:"+sharingName+"::"+tex.GetNativeTexturePtr().ToInt32());
IntPtr p_tex = tex.GetNativeTexturePtr();
if (p_tex == IntPtr.Zero)
{
Debug.Log("[WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING]");
Debug.Log("Spout.UpdateSender:" + sharingName + " NativeTexturePtr is NULL !!!");
Debug.Log("[WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING]");
return false;
}
return updateSenderNative(sharingName, p_tex);
}
public TextureInfo getTextureInfo(string sharingName)
{
if (activeSenders == null) return null;
foreach (TextureInfo tex in activeSenders)
{
if (tex.name == sharingName) return tex;
}
if (sharingName != Spout.fakeName) Debug.Log(String.Format("sharing name {0} not found", sharingName));
return null;
}
private const string SpoutVersion = "2_006";
private const string SpoutLibNameBase = "NativeSpoutPlugin";
private const string SpoutLibName = SpoutLibNameBase + "_" + SpoutVersion;
#if DEVELOPMENT_BUILD
public const string SpoutLibImport = SpoutLibName + "_Debug";
#else
public const string SpoutLibImport = SpoutLibName;
#endif
//Imports
[DllImport(SpoutLibImport, EntryPoint = "init")]
public static extern bool initNative();
[DllImport(SpoutLibImport, EntryPoint = "initDebugConsole")]
private static extern void _initDebugConsole();
[DllImport(SpoutLibImport)]
private static extern void checkReceivers();
[DllImport(SpoutLibImport, EntryPoint = "createSender")]
private static extern bool createSenderNative(string sharingName, IntPtr texture, int texFormat);
[DllImport(SpoutLibImport, EntryPoint = "updateSender")]
private static extern bool updateSenderNative(string sharingName, IntPtr texture);
[DllImport(SpoutLibImport, EntryPoint = "closeSender")]
public static extern bool CloseSender(string sharingName);
[DllImport(SpoutLibImport)]
private static extern void clean();
[DllImport(SpoutLibImport, EntryPoint = "startReceiving")]
private static extern bool startReceivingNative(IntPtr senderUpdateHandler, IntPtr senderStartedHandler, IntPtr senderStoppedHandler);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void SpoutSenderUpdateDelegate(int numSenders);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void SpoutSenderStartedDelegate(string senderName, IntPtr resourceView, int textureWidth, int textureHeight);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void SpoutSenderStoppedDelegate(string senderName);
public void initDebugConsole()
{
//check if multiple inits?
_initDebugConsole();
}
private void _startReceiving()
{
if (isReceiving) return;
//Debug.Log("Spout.startReceiving");
SpoutSenderUpdateDelegate senderUpdate_delegate = new SpoutSenderUpdateDelegate(SenderUpdate);
handleSenderUpdate = GCHandle.Alloc(senderUpdate_delegate);
intptr_senderUpdate_delegate = Marshal.GetFunctionPointerForDelegate(senderUpdate_delegate);
SpoutSenderStartedDelegate senderStarted_delegate = new SpoutSenderStartedDelegate(SenderStarted);
handleSenderStarted = GCHandle.Alloc(senderStarted_delegate);
intptr_senderStarted_delegate = Marshal.GetFunctionPointerForDelegate(senderStarted_delegate);
SpoutSenderStoppedDelegate senderStopped_delegate = new SpoutSenderStoppedDelegate(SenderStopped);
handleSenderStopped = GCHandle.Alloc(senderStopped_delegate);
intptr_senderStopped_delegate = Marshal.GetFunctionPointerForDelegate(senderStopped_delegate);
isReceiving = startReceivingNative(intptr_senderUpdate_delegate, intptr_senderStarted_delegate, intptr_senderStopped_delegate);
}
private void SenderUpdate(int numSenders)
{
//Debug.Log("Sender update, numSenders : "+numSenders);
}
private void SenderStarted(string senderName, IntPtr resourceView, int textureWidth, int textureHeight)
{
Debug.Log("Spout. Sender started, sender name : " + senderName);
if (_instance == null || _instance.activeLocalSenders == null || _instance.newSenders == null) return;
lock (this)
{
TextureInfo texInfo = new TextureInfo(senderName);
Debug.Log("resourceView:" + resourceView.ToInt32());
texInfo.setInfos(textureWidth, textureHeight, resourceView);
_instance.newSenders.Add(texInfo);
if (_instance.localSenderNames.Contains(texInfo.name))
{
_instance.activeLocalSenders.Add(texInfo);
//Debug.Log("activeLocalSenders.count:"+_instance.activeLocalSenders.Count);
}
Debug.Log("Spout.SenderStarted.End");
}//lock
}
private void SenderStopped(string senderName)
{
Debug.Log("Sender stopped, sender name : " + senderName);
if (_instance == null || _instance.activeLocalSenders == null || _instance.stoppedSenders == null) return;
lock (this)
{
TextureInfo texInfo = new TextureInfo(senderName);
_instance.stoppedSenders.Add(texInfo);
_instance.localSenderNames.Remove(texInfo.name);
if (_instance.activeLocalSenders.Contains(texInfo))
{
_instance.activeLocalSenders.Remove(texInfo);
}
}//lock
//Debug.Log("localSenderNames.count:"+instance.localSenderNames.Count);
//Debug.Log("activeLocalSenders.count:"+instance.activeLocalSenders.Count);
}
private void StopAllLocalSenders()
{
Debug.Log("Spout.StopAllLocalSenders()");
if (_instance == null) return;
foreach (TextureInfo t in _instance.activeLocalSenders)
{
CloseSender(t.name);
if (OnSenderStopped != null) OnSenderStopped(this, new TextureShareEventArgs(t.name));
/*
double i = 0;
while(i< 100000000){
i++;
}
*/
}
if (OnAllSendersStopped != null) OnAllSendersStopped();
}
}
public class TextureShareEventArgs : EventArgs
{
public string sharingName { get; set; }
public TextureShareEventArgs(string myString)
{
this.sharingName = myString;
}
}
}

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: aa175692d4b749244b474315598e4d14
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:

@ -1,201 +0,0 @@
/*
* Spout4Unity
* Copyright © 2014-2015 Benjamin Kuperberg
* Copyright © 2015 Stefan Schlupek
* All rights reserved
*/
using UnityEngine;
using System.Collections;
using System;
namespace Spout{
[Serializable]
[ExecuteInEditMode]
public class SpoutReceiver : MonoBehaviour {
[SerializeField]
private string _sharingName;
private Texture2D _texture;
// leave false in this version!
//private bool debugConsole = false;
private bool _receiverIsReady;
//If you have want to prevent the Console warnings about not existing Senders just turn on the StartupDelay and specify the frame delay
private bool _startupDelay = true;
//how many frames of delay
private int _startupFramesDelay = 0;
private int _startUpFrameCount;
private string _tempName;
// Use this for initialization
void Awake () {
// Debug.Log("SpoutReceiver.Awake");
//if(debugConsole) Spout2.instance.initDebugConsole();
}
void Start()
{
}
void OnEnable(){
//Debug.Log("SpoutReceiver.OnEnable");
//Add the listener immediately to get the events when Unity starts and the Spout plugin initialize.
//Otherwise the external Spout Senders have to start afterwards to trigger the native plugin events
Spout.instance.addListener(TexShared,TexStopped);
#if UNITY_EDITOR
if(!Application.isPlaying){
UnityEditor.EditorApplication.update -= _Update;
UnityEditor.EditorApplication.update += _Update;
}
#endif
_receiverIsReady = false;
_startUpFrameCount = 0;
if(!_startupDelay)_ForceTextureUpdate();
}
void OnDisable(){
//Debug.Log("SpoutReceiver.OnDisable");
#if UNITY_EDITOR
UnityEditor.EditorApplication.update -= _Update;
#endif
_receiverIsReady = false;
_startUpFrameCount = 0;
Spout.removeListener(TexShared,TexStopped);
texture = null;
GC.Collect();
}
void OnDestroy(){
//Debug.Log("SpoutReceiver.OnDestroy");
}
void Update(){
_Update();
}
// Update is called once per frame
void _Update () {
//if(texture == null)_createNullTexture();
if(!_startupDelay)return;
if(!_receiverIsReady){
_startUpFrameCount++;
if( _startUpFrameCount < _startupFramesDelay)return;
_ForceTextureUpdate();
}
}
private void _ForceTextureUpdate(){
//Debug.Log("SpoutReceiver._ForceTextureUpdate");
//Little hack to force an update of the Texture
_tempName = _sharingName;
sharingName = Spout.fakeName;
sharingName = _tempName;
_receiverIsReady = true;
}
public void TexShared(TextureInfo texInfo)
{
//Debug.Log("SpoutReceiver.texShared");
if(sharingName == "" || sharingName == texInfo.name || sharingName == "Any")
{
//Debug.Log("SpoutReceiver.texShared:"+texInfo.name);
texture = texInfo.getTexture();
}
}
public void TexStopped(TextureInfo texInfo)
{
//Debug.Log("SpoutReceiver.texStopped:"+texInfo.name);
if(texInfo.name == _sharingName)
{
//Debug.Log("SpoutReceiver.texStopped:"+texInfo.name);
texture = Spout.nullTexture;
}
else if(sharingName == "Any" && Spout.instance.activeSenders.Count > 0)
{
texture = Spout.instance.activeSenders[Spout.instance.activeSenders.Count-1].getTexture();
}
}
public Texture2D texture
{
get { return _texture; }
set {
_texture = value;
if(_texture == null) _texture = Spout.nullTexture;
#if false
try { GetComponent<Renderer>().sharedMaterial.mainTexture = _texture; } catch { }
try { GetComponent<UnityEngine.UI.RawImage>().texture = _texture; } catch { }
#else
if(GetComponent<Renderer>() != null)
{
GetComponent<Renderer>().sharedMaterial.mainTexture = _texture;
}
if (GetComponent<UnityEngine.UI.RawImage>() != null)
{
GetComponent<UnityEngine.UI.RawImage>().texture = _texture;
}
#endif
}
}
[SerializeField]
public string sharingName
{
get { return _sharingName; }
set {
if(_sharingName == value && sharingName != "Any") return;
_sharingName = value;
//Debug.Log("sharingName:"+_sharingName);
if(sharingName == "Any")
{
if(Spout.instance.activeSenders != null && Spout.instance.activeSenders.Count > 0)
{
texture = Spout.instance.activeSenders[Spout.instance.activeSenders.Count-1].getTexture();
}
}else
{
//Debug.Log ("Set sharing name :"+sharingName);
TextureInfo texInfo = Spout.instance.getTextureInfo(sharingName);
if(texInfo != null) {
texture = texInfo.getTexture ();
}
else
{
if(sharingName != Spout.fakeName)Debug.LogWarning ("Sender "+sharingName+" does not exist");
texture = Spout.nullTexture;
/*
texture = new Texture2D(32,32);
//new Texture2D(32,32,TextureFormat.RGBA32,true,true);
texture.hideFlags = HideFlags.HideAndDontSave;
*/
}
}
}
}
}
}

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 846b026f9a6af4049ae8cbc3b560f976
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:

@ -1,236 +0,0 @@
/*
* Spout4Unity
* Copyright © 2014-2015 Benjamin Kuperberg
* Copyright © 2015 Stefan Schlupek
* All rights reserved
*/
using UnityEngine;
using System.Collections;
using System;
namespace Spout
{
[Serializable]
[ExecuteInEditMode]
[Obsolete("This component is deprecated. Use ImageEffectSpoutSender component instead.", false)]
public class SpoutSender : MonoBehaviour
{
//according to dxgiformat.h :
//tested with DXGI_FORMAT_R8G8B8A8_UNORM (ATI Card)
public string sharingName = "UnitySender";
public Texture texture;
public Spout.TextureFormat textureFormat = Spout.TextureFormat.DXGI_FORMAT_R8G8B8A8_UNORM;
public bool debugConsole = false;
private bool senderIsCreated;
#if UNITY_EDITOR
private Camera _cam;
#endif
//make this public if you want
//It's better you set this always to true!
//There are problems with creating a sender at OnEnable at Editor/App Start time so we have a little delay hack that calls the CreateSender at Update()
private bool StartupDelay = true;
// if there are problems you can increase this value
private int _startupFramesDelay = 3;
private int _startUpFrameCount;
private int _createAttempts = 5;
private int _attempts = 0;
#pragma warning disable 414
//In EditMode we have to force the camera to render.But as this is called 100 times per second beware of your performance, so we only render at a specific interval
private int _editorUpdateFrameInterval = 10;
#pragma warning restore 414
private int _frameCounter;
void Awake()
{
//Debug.Log("SpoutSender.Awake");
//if(debugConsole) Spout2.instance.initDebugConsole();
#if UNITY_EDITOR
_cam = GetComponent<Camera>() as Camera;
#endif
}
void Start()
{
}
void OnEnable()
{
//Debug.Log("SpoutSender.OnEnable");
#if UNITY_EDITOR
if (!Application.isPlaying)
{
UnityEditor.EditorApplication.update -= _Update;
UnityEditor.EditorApplication.update += _Update;
}
#endif
if (debugConsole) Spout.instance.initDebugConsole();
_startUpFrameCount = 0;
_attempts = 0;
//Problem with creatingSender and disabled hosting Gameobject.(You always have to call OnEnable twice to get a Sender created)
//It's better to do the real createSender call at OnUpdate.
if (!StartupDelay) _CreateSender();
}
void OnDisable()
{
Debug.Log("SpoutSender.OnDisable");
//we can't call Spout2.instance because on Disable is also called when scene is destroyed.
//so a nother instance of Spout could be generated in the moment when the Spout2 instance is destroyed!
#if UNITY_EDITOR
UnityEditor.EditorApplication.update -= _Update;
#endif
_CloseSender();
}
void Update()
{
_Update();
}
void _Update()
{
//Debug.Log("SpoutSender.Update");
if (texture == null) return;
//in EditMode we have to force the camera to render.But as this is called 100 times per second beware of your performance, so we only render at a special interval
#if UNITY_EDITOR
if (!Application.isPlaying)
{
_frameCounter++;
_frameCounter %= _editorUpdateFrameInterval;
if (Spout.isEnabledInEditor)
{
if (_cam != null)
{
if (_frameCounter == 0) _cam.Render();
}
}
}
#endif
if (senderIsCreated)
{
Spout.instance.UpdateSender(sharingName, texture);
//Debug.Log("Update sender :"+updateSenderResult);
}
else
{
//this is the delay
if (StartupDelay)
{
_startUpFrameCount++;
if (_startUpFrameCount < _startupFramesDelay) return;
if (_attempts > _createAttempts) return;
_CreateSender();
}
}
}
void OnDestroy()
{
}
private void _CreateSender()
{
//Debug.Log("SpoutSender._CreateSender");
if (texture == null) return;
if (!Spout.isInit) return;
if (!Spout.instance.enabled) return;
#if UNITY_EDITOR
if (!Application.isPlaying && !Spout.isEnabledInEditor) return;
#endif
//Debug.Log("SpoutSender._CreateSender");
if (!senderIsCreated)
{
Debug.Log("Sender is not created, creating one");
senderIsCreated = Spout.instance.CreateSender(sharingName, texture, (int)textureFormat);
}
_attempts++;
if (_attempts > _createAttempts) Debug.LogWarning(String.Format("There are problems with creating the sender {0}. Please check your settings or restart Unity.", sharingName));
#if UNITY_EDITOR
if (_cam != null)
{
if (_cam.targetTexture == null || _cam.targetTexture != texture)
{
Debug.LogWarning("Your Camera has no Target Texture or the texture that the Spout Sender uses is different!");
if (texture != null) _cam.targetTexture = (RenderTexture)texture;
}
}
#endif
Spout.instance.OnSenderStopped -= OnSenderStoppedDelegate;
Spout.instance.OnSenderStopped += OnSenderStoppedDelegate;
Spout.instance.OnAllSendersStopped -= OnAllSendersStoppedDelegate;
Spout.instance.OnAllSendersStopped += OnAllSendersStoppedDelegate;
Spout.instance.OnEnabled -= _OnSpoutEnabled;
Spout.instance.OnEnabled += _OnSpoutEnabled;
}
private void _OnSpoutEnabled()
{
//Debug.Log("SpoutSender._OnSpoutEnabled");
if (enabled)
{
//force a reconnection
enabled = !enabled;
enabled = !enabled;
}
}
private void _CloseSender()
{
Debug.Log("SpoutSender._CloseSender:" + sharingName);
if (senderIsCreated) Spout.CloseSender(sharingName);
_CloseSenderCleanUpData();
}
private void OnSenderStoppedDelegate(object sender, TextureShareEventArgs e)
{
//Debug.Log("SpoutSender.OnSenderStoppedDelegate:"+e.sharingName);
if (e.sharingName == sharingName)
{
_CloseSenderCleanUpData();
}
}
private void OnAllSendersStoppedDelegate()
{
_CloseSenderCleanUpData();
}
private void _CloseSenderCleanUpData()
{
senderIsCreated = false;
}
}
}

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 6a2582b4147ea6e4ebf31586d3c7d730
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:

@ -1,82 +0,0 @@
/*
* Spout4Unity
* Copyright © 2014-2015 Benjamin Kuperberg
* Copyright © 2015 Stefan Schlupek
* All rights reserved
*/
using UnityEngine;
using System.Collections;
using System;
namespace Spout{
public class TextureInfo {
public string name;
private int w;
private int h;
private IntPtr resourceView;
private Texture2D tex;
// Use this for initialization
public TextureInfo (string name) {
this.name = name;
}
public void setInfos(int width, int height, IntPtr resourceView){
this.w = width;
this.h = height;
this.resourceView = resourceView;
}
public Texture2D getTexture()
{
if(resourceView == IntPtr.Zero)
{
Debug.LogWarning("ResourceView is null, returning empty texture");
tex = null;
//Resources.UnloadUnusedAssets();
//GC.Collect();
//There could be problems with creating a Texture2d at this point!
//tex = new Texture2D(64,64,TextureFormat.RGBA32,false,true);//new Texture2D(64,64);
//tex.hideFlags = HideFlags.HideAndDontSave;
}
else
{
if(tex == null) {
tex = Texture2D.CreateExternalTexture(w,h,TextureFormat.RGBA32,true,true,resourceView);
/*
Without setting the Hideflags there seems to be a reference floating in the scene which causes great trouble with [ExecuteInEditmode] at OnDestroy
And we get some weired exception when enter PlayMode and there is an already open Spout sender outside from Unity
*/
tex.hideFlags = HideFlags.HideAndDontSave;
}
}
return tex;
}
//Make it comparable for Linq
public override bool Equals(object obj)
{
TextureInfo q = obj as TextureInfo;
return q != null && q.name == this.name ;
}
public override int GetHashCode()
{
return this.name.GetHashCode() ^ this.name.GetHashCode();
}
}
}

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 9403bcc28b14bab4086ab044f04eb4e2
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:

@ -1,10 +0,0 @@
fileFormatVersion: 2
guid: c8fe6346593cd964c9d313393b66f89c
folderAsset: yes
timeCreated: 1519718036
licenseType: Free
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

@ -1,63 +0,0 @@
Shader "Unlit/AlphaPremultiplied"
{
Properties
{
_MainTex ("Texture", 2D) = "white" {}
yFlip ("display name", Int) = 0
}
SubShader
{
Tags { "RenderType"="Opeque" }
LOD 100
//Blend One Zero
Blend One OneMinusSrcAlpha
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
// make fog work
#pragma multi_compile_fog
#include "UnityCG.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
};
struct v2f
{
float2 uv : TEXCOORD0;
UNITY_FOG_COORDS(1)
float4 vertex : SV_POSITION;
};
sampler2D _MainTex;
float4 _MainTex_ST;
int yFlip;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
UNITY_TRANSFER_FOG(o,o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
// sample the texture
float2 uv = i.uv;
if (yFlip == 1)
uv = i.uv*float2(1.0, -1.0) + float2(0.0, 1.0);
fixed4 col = tex2D(_MainTex, uv);
col.rgb *= col.a;
return col;
}
ENDCG
}
}
}

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: ca95743014f24fd49897e12abbe931fc
timeCreated: 1490605733
licenseType: Free
ShaderImporter:
defaultTextures: []
userData:
assetBundleName:
assetBundleVariant:

@ -1,10 +0,0 @@
fileFormatVersion: 2
guid: 0a3e0d9622f03624fa27cb23b60badde
folderAsset: yes
timeCreated: 1519706012
licenseType: Free
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

@ -1,10 +0,0 @@
fileFormatVersion: 2
guid: 0a07a7835f1704444a493a17b63d5a45
folderAsset: yes
timeCreated: 1519706012
licenseType: Free
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 83715878d3a8db441aa5636641db69a3
folderAsset: yes
timeCreated: 1476176392
licenseType: Pro
DefaultImporter:
userData:
assetBundleName:
assetBundleVariant:

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: e7358848dd8737c459f4636f1c075835
folderAsset: yes
timeCreated: 1460361782
licenseType: Pro
DefaultImporter:
userData:
assetBundleName:
assetBundleVariant:

@ -1,91 +0,0 @@
#include "UnityCG.cginc"
RWStructuredBuffer<uint4> _Histogram;
Texture2D<float4> _Source;
CBUFFER_START (Params)
uint _IsLinear;
float4 _Res;
uint4 _Channels;
CBUFFER_END
groupshared uint4 gs_histogram[256];
#define GROUP_SIZE 16
#pragma kernel KHistogramGather
[numthreads(GROUP_SIZE, GROUP_SIZE,1)]
void KHistogramGather(uint2 dispatchThreadId : SV_DispatchThreadID, uint2 groupThreadId : SV_GroupThreadID)
{
const uint localThreadId = groupThreadId.y * GROUP_SIZE + groupThreadId.x;
if (localThreadId < 256)
gs_histogram[localThreadId] = uint4(0, 0, 0, 0);
GroupMemoryBarrierWithGroupSync();
if (dispatchThreadId.x < (uint)_Res.x && dispatchThreadId.y < (uint)_Res.y)
{
// We want a gamma histogram (like Photoshop & all)
float3 color = saturate(_Source[dispatchThreadId].xyz);
if (_IsLinear > 0)
color = LinearToGammaSpace(color);
// Convert color & luminance to histogram bin
uint3 idx_c = (uint3)(round(color * 255.0));
uint idx_l = (uint)(round(dot(color.rgb, float3(0.2125, 0.7154, 0.0721)) * 255.0));
// Fill the group shared histogram
if (_Channels.x > 0u) InterlockedAdd(gs_histogram[idx_c.x].x, 1); // Red
if (_Channels.y > 0u) InterlockedAdd(gs_histogram[idx_c.y].y, 1); // Green
if (_Channels.z > 0u) InterlockedAdd(gs_histogram[idx_c.z].z, 1); // Blue
if (_Channels.w > 0u) InterlockedAdd(gs_histogram[idx_l].w, 1); // Luminance
}
GroupMemoryBarrierWithGroupSync();
// Merge
if (localThreadId < 256)
{
uint4 h = gs_histogram[localThreadId];
if (_Channels.x > 0u && h.x > 0) InterlockedAdd(_Histogram[localThreadId].x, h.x); // Red
if (_Channels.y > 0u && h.y > 0) InterlockedAdd(_Histogram[localThreadId].y, h.y); // Green
if (_Channels.z > 0u && h.z > 0) InterlockedAdd(_Histogram[localThreadId].z, h.z); // Blue
if (_Channels.w > 0u && h.w > 0) InterlockedAdd(_Histogram[localThreadId].w, h.w); // Luminance
}
}
// Scaling pass
groupshared uint4 gs_pyramid[256];
#pragma kernel KHistogramScale
[numthreads(16,16,1)]
void KHistogramScale(uint2 groupThreadId : SV_GroupThreadID)
{
const uint localThreadId = groupThreadId.y * 16 + groupThreadId.x;
gs_pyramid[localThreadId] = _Histogram[localThreadId];
GroupMemoryBarrierWithGroupSync();
// Parallel reduction to find the max value
UNITY_UNROLL
for(uint i = 256 >> 1; i > 0; i >>= 1)
{
if(localThreadId < i)
gs_pyramid[localThreadId] = max(gs_pyramid[localThreadId], gs_pyramid[localThreadId + i]);
GroupMemoryBarrierWithGroupSync();
}
// Actual scaling
float4 factor = _Res.y / (float4)gs_pyramid[0];
_Histogram[localThreadId] = (uint4)round(_Histogram[localThreadId] * factor);
}
#pragma kernel KHistogramClear
[numthreads(GROUP_SIZE, GROUP_SIZE, 1)]
void KHistogramClear(uint2 dispatchThreadId : SV_DispatchThreadID)
{
if (dispatchThreadId.x < (uint)_Res.x && dispatchThreadId.y < (uint)_Res.y)
_Histogram[dispatchThreadId.y * _Res.x + dispatchThreadId.x] = uint4(0u, 0u, 0u, 0u);
}

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 51b7e4b4448c98f4a849081110fd6212
timeCreated: 1459956391
licenseType: Pro
ComputeShaderImporter:
currentAPIMask: 4
userData:
assetBundleName:
assetBundleVariant:

@ -1,141 +0,0 @@
Shader "Hidden/Post FX/Monitors/Histogram Render"
{
SubShader
{
ZTest Always Cull Off ZWrite Off
Fog { Mode off }
CGINCLUDE
#pragma fragmentoption ARB_precision_hint_fastest
#pragma target 5.0
#include "UnityCG.cginc"
StructuredBuffer<uint4> _Histogram;
float2 _Size;
uint _Channel;
float4 _ColorR;
float4 _ColorG;
float4 _ColorB;
float4 _ColorL;
float4 FragSingleChannel(v2f_img i) : SV_Target
{
const float4 COLORS[4] = { _ColorR, _ColorG, _ColorB, _ColorL };
float remapI = i.uv.x * 255.0;
uint index = floor(remapI);
float delta = frac(remapI);
float v1 = _Histogram[index][_Channel];
float v2 = _Histogram[min(index + 1, 255)][_Channel];
float h = v1 * (1.0 - delta) + v2 * delta;
uint y = (uint)round(i.uv.y * _Size.y);
float4 color = float4(0.1, 0.1, 0.1, 1.0);
float fill = step(y, h);
color = lerp(color, COLORS[_Channel], fill);
return color;
}
float4 FragRgbMerged(v2f_img i) : SV_Target
{
const float4 COLORS[3] = { _ColorR, _ColorG, _ColorB };
float4 targetColor = float4(0.1, 0.1, 0.1, 1.0);
float4 emptyColor = float4(0.0, 0.0, 0.0, 1.0);
float remapI = i.uv.x * 255.0;
uint index = floor(remapI);
float delta = frac(remapI);
for (int j = 0; j < 3; j++)
{
float v1 = _Histogram[index][j];
float v2 = _Histogram[min(index + 1, 255)][j];
float h = v1 * (1.0 - delta) + v2 * delta;
uint y = (uint)round(i.uv.y * _Size.y);
float fill = step(y, h);
float4 color = lerp(emptyColor, COLORS[j], fill);
targetColor += color;
}
return saturate(targetColor);
}
float4 FragRgbSplitted(v2f_img i) : SV_Target
{
const float4 COLORS[3] = {_ColorR, _ColorG, _ColorB};
const float limitB = round(_Size.y / 3.0);
const float limitG = limitB * 2;
float4 color = float4(0.1, 0.1, 0.1, 1.0);
uint channel;
float offset;
if (i.pos.y < limitB)
{
channel = 2;
offset = 0.0;
}
else if (i.pos.y < limitG)
{
channel = 1;
offset = limitB;
}
else
{
channel = 0;
offset = limitG;
}
float remapI = i.uv.x * 255.0;
uint index = floor(remapI);
float delta = frac(remapI);
float v1 = offset + _Histogram[index][channel] / 3.0;
float v2 = offset + _Histogram[min(index + 1, 255)][channel] / 3.0;
float h = v1 * (1.0 - delta) + v2 * delta;
uint y = (uint)round(i.uv.y * _Size.y);
float fill = step(y, h);
color = lerp(color, COLORS[channel], fill);
return color;
}
ENDCG
// (0) Channel
Pass
{
CGPROGRAM
#pragma vertex vert_img
#pragma fragment FragSingleChannel
ENDCG
}
// (1) RGB merged
Pass
{
CGPROGRAM
#pragma vertex vert_img
#pragma fragment FragRgbMerged
ENDCG
}
// (2) RGB splitted
Pass
{
CGPROGRAM
#pragma vertex vert_img
#pragma fragment FragRgbSplitted
ENDCG
}
}
FallBack off
}

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 965efa32cf2345647a1c987546e08f86
timeCreated: 1459956391
licenseType: Pro
ShaderImporter:
defaultTextures: []
userData:
assetBundleName:
assetBundleVariant:

@ -1,76 +0,0 @@
Shader "Hidden/Post FX/Monitors/Parade Render"
{
SubShader
{
ZTest Always Cull Off ZWrite Off
Fog { Mode off }
CGINCLUDE
#pragma fragmentoption ARB_precision_hint_fastest
#pragma target 5.0
#include "UnityCG.cginc"
StructuredBuffer<uint4> _Waveform;
float4 _Size;
float _Exposure;
float3 Tonemap(float3 x, float exposure)
{
const float a = 6.2;
const float b = 0.5;
const float c = 1.7;
const float d = 0.06;
x *= exposure;
x = max((0.0).xxx, x - (0.004).xxx);
x = (x * (a * x + b)) / (x * (a * x + c) + d);
return x * x;
}
float4 FragParade(v2f_img i) : SV_Target
{
const float3 red = float3(1.8, 0.03, 0.02);
const float3 green = float3(0.02, 1.3, 0.05);
const float3 blue = float3(0.0, 0.45, 1.75);
float3 color = float3(0.0, 0.0, 0.0);
const uint limitR = _Size.x / 3;
const uint limitG = limitR * 2;
if (i.pos.x < (float)limitR)
{
uint2 uvI = i.pos.xy;
color = _Waveform[uvI.y + uvI.x * _Size.y].r * red;
}
else if (i.pos.x < (float)limitG)
{
uint2 uvI = uint2(i.pos.x - limitR, i.pos.y);
color = _Waveform[uvI.y + uvI.x * _Size.y].g * green;
}
else
{
uint2 uvI = uint2(i.pos.x - limitG, i.pos.y);
color = _Waveform[uvI.y + uvI.x * _Size.y].b * blue;
}
color = Tonemap(color, _Exposure);
color += (0.1).xxx;
return float4(saturate(color), 1.0);
}
ENDCG
// (0)
Pass
{
CGPROGRAM
#pragma vertex vert_img
#pragma fragment FragParade
ENDCG
}
}
FallBack off
}

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 5ae1bfc1dd20ac04e8b74aa0f2f12eea
timeCreated: 1459956391
licenseType: Pro
ShaderImporter:
defaultTextures: []
userData:
assetBundleName:
assetBundleVariant:

@ -1,49 +0,0 @@
#include "UnityCG.cginc"
RWStructuredBuffer<uint> _Vectorscope;
Texture2D<float4> _Source;
CBUFFER_START (Params)
uint _IsLinear;
float4 _Res;
CBUFFER_END
#define GROUP_SIZE 32
float3 RgbToYUV(float3 c)
{
float Y = 0.299 * c.r + 0.587 * c.g + 0.114 * c.b;
float U = -0.169 * c.r - 0.331 * c.g + 0.500 * c.b;
float V = 0.500 * c.r - 0.419 * c.g - 0.081 * c.b;
return float3(Y, U, V);
}
#pragma kernel KVectorscope
[numthreads(GROUP_SIZE,GROUP_SIZE,1)]
void KVectorscope(uint2 dispatchThreadId : SV_DispatchThreadID)
{
if (dispatchThreadId.x < (uint)_Res.x && dispatchThreadId.y < (uint)_Res.y)
{
float3 color = saturate(_Source[dispatchThreadId].xyz);
if (_IsLinear > 0)
color = LinearToGammaSpace(color);
float3 yuv = RgbToYUV(color);
if (length(yuv.yz) > 0.49)
yuv.yz = normalize(yuv.yz) * 0.49;
yuv.yz += (0.5).xx;
uint u = (uint)floor(yuv.y * _Res.x);
uint v = (uint)floor(yuv.z * _Res.y);
InterlockedAdd(_Vectorscope[v * _Res.x + u], 1);
}
}
#pragma kernel KVectorscopeClear
[numthreads(GROUP_SIZE,GROUP_SIZE,1)]
void KVectorscopeClear(uint2 dispatchThreadId : SV_DispatchThreadID)
{
if (dispatchThreadId.x < (uint)_Res.x && dispatchThreadId.y < (uint)_Res.y)
_Vectorscope[dispatchThreadId.y * _Res.x + dispatchThreadId.x] = 0u;
}

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 45de9ff58691e934c9810dc23de2ba50
timeCreated: 1459956391
licenseType: Pro
ComputeShaderImporter:
currentAPIMask: 4
userData:
assetBundleName:
assetBundleVariant:

@ -1,101 +0,0 @@
Shader "Hidden/Post FX/Monitors/Vectorscope Render"
{
SubShader
{
ZTest Always Cull Off ZWrite Off
Fog { Mode off }
CGINCLUDE
#pragma fragmentoption ARB_precision_hint_fastest
#pragma target 5.0
#include "UnityCG.cginc"
StructuredBuffer<uint> _Vectorscope;
float2 _Size;
float _Exposure;
float Tonemap(float x, float exposure)
{
const float a = 6.2;
const float b = 0.5;
const float c = 1.7;
const float d = 0.06;
x *= exposure;
x = max(0.0, x - 0.004);
x = (x * (a * x + b)) / (x * (a * x + c) + d);
return x * x;
}
float3 YuvToRgb(float3 c)
{
float R = c.x + 0.000 * c.y + 1.403 * c.z;
float G = c.x - 0.344 * c.y - 0.714 * c.z;
float B = c.x - 1.773 * c.y + 0.000 * c.z;
return float3(R, G, B);
}
float4 FragBackground(v2f_img i) : SV_Target
{
i.uv.x = 1.0 - i.uv.x;
float2 uv = i.uv - (0.5).xx;
float3 c = YuvToRgb(float3(0.5, uv.x, uv.y));
float dist = sqrt(dot(uv, uv));
float delta = fwidth(dist);
float alphaOut = 1.0 - smoothstep(0.5 - delta, 0.5 + delta, dist);
float alphaIn = smoothstep(0.495 - delta, 0.495 + delta, dist);
uint2 uvI = i.pos.xy;
uint v = _Vectorscope[uvI.x + uvI.y * _Size.x];
float vt = saturate(Tonemap(v, _Exposure));
float4 color = float4(lerp(c, (0.0).xxx, vt), alphaOut);
color.rgb += alphaIn;
return color;
}
float4 FragNoBackground(v2f_img i) : SV_Target
{
i.uv.x = 1.0 - i.uv.x;
float2 uv = i.uv - (0.5).xx;
float dist = sqrt(dot(uv, uv));
float delta = fwidth(dist);
float alphaOut = 1.0 - smoothstep(0.5 - delta, 0.5 + delta, dist);
float alphaIn = smoothstep(0.495 - delta, 0.495 + delta, dist);
uint2 uvI = i.pos.xy;
uint v = _Vectorscope[uvI.x + uvI.y * _Size.x];
float vt = saturate(Tonemap(v, _Exposure));
float4 color = float4((1.0).xxx, vt + alphaIn * alphaOut);
return color;
}
ENDCG
// (0)
Pass
{
CGPROGRAM
#pragma vertex vert_img
#pragma fragment FragBackground
ENDCG
}
// (1)
Pass
{
CGPROGRAM
#pragma vertex vert_img
#pragma fragment FragNoBackground
ENDCG
}
}
FallBack off
}

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 1c4298cd35ef7834e892898e49d61ecd
timeCreated: 1461756159
licenseType: Pro
ShaderImporter:
defaultTextures: []
userData:
assetBundleName:
assetBundleVariant:

@ -1,42 +0,0 @@
#include "UnityCG.cginc"
RWStructuredBuffer<uint4> _Waveform;
Texture2D<float4> _Source;
CBUFFER_START (Params)
uint _IsLinear;
uint4 _Channels;
CBUFFER_END
#define COLUMNS 384
#pragma kernel KWaveform
[numthreads(1,COLUMNS,1)]
void KWaveform(uint2 dispatchThreadId : SV_DispatchThreadID)
{
// We want a gamma corrected colors
float3 color = _Source[dispatchThreadId].rgb;
if (_IsLinear > 0u)
color = LinearToGammaSpace(color);
color = saturate(color);
// Convert color & luminance to histogram bins
const float kColumnsMinusOne = COLUMNS - 1.0;
uint3 idx_c = (uint3)(round(color * kColumnsMinusOne));
uint idx_l = (uint)(round(dot(color.rgb, float3(0.2126, 0.7152, 0.0722)) * kColumnsMinusOne));
// A lot of atomic operations will be skipped so there's no need to over-think this one.
uint j = dispatchThreadId.x * COLUMNS;
if (_Channels.x > 0u && idx_c.x > 0u) InterlockedAdd(_Waveform[j + idx_c.x].x, 1u); // Red
if (_Channels.y > 0u && idx_c.y > 0u) InterlockedAdd(_Waveform[j + idx_c.y].y, 1u); // Green
if (_Channels.z > 0u && idx_c.z > 0u) InterlockedAdd(_Waveform[j + idx_c.z].z, 1u); // Blue
if (_Channels.w > 0u) InterlockedAdd(_Waveform[j + idx_l].w, 1u); // Luminance
}
#pragma kernel KWaveformClear
[numthreads(1, COLUMNS, 1)]
void KWaveformClear(uint2 dispatchThreadId : SV_DispatchThreadID)
{
_Waveform[dispatchThreadId.x * COLUMNS + dispatchThreadId.y] = uint4(0u, 0u, 0u, 0u);
}

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 9d9b886f7a8fe7b4baf56624c42e3420
timeCreated: 1459956392
licenseType: Pro
ComputeShaderImporter:
currentAPIMask: 4
userData:
assetBundleName:
assetBundleVariant:

@ -1,65 +0,0 @@
Shader "Hidden/Post FX/Monitors/Waveform Render"
{
SubShader
{
ZTest Always Cull Off ZWrite Off
Fog { Mode off }
CGINCLUDE
#pragma fragmentoption ARB_precision_hint_fastest
#pragma target 5.0
#include "UnityCG.cginc"
StructuredBuffer<uint4> _Waveform;
float2 _Size;
float4 _Channels;
float _Exposure;
float3 Tonemap(float3 x, float exposure)
{
const float a = 6.2;
const float b = 0.5;
const float c = 1.7;
const float d = 0.06;
x *= exposure;
x = max((0.0).xxx, x - (0.004).xxx);
x = (x * (a * x + b)) / (x * (a * x + c) + d);
return x * x;
}
float4 FragWaveform(v2f_img i) : SV_Target
{
const float3 red = float3(1.4, 0.03, 0.02);
const float3 green = float3(0.02, 1.1, 0.05);
const float3 blue = float3(0.0, 0.25, 1.5);
float3 color = float3(0.0, 0.0, 0.0);
uint2 uvI = i.pos.xy;
float4 w = _Waveform[uvI.y + uvI.x * _Size.y]; // Waveform data is stored in columns instead of rows
color += red * w.r * _Channels.r;
color += green * w.g * _Channels.g;
color += blue * w.b * _Channels.b;
color += w.aaa * _Channels.a * 1.5;
color = Tonemap(color, _Exposure);
color += (0.1).xxx;
return float4(saturate(color), 1.0);
}
ENDCG
// (0)
Pass
{
CGPROGRAM
#pragma vertex vert_img
#pragma fragment FragWaveform
ENDCG
}
}
FallBack off
}

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 8b3e43c50424ab2428a9c172843bc66d
timeCreated: 1459956391
licenseType: Pro
ShaderImporter:
defaultTextures: []
userData:
assetBundleName:
assetBundleVariant:

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: df37d60cc69b7b04d9705a74938179e7
folderAsset: yes
timeCreated: 1460627771
licenseType: Pro
DefaultImporter:
userData:
assetBundleName:
assetBundleVariant:

@ -1,63 +0,0 @@
Shader "Hidden/Post FX/UI/Curve Background"
{
CGINCLUDE
#pragma target 3.0
#include "UnityCG.cginc"
float _DisabledState;
float3 HsvToRgb(float3 c)
{
float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
float3 p = abs(frac(c.xxx + K.xyz) * 6.0 - K.www);
return c.z * lerp(K.xxx, saturate(p - K.xxx), c.y);
}
float4 FragHue(v2f_img i) : SV_Target
{
float3 hsv = HsvToRgb(float3(i.uv.x, 1.0, 0.2));
float4 color = float4((0.0).xxx, 1.0);
color.rgb = lerp(color.rgb, hsv, smoothstep(0.5, 1.1, 1.0 - i.uv.y)) + lerp(color.rgb, hsv, smoothstep(0.5, 1.1, i.uv.y));
color.rgb += (0.15).xxx;
return float4(color.rgb, color.a * _DisabledState);
}
float4 FragSat(v2f_img i) : SV_Target
{
float4 color = float4((0.0).xxx, 1.0);
float sat = i.uv.x / 2;
color.rgb += lerp(color.rgb, (sat).xxx, smoothstep(0.5, 1.2, 1.0 - i.uv.y)) + lerp(color.rgb, (sat).xxx, smoothstep(0.5, 1.2, i.uv.y));
color.rgb += (0.15).xxx;
return float4(color.rgb, color.a * _DisabledState);
}
ENDCG
SubShader
{
Cull Off ZWrite Off ZTest Always
// (0) Hue
Pass
{
CGPROGRAM
#pragma vertex vert_img
#pragma fragment FragHue
ENDCG
}
// (1) Sat/lum
Pass
{
CGPROGRAM
#pragma vertex vert_img
#pragma fragment FragSat
ENDCG
}
}
}

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: b1b2bfb2897659e45983f0c3e7dda2c8
timeCreated: 1460970196
licenseType: Pro
ShaderImporter:
defaultTextures: []
userData:
assetBundleName:
assetBundleVariant:

@ -1,59 +0,0 @@
fileFormatVersion: 2
guid: c0fa58091049bd24394fa15b0b6d4c5a
timeCreated: 1468326774
licenseType: Pro
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 0
linearTexture: 1
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: 0.25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
cubemapConvolution: 0
cubemapConvolutionSteps: 7
cubemapConvolutionExponent: 1.5
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 2048
textureSettings:
filterMode: -1
aniso: 1
mipBias: -1
wrapMode: 1
nPOTScale: 0
lightmap: 0
rGBM: 0
compressionQuality: 50
allowsAlphaSplitting: 0
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: 0.5, y: 0.5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 1
spriteTessellationDetail: -1
textureType: 2
buildTargetSettings: []
spriteSheet:
serializedVersion: 2
sprites: []
outline: []
spritePackingTag:
userData:
assetBundleName:
assetBundleVariant:

@ -1,118 +0,0 @@
Shader "Hidden/Post FX/UI/Trackball"
{
CGINCLUDE
#include "UnityCG.cginc"
#define PI 3.14159265359
#define PI2 6.28318530718
float _Offset;
float _DisabledState;
float2 _Resolution; // x: size, y: size / 2
float3 HsvToRgb(float3 c)
{
float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
float3 p = abs(frac(c.xxx + K.xyz) * 6.0 - K.www);
return c.z * lerp(K.xxx, saturate(p - K.xxx), c.y);
}
float4 CreateWheel(v2f_img i, float crossColor, float offsetColor)
{
const float kHueOuterRadius = 0.45;
const float kHueInnerRadius = 0.38;
const float kLumOuterRadius = 0.495;
const float kLumInnerRadius = 0.48;
float4 color = (0.0).xxxx;
float2 uvc = i.uv - (0.5).xx;
float dist = sqrt(dot(uvc, uvc));
float delta = fwidth(dist);
float angle = atan2(uvc.x, uvc.y);
// Cross
{
float radius = (0.5 - kHueInnerRadius) * _Resolution.x + 1.0;
float2 pixel = (_Resolution.xx - 1.0) * i.uv + 1.0;
float vline = step(floor(fmod(pixel.x, _Resolution.y)), 0.0);
vline *= step(radius, pixel.y) * step(pixel.y, _Resolution.x - radius);
float hline = step(floor(fmod(pixel.y, _Resolution.y)), 0.0);
hline *= step(radius, pixel.x) * step(pixel.x, _Resolution.x - radius);
color += hline.xxxx * (1.0).xxxx;
color += vline.xxxx * (1.0).xxxx;
color = saturate(color);
color *= half4((crossColor).xxx, 0.05);
}
// Hue
{
float alphaOut = smoothstep(kHueOuterRadius - delta, kHueOuterRadius + delta, dist);
float alphaIn = smoothstep(kHueInnerRadius - delta, kHueInnerRadius + delta, dist);
float hue = angle;
hue = 1.0 - ((hue > 0.0) ? hue : PI2 + hue) / PI2;
float4 c = float4(HsvToRgb(float3(hue, 1.0, 1.0)), 1.0);
color += lerp((0.0).xxxx, c, alphaIn - alphaOut);
}
// Offset
{
float alphaOut = smoothstep(kLumOuterRadius - delta, kLumOuterRadius + delta, dist);
float alphaIn = smoothstep(kLumInnerRadius - delta, kLumInnerRadius + delta / 2, dist);
float4 c = float4((offsetColor).xxx, 1.0);
float a = PI * _Offset;
if (_Offset >= 0 && angle < a && angle > 0.0)
c = float4((1.0).xxx, 0.5);
else if (angle > a && angle < 0.0)
c = float4((1.0).xxx, 0.5);
color += lerp((0.0).xxxx, c, alphaIn - alphaOut);
}
return color * _DisabledState;
}
float4 FragTrackballDark(v2f_img i) : SV_Target
{
return CreateWheel(i, 1.0, 0.15);
}
float4 FragTrackballLight(v2f_img i) : SV_Target
{
return CreateWheel(i, 0.0, 0.3);
}
ENDCG
SubShader
{
Cull Off ZWrite Off ZTest Always
// (0) Dark skin
Pass
{
CGPROGRAM
#pragma vertex vert_img
#pragma fragment FragTrackballDark
ENDCG
}
// (1) Light skin
Pass
{
CGPROGRAM
#pragma vertex vert_img
#pragma fragment FragTrackballLight
ENDCG
}
}
}

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 4bf49309c7ab9eb42a86774d2c09b4fa
timeCreated: 1460627788
licenseType: Pro
ShaderImporter:
defaultTextures: []
userData:
assetBundleName:
assetBundleVariant:

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: e0e418747b892364db5c5f4451e67ede
folderAsset: yes
timeCreated: 1466586258
licenseType: Pro
DefaultImporter:
userData:
assetBundleName:
assetBundleVariant:

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: cc5c690f549b4704eb992a9be781554d
folderAsset: yes
timeCreated: 1466769698
licenseType: Pro
DefaultImporter:
userData:
assetBundleName:
assetBundleVariant:

@ -1,16 +0,0 @@
using System;
namespace UnityEditor.PostProcessing
{
public class PostProcessingModelEditorAttribute : Attribute
{
public readonly Type type;
public readonly bool alwaysEnabled;
public PostProcessingModelEditorAttribute(Type type, bool alwaysEnabled = false)
{
this.type = type;
this.alwaysEnabled = alwaysEnabled;
}
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: c21938aa988055347a2271f03a3e731e
timeCreated: 1466769734
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: d5341d31985da604db4b100f174142ad
folderAsset: yes
timeCreated: 1466769808
licenseType: Pro
DefaultImporter:
userData:
assetBundleName:
assetBundleVariant:

@ -1,42 +0,0 @@
using UnityEngine.PostProcessing;
namespace UnityEditor.PostProcessing
{
using Settings = AmbientOcclusionModel.Settings;
[PostProcessingModelEditor(typeof(AmbientOcclusionModel))]
public class AmbientOcclusionModelEditor : PostProcessingModelEditor
{
SerializedProperty m_Intensity;
SerializedProperty m_Radius;
SerializedProperty m_SampleCount;
SerializedProperty m_Downsampling;
SerializedProperty m_ForceForwardCompatibility;
SerializedProperty m_AmbientOnly;
SerializedProperty m_HighPrecision;
public override void OnEnable()
{
m_Intensity = FindSetting((Settings x) => x.intensity);
m_Radius = FindSetting((Settings x) => x.radius);
m_SampleCount = FindSetting((Settings x) => x.sampleCount);
m_Downsampling = FindSetting((Settings x) => x.downsampling);
m_ForceForwardCompatibility = FindSetting((Settings x) => x.forceForwardCompatibility);
m_AmbientOnly = FindSetting((Settings x) => x.ambientOnly);
m_HighPrecision = FindSetting((Settings x) => x.highPrecision);
}
public override void OnInspectorGUI()
{
EditorGUILayout.PropertyField(m_Intensity);
EditorGUILayout.PropertyField(m_Radius);
EditorGUILayout.PropertyField(m_SampleCount);
EditorGUILayout.PropertyField(m_Downsampling);
EditorGUILayout.PropertyField(m_ForceForwardCompatibility);
EditorGUILayout.PropertyField(m_HighPrecision, EditorGUIHelper.GetContent("High Precision (Forward)"));
using (new EditorGUI.DisabledGroupScope(m_ForceForwardCompatibility.boolValue))
EditorGUILayout.PropertyField(m_AmbientOnly, EditorGUIHelper.GetContent("Ambient Only (Deferred + HDR)"));
}
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: 9fcb710e23a5a0546a3b8b0ca28c1720
timeCreated: 1467190133
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,71 +0,0 @@
using UnityEngine;
using UnityEngine.PostProcessing;
namespace UnityEditor.PostProcessing
{
using Method = AntialiasingModel.Method;
using Settings = AntialiasingModel.Settings;
[PostProcessingModelEditor(typeof(AntialiasingModel))]
public class AntialiasingModelEditor : PostProcessingModelEditor
{
SerializedProperty m_Method;
SerializedProperty m_FxaaPreset;
SerializedProperty m_TaaJitterSpread;
SerializedProperty m_TaaSharpen;
SerializedProperty m_TaaStationaryBlending;
SerializedProperty m_TaaMotionBlending;
static string[] s_MethodNames =
{
"Fast Approximate Anti-aliasing",
"Temporal Anti-aliasing"
};
public override void OnEnable()
{
m_Method = FindSetting((Settings x) => x.method);
m_FxaaPreset = FindSetting((Settings x) => x.fxaaSettings.preset);
m_TaaJitterSpread = FindSetting((Settings x) => x.taaSettings.jitterSpread);
m_TaaSharpen = FindSetting((Settings x) => x.taaSettings.sharpen);
m_TaaStationaryBlending = FindSetting((Settings x) => x.taaSettings.stationaryBlending);
m_TaaMotionBlending = FindSetting((Settings x) => x.taaSettings.motionBlending);
}
public override void OnInspectorGUI()
{
m_Method.intValue = EditorGUILayout.Popup("Method", m_Method.intValue, s_MethodNames);
if (m_Method.intValue == (int)Method.Fxaa)
{
EditorGUILayout.PropertyField(m_FxaaPreset);
}
else if (m_Method.intValue == (int)Method.Taa)
{
if (QualitySettings.antiAliasing > 1)
EditorGUILayout.HelpBox("Temporal Anti-Aliasing doesn't work correctly when MSAA is enabled.", MessageType.Warning);
EditorGUILayout.LabelField("Jitter", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_TaaJitterSpread, EditorGUIHelper.GetContent("Spread"));
EditorGUI.indentLevel--;
EditorGUILayout.Space();
EditorGUILayout.LabelField("Blending", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_TaaStationaryBlending, EditorGUIHelper.GetContent("Stationary"));
EditorGUILayout.PropertyField(m_TaaMotionBlending, EditorGUIHelper.GetContent("Motion"));
EditorGUI.indentLevel--;
EditorGUILayout.Space();
EditorGUILayout.PropertyField(m_TaaSharpen);
}
}
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: 2451939fe695c1a408ba688219837667
timeCreated: 1467190133
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,204 +0,0 @@
using UnityEngine;
using UnityEngine.PostProcessing;
namespace UnityEditor.PostProcessing
{
using Settings = BloomModel.Settings;
[PostProcessingModelEditor(typeof(BloomModel))]
public class BloomModelEditor : PostProcessingModelEditor
{
struct BloomSettings
{
public SerializedProperty intensity;
public SerializedProperty threshold;
public SerializedProperty softKnee;
public SerializedProperty radius;
public SerializedProperty antiFlicker;
}
struct LensDirtSettings
{
public SerializedProperty texture;
public SerializedProperty intensity;
}
BloomSettings m_Bloom;
LensDirtSettings m_LensDirt;
public override void OnEnable()
{
m_Bloom = new BloomSettings
{
intensity = FindSetting((Settings x) => x.bloom.intensity),
threshold = FindSetting((Settings x) => x.bloom.threshold),
softKnee = FindSetting((Settings x) => x.bloom.softKnee),
radius = FindSetting((Settings x) => x.bloom.radius),
antiFlicker = FindSetting((Settings x) => x.bloom.antiFlicker)
};
m_LensDirt = new LensDirtSettings
{
texture = FindSetting((Settings x) => x.lensDirt.texture),
intensity = FindSetting((Settings x) => x.lensDirt.intensity)
};
}
public override void OnInspectorGUI()
{
EditorGUILayout.Space();
PrepareGraph();
DrawGraph();
EditorGUILayout.Space();
EditorGUILayout.PropertyField(m_Bloom.intensity);
EditorGUILayout.PropertyField(m_Bloom.threshold, EditorGUIHelper.GetContent("Threshold (Gamma)"));
EditorGUILayout.PropertyField(m_Bloom.softKnee);
EditorGUILayout.PropertyField(m_Bloom.radius);
EditorGUILayout.PropertyField(m_Bloom.antiFlicker);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Dirt", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_LensDirt.texture);
EditorGUILayout.PropertyField(m_LensDirt.intensity);
EditorGUI.indentLevel--;
}
#region Graph
float m_GraphThreshold;
float m_GraphKnee;
float m_GraphIntensity;
// Number of vertices in curve
const int k_CurveResolution = 48;
// Vertex buffers
Vector3[] m_RectVertices = new Vector3[4];
Vector3[] m_LineVertices = new Vector3[2];
Vector3[] m_CurveVertices = new Vector3[k_CurveResolution];
Rect m_RectGraph;
float m_RangeX;
float m_RangeY;
float ResponseFunction(float x)
{
var rq = Mathf.Clamp(x - m_GraphThreshold + m_GraphKnee, 0, m_GraphKnee * 2);
rq = rq * rq * 0.25f / m_GraphKnee;
return Mathf.Max(rq, x - m_GraphThreshold) * m_GraphIntensity;
}
// Transform a point into the graph rect
Vector3 PointInRect(float x, float y)
{
x = Mathf.Lerp(m_RectGraph.x, m_RectGraph.xMax, x / m_RangeX);
y = Mathf.Lerp(m_RectGraph.yMax, m_RectGraph.y, y / m_RangeY);
return new Vector3(x, y, 0);
}
// Draw a line in the graph rect
void DrawLine(float x1, float y1, float x2, float y2, float grayscale)
{
m_LineVertices[0] = PointInRect(x1, y1);
m_LineVertices[1] = PointInRect(x2, y2);
Handles.color = Color.white * grayscale;
Handles.DrawAAPolyLine(2.0f, m_LineVertices);
}
// Draw a rect in the graph rect
void DrawRect(float x1, float y1, float x2, float y2, float fill, float line)
{
m_RectVertices[0] = PointInRect(x1, y1);
m_RectVertices[1] = PointInRect(x2, y1);
m_RectVertices[2] = PointInRect(x2, y2);
m_RectVertices[3] = PointInRect(x1, y2);
Handles.DrawSolidRectangleWithOutline(
m_RectVertices,
fill < 0 ? Color.clear : Color.white * fill,
line < 0 ? Color.clear : Color.white * line
);
}
// Update internal state with a given bloom instance
public void PrepareGraph()
{
var bloom = (BloomModel)target;
m_RangeX = 5f;
m_RangeY = 2f;
m_GraphThreshold = bloom.settings.bloom.thresholdLinear;
m_GraphKnee = bloom.settings.bloom.softKnee * m_GraphThreshold + 1e-5f;
// Intensity is capped to prevent sampling errors
m_GraphIntensity = Mathf.Min(bloom.settings.bloom.intensity, 10f);
}
// Draw the graph at the current position
public void DrawGraph()
{
using (new GUILayout.HorizontalScope())
{
GUILayout.Space(EditorGUI.indentLevel * 15f);
m_RectGraph = GUILayoutUtility.GetRect(128, 80);
}
// Background
DrawRect(0, 0, m_RangeX, m_RangeY, 0.1f, 0.4f);
// Soft-knee range
DrawRect(m_GraphThreshold - m_GraphKnee, 0, m_GraphThreshold + m_GraphKnee, m_RangeY, 0.25f, -1);
// Horizontal lines
for (var i = 1; i < m_RangeY; i++)
DrawLine(0, i, m_RangeX, i, 0.4f);
// Vertical lines
for (var i = 1; i < m_RangeX; i++)
DrawLine(i, 0, i, m_RangeY, 0.4f);
// Label
Handles.Label(
PointInRect(0, m_RangeY) + Vector3.right,
"Brightness Response (linear)", EditorStyles.miniLabel
);
// Threshold line
DrawLine(m_GraphThreshold, 0, m_GraphThreshold, m_RangeY, 0.6f);
// Response curve
var vcount = 0;
while (vcount < k_CurveResolution)
{
var x = m_RangeX * vcount / (k_CurveResolution - 1);
var y = ResponseFunction(x);
if (y < m_RangeY)
{
m_CurveVertices[vcount++] = PointInRect(x, y);
}
else
{
if (vcount > 1)
{
// Extend the last segment to the top edge of the rect.
var v1 = m_CurveVertices[vcount - 2];
var v2 = m_CurveVertices[vcount - 1];
var clip = (m_RectGraph.y - v1.y) / (v2.y - v1.y);
m_CurveVertices[vcount - 1] = v1 + (v2 - v1) * clip;
}
break;
}
}
if (vcount > 1)
{
Handles.color = Color.white * 0.9f;
Handles.DrawAAPolyLine(2.0f, vcount, m_CurveVertices);
}
}
#endregion
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: a95f3f10e7e437c49ade656f531b30d2
timeCreated: 1467190133
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,106 +0,0 @@
using UnityEngine.PostProcessing;
namespace UnityEditor.PostProcessing
{
using Mode = BuiltinDebugViewsModel.Mode;
using Settings = BuiltinDebugViewsModel.Settings;
[PostProcessingModelEditor(typeof(BuiltinDebugViewsModel), alwaysEnabled: true)]
public class BuiltinDebugViewsEditor : PostProcessingModelEditor
{
struct DepthSettings
{
public SerializedProperty scale;
}
struct MotionVectorsSettings
{
public SerializedProperty sourceOpacity;
public SerializedProperty motionImageOpacity;
public SerializedProperty motionImageAmplitude;
public SerializedProperty motionVectorsOpacity;
public SerializedProperty motionVectorsResolution;
public SerializedProperty motionVectorsAmplitude;
}
SerializedProperty m_Mode;
DepthSettings m_Depth;
MotionVectorsSettings m_MotionVectors;
public override void OnEnable()
{
m_Mode = FindSetting((Settings x) => x.mode);
m_Depth = new DepthSettings
{
scale = FindSetting((Settings x) => x.depth.scale)
};
m_MotionVectors = new MotionVectorsSettings
{
sourceOpacity = FindSetting((Settings x) => x.motionVectors.sourceOpacity),
motionImageOpacity = FindSetting((Settings x) => x.motionVectors.motionImageOpacity),
motionImageAmplitude = FindSetting((Settings x) => x.motionVectors.motionImageAmplitude),
motionVectorsOpacity = FindSetting((Settings x) => x.motionVectors.motionVectorsOpacity),
motionVectorsResolution = FindSetting((Settings x) => x.motionVectors.motionVectorsResolution),
motionVectorsAmplitude = FindSetting((Settings x) => x.motionVectors.motionVectorsAmplitude),
};
}
public override void OnInspectorGUI()
{
EditorGUILayout.PropertyField(m_Mode);
int mode = m_Mode.intValue;
if (mode == (int)Mode.Depth)
{
EditorGUILayout.PropertyField(m_Depth.scale);
}
else if (mode == (int)Mode.MotionVectors)
{
EditorGUILayout.HelpBox("Switch to play mode to see motion vectors.", MessageType.Info);
EditorGUILayout.LabelField("Source Image", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_MotionVectors.sourceOpacity, EditorGUIHelper.GetContent("Opacity"));
EditorGUI.indentLevel--;
EditorGUILayout.Space();
EditorGUILayout.LabelField("Motion Vectors (overlay)", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
if (m_MotionVectors.motionImageOpacity.floatValue > 0f)
EditorGUILayout.HelpBox("Please keep opacity to 0 if you're subject to motion sickness.", MessageType.Warning);
EditorGUILayout.PropertyField(m_MotionVectors.motionImageOpacity, EditorGUIHelper.GetContent("Opacity"));
EditorGUILayout.PropertyField(m_MotionVectors.motionImageAmplitude, EditorGUIHelper.GetContent("Amplitude"));
EditorGUI.indentLevel--;
EditorGUILayout.Space();
EditorGUILayout.LabelField("Motion Vectors (arrows)", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_MotionVectors.motionVectorsOpacity, EditorGUIHelper.GetContent("Opacity"));
EditorGUILayout.PropertyField(m_MotionVectors.motionVectorsResolution, EditorGUIHelper.GetContent("Resolution"));
EditorGUILayout.PropertyField(m_MotionVectors.motionVectorsAmplitude, EditorGUIHelper.GetContent("Amplitude"));
EditorGUI.indentLevel--;
}
else
{
CheckActiveEffect(mode == (int)Mode.AmbientOcclusion && !profile.ambientOcclusion.enabled, "Ambient Occlusion");
CheckActiveEffect(mode == (int)Mode.FocusPlane && !profile.depthOfField.enabled, "Depth Of Field");
CheckActiveEffect(mode == (int)Mode.EyeAdaptation && !profile.eyeAdaptation.enabled, "Eye Adaptation");
CheckActiveEffect((mode == (int)Mode.LogLut || mode == (int)Mode.PreGradingLog) && !profile.colorGrading.enabled, "Color Grading");
CheckActiveEffect(mode == (int)Mode.UserLut && !profile.userLut.enabled, "User Lut");
}
}
void CheckActiveEffect(bool expr, string name)
{
if (expr)
EditorGUILayout.HelpBox(string.Format("{0} isn't enabled, the debug view won't work.", name), MessageType.Warning);
}
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: 760ffebbef2ed644c87940a699eb7fe6
timeCreated: 1468237035
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,9 +0,0 @@
using UnityEngine.PostProcessing;
namespace UnityEditor.PostProcessing
{
[PostProcessingModelEditor(typeof(ChromaticAberrationModel))]
public class ChromaticaAberrationModelEditor : DefaultPostFxModelEditor
{
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: 8a713f71a0169794a915a081f6242f60
timeCreated: 1467190133
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,672 +0,0 @@
using UnityEngine;
using UnityEngine.PostProcessing;
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
namespace UnityEditor.PostProcessing
{
using Settings = ColorGradingModel.Settings;
using Tonemapper = ColorGradingModel.Tonemapper;
using ColorWheelMode = ColorGradingModel.ColorWheelMode;
[PostProcessingModelEditor(typeof(ColorGradingModel))]
public class ColorGradingModelEditor : PostProcessingModelEditor
{
static GUIContent[] s_Tonemappers =
{
new GUIContent("None"),
new GUIContent("Filmic (ACES)"),
new GUIContent("Neutral")
};
struct TonemappingSettings
{
public SerializedProperty tonemapper;
public SerializedProperty neutralBlackIn;
public SerializedProperty neutralWhiteIn;
public SerializedProperty neutralBlackOut;
public SerializedProperty neutralWhiteOut;
public SerializedProperty neutralWhiteLevel;
public SerializedProperty neutralWhiteClip;
}
struct BasicSettings
{
public SerializedProperty exposure;
public SerializedProperty temperature;
public SerializedProperty tint;
public SerializedProperty hueShift;
public SerializedProperty saturation;
public SerializedProperty contrast;
}
struct ChannelMixerSettings
{
public SerializedProperty[] channels;
public SerializedProperty currentEditingChannel;
}
struct ColorWheelsSettings
{
public SerializedProperty mode;
public SerializedProperty log;
public SerializedProperty linear;
}
static GUIContent[] s_Curves =
{
new GUIContent("YRGB"),
new GUIContent("Hue VS Hue"),
new GUIContent("Hue VS Sat"),
new GUIContent("Sat VS Sat"),
new GUIContent("Lum VS Sat")
};
struct CurvesSettings
{
public SerializedProperty master;
public SerializedProperty red;
public SerializedProperty green;
public SerializedProperty blue;
public SerializedProperty hueVShue;
public SerializedProperty hueVSsat;
public SerializedProperty satVSsat;
public SerializedProperty lumVSsat;
public SerializedProperty currentEditingCurve;
public SerializedProperty curveY;
public SerializedProperty curveR;
public SerializedProperty curveG;
public SerializedProperty curveB;
}
TonemappingSettings m_Tonemapping;
BasicSettings m_Basic;
ChannelMixerSettings m_ChannelMixer;
ColorWheelsSettings m_ColorWheels;
CurvesSettings m_Curves;
CurveEditor m_CurveEditor;
Dictionary<SerializedProperty, Color> m_CurveDict;
// Neutral tonemapping curve helper
const int k_CurveResolution = 24;
const float k_NeutralRangeX = 2f;
const float k_NeutralRangeY = 1f;
Vector3[] m_RectVertices = new Vector3[4];
Vector3[] m_LineVertices = new Vector3[2];
Vector3[] m_CurveVertices = new Vector3[k_CurveResolution];
Rect m_NeutralCurveRect;
public override void OnEnable()
{
// Tonemapping settings
m_Tonemapping = new TonemappingSettings
{
tonemapper = FindSetting((Settings x) => x.tonemapping.tonemapper),
neutralBlackIn = FindSetting((Settings x) => x.tonemapping.neutralBlackIn),
neutralWhiteIn = FindSetting((Settings x) => x.tonemapping.neutralWhiteIn),
neutralBlackOut = FindSetting((Settings x) => x.tonemapping.neutralBlackOut),
neutralWhiteOut = FindSetting((Settings x) => x.tonemapping.neutralWhiteOut),
neutralWhiteLevel = FindSetting((Settings x) => x.tonemapping.neutralWhiteLevel),
neutralWhiteClip = FindSetting((Settings x) => x.tonemapping.neutralWhiteClip)
};
// Basic settings
m_Basic = new BasicSettings
{
exposure = FindSetting((Settings x) => x.basic.postExposure),
temperature = FindSetting((Settings x) => x.basic.temperature),
tint = FindSetting((Settings x) => x.basic.tint),
hueShift = FindSetting((Settings x) => x.basic.hueShift),
saturation = FindSetting((Settings x) => x.basic.saturation),
contrast = FindSetting((Settings x) => x.basic.contrast)
};
// Channel mixer
m_ChannelMixer = new ChannelMixerSettings
{
channels = new[]
{
FindSetting((Settings x) => x.channelMixer.red),
FindSetting((Settings x) => x.channelMixer.green),
FindSetting((Settings x) => x.channelMixer.blue)
},
currentEditingChannel = FindSetting((Settings x) => x.channelMixer.currentEditingChannel)
};
// Color wheels
m_ColorWheels = new ColorWheelsSettings
{
mode = FindSetting((Settings x) => x.colorWheels.mode),
log = FindSetting((Settings x) => x.colorWheels.log),
linear = FindSetting((Settings x) => x.colorWheels.linear)
};
// Curves
m_Curves = new CurvesSettings
{
master = FindSetting((Settings x) => x.curves.master.curve),
red = FindSetting((Settings x) => x.curves.red.curve),
green = FindSetting((Settings x) => x.curves.green.curve),
blue = FindSetting((Settings x) => x.curves.blue.curve),
hueVShue = FindSetting((Settings x) => x.curves.hueVShue.curve),
hueVSsat = FindSetting((Settings x) => x.curves.hueVSsat.curve),
satVSsat = FindSetting((Settings x) => x.curves.satVSsat.curve),
lumVSsat = FindSetting((Settings x) => x.curves.lumVSsat.curve),
currentEditingCurve = FindSetting((Settings x) => x.curves.e_CurrentEditingCurve),
curveY = FindSetting((Settings x) => x.curves.e_CurveY),
curveR = FindSetting((Settings x) => x.curves.e_CurveR),
curveG = FindSetting((Settings x) => x.curves.e_CurveG),
curveB = FindSetting((Settings x) => x.curves.e_CurveB)
};
// Prepare the curve editor and extract curve display settings
m_CurveDict = new Dictionary<SerializedProperty, Color>();
var settings = CurveEditor.Settings.defaultSettings;
m_CurveEditor = new CurveEditor(settings);
AddCurve(m_Curves.master, new Color(1f, 1f, 1f), 2, false);
AddCurve(m_Curves.red, new Color(1f, 0f, 0f), 2, false);
AddCurve(m_Curves.green, new Color(0f, 1f, 0f), 2, false);
AddCurve(m_Curves.blue, new Color(0f, 0.5f, 1f), 2, false);
AddCurve(m_Curves.hueVShue, new Color(1f, 1f, 1f), 0, true);
AddCurve(m_Curves.hueVSsat, new Color(1f, 1f, 1f), 0, true);
AddCurve(m_Curves.satVSsat, new Color(1f, 1f, 1f), 0, false);
AddCurve(m_Curves.lumVSsat, new Color(1f, 1f, 1f), 0, false);
}
void AddCurve(SerializedProperty prop, Color color, uint minPointCount, bool loop)
{
var state = CurveEditor.CurveState.defaultState;
state.color = color;
state.visible = false;
state.minPointCount = minPointCount;
state.onlyShowHandlesOnSelection = true;
state.zeroKeyConstantValue = 0.5f;
state.loopInBounds = loop;
m_CurveEditor.Add(prop, state);
m_CurveDict.Add(prop, color);
}
public override void OnDisable()
{
m_CurveEditor.RemoveAll();
}
public override void OnInspectorGUI()
{
DoGUIFor("Tonemapping", DoTonemappingGUI);
EditorGUILayout.Space();
DoGUIFor("Basic", DoBasicGUI);
EditorGUILayout.Space();
DoGUIFor("Channel Mixer", DoChannelMixerGUI);
EditorGUILayout.Space();
DoGUIFor("Trackballs", DoColorWheelsGUI);
EditorGUILayout.Space();
DoGUIFor("Grading Curves", DoCurvesGUI);
}
void DoGUIFor(string title, Action func)
{
EditorGUILayout.LabelField(title, EditorStyles.boldLabel);
EditorGUI.indentLevel++;
func();
EditorGUI.indentLevel--;
}
void DoTonemappingGUI()
{
int tid = EditorGUILayout.Popup(EditorGUIHelper.GetContent("Tonemapper"), m_Tonemapping.tonemapper.intValue, s_Tonemappers);
if (tid == (int)Tonemapper.Neutral)
{
DrawNeutralTonemappingCurve();
EditorGUILayout.PropertyField(m_Tonemapping.neutralBlackIn, EditorGUIHelper.GetContent("Black In"));
EditorGUILayout.PropertyField(m_Tonemapping.neutralWhiteIn, EditorGUIHelper.GetContent("White In"));
EditorGUILayout.PropertyField(m_Tonemapping.neutralBlackOut, EditorGUIHelper.GetContent("Black Out"));
EditorGUILayout.PropertyField(m_Tonemapping.neutralWhiteOut, EditorGUIHelper.GetContent("White Out"));
EditorGUILayout.PropertyField(m_Tonemapping.neutralWhiteLevel, EditorGUIHelper.GetContent("White Level"));
EditorGUILayout.PropertyField(m_Tonemapping.neutralWhiteClip, EditorGUIHelper.GetContent("White Clip"));
}
m_Tonemapping.tonemapper.intValue = tid;
}
void DrawNeutralTonemappingCurve()
{
using (new GUILayout.HorizontalScope())
{
GUILayout.Space(EditorGUI.indentLevel * 15f);
m_NeutralCurveRect = GUILayoutUtility.GetRect(128, 80);
}
// Background
m_RectVertices[0] = PointInRect( 0f, 0f);
m_RectVertices[1] = PointInRect(k_NeutralRangeX, 0f);
m_RectVertices[2] = PointInRect(k_NeutralRangeX, k_NeutralRangeY);
m_RectVertices[3] = PointInRect( 0f, k_NeutralRangeY);
Handles.DrawSolidRectangleWithOutline(
m_RectVertices,
Color.white * 0.1f,
Color.white * 0.4f
);
// Horizontal lines
for (var i = 1; i < k_NeutralRangeY; i++)
DrawLine(0, i, k_NeutralRangeX, i, 0.4f);
// Vertical lines
for (var i = 1; i < k_NeutralRangeX; i++)
DrawLine(i, 0, i, k_NeutralRangeY, 0.4f);
// Label
Handles.Label(
PointInRect(0, k_NeutralRangeY) + Vector3.right,
"Neutral Tonemapper", EditorStyles.miniLabel
);
// Precompute some values
var tonemap = ((ColorGradingModel)target).settings.tonemapping;
const float scaleFactor = 20f;
const float scaleFactorHalf = scaleFactor * 0.5f;
float inBlack = tonemap.neutralBlackIn * scaleFactor + 1f;
float outBlack = tonemap.neutralBlackOut * scaleFactorHalf + 1f;
float inWhite = tonemap.neutralWhiteIn / scaleFactor;
float outWhite = 1f - tonemap.neutralWhiteOut / scaleFactor;
float blackRatio = inBlack / outBlack;
float whiteRatio = inWhite / outWhite;
const float a = 0.2f;
float b = Mathf.Max(0f, Mathf.LerpUnclamped(0.57f, 0.37f, blackRatio));
float c = Mathf.LerpUnclamped(0.01f, 0.24f, whiteRatio);
float d = Mathf.Max(0f, Mathf.LerpUnclamped(0.02f, 0.20f, blackRatio));
const float e = 0.02f;
const float f = 0.30f;
float whiteLevel = tonemap.neutralWhiteLevel;
float whiteClip = tonemap.neutralWhiteClip / scaleFactorHalf;
// Tonemapping curve
var vcount = 0;
while (vcount < k_CurveResolution)
{
float x = k_NeutralRangeX * vcount / (k_CurveResolution - 1);
float y = NeutralTonemap(x, a, b, c, d, e, f, whiteLevel, whiteClip);
if (y < k_NeutralRangeY)
{
m_CurveVertices[vcount++] = PointInRect(x, y);
}
else
{
if (vcount > 1)
{
// Extend the last segment to the top edge of the rect.
var v1 = m_CurveVertices[vcount - 2];
var v2 = m_CurveVertices[vcount - 1];
var clip = (m_NeutralCurveRect.y - v1.y) / (v2.y - v1.y);
m_CurveVertices[vcount - 1] = v1 + (v2 - v1) * clip;
}
break;
}
}
if (vcount > 1)
{
Handles.color = Color.white * 0.9f;
Handles.DrawAAPolyLine(2.0f, vcount, m_CurveVertices);
}
}
void DrawLine(float x1, float y1, float x2, float y2, float grayscale)
{
m_LineVertices[0] = PointInRect(x1, y1);
m_LineVertices[1] = PointInRect(x2, y2);
Handles.color = Color.white * grayscale;
Handles.DrawAAPolyLine(2f, m_LineVertices);
}
Vector3 PointInRect(float x, float y)
{
x = Mathf.Lerp(m_NeutralCurveRect.x, m_NeutralCurveRect.xMax, x / k_NeutralRangeX);
y = Mathf.Lerp(m_NeutralCurveRect.yMax, m_NeutralCurveRect.y, y / k_NeutralRangeY);
return new Vector3(x, y, 0);
}
float NeutralCurve(float x, float a, float b, float c, float d, float e, float f)
{
return ((x * (a * x + c * b) + d * e) / (x * (a * x + b) + d * f)) - e / f;
}
float NeutralTonemap(float x, float a, float b, float c, float d, float e, float f, float whiteLevel, float whiteClip)
{
x = Mathf.Max(0f, x);
// Tonemap
float whiteScale = 1f / NeutralCurve(whiteLevel, a, b, c, d, e, f);
x = NeutralCurve(x * whiteScale, a, b, c, d, e, f);
x *= whiteScale;
// Post-curve white point adjustment
x /= whiteClip;
return x;
}
void DoBasicGUI()
{
EditorGUILayout.PropertyField(m_Basic.exposure, EditorGUIHelper.GetContent("Post Exposure (EV)"));
EditorGUILayout.PropertyField(m_Basic.temperature);
EditorGUILayout.PropertyField(m_Basic.tint);
EditorGUILayout.PropertyField(m_Basic.hueShift);
EditorGUILayout.PropertyField(m_Basic.saturation);
EditorGUILayout.PropertyField(m_Basic.contrast);
}
void DoChannelMixerGUI()
{
int currentChannel = m_ChannelMixer.currentEditingChannel.intValue;
EditorGUI.BeginChangeCheck();
{
using (new EditorGUILayout.HorizontalScope())
{
EditorGUILayout.PrefixLabel("Channel");
if (GUILayout.Toggle(currentChannel == 0, EditorGUIHelper.GetContent("Red|Red output channel."), EditorStyles.miniButtonLeft)) currentChannel = 0;
if (GUILayout.Toggle(currentChannel == 1, EditorGUIHelper.GetContent("Green|Green output channel."), EditorStyles.miniButtonMid)) currentChannel = 1;
if (GUILayout.Toggle(currentChannel == 2, EditorGUIHelper.GetContent("Blue|Blue output channel."), EditorStyles.miniButtonRight)) currentChannel = 2;
}
}
if (EditorGUI.EndChangeCheck())
{
GUI.FocusControl(null);
}
var serializedChannel = m_ChannelMixer.channels[currentChannel];
m_ChannelMixer.currentEditingChannel.intValue = currentChannel;
var v = serializedChannel.vector3Value;
v.x = EditorGUILayout.Slider(EditorGUIHelper.GetContent("Red|Modify influence of the red channel within the overall mix."), v.x, -2f, 2f);
v.y = EditorGUILayout.Slider(EditorGUIHelper.GetContent("Green|Modify influence of the green channel within the overall mix."), v.y, -2f, 2f);
v.z = EditorGUILayout.Slider(EditorGUIHelper.GetContent("Blue|Modify influence of the blue channel within the overall mix."), v.z, -2f, 2f);
serializedChannel.vector3Value = v;
}
void DoColorWheelsGUI()
{
int wheelMode = m_ColorWheels.mode.intValue;
using (new EditorGUILayout.HorizontalScope())
{
GUILayout.Space(15);
if (GUILayout.Toggle(wheelMode == (int)ColorWheelMode.Linear, "Linear", EditorStyles.miniButtonLeft)) wheelMode = (int)ColorWheelMode.Linear;
if (GUILayout.Toggle(wheelMode == (int)ColorWheelMode.Log, "Log", EditorStyles.miniButtonRight)) wheelMode = (int)ColorWheelMode.Log;
}
m_ColorWheels.mode.intValue = wheelMode;
EditorGUILayout.Space();
if (wheelMode == (int)ColorWheelMode.Linear)
{
EditorGUILayout.PropertyField(m_ColorWheels.linear);
WheelSetTitle(GUILayoutUtility.GetLastRect(), "Linear Controls");
}
else if (wheelMode == (int)ColorWheelMode.Log)
{
EditorGUILayout.PropertyField(m_ColorWheels.log);
WheelSetTitle(GUILayoutUtility.GetLastRect(), "Log Controls");
}
}
static void WheelSetTitle(Rect position, string label)
{
var matrix = GUI.matrix;
var rect = new Rect(position.x - 10f, position.y, TrackballGroupDrawer.m_Size, TrackballGroupDrawer.m_Size);
GUIUtility.RotateAroundPivot(-90f, rect.center);
GUI.Label(rect, label, FxStyles.centeredMiniLabel);
GUI.matrix = matrix;
}
void ResetVisibleCurves()
{
foreach (var curve in m_CurveDict)
{
var state = m_CurveEditor.GetCurveState(curve.Key);
state.visible = false;
m_CurveEditor.SetCurveState(curve.Key, state);
}
}
void SetCurveVisible(SerializedProperty prop)
{
var state = m_CurveEditor.GetCurveState(prop);
state.visible = true;
m_CurveEditor.SetCurveState(prop, state);
}
bool SpecialToggle(bool value, string name, out bool rightClicked)
{
var rect = GUILayoutUtility.GetRect(EditorGUIHelper.GetContent(name), EditorStyles.toolbarButton);
var e = Event.current;
rightClicked = (e.type == EventType.MouseUp && rect.Contains(e.mousePosition) && e.button == 1);
return GUI.Toggle(rect, value, name, EditorStyles.toolbarButton);
}
static Material s_MaterialSpline;
void DoCurvesGUI()
{
EditorGUILayout.Space();
EditorGUI.indentLevel -= 2;
ResetVisibleCurves();
using (new EditorGUI.DisabledGroupScope(serializedProperty.serializedObject.isEditingMultipleObjects))
{
int curveEditingId = 0;
// Top toolbar
using (new GUILayout.HorizontalScope(EditorStyles.toolbar))
{
curveEditingId = EditorGUILayout.Popup(m_Curves.currentEditingCurve.intValue, s_Curves, EditorStyles.toolbarPopup, GUILayout.MaxWidth(150f));
bool y = false, r = false, g = false, b = false;
if (curveEditingId == 0)
{
EditorGUILayout.Space();
bool rightClickedY, rightClickedR, rightClickedG, rightClickedB;
y = SpecialToggle(m_Curves.curveY.boolValue, "Y", out rightClickedY);
r = SpecialToggle(m_Curves.curveR.boolValue, "R", out rightClickedR);
g = SpecialToggle(m_Curves.curveG.boolValue, "G", out rightClickedG);
b = SpecialToggle(m_Curves.curveB.boolValue, "B", out rightClickedB);
if (!y && !r && !g && !b)
{
r = g = b = false;
y = true;
}
if (rightClickedY || rightClickedR || rightClickedG || rightClickedB)
{
y = rightClickedY;
r = rightClickedR;
g = rightClickedG;
b = rightClickedB;
}
if (y) SetCurveVisible(m_Curves.master);
if (r) SetCurveVisible(m_Curves.red);
if (g) SetCurveVisible(m_Curves.green);
if (b) SetCurveVisible(m_Curves.blue);
m_Curves.curveY.boolValue = y;
m_Curves.curveR.boolValue = r;
m_Curves.curveG.boolValue = g;
m_Curves.curveB.boolValue = b;
}
else
{
switch (curveEditingId)
{
case 1: SetCurveVisible(m_Curves.hueVShue);
break;
case 2: SetCurveVisible(m_Curves.hueVSsat);
break;
case 3: SetCurveVisible(m_Curves.satVSsat);
break;
case 4: SetCurveVisible(m_Curves.lumVSsat);
break;
}
}
GUILayout.FlexibleSpace();
if (GUILayout.Button("Reset", EditorStyles.toolbarButton))
{
switch (curveEditingId)
{
case 0:
if (y) m_Curves.master.animationCurveValue = AnimationCurve.Linear(0f, 0f, 1f, 1f);
if (r) m_Curves.red.animationCurveValue = AnimationCurve.Linear(0f, 0f, 1f, 1f);
if (g) m_Curves.green.animationCurveValue = AnimationCurve.Linear(0f, 0f, 1f, 1f);
if (b) m_Curves.blue.animationCurveValue = AnimationCurve.Linear(0f, 0f, 1f, 1f);
break;
case 1: m_Curves.hueVShue.animationCurveValue = new AnimationCurve();
break;
case 2: m_Curves.hueVSsat.animationCurveValue = new AnimationCurve();
break;
case 3: m_Curves.satVSsat.animationCurveValue = new AnimationCurve();
break;
case 4: m_Curves.lumVSsat.animationCurveValue = new AnimationCurve();
break;
}
}
m_Curves.currentEditingCurve.intValue = curveEditingId;
}
// Curve area
var settings = m_CurveEditor.settings;
var rect = GUILayoutUtility.GetAspectRect(2f);
var innerRect = settings.padding.Remove(rect);
if (Event.current.type == EventType.Repaint)
{
// Background
EditorGUI.DrawRect(rect, new Color(0.15f, 0.15f, 0.15f, 1f));
if (s_MaterialSpline == null)
s_MaterialSpline = new Material(Shader.Find("Hidden/Post FX/UI/Curve Background")) { hideFlags = HideFlags.HideAndDontSave };
if (curveEditingId == 1 || curveEditingId == 2)
DrawBackgroundTexture(innerRect, 0);
else if (curveEditingId == 3 || curveEditingId == 4)
DrawBackgroundTexture(innerRect, 1);
// Bounds
Handles.color = Color.white;
Handles.DrawSolidRectangleWithOutline(innerRect, Color.clear, new Color(0.8f, 0.8f, 0.8f, 0.5f));
// Grid setup
Handles.color = new Color(1f, 1f, 1f, 0.05f);
int hLines = (int)Mathf.Sqrt(innerRect.width);
int vLines = (int)(hLines / (innerRect.width / innerRect.height));
// Vertical grid
int gridOffset = Mathf.FloorToInt(innerRect.width / hLines);
int gridPadding = ((int)(innerRect.width) % hLines) / 2;
for (int i = 1; i < hLines; i++)
{
var offset = i * Vector2.right * gridOffset;
offset.x += gridPadding;
Handles.DrawLine(innerRect.position + offset, new Vector2(innerRect.x, innerRect.yMax - 1) + offset);
}
// Horizontal grid
gridOffset = Mathf.FloorToInt(innerRect.height / vLines);
gridPadding = ((int)(innerRect.height) % vLines) / 2;
for (int i = 1; i < vLines; i++)
{
var offset = i * Vector2.up * gridOffset;
offset.y += gridPadding;
Handles.DrawLine(innerRect.position + offset, new Vector2(innerRect.xMax - 1, innerRect.y) + offset);
}
}
// Curve editor
if (m_CurveEditor.OnGUI(rect))
{
Repaint();
GUI.changed = true;
}
if (Event.current.type == EventType.Repaint)
{
// Borders
Handles.color = Color.black;
Handles.DrawLine(new Vector2(rect.x, rect.y - 18f), new Vector2(rect.xMax, rect.y - 18f));
Handles.DrawLine(new Vector2(rect.x, rect.y - 19f), new Vector2(rect.x, rect.yMax));
Handles.DrawLine(new Vector2(rect.x, rect.yMax), new Vector2(rect.xMax, rect.yMax));
Handles.DrawLine(new Vector2(rect.xMax, rect.yMax), new Vector2(rect.xMax, rect.y - 18f));
// Selection info
var selection = m_CurveEditor.GetSelection();
if (selection.curve != null && selection.keyframeIndex > -1)
{
var key = selection.keyframe.Value;
var infoRect = innerRect;
infoRect.x += 5f;
infoRect.width = 100f;
infoRect.height = 30f;
GUI.Label(infoRect, string.Format("{0}\n{1}", key.time.ToString("F3"), key.value.ToString("F3")), FxStyles.preLabel);
}
}
}
/*
EditorGUILayout.HelpBox(
@"Curve editor cheat sheet:
- [Del] or [Backspace] to remove a key
- [Ctrl] to break a tangent handle
- [Shift] to align tangent handles
- [Double click] to create a key on the curve(s) at mouse position
- [Alt] + [Double click] to create a key on the curve(s) at a given time",
MessageType.Info);
*/
EditorGUILayout.Space();
EditorGUI.indentLevel += 2;
}
void DrawBackgroundTexture(Rect rect, int pass)
{
float scale = EditorGUIUtility.pixelsPerPoint;
var oldRt = RenderTexture.active;
var rt = RenderTexture.GetTemporary(Mathf.CeilToInt(rect.width * scale), Mathf.CeilToInt(rect.height * scale), 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
s_MaterialSpline.SetFloat("_DisabledState", GUI.enabled ? 1f : 0.5f);
s_MaterialSpline.SetFloat("_PixelScaling", EditorGUIUtility.pixelsPerPoint);
Graphics.Blit(null, rt, s_MaterialSpline, pass);
RenderTexture.active = oldRt;
GUI.DrawTexture(rect, rt);
RenderTexture.ReleaseTemporary(rt);
}
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: c3e3bce1d5c900d4fa7aa0f2b21814cf
timeCreated: 1467190133
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,22 +0,0 @@
using System.Collections.Generic;
namespace UnityEditor.PostProcessing
{
public class DefaultPostFxModelEditor : PostProcessingModelEditor
{
List<SerializedProperty> m_Properties = new List<SerializedProperty>();
public override void OnEnable()
{
var iter = m_SettingsProperty.Copy().GetEnumerator();
while (iter.MoveNext())
m_Properties.Add(((SerializedProperty)iter.Current).Copy());
}
public override void OnInspectorGUI()
{
foreach (var property in m_Properties)
EditorGUILayout.PropertyField(property);
}
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: c15016a7fef58974f91a6a4d6b132d94
timeCreated: 1467190133
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,37 +0,0 @@
using UnityEngine.PostProcessing;
namespace UnityEditor.PostProcessing
{
using Settings = DepthOfFieldModel.Settings;
[PostProcessingModelEditor(typeof(DepthOfFieldModel))]
public class DepthOfFieldModelEditor : PostProcessingModelEditor
{
SerializedProperty m_FocusDistance;
SerializedProperty m_Aperture;
SerializedProperty m_FocalLength;
SerializedProperty m_UseCameraFov;
SerializedProperty m_KernelSize;
public override void OnEnable()
{
m_FocusDistance = FindSetting((Settings x) => x.focusDistance);
m_Aperture = FindSetting((Settings x) => x.aperture);
m_FocalLength = FindSetting((Settings x) => x.focalLength);
m_UseCameraFov = FindSetting((Settings x) => x.useCameraFov);
m_KernelSize = FindSetting((Settings x) => x.kernelSize);
}
public override void OnInspectorGUI()
{
EditorGUILayout.PropertyField(m_FocusDistance);
EditorGUILayout.PropertyField(m_Aperture, EditorGUIHelper.GetContent("Aperture (f-stop)"));
EditorGUILayout.PropertyField(m_UseCameraFov, EditorGUIHelper.GetContent("Use Camera FOV"));
if (!m_UseCameraFov.boolValue)
EditorGUILayout.PropertyField(m_FocalLength, EditorGUIHelper.GetContent("Focal Length (mm)"));
EditorGUILayout.PropertyField(m_KernelSize);
}
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: dc2f388440e9f8b4f8fc7bb43c01cc7d
timeCreated: 1467190133
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,16 +0,0 @@
using UnityEngine.PostProcessing;
namespace UnityEditor.PostProcessing
{
[PostProcessingModelEditor(typeof(DitheringModel))]
public class DitheringModelEditor : PostProcessingModelEditor
{
public override void OnInspectorGUI()
{
if (profile.grain.enabled && target.enabled)
EditorGUILayout.HelpBox("Grain is enabled, you probably don't need dithering !", MessageType.Warning);
else
EditorGUILayout.HelpBox("Nothing to configure !", MessageType.Info);
}
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: 87377c86d84f49a4e912d37d28353e7f
timeCreated: 1485179854
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,86 +0,0 @@
using UnityEngine;
using UnityEngine.PostProcessing;
namespace UnityEditor.PostProcessing
{
using Settings = EyeAdaptationModel.Settings;
[PostProcessingModelEditor(typeof(EyeAdaptationModel))]
public class EyeAdaptationModelEditor : PostProcessingModelEditor
{
SerializedProperty m_LowPercent;
SerializedProperty m_HighPercent;
SerializedProperty m_MinLuminance;
SerializedProperty m_MaxLuminance;
SerializedProperty m_KeyValue;
SerializedProperty m_DynamicKeyValue;
SerializedProperty m_AdaptationType;
SerializedProperty m_SpeedUp;
SerializedProperty m_SpeedDown;
SerializedProperty m_LogMin;
SerializedProperty m_LogMax;
public override void OnEnable()
{
m_LowPercent = FindSetting((Settings x) => x.lowPercent);
m_HighPercent = FindSetting((Settings x) => x.highPercent);
m_MinLuminance = FindSetting((Settings x) => x.minLuminance);
m_MaxLuminance = FindSetting((Settings x) => x.maxLuminance);
m_KeyValue = FindSetting((Settings x) => x.keyValue);
m_DynamicKeyValue = FindSetting((Settings x) => x.dynamicKeyValue);
m_AdaptationType = FindSetting((Settings x) => x.adaptationType);
m_SpeedUp = FindSetting((Settings x) => x.speedUp);
m_SpeedDown = FindSetting((Settings x) => x.speedDown);
m_LogMin = FindSetting((Settings x) => x.logMin);
m_LogMax = FindSetting((Settings x) => x.logMax);
}
public override void OnInspectorGUI()
{
if (!GraphicsUtils.supportsDX11)
EditorGUILayout.HelpBox("This effect requires support for compute shaders. Enabling it won't do anything on unsupported platforms.", MessageType.Warning);
EditorGUILayout.LabelField("Luminosity range", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_LogMin, EditorGUIHelper.GetContent("Minimum (EV)"));
EditorGUILayout.PropertyField(m_LogMax, EditorGUIHelper.GetContent("Maximum (EV)"));
EditorGUI.indentLevel--;
EditorGUILayout.Space();
EditorGUILayout.LabelField("Auto exposure", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
float low = m_LowPercent.floatValue;
float high = m_HighPercent.floatValue;
EditorGUILayout.MinMaxSlider(EditorGUIHelper.GetContent("Histogram filtering|These values are the lower and upper percentages of the histogram that will be used to find a stable average luminance. Values outside of this range will be discarded and won't contribute to the average luminance."), ref low, ref high, 1f, 99f);
m_LowPercent.floatValue = low;
m_HighPercent.floatValue = high;
EditorGUILayout.PropertyField(m_MinLuminance, EditorGUIHelper.GetContent("Minimum (EV)"));
EditorGUILayout.PropertyField(m_MaxLuminance, EditorGUIHelper.GetContent("Maximum (EV)"));
EditorGUILayout.PropertyField(m_DynamicKeyValue);
if (!m_DynamicKeyValue.boolValue)
EditorGUILayout.PropertyField(m_KeyValue);
EditorGUI.indentLevel--;
EditorGUILayout.Space();
EditorGUILayout.LabelField("Adaptation", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_AdaptationType, EditorGUIHelper.GetContent("Type"));
if (m_AdaptationType.intValue == (int)EyeAdaptationModel.EyeAdaptationType.Progressive)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_SpeedUp);
EditorGUILayout.PropertyField(m_SpeedDown);
EditorGUI.indentLevel--;
}
EditorGUI.indentLevel--;
}
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: 489b5c785ba0f614d90c322fa0827216
timeCreated: 1467190133
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,24 +0,0 @@
using UnityEngine.PostProcessing;
namespace UnityEditor.PostProcessing
{
using Settings = FogModel.Settings;
[PostProcessingModelEditor(typeof(FogModel))]
public class FogModelEditor : PostProcessingModelEditor
{
SerializedProperty m_ExcludeSkybox;
public override void OnEnable()
{
m_ExcludeSkybox = FindSetting((Settings x) => x.excludeSkybox);
}
public override void OnInspectorGUI()
{
EditorGUILayout.HelpBox("This effect adds fog compatibility to the deferred rendering path; enabling it with the forward rendering path won't have any effect. Actual fog settings should be set in the Lighting panel.", MessageType.Info);
EditorGUILayout.PropertyField(m_ExcludeSkybox);
EditorGUI.indentLevel--;
}
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: 44a64b44ec891d24b96ed84d958c3d4f
timeCreated: 1487335049
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,31 +0,0 @@
using UnityEngine.PostProcessing;
namespace UnityEditor.PostProcessing
{
using Settings = GrainModel.Settings;
[PostProcessingModelEditor(typeof(GrainModel))]
public class GrainModelEditor : PostProcessingModelEditor
{
SerializedProperty m_Colored;
SerializedProperty m_Intensity;
SerializedProperty m_Size;
SerializedProperty m_LuminanceContribution;
public override void OnEnable()
{
m_Colored = FindSetting((Settings x) => x.colored);
m_Intensity = FindSetting((Settings x) => x.intensity);
m_Size = FindSetting((Settings x) => x.size);
m_LuminanceContribution = FindSetting((Settings x) => x.luminanceContribution);
}
public override void OnInspectorGUI()
{
EditorGUILayout.PropertyField(m_Intensity);
EditorGUILayout.PropertyField(m_LuminanceContribution);
EditorGUILayout.PropertyField(m_Size);
EditorGUILayout.PropertyField(m_Colored);
}
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: 8330694e2c90c284f81153ac83b3cb4a
timeCreated: 1467190133
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,197 +0,0 @@
using UnityEngine;
using UnityEngine.PostProcessing;
namespace UnityEditor.PostProcessing
{
using Settings = MotionBlurModel.Settings;
[PostProcessingModelEditor(typeof(MotionBlurModel))]
public class MotionBlurModelEditor : PostProcessingModelEditor
{
SerializedProperty m_ShutterAngle;
SerializedProperty m_SampleCount;
SerializedProperty m_FrameBlending;
GraphDrawer m_GraphDrawer;
class GraphDrawer
{
const float k_Height = 32f;
Texture m_BlendingIcon;
GUIStyle m_LowerCenterStyle;
GUIStyle m_MiddleCenterStyle;
Color m_ColorDark;
Color m_ColorGray;
Vector3[] m_RectVertices = new Vector3[4];
public GraphDrawer()
{
m_BlendingIcon = EditorResources.Load<Texture>("UI/MotionBlendingIcon.png");
m_LowerCenterStyle = new GUIStyle(EditorStyles.miniLabel) { alignment = TextAnchor.LowerCenter };
m_MiddleCenterStyle = new GUIStyle(EditorStyles.miniLabel) { alignment = TextAnchor.MiddleCenter };
if (EditorGUIUtility.isProSkin)
{
m_ColorDark = new Color(0.18f, 0.18f, 0.18f);
m_ColorGray = new Color(0.43f, 0.43f, 0.43f);
}
else
{
m_ColorDark = new Color(0.64f, 0.64f, 0.64f);
m_ColorGray = new Color(0.92f, 0.92f, 0.92f);
}
}
public void DrawShutterGraph(float angle)
{
var center = GUILayoutUtility.GetRect(128, k_Height).center;
// Parameters used to make transitions smooth.
var zeroWhenOff = Mathf.Min(1f, angle * 0.1f);
var zeroWhenFull = Mathf.Min(1f, (360f - angle) * 0.02f);
// Shutter angle graph
var discCenter = center - new Vector2(k_Height * 2.4f, 0f);
// - exposure duration indicator
DrawDisc(discCenter, k_Height * Mathf.Lerp(0.5f, 0.38f, zeroWhenFull), m_ColorGray);
// - shutter disc
DrawDisc(discCenter, k_Height * 0.16f * zeroWhenFull, m_ColorDark);
// - shutter blade
DrawArc(discCenter, k_Height * 0.5f, 360f - angle, m_ColorDark);
// - shutter axis
DrawDisc(discCenter, zeroWhenOff, m_ColorGray);
// Shutter label (off/full)
var labelSize = new Vector2(k_Height, k_Height);
var labelOrigin = discCenter - labelSize * 0.5f;
var labelRect = new Rect(labelOrigin, labelSize);
if (Mathf.Approximately(angle, 0f))
GUI.Label(labelRect, "Off", m_MiddleCenterStyle);
else if (Mathf.Approximately(angle, 360f))
GUI.Label(labelRect, "Full", m_MiddleCenterStyle);
// Exposure time bar graph
var outerBarSize = new Vector2(4.75f, 0.5f) * k_Height;
var innerBarSize = outerBarSize;
innerBarSize.x *= angle / 360f;
var barCenter = center + new Vector2(k_Height * 0.9f, 0f);
var barOrigin = barCenter - outerBarSize * 0.5f;
DrawRect(barOrigin, outerBarSize, m_ColorDark);
DrawRect(barOrigin, innerBarSize, m_ColorGray);
var barText = "Exposure time = " + (angle / 3.6f).ToString("0") + "% of ΔT";
GUI.Label(new Rect(barOrigin, outerBarSize), barText, m_MiddleCenterStyle);
}
public void DrawBlendingGraph(float strength)
{
var center = GUILayoutUtility.GetRect(128, k_Height).center;
var iconSize = new Vector2(k_Height, k_Height);
var iconStride = new Vector2(k_Height * 0.9f, 0f);
var iconOrigin = center - iconSize * 0.5f - iconStride * 2f;
for (var i = 0; i < 5; i++)
{
var weight = BlendingWeight(strength, i / 60f);
var rect = new Rect(iconOrigin + iconStride * i, iconSize);
var color = m_ColorGray;
color.a = weight;
GUI.color = color;
GUI.Label(rect, m_BlendingIcon);
GUI.color = Color.white;
GUI.Label(rect, (weight * 100).ToString("0") + "%", m_LowerCenterStyle);
}
// EditorGUIUtility.isProSkin
}
// Weight function for multi frame blending
float BlendingWeight(float strength, float time)
{
if (strength > 0f || Mathf.Approximately(time, 0f))
return Mathf.Exp(-time * Mathf.Lerp(80f, 10f, strength));
return 0;
}
// Draw a solid disc in the graph rect.
void DrawDisc(Vector2 center, float radius, Color fill)
{
Handles.color = fill;
Handles.DrawSolidDisc(center, Vector3.forward, radius);
}
// Draw an arc in the graph rect.
void DrawArc(Vector2 center, float radius, float angle, Color fill)
{
var start = new Vector2(
-Mathf.Cos(Mathf.Deg2Rad * angle / 2f),
Mathf.Sin(Mathf.Deg2Rad * angle / 2f)
);
Handles.color = fill;
Handles.DrawSolidArc(center, Vector3.forward, start, angle, radius);
}
// Draw a rectangle in the graph rect.
void DrawRect(Vector2 origin, Vector2 size, Color color)
{
var p0 = origin;
var p1 = origin + size;
m_RectVertices[0] = p0;
m_RectVertices[1] = new Vector2(p1.x, p0.y);
m_RectVertices[2] = p1;
m_RectVertices[3] = new Vector2(p0.x, p1.y);
Handles.color = Color.white;
Handles.DrawSolidRectangleWithOutline(m_RectVertices, color, Color.clear);
}
}
public override void OnEnable()
{
m_ShutterAngle = FindSetting((Settings x) => x.shutterAngle);
m_SampleCount = FindSetting((Settings x) => x.sampleCount);
m_FrameBlending = FindSetting((Settings x) => x.frameBlending);
}
public override void OnInspectorGUI()
{
if (m_GraphDrawer == null)
m_GraphDrawer = new GraphDrawer();
EditorGUILayout.LabelField("Shutter Speed Simulation", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
m_GraphDrawer.DrawShutterGraph(m_ShutterAngle.floatValue);
EditorGUILayout.PropertyField(m_ShutterAngle);
EditorGUILayout.PropertyField(m_SampleCount);
EditorGUI.indentLevel--;
EditorGUILayout.Space();
EditorGUILayout.LabelField("Multiple Frame Blending", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
float fbValue = m_FrameBlending.floatValue;
m_GraphDrawer.DrawBlendingGraph(fbValue);
EditorGUILayout.PropertyField(m_FrameBlending);
if (fbValue > 0f)
EditorGUILayout.HelpBox("Multi-Frame Blending lowers precision of the final picture for optimization purposes.", MessageType.Info);
EditorGUI.indentLevel--;
}
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: 870806eda355b5144879155e2ba37eb6
timeCreated: 1468325681
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,100 +0,0 @@
using UnityEngine;
using UnityEngine.PostProcessing;
namespace UnityEditor.PostProcessing
{
using Settings = ScreenSpaceReflectionModel.Settings;
[PostProcessingModelEditor(typeof(ScreenSpaceReflectionModel))]
public class ScreenSpaceReflectionModelEditor : PostProcessingModelEditor
{
struct IntensitySettings
{
public SerializedProperty reflectionMultiplier;
public SerializedProperty fadeDistance;
public SerializedProperty fresnelFade;
public SerializedProperty fresnelFadePower;
}
struct ReflectionSettings
{
public SerializedProperty blendType;
public SerializedProperty reflectionQuality;
public SerializedProperty maxDistance;
public SerializedProperty iterationCount;
public SerializedProperty stepSize;
public SerializedProperty widthModifier;
public SerializedProperty reflectionBlur;
public SerializedProperty reflectBackfaces;
}
struct ScreenEdgeMask
{
public SerializedProperty intensity;
}
IntensitySettings m_Intensity;
ReflectionSettings m_Reflection;
ScreenEdgeMask m_ScreenEdgeMask;
public override void OnEnable()
{
m_Intensity = new IntensitySettings
{
reflectionMultiplier = FindSetting((Settings x) => x.intensity.reflectionMultiplier),
fadeDistance = FindSetting((Settings x) => x.intensity.fadeDistance),
fresnelFade = FindSetting((Settings x) => x.intensity.fresnelFade),
fresnelFadePower = FindSetting((Settings x) => x.intensity.fresnelFadePower)
};
m_Reflection = new ReflectionSettings
{
blendType = FindSetting((Settings x) => x.reflection.blendType),
reflectionQuality = FindSetting((Settings x) => x.reflection.reflectionQuality),
maxDistance = FindSetting((Settings x) => x.reflection.maxDistance),
iterationCount = FindSetting((Settings x) => x.reflection.iterationCount),
stepSize = FindSetting((Settings x) => x.reflection.stepSize),
widthModifier = FindSetting((Settings x) => x.reflection.widthModifier),
reflectionBlur = FindSetting((Settings x) => x.reflection.reflectionBlur),
reflectBackfaces = FindSetting((Settings x) => x.reflection.reflectBackfaces)
};
m_ScreenEdgeMask = new ScreenEdgeMask
{
intensity = FindSetting((Settings x) => x.screenEdgeMask.intensity)
};
}
public override void OnInspectorGUI()
{
EditorGUILayout.HelpBox("This effect only works with the deferred rendering path.", MessageType.Info);
EditorGUILayout.LabelField("Reflection", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_Reflection.blendType);
EditorGUILayout.PropertyField(m_Reflection.reflectionQuality);
EditorGUILayout.PropertyField(m_Reflection.maxDistance);
EditorGUILayout.PropertyField(m_Reflection.iterationCount);
EditorGUILayout.PropertyField(m_Reflection.stepSize);
EditorGUILayout.PropertyField(m_Reflection.widthModifier);
EditorGUILayout.PropertyField(m_Reflection.reflectionBlur);
EditorGUILayout.PropertyField(m_Reflection.reflectBackfaces);
EditorGUI.indentLevel--;
EditorGUILayout.Space();
EditorGUILayout.LabelField("Intensity", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_Intensity.reflectionMultiplier);
EditorGUILayout.PropertyField(m_Intensity.fadeDistance);
EditorGUILayout.PropertyField(m_Intensity.fresnelFade);
EditorGUILayout.PropertyField(m_Intensity.fresnelFadePower);
EditorGUI.indentLevel--;
EditorGUILayout.Space();
EditorGUILayout.LabelField("Screen Edge Mask", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_ScreenEdgeMask.intensity);
EditorGUI.indentLevel--;
}
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: 57bbe1f20eec7bb4d9bc90fc65ef381b
timeCreated: 1467190133
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,87 +0,0 @@
using UnityEngine;
using UnityEngine.PostProcessing;
namespace UnityEditor.PostProcessing
{
using Settings = UserLutModel.Settings;
[PostProcessingModelEditor(typeof(UserLutModel))]
public class UserLutModelEditor : PostProcessingModelEditor
{
SerializedProperty m_Texture;
SerializedProperty m_Contribution;
public override void OnEnable()
{
m_Texture = FindSetting((Settings x) => x.lut);
m_Contribution = FindSetting((Settings x) => x.contribution);
}
public override void OnInspectorGUI()
{
var lut = (target as UserLutModel).settings.lut;
// Checks import settings on the lut, offers to fix them if invalid
if (lut != null)
{
var importer = (TextureImporter)AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(lut));
if (importer != null) // Fails when using an internal texture
{
#if UNITY_5_5_OR_NEWER
bool valid = importer.anisoLevel == 0
&& importer.mipmapEnabled == false
&& importer.sRGBTexture == false
&& (importer.textureCompression == TextureImporterCompression.Uncompressed);
#else
bool valid = importer.anisoLevel == 0
&& importer.mipmapEnabled == false
&& importer.linearTexture == true
&& (importer.textureFormat == TextureImporterFormat.RGB24 || importer.textureFormat == TextureImporterFormat.AutomaticTruecolor);
#endif
if (!valid)
{
EditorGUILayout.HelpBox("Invalid LUT import settings.", MessageType.Warning);
GUILayout.Space(-32);
using (new EditorGUILayout.HorizontalScope())
{
GUILayout.FlexibleSpace();
if (GUILayout.Button("Fix", GUILayout.Width(60)))
{
SetLUTImportSettings(importer);
AssetDatabase.Refresh();
}
GUILayout.Space(8);
}
GUILayout.Space(11);
}
}
else
{
m_Texture.objectReferenceValue = null;
}
}
EditorGUILayout.PropertyField(m_Texture);
EditorGUILayout.PropertyField(m_Contribution);
}
void SetLUTImportSettings(TextureImporter importer)
{
#if UNITY_5_5_OR_NEWER
importer.textureType = TextureImporterType.Default;
importer.sRGBTexture = false;
importer.textureCompression = TextureImporterCompression.Uncompressed;
#else
importer.textureType = TextureImporterType.Advanced;
importer.linearTexture = true;
importer.textureFormat = TextureImporterFormat.RGB24;
#endif
importer.anisoLevel = 0;
importer.mipmapEnabled = false;
importer.SaveAndReimport();
}
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: b235eb1c486b38c4fa06470234bbfd32
timeCreated: 1466769818
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,118 +0,0 @@
using UnityEngine;
using UnityEngine.PostProcessing;
namespace UnityEditor.PostProcessing
{
using VignetteMode = VignetteModel.Mode;
using Settings = VignetteModel.Settings;
[PostProcessingModelEditor(typeof(VignetteModel))]
public class VignetteModelEditor : PostProcessingModelEditor
{
SerializedProperty m_Mode;
SerializedProperty m_Color;
SerializedProperty m_Center;
SerializedProperty m_Intensity;
SerializedProperty m_Smoothness;
SerializedProperty m_Roundness;
SerializedProperty m_Mask;
SerializedProperty m_Opacity;
SerializedProperty m_Rounded;
public override void OnEnable()
{
m_Mode = FindSetting((Settings x) => x.mode);
m_Color = FindSetting((Settings x) => x.color);
m_Center = FindSetting((Settings x) => x.center);
m_Intensity = FindSetting((Settings x) => x.intensity);
m_Smoothness = FindSetting((Settings x) => x.smoothness);
m_Roundness = FindSetting((Settings x) => x.roundness);
m_Mask = FindSetting((Settings x) => x.mask);
m_Opacity = FindSetting((Settings x) => x.opacity);
m_Rounded = FindSetting((Settings x) => x.rounded);
}
public override void OnInspectorGUI()
{
EditorGUILayout.PropertyField(m_Mode);
EditorGUILayout.PropertyField(m_Color);
if (m_Mode.intValue < (int)VignetteMode.Masked)
{
EditorGUILayout.PropertyField(m_Center);
EditorGUILayout.PropertyField(m_Intensity);
EditorGUILayout.PropertyField(m_Smoothness);
EditorGUILayout.PropertyField(m_Roundness);
EditorGUILayout.PropertyField(m_Rounded);
}
else
{
var mask = (target as VignetteModel).settings.mask;
// Checks import settings on the mask, offers to fix them if invalid
if (mask != null)
{
var importer = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(mask)) as TextureImporter;
if (importer != null) // Fails when using an internal texture
{
#if UNITY_5_5_OR_NEWER
bool valid = importer.anisoLevel == 0
&& importer.mipmapEnabled == false
//&& importer.alphaUsage == TextureImporterAlphaUsage.FromGrayScale
&& importer.alphaSource == TextureImporterAlphaSource.FromGrayScale
&& importer.textureCompression == TextureImporterCompression.Uncompressed
&& importer.wrapMode == TextureWrapMode.Clamp;
#else
bool valid = importer.anisoLevel == 0
&& importer.mipmapEnabled == false
&& importer.grayscaleToAlpha == true
&& importer.textureFormat == TextureImporterFormat.Alpha8
&& importer.wrapMode == TextureWrapMode.Clamp;
#endif
if (!valid)
{
EditorGUILayout.HelpBox("Invalid mask import settings.", MessageType.Warning);
GUILayout.Space(-32);
using (new EditorGUILayout.HorizontalScope())
{
GUILayout.FlexibleSpace();
if (GUILayout.Button("Fix", GUILayout.Width(60)))
{
SetMaskImportSettings(importer);
AssetDatabase.Refresh();
}
GUILayout.Space(8);
}
GUILayout.Space(11);
}
}
}
EditorGUILayout.PropertyField(m_Mask);
EditorGUILayout.PropertyField(m_Opacity);
}
}
void SetMaskImportSettings(TextureImporter importer)
{
#if UNITY_5_5_OR_NEWER
importer.textureType = TextureImporterType.SingleChannel;
//importer.alphaUsage = TextureImporterAlphaUsage.FromGrayScale;
importer.alphaSource = TextureImporterAlphaSource.FromGrayScale;
importer.textureCompression = TextureImporterCompression.Uncompressed;
#else
importer.textureType = TextureImporterType.Advanced;
importer.grayscaleToAlpha = true;
importer.textureFormat = TextureImporterFormat.Alpha8;
#endif
importer.anisoLevel = 0;
importer.mipmapEnabled = false;
importer.wrapMode = TextureWrapMode.Clamp;
importer.SaveAndReimport();
}
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: 745ad42620dabf04b94761acc86189ba
timeCreated: 1467190133
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: e31078d57ac582944ad5e1e76a84f36a
folderAsset: yes
timeCreated: 1467188891
licenseType: Pro
DefaultImporter:
userData:
assetBundleName:
assetBundleVariant:

@ -1,338 +0,0 @@
using UnityEditorInternal;
using UnityEngine;
using UnityEngine.PostProcessing;
namespace UnityEditor.PostProcessing
{
using HistogramMode = PostProcessingProfile.MonitorSettings.HistogramMode;
public class HistogramMonitor : PostProcessingMonitor
{
static GUIContent s_MonitorTitle = new GUIContent("Histogram");
ComputeShader m_ComputeShader;
ComputeBuffer m_Buffer;
Material m_Material;
RenderTexture m_HistogramTexture;
Rect m_MonitorAreaRect;
public HistogramMonitor()
{
m_ComputeShader = EditorResources.Load<ComputeShader>("Monitors/HistogramCompute.compute");
}
public override void Dispose()
{
GraphicsUtils.Destroy(m_Material);
GraphicsUtils.Destroy(m_HistogramTexture);
if (m_Buffer != null)
m_Buffer.Release();
m_Material = null;
m_HistogramTexture = null;
m_Buffer = null;
}
public override bool IsSupported()
{
return m_ComputeShader != null && GraphicsUtils.supportsDX11;
}
public override GUIContent GetMonitorTitle()
{
return s_MonitorTitle;
}
public override void OnMonitorSettings()
{
EditorGUI.BeginChangeCheck();
bool refreshOnPlay = m_MonitorSettings.refreshOnPlay;
var mode = m_MonitorSettings.histogramMode;
refreshOnPlay = GUILayout.Toggle(refreshOnPlay, new GUIContent(FxStyles.playIcon, "Keep refreshing the histogram in play mode; this may impact performances."), FxStyles.preButton);
mode = (HistogramMode)EditorGUILayout.EnumPopup(mode, FxStyles.preDropdown, GUILayout.MaxWidth(100f));
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(m_BaseEditor.serializedObject.targetObject, "Histogram Settings Changed");
m_MonitorSettings.refreshOnPlay = refreshOnPlay;
m_MonitorSettings.histogramMode = mode;
InternalEditorUtility.RepaintAllViews();
}
}
public override void OnMonitorGUI(Rect r)
{
if (Event.current.type == EventType.Repaint)
{
// If m_MonitorAreaRect isn't set the preview was just opened so refresh the render to get the histogram data
if (Mathf.Approximately(m_MonitorAreaRect.width, 0) && Mathf.Approximately(m_MonitorAreaRect.height, 0))
InternalEditorUtility.RepaintAllViews();
// Sizing
float width = m_HistogramTexture != null
? Mathf.Min(m_HistogramTexture.width, r.width - 65f)
: r.width;
float height = m_HistogramTexture != null
? Mathf.Min(m_HistogramTexture.height, r.height - 45f)
: r.height;
m_MonitorAreaRect = new Rect(
Mathf.Floor(r.x + r.width / 2f - width / 2f),
Mathf.Floor(r.y + r.height / 2f - height / 2f - 5f),
width, height
);
if (m_HistogramTexture != null)
{
Graphics.DrawTexture(m_MonitorAreaRect, m_HistogramTexture);
var color = Color.white;
const float kTickSize = 5f;
// Rect, lines & ticks points
if (m_MonitorSettings.histogramMode == HistogramMode.RGBSplit)
{
// A B C D E
// N F
// M G
// L K J I H
var A = new Vector3(m_MonitorAreaRect.x - 1f, m_MonitorAreaRect.y - 1f);
var E = new Vector3(A.x + m_MonitorAreaRect.width + 2f, m_MonitorAreaRect.y - 1f);
var H = new Vector3(E.x, E.y + m_MonitorAreaRect.height + 2f);
var L = new Vector3(A.x, H.y);
var N = new Vector3(A.x, A.y + (L.y - A.y) / 3f);
var M = new Vector3(A.x, A.y + (L.y - A.y) * 2f / 3f);
var F = new Vector3(E.x, E.y + (H.y - E.y) / 3f);
var G = new Vector3(E.x, E.y + (H.y - E.y) * 2f / 3f);
var C = new Vector3(A.x + (E.x - A.x) / 2f, A.y);
var J = new Vector3(L.x + (H.x - L.x) / 2f, L.y);
var B = new Vector3(A.x + (C.x - A.x) / 2f, A.y);
var D = new Vector3(C.x + (E.x - C.x) / 2f, C.y);
var I = new Vector3(J.x + (H.x - J.x) / 2f, J.y);
var K = new Vector3(L.x + (J.x - L.x) / 2f, L.y);
// Borders
Handles.color = color;
Handles.DrawLine(A, E);
Handles.DrawLine(E, H);
Handles.DrawLine(H, L);
Handles.DrawLine(L, new Vector3(A.x, A.y - 1f));
// Vertical ticks
Handles.DrawLine(A, new Vector3(A.x - kTickSize, A.y));
Handles.DrawLine(N, new Vector3(N.x - kTickSize, N.y));
Handles.DrawLine(M, new Vector3(M.x - kTickSize, M.y));
Handles.DrawLine(L, new Vector3(L.x - kTickSize, L.y));
Handles.DrawLine(E, new Vector3(E.x + kTickSize, E.y));
Handles.DrawLine(F, new Vector3(F.x + kTickSize, F.y));
Handles.DrawLine(G, new Vector3(G.x + kTickSize, G.y));
Handles.DrawLine(H, new Vector3(H.x + kTickSize, H.y));
// Horizontal ticks
Handles.DrawLine(A, new Vector3(A.x, A.y - kTickSize));
Handles.DrawLine(B, new Vector3(B.x, B.y - kTickSize));
Handles.DrawLine(C, new Vector3(C.x, C.y - kTickSize));
Handles.DrawLine(D, new Vector3(D.x, D.y - kTickSize));
Handles.DrawLine(E, new Vector3(E.x, E.y - kTickSize));
Handles.DrawLine(L, new Vector3(L.x, L.y + kTickSize));
Handles.DrawLine(K, new Vector3(K.x, K.y + kTickSize));
Handles.DrawLine(J, new Vector3(J.x, J.y + kTickSize));
Handles.DrawLine(I, new Vector3(I.x, I.y + kTickSize));
Handles.DrawLine(H, new Vector3(H.x, H.y + kTickSize));
// Separators
Handles.DrawLine(N, F);
Handles.DrawLine(M, G);
// Labels
GUI.color = color;
GUI.Label(new Rect(L.x - 15f, L.y + kTickSize - 4f, 30f, 30f), "0.0", FxStyles.tickStyleCenter);
GUI.Label(new Rect(J.x - 15f, J.y + kTickSize - 4f, 30f, 30f), "0.5", FxStyles.tickStyleCenter);
GUI.Label(new Rect(H.x - 15f, H.y + kTickSize - 4f, 30f, 30f), "1.0", FxStyles.tickStyleCenter);
}
else
{
// A B C D E
// P F
// O G
// N H
// M L K J I
var A = new Vector3(m_MonitorAreaRect.x, m_MonitorAreaRect.y);
var E = new Vector3(A.x + m_MonitorAreaRect.width + 1f, m_MonitorAreaRect.y);
var I = new Vector3(E.x, E.y + m_MonitorAreaRect.height + 1f);
var M = new Vector3(A.x, I.y);
var C = new Vector3(A.x + (E.x - A.x) / 2f, A.y);
var G = new Vector3(E.x, E.y + (I.y - E.y) / 2f);
var K = new Vector3(M.x + (I.x - M.x) / 2f, M.y);
var O = new Vector3(A.x, A.y + (M.y - A.y) / 2f);
var P = new Vector3(A.x, A.y + (O.y - A.y) / 2f);
var F = new Vector3(E.x, E.y + (G.y - E.y) / 2f);
var N = new Vector3(A.x, O.y + (M.y - O.y) / 2f);
var H = new Vector3(E.x, G.y + (I.y - G.y) / 2f);
var B = new Vector3(A.x + (C.x - A.x) / 2f, A.y);
var L = new Vector3(M.x + (K.x - M.x) / 2f, M.y);
var D = new Vector3(C.x + (E.x - C.x) / 2f, A.y);
var J = new Vector3(K.x + (I.x - K.x) / 2f, M.y);
// Borders
Handles.color = color;
Handles.DrawLine(A, E);
Handles.DrawLine(E, I);
Handles.DrawLine(I, M);
Handles.DrawLine(M, new Vector3(A.x, A.y - 1f));
// Vertical ticks
Handles.DrawLine(A, new Vector3(A.x - kTickSize, A.y));
Handles.DrawLine(P, new Vector3(P.x - kTickSize, P.y));
Handles.DrawLine(O, new Vector3(O.x - kTickSize, O.y));
Handles.DrawLine(N, new Vector3(N.x - kTickSize, N.y));
Handles.DrawLine(M, new Vector3(M.x - kTickSize, M.y));
Handles.DrawLine(E, new Vector3(E.x + kTickSize, E.y));
Handles.DrawLine(F, new Vector3(F.x + kTickSize, F.y));
Handles.DrawLine(G, new Vector3(G.x + kTickSize, G.y));
Handles.DrawLine(H, new Vector3(H.x + kTickSize, H.y));
Handles.DrawLine(I, new Vector3(I.x + kTickSize, I.y));
// Horizontal ticks
Handles.DrawLine(A, new Vector3(A.x, A.y - kTickSize));
Handles.DrawLine(B, new Vector3(B.x, B.y - kTickSize));
Handles.DrawLine(C, new Vector3(C.x, C.y - kTickSize));
Handles.DrawLine(D, new Vector3(D.x, D.y - kTickSize));
Handles.DrawLine(E, new Vector3(E.x, E.y - kTickSize));
Handles.DrawLine(M, new Vector3(M.x, M.y + kTickSize));
Handles.DrawLine(L, new Vector3(L.x, L.y + kTickSize));
Handles.DrawLine(K, new Vector3(K.x, K.y + kTickSize));
Handles.DrawLine(J, new Vector3(J.x, J.y + kTickSize));
Handles.DrawLine(I, new Vector3(I.x, I.y + kTickSize));
// Labels
GUI.color = color;
GUI.Label(new Rect(A.x - kTickSize - 34f, A.y - 15f, 30f, 30f), "1.0", FxStyles.tickStyleRight);
GUI.Label(new Rect(O.x - kTickSize - 34f, O.y - 15f, 30f, 30f), "0.5", FxStyles.tickStyleRight);
GUI.Label(new Rect(M.x - kTickSize - 34f, M.y - 15f, 30f, 30f), "0.0", FxStyles.tickStyleRight);
GUI.Label(new Rect(E.x + kTickSize + 4f, E.y - 15f, 30f, 30f), "1.0", FxStyles.tickStyleLeft);
GUI.Label(new Rect(G.x + kTickSize + 4f, G.y - 15f, 30f, 30f), "0.5", FxStyles.tickStyleLeft);
GUI.Label(new Rect(I.x + kTickSize + 4f, I.y - 15f, 30f, 30f), "0.0", FxStyles.tickStyleLeft);
GUI.Label(new Rect(M.x - 15f, M.y + kTickSize - 4f, 30f, 30f), "0.0", FxStyles.tickStyleCenter);
GUI.Label(new Rect(K.x - 15f, K.y + kTickSize - 4f, 30f, 30f), "0.5", FxStyles.tickStyleCenter);
GUI.Label(new Rect(I.x - 15f, I.y + kTickSize - 4f, 30f, 30f), "1.0", FxStyles.tickStyleCenter);
}
}
}
}
public override void OnFrameData(RenderTexture source)
{
if (Application.isPlaying && !m_MonitorSettings.refreshOnPlay)
return;
if (Mathf.Approximately(m_MonitorAreaRect.width, 0) || Mathf.Approximately(m_MonitorAreaRect.height, 0))
return;
float ratio = (float)source.width / (float)source.height;
int h = 512;
int w = Mathf.FloorToInt(h * ratio);
var rt = RenderTexture.GetTemporary(w, h, 0, source.format);
Graphics.Blit(source, rt);
ComputeHistogram(rt);
m_BaseEditor.Repaint();
RenderTexture.ReleaseTemporary(rt);
}
void CreateBuffer(int width, int height)
{
m_Buffer = new ComputeBuffer(width * height, sizeof(uint) << 2);
}
void ComputeHistogram(RenderTexture source)
{
if (m_Buffer == null)
{
CreateBuffer(256, 1);
}
else if (m_Buffer.count != 256)
{
m_Buffer.Release();
CreateBuffer(256, 1);
}
if (m_Material == null)
{
m_Material = new Material(Shader.Find("Hidden/Post FX/Monitors/Histogram Render")) { hideFlags = HideFlags.DontSave };
}
var channels = Vector4.zero;
switch (m_MonitorSettings.histogramMode)
{
case HistogramMode.Red: channels.x = 1f; break;
case HistogramMode.Green: channels.y = 1f; break;
case HistogramMode.Blue: channels.z = 1f; break;
case HistogramMode.Luminance: channels.w = 1f; break;
default: channels = new Vector4(1f, 1f, 1f, 0f); break;
}
var cs = m_ComputeShader;
int kernel = cs.FindKernel("KHistogramClear");
cs.SetBuffer(kernel, "_Histogram", m_Buffer);
cs.Dispatch(kernel, 1, 1, 1);
kernel = cs.FindKernel("KHistogramGather");
cs.SetBuffer(kernel, "_Histogram", m_Buffer);
cs.SetTexture(kernel, "_Source", source);
cs.SetInt("_IsLinear", GraphicsUtils.isLinearColorSpace ? 1 : 0);
cs.SetVector("_Res", new Vector4(source.width, source.height, 0f, 0f));
cs.SetVector("_Channels", channels);
cs.Dispatch(kernel, Mathf.CeilToInt(source.width / 16f), Mathf.CeilToInt(source.height / 16f), 1);
kernel = cs.FindKernel("KHistogramScale");
cs.SetBuffer(kernel, "_Histogram", m_Buffer);
cs.Dispatch(kernel, 1, 1, 1);
if (m_HistogramTexture == null || m_HistogramTexture.width != source.width || m_HistogramTexture.height != source.height)
{
GraphicsUtils.Destroy(m_HistogramTexture);
m_HistogramTexture = new RenderTexture(source.width, source.height, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear)
{
hideFlags = HideFlags.DontSave,
wrapMode = TextureWrapMode.Clamp,
filterMode = FilterMode.Bilinear
};
}
m_Material.SetBuffer("_Histogram", m_Buffer);
m_Material.SetVector("_Size", new Vector2(m_HistogramTexture.width, m_HistogramTexture.height));
m_Material.SetColor("_ColorR", new Color(1f, 0f, 0f, 1f));
m_Material.SetColor("_ColorG", new Color(0f, 1f, 0f, 1f));
m_Material.SetColor("_ColorB", new Color(0f, 0f, 1f, 1f));
m_Material.SetColor("_ColorL", new Color(1f, 1f, 1f, 1f));
m_Material.SetInt("_Channel", (int)m_MonitorSettings.histogramMode);
int pass = 0;
if (m_MonitorSettings.histogramMode == HistogramMode.RGBMerged)
pass = 1;
else if (m_MonitorSettings.histogramMode == HistogramMode.RGBSplit)
pass = 2;
Graphics.Blit(null, m_HistogramTexture, m_Material, pass);
}
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: 4581c45ac4aa2264187087659a4cc252
timeCreated: 1460031632
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,257 +0,0 @@
using UnityEditorInternal;
using UnityEngine;
using UnityEngine.PostProcessing;
namespace UnityEditor.PostProcessing
{
public class ParadeMonitor : PostProcessingMonitor
{
static GUIContent s_MonitorTitle = new GUIContent("Parade");
ComputeShader m_ComputeShader;
ComputeBuffer m_Buffer;
Material m_Material;
RenderTexture m_WaveformTexture;
Rect m_MonitorAreaRect;
public ParadeMonitor()
{
m_ComputeShader = EditorResources.Load<ComputeShader>("Monitors/WaveformCompute.compute");
}
public override void Dispose()
{
GraphicsUtils.Destroy(m_Material);
GraphicsUtils.Destroy(m_WaveformTexture);
if (m_Buffer != null)
m_Buffer.Release();
m_Material = null;
m_WaveformTexture = null;
m_Buffer = null;
}
public override bool IsSupported()
{
return m_ComputeShader != null && GraphicsUtils.supportsDX11;
}
public override GUIContent GetMonitorTitle()
{
return s_MonitorTitle;
}
public override void OnMonitorSettings()
{
EditorGUI.BeginChangeCheck();
bool refreshOnPlay = m_MonitorSettings.refreshOnPlay;
float exposure = m_MonitorSettings.paradeExposure;
refreshOnPlay = GUILayout.Toggle(refreshOnPlay, new GUIContent(FxStyles.playIcon, "Keep refreshing the parade in play mode; this may impact performances."), FxStyles.preButton);
exposure = GUILayout.HorizontalSlider(exposure, 0.05f, 0.3f, FxStyles.preSlider, FxStyles.preSliderThumb, GUILayout.Width(40f));
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(m_BaseEditor.serializedObject.targetObject, "Parade Settings Changed");
m_MonitorSettings.refreshOnPlay = refreshOnPlay;
m_MonitorSettings.paradeExposure = exposure;
InternalEditorUtility.RepaintAllViews();
}
}
public override void OnMonitorGUI(Rect r)
{
if (Event.current.type == EventType.Repaint)
{
// If m_MonitorAreaRect isn't set the preview was just opened so refresh the render to get the waveform data
if (Mathf.Approximately(m_MonitorAreaRect.width, 0) && Mathf.Approximately(m_MonitorAreaRect.height, 0))
InternalEditorUtility.RepaintAllViews();
// Sizing
float width = m_WaveformTexture != null
? Mathf.Min(m_WaveformTexture.width, r.width - 65f)
: r.width;
float height = m_WaveformTexture != null
? Mathf.Min(m_WaveformTexture.height, r.height - 45f)
: r.height;
m_MonitorAreaRect = new Rect(
Mathf.Floor(r.x + r.width / 2f - width / 2f),
Mathf.Floor(r.y + r.height / 2f - height / 2f - 5f),
width, height
);
if (m_WaveformTexture != null)
{
m_Material.SetFloat("_Exposure", m_MonitorSettings.paradeExposure);
var oldActive = RenderTexture.active;
Graphics.Blit(null, m_WaveformTexture, m_Material, 0);
RenderTexture.active = oldActive;
Graphics.DrawTexture(m_MonitorAreaRect, m_WaveformTexture);
var color = Color.white;
const float kTickSize = 5f;
// Rect, lines & ticks points
// A O B P C Q D
// N E
// M F
// L G
// K T J S I R H
var A = new Vector3(m_MonitorAreaRect.x, m_MonitorAreaRect.y);
var D = new Vector3(A.x + m_MonitorAreaRect.width + 1f, m_MonitorAreaRect.y);
var H = new Vector3(D.x, D.y + m_MonitorAreaRect.height + 1f);
var K = new Vector3(A.x, H.y);
var F = new Vector3(D.x, D.y + (H.y - D.y) / 2f);
var M = new Vector3(A.x, A.y + (K.y - A.y) / 2f);
var B = new Vector3(A.x + (D.x - A.x) / 3f, A.y);
var C = new Vector3(A.x + (D.x - A.x) * 2f / 3f, A.y);
var I = new Vector3(K.x + (H.x - K.x) * 2f / 3f, K.y);
var J = new Vector3(K.x + (H.x - K.x) / 3f, K.y);
var N = new Vector3(A.x, A.y + (M.y - A.y) / 2f);
var L = new Vector3(A.x, M.y + (K.y - M.y) / 2f);
var E = new Vector3(D.x, D.y + (F.y - D.y) / 2f);
var G = new Vector3(D.x, F.y + (H.y - F.y) / 2f);
var O = new Vector3(A.x + (B.x - A.x) / 2f, A.y);
var P = new Vector3(B.x + (C.x - B.x) / 2f, B.y);
var Q = new Vector3(C.x + (D.x - C.x) / 2f, C.y);
var R = new Vector3(I.x + (H.x - I.x) / 2f, I.y);
var S = new Vector3(J.x + (I.x - J.x) / 2f, J.y);
var T = new Vector3(K.x + (J.x - K.x) / 2f, K.y);
// Borders
Handles.color = color;
Handles.DrawLine(A, D);
Handles.DrawLine(D, H);
Handles.DrawLine(H, K);
Handles.DrawLine(K, new Vector3(A.x, A.y - 1f));
Handles.DrawLine(B, J);
Handles.DrawLine(C, I);
// Vertical ticks
Handles.DrawLine(A, new Vector3(A.x - kTickSize, A.y));
Handles.DrawLine(N, new Vector3(N.x - kTickSize, N.y));
Handles.DrawLine(M, new Vector3(M.x - kTickSize, M.y));
Handles.DrawLine(L, new Vector3(L.x - kTickSize, L.y));
Handles.DrawLine(K, new Vector3(K.x - kTickSize, K.y));
Handles.DrawLine(D, new Vector3(D.x + kTickSize, D.y));
Handles.DrawLine(E, new Vector3(E.x + kTickSize, E.y));
Handles.DrawLine(F, new Vector3(F.x + kTickSize, F.y));
Handles.DrawLine(G, new Vector3(G.x + kTickSize, G.y));
Handles.DrawLine(H, new Vector3(H.x + kTickSize, H.y));
// Horizontal ticks
Handles.DrawLine(A, new Vector3(A.x, A.y - kTickSize));
Handles.DrawLine(B, new Vector3(B.x, B.y - kTickSize));
Handles.DrawLine(C, new Vector3(C.x, C.y - kTickSize));
Handles.DrawLine(D, new Vector3(D.x, D.y - kTickSize));
Handles.DrawLine(O, new Vector3(O.x, O.y - kTickSize));
Handles.DrawLine(P, new Vector3(P.x, P.y - kTickSize));
Handles.DrawLine(Q, new Vector3(Q.x, Q.y - kTickSize));
Handles.DrawLine(H, new Vector3(H.x, H.y + kTickSize));
Handles.DrawLine(I, new Vector3(I.x, I.y + kTickSize));
Handles.DrawLine(J, new Vector3(J.x, J.y + kTickSize));
Handles.DrawLine(K, new Vector3(K.x, K.y + kTickSize));
Handles.DrawLine(R, new Vector3(R.x, R.y + kTickSize));
Handles.DrawLine(S, new Vector3(S.x, S.y + kTickSize));
Handles.DrawLine(T, new Vector3(T.x, T.y + kTickSize));
// Labels
GUI.color = color;
GUI.Label(new Rect(A.x - kTickSize - 34f, A.y - 15f, 30f, 30f), "1.0", FxStyles.tickStyleRight);
GUI.Label(new Rect(M.x - kTickSize - 34f, M.y - 15f, 30f, 30f), "0.5", FxStyles.tickStyleRight);
GUI.Label(new Rect(K.x - kTickSize - 34f, K.y - 15f, 30f, 30f), "0.0", FxStyles.tickStyleRight);
GUI.Label(new Rect(D.x + kTickSize + 4f, D.y - 15f, 30f, 30f), "1.0", FxStyles.tickStyleLeft);
GUI.Label(new Rect(F.x + kTickSize + 4f, F.y - 15f, 30f, 30f), "0.5", FxStyles.tickStyleLeft);
GUI.Label(new Rect(H.x + kTickSize + 4f, H.y - 15f, 30f, 30f), "0.0", FxStyles.tickStyleLeft);
}
}
}
public override void OnFrameData(RenderTexture source)
{
if (Application.isPlaying && !m_MonitorSettings.refreshOnPlay)
return;
if (Mathf.Approximately(m_MonitorAreaRect.width, 0) || Mathf.Approximately(m_MonitorAreaRect.height, 0))
return;
float ratio = ((float)source.width / (float)source.height) / 3f;
int h = 384;
int w = Mathf.FloorToInt(h * ratio);
var rt = RenderTexture.GetTemporary(w, h, 0, source.format);
Graphics.Blit(source, rt);
ComputeWaveform(rt);
m_BaseEditor.Repaint();
RenderTexture.ReleaseTemporary(rt);
}
void CreateBuffer(int width, int height)
{
m_Buffer = new ComputeBuffer(width * height, sizeof(uint) << 2);
}
void ComputeWaveform(RenderTexture source)
{
if (m_Buffer == null)
{
CreateBuffer(source.width, source.height);
}
else if (m_Buffer.count != (source.width * source.height))
{
m_Buffer.Release();
CreateBuffer(source.width, source.height);
}
var channels = m_MonitorSettings.waveformY
? new Vector4(0f, 0f, 0f, 1f)
: new Vector4(m_MonitorSettings.waveformR ? 1f : 0f, m_MonitorSettings.waveformG ? 1f : 0f, m_MonitorSettings.waveformB ? 1f : 0f, 0f);
var cs = m_ComputeShader;
int kernel = cs.FindKernel("KWaveformClear");
cs.SetBuffer(kernel, "_Waveform", m_Buffer);
cs.Dispatch(kernel, source.width, 1, 1);
kernel = cs.FindKernel("KWaveform");
cs.SetBuffer(kernel, "_Waveform", m_Buffer);
cs.SetTexture(kernel, "_Source", source);
cs.SetInt("_IsLinear", GraphicsUtils.isLinearColorSpace ? 1 : 0);
cs.SetVector("_Channels", channels);
cs.Dispatch(kernel, source.width, 1, 1);
if (m_WaveformTexture == null || m_WaveformTexture.width != (source.width * 3) || m_WaveformTexture.height != source.height)
{
GraphicsUtils.Destroy(m_WaveformTexture);
m_WaveformTexture = new RenderTexture(source.width * 3, source.height, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear)
{
hideFlags = HideFlags.DontSave,
wrapMode = TextureWrapMode.Clamp,
filterMode = FilterMode.Bilinear
};
}
if (m_Material == null)
m_Material = new Material(Shader.Find("Hidden/Post FX/Monitors/Parade Render")) { hideFlags = HideFlags.DontSave };
m_Material.SetBuffer("_Waveform", m_Buffer);
m_Material.SetVector("_Size", new Vector2(m_WaveformTexture.width, m_WaveformTexture.height));
m_Material.SetVector("_Channels", channels);
}
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: b1f878f3742072e40a280683573bd0ee
timeCreated: 1460031643
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,241 +0,0 @@
using UnityEditorInternal;
using UnityEngine;
using UnityEngine.PostProcessing;
namespace UnityEditor.PostProcessing
{
public class VectorscopeMonitor : PostProcessingMonitor
{
static GUIContent s_MonitorTitle = new GUIContent("Vectorscope");
ComputeShader m_ComputeShader;
ComputeBuffer m_Buffer;
Material m_Material;
RenderTexture m_VectorscopeTexture;
Rect m_MonitorAreaRect;
public VectorscopeMonitor()
{
m_ComputeShader = EditorResources.Load<ComputeShader>("Monitors/VectorscopeCompute.compute");
}
public override void Dispose()
{
GraphicsUtils.Destroy(m_Material);
GraphicsUtils.Destroy(m_VectorscopeTexture);
if (m_Buffer != null)
m_Buffer.Release();
m_Material = null;
m_VectorscopeTexture = null;
m_Buffer = null;
}
public override bool IsSupported()
{
return m_ComputeShader != null && GraphicsUtils.supportsDX11;
}
public override GUIContent GetMonitorTitle()
{
return s_MonitorTitle;
}
public override void OnMonitorSettings()
{
EditorGUI.BeginChangeCheck();
bool refreshOnPlay = m_MonitorSettings.refreshOnPlay;
float exposure = m_MonitorSettings.vectorscopeExposure;
bool showBackground = m_MonitorSettings.vectorscopeShowBackground;
refreshOnPlay = GUILayout.Toggle(refreshOnPlay, new GUIContent(FxStyles.playIcon, "Keep refreshing the vectorscope in play mode; this may impact performances."), FxStyles.preButton);
exposure = GUILayout.HorizontalSlider(exposure, 0.05f, 0.3f, FxStyles.preSlider, FxStyles.preSliderThumb, GUILayout.Width(40f));
showBackground = GUILayout.Toggle(showBackground, new GUIContent(FxStyles.checkerIcon, "Show an YUV background in the vectorscope."), FxStyles.preButton);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(m_BaseEditor.serializedObject.targetObject, "Vectorscope Settings Changed");
m_MonitorSettings.refreshOnPlay = refreshOnPlay;
m_MonitorSettings.vectorscopeExposure = exposure;
m_MonitorSettings.vectorscopeShowBackground = showBackground;
InternalEditorUtility.RepaintAllViews();
}
}
public override void OnMonitorGUI(Rect r)
{
if (Event.current.type == EventType.Repaint)
{
// If m_MonitorAreaRect isn't set the preview was just opened so refresh the render to get the vectoscope data
if (Mathf.Approximately(m_MonitorAreaRect.width, 0) && Mathf.Approximately(m_MonitorAreaRect.height, 0))
InternalEditorUtility.RepaintAllViews();
// Sizing
float size = 0f;
if (r.width < r.height)
{
size = m_VectorscopeTexture != null
? Mathf.Min(m_VectorscopeTexture.width, r.width - 35f)
: r.width;
}
else
{
size = m_VectorscopeTexture != null
? Mathf.Min(m_VectorscopeTexture.height, r.height - 25f)
: r.height;
}
m_MonitorAreaRect = new Rect(
Mathf.Floor(r.x + r.width / 2f - size / 2f),
Mathf.Floor(r.y + r.height / 2f - size / 2f - 5f),
size, size
);
if (m_VectorscopeTexture != null)
{
m_Material.SetFloat("_Exposure", m_MonitorSettings.vectorscopeExposure);
var oldActive = RenderTexture.active;
Graphics.Blit(null, m_VectorscopeTexture, m_Material, m_MonitorSettings.vectorscopeShowBackground ? 0 : 1);
RenderTexture.active = oldActive;
Graphics.DrawTexture(m_MonitorAreaRect, m_VectorscopeTexture);
var color = Color.white;
const float kTickSize = 10f;
const int kTickCount = 24;
float radius = m_MonitorAreaRect.width / 2f;
float midX = m_MonitorAreaRect.x + radius;
float midY = m_MonitorAreaRect.y + radius;
var center = new Vector2(midX, midY);
// Cross
color.a *= 0.5f;
Handles.color = color;
Handles.DrawLine(new Vector2(midX, m_MonitorAreaRect.y), new Vector2(midX, m_MonitorAreaRect.y + m_MonitorAreaRect.height));
Handles.DrawLine(new Vector2(m_MonitorAreaRect.x, midY), new Vector2(m_MonitorAreaRect.x + m_MonitorAreaRect.width, midY));
if (m_MonitorAreaRect.width > 100f)
{
color.a = 1f;
// Ticks
Handles.color = color;
for (int i = 0; i < kTickCount; i++)
{
float a = (float)i / (float)kTickCount;
float theta = a * (Mathf.PI * 2f);
float tx = Mathf.Cos(theta + (Mathf.PI / 2f));
float ty = Mathf.Sin(theta - (Mathf.PI / 2f));
var innerVec = center + new Vector2(tx, ty) * (radius - kTickSize);
var outerVec = center + new Vector2(tx, ty) * radius;
Handles.DrawAAPolyLine(3f, innerVec, outerVec);
}
// Labels (where saturation reaches 75%)
color.a = 1f;
var oldColor = GUI.color;
GUI.color = color * 2f;
var point = new Vector2(-0.254f, -0.750f) * radius + center;
var rect = new Rect(point.x - 10f, point.y - 10f, 20f, 20f);
GUI.Label(rect, "[R]", FxStyles.tickStyleCenter);
point = new Vector2(-0.497f, 0.629f) * radius + center;
rect = new Rect(point.x - 10f, point.y - 10f, 20f, 20f);
GUI.Label(rect, "[G]", FxStyles.tickStyleCenter);
point = new Vector2(0.750f, 0.122f) * radius + center;
rect = new Rect(point.x - 10f, point.y - 10f, 20f, 20f);
GUI.Label(rect, "[B]", FxStyles.tickStyleCenter);
point = new Vector2(-0.750f, -0.122f) * radius + center;
rect = new Rect(point.x - 10f, point.y - 10f, 20f, 20f);
GUI.Label(rect, "[Y]", FxStyles.tickStyleCenter);
point = new Vector2(0.254f, 0.750f) * radius + center;
rect = new Rect(point.x - 10f, point.y - 10f, 20f, 20f);
GUI.Label(rect, "[C]", FxStyles.tickStyleCenter);
point = new Vector2(0.497f, -0.629f) * radius + center;
rect = new Rect(point.x - 10f, point.y - 10f, 20f, 20f);
GUI.Label(rect, "[M]", FxStyles.tickStyleCenter);
GUI.color = oldColor;
}
}
}
}
public override void OnFrameData(RenderTexture source)
{
if (Application.isPlaying && !m_MonitorSettings.refreshOnPlay)
return;
if (Mathf.Approximately(m_MonitorAreaRect.width, 0) || Mathf.Approximately(m_MonitorAreaRect.height, 0))
return;
float ratio = (float)source.width / (float)source.height;
int h = 384;
int w = Mathf.FloorToInt(h * ratio);
var rt = RenderTexture.GetTemporary(w, h, 0, source.format);
Graphics.Blit(source, rt);
ComputeVectorscope(rt);
m_BaseEditor.Repaint();
RenderTexture.ReleaseTemporary(rt);
}
void CreateBuffer(int width, int height)
{
m_Buffer = new ComputeBuffer(width * height, sizeof(uint));
}
void ComputeVectorscope(RenderTexture source)
{
if (m_Buffer == null)
{
CreateBuffer(source.width, source.height);
}
else if (m_Buffer.count != (source.width * source.height))
{
m_Buffer.Release();
CreateBuffer(source.width, source.height);
}
var cs = m_ComputeShader;
int kernel = cs.FindKernel("KVectorscopeClear");
cs.SetBuffer(kernel, "_Vectorscope", m_Buffer);
cs.SetVector("_Res", new Vector4(source.width, source.height, 0f, 0f));
cs.Dispatch(kernel, Mathf.CeilToInt(source.width / 32f), Mathf.CeilToInt(source.height / 32f), 1);
kernel = cs.FindKernel("KVectorscope");
cs.SetBuffer(kernel, "_Vectorscope", m_Buffer);
cs.SetTexture(kernel, "_Source", source);
cs.SetInt("_IsLinear", GraphicsUtils.isLinearColorSpace ? 1 : 0);
cs.SetVector("_Res", new Vector4(source.width, source.height, 0f, 0f));
cs.Dispatch(kernel, Mathf.CeilToInt(source.width / 32f), Mathf.CeilToInt(source.height / 32f), 1);
if (m_VectorscopeTexture == null || m_VectorscopeTexture.width != source.width || m_VectorscopeTexture.height != source.height)
{
GraphicsUtils.Destroy(m_VectorscopeTexture);
m_VectorscopeTexture = new RenderTexture(source.width, source.height, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear)
{
hideFlags = HideFlags.DontSave,
wrapMode = TextureWrapMode.Clamp,
filterMode = FilterMode.Bilinear
};
}
if (m_Material == null)
m_Material = new Material(Shader.Find("Hidden/Post FX/Monitors/Vectorscope Render")) { hideFlags = HideFlags.DontSave };
m_Material.SetBuffer("_Vectorscope", m_Buffer);
m_Material.SetVector("_Size", new Vector2(m_VectorscopeTexture.width, m_VectorscopeTexture.height));
}
}
}

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: 805119df0d94800418006c621cc99cc2
timeCreated: 1461748750
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

@ -1,280 +0,0 @@
using UnityEditorInternal;
using UnityEngine;
using UnityEngine.PostProcessing;
namespace UnityEditor.PostProcessing
{
public class WaveformMonitor : PostProcessingMonitor
{
static GUIContent s_MonitorTitle = new GUIContent("Waveform");
ComputeShader m_ComputeShader;
ComputeBuffer m_Buffer;
Material m_Material;
RenderTexture m_WaveformTexture;
Rect m_MonitorAreaRect;
public WaveformMonitor()
{
m_ComputeShader = EditorResources.Load<ComputeShader>("Monitors/WaveformCompute.compute");
}
public override void Dispose()
{
GraphicsUtils.Destroy(m_Material);
GraphicsUtils.Destroy(m_WaveformTexture);
if (m_Buffer != null)
m_Buffer.Release();
m_Material = null;
m_WaveformTexture = null;
m_Buffer = null;
}
public override bool IsSupported()
{
return m_ComputeShader != null && GraphicsUtils.supportsDX11;
}
public override GUIContent GetMonitorTitle()
{
return s_MonitorTitle;
}
public override void OnMonitorSettings()
{
EditorGUI.BeginChangeCheck();
bool refreshOnPlay = m_MonitorSettings.refreshOnPlay;
float exposure = m_MonitorSettings.waveformExposure;
bool Y = m_MonitorSettings.waveformY;
bool R = m_MonitorSettings.waveformR;
bool G = m_MonitorSettings.waveformG;
bool B = m_MonitorSettings.waveformB;
refreshOnPlay = GUILayout.Toggle(refreshOnPlay, new GUIContent(FxStyles.playIcon, "Keep refreshing the waveform in play mode; this may impact performances."), FxStyles.preButton);
exposure = GUILayout.HorizontalSlider(exposure, 0.05f, 0.3f, FxStyles.preSlider, FxStyles.preSliderThumb, GUILayout.Width(40f));
Y = GUILayout.Toggle(Y, new GUIContent("Y", "Show the luminance waveform only."), FxStyles.preButton);
if (Y)
{
R = false;
G = false;
B = false;
}
R = GUILayout.Toggle(R, new GUIContent("R", "Show the red waveform."), FxStyles.preButton);
G = GUILayout.Toggle(G, new GUIContent("G", "Show the green waveform."), FxStyles.preButton);
B = GUILayout.Toggle(B, new GUIContent("B", "Show the blue waveform."), FxStyles.preButton);
if (R || G || B)
Y = false;
if (!Y && !R && !G && !B)
{
R = true;
G = true;
B = true;
}
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(m_BaseEditor.serializedObject.targetObject, "Waveforme Settings Changed");
m_MonitorSettings.refreshOnPlay = refreshOnPlay;
m_MonitorSettings.waveformExposure = exposure;
m_MonitorSettings.waveformY = Y;
m_MonitorSettings.waveformR = R;
m_MonitorSettings.waveformG = G;
m_MonitorSettings.waveformB = B;
InternalEditorUtility.RepaintAllViews();
}
}
public override void OnMonitorGUI(Rect r)
{
if (Event.current.type == EventType.Repaint)
{
// If m_MonitorAreaRect isn't set the preview was just opened so refresh the render to get the waveform data
if (Mathf.Approximately(m_MonitorAreaRect.width, 0) && Mathf.Approximately(m_MonitorAreaRect.height, 0))
InternalEditorUtility.RepaintAllViews();
// Sizing
float width = m_WaveformTexture != null
? Mathf.Min(m_WaveformTexture.width, r.width - 65f)
: r.width;
float height = m_WaveformTexture != null
? Mathf.Min(m_WaveformTexture.height, r.height - 45f)
: r.height;
m_MonitorAreaRect = new Rect(
Mathf.Floor(r.x + r.width / 2f - width / 2f),
Mathf.Floor(r.y + r.height / 2f - height / 2f - 5f),
width, height
);
if (m_WaveformTexture != null)
{
m_Material.SetFloat("_Exposure", m_MonitorSettings.waveformExposure);
var oldActive = RenderTexture.active;
Graphics.Blit(null, m_WaveformTexture, m_Material, 0);
RenderTexture.active = oldActive;
Graphics.DrawTexture(m_MonitorAreaRect, m_WaveformTexture);
var color = Color.white;
const float kTickSize = 5f;
// Rect, lines & ticks points
// A B C D E
// P F
// O G
// N H
// M L K J I
var A = new Vector3(m_MonitorAreaRect.x, m_MonitorAreaRect.y);
var E = new Vector3(A.x + m_MonitorAreaRect.width + 1f, m_MonitorAreaRect.y);
var I = new Vector3(E.x, E.y + m_MonitorAreaRect.height + 1f);
var M = new Vector3(A.x, I.y);
var C = new Vector3(A.x + (E.x - A.x) / 2f, A.y);
var G = new Vector3(E.x, E.y + (I.y - E.y) / 2f);
var K = new Vector3(M.x + (I.x - M.x) / 2f, M.y);
var O = new Vector3(A.x, A.y + (M.y - A.y) / 2f);
var P = new Vector3(A.x, A.y + (O.y - A.y) / 2f);
var F = new Vector3(E.x, E.y + (G.y - E.y) / 2f);
var N = new Vector3(A.x, O.y + (M.y - O.y) / 2f);
var H = new Vector3(E.x, G.y + (I.y - G.y) / 2f);
var B = new Vector3(A.x + (C.x - A.x) / 2f, A.y);
var L = new Vector3(M.x + (K.x - M.x) / 2f, M.y);
var D = new Vector3(C.x + (E.x - C.x) / 2f, A.y);
var J = new Vector3(K.x + (I.x - K.x) / 2f, M.y);
// Borders
Handles.color = color;
Handles.DrawLine(A, E);
Handles.DrawLine(E, I);
Handles.DrawLine(I, M);
Handles.DrawLine(M, new Vector3(A.x, A.y - 1f));
// Vertical ticks
Handles.DrawLine(A, new Vector3(A.x - kTickSize, A.y));
Handles.DrawLine(P, new Vector3(P.x - kTickSize, P.y));
Handles.DrawLine(O, new Vector3(O.x - kTickSize, O.y));
Handles.DrawLine(N, new Vector3(N.x - kTickSize, N.y));
Handles.DrawLine(M, new Vector3(M.x - kTickSize, M.y));
Handles.DrawLine(E, new Vector3(E.x + kTickSize, E.y));
Handles.DrawLine(F, new Vector3(F.x + kTickSize, F.y));
Handles.DrawLine(G, new Vector3(G.x + kTickSize, G.y));
Handles.DrawLine(H, new Vector3(H.x + kTickSize, H.y));
Handles.DrawLine(I, new Vector3(I.x + kTickSize, I.y));
// Horizontal ticks
Handles.DrawLine(A, new Vector3(A.x, A.y - kTickSize));
Handles.DrawLine(B, new Vector3(B.x, B.y - kTickSize));
Handles.DrawLine(C, new Vector3(C.x, C.y - kTickSize));
Handles.DrawLine(D, new Vector3(D.x, D.y - kTickSize));
Handles.DrawLine(E, new Vector3(E.x, E.y - kTickSize));
Handles.DrawLine(M, new Vector3(M.x, M.y + kTickSize));
Handles.DrawLine(L, new Vector3(L.x, L.y + kTickSize));
Handles.DrawLine(K, new Vector3(K.x, K.y + kTickSize));
Handles.DrawLine(J, new Vector3(J.x, J.y + kTickSize));
Handles.DrawLine(I, new Vector3(I.x, I.y + kTickSize));
// Labels
GUI.color = color;
GUI.Label(new Rect(A.x - kTickSize - 34f, A.y - 15f, 30f, 30f), "1.0", FxStyles.tickStyleRight);
GUI.Label(new Rect(O.x - kTickSize - 34f, O.y - 15f, 30f, 30f), "0.5", FxStyles.tickStyleRight);
GUI.Label(new Rect(M.x - kTickSize - 34f, M.y - 15f, 30f, 30f), "0.0", FxStyles.tickStyleRight);
GUI.Label(new Rect(E.x + kTickSize + 4f, E.y - 15f, 30f, 30f), "1.0", FxStyles.tickStyleLeft);
GUI.Label(new Rect(G.x + kTickSize + 4f, G.y - 15f, 30f, 30f), "0.5", FxStyles.tickStyleLeft);
GUI.Label(new Rect(I.x + kTickSize + 4f, I.y - 15f, 30f, 30f), "0.0", FxStyles.tickStyleLeft);
GUI.Label(new Rect(M.x - 15f, M.y + kTickSize - 4f, 30f, 30f), "0.0", FxStyles.tickStyleCenter);
GUI.Label(new Rect(K.x - 15f, K.y + kTickSize - 4f, 30f, 30f), "0.5", FxStyles.tickStyleCenter);
GUI.Label(new Rect(I.x - 15f, I.y + kTickSize - 4f, 30f, 30f), "1.0", FxStyles.tickStyleCenter);
}
}
}
public override void OnFrameData(RenderTexture source)
{
if (Application.isPlaying && !m_MonitorSettings.refreshOnPlay)
return;
if (Mathf.Approximately(m_MonitorAreaRect.width, 0) || Mathf.Approximately(m_MonitorAreaRect.height, 0))
return;
float ratio = (float)source.width / (float)source.height;
int h = 384;
int w = Mathf.FloorToInt(h * ratio);
var rt = RenderTexture.GetTemporary(w, h, 0, source.format);
Graphics.Blit(source, rt);
ComputeWaveform(rt);
m_BaseEditor.Repaint();
RenderTexture.ReleaseTemporary(rt);
}
void CreateBuffer(int width, int height)
{
m_Buffer = new ComputeBuffer(width * height, sizeof(uint) << 2);
}
void ComputeWaveform(RenderTexture source)
{
if (m_Buffer == null)
{
CreateBuffer(source.width, source.height);
}
else if (m_Buffer.count != (source.width * source.height))
{
m_Buffer.Release();
CreateBuffer(source.width, source.height);
}
var channels = m_MonitorSettings.waveformY
? new Vector4(0f, 0f, 0f, 1f)
: new Vector4(m_MonitorSettings.waveformR ? 1f : 0f, m_MonitorSettings.waveformG ? 1f : 0f, m_MonitorSettings.waveformB ? 1f : 0f, 0f);
var cs = m_ComputeShader;
int kernel = cs.FindKernel("KWaveformClear");
cs.SetBuffer(kernel, "_Waveform", m_Buffer);
cs.Dispatch(kernel, source.width, 1, 1);
kernel = cs.FindKernel("KWaveform");
cs.SetBuffer(kernel, "_Waveform", m_Buffer);
cs.SetTexture(kernel, "_Source", source);
cs.SetInt("_IsLinear", GraphicsUtils.isLinearColorSpace ? 1 : 0);
cs.SetVector("_Channels", channels);
cs.Dispatch(kernel, source.width, 1, 1);
if (m_WaveformTexture == null || m_WaveformTexture.width != source.width || m_WaveformTexture.height != source.height)
{
GraphicsUtils.Destroy(m_WaveformTexture);
m_WaveformTexture = new RenderTexture(source.width, source.height, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear)
{
hideFlags = HideFlags.DontSave,
wrapMode = TextureWrapMode.Clamp,
filterMode = FilterMode.Bilinear
};
}
if (m_Material == null)
m_Material = new Material(Shader.Find("Hidden/Post FX/Monitors/Waveform Render")) { hideFlags = HideFlags.DontSave };
m_Material.SetBuffer("_Waveform", m_Buffer);
m_Material.SetVector("_Size", new Vector2(m_WaveformTexture.width, m_WaveformTexture.height));
m_Material.SetVector("_Channels", channels);
}
}
}

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save