public static void ConvertColourGradingViaLUT(PostProcessProfile ppp,
ColorGradingModel oldColorGradingSettings, PostProcessingProfile oldPPP)
{
var materialFactory = new MaterialFactory();
var uberShader = materialFactory.Get("Hidden/Post FX/Uber Shader");
uberShader.shaderKeywords = new string[0];
var cgc = new ColorGradingComponent();
cgc.Init(new PostProcessingContext
{
materialFactory = materialFactory
}, oldColorGradingSettings);
cgc.context.profile = oldPPP;
cgc.Prepare(uberShader);
var cg = ppp.AddSettings <ColorGrading>();
cg.gradingMode.value = GradingMode.LowDefinitionRange;
cg.gradingMode.overrideState = true;
var lut = cgc.model.bakedLut;
/*
* var textureFormat = TextureFormat.RGBAHalf;
* if (!SystemInfo.SupportsTextureFormat(textureFormat))
* textureFormat = TextureFormat.ARGB32;
*
* var lutAsT2D = lut.GrabTexture(dontUseCopyTexture: true, format: textureFormat).GetPixels();
*
* for (int i = 0; i < lutAsT2D.Length; i++)
* {
* lutAsT2D[i] = lutAsT2D[i].gamma;
* }
*
* var newLut = new Texture2D(lut.width, lut.height, textureFormat, false, true);
* newLut.SetPixels(lutAsT2D);
* newLut.Apply(true, false);
*/
cg.ldrLut.value = lut;//newLut;//TextureCompositor.GPUDegamma(newLut, null, true);
cg.ldrLut.overrideState = true;
cg.ldrLutContribution.value = 1.0f;
cg.ldrLutContribution.overrideState = true;
var exposure = ppp.AddSettings <AutoExposure>();
exposure.eyeAdaptation.value = EyeAdaptation.Fixed;
exposure.eyeAdaptation.overrideState = true;
exposure.keyValue.value = 1.0f;
exposure.keyValue.overrideState = true;
}
private static void ConvertDepthOfFieldSettings(PostProcessProfile ppp, DepthOfFieldModel.Settings dof)
{
var dof2 = ppp.AddSettings <DepthOfField>();
dof2.aperture.overrideState = true;
dof2.aperture.value = dof.aperture;
dof2.focalLength.overrideState = true;
dof2.focalLength.value = dof.focalLength;
dof2.focusDistance.overrideState = true;
dof2.focusDistance.value = dof.focusDistance;
dof2.kernelSize.overrideState = true;
switch (dof.kernelSize)
{
case DepthOfFieldModel.KernelSize.VeryLarge:
dof2.kernelSize.value = KernelSize.VeryLarge;
break;
case DepthOfFieldModel.KernelSize.Large:
dof2.kernelSize.value = KernelSize.Large;
break;
case DepthOfFieldModel.KernelSize.Medium:
dof2.kernelSize.value = KernelSize.Medium;
break;
case DepthOfFieldModel.KernelSize.Small:
dof2.kernelSize.value = KernelSize.Small;
break;
}
// Not supported: dof.useCameraFov;
}
private static void ConvertAmbientOcclusionSettings(PostProcessProfile ppp, AmbientOcclusionModel.Settings oldAmbientOcclusionSettings)
{
var newAmbientOcclusionSettings = ppp.AddSettings <AmbientOcclusion>();
newAmbientOcclusionSettings.ambientOnly.overrideState = true;
newAmbientOcclusionSettings.ambientOnly.value = oldAmbientOcclusionSettings.ambientOnly;
// Ignoring ao.downsampling
// Ignoring ao.forceForwardCompatibility
newAmbientOcclusionSettings.intensity.overrideState = true;
newAmbientOcclusionSettings.intensity.value = oldAmbientOcclusionSettings.intensity / 2f; // Intensity seems less impactful in postv2
newAmbientOcclusionSettings.quality.overrideState = true;
switch (oldAmbientOcclusionSettings.sampleCount)
{
case AmbientOcclusionModel.SampleCount.High:
newAmbientOcclusionSettings.quality.value = AmbientOcclusionQuality.High;
break;
case AmbientOcclusionModel.SampleCount.Medium:
newAmbientOcclusionSettings.quality.value = AmbientOcclusionQuality.Medium;
break;
case AmbientOcclusionModel.SampleCount.Low:
newAmbientOcclusionSettings.quality.value = AmbientOcclusionQuality.Low;
break;
case AmbientOcclusionModel.SampleCount.Lowest:
newAmbientOcclusionSettings.quality.value = AmbientOcclusionQuality.Lowest;
break;
}
newAmbientOcclusionSettings.radius.overrideState = true;
newAmbientOcclusionSettings.radius.value = oldAmbientOcclusionSettings.radius;
// Ignoring ao.highPrecision
}
private static void ConvertEyeAdaptionSettings(PostProcessProfile ppp, EyeAdaptationModel.Settings eye)
{
var eye2 = ppp.AddSettings <AutoExposure>();
eye2.eyeAdaptation.overrideState = true;
eye2.eyeAdaptation.value = eye.adaptationType == EyeAdaptationModel.EyeAdaptationType.Fixed
? EyeAdaptation.Fixed
: EyeAdaptation.Progressive;
eye2.keyValue.overrideState = true;
eye2.keyValue.value = eye.keyValue;
// Not supported: eye.dynamicKeyValue;
// eye.highPercent;
// eye.logMax;
// eye.logMin;
// eye.lowPercent;
eye2.maxLuminance.overrideState = true;
eye2.maxLuminance.value = eye.maxLuminance;
eye2.minLuminance.overrideState = true;
eye2.minLuminance.value = eye.minLuminance;
eye2.speedDown.overrideState = true;
eye2.speedDown.value = eye.speedDown;
eye2.speedUp.overrideState = true;
eye2.speedUp.value = eye.speedUp;
}
void Awake()
{
if (!postProcessingProfile.TryGetSettings <DepthOfField>(out dof)) //Try to get the setting override
{
dof = postProcessingProfile.AddSettings <DepthOfField>(); //Create one if it can't be found
}
}
public void UpdatePostProcessingProfile(PostProcessProfile p)
{
if (!p.HasSettings <PUnderwater>())
{
p.AddSettings <PUnderwater>();
}
PUnderwater underwaterSettings = p.GetSetting <PUnderwater>();
underwaterSettings.active = EnableUnderwater;
underwaterSettings.enabled.Override(EnableUnderwater);
if (EnableUnderwater)
{
underwaterSettings.waterLevel.Override(UnderwaterWaterLevel);
underwaterSettings.maxDepth.Override(UnderwaterMaxDepth);
underwaterSettings.surfaceColorBoost.Override(UnderwaterSurfaceColorBoost);
underwaterSettings.shallowFogColor.Override(UnderwaterShallowFogColor);
underwaterSettings.deepFogColor.Override(UnderwaterDeepFogColor);
underwaterSettings.viewDistance.Override(UnderwaterViewDistance);
underwaterSettings.enableCaustic.Override(UnderwaterEnableCaustic);
underwaterSettings.causticTexture.Override(UnderwaterCausticTexture);
underwaterSettings.causticSize.Override(UnderwaterCausticSize);
underwaterSettings.causticStrength.Override(UnderwaterCausticStrength);
underwaterSettings.enableDistortion.Override(UnderwaterEnableDistortion);
underwaterSettings.distortionNormalMap.Override(UnderwaterDistortionTexture);
underwaterSettings.distortionStrength.Override(UnderwaterDistortionStrength);
underwaterSettings.waterFlowSpeed.Override(UnderwaterWaterFlowSpeed);
}
if (!p.HasSettings <PWetLens>())
{
p.AddSettings <PWetLens>();
}
PWetLens wetLensSettings = p.GetSetting <PWetLens>();
wetLensSettings.active = EnableWetLens;
wetLensSettings.enabled.Override(EnableWetLens);
if (EnableWetLens)
{
wetLensSettings.normalMap.Override(WetLensNormalMap);
wetLensSettings.strength.Override(WetLensStrength);
}
}
protected override void Awake()
{
if (!postProcessingProfile.TryGetSettings <ScreenSpaceReflections>(out ssr)) //Try to get the setting override
{
ssr = postProcessingProfile.AddSettings <ScreenSpaceReflections>(); //Create one if it can't be found
}
base.Awake();
}
protected override void Awake()
{
if (!postProcessingProfile.TryGetSettings <AmbientOcclusion>(out ao)) //Try to get the setting override
{
ao = postProcessingProfile.AddSettings <AmbientOcclusion>(); //Create one if it can't be found
}
base.Awake();
}
protected override void Awake()
{
if (!postProcessingProfile.TryGetSettings <MotionBlur>(out mb)) //Try to get the setting override
{
mb = postProcessingProfile.AddSettings <MotionBlur>(); //Create one if it can't be found
}
base.Awake();
}
protected override void Awake()
{
if (!postProcessingProfile.TryGetSettings <Bloom>(out bloom)) //Try to get the setting override
{
bloom = postProcessingProfile.AddSettings <Bloom>(); //Create one if it can't be found
}
base.Awake();
}
protected override void Awake()
{
if (!postProcessingProfile.TryGetSettings <Vignette>(out vig)) //Try to get the setting override
{
vig = postProcessingProfile.AddSettings <Vignette>(); //Create one if it can't be found
}
base.Awake();
}
protected override void Awake()
{
if (!postProcessingProfile.TryGetSettings <ChromaticAberration>(out ca)) //Try to get the setting override
{
ca = postProcessingProfile.AddSettings <ChromaticAberration>(); //Create one if it can't be found
}
base.Awake();
}
private static void ConvertChromaticAberrationSettings(PostProcessProfile ppp, ChromaticAberrationModel.Settings ca)
{
var ca2 = ppp.AddSettings <ChromaticAberration>();
ca2.intensity.overrideState = true;
ca2.intensity.value = ca.intensity;
ca2.spectralLut.overrideState = true;
ca2.spectralLut.value = ca.spectralTexture;
}
protected override void Awake()
{
if (!postProcessingProfile.TryGetSettings <T>(out setting)) //Try to get the setting
{
setting = postProcessingProfile.AddSettings <T>(); //Create it if it can't be found
setting.SetAllOverridesTo(true);
}
base.Awake();
}
private static void ConvertMotionBlurSettings(PostProcessProfile ppp, MotionBlurModel.Settings mb)
{
var mb2 = ppp.AddSettings <MotionBlur>();
mb2.sampleCount.overrideState = true;
mb2.sampleCount.value = mb.sampleCount;
mb2.shutterAngle.overrideState = true;
mb2.shutterAngle.value = mb.shutterAngle;
// Not supported: mb.frameBlending
}
void Start()
{
controller = GetComponent <CharacterController>();
targetPos = Floor(transform.position.z);
chromme = ScriptableObject.CreateInstance <ChromaticAberration>();
chromme.enabled.Override(true);
chromme.intensity.Override(0.2f);
postProcess.AddSettings(chromme);
colorGrading = postProcess.GetSetting <ColorGrading>();
//rigidbody = GetComponent<Rigidbody>();
}
private static void ConvertGrainSettings(PostProcessProfile ppp, GrainModel.Settings grain)
{
var grain2 = ppp.AddSettings <Grain>();
grain2.colored.overrideState = true;
grain2.colored.value = grain.colored;
grain2.intensity.overrideState = true;
grain2.intensity.value = grain.intensity;
grain2.lumContrib.overrideState = true;
grain2.lumContrib.value = grain.luminanceContribution;
grain2.size.overrideState = true;
grain2.size.value = grain.size;
}
private void Awake()
{
i = this;
PostProcessProfile i_postProcessVolumeProfile = Camera.main.GetComponent <PostProcessVolume>().profile;
if (i_postProcessVolumeProfile == null)
{
Debug.LogWarning("No post process found, won't update its values");
}
//Retrieves or add bloom settings
if (!i_postProcessVolumeProfile.TryGetSettings(out bloom))
{
i_postProcessVolumeProfile.AddSettings <Bloom>();
}
i_postProcessVolumeProfile.TryGetSettings(out bloom);
//Retrieves or add chromaticAberration settings
if (!i_postProcessVolumeProfile.TryGetSettings(out chromaticAberration))
{
i_postProcessVolumeProfile.AddSettings <ChromaticAberration>();
}
i_postProcessVolumeProfile.TryGetSettings(out chromaticAberration);
//Retrieves or add colorGrading settings
if (!i_postProcessVolumeProfile.TryGetSettings(out colorGrading))
{
i_postProcessVolumeProfile.AddSettings <ColorGrading>();
}
i_postProcessVolumeProfile.TryGetSettings(out colorGrading);
//Retrieves or add grain settings
if (!i_postProcessVolumeProfile.TryGetSettings(out grain))
{
i_postProcessVolumeProfile.AddSettings <Grain>();
}
i_postProcessVolumeProfile.TryGetSettings(out grain);
}
// Called when the owning graph starts playing
public override void OnGraphStart(Playable playable)
{
PostProcessLayer postLayer = null;
if (Camera.main != null)
{
postLayer = Camera.main.gameObject.GetComponentInChildren <PostProcessLayer>();
}
if (postLayer == null)
{
var allCam = Camera.allCameras;
foreach (var cam in allCam)
{
var pl = cam.gameObject.GetComponentInChildren <PostProcessLayer>();
if (pl != null)
{
postLayer = pl;
break;
}
}
}
if (postLayer == null)
{
return;
}
PostProcessVolume volume = PostProcessManager.instance.GetHighestPriorityVolume(postLayer);
PostProcessProfile profile = volume.sharedProfile;
if (profile == null)
{
return;
}
blurCtrl = profile.GetSetting <RadialBlur>();
if (blurCtrl == null)
{
blurCtrl = profile.AddSettings <RadialBlur>();
}
blurCtrl.enabled.value = true;
blurCtrl.center.value = this.blurCenter;
blurCtrl.center.overrideState = true;
blurCtrl.centerSize.value = this.centerSize;
blurCtrl.centerSize.overrideState = true;
blurCtrl.blurSize.value = this.blurSizeCur.Evaluate(0f);
blurCtrl.blurSize.overrideState = true;
}
PostProcessProfile CustomCopyProfile(PostProcessProfile file)
{
if (file.settings == null || file.settings.Count < 1)
{
return(null);
}
PostProcessProfile ret = Object.Instantiate(file);
//remove old
ret.RemoveSettings <ColorGrading>();
var newOne = ret.AddSettings <ColorGrading>();
newOne.active = false;
return(ret);
}
private void Awake()
{
instance = this;
PostProcessProfile i_postProcessVolumeProfile = Camera.main.GetComponent <PostProcessVolume>().profile;
if (!i_postProcessVolumeProfile.TryGetSettings(out vignette))
{
i_postProcessVolumeProfile.AddSettings <Vignette>();
}
i_postProcessVolumeProfile.TryGetSettings(out vignette);
vignette.color.value = vignetteColor;
animator = GetComponent <Animator>();
gameObject.SetActive(false);
}
private void Start()
{
_ppp = ScriptableObject.CreateInstance <PostProcessProfile>();
_ppp.AddSettings <DepthOfField>();
_dof = _ppp.GetSetting <DepthOfField>();
_dof.focusDistance.overrideState = true;
_dof.focalLength.overrideState = true;
_dof.aperture.overrideState = true;
_dof.kernelSize.overrideState = true;
_dof.focusDistance.value = .1f;
_dof.aperture.value = 10;
_dof.kernelSize.value = KernelSize.Medium;
this.GetComponent <PostProcessVolume>().profile = _ppp;
}
public override void OnGraphStart(Playable playable)
{
PostProcessLayer postLayer = null;
if (Camera.main != null)
{
postLayer = Camera.main.gameObject.GetComponentInChildren <PostProcessLayer>();
}
if (postLayer == null)
{
var allCam = Camera.allCameras;
foreach (var cam in allCam)
{
var pl = cam.gameObject.GetComponentInChildren <PostProcessLayer>();
if (pl != null)
{
postLayer = pl;
break;
}
}
}
if (postLayer == null)
{
return;
}
//
totalTime = (float)playable.GetDuration();
// ColorGrading Initial
// 得到ColorGrading
PostProcessVolume volume = PostProcessManager.instance.GetHighestPriorityVolume(postLayer);
PostProcessProfile profile = volume.sharedProfile;
colorGrading = profile.GetSetting <ColorGrading>();
if (colorGrading == null)
{
colorGrading = profile.AddSettings <ColorGrading>();
}
// 初始化
colorGrading.active = true;
colorGrading.ldrLutContribution.value = 0f;
}
void Start()
{
_dof = ScriptableObject.CreateInstance <DepthOfField>();
_dof.hideFlags = HideFlags.DontSave;
_dof.focusDistance.overrideState = true;
_dof.enabled.value = true;
_profile = ScriptableObject.CreateInstance <PostProcessProfile>();
_profile.hideFlags = HideFlags.DontSave;
_profile.AddSettings(_dof);
_volume = gameObject.AddComponent <PostProcessVolume>();
_volume.hideFlags = HideFlags.DontSave | HideFlags.NotEditable;
_volume.sharedProfile = _profile;
_volume.isGlobal = true;
_volume.priority = 1000;
Update();
}
private static void Enable()
{
#if UNITY_POST_PROCESSING_STACK_V2
if (!enable)
{
return;
}
profile = ScriptableObject.CreateInstance <PostProcessProfile>();
AssetDatabase.CreateAsset(profile, "Assets/CheckerContrastProfile.asset");
granding = ScriptableObject.CreateInstance <ColorGrading>();
AssetDatabase.CreateAsset(granding, "Assets/Granding.asset");
granding.saturation.overrideState = true;
granding.saturation.value = -100;
profile.AddSettings(granding);
profile.settings[0].enabled.value = true;
EditorApplication.update += EnableDelay;
#endif
}
private static GameCamera WrapCamera(Camera camera)
{
PostProcessLayer postProcessLayer = camera.GetComponent <PostProcessLayer>();
CameraController3 componentInParent = camera.GetComponentInParent <CameraController3>();
if (postProcessLayer == null)
{
postProcessLayer = new PostProcessLayer();
}
GameCamera gameCamera = new GameCamera();
gameCamera.camera = camera;
gameCamera.blur = camera.GetComponent <BlurOptimized>();
gameCamera.holder = camera.transform.parent;
gameCamera.resetCounter = 3;
gameCamera.layer = postProcessLayer;
GameCamera gameCamera2 = gameCamera;
if (componentInParent != null)
{
postProcessLayer.volumeTrigger = componentInParent.human.transform;
GameObject gameObject = new GameObject("Quick Volume (override focus)");
gameObject.transform.SetParent(postProcessLayer.volumeTrigger, worldPositionStays: false);
gameObject.layer = 30;
SphereCollider sphereCollider = gameObject.AddComponent <SphereCollider>();
sphereCollider.isTrigger = true;
sphereCollider.radius = 0.1f;
PostProcessVolume postProcessVolume = gameObject.AddComponent <PostProcessVolume>();
postProcessVolume.priority = 2f;
PostProcessProfile postProcessProfile = postProcessVolume.sharedProfile = postProcessVolume.profile;
gameCamera2.depthOfField = ScriptableObject.CreateInstance <DepthOfField>();
gameCamera2.depthOfField.enabled.Override(instance.allowDepthOfField && !instance.blockBlur);
postProcessProfile.AddSettings(gameCamera2.depthOfField);
}
else
{
postProcessLayer.volumeTrigger = camera.transform;
}
return(gameCamera2);
}
public PostProcessEffectSettingsLerp(PostProcessProfile from, PostProcessProfile to, PostProcessProfile temp)
{
from.TryGetSettings(out m_fromSettings);
to.TryGetSettings(out m_toSettings);
if ((m_fromSettings != null && m_fromSettings.active) ||
(m_toSettings != null && m_toSettings.active))
{
temp.TryGetSettings(out m_tempSettings);
if (m_tempSettings == null)
{
m_tempSettings = temp.AddSettings <T>();
}
m_isValid = true;
m_tempSettings.active = true;
}
if (m_isValid)
{
InitializeParameters();
}
}
private static void ConvertVignetteSettings(PostProcessProfile ppp, VignetteModel.Settings vignette)
{
var vignette2 = ppp.AddSettings <Vignette>();
vignette2.center.overrideState = true;
vignette2.center.value = vignette.center;
vignette2.color.overrideState = true;
vignette2.color.value = vignette.color;
vignette2.intensity.overrideState = true;
vignette2.intensity.value = vignette.intensity;
vignette2.mask.overrideState = true;
vignette2.mask.value = vignette.mask;
vignette2.mode.overrideState = true;
switch (vignette.mode)
{
case VignetteModel.Mode.Classic:
vignette2.mode.value = VignetteMode.Classic;
break;
case VignetteModel.Mode.Masked:
vignette2.mode.value = VignetteMode.Masked;
break;
}
vignette2.opacity.overrideState = true;
vignette2.opacity.value = vignette.opacity;
vignette2.rounded.overrideState = true;
vignette2.rounded.value = vignette.rounded;
vignette2.roundness.overrideState = true;
vignette2.roundness.value = vignette.roundness;
vignette2.smoothness.overrideState = true;
vignette2.smoothness.value = vignette.smoothness;
}
private static void ConvertReflectionSettings(PostProcessProfile ppp, ScreenSpaceReflectionModel.Settings ssr)
{
var ssr2 = ppp.AddSettings <ScreenSpaceReflections>();
ssr2.SetAllOverridesTo(true);
var intensity = ssr.intensity;
ssr2.distanceFade.value = intensity.fadeDistance;
// Not supported: intensity.fresnelFade;
// Not supported: intensity.fresnelFadePower;
// Not supported: intensity.reflectionMultiplier;
var reflection = ssr.reflection;
//reflection.blendType;
ssr2.maximumIterationCount.value = reflection.iterationCount;
ssr2.maximumMarchDistance.value = reflection.maxDistance;
//reflection.reflectBackfaces;
//reflection.reflectionBlur;
switch (reflection.reflectionQuality)
{
case ScreenSpaceReflectionModel.SSRResolution.High:
ssr2.resolution.value = ScreenSpaceReflectionResolution.FullSize;
break;
case ScreenSpaceReflectionModel.SSRResolution.Low:
ssr2.resolution.value = ScreenSpaceReflectionResolution.Downsampled;
break;
}
//reflection.stepSize;
ssr2.thickness.value = reflection.widthModifier;
var mask = ssr.screenEdgeMask;
ssr2.vignette.value = mask.intensity;
}
private static void ConvertBloomSettings(PostProcessProfile ppp, BloomModel.Settings bloom)
{
var bloom2 = ppp.AddSettings <Bloom>();
var bloomSettings = bloom.bloom;
// Skipping bloomSettings.antiFlicker;
bloom2.intensity.overrideState = true;
bloom2.intensity.value = bloomSettings.intensity * 3f; // Seems to be off by a factor of 3x?
bloom2.diffusion.overrideState = true;
bloom2.diffusion.value = bloomSettings.radius * 2f; // TODO: Unsure this is the right setting
bloom2.softKnee.overrideState = true;
bloom2.softKnee.value = bloomSettings.softKnee;
bloom2.threshold.overrideState = true;
bloom2.threshold.value = bloomSettings.threshold;
var dirt = bloom.lensDirt;
bloom2.dirtIntensity.overrideState = true;
bloom2.dirtIntensity.value = dirt.intensity;
bloom2.dirtTexture.overrideState = dirt.texture != null;
bloom2.dirtTexture.value = dirt.texture;
}
