parent
d502f77a5b
commit
39249efe51
811 changed files with 19063 additions and 241415 deletions
@ -1,515 +0,0 @@ |
||||
%YAML 1.1 |
||||
%TAG !u! tag:unity3d.com,2011: |
||||
--- !u!114 &11400000 |
||||
MonoBehaviour: |
||||
m_ObjectHideFlags: 0 |
||||
m_PrefabParentObject: {fileID: 0} |
||||
m_PrefabInternal: {fileID: 0} |
||||
m_GameObject: {fileID: 0} |
||||
m_Enabled: 1 |
||||
m_EditorHideFlags: 0 |
||||
m_Script: {fileID: 11500000, guid: 8e6292b2c06870d4495f009f912b9600, type: 3} |
||||
m_Name: PostProcessingProfile |
||||
m_EditorClassIdentifier: |
||||
settings: |
||||
- {fileID: 114833496269074576} |
||||
- {fileID: 114319687773204480} |
||||
- {fileID: 114757437605629214} |
||||
- {fileID: 114751192064109246} |
||||
- {fileID: 114455859145519820} |
||||
- {fileID: 114238086573610688} |
||||
--- !u!114 &114238086573610688 |
||||
MonoBehaviour: |
||||
m_ObjectHideFlags: 3 |
||||
m_PrefabParentObject: {fileID: 0} |
||||
m_PrefabInternal: {fileID: 0} |
||||
m_GameObject: {fileID: 0} |
||||
m_Enabled: 1 |
||||
m_EditorHideFlags: 0 |
||||
m_Script: {fileID: 11500000, guid: c1cb7e9e120078f43bce4f0b1be547a7, type: 3} |
||||
m_Name: AmbientOcclusion |
||||
m_EditorClassIdentifier: |
||||
active: 1 |
||||
enabled: |
||||
overrideState: 1 |
||||
value: 1 |
||||
mode: |
||||
overrideState: 0 |
||||
value: 1 |
||||
intensity: |
||||
overrideState: 1 |
||||
value: 1 |
||||
color: |
||||
overrideState: 0 |
||||
value: {r: 0, g: 0, b: 0, a: 1} |
||||
ambientOnly: |
||||
overrideState: 0 |
||||
value: 1 |
||||
noiseFilterTolerance: |
||||
overrideState: 0 |
||||
value: 0 |
||||
blurTolerance: |
||||
overrideState: 0 |
||||
value: -4.6 |
||||
upsampleTolerance: |
||||
overrideState: 0 |
||||
value: -12 |
||||
thicknessModifier: |
||||
overrideState: 0 |
||||
value: 1 |
||||
directLightingStrength: |
||||
overrideState: 0 |
||||
value: 0 |
||||
radius: |
||||
overrideState: 0 |
||||
value: 0.25 |
||||
quality: |
||||
overrideState: 0 |
||||
value: 2 |
||||
--- !u!114 &114319687773204480 |
||||
MonoBehaviour: |
||||
m_ObjectHideFlags: 3 |
||||
m_PrefabParentObject: {fileID: 0} |
||||
m_PrefabInternal: {fileID: 0} |
||||
m_GameObject: {fileID: 0} |
||||
m_Enabled: 1 |
||||
m_EditorHideFlags: 0 |
||||
m_Script: {fileID: 11500000, guid: 6050e2d5de785ce4d931e4dbdbf2d755, type: 3} |
||||
m_Name: ChromaticAberration |
||||
m_EditorClassIdentifier: |
||||
active: 1 |
||||
enabled: |
||||
overrideState: 1 |
||||
value: 1 |
||||
spectralLut: |
||||
overrideState: 1 |
||||
value: {fileID: 2800000, guid: 318cbcd94840f1d48aca4d86234dc2e7, type: 3} |
||||
intensity: |
||||
overrideState: 1 |
||||
value: 0.157 |
||||
fastMode: |
||||
overrideState: 0 |
||||
value: 0 |
||||
--- !u!114 &114455859145519820 |
||||
MonoBehaviour: |
||||
m_ObjectHideFlags: 3 |
||||
m_PrefabParentObject: {fileID: 0} |
||||
m_PrefabInternal: {fileID: 0} |
||||
m_GameObject: {fileID: 0} |
||||
m_Enabled: 1 |
||||
m_EditorHideFlags: 0 |
||||
m_Script: {fileID: 11500000, guid: 40b924e2dad56384a8df2a1e111bb675, type: 3} |
||||
m_Name: Vignette |
||||
m_EditorClassIdentifier: |
||||
active: 1 |
||||
enabled: |
||||
overrideState: 1 |
||||
value: 1 |
||||
mode: |
||||
overrideState: 0 |
||||
value: 0 |
||||
color: |
||||
overrideState: 0 |
||||
value: {r: 0, g: 0, b: 0, a: 1} |
||||
center: |
||||
overrideState: 0 |
||||
value: {x: 0.5, y: 0.5} |
||||
intensity: |
||||
overrideState: 1 |
||||
value: 0.226 |
||||
smoothness: |
||||
overrideState: 0 |
||||
value: 0.2 |
||||
roundness: |
||||
overrideState: 0 |
||||
value: 1 |
||||
rounded: |
||||
overrideState: 0 |
||||
value: 0 |
||||
mask: |
||||
overrideState: 0 |
||||
value: {fileID: 0} |
||||
opacity: |
||||
overrideState: 0 |
||||
value: 1 |
||||
--- !u!114 &114691993215349014 |
||||
MonoBehaviour: |
||||
m_ObjectHideFlags: 3 |
||||
m_PrefabParentObject: {fileID: 0} |
||||
m_PrefabInternal: {fileID: 0} |
||||
m_GameObject: {fileID: 0} |
||||
m_Enabled: 1 |
||||
m_EditorHideFlags: 0 |
||||
m_Script: {fileID: 11500000, guid: b3f6f3f7c722b4544b97e3c75840aa33, type: 3} |
||||
m_Name: AutoExposure |
||||
m_EditorClassIdentifier: |
||||
active: 1 |
||||
enabled: |
||||
overrideState: 1 |
||||
value: 1 |
||||
filtering: |
||||
overrideState: 0 |
||||
value: {x: 50, y: 95} |
||||
minLuminance: |
||||
overrideState: 0 |
||||
value: 0 |
||||
maxLuminance: |
||||
overrideState: 0 |
||||
value: 0 |
||||
keyValue: |
||||
overrideState: 0 |
||||
value: 1 |
||||
eyeAdaptation: |
||||
overrideState: 0 |
||||
value: 0 |
||||
speedUp: |
||||
overrideState: 0 |
||||
value: 2 |
||||
speedDown: |
||||
overrideState: 0 |
||||
value: 1 |
||||
--- !u!114 &114751192064109246 |
||||
MonoBehaviour: |
||||
m_ObjectHideFlags: 3 |
||||
m_PrefabParentObject: {fileID: 0} |
||||
m_PrefabInternal: {fileID: 0} |
||||
m_GameObject: {fileID: 0} |
||||
m_Enabled: 1 |
||||
m_EditorHideFlags: 0 |
||||
m_Script: {fileID: 11500000, guid: 556797029e73b2347956b6579e77e05b, type: 3} |
||||
m_Name: DepthOfField |
||||
m_EditorClassIdentifier: |
||||
active: 0 |
||||
enabled: |
||||
overrideState: 1 |
||||
value: 1 |
||||
focusDistance: |
||||
overrideState: 1 |
||||
value: 20 |
||||
aperture: |
||||
overrideState: 0 |
||||
value: 5.6 |
||||
focalLength: |
||||
overrideState: 0 |
||||
value: 50 |
||||
kernelSize: |
||||
overrideState: 0 |
||||
value: 1 |
||||
--- !u!114 &114757437605629214 |
||||
MonoBehaviour: |
||||
m_ObjectHideFlags: 3 |
||||
m_PrefabParentObject: {fileID: 0} |
||||
m_PrefabInternal: {fileID: 0} |
||||
m_GameObject: {fileID: 0} |
||||
m_Enabled: 1 |
||||
m_EditorHideFlags: 0 |
||||
m_Script: {fileID: 11500000, guid: adb84e30e02715445aeb9959894e3b4d, type: 3} |
||||
m_Name: ColorGrading |
||||
m_EditorClassIdentifier: |
||||
active: 1 |
||||
enabled: |
||||
overrideState: 1 |
||||
value: 1 |
||||
gradingMode: |
||||
overrideState: 1 |
||||
value: 1 |
||||
externalLut: |
||||
overrideState: 0 |
||||
value: {fileID: 0} |
||||
tonemapper: |
||||
overrideState: 1 |
||||
value: 2 |
||||
toneCurveToeStrength: |
||||
overrideState: 0 |
||||
value: 0 |
||||
toneCurveToeLength: |
||||
overrideState: 0 |
||||
value: 0.5 |
||||
toneCurveShoulderStrength: |
||||
overrideState: 0 |
||||
value: 0 |
||||
toneCurveShoulderLength: |
||||
overrideState: 0 |
||||
value: 0.5 |
||||
toneCurveShoulderAngle: |
||||
overrideState: 0 |
||||
value: 0 |
||||
toneCurveGamma: |
||||
overrideState: 0 |
||||
value: 1 |
||||
logLut: |
||||
overrideState: 0 |
||||
value: {fileID: 0} |
||||
ldrLut: |
||||
overrideState: 0 |
||||
value: {fileID: 0} |
||||
temperature: |
||||
overrideState: 0 |
||||
value: 0 |
||||
tint: |
||||
overrideState: 0 |
||||
value: 0 |
||||
colorFilter: |
||||
overrideState: 0 |
||||
value: {r: 1, g: 1, b: 1, a: 1} |
||||
hueShift: |
||||
overrideState: 0 |
||||
value: 0 |
||||
saturation: |
||||
overrideState: 0 |
||||
value: 0 |
||||
brightness: |
||||
overrideState: 0 |
||||
value: 0 |
||||
postExposure: |
||||
overrideState: 1 |
||||
value: 1 |
||||
contrast: |
||||
overrideState: 0 |
||||
value: 0 |
||||
mixerRedOutRedIn: |
||||
overrideState: 0 |
||||
value: 100 |
||||
mixerRedOutGreenIn: |
||||
overrideState: 0 |
||||
value: 0 |
||||
mixerRedOutBlueIn: |
||||
overrideState: 0 |
||||
value: 0 |
||||
mixerGreenOutRedIn: |
||||
overrideState: 0 |
||||
value: 0 |
||||
mixerGreenOutGreenIn: |
||||
overrideState: 0 |
||||
value: 100 |
||||
mixerGreenOutBlueIn: |
||||
overrideState: 0 |
||||
value: 0 |
||||
mixerBlueOutRedIn: |
||||
overrideState: 0 |
||||
value: 0 |
||||
mixerBlueOutGreenIn: |
||||
overrideState: 0 |
||||
value: 0 |
||||
mixerBlueOutBlueIn: |
||||
overrideState: 0 |
||||
value: 100 |
||||
lift: |
||||
overrideState: 0 |
||||
value: {x: 1, y: 1, z: 1, w: 0} |
||||
gamma: |
||||
overrideState: 0 |
||||
value: {x: 1, y: 1, z: 1, w: 0} |
||||
gain: |
||||
overrideState: 0 |
||||
value: {x: 1, y: 1, z: 1, w: 0} |
||||
masterCurve: |
||||
overrideState: 0 |
||||
value: |
||||
curve: |
||||
serializedVersion: 2 |
||||
m_Curve: |
||||
- serializedVersion: 3 |
||||
time: 0 |
||||
value: 0 |
||||
inSlope: 1 |
||||
outSlope: 1 |
||||
tangentMode: 0 |
||||
weightedMode: 0 |
||||
inWeight: 0.33333334 |
||||
outWeight: 0.33333334 |
||||
- serializedVersion: 3 |
||||
time: 1 |
||||
value: 1 |
||||
inSlope: 1 |
||||
outSlope: 1 |
||||
tangentMode: 0 |
||||
weightedMode: 0 |
||||
inWeight: 0.33333334 |
||||
outWeight: 0.33333334 |
||||
m_PreInfinity: 2 |
||||
m_PostInfinity: 2 |
||||
m_RotationOrder: 4 |
||||
m_Loop: 0 |
||||
m_ZeroValue: 0 |
||||
m_Range: 1 |
||||
redCurve: |
||||
overrideState: 0 |
||||
value: |
||||
curve: |
||||
serializedVersion: 2 |
||||
m_Curve: |
||||
- serializedVersion: 3 |
||||
time: 0 |
||||
value: 0 |
||||
inSlope: 1 |
||||
outSlope: 1 |
||||
tangentMode: 0 |
||||
weightedMode: 0 |
||||
inWeight: 0.33333334 |
||||
outWeight: 0.33333334 |
||||
- serializedVersion: 3 |
||||
time: 1 |
||||
value: 1 |
||||
inSlope: 1 |
||||
outSlope: 1 |
||||
tangentMode: 0 |
||||
weightedMode: 0 |
||||
inWeight: 0.33333334 |
||||
outWeight: 0.33333334 |
||||
m_PreInfinity: 2 |
||||
m_PostInfinity: 2 |
||||
m_RotationOrder: 4 |
||||
m_Loop: 0 |
||||
m_ZeroValue: 0 |
||||
m_Range: 1 |
||||
greenCurve: |
||||
overrideState: 0 |
||||
value: |
||||
curve: |
||||
serializedVersion: 2 |
||||
m_Curve: |
||||
- serializedVersion: 3 |
||||
time: 0 |
||||
value: 0 |
||||
inSlope: 1 |
||||
outSlope: 1 |
||||
tangentMode: 0 |
||||
weightedMode: 0 |
||||
inWeight: 0.33333334 |
||||
outWeight: 0.33333334 |
||||
- serializedVersion: 3 |
||||
time: 1 |
||||
value: 1 |
||||
inSlope: 1 |
||||
outSlope: 1 |
||||
tangentMode: 0 |
||||
weightedMode: 0 |
||||
inWeight: 0.33333334 |
||||
outWeight: 0.33333334 |
||||
m_PreInfinity: 2 |
||||
m_PostInfinity: 2 |
||||
m_RotationOrder: 4 |
||||
m_Loop: 0 |
||||
m_ZeroValue: 0 |
||||
m_Range: 1 |
||||
blueCurve: |
||||
overrideState: 0 |
||||
value: |
||||
curve: |
||||
serializedVersion: 2 |
||||
m_Curve: |
||||
- serializedVersion: 3 |
||||
time: 0 |
||||
value: 0 |
||||
inSlope: 1 |
||||
outSlope: 1 |
||||
tangentMode: 0 |
||||
weightedMode: 0 |
||||
inWeight: 0.33333334 |
||||
outWeight: 0.33333334 |
||||
- serializedVersion: 3 |
||||
time: 1 |
||||
value: 1 |
||||
inSlope: 1 |
||||
outSlope: 1 |
||||
tangentMode: 0 |
||||
weightedMode: 0 |
||||
inWeight: 0.33333334 |
||||
outWeight: 0.33333334 |
||||
m_PreInfinity: 2 |
||||
m_PostInfinity: 2 |
||||
m_RotationOrder: 4 |
||||
m_Loop: 0 |
||||
m_ZeroValue: 0 |
||||
m_Range: 1 |
||||
hueVsHueCurve: |
||||
overrideState: 0 |
||||
value: |
||||
curve: |
||||
serializedVersion: 2 |
||||
m_Curve: [] |
||||
m_PreInfinity: 2 |
||||
m_PostInfinity: 2 |
||||
m_RotationOrder: 0 |
||||
m_Loop: 1 |
||||
m_ZeroValue: 0.5 |
||||
m_Range: 1 |
||||
hueVsSatCurve: |
||||
overrideState: 0 |
||||
value: |
||||
curve: |
||||
serializedVersion: 2 |
||||
m_Curve: [] |
||||
m_PreInfinity: 2 |
||||
m_PostInfinity: 2 |
||||
m_RotationOrder: 4 |
||||
m_Loop: 1 |
||||
m_ZeroValue: 0.5 |
||||
m_Range: 1 |
||||
satVsSatCurve: |
||||
overrideState: 0 |
||||
value: |
||||
curve: |
||||
serializedVersion: 2 |
||||
m_Curve: [] |
||||
m_PreInfinity: 2 |
||||
m_PostInfinity: 2 |
||||
m_RotationOrder: 4 |
||||
m_Loop: 0 |
||||
m_ZeroValue: 0.5 |
||||
m_Range: 1 |
||||
lumVsSatCurve: |
||||
overrideState: 0 |
||||
value: |
||||
curve: |
||||
serializedVersion: 2 |
||||
m_Curve: [] |
||||
m_PreInfinity: 2 |
||||
m_PostInfinity: 2 |
||||
m_RotationOrder: 4 |
||||
m_Loop: 0 |
||||
m_ZeroValue: 0.5 |
||||
m_Range: 1 |
||||
--- !u!114 &114833496269074576 |
||||
MonoBehaviour: |
||||
m_ObjectHideFlags: 3 |
||||
m_PrefabParentObject: {fileID: 0} |
||||
m_PrefabInternal: {fileID: 0} |
||||
m_GameObject: {fileID: 0} |
||||
m_Enabled: 1 |
||||
m_EditorHideFlags: 0 |
||||
m_Script: {fileID: 11500000, guid: 48a79b01ea5641d4aa6daa2e23605641, type: 3} |
||||
m_Name: Bloom |
||||
m_EditorClassIdentifier: |
||||
active: 0 |
||||
enabled: |
||||
overrideState: 1 |
||||
value: 1 |
||||
intensity: |
||||
overrideState: 1 |
||||
value: 3 |
||||
threshold: |
||||
overrideState: 0 |
||||
value: 1 |
||||
softKnee: |
||||
overrideState: 0 |
||||
value: 0.5 |
||||
diffusion: |
||||
overrideState: 0 |
||||
value: 7 |
||||
anamorphicRatio: |
||||
overrideState: 0 |
||||
value: 0 |
||||
color: |
||||
overrideState: 0 |
||||
value: {r: 1, g: 1, b: 1, a: 1} |
||||
fastMode: |
||||
overrideState: 0 |
||||
value: 0 |
||||
dirtTexture: |
||||
overrideState: 1 |
||||
value: {fileID: 2800000, guid: a2960ffde020f27409e070d92fb2e00b, type: 3} |
||||
dirtIntensity: |
||||
overrideState: 1 |
||||
value: 4.08 |
||||
@ -1,10 +0,0 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 13848f592641d12488d9f26f621f4aea |
||||
timeCreated: 1513322306 |
||||
licenseType: Free |
||||
NativeFormatImporter: |
||||
externalObjects: {} |
||||
mainObjectFileID: 11400000 |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -1,16 +0,0 @@ |
||||
%YAML 1.1 |
||||
%TAG !u! tag:unity3d.com,2011: |
||||
--- !u!114 &11400000 |
||||
MonoBehaviour: |
||||
m_ObjectHideFlags: 0 |
||||
m_PrefabParentObject: {fileID: 0} |
||||
m_PrefabInternal: {fileID: 0} |
||||
m_GameObject: {fileID: 0} |
||||
m_Enabled: 1 |
||||
m_EditorHideFlags: 0 |
||||
m_Script: {fileID: 11500000, guid: 2f29da58f3a63f649a512733d24af22c, type: 3} |
||||
m_Name: PostProcessStrippingConfig |
||||
m_EditorClassIdentifier: |
||||
stripUnsupportedShaders: 1 |
||||
stripDebugShaders: 0 |
||||
stripComputeShaders: 0 |
||||
@ -1,10 +0,0 @@ |
||||
fileFormatVersion: 2 |
||||
guid: fdb84457dc528a942964520afbd6bcf8 |
||||
timeCreated: 1519736043 |
||||
licenseType: Free |
||||
NativeFormatImporter: |
||||
externalObjects: {} |
||||
mainObjectFileID: 11400000 |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -1,7 +1,7 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 1da84851b99c43746afb49e79ae2b1d6 |
||||
guid: 83715878d3a8db441aa5636641db69a3 |
||||
folderAsset: yes |
||||
timeCreated: 1492696579 |
||||
timeCreated: 1476176392 |
||||
licenseType: Pro |
||||
DefaultImporter: |
||||
userData: |
||||
@ -1,7 +1,7 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 0a243807ad889ae44bf63a9bcdc984af |
||||
guid: e7358848dd8737c459f4636f1c075835 |
||||
folderAsset: yes |
||||
timeCreated: 1499676298 |
||||
timeCreated: 1460361782 |
||||
licenseType: Pro |
||||
DefaultImporter: |
||||
userData: |
||||
@ -0,0 +1,91 @@ |
||||
#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,6 +1,6 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 8c2fcbdf9bc58664f89917f7b9d79501 |
||||
timeCreated: 1488985723 |
||||
guid: 51b7e4b4448c98f4a849081110fd6212 |
||||
timeCreated: 1459956391 |
||||
licenseType: Pro |
||||
ComputeShaderImporter: |
||||
currentAPIMask: 4 |
||||
@ -0,0 +1,141 @@ |
||||
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,6 +1,6 @@ |
||||
fileFormatVersion: 2 |
||||
guid: d7de89b714449b04391f3a2fb53a9022 |
||||
timeCreated: 1493731593 |
||||
guid: 965efa32cf2345647a1c987546e08f86 |
||||
timeCreated: 1459956391 |
||||
licenseType: Pro |
||||
ShaderImporter: |
||||
defaultTextures: [] |
||||
@ -0,0 +1,76 @@ |
||||
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,6 +1,6 @@ |
||||
fileFormatVersion: 2 |
||||
guid: d4e61b1eb5c3ac248add7bb738198560 |
||||
timeCreated: 1489753963 |
||||
guid: 5ae1bfc1dd20ac04e8b74aa0f2f12eea |
||||
timeCreated: 1459956391 |
||||
licenseType: Pro |
||||
ShaderImporter: |
||||
defaultTextures: [] |
||||
@ -0,0 +1,49 @@ |
||||
#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,6 +1,6 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 31e9175024adfd44aba2530ff9b77494 |
||||
timeCreated: 1496933873 |
||||
guid: 45de9ff58691e934c9810dc23de2ba50 |
||||
timeCreated: 1459956391 |
||||
licenseType: Pro |
||||
ComputeShaderImporter: |
||||
currentAPIMask: 4 |
||||
@ -0,0 +1,101 @@ |
||||
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,6 +1,6 @@ |
||||
fileFormatVersion: 2 |
||||
guid: ed6416461734f3a4d97b2475252d5f6c |
||||
timeCreated: 1489754075 |
||||
guid: 1c4298cd35ef7834e892898e49d61ecd |
||||
timeCreated: 1461756159 |
||||
licenseType: Pro |
||||
ShaderImporter: |
||||
defaultTextures: [] |
||||
@ -0,0 +1,42 @@ |
||||
#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 +1,9 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 18183ebfeeab97749b43e38b928604a7 |
||||
timeCreated: 1499679719 |
||||
guid: 9d9b886f7a8fe7b4baf56624c42e3420 |
||||
timeCreated: 1459956392 |
||||
licenseType: Pro |
||||
ComputeShaderImporter: |
||||
currentAPIMask: 8196 |
||||
currentAPIMask: 4 |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -0,0 +1,65 @@ |
||||
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,6 +1,6 @@ |
||||
fileFormatVersion: 2 |
||||
guid: a741cbbb27e6ad747a354440a9132a66 |
||||
timeCreated: 1489754265 |
||||
guid: 8b3e43c50424ab2428a9c172843bc66d |
||||
timeCreated: 1459956391 |
||||
licenseType: Pro |
||||
ShaderImporter: |
||||
defaultTextures: [] |
||||
@ -1,7 +1,7 @@ |
||||
fileFormatVersion: 2 |
||||
guid: e58158d9d8b440d4ca944a07d6cde9af |
||||
guid: df37d60cc69b7b04d9705a74938179e7 |
||||
folderAsset: yes |
||||
timeCreated: 1496736709 |
||||
timeCreated: 1460627771 |
||||
licenseType: Pro |
||||
DefaultImporter: |
||||
userData: |
||||
@ -1,4 +1,4 @@ |
||||
Shader "Hidden/PostProcessing/Editor/CurveGrid" |
||||
Shader "Hidden/Post FX/UI/Curve Background" |
||||
{ |
||||
CGINCLUDE |
||||
|
||||
@ -0,0 +1,9 @@ |
||||
fileFormatVersion: 2 |
||||
guid: b1b2bfb2897659e45983f0c3e7dda2c8 |
||||
timeCreated: 1460970196 |
||||
licenseType: Pro |
||||
ShaderImporter: |
||||
defaultTextures: [] |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
BIN
Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/UI/MotionBlendingIcon.png (Stored with Git LFS)
BIN
Unity_2018_Frozen/Assets/Unity-Technologies/PostProcessing/Editor Resources/UI/MotionBlendingIcon.png (Stored with Git LFS)
Binary file not shown.
@ -0,0 +1,59 @@ |
||||
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,6 +1,6 @@ |
||||
fileFormatVersion: 2 |
||||
guid: de7f3ac52268a194383c7d62c2a343c1 |
||||
timeCreated: 1493903699 |
||||
guid: 4bf49309c7ab9eb42a86774d2c09b4fa |
||||
timeCreated: 1460627788 |
||||
licenseType: Pro |
||||
ShaderImporter: |
||||
defaultTextures: [] |
||||
@ -1,15 +0,0 @@ |
||||
using System; |
||||
|
||||
namespace UnityEditor.Rendering.PostProcessing |
||||
{ |
||||
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)] |
||||
public sealed class DecoratorAttribute : Attribute |
||||
{ |
||||
public readonly Type attributeType; |
||||
|
||||
public DecoratorAttribute(Type attributeType) |
||||
{ |
||||
this.attributeType = attributeType; |
||||
} |
||||
} |
||||
} |
||||
@ -1,15 +0,0 @@ |
||||
using System; |
||||
|
||||
namespace UnityEngine.Rendering.PostProcessing |
||||
{ |
||||
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)] |
||||
public sealed class PostProcessEditorAttribute : Attribute |
||||
{ |
||||
public readonly Type settingsType; |
||||
|
||||
public PostProcessEditorAttribute(Type settingsType) |
||||
{ |
||||
this.settingsType = settingsType; |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,16 @@ |
||||
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,6 +1,6 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 9753335d6f48da542be1c720aa07bbf5 |
||||
timeCreated: 1493109769 |
||||
guid: c21938aa988055347a2271f03a3e731e |
||||
timeCreated: 1466769734 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
@ -1,21 +0,0 @@ |
||||
using System; |
||||
using System.Linq.Expressions; |
||||
using UnityEngine; |
||||
using UnityEngine.Rendering.PostProcessing; |
||||
|
||||
namespace UnityEditor.Rendering.PostProcessing |
||||
{ |
||||
public class BaseEditor<T> : Editor |
||||
where T : MonoBehaviour |
||||
{ |
||||
protected T m_Target |
||||
{ |
||||
get { return (T)target; } |
||||
} |
||||
|
||||
protected SerializedProperty FindProperty<TValue>(Expression<Func<T, TValue>> expr) |
||||
{ |
||||
return serializedObject.FindProperty(RuntimeUtilities.GetFieldPath(expr)); |
||||
} |
||||
} |
||||
} |
||||
@ -1,17 +0,0 @@ |
||||
using System; |
||||
using UnityEngine; |
||||
|
||||
namespace UnityEditor.Rendering.PostProcessing |
||||
{ |
||||
public abstract class AttributeDecorator |
||||
{ |
||||
// Override this and return false if you want to customize the override checkbox position, |
||||
// else it'll automatically draw it and put the property content in a horizontal scope. |
||||
public virtual bool IsAutoProperty() |
||||
{ |
||||
return true; |
||||
} |
||||
|
||||
public abstract bool OnGUI(SerializedProperty property, SerializedProperty overrideState, GUIContent title, Attribute attribute); |
||||
} |
||||
} |
||||
@ -1,143 +0,0 @@ |
||||
using System; |
||||
using UnityEngine; |
||||
|
||||
namespace UnityEditor.Rendering.PostProcessing |
||||
{ |
||||
[Decorator(typeof(RangeAttribute))] |
||||
public sealed class RangeDecorator : AttributeDecorator |
||||
{ |
||||
public override bool OnGUI(SerializedProperty property, SerializedProperty overrideState, GUIContent title, Attribute attribute) |
||||
{ |
||||
var attr = (RangeAttribute)attribute; |
||||
|
||||
if (property.propertyType == SerializedPropertyType.Float) |
||||
{ |
||||
property.floatValue = EditorGUILayout.Slider(title, property.floatValue, attr.min, attr.max); |
||||
return true; |
||||
} |
||||
|
||||
if (property.propertyType == SerializedPropertyType.Integer) |
||||
{ |
||||
property.intValue = EditorGUILayout.IntSlider(title, property.intValue, (int)attr.min, (int)attr.max); |
||||
return true; |
||||
} |
||||
|
||||
return false; |
||||
} |
||||
} |
||||
|
||||
[Decorator(typeof(UnityEngine.Rendering.PostProcessing.MinAttribute))] |
||||
public sealed class MinDecorator : AttributeDecorator |
||||
{ |
||||
public override bool OnGUI(SerializedProperty property, SerializedProperty overrideState, GUIContent title, Attribute attribute) |
||||
{ |
||||
var attr = (UnityEngine.Rendering.PostProcessing.MinAttribute)attribute; |
||||
|
||||
if (property.propertyType == SerializedPropertyType.Float) |
||||
{ |
||||
float v = EditorGUILayout.FloatField(title, property.floatValue); |
||||
property.floatValue = Mathf.Max(v, attr.min); |
||||
return true; |
||||
} |
||||
|
||||
if (property.propertyType == SerializedPropertyType.Integer) |
||||
{ |
||||
int v = EditorGUILayout.IntField(title, property.intValue); |
||||
property.intValue = Mathf.Max(v, (int)attr.min); |
||||
return true; |
||||
} |
||||
|
||||
return false; |
||||
} |
||||
} |
||||
|
||||
[Decorator(typeof(UnityEngine.Rendering.PostProcessing.MaxAttribute))] |
||||
public sealed class MaxDecorator : AttributeDecorator |
||||
{ |
||||
public override bool OnGUI(SerializedProperty property, SerializedProperty overrideState, GUIContent title, Attribute attribute) |
||||
{ |
||||
var attr = (UnityEngine.Rendering.PostProcessing.MaxAttribute)attribute; |
||||
|
||||
if (property.propertyType == SerializedPropertyType.Float) |
||||
{ |
||||
float v = EditorGUILayout.FloatField(title, property.floatValue); |
||||
property.floatValue = Mathf.Min(v, attr.max); |
||||
return true; |
||||
} |
||||
|
||||
if (property.propertyType == SerializedPropertyType.Integer) |
||||
{ |
||||
int v = EditorGUILayout.IntField(title, property.intValue); |
||||
property.intValue = Mathf.Min(v, (int)attr.max); |
||||
return true; |
||||
} |
||||
|
||||
return false; |
||||
} |
||||
} |
||||
|
||||
[Decorator(typeof(UnityEngine.Rendering.PostProcessing.MinMaxAttribute))] |
||||
public sealed class MinMaxDecorator : AttributeDecorator |
||||
{ |
||||
public override bool OnGUI(SerializedProperty property, SerializedProperty overrideState, GUIContent title, Attribute attribute) |
||||
{ |
||||
var attr = (UnityEngine.Rendering.PostProcessing.MinMaxAttribute)attribute; |
||||
|
||||
if (property.propertyType == SerializedPropertyType.Float) |
||||
{ |
||||
float v = EditorGUILayout.FloatField(title, property.floatValue); |
||||
property.floatValue = Mathf.Clamp(v, attr.min, attr.max); |
||||
return true; |
||||
} |
||||
|
||||
if (property.propertyType == SerializedPropertyType.Integer) |
||||
{ |
||||
int v = EditorGUILayout.IntField(title, property.intValue); |
||||
property.intValue = Mathf.Clamp(v, (int)attr.min, (int)attr.max); |
||||
return true; |
||||
} |
||||
|
||||
if (property.propertyType == SerializedPropertyType.Vector2) |
||||
{ |
||||
var v = property.vector2Value; |
||||
EditorGUILayout.MinMaxSlider(title, ref v.x, ref v.y, attr.min, attr.max); |
||||
property.vector2Value = v; |
||||
return true; |
||||
} |
||||
|
||||
return false; |
||||
} |
||||
} |
||||
|
||||
[Decorator(typeof(ColorUsageAttribute))] |
||||
public sealed class ColorUsageDecorator : AttributeDecorator |
||||
{ |
||||
public override bool OnGUI(SerializedProperty property, SerializedProperty overrideState, GUIContent title, Attribute attribute) |
||||
{ |
||||
var attr = (ColorUsageAttribute)attribute; |
||||
|
||||
if (property.propertyType != SerializedPropertyType.Color) |
||||
return false; |
||||
|
||||
#if UNITY_2018_1_OR_NEWER |
||||
property.colorValue = EditorGUILayout.ColorField(title, property.colorValue, true, attr.showAlpha, attr.hdr); |
||||
#else |
||||
ColorPickerHDRConfig hdrConfig = null; |
||||
|
||||
if (attr.hdr) |
||||
{ |
||||
hdrConfig = new ColorPickerHDRConfig( |
||||
attr.minBrightness, |
||||
attr.maxBrightness, |
||||
attr.minExposureValue, |
||||
attr.maxExposureValue |
||||
); |
||||
} |
||||
|
||||
property.colorValue = EditorGUILayout.ColorField(title, property.colorValue, true, attr.showAlpha, attr.hdr, hdrConfig); |
||||
#endif |
||||
|
||||
return true; |
||||
} |
||||
} |
||||
} |
||||
@ -1,12 +0,0 @@ |
||||
fileFormatVersion: 2 |
||||
guid: d6ae47710b8593e41960a944bb29e6c3 |
||||
timeCreated: 1493051241 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -1,209 +0,0 @@ |
||||
using System; |
||||
using UnityEngine; |
||||
using UnityEngine.Rendering.PostProcessing; |
||||
|
||||
namespace UnityEditor.Rendering.PostProcessing |
||||
{ |
||||
[Decorator(typeof(TrackballAttribute))] |
||||
public sealed class TrackballDecorator : AttributeDecorator |
||||
{ |
||||
static readonly int k_ThumbHash = "colorWheelThumb".GetHashCode(); |
||||
static Material s_Material; |
||||
|
||||
bool m_ResetState; |
||||
Vector2 m_CursorPos; |
||||
|
||||
public override bool IsAutoProperty() |
||||
{ |
||||
return false; |
||||
} |
||||
|
||||
public override bool OnGUI(SerializedProperty property, SerializedProperty overrideState, GUIContent title, Attribute attribute) |
||||
{ |
||||
if (property.propertyType != SerializedPropertyType.Vector4) |
||||
return false; |
||||
|
||||
var value = property.vector4Value; |
||||
|
||||
using (new EditorGUILayout.VerticalScope()) |
||||
{ |
||||
using (new EditorGUI.DisabledScope(!overrideState.boolValue)) |
||||
DrawWheel(ref value, overrideState.boolValue, (TrackballAttribute)attribute); |
||||
|
||||
DrawLabelAndOverride(title, overrideState); |
||||
} |
||||
|
||||
if (m_ResetState) |
||||
{ |
||||
value = Vector4.zero; |
||||
m_ResetState = false; |
||||
} |
||||
|
||||
property.vector4Value = value; |
||||
|
||||
return true; |
||||
} |
||||
|
||||
void DrawWheel(ref Vector4 value, bool overrideState, TrackballAttribute attr) |
||||
{ |
||||
var wheelRect = GUILayoutUtility.GetAspectRect(1f); |
||||
float size = wheelRect.width; |
||||
float hsize = size / 2f; |
||||
float radius = 0.38f * size; |
||||
|
||||
Vector3 hsv; |
||||
Color.RGBToHSV(value, out hsv.x, out hsv.y, out hsv.z); |
||||
float offset = value.w; |
||||
|
||||
// Thumb |
||||
var thumbPos = Vector2.zero; |
||||
float theta = hsv.x * (Mathf.PI * 2f); |
||||
thumbPos.x = Mathf.Cos(theta + (Mathf.PI / 2f)); |
||||
thumbPos.y = Mathf.Sin(theta - (Mathf.PI / 2f)); |
||||
thumbPos *= hsv.y * radius; |
||||
|
||||
// Draw the wheel |
||||
if (Event.current.type == EventType.Repaint) |
||||
{ |
||||
// Retina support |
||||
float scale = EditorGUIUtility.pixelsPerPoint; |
||||
|
||||
if (s_Material == null) |
||||
s_Material = new Material(Shader.Find("Hidden/PostProcessing/Editor/Trackball")) { hideFlags = HideFlags.HideAndDontSave }; |
||||
|
||||
// Wheel texture |
||||
#if UNITY_2018_1_OR_NEWER |
||||
const RenderTextureReadWrite kReadWrite = RenderTextureReadWrite.sRGB; |
||||
#else |
||||
const RenderTextureReadWrite kReadWrite = RenderTextureReadWrite.Linear; |
||||
#endif |
||||
|
||||
var oldRT = RenderTexture.active; |
||||
var rt = RenderTexture.GetTemporary((int)(size * scale), (int)(size * scale), 0, RenderTextureFormat.ARGB32, kReadWrite); |
||||
s_Material.SetFloat("_Offset", offset); |
||||
s_Material.SetFloat("_DisabledState", overrideState ? 1f : 0.5f); |
||||
s_Material.SetVector("_Resolution", new Vector2(size * scale, size * scale / 2f)); |
||||
Graphics.Blit(null, rt, s_Material, EditorGUIUtility.isProSkin ? 0 : 1); |
||||
RenderTexture.active = oldRT; |
||||
|
||||
GUI.DrawTexture(wheelRect, rt); |
||||
RenderTexture.ReleaseTemporary(rt); |
||||
|
||||
var thumbSize = Styling.wheelThumbSize; |
||||
var thumbSizeH = thumbSize / 2f; |
||||
Styling.wheelThumb.Draw(new Rect(wheelRect.x + hsize + thumbPos.x - thumbSizeH.x, wheelRect.y + hsize + thumbPos.y - thumbSizeH.y, thumbSize.x, thumbSize.y), false, false, false, false); |
||||
} |
||||
|
||||
// Input |
||||
var bounds = wheelRect; |
||||
bounds.x += hsize - radius; |
||||
bounds.y += hsize - radius; |
||||
bounds.width = bounds.height = radius * 2f; |
||||
hsv = GetInput(bounds, hsv, thumbPos, radius); |
||||
value = Color.HSVToRGB(hsv.x, hsv.y, 1f); |
||||
value.w = offset; |
||||
|
||||
// Offset |
||||
var sliderRect = GUILayoutUtility.GetRect(1f, 17f); |
||||
float padding = sliderRect.width * 0.05f; // 5% padding |
||||
sliderRect.xMin += padding; |
||||
sliderRect.xMax -= padding; |
||||
value.w = GUI.HorizontalSlider(sliderRect, value.w, -1f, 1f); |
||||
|
||||
if (attr.mode == TrackballAttribute.Mode.None) |
||||
return; |
||||
|
||||
// Values |
||||
var displayValue = Vector3.zero; |
||||
|
||||
switch (attr.mode) |
||||
{ |
||||
case TrackballAttribute.Mode.Lift: displayValue = ColorUtilities.ColorToLift(value); |
||||
break; |
||||
case TrackballAttribute.Mode.Gamma: displayValue = ColorUtilities.ColorToInverseGamma(value); |
||||
break; |
||||
case TrackballAttribute.Mode.Gain: displayValue = ColorUtilities.ColorToGain(value); |
||||
break; |
||||
} |
||||
|
||||
using (new EditorGUI.DisabledGroupScope(true)) |
||||
{ |
||||
var valuesRect = GUILayoutUtility.GetRect(1f, 17f); |
||||
valuesRect.width /= 3f; |
||||
GUI.Label(valuesRect, displayValue.x.ToString("F2"), EditorStyles.centeredGreyMiniLabel); |
||||
valuesRect.x += valuesRect.width; |
||||
GUI.Label(valuesRect, displayValue.y.ToString("F2"), EditorStyles.centeredGreyMiniLabel); |
||||
valuesRect.x += valuesRect.width; |
||||
GUI.Label(valuesRect, displayValue.z.ToString("F2"), EditorStyles.centeredGreyMiniLabel); |
||||
valuesRect.x += valuesRect.width; |
||||
} |
||||
} |
||||
|
||||
void DrawLabelAndOverride(GUIContent title, SerializedProperty overrideState) |
||||
{ |
||||
// Title |
||||
var areaRect = GUILayoutUtility.GetRect(1f, 17f); |
||||
var labelSize = Styling.wheelLabel.CalcSize(title); |
||||
var labelRect = new Rect(areaRect.x + areaRect.width / 2 - labelSize.x / 2, areaRect.y, labelSize.x, labelSize.y); |
||||
GUI.Label(labelRect, title, Styling.wheelLabel); |
||||
|
||||
// Override checkbox |
||||
var overrideRect = new Rect(labelRect.x - 17, labelRect.y + 3, 17f, 17f); |
||||
EditorUtilities.DrawOverrideCheckbox(overrideRect, overrideState); |
||||
} |
||||
|
||||
Vector3 GetInput(Rect bounds, Vector3 hsv, Vector2 thumbPos, float radius) |
||||
{ |
||||
var e = Event.current; |
||||
var id = GUIUtility.GetControlID(k_ThumbHash, FocusType.Passive, bounds); |
||||
var mousePos = e.mousePosition; |
||||
|
||||
if (e.type == EventType.MouseDown && GUIUtility.hotControl == 0 && bounds.Contains(mousePos)) |
||||
{ |
||||
if (e.button == 0) |
||||
{ |
||||
var center = new Vector2(bounds.x + radius, bounds.y + radius); |
||||
float dist = Vector2.Distance(center, mousePos); |
||||
|
||||
if (dist <= radius) |
||||
{ |
||||
e.Use(); |
||||
m_CursorPos = new Vector2(thumbPos.x + radius, thumbPos.y + radius); |
||||
GUIUtility.hotControl = id; |
||||
GUI.changed = true; |
||||
} |
||||
} |
||||
else if (e.button == 1) |
||||
{ |
||||
e.Use(); |
||||
GUI.changed = true; |
||||
m_ResetState = true; |
||||
} |
||||
} |
||||
else if (e.type == EventType.MouseDrag && e.button == 0 && GUIUtility.hotControl == id) |
||||
{ |
||||
e.Use(); |
||||
GUI.changed = true; |
||||
m_CursorPos += e.delta * GlobalSettings.trackballSensitivity; |
||||
GetWheelHueSaturation(m_CursorPos.x, m_CursorPos.y, radius, out hsv.x, out hsv.y); |
||||
} |
||||
else if (e.rawType == EventType.MouseUp && e.button == 0 && GUIUtility.hotControl == id) |
||||
{ |
||||
e.Use(); |
||||
GUIUtility.hotControl = 0; |
||||
} |
||||
|
||||
return hsv; |
||||
} |
||||
|
||||
void GetWheelHueSaturation(float x, float y, float radius, out float hue, out float saturation) |
||||
{ |
||||
float dx = (x - radius) / radius; |
||||
float dy = (y - radius) / radius; |
||||
float d = Mathf.Sqrt(dx * dx + dy * dy); |
||||
hue = Mathf.Atan2(dx, -dy); |
||||
hue = 1f - ((hue > 0) ? hue : (Mathf.PI * 2f) + hue) / (Mathf.PI * 2f); |
||||
saturation = Mathf.Clamp01(d); |
||||
} |
||||
} |
||||
} |
||||
@ -1,12 +0,0 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 26ed99f46b86df8449003e6ec0f65144 |
||||
timeCreated: 1493900975 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -1,316 +0,0 @@ |
||||
using System; |
||||
using System.Collections.Generic; |
||||
using System.Linq; |
||||
using UnityEngine; |
||||
using UnityEngine.Assertions; |
||||
using UnityEngine.Rendering.PostProcessing; |
||||
|
||||
namespace UnityEditor.Rendering.PostProcessing |
||||
{ |
||||
public sealed class EffectListEditor |
||||
{ |
||||
Editor m_BaseEditor; |
||||
|
||||
PostProcessProfile m_Asset; |
||||
SerializedObject m_SerializedObject; |
||||
SerializedProperty m_SettingsProperty; |
||||
|
||||
Dictionary<Type, Type> m_EditorTypes; // SettingsType => EditorType |
||||
List<PostProcessEffectBaseEditor> m_Editors; |
||||
|
||||
public EffectListEditor(Editor editor) |
||||
{ |
||||
Assert.IsNotNull(editor); |
||||
m_BaseEditor = editor; |
||||
} |
||||
|
||||
public void Init(PostProcessProfile asset, SerializedObject serializedObject) |
||||
{ |
||||
Assert.IsNotNull(asset); |
||||
Assert.IsNotNull(serializedObject); |
||||
|
||||
m_Asset = asset; |
||||
m_SerializedObject = serializedObject; |
||||
m_SettingsProperty = serializedObject.FindProperty("settings"); |
||||
Assert.IsNotNull(m_SettingsProperty); |
||||
|
||||
m_EditorTypes = new Dictionary<Type, Type>(); |
||||
m_Editors = new List<PostProcessEffectBaseEditor>(); |
||||
|
||||
// Gets the list of all available postfx editors |
||||
var editorTypes = RuntimeUtilities.GetAllAssemblyTypes() |
||||
.Where( |
||||
t => t.IsSubclassOf(typeof(PostProcessEffectBaseEditor)) |
||||
&& t.IsDefined(typeof(PostProcessEditorAttribute), false) |
||||
&& !t.IsAbstract |
||||
); |
||||
|
||||
// Map them to their corresponding settings type |
||||
foreach (var editorType in editorTypes) |
||||
{ |
||||
var attribute = editorType.GetAttribute<PostProcessEditorAttribute>(); |
||||
m_EditorTypes.Add(attribute.settingsType, editorType); |
||||
} |
||||
|
||||
// Create editors for existing settings |
||||
for (int i = 0; i < m_Asset.settings.Count; i++) |
||||
CreateEditor(m_Asset.settings[i], m_SettingsProperty.GetArrayElementAtIndex(i)); |
||||
|
||||
// Keep track of undo/redo to redraw the inspector when that happens |
||||
Undo.undoRedoPerformed += OnUndoRedoPerformed; |
||||
} |
||||
|
||||
void OnUndoRedoPerformed() |
||||
{ |
||||
m_Asset.isDirty = true; |
||||
|
||||
// Dumb hack to make sure the serialized object is up to date on undo (else there'll be |
||||
// a state mismatch when this class is used in a GameObject inspector). |
||||
m_SerializedObject.Update(); |
||||
m_SerializedObject.ApplyModifiedProperties(); |
||||
|
||||
// Seems like there's an issue with the inspector not repainting after some undo events |
||||
// This will take care of that |
||||
m_BaseEditor.Repaint(); |
||||
} |
||||
|
||||
void CreateEditor(PostProcessEffectSettings settings, SerializedProperty property, int index = -1) |
||||
{ |
||||
var settingsType = settings.GetType(); |
||||
Type editorType; |
||||
|
||||
if (!m_EditorTypes.TryGetValue(settingsType, out editorType)) |
||||
editorType = typeof(DefaultPostProcessEffectEditor); |
||||
|
||||
var editor = (PostProcessEffectBaseEditor)Activator.CreateInstance(editorType); |
||||
editor.Init(settings, m_BaseEditor); |
||||
editor.baseProperty = property.Copy(); |
||||
|
||||
if (index < 0) |
||||
m_Editors.Add(editor); |
||||
else |
||||
m_Editors[index] = editor; |
||||
} |
||||
|
||||
// Clears & recreate all editors - mainly used when the volume has been modified outside of |
||||
// the editor (user scripts, inspector reset etc). |
||||
void RefreshEditors() |
||||
{ |
||||
// Disable all editors first |
||||
foreach (var editor in m_Editors) |
||||
editor.OnDisable(); |
||||
|
||||
// Remove them |
||||
m_Editors.Clear(); |
||||
|
||||
// Recreate editors for existing settings, if any |
||||
for (int i = 0; i < m_Asset.settings.Count; i++) |
||||
CreateEditor(m_Asset.settings[i], m_SettingsProperty.GetArrayElementAtIndex(i)); |
||||
} |
||||
|
||||
public void Clear() |
||||
{ |
||||
if (m_Editors == null) |
||||
return; // Hasn't been inited yet |
||||
|
||||
foreach (var editor in m_Editors) |
||||
editor.OnDisable(); |
||||
|
||||
m_Editors.Clear(); |
||||
m_EditorTypes.Clear(); |
||||
|
||||
Undo.undoRedoPerformed -= OnUndoRedoPerformed; |
||||
} |
||||
|
||||
public void OnGUI() |
||||
{ |
||||
if (m_Asset == null) |
||||
return; |
||||
|
||||
if (m_Asset.isDirty) |
||||
{ |
||||
RefreshEditors(); |
||||
m_Asset.isDirty = false; |
||||
} |
||||
|
||||
bool isEditable = !VersionControl.Provider.isActive |
||||
|| AssetDatabase.IsOpenForEdit(m_Asset, StatusQueryOptions.UseCachedIfPossible); |
||||
|
||||
using (new EditorGUI.DisabledScope(!isEditable)) |
||||
{ |
||||
EditorGUILayout.LabelField(EditorUtilities.GetContent("Overrides"), EditorStyles.boldLabel); |
||||
|
||||
// Override list |
||||
for (int i = 0; i < m_Editors.Count; i++) |
||||
{ |
||||
var editor = m_Editors[i]; |
||||
string title = editor.GetDisplayTitle(); |
||||
int id = i; // Needed for closure capture below |
||||
|
||||
EditorUtilities.DrawSplitter(); |
||||
bool displayContent = EditorUtilities.DrawHeader( |
||||
title, |
||||
editor.baseProperty, |
||||
editor.activeProperty, |
||||
editor.target, |
||||
() => ResetEffectOverride(editor.target.GetType(), id), |
||||
() => RemoveEffectOverride(id) |
||||
); |
||||
|
||||
if (displayContent) |
||||
{ |
||||
using (new EditorGUI.DisabledScope(!editor.activeProperty.boolValue)) |
||||
editor.OnInternalInspectorGUI(); |
||||
} |
||||
} |
||||
|
||||
if (m_Editors.Count > 0) |
||||
{ |
||||
EditorUtilities.DrawSplitter(); |
||||
EditorGUILayout.Space(); |
||||
} |
||||
else |
||||
{ |
||||
EditorGUILayout.HelpBox("No override set on this volume.", MessageType.Info); |
||||
} |
||||
|
||||
if (GUILayout.Button("Add effect...", EditorStyles.miniButton)) |
||||
{ |
||||
var menu = new GenericMenu(); |
||||
|
||||
var typeMap = PostProcessManager.instance.settingsTypes; |
||||
foreach (var kvp in typeMap) |
||||
{ |
||||
var type = kvp.Key; |
||||
var title = EditorUtilities.GetContent(kvp.Value.menuItem); |
||||
bool exists = m_Asset.HasSettings(type); |
||||
|
||||
if (!exists) |
||||
menu.AddItem(title, false, () => AddEffectOverride(type)); |
||||
else |
||||
menu.AddDisabledItem(title); |
||||
} |
||||
|
||||
menu.ShowAsContext(); |
||||
} |
||||
|
||||
EditorGUILayout.Space(); |
||||
} |
||||
} |
||||
|
||||
void AddEffectOverride(Type type) |
||||
{ |
||||
m_SerializedObject.Update(); |
||||
|
||||
var effect = CreateNewEffect(type); |
||||
Undo.RegisterCreatedObjectUndo(effect, "Add Effect Override"); |
||||
|
||||
// Store this new effect as a subasset so we can reference it safely afterwards |
||||
AssetDatabase.AddObjectToAsset(effect, m_Asset); |
||||
|
||||
// Grow the list first, then add - that's how serialized lists work in Unity |
||||
m_SettingsProperty.arraySize++; |
||||
var effectProp = m_SettingsProperty.GetArrayElementAtIndex(m_SettingsProperty.arraySize - 1); |
||||
effectProp.objectReferenceValue = effect; |
||||
|
||||
// Force save / refresh |
||||
EditorUtility.SetDirty(m_Asset); |
||||
AssetDatabase.SaveAssets(); |
||||
|
||||
// Create & store the internal editor object for this effect |
||||
CreateEditor(effect, effectProp); |
||||
|
||||
m_SerializedObject.ApplyModifiedProperties(); |
||||
} |
||||
|
||||
void RemoveEffectOverride(int id) |
||||
{ |
||||
// Huh. Hack to keep foldout state on the next element... |
||||
bool nextFoldoutState = false; |
||||
if (id < m_Editors.Count - 1) |
||||
nextFoldoutState = m_Editors[id + 1].baseProperty.isExpanded; |
||||
|
||||
// Remove from the cached editors list |
||||
m_Editors[id].OnDisable(); |
||||
m_Editors.RemoveAt(id); |
||||
|
||||
m_SerializedObject.Update(); |
||||
|
||||
var property = m_SettingsProperty.GetArrayElementAtIndex(id); |
||||
var effect = property.objectReferenceValue; |
||||
|
||||
// Unassign it (should be null already but serialization does funky things |
||||
property.objectReferenceValue = null; |
||||
|
||||
// ...and remove the array index itself from the list |
||||
m_SettingsProperty.DeleteArrayElementAtIndex(id); |
||||
|
||||
// Finally refresh editor reference to the serialized settings list |
||||
for (int i = 0; i < m_Editors.Count; i++) |
||||
m_Editors[i].baseProperty = m_SettingsProperty.GetArrayElementAtIndex(i).Copy(); |
||||
|
||||
if (id < m_Editors.Count) |
||||
m_Editors[id].baseProperty.isExpanded = nextFoldoutState; |
||||
|
||||
m_SerializedObject.ApplyModifiedProperties(); |
||||
|
||||
// Destroy the setting object after ApplyModifiedProperties(). If we do it before, redo |
||||
// actions will be in the wrong order and the reference to the setting object in the |
||||
// list will be lost. |
||||
Undo.DestroyObjectImmediate(effect); |
||||
|
||||
// Force save / refresh |
||||
EditorUtility.SetDirty(m_Asset); |
||||
AssetDatabase.SaveAssets(); |
||||
} |
||||
|
||||
// Reset is done by deleting and removing the object from the list and adding a new one in |
||||
// the place as it was before |
||||
void ResetEffectOverride(Type type, int id) |
||||
{ |
||||
// Remove from the cached editors list |
||||
m_Editors[id].OnDisable(); |
||||
m_Editors[id] = null; |
||||
|
||||
m_SerializedObject.Update(); |
||||
|
||||
var property = m_SettingsProperty.GetArrayElementAtIndex(id); |
||||
var prevSettings = property.objectReferenceValue; |
||||
|
||||
// Unassign it but down remove it from the array to keep the index available |
||||
property.objectReferenceValue = null; |
||||
|
||||
// Create a new object |
||||
var newEffect = CreateNewEffect(type); |
||||
Undo.RegisterCreatedObjectUndo(newEffect, "Reset Effect Override"); |
||||
|
||||
// Store this new effect as a subasset so we can reference it safely afterwards |
||||
AssetDatabase.AddObjectToAsset(newEffect, m_Asset); |
||||
|
||||
// Put it in the reserved space |
||||
property.objectReferenceValue = newEffect; |
||||
|
||||
// Create & store the internal editor object for this effect |
||||
CreateEditor(newEffect, property, id); |
||||
|
||||
m_SerializedObject.ApplyModifiedProperties(); |
||||
|
||||
// Same as RemoveEffectOverride, destroy at the end so it's recreated first on Undo to |
||||
// make sure the GUID exists before undoing the list state |
||||
Undo.DestroyObjectImmediate(prevSettings); |
||||
|
||||
// Force save / refresh |
||||
EditorUtility.SetDirty(m_Asset); |
||||
AssetDatabase.SaveAssets(); |
||||
} |
||||
|
||||
PostProcessEffectSettings CreateNewEffect(Type type) |
||||
{ |
||||
var effect = (PostProcessEffectSettings)ScriptableObject.CreateInstance(type); |
||||
effect.hideFlags = HideFlags.HideInInspector | HideFlags.HideInHierarchy; |
||||
effect.name = type.Name; |
||||
effect.enabled.value = true; |
||||
return effect; |
||||
} |
||||
} |
||||
} |
||||
@ -1,12 +0,0 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 9f9fffe306f3969418c31ee836b6ffee |
||||
timeCreated: 1494328254 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -1,73 +0,0 @@ |
||||
using UnityEngine; |
||||
using UnityEngine.Rendering.PostProcessing; |
||||
|
||||
namespace UnityEditor.Rendering.PostProcessing |
||||
{ |
||||
[PostProcessEditor(typeof(AmbientOcclusion))] |
||||
public sealed class AmbientOcclusionEditor : PostProcessEffectEditor<AmbientOcclusion> |
||||
{ |
||||
SerializedParameterOverride m_Mode; |
||||
SerializedParameterOverride m_Intensity; |
||||
SerializedParameterOverride m_Color; |
||||
SerializedParameterOverride m_AmbientOnly; |
||||
SerializedParameterOverride m_ThicknessModifier; |
||||
SerializedParameterOverride m_DirectLightingStrength; |
||||
SerializedParameterOverride m_Quality; |
||||
SerializedParameterOverride m_Radius; |
||||
|
||||
public override void OnEnable() |
||||
{ |
||||
m_Mode = FindParameterOverride(x => x.mode); |
||||
m_Intensity = FindParameterOverride(x => x.intensity); |
||||
m_Color = FindParameterOverride(x => x.color); |
||||
m_AmbientOnly = FindParameterOverride(x => x.ambientOnly); |
||||
m_ThicknessModifier = FindParameterOverride(x => x.thicknessModifier); |
||||
m_DirectLightingStrength = FindParameterOverride(x => x.directLightingStrength); |
||||
m_Quality = FindParameterOverride(x => x.quality); |
||||
m_Radius = FindParameterOverride(x => x.radius); |
||||
} |
||||
|
||||
public override void OnInspectorGUI() |
||||
{ |
||||
PropertyField(m_Mode); |
||||
int aoMode = m_Mode.value.intValue; |
||||
|
||||
if (RuntimeUtilities.scriptableRenderPipelineActive && aoMode == (int)AmbientOcclusionMode.ScalableAmbientObscurance) |
||||
{ |
||||
EditorGUILayout.HelpBox("Scalable ambient obscurance doesn't work with scriptable render pipelines.", MessageType.Warning); |
||||
return; |
||||
} |
||||
|
||||
#if !UNITY_2017_1_OR_NEWER |
||||
if (aoMode == (int)AmbientOcclusionMode.MultiScaleVolumetricObscurance) |
||||
{ |
||||
EditorGUILayout.HelpBox("Multi-scale volumetric obscurance requires Unity 2017.1 or more.", MessageType.Warning); |
||||
return; |
||||
} |
||||
#endif |
||||
|
||||
PropertyField(m_Intensity); |
||||
|
||||
if (aoMode == (int)AmbientOcclusionMode.ScalableAmbientObscurance) |
||||
{ |
||||
PropertyField(m_Radius); |
||||
PropertyField(m_Quality); |
||||
} |
||||
else if (aoMode == (int)AmbientOcclusionMode.MultiScaleVolumetricObscurance) |
||||
{ |
||||
if (!SystemInfo.supportsComputeShaders) |
||||
EditorGUILayout.HelpBox("Multi-scale volumetric obscurance requires compute shader support.", MessageType.Warning); |
||||
|
||||
PropertyField(m_ThicknessModifier); |
||||
|
||||
if (RuntimeUtilities.scriptableRenderPipelineActive) |
||||
PropertyField(m_DirectLightingStrength); |
||||
} |
||||
|
||||
PropertyField(m_Color); |
||||
|
||||
if (Camera.main != null && Camera.main.actualRenderingPath == RenderingPath.DeferredShading && Camera.main.allowHDR) |
||||
PropertyField(m_AmbientOnly); |
||||
} |
||||
} |
||||
} |
||||
@ -1,12 +0,0 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 67909952e72978b4ea41880509c936ff |
||||
timeCreated: 1505217529 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -1,63 +0,0 @@ |
||||
using UnityEngine; |
||||
using UnityEngine.Rendering.PostProcessing; |
||||
|
||||
namespace UnityEditor.Rendering.PostProcessing |
||||
{ |
||||
[PostProcessEditor(typeof(AutoExposure))] |
||||
public sealed class AutoExposureEditor : PostProcessEffectEditor<AutoExposure> |
||||
{ |
||||
SerializedParameterOverride m_Filtering; |
||||
|
||||
SerializedParameterOverride m_MinLuminance; |
||||
SerializedParameterOverride m_MaxLuminance; |
||||
SerializedParameterOverride m_KeyValue; |
||||
|
||||
SerializedParameterOverride m_EyeAdaptation; |
||||
SerializedParameterOverride m_SpeedUp; |
||||
SerializedParameterOverride m_SpeedDown; |
||||
|
||||
public override void OnEnable() |
||||
{ |
||||
m_Filtering = FindParameterOverride(x => x.filtering); |
||||
|
||||
m_MinLuminance = FindParameterOverride(x => x.minLuminance); |
||||
m_MaxLuminance = FindParameterOverride(x => x.maxLuminance); |
||||
m_KeyValue = FindParameterOverride(x => x.keyValue); |
||||
|
||||
m_EyeAdaptation = FindParameterOverride(x => x.eyeAdaptation); |
||||
m_SpeedUp = FindParameterOverride(x => x.speedUp); |
||||
m_SpeedDown = FindParameterOverride(x => x.speedDown); |
||||
} |
||||
|
||||
public override void OnInspectorGUI() |
||||
{ |
||||
if (!SystemInfo.supportsComputeShaders) |
||||
EditorGUILayout.HelpBox("Auto exposure requires compute shader support.", MessageType.Warning); |
||||
|
||||
EditorUtilities.DrawHeaderLabel("Exposure"); |
||||
|
||||
PropertyField(m_Filtering); |
||||
PropertyField(m_MinLuminance); |
||||
PropertyField(m_MaxLuminance); |
||||
|
||||
// Clamp min/max adaptation values |
||||
float minLum = m_MinLuminance.value.floatValue; |
||||
float maxLum = m_MaxLuminance.value.floatValue; |
||||
m_MinLuminance.value.floatValue = Mathf.Min(minLum, maxLum); |
||||
m_MaxLuminance.value.floatValue = Mathf.Max(minLum, maxLum); |
||||
|
||||
PropertyField(m_KeyValue); |
||||
|
||||
EditorGUILayout.Space(); |
||||
EditorUtilities.DrawHeaderLabel("Adaptation"); |
||||
|
||||
PropertyField(m_EyeAdaptation); |
||||
|
||||
if (m_EyeAdaptation.value.intValue == (int)EyeAdaptation.Progressive) |
||||
{ |
||||
PropertyField(m_SpeedUp); |
||||
PropertyField(m_SpeedDown); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
@ -1,12 +0,0 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 3051d2fb25301fa4a81e797109712feb |
||||
timeCreated: 1493022639 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -1,62 +0,0 @@ |
||||
using UnityEngine.Rendering.PostProcessing; |
||||
|
||||
namespace UnityEditor.Rendering.PostProcessing |
||||
{ |
||||
[PostProcessEditor(typeof(Bloom))] |
||||
public sealed class BloomEditor : PostProcessEffectEditor<Bloom> |
||||
{ |
||||
SerializedParameterOverride m_Intensity; |
||||
SerializedParameterOverride m_Threshold; |
||||
SerializedParameterOverride m_SoftKnee; |
||||
SerializedParameterOverride m_Diffusion; |
||||
SerializedParameterOverride m_AnamorphicRatio; |
||||
SerializedParameterOverride m_Color; |
||||
SerializedParameterOverride m_FastMode; |
||||
|
||||
SerializedParameterOverride m_DirtTexture; |
||||
SerializedParameterOverride m_DirtIntensity; |
||||
|
||||
public override void OnEnable() |
||||
{ |
||||
m_Intensity = FindParameterOverride(x => x.intensity); |
||||
m_Threshold = FindParameterOverride(x => x.threshold); |
||||
m_SoftKnee = FindParameterOverride(x => x.softKnee); |
||||
m_Diffusion = FindParameterOverride(x => x.diffusion); |
||||
m_AnamorphicRatio = FindParameterOverride(x => x.anamorphicRatio); |
||||
m_Color = FindParameterOverride(x => x.color); |
||||
m_FastMode = FindParameterOverride(x => x.fastMode); |
||||
|
||||
m_DirtTexture = FindParameterOverride(x => x.dirtTexture); |
||||
m_DirtIntensity = FindParameterOverride(x => x.dirtIntensity); |
||||
} |
||||
|
||||
public override void OnInspectorGUI() |
||||
{ |
||||
EditorUtilities.DrawHeaderLabel("Bloom"); |
||||
|
||||
PropertyField(m_Intensity); |
||||
PropertyField(m_Threshold); |
||||
PropertyField(m_SoftKnee); |
||||
PropertyField(m_Diffusion); |
||||
PropertyField(m_AnamorphicRatio); |
||||
PropertyField(m_Color); |
||||
PropertyField(m_FastMode); |
||||
|
||||
if (m_FastMode.overrideState.boolValue && !m_FastMode.value.boolValue && EditorUtilities.isTargetingConsolesOrMobiles) |
||||
EditorGUILayout.HelpBox("For performance reasons it is recommended to use Fast Mode on mobile and console platforms.", MessageType.Warning); |
||||
|
||||
EditorGUILayout.Space(); |
||||
EditorUtilities.DrawHeaderLabel("Dirtiness"); |
||||
|
||||
PropertyField(m_DirtTexture); |
||||
PropertyField(m_DirtIntensity); |
||||
|
||||
if (RuntimeUtilities.isVREnabled) |
||||
{ |
||||
if ((m_DirtIntensity.overrideState.boolValue && m_DirtIntensity.value.floatValue > 0f) |
||||
|| (m_DirtTexture.overrideState.boolValue && m_DirtTexture.value.objectReferenceValue != null)) |
||||
EditorGUILayout.HelpBox("Using a dirt texture in VR is not recommended.", MessageType.Warning); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
@ -1,12 +0,0 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 47feae56b7bdcf4499b96c2aa3c6ce07 |
||||
timeCreated: 1493116477 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -1,11 +0,0 @@ |
||||
fileFormatVersion: 2 |
||||
guid: f8e5f5614c0d72445b292f4b16ab660b |
||||
MonoImporter: |
||||
externalObjects: {} |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -1,738 +0,0 @@ |
||||
using System.Collections.Generic; |
||||
using UnityEngine; |
||||
using UnityEngine.Rendering.PostProcessing; |
||||
|
||||
namespace UnityEditor.Rendering.PostProcessing |
||||
{ |
||||
[PostProcessEditor(typeof(ColorGrading))] |
||||
public sealed class ColorGradingEditor : PostProcessEffectEditor<ColorGrading> |
||||
{ |
||||
SerializedParameterOverride m_GradingMode; |
||||
|
||||
static GUIContent[] s_Curves = |
||||
{ |
||||
new GUIContent("Master"), |
||||
new GUIContent("Red"), |
||||
new GUIContent("Green"), |
||||
new GUIContent("Blue"), |
||||
new GUIContent("Hue Vs Hue"), |
||||
new GUIContent("Hue Vs Sat"), |
||||
new GUIContent("Sat Vs Sat"), |
||||
new GUIContent("Lum Vs Sat") |
||||
}; |
||||
|
||||
SerializedParameterOverride m_ExternalLut; |
||||
|
||||
SerializedParameterOverride m_Tonemapper; |
||||
SerializedParameterOverride m_ToneCurveToeStrength; |
||||
SerializedParameterOverride m_ToneCurveToeLength; |
||||
SerializedParameterOverride m_ToneCurveShoulderStrength; |
||||
SerializedParameterOverride m_ToneCurveShoulderLength; |
||||
SerializedParameterOverride m_ToneCurveShoulderAngle; |
||||
SerializedParameterOverride m_ToneCurveGamma; |
||||
|
||||
SerializedParameterOverride m_LdrLut; |
||||
|
||||
SerializedParameterOverride m_Temperature; |
||||
SerializedParameterOverride m_Tint; |
||||
|
||||
SerializedParameterOverride m_ColorFilter; |
||||
SerializedParameterOverride m_HueShift; |
||||
SerializedParameterOverride m_Saturation; |
||||
SerializedParameterOverride m_Brightness; |
||||
SerializedParameterOverride m_PostExposure; |
||||
SerializedParameterOverride m_Contrast; |
||||
|
||||
SerializedParameterOverride m_MixerRedOutRedIn; |
||||
SerializedParameterOverride m_MixerRedOutGreenIn; |
||||
SerializedParameterOverride m_MixerRedOutBlueIn; |
||||
|
||||
SerializedParameterOverride m_MixerGreenOutRedIn; |
||||
SerializedParameterOverride m_MixerGreenOutGreenIn; |
||||
SerializedParameterOverride m_MixerGreenOutBlueIn; |
||||
|
||||
SerializedParameterOverride m_MixerBlueOutRedIn; |
||||
SerializedParameterOverride m_MixerBlueOutGreenIn; |
||||
SerializedParameterOverride m_MixerBlueOutBlueIn; |
||||
|
||||
SerializedParameterOverride m_Lift; |
||||
SerializedParameterOverride m_Gamma; |
||||
SerializedParameterOverride m_Gain; |
||||
|
||||
SerializedParameterOverride m_MasterCurve; |
||||
SerializedParameterOverride m_RedCurve; |
||||
SerializedParameterOverride m_GreenCurve; |
||||
SerializedParameterOverride m_BlueCurve; |
||||
|
||||
SerializedParameterOverride m_HueVsHueCurve; |
||||
SerializedParameterOverride m_HueVsSatCurve; |
||||
SerializedParameterOverride m_SatVsSatCurve; |
||||
SerializedParameterOverride m_LumVsSatCurve; |
||||
|
||||
// Internal references to the actual animation curves |
||||
// Needed for the curve editor |
||||
SerializedProperty m_RawMasterCurve; |
||||
SerializedProperty m_RawRedCurve; |
||||
SerializedProperty m_RawGreenCurve; |
||||
SerializedProperty m_RawBlueCurve; |
||||
|
||||
SerializedProperty m_RawHueVsHueCurve; |
||||
SerializedProperty m_RawHueVsSatCurve; |
||||
SerializedProperty m_RawSatVsSatCurve; |
||||
SerializedProperty m_RawLumVsSatCurve; |
||||
|
||||
CurveEditor m_CurveEditor; |
||||
Dictionary<SerializedProperty, Color> m_CurveDict; |
||||
|
||||
// Custom tone curve drawing |
||||
const int k_CustomToneCurveResolution = 48; |
||||
const float k_CustomToneCurveRangeY = 1.025f; |
||||
readonly Vector3[] m_RectVertices = new Vector3[4]; |
||||
readonly Vector3[] m_LineVertices = new Vector3[2]; |
||||
readonly Vector3[] m_CurveVertices = new Vector3[k_CustomToneCurveResolution]; |
||||
Rect m_CustomToneCurveRect; |
||||
readonly HableCurve m_HableCurve = new HableCurve(); |
||||
|
||||
public override void OnEnable() |
||||
{ |
||||
m_GradingMode = FindParameterOverride(x => x.gradingMode); |
||||
|
||||
m_ExternalLut = FindParameterOverride(x => x.externalLut); |
||||
|
||||
m_Tonemapper = FindParameterOverride(x => x.tonemapper); |
||||
m_ToneCurveToeStrength = FindParameterOverride(x => x.toneCurveToeStrength); |
||||
m_ToneCurveToeLength = FindParameterOverride(x => x.toneCurveToeLength); |
||||
m_ToneCurveShoulderStrength = FindParameterOverride(x => x.toneCurveShoulderStrength); |
||||
m_ToneCurveShoulderLength = FindParameterOverride(x => x.toneCurveShoulderLength); |
||||
m_ToneCurveShoulderAngle = FindParameterOverride(x => x.toneCurveShoulderAngle); |
||||
m_ToneCurveGamma = FindParameterOverride(x => x.toneCurveGamma); |
||||
|
||||
m_LdrLut = FindParameterOverride(x => x.ldrLut); |
||||
|
||||
m_Temperature = FindParameterOverride(x => x.temperature); |
||||
m_Tint = FindParameterOverride(x => x.tint); |
||||
|
||||
m_ColorFilter = FindParameterOverride(x => x.colorFilter); |
||||
m_HueShift = FindParameterOverride(x => x.hueShift); |
||||
m_Saturation = FindParameterOverride(x => x.saturation); |
||||
m_Brightness = FindParameterOverride(x => x.brightness); |
||||
m_PostExposure = FindParameterOverride(x => x.postExposure); |
||||
m_Contrast = FindParameterOverride(x => x.contrast); |
||||
|
||||
m_MixerRedOutRedIn = FindParameterOverride(x => x.mixerRedOutRedIn); |
||||
m_MixerRedOutGreenIn = FindParameterOverride(x => x.mixerRedOutGreenIn); |
||||
m_MixerRedOutBlueIn = FindParameterOverride(x => x.mixerRedOutBlueIn); |
||||
|
||||
m_MixerGreenOutRedIn = FindParameterOverride(x => x.mixerGreenOutRedIn); |
||||
m_MixerGreenOutGreenIn = FindParameterOverride(x => x.mixerGreenOutGreenIn); |
||||
m_MixerGreenOutBlueIn = FindParameterOverride(x => x.mixerGreenOutBlueIn); |
||||
|
||||
m_MixerBlueOutRedIn = FindParameterOverride(x => x.mixerBlueOutRedIn); |
||||
m_MixerBlueOutGreenIn = FindParameterOverride(x => x.mixerBlueOutGreenIn); |
||||
m_MixerBlueOutBlueIn = FindParameterOverride(x => x.mixerBlueOutBlueIn); |
||||
|
||||
m_Lift = FindParameterOverride(x => x.lift); |
||||
m_Gamma = FindParameterOverride(x => x.gamma); |
||||
m_Gain = FindParameterOverride(x => x.gain); |
||||
|
||||
m_MasterCurve = FindParameterOverride(x => x.masterCurve); |
||||
m_RedCurve = FindParameterOverride(x => x.redCurve); |
||||
m_GreenCurve = FindParameterOverride(x => x.greenCurve); |
||||
m_BlueCurve = FindParameterOverride(x => x.blueCurve); |
||||
|
||||
m_HueVsHueCurve = FindParameterOverride(x => x.hueVsHueCurve); |
||||
m_HueVsSatCurve = FindParameterOverride(x => x.hueVsSatCurve); |
||||
m_SatVsSatCurve = FindParameterOverride(x => x.satVsSatCurve); |
||||
m_LumVsSatCurve = FindParameterOverride(x => x.lumVsSatCurve); |
||||
|
||||
m_RawMasterCurve = FindProperty(x => x.masterCurve.value.curve); |
||||
m_RawRedCurve = FindProperty(x => x.redCurve.value.curve); |
||||
m_RawGreenCurve = FindProperty(x => x.greenCurve.value.curve); |
||||
m_RawBlueCurve = FindProperty(x => x.blueCurve.value.curve); |
||||
|
||||
m_RawHueVsHueCurve = FindProperty(x => x.hueVsHueCurve.value.curve); |
||||
m_RawHueVsSatCurve = FindProperty(x => x.hueVsSatCurve.value.curve); |
||||
m_RawSatVsSatCurve = FindProperty(x => x.satVsSatCurve.value.curve); |
||||
m_RawLumVsSatCurve = FindProperty(x => x.lumVsSatCurve.value.curve); |
||||
|
||||
m_CurveEditor = new CurveEditor(); |
||||
m_CurveDict = new Dictionary<SerializedProperty, Color>(); |
||||
|
||||
// Prepare the curve editor |
||||
SetupCurve(m_RawMasterCurve, new Color(1f, 1f, 1f), 2, false); |
||||
SetupCurve(m_RawRedCurve, new Color(1f, 0f, 0f), 2, false); |
||||
SetupCurve(m_RawGreenCurve, new Color(0f, 1f, 0f), 2, false); |
||||
SetupCurve(m_RawBlueCurve, new Color(0f, 0.5f, 1f), 2, false); |
||||
SetupCurve(m_RawHueVsHueCurve, new Color(1f, 1f, 1f), 0, true); |
||||
SetupCurve(m_RawHueVsSatCurve, new Color(1f, 1f, 1f), 0, true); |
||||
SetupCurve(m_RawSatVsSatCurve, new Color(1f, 1f, 1f), 0, false); |
||||
SetupCurve(m_RawLumVsSatCurve, new Color(1f, 1f, 1f), 0, false); |
||||
} |
||||
|
||||
public override void OnInspectorGUI() |
||||
{ |
||||
PropertyField(m_GradingMode); |
||||
|
||||
var gradingMode = (GradingMode)m_GradingMode.value.intValue; |
||||
|
||||
// Check if we're in gamma or linear and display a warning if we're trying to do hdr |
||||
// color grading while being in gamma mode |
||||
if (gradingMode != GradingMode.LowDefinitionRange) |
||||
{ |
||||
if (QualitySettings.activeColorSpace == ColorSpace.Gamma) |
||||
EditorGUILayout.HelpBox("ColorSpace in project settings is set to Gamma, HDR color grading won't look correct. Switch to Linear or use LDR color grading mode instead.", MessageType.Warning); |
||||
} |
||||
|
||||
if (m_GradingMode.overrideState.boolValue && gradingMode == GradingMode.External) |
||||
{ |
||||
if (!SystemInfo.supports3DRenderTextures || !SystemInfo.supportsComputeShaders) |
||||
EditorGUILayout.HelpBox("HDR color grading requires compute shader & 3D render texture support.", MessageType.Warning); |
||||
} |
||||
|
||||
if (gradingMode == GradingMode.LowDefinitionRange) |
||||
DoStandardModeGUI(false); |
||||
else if (gradingMode == GradingMode.HighDefinitionRange) |
||||
DoStandardModeGUI(true); |
||||
else if (gradingMode == GradingMode.External) |
||||
DoExternalModeGUI(); |
||||
|
||||
EditorGUILayout.Space(); |
||||
} |
||||
|
||||
void SetupCurve(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); |
||||
} |
||||
|
||||
void DoExternalModeGUI() |
||||
{ |
||||
PropertyField(m_ExternalLut); |
||||
|
||||
var lut = m_ExternalLut.value.objectReferenceValue; |
||||
if (lut != null) |
||||
{ |
||||
if (lut.GetType() == typeof(Texture3D)) |
||||
{ |
||||
var o = (Texture3D)lut; |
||||
if (o.width == o.height && o.height == o.depth) |
||||
return; |
||||
} |
||||
else if (lut.GetType() == typeof(RenderTexture)) |
||||
{ |
||||
var o = (RenderTexture)lut; |
||||
if (o.width == o.height && o.height == o.volumeDepth) |
||||
return; |
||||
} |
||||
|
||||
EditorGUILayout.HelpBox("Custom LUTs have to be log-encoded 3D textures or 3D render textures with cube format.", MessageType.Warning); |
||||
} |
||||
} |
||||
|
||||
void DoStandardModeGUI(bool hdr) |
||||
{ |
||||
if (!hdr) |
||||
{ |
||||
PropertyField(m_LdrLut); |
||||
|
||||
var lut = (target as ColorGrading).ldrLut.value; |
||||
CheckLutImportSettings(lut); |
||||
} |
||||
|
||||
if (hdr) |
||||
{ |
||||
EditorGUILayout.Space(); |
||||
EditorUtilities.DrawHeaderLabel("Tonemapping"); |
||||
PropertyField(m_Tonemapper); |
||||
|
||||
if (m_Tonemapper.value.intValue == (int)Tonemapper.Custom) |
||||
{ |
||||
DrawCustomToneCurve(); |
||||
PropertyField(m_ToneCurveToeStrength); |
||||
PropertyField(m_ToneCurveToeLength); |
||||
PropertyField(m_ToneCurveShoulderStrength); |
||||
PropertyField(m_ToneCurveShoulderLength); |
||||
PropertyField(m_ToneCurveShoulderAngle); |
||||
PropertyField(m_ToneCurveGamma); |
||||
} |
||||
} |
||||
|
||||
EditorGUILayout.Space(); |
||||
EditorUtilities.DrawHeaderLabel("White Balance"); |
||||
|
||||
PropertyField(m_Temperature); |
||||
PropertyField(m_Tint); |
||||
|
||||
EditorGUILayout.Space(); |
||||
EditorUtilities.DrawHeaderLabel("Tone"); |
||||
|
||||
if (hdr) |
||||
PropertyField(m_PostExposure); |
||||
|
||||
PropertyField(m_ColorFilter); |
||||
PropertyField(m_HueShift); |
||||
PropertyField(m_Saturation); |
||||
|
||||
if (!hdr) |
||||
PropertyField(m_Brightness); |
||||
|
||||
PropertyField(m_Contrast); |
||||
|
||||
EditorGUILayout.Space(); |
||||
int currentChannel = GlobalSettings.currentChannelMixer; |
||||
|
||||
using (new EditorGUILayout.HorizontalScope()) |
||||
{ |
||||
EditorGUILayout.PrefixLabel("Channel Mixer", GUIStyle.none, Styling.labelHeader); |
||||
|
||||
EditorGUI.BeginChangeCheck(); |
||||
{ |
||||
using (new EditorGUILayout.HorizontalScope()) |
||||
{ |
||||
GUILayoutUtility.GetRect(9f, 18f, GUILayout.ExpandWidth(false)); // Dirty hack to do proper right column alignement |
||||
if (GUILayout.Toggle(currentChannel == 0, EditorUtilities.GetContent("Red|Red output channel."), EditorStyles.miniButtonLeft)) currentChannel = 0; |
||||
if (GUILayout.Toggle(currentChannel == 1, EditorUtilities.GetContent("Green|Green output channel."), EditorStyles.miniButtonMid)) currentChannel = 1; |
||||
if (GUILayout.Toggle(currentChannel == 2, EditorUtilities.GetContent("Blue|Blue output channel."), EditorStyles.miniButtonRight)) currentChannel = 2; |
||||
} |
||||
} |
||||
if (EditorGUI.EndChangeCheck()) |
||||
GUI.FocusControl(null); |
||||
} |
||||
|
||||
GlobalSettings.currentChannelMixer = currentChannel; |
||||
|
||||
if (currentChannel == 0) |
||||
{ |
||||
PropertyField(m_MixerRedOutRedIn); |
||||
PropertyField(m_MixerRedOutGreenIn); |
||||
PropertyField(m_MixerRedOutBlueIn); |
||||
} |
||||
else if (currentChannel == 1) |
||||
{ |
||||
PropertyField(m_MixerGreenOutRedIn); |
||||
PropertyField(m_MixerGreenOutGreenIn); |
||||
PropertyField(m_MixerGreenOutBlueIn); |
||||
} |
||||
else |
||||
{ |
||||
PropertyField(m_MixerBlueOutRedIn); |
||||
PropertyField(m_MixerBlueOutGreenIn); |
||||
PropertyField(m_MixerBlueOutBlueIn); |
||||
} |
||||
|
||||
EditorGUILayout.Space(); |
||||
EditorUtilities.DrawHeaderLabel("Trackballs"); |
||||
|
||||
using (new EditorGUILayout.HorizontalScope()) |
||||
{ |
||||
PropertyField(m_Lift); |
||||
GUILayout.Space(4f); |
||||
PropertyField(m_Gamma); |
||||
GUILayout.Space(4f); |
||||
PropertyField(m_Gain); |
||||
} |
||||
|
||||
EditorGUILayout.Space(); |
||||
EditorUtilities.DrawHeaderLabel("Grading Curves"); |
||||
|
||||
DoCurvesGUI(hdr); |
||||
} |
||||
|
||||
void CheckLutImportSettings(Texture lut) |
||||
{ |
||||
if (lut != null) |
||||
{ |
||||
var importer = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(lut)) as TextureImporter; |
||||
|
||||
// Fails when using an internal texture as you can't change import settings on |
||||
// builtin resources, thus the check for null |
||||
if (importer != null) |
||||
{ |
||||
bool valid = importer.anisoLevel == 0 |
||||
&& importer.mipmapEnabled == false |
||||
&& importer.sRGBTexture == false |
||||
&& importer.textureCompression == TextureImporterCompression.Uncompressed |
||||
&& importer.wrapMode == TextureWrapMode.Clamp; |
||||
|
||||
if (!valid) |
||||
EditorUtilities.DrawFixMeBox("Invalid LUT import settings.", () => SetLutImportSettings(importer)); |
||||
} |
||||
} |
||||
} |
||||
|
||||
void SetLutImportSettings(TextureImporter importer) |
||||
{ |
||||
importer.textureType = TextureImporterType.Default; |
||||
importer.mipmapEnabled = false; |
||||
importer.anisoLevel = 0; |
||||
importer.sRGBTexture = false; |
||||
importer.npotScale = TextureImporterNPOTScale.None; |
||||
importer.textureCompression = TextureImporterCompression.Uncompressed; |
||||
importer.alphaSource = TextureImporterAlphaSource.None; |
||||
importer.wrapMode = TextureWrapMode.Clamp; |
||||
importer.SaveAndReimport(); |
||||
AssetDatabase.Refresh(); |
||||
} |
||||
|
||||
void DrawCustomToneCurve() |
||||
{ |
||||
EditorGUILayout.Space(); |
||||
|
||||
// Reserve GUI space |
||||
using (new GUILayout.HorizontalScope()) |
||||
{ |
||||
GUILayout.Space(EditorGUI.indentLevel * 15f); |
||||
m_CustomToneCurveRect = GUILayoutUtility.GetRect(128, 80); |
||||
} |
||||
|
||||
if (Event.current.type != EventType.Repaint) |
||||
return; |
||||
|
||||
// Prepare curve data |
||||
float toeStrength = m_ToneCurveToeStrength.value.floatValue; |
||||
float toeLength = m_ToneCurveToeLength.value.floatValue; |
||||
float shoulderStrength = m_ToneCurveShoulderStrength.value.floatValue; |
||||
float shoulderLength = m_ToneCurveShoulderLength.value.floatValue; |
||||
float shoulderAngle = m_ToneCurveShoulderAngle.value.floatValue; |
||||
float gamma = m_ToneCurveGamma.value.floatValue; |
||||
m_HableCurve.Init( |
||||
toeStrength, |
||||
toeLength, |
||||
shoulderStrength, |
||||
shoulderLength, |
||||
shoulderAngle, |
||||
gamma |
||||
); |
||||
|
||||
float endPoint = m_HableCurve.whitePoint; |
||||
|
||||
// Background |
||||
m_RectVertices[0] = PointInRect(0f, 0f, endPoint); |
||||
m_RectVertices[1] = PointInRect(endPoint, 0f, endPoint); |
||||
m_RectVertices[2] = PointInRect(endPoint, k_CustomToneCurveRangeY, endPoint); |
||||
m_RectVertices[3] = PointInRect(0f, k_CustomToneCurveRangeY, endPoint); |
||||
Handles.DrawSolidRectangleWithOutline(m_RectVertices, Color.white * 0.1f, Color.white * 0.4f); |
||||
|
||||
// Vertical guides |
||||
if (endPoint < m_CustomToneCurveRect.width / 3) |
||||
{ |
||||
int steps = Mathf.CeilToInt(endPoint); |
||||
for (var i = 1; i < steps; i++) |
||||
DrawLine(i, 0, i, k_CustomToneCurveRangeY, 0.4f, endPoint); |
||||
} |
||||
|
||||
// Label |
||||
Handles.Label(m_CustomToneCurveRect.position + Vector2.right, "Custom Tone Curve", EditorStyles.miniLabel); |
||||
|
||||
// Draw the acual curve |
||||
var vcount = 0; |
||||
while (vcount < k_CustomToneCurveResolution) |
||||
{ |
||||
float x = endPoint * vcount / (k_CustomToneCurveResolution - 1); |
||||
float y = m_HableCurve.Eval(x); |
||||
|
||||
if (y < k_CustomToneCurveRangeY) |
||||
{ |
||||
m_CurveVertices[vcount++] = PointInRect(x, y, endPoint); |
||||
} |
||||
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_CustomToneCurveRect.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(2f, vcount, m_CurveVertices); |
||||
} |
||||
} |
||||
|
||||
void DrawLine(float x1, float y1, float x2, float y2, float grayscale, float rangeX) |
||||
{ |
||||
m_LineVertices[0] = PointInRect(x1, y1, rangeX); |
||||
m_LineVertices[1] = PointInRect(x2, y2, rangeX); |
||||
Handles.color = Color.white * grayscale; |
||||
Handles.DrawAAPolyLine(2f, m_LineVertices); |
||||
} |
||||
|
||||
Vector3 PointInRect(float x, float y, float rangeX) |
||||
{ |
||||
x = Mathf.Lerp(m_CustomToneCurveRect.x, m_CustomToneCurveRect.xMax, x / rangeX); |
||||
y = Mathf.Lerp(m_CustomToneCurveRect.yMax, m_CustomToneCurveRect.y, y / k_CustomToneCurveRangeY); |
||||
return new Vector3(x, y, 0); |
||||
} |
||||
|
||||
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 rawProp, SerializedProperty overrideProp) |
||||
{ |
||||
var state = m_CurveEditor.GetCurveState(rawProp); |
||||
state.visible = true; |
||||
state.editable = overrideProp.boolValue; |
||||
m_CurveEditor.SetCurveState(rawProp, state); |
||||
} |
||||
|
||||
void CurveOverrideToggle(SerializedProperty overrideProp) |
||||
{ |
||||
overrideProp.boolValue = GUILayout.Toggle(overrideProp.boolValue, EditorUtilities.GetContent("Override"), EditorStyles.toolbarButton); |
||||
} |
||||
|
||||
static Material s_MaterialGrid; |
||||
|
||||
void DoCurvesGUI(bool hdr) |
||||
{ |
||||
EditorGUILayout.Space(); |
||||
ResetVisibleCurves(); |
||||
|
||||
using (new EditorGUI.DisabledGroupScope(serializedObject.isEditingMultipleObjects)) |
||||
{ |
||||
int curveEditingId = 0; |
||||
SerializedProperty currentCurveRawProp = null; |
||||
|
||||
// Top toolbar |
||||
using (new GUILayout.HorizontalScope(EditorStyles.toolbar)) |
||||
{ |
||||
curveEditingId = DoCurveSelectionPopup(GlobalSettings.currentCurve, hdr); |
||||
curveEditingId = Mathf.Clamp(curveEditingId, hdr ? 4 : 0, 7); |
||||
|
||||
EditorGUILayout.Space(); |
||||
|
||||
switch (curveEditingId) |
||||
{ |
||||
case 0: |
||||
CurveOverrideToggle(m_MasterCurve.overrideState); |
||||
SetCurveVisible(m_RawMasterCurve, m_MasterCurve.overrideState); |
||||
currentCurveRawProp = m_RawMasterCurve; |
||||
break; |
||||
case 1: |
||||
CurveOverrideToggle(m_RedCurve.overrideState); |
||||
SetCurveVisible(m_RawRedCurve, m_RedCurve.overrideState); |
||||
currentCurveRawProp = m_RawRedCurve; |
||||
break; |
||||
case 2: |
||||
CurveOverrideToggle(m_GreenCurve.overrideState); |
||||
SetCurveVisible(m_RawGreenCurve, m_GreenCurve.overrideState); |
||||
currentCurveRawProp = m_RawGreenCurve; |
||||
break; |
||||
case 3: |
||||
CurveOverrideToggle(m_BlueCurve.overrideState); |
||||
SetCurveVisible(m_RawBlueCurve, m_BlueCurve.overrideState); |
||||
currentCurveRawProp = m_RawBlueCurve; |
||||
break; |
||||
case 4: |
||||
CurveOverrideToggle(m_HueVsHueCurve.overrideState); |
||||
SetCurveVisible(m_RawHueVsHueCurve, m_HueVsHueCurve.overrideState); |
||||
currentCurveRawProp = m_RawHueVsHueCurve; |
||||
break; |
||||
case 5: |
||||
CurveOverrideToggle(m_HueVsSatCurve.overrideState); |
||||
SetCurveVisible(m_RawHueVsSatCurve, m_HueVsSatCurve.overrideState); |
||||
currentCurveRawProp = m_RawHueVsSatCurve; |
||||
break; |
||||
case 6: |
||||
CurveOverrideToggle(m_SatVsSatCurve.overrideState); |
||||
SetCurveVisible(m_RawSatVsSatCurve, m_SatVsSatCurve.overrideState); |
||||
currentCurveRawProp = m_RawSatVsSatCurve; |
||||
break; |
||||
case 7: |
||||
CurveOverrideToggle(m_LumVsSatCurve.overrideState); |
||||
SetCurveVisible(m_RawLumVsSatCurve, m_LumVsSatCurve.overrideState); |
||||
currentCurveRawProp = m_RawLumVsSatCurve; |
||||
break; |
||||
} |
||||
|
||||
GUILayout.FlexibleSpace(); |
||||
|
||||
if (GUILayout.Button("Reset", EditorStyles.toolbarButton)) |
||||
{ |
||||
switch (curveEditingId) |
||||
{ |
||||
case 0: m_RawMasterCurve.animationCurveValue = AnimationCurve.Linear(0f, 0f, 1f, 1f); |
||||
break; |
||||
case 1: m_RawRedCurve.animationCurveValue = AnimationCurve.Linear(0f, 0f, 1f, 1f); |
||||
break; |
||||
case 2: m_RawGreenCurve.animationCurveValue = AnimationCurve.Linear(0f, 0f, 1f, 1f); |
||||
break; |
||||
case 3: m_RawBlueCurve.animationCurveValue = AnimationCurve.Linear(0f, 0f, 1f, 1f); |
||||
break; |
||||
case 4: m_RawHueVsHueCurve.animationCurveValue = new AnimationCurve(); |
||||
break; |
||||
case 5: m_RawHueVsSatCurve.animationCurveValue = new AnimationCurve(); |
||||
break; |
||||
case 6: m_RawSatVsSatCurve.animationCurveValue = new AnimationCurve(); |
||||
break; |
||||
case 7: m_RawLumVsSatCurve.animationCurveValue = new AnimationCurve(); |
||||
break; |
||||
} |
||||
} |
||||
|
||||
GlobalSettings.currentCurve = 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 (curveEditingId == 4 || curveEditingId == 5) |
||||
DrawBackgroundTexture(innerRect, 0); |
||||
else if (curveEditingId == 6 || curveEditingId == 7) |
||||
DrawBackgroundTexture(innerRect, 1); |
||||
|
||||
// Bounds |
||||
Handles.color = Color.white * (GUI.enabled ? 1f : 0.5f); |
||||
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)); |
||||
|
||||
bool editable = m_CurveEditor.GetCurveState(currentCurveRawProp).editable; |
||||
string editableString = editable ? string.Empty : "(Not Overriding)\n"; |
||||
|
||||
// Selection info |
||||
var selection = m_CurveEditor.GetSelection(); |
||||
var infoRect = innerRect; |
||||
infoRect.x += 5f; |
||||
infoRect.width = 100f; |
||||
infoRect.height = 30f; |
||||
|
||||
if (selection.curve != null && selection.keyframeIndex > -1) |
||||
{ |
||||
var key = selection.keyframe.Value; |
||||
GUI.Label(infoRect, string.Format("{0}\n{1}", key.time.ToString("F3"), key.value.ToString("F3")), Styling.preLabel); |
||||
} |
||||
else |
||||
{ |
||||
GUI.Label(infoRect, editableString, Styling.preLabel); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
void DrawBackgroundTexture(Rect rect, int pass) |
||||
{ |
||||
if (s_MaterialGrid == null) |
||||
s_MaterialGrid = new Material(Shader.Find("Hidden/PostProcessing/Editor/CurveGrid")) { hideFlags = HideFlags.HideAndDontSave }; |
||||
|
||||
float scale = EditorGUIUtility.pixelsPerPoint; |
||||
|
||||
#if UNITY_2018_1_OR_NEWER |
||||
const RenderTextureReadWrite kReadWrite = RenderTextureReadWrite.sRGB; |
||||
#else |
||||
const RenderTextureReadWrite kReadWrite = RenderTextureReadWrite.Linear; |
||||
#endif |
||||
|
||||
var oldRt = RenderTexture.active; |
||||
var rt = RenderTexture.GetTemporary(Mathf.CeilToInt(rect.width * scale), Mathf.CeilToInt(rect.height * scale), 0, RenderTextureFormat.ARGB32, kReadWrite); |
||||
s_MaterialGrid.SetFloat("_DisabledState", GUI.enabled ? 1f : 0.5f); |
||||
s_MaterialGrid.SetFloat("_PixelScaling", EditorGUIUtility.pixelsPerPoint); |
||||
|
||||
Graphics.Blit(null, rt, s_MaterialGrid, pass); |
||||
RenderTexture.active = oldRt; |
||||
|
||||
GUI.DrawTexture(rect, rt); |
||||
RenderTexture.ReleaseTemporary(rt); |
||||
} |
||||
|
||||
int DoCurveSelectionPopup(int id, bool hdr) |
||||
{ |
||||
GUILayout.Label(s_Curves[id], EditorStyles.toolbarPopup, GUILayout.MaxWidth(150f)); |
||||
|
||||
var lastRect = GUILayoutUtility.GetLastRect(); |
||||
var e = Event.current; |
||||
|
||||
if (e.type == EventType.MouseDown && e.button == 0 && lastRect.Contains(e.mousePosition)) |
||||
{ |
||||
var menu = new GenericMenu(); |
||||
|
||||
for (int i = 0; i < s_Curves.Length; i++) |
||||
{ |
||||
if (i == 4) |
||||
menu.AddSeparator(""); |
||||
|
||||
if (hdr && i < 4) |
||||
menu.AddDisabledItem(s_Curves[i]); |
||||
else |
||||
{ |
||||
int current = i; // Capture local for closure |
||||
menu.AddItem(s_Curves[i], current == id, () => GlobalSettings.currentCurve = current); |
||||
} |
||||
} |
||||
|
||||
menu.DropDown(new Rect(lastRect.xMin, lastRect.yMax, 1f, 1f)); |
||||
} |
||||
|
||||
return id; |
||||
} |
||||
} |
||||
} |
||||
@ -1,12 +0,0 @@ |
||||
fileFormatVersion: 2 |
||||
guid: f79c8927d684af6499f512361e23bace |
||||
timeCreated: 1493026581 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -1,41 +0,0 @@ |
||||
using System; |
||||
using System.Collections.Generic; |
||||
using System.Linq; |
||||
using System.Reflection; |
||||
using UnityEngine.Rendering.PostProcessing; |
||||
|
||||
namespace UnityEditor.Rendering.PostProcessing |
||||
{ |
||||
public class DefaultPostProcessEffectEditor : PostProcessEffectBaseEditor |
||||
{ |
||||
List<SerializedParameterOverride> m_Parameters; |
||||
|
||||
public override void OnEnable() |
||||
{ |
||||
m_Parameters = new List<SerializedParameterOverride>(); |
||||
|
||||
var fields = target.GetType() |
||||
.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) |
||||
.Where(t => t.FieldType.IsSubclassOf(typeof(ParameterOverride)) && t.Name != "enabled") |
||||
.Where(t => |
||||
(t.IsPublic && t.GetCustomAttributes(typeof(NonSerializedAttribute), false).Length == 0) |
||||
|| (t.GetCustomAttributes(typeof(UnityEngine.SerializeField), false).Length > 0) |
||||
) |
||||
.ToList(); |
||||
|
||||
foreach (var field in fields) |
||||
{ |
||||
var property = serializedObject.FindProperty(field.Name); |
||||
var attributes = field.GetCustomAttributes(false).Cast<Attribute>().ToArray(); |
||||
var parameter = new SerializedParameterOverride(property, attributes); |
||||
m_Parameters.Add(parameter); |
||||
} |
||||
} |
||||
|
||||
public override void OnInspectorGUI() |
||||
{ |
||||
foreach (var parameter in m_Parameters) |
||||
PropertyField(parameter); |
||||
} |
||||
} |
||||
} |
||||
@ -1,12 +0,0 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 4b0cd5ddb61a56b4f86ea0fd0a102fe7 |
||||
timeCreated: 1492705253 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -1,33 +0,0 @@ |
||||
using UnityEngine; |
||||
using UnityEngine.Rendering.PostProcessing; |
||||
|
||||
namespace UnityEditor.Rendering.PostProcessing |
||||
{ |
||||
[PostProcessEditor(typeof(DepthOfField))] |
||||
public sealed class DepthOfFieldEditor : PostProcessEffectEditor<DepthOfField> |
||||
{ |
||||
SerializedParameterOverride m_FocusDistance; |
||||
SerializedParameterOverride m_Aperture; |
||||
SerializedParameterOverride m_FocalLength; |
||||
SerializedParameterOverride m_KernelSize; |
||||
|
||||
public override void OnEnable() |
||||
{ |
||||
m_FocusDistance = FindParameterOverride(x => x.focusDistance); |
||||
m_Aperture = FindParameterOverride(x => x.aperture); |
||||
m_FocalLength = FindParameterOverride(x => x.focalLength); |
||||
m_KernelSize = FindParameterOverride(x => x.kernelSize); |
||||
} |
||||
|
||||
public override void OnInspectorGUI() |
||||
{ |
||||
if (SystemInfo.graphicsShaderLevel < 35) |
||||
EditorGUILayout.HelpBox("Depth Of Field is only supported on the following platforms:\nDX11+, OpenGL 3.2+, OpenGL ES 3+, Metal, Vulkan, PS4/XB1 consoles.", MessageType.Warning); |
||||
|
||||
PropertyField(m_FocusDistance); |
||||
PropertyField(m_Aperture); |
||||
PropertyField(m_FocalLength); |
||||
PropertyField(m_KernelSize); |
||||
} |
||||
} |
||||
} |
||||
@ -1,12 +0,0 @@ |
||||
fileFormatVersion: 2 |
||||
guid: eb4c0b518e013c8418135b3bd8a91b6c |
||||
timeCreated: 1513004657 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -1,58 +0,0 @@ |
||||
using UnityEngine; |
||||
using UnityEngine.Rendering.PostProcessing; |
||||
|
||||
namespace UnityEditor.Rendering.PostProcessing |
||||
{ |
||||
[PostProcessEditor(typeof(ScreenSpaceReflections))] |
||||
public sealed class ScreenSpaceReflectionsEditor : PostProcessEffectEditor<ScreenSpaceReflections> |
||||
{ |
||||
SerializedParameterOverride m_Preset; |
||||
SerializedParameterOverride m_MaximumIterationCount; |
||||
SerializedParameterOverride m_Thickness; |
||||
SerializedParameterOverride m_Resolution; |
||||
SerializedParameterOverride m_MaximumMarchDistance; |
||||
SerializedParameterOverride m_DistanceFade; |
||||
SerializedParameterOverride m_Vignette; |
||||
|
||||
public override void OnEnable() |
||||
{ |
||||
m_Preset = FindParameterOverride(x => x.preset); |
||||
m_MaximumIterationCount = FindParameterOverride(x => x.maximumIterationCount); |
||||
m_Thickness = FindParameterOverride(x => x.thickness); |
||||
m_Resolution = FindParameterOverride(x => x.resolution); |
||||
m_MaximumMarchDistance = FindParameterOverride(x => x.maximumMarchDistance); |
||||
m_DistanceFade = FindParameterOverride(x => x.distanceFade); |
||||
m_Vignette = FindParameterOverride(x => x.vignette); |
||||
} |
||||
|
||||
public override void OnInspectorGUI() |
||||
{ |
||||
if (RuntimeUtilities.scriptableRenderPipelineActive) |
||||
{ |
||||
EditorGUILayout.HelpBox("This effect doesn't work with scriptable render pipelines yet.", MessageType.Warning); |
||||
return; |
||||
} |
||||
|
||||
if (Camera.main != null && Camera.main.actualRenderingPath != RenderingPath.DeferredShading) |
||||
EditorGUILayout.HelpBox("This effect only works with the deferred rendering path.", MessageType.Warning); |
||||
|
||||
if (!SystemInfo.supportsComputeShaders) |
||||
EditorGUILayout.HelpBox("This effect requires compute shader support.", MessageType.Warning); |
||||
|
||||
PropertyField(m_Preset); |
||||
|
||||
if (m_Preset.value.intValue == (int)ScreenSpaceReflectionPreset.Custom) |
||||
{ |
||||
PropertyField(m_MaximumIterationCount); |
||||
PropertyField(m_Thickness); |
||||
PropertyField(m_Resolution); |
||||
|
||||
EditorGUILayout.Space(); |
||||
} |
||||
|
||||
PropertyField(m_MaximumMarchDistance); |
||||
PropertyField(m_DistanceFade); |
||||
PropertyField(m_Vignette); |
||||
} |
||||
} |
||||
} |
||||
@ -1,12 +0,0 @@ |
||||
fileFormatVersion: 2 |
||||
guid: d798d5719bf3b434eafb013385f872eb |
||||
timeCreated: 1505226497 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -1,91 +0,0 @@ |
||||
using UnityEngine; |
||||
using UnityEngine.Rendering.PostProcessing; |
||||
|
||||
namespace UnityEditor.Rendering.PostProcessing |
||||
{ |
||||
[PostProcessEditor(typeof(Vignette))] |
||||
public sealed class VignetteEditor : PostProcessEffectEditor<Vignette> |
||||
{ |
||||
SerializedParameterOverride m_Mode; |
||||
SerializedParameterOverride m_Color; |
||||
|
||||
SerializedParameterOverride m_Center; |
||||
SerializedParameterOverride m_Intensity; |
||||
SerializedParameterOverride m_Smoothness; |
||||
SerializedParameterOverride m_Roundness; |
||||
SerializedParameterOverride m_Rounded; |
||||
|
||||
SerializedParameterOverride m_Mask; |
||||
SerializedParameterOverride m_Opacity; |
||||
|
||||
public override void OnEnable() |
||||
{ |
||||
m_Mode = FindParameterOverride(x => x.mode); |
||||
m_Color = FindParameterOverride(x => x.color); |
||||
|
||||
m_Center = FindParameterOverride(x => x.center); |
||||
m_Intensity = FindParameterOverride(x => x.intensity); |
||||
m_Smoothness = FindParameterOverride(x => x.smoothness); |
||||
m_Roundness = FindParameterOverride(x => x.roundness); |
||||
m_Rounded = FindParameterOverride(x => x.rounded); |
||||
|
||||
m_Mask = FindParameterOverride(x => x.mask); |
||||
m_Opacity = FindParameterOverride(x => x.opacity); |
||||
} |
||||
|
||||
public override void OnInspectorGUI() |
||||
{ |
||||
PropertyField(m_Mode); |
||||
PropertyField(m_Color); |
||||
|
||||
if (m_Mode.value.intValue == (int)VignetteMode.Classic) |
||||
{ |
||||
PropertyField(m_Center); |
||||
PropertyField(m_Intensity); |
||||
PropertyField(m_Smoothness); |
||||
PropertyField(m_Roundness); |
||||
PropertyField(m_Rounded); |
||||
} |
||||
else |
||||
{ |
||||
PropertyField(m_Mask); |
||||
|
||||
var mask = (target as Vignette).mask.value; |
||||
|
||||
// Checks import settings on the mask |
||||
if (mask != null) |
||||
{ |
||||
var importer = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(mask)) as TextureImporter; |
||||
|
||||
// Fails when using an internal texture as you can't change import settings on |
||||
// builtin resources, thus the check for null |
||||
if (importer != null) |
||||
{ |
||||
bool valid = importer.anisoLevel == 0 |
||||
&& importer.mipmapEnabled == false |
||||
&& importer.alphaSource == TextureImporterAlphaSource.FromGrayScale |
||||
&& importer.textureCompression == TextureImporterCompression.Uncompressed |
||||
&& importer.wrapMode == TextureWrapMode.Clamp; |
||||
|
||||
if (!valid) |
||||
EditorUtilities.DrawFixMeBox("Invalid mask import settings.", () => SetMaskImportSettings(importer)); |
||||
} |
||||
} |
||||
|
||||
PropertyField(m_Opacity); |
||||
} |
||||
} |
||||
|
||||
void SetMaskImportSettings(TextureImporter importer) |
||||
{ |
||||
importer.textureType = TextureImporterType.SingleChannel; |
||||
importer.alphaSource = TextureImporterAlphaSource.FromGrayScale; |
||||
importer.textureCompression = TextureImporterCompression.Uncompressed; |
||||
importer.anisoLevel = 0; |
||||
importer.mipmapEnabled = false; |
||||
importer.wrapMode = TextureWrapMode.Clamp; |
||||
importer.SaveAndReimport(); |
||||
AssetDatabase.Refresh(); |
||||
} |
||||
} |
||||
} |
||||
@ -1,12 +0,0 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 3869d037332a74744a54736f00d62763 |
||||
timeCreated: 1492696599 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -1,7 +1,7 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 018e19d6c1b36224b85b5c0ddd6a895e |
||||
guid: d5341d31985da604db4b100f174142ad |
||||
folderAsset: yes |
||||
timeCreated: 1489051059 |
||||
timeCreated: 1466769808 |
||||
licenseType: Pro |
||||
DefaultImporter: |
||||
userData: |
||||
@ -0,0 +1,42 @@ |
||||
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,6 +1,6 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 69a4fc27499557744827c787d71fdf08 |
||||
timeCreated: 1488275908 |
||||
guid: 9fcb710e23a5a0546a3b8b0ca28c1720 |
||||
timeCreated: 1467190133 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
@ -0,0 +1,71 @@ |
||||
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,6 +1,6 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 70ea2ab329ffbac43a0a02daa61dbe6b |
||||
timeCreated: 1492690987 |
||||
guid: 2451939fe695c1a408ba688219837667 |
||||
timeCreated: 1467190133 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
@ -0,0 +1,204 @@ |
||||
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,6 +1,6 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 6b2666165a17bbd4e851c1382898651e |
||||
timeCreated: 1493051184 |
||||
guid: a95f3f10e7e437c49ade656f531b30d2 |
||||
timeCreated: 1467190133 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
@ -0,0 +1,106 @@ |
||||
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); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 760ffebbef2ed644c87940a699eb7fe6 |
||||
timeCreated: 1468237035 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -0,0 +1,9 @@ |
||||
using UnityEngine.PostProcessing; |
||||
|
||||
namespace UnityEditor.PostProcessing |
||||
{ |
||||
[PostProcessingModelEditor(typeof(ChromaticAberrationModel))] |
||||
public class ChromaticaAberrationModelEditor : DefaultPostFxModelEditor |
||||
{ |
||||
} |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 8a713f71a0169794a915a081f6242f60 |
||||
timeCreated: 1467190133 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -0,0 +1,672 @@ |
||||
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); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
fileFormatVersion: 2 |
||||
guid: c3e3bce1d5c900d4fa7aa0f2b21814cf |
||||
timeCreated: 1467190133 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -0,0 +1,22 @@ |
||||
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); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
fileFormatVersion: 2 |
||||
guid: c15016a7fef58974f91a6a4d6b132d94 |
||||
timeCreated: 1467190133 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -0,0 +1,37 @@ |
||||
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); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
fileFormatVersion: 2 |
||||
guid: dc2f388440e9f8b4f8fc7bb43c01cc7d |
||||
timeCreated: 1467190133 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -0,0 +1,16 @@ |
||||
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); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 87377c86d84f49a4e912d37d28353e7f |
||||
timeCreated: 1485179854 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -0,0 +1,86 @@ |
||||
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--; |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 489b5c785ba0f614d90c322fa0827216 |
||||
timeCreated: 1467190133 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -0,0 +1,24 @@ |
||||
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--; |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 44a64b44ec891d24b96ed84d958c3d4f |
||||
timeCreated: 1487335049 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -0,0 +1,31 @@ |
||||
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); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 8330694e2c90c284f81153ac83b3cb4a |
||||
timeCreated: 1467190133 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -0,0 +1,197 @@ |
||||
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--; |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 870806eda355b5144879155e2ba37eb6 |
||||
timeCreated: 1468325681 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -0,0 +1,100 @@ |
||||
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--; |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 57bbe1f20eec7bb4d9bc90fc65ef381b |
||||
timeCreated: 1467190133 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -0,0 +1,87 @@ |
||||
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(); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
fileFormatVersion: 2 |
||||
guid: b235eb1c486b38c4fa06470234bbfd32 |
||||
timeCreated: 1466769818 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -0,0 +1,118 @@ |
||||
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(); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 745ad42620dabf04b94761acc86189ba |
||||
timeCreated: 1467190133 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
defaultReferences: [] |
||||
executionOrder: 0 |
||||
icon: {instanceID: 0} |
||||
userData: |
||||
assetBundleName: |
||||
assetBundleVariant: |
||||
@ -1,7 +1,7 @@ |
||||
fileFormatVersion: 2 |
||||
guid: 21a375b704549664589881dfc892e7e7 |
||||
guid: e31078d57ac582944ad5e1e76a84f36a |
||||
folderAsset: yes |
||||
timeCreated: 1493051174 |
||||
timeCreated: 1467188891 |
||||
licenseType: Pro |
||||
DefaultImporter: |
||||
userData: |
||||
@ -0,0 +1,338 @@ |
||||
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,6 +1,6 @@ |
||||
fileFormatVersion: 2 |
||||
guid: cce62646e6d421c41b0aa1c300fcd0fe |
||||
timeCreated: 1499676418 |
||||
guid: 4581c45ac4aa2264187087659a4cc252 |
||||
timeCreated: 1460031632 |
||||
licenseType: Pro |
||||
MonoImporter: |
||||
serializedVersion: 2 |
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue