+init

1 files changed, 319 insertions, 0 deletions

diff --git a/UnityEngine.PostProcessing/ColorGradingModel.cs b/UnityEngine.PostProcessing/ColorGradingModel.cs
new file mode 100644
index 0000000..5d5a45b
--- /dev/null
+++ b/UnityEngine.PostProcessing/ColorGradingModel.cs
@@ -0,0 +1,319 @@
+using System;
+
+namespace UnityEngine.PostProcessing;
+
+[Serializable]
+public class ColorGradingModel : PostProcessingModel
+{
+	public enum Tonemapper
+	{
+		None,
+		ACES,
+		Neutral
+	}
+
+	[Serializable]
+	public struct TonemappingSettings
+	{
+		[Tooltip("Tonemapping algorithm to use at the end of the color grading process. Use \"Neutral\" if you need a customizable tonemapper or \"Filmic\" to give a standard filmic look to your scenes.")]
+		public Tonemapper tonemapper;
+
+		[Range(-0.1f, 0.1f)]
+		public float neutralBlackIn;
+
+		[Range(1f, 20f)]
+		public float neutralWhiteIn;
+
+		[Range(-0.09f, 0.1f)]
+		public float neutralBlackOut;
+
+		[Range(1f, 19f)]
+		public float neutralWhiteOut;
+
+		[Range(0.1f, 20f)]
+		public float neutralWhiteLevel;
+
+		[Range(1f, 10f)]
+		public float neutralWhiteClip;
+
+		public static TonemappingSettings defaultSettings
+		{
+			get
+			{
+				TonemappingSettings result = default(TonemappingSettings);
+				result.tonemapper = Tonemapper.Neutral;
+				result.neutralBlackIn = 0.02f;
+				result.neutralWhiteIn = 10f;
+				result.neutralBlackOut = 0f;
+				result.neutralWhiteOut = 10f;
+				result.neutralWhiteLevel = 5.3f;
+				result.neutralWhiteClip = 10f;
+				return result;
+			}
+		}
+	}
+
+	[Serializable]
+	public struct BasicSettings
+	{
+		[Tooltip("Adjusts the overall exposure of the scene in EV units. This is applied after HDR effect and right before tonemapping so it won't affect previous effects in the chain.")]
+		public float postExposure;
+
+		[Range(-100f, 100f)]
+		[Tooltip("Sets the white balance to a custom color temperature.")]
+		public float temperature;
+
+		[Range(-100f, 100f)]
+		[Tooltip("Sets the white balance to compensate for a green or magenta tint.")]
+		public float tint;
+
+		[Range(-180f, 180f)]
+		[Tooltip("Shift the hue of all colors.")]
+		public float hueShift;
+
+		[Range(0f, 2f)]
+		[Tooltip("Pushes the intensity of all colors.")]
+		public float saturation;
+
+		[Range(0f, 2f)]
+		[Tooltip("Expands or shrinks the overall range of tonal values.")]
+		public float contrast;
+
+		public static BasicSettings defaultSettings
+		{
+			get
+			{
+				BasicSettings result = default(BasicSettings);
+				result.postExposure = 0f;
+				result.temperature = 0f;
+				result.tint = 0f;
+				result.hueShift = 0f;
+				result.saturation = 1f;
+				result.contrast = 1f;
+				return result;
+			}
+		}
+	}
+
+	[Serializable]
+	public struct ChannelMixerSettings
+	{
+		public Vector3 red;
+
+		public Vector3 green;
+
+		public Vector3 blue;
+
+		[HideInInspector]
+		public int currentEditingChannel;
+
+		public static ChannelMixerSettings defaultSettings
+		{
+			get
+			{
+				ChannelMixerSettings result = default(ChannelMixerSettings);
+				result.red = new Vector3(1f, 0f, 0f);
+				result.green = new Vector3(0f, 1f, 0f);
+				result.blue = new Vector3(0f, 0f, 1f);
+				result.currentEditingChannel = 0;
+				return result;
+			}
+		}
+	}
+
+	[Serializable]
+	public struct LogWheelsSettings
+	{
+		[Trackball("GetSlopeValue")]
+		public Color slope;
+
+		[Trackball("GetPowerValue")]
+		public Color power;
+
+		[Trackball("GetOffsetValue")]
+		public Color offset;
+
+		public static LogWheelsSettings defaultSettings
+		{
+			get
+			{
+				LogWheelsSettings result = default(LogWheelsSettings);
+				result.slope = Color.clear;
+				result.power = Color.clear;
+				result.offset = Color.clear;
+				return result;
+			}
+		}
+	}
+
+	[Serializable]
+	public struct LinearWheelsSettings
+	{
+		[Trackball("GetLiftValue")]
+		public Color lift;
+
+		[Trackball("GetGammaValue")]
+		public Color gamma;
+
+		[Trackball("GetGainValue")]
+		public Color gain;
+
+		public static LinearWheelsSettings defaultSettings
+		{
+			get
+			{
+				LinearWheelsSettings result = default(LinearWheelsSettings);
+				result.lift = Color.clear;
+				result.gamma = Color.clear;
+				result.gain = Color.clear;
+				return result;
+			}
+		}
+	}
+
+	public enum ColorWheelMode
+	{
+		Linear,
+		Log
+	}
+
+	[Serializable]
+	public struct ColorWheelsSettings
+	{
+		public ColorWheelMode mode;
+
+		[TrackballGroup]
+		public LogWheelsSettings log;
+
+		[TrackballGroup]
+		public LinearWheelsSettings linear;
+
+		public static ColorWheelsSettings defaultSettings
+		{
+			get
+			{
+				ColorWheelsSettings result = default(ColorWheelsSettings);
+				result.mode = ColorWheelMode.Log;
+				result.log = LogWheelsSettings.defaultSettings;
+				result.linear = LinearWheelsSettings.defaultSettings;
+				return result;
+			}
+		}
+	}
+
+	[Serializable]
+	public struct CurvesSettings
+	{
+		public ColorGradingCurve master;
+
+		public ColorGradingCurve red;
+
+		public ColorGradingCurve green;
+
+		public ColorGradingCurve blue;
+
+		public ColorGradingCurve hueVShue;
+
+		public ColorGradingCurve hueVSsat;
+
+		public ColorGradingCurve satVSsat;
+
+		public ColorGradingCurve lumVSsat;
+
+		[HideInInspector]
+		public int e_CurrentEditingCurve;
+
+		[HideInInspector]
+		public bool e_CurveY;
+
+		[HideInInspector]
+		public bool e_CurveR;
+
+		[HideInInspector]
+		public bool e_CurveG;
+
+		[HideInInspector]
+		public bool e_CurveB;
+
+		public static CurvesSettings defaultSettings
+		{
+			get
+			{
+				CurvesSettings result = default(CurvesSettings);
+				result.master = new ColorGradingCurve(new AnimationCurve(new Keyframe(0f, 0f, 1f, 1f), new Keyframe(1f, 1f, 1f, 1f)), 0f, loop: false, new Vector2(0f, 1f));
+				result.red = new ColorGradingCurve(new AnimationCurve(new Keyframe(0f, 0f, 1f, 1f), new Keyframe(1f, 1f, 1f, 1f)), 0f, loop: false, new Vector2(0f, 1f));
+				result.green = new ColorGradingCurve(new AnimationCurve(new Keyframe(0f, 0f, 1f, 1f), new Keyframe(1f, 1f, 1f, 1f)), 0f, loop: false, new Vector2(0f, 1f));
+				result.blue = new ColorGradingCurve(new AnimationCurve(new Keyframe(0f, 0f, 1f, 1f), new Keyframe(1f, 1f, 1f, 1f)), 0f, loop: false, new Vector2(0f, 1f));
+				result.hueVShue = new ColorGradingCurve(new AnimationCurve(), 0.5f, loop: true, new Vector2(0f, 1f));
+				result.hueVSsat = new ColorGradingCurve(new AnimationCurve(), 0.5f, loop: true, new Vector2(0f, 1f));
+				result.satVSsat = new ColorGradingCurve(new AnimationCurve(), 0.5f, loop: false, new Vector2(0f, 1f));
+				result.lumVSsat = new ColorGradingCurve(new AnimationCurve(), 0.5f, loop: false, new Vector2(0f, 1f));
+				result.e_CurrentEditingCurve = 0;
+				result.e_CurveY = true;
+				result.e_CurveR = false;
+				result.e_CurveG = false;
+				result.e_CurveB = false;
+				return result;
+			}
+		}
+	}
+
+	[Serializable]
+	public struct Settings
+	{
+		public TonemappingSettings tonemapping;
+
+		public BasicSettings basic;
+
+		public ChannelMixerSettings channelMixer;
+
+		public ColorWheelsSettings colorWheels;
+
+		public CurvesSettings curves;
+
+		public static Settings defaultSettings
+		{
+			get
+			{
+				Settings result = default(Settings);
+				result.tonemapping = TonemappingSettings.defaultSettings;
+				result.basic = BasicSettings.defaultSettings;
+				result.channelMixer = ChannelMixerSettings.defaultSettings;
+				result.colorWheels = ColorWheelsSettings.defaultSettings;
+				result.curves = CurvesSettings.defaultSettings;
+				return result;
+			}
+		}
+	}
+
+	[SerializeField]
+	private Settings m_Settings = Settings.defaultSettings;
+
+	public Settings settings
+	{
+		get
+		{
+			return m_Settings;
+		}
+		set
+		{
+			m_Settings = value;
+			OnValidate();
+		}
+	}
+
+	public bool isDirty { get; internal set; }
+
+	public RenderTexture bakedLut { get; internal set; }
+
+	public override void Reset()
+	{
+		m_Settings = Settings.defaultSettings;
+		OnValidate();
+	}
+
+	public override void OnValidate()
+	{
+		isDirty = true;
+	}
+}