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; }