protected override void ConvertToTarget(BIRPRendering.PostProcessEffectSettings oldSettings, VolumeProfile targetProfile)
{
var oldMotionBlur = oldSettings as BIRPRendering.MotionBlur;
var newVolumeComponent = AddVolumeComponentToAsset <URPRendering.MotionBlur>(targetProfile);
newVolumeComponent.active = oldMotionBlur.active;
// Note: These settings cannot provide visual parity,
// but this scale factor provides a good starting point.
oldMotionBlur.shutterAngle.Convert(newVolumeComponent.intensity, scale: 1f / 360f, oldMotionBlur.enabled);
newVolumeComponent.quality.overrideState = oldMotionBlur.sampleCount.overrideState;
if (oldMotionBlur.sampleCount >= 24)
{
newVolumeComponent.quality.value = URPRendering.MotionBlurQuality.High;
}
else if (oldMotionBlur.sampleCount > 12)
{
newVolumeComponent.quality.value = URPRendering.MotionBlurQuality.Medium;
}
else
{
newVolumeComponent.quality.value = URPRendering.MotionBlurQuality.Low;
}
}
protected override void ConvertToTarget(BIRPRendering.PostProcessEffectSettings oldSettings,
VolumeProfile targetProfile)
{
var oldVignette = oldSettings as BIRPRendering.Vignette;
var newVolumeComponent = AddVolumeComponentToAsset <URPRendering.Vignette>(targetProfile);
newVolumeComponent.active = oldVignette.active;
oldVignette.color.Convert(newVolumeComponent.color);
if (oldVignette.mode.value == BIRPRendering.VignetteMode.Masked)
{
// There's not much we can do with the Masked mode at present,
// so we just assume the old opacity should be used as intensity,
// and leave all other settings at default values.
oldVignette.opacity.Convert(newVolumeComponent.intensity, enabledState: oldSettings.enabled);
}
else
{
oldVignette.intensity.Convert(newVolumeComponent.intensity, enabledState: oldSettings.enabled);
oldVignette.center.Convert(newVolumeComponent.center);
oldVignette.rounded.Convert(newVolumeComponent.rounded);
oldVignette.smoothness.Convert(newVolumeComponent.smoothness);
}
// TODO: No clear conversions for these?
// oldVignette.mask
// oldVignette.roundness
}
protected override void ConvertToTarget(BIRPRendering.PostProcessEffectSettings oldSettings,
VolumeProfile targetProfile)
{
var oldGrain = oldSettings as BIRPRendering.Grain;
var newVolumeComponent = AddVolumeComponentToAsset <URPRendering.FilmGrain>(targetProfile);
newVolumeComponent.active = oldGrain.active;
oldGrain.intensity.Convert(newVolumeComponent.intensity, enabledState: oldGrain.enabled);
oldGrain.lumContrib.Convert(newVolumeComponent.response);
newVolumeComponent.type.overrideState = oldGrain.size.overrideState;
if (oldGrain.size.value > 1.5f)
{
newVolumeComponent.type.value = URPRendering.FilmGrainLookup.Medium3;
}
else if (oldGrain.size.value > 1.25f)
{
newVolumeComponent.type.value = URPRendering.FilmGrainLookup.Medium2;
}
else if (oldGrain.size.value > 0.7f)
{
newVolumeComponent.type.value = URPRendering.FilmGrainLookup.Thin2;
}
else
{
newVolumeComponent.type.value = URPRendering.FilmGrainLookup.Thin1;
}
// TODO: No clear conversions for these?
// oldGrain.colored
}
public void AddConvertedProfileSettingsToProfile(
BIRPRendering.PostProcessEffectSettings oldSettings,
VolumeProfile targetProfile)
{
if (oldSettings == null || oldSettings.GetType() != OldSettingsType)
{
return;
}
if (targetProfile == null || targetProfile.Has(OldSettingsType))
{
return;
}
ConvertToTarget(oldSettings, targetProfile);
}
protected override void ConvertToTarget(BIRPRendering.PostProcessEffectSettings oldSettings,
VolumeProfile targetProfile)
{
var oldChromaticAberration = oldSettings as BIRPRendering.ChromaticAberration;
var newVolumeComponent = AddVolumeComponentToAsset <URPRendering.ChromaticAberration>(targetProfile);
newVolumeComponent.active = oldChromaticAberration.active;
// TODO: Verify that these are 1:1 conversions for visual parity
oldChromaticAberration.intensity.Convert(newVolumeComponent.intensity,
enabledState: oldChromaticAberration.enabled);
// TODO: No clear conversions for these?
// oldChromaticAberration.spectralLut
// oldChromaticAberration.fastMode
}
protected override void ConvertToTarget(BIRPRendering.PostProcessEffectSettings oldSettings,
VolumeProfile targetProfile)
{
var oldLensDistortion = oldSettings as BIRPRendering.LensDistortion;
var newVolumeComponent = AddVolumeComponentToAsset <URPRendering.LensDistortion>(targetProfile);
newVolumeComponent.active = oldLensDistortion.active;
oldLensDistortion.intensity.Convert(newVolumeComponent.intensity,
scale: 0.01f,
enabledState: oldLensDistortion.enabled);
oldLensDistortion.intensityX.Convert(newVolumeComponent.xMultiplier);
oldLensDistortion.intensityY.Convert(newVolumeComponent.yMultiplier);
oldLensDistortion.scale.Convert(newVolumeComponent.scale);
newVolumeComponent.center.overrideState =
oldLensDistortion.centerX.overrideState || oldLensDistortion.centerY.overrideState;
newVolumeComponent.center.value =
new Vector2(oldLensDistortion.centerX.value, oldLensDistortion.centerY.value);
}
protected override void ConvertToTarget(BIRPRendering.PostProcessEffectSettings oldSettings, VolumeProfile targetProfile)
{
var oldBloom = oldSettings as BIRPRendering.Bloom;
var newVolumeComponent = AddVolumeComponentToAsset <URPRendering.Bloom>(targetProfile);
newVolumeComponent.active = oldBloom.active;
oldBloom.clamp.Convert(newVolumeComponent.clamp);
oldBloom.diffusion.Convert(newVolumeComponent.scatter, scale: 0.05f);
oldBloom.intensity.Convert(newVolumeComponent.intensity, enabledState: oldBloom.enabled);
oldBloom.threshold.Convert(newVolumeComponent.threshold);
oldBloom.color.Convert(newVolumeComponent.tint);
oldBloom.dirtIntensity.Convert(newVolumeComponent.dirtIntensity);
oldBloom.dirtTexture.Convert(newVolumeComponent.dirtTexture);
oldBloom.fastMode.Convert(newVolumeComponent.highQualityFiltering, invertValue: true);
// TODO: No clear conversions for these?
// newVolumeComponent.skipIterations = oldBloom.???;
// newVolumeComponent.??? = oldBloom.anamorphicRatio;
// newVolumeComponent.??? = oldBloom.softKnee;
}
protected override void ConvertToTarget(BIRPRendering.PostProcessEffectSettings oldSettings,
VolumeProfile targetProfile)
{
var oldDepthOfField = oldSettings as BIRPRendering.DepthOfField;
var newVolumeComponent = AddVolumeComponentToAsset <URPRendering.DepthOfField>(targetProfile);
newVolumeComponent.active = oldDepthOfField.active;
// Always use Bokeh mode, because it has parity with the PPv2 approach
newVolumeComponent.mode.value = oldDepthOfField.enabled
? URPRendering.DepthOfFieldMode.Bokeh
: URPRendering.DepthOfFieldMode.Off;
newVolumeComponent.mode.overrideState = true;
oldDepthOfField.focusDistance.Convert(newVolumeComponent.focusDistance, enabledState: oldSettings.enabled);
oldDepthOfField.focalLength.Convert(newVolumeComponent.focalLength, enabledState: oldSettings.enabled);
oldDepthOfField.aperture.Convert(newVolumeComponent.aperture, enabledState: oldSettings.enabled);
// TODO: No clear conversions for these?
// oldDepthOfField.kernelSize
}
protected abstract void ConvertToTarget(BIRPRendering.PostProcessEffectSettings oldBloom,
VolumeProfile targetProfile);
internal abstract void SetSettings(PostProcessEffectSettings settings);
protected override void ConvertToTarget(BIRPRendering.PostProcessEffectSettings oldSettings,
VolumeProfile targetProfile)
{
var oldColorGrading = oldSettings as BIRPRendering.ColorGrading;
var newTonemapping = AddVolumeComponentToAsset <URPRendering.Tonemapping>(targetProfile); // was: Tonemapping
var newWhiteBalance =
AddVolumeComponentToAsset <URPRendering.WhiteBalance>(targetProfile); // was: White Balance
var newColorAdjustments =
AddVolumeComponentToAsset <URPRendering.ColorAdjustments>(targetProfile); // was: Tone
var newTargetProfile =
AddVolumeComponentToAsset <URPRendering.ChannelMixer>(targetProfile); // was: Channel Mixer
var newLiftGammaGain =
AddVolumeComponentToAsset <URPRendering.LiftGammaGain>(targetProfile); // was: Trackballs
var newColorCurves =
AddVolumeComponentToAsset <URPRendering.ColorCurves>(targetProfile); // was: Grading Curves
// Tonemapping
newTonemapping.active = oldColorGrading.active;
ConvertTonemapper(oldColorGrading.tonemapper, newTonemapping.mode, oldColorGrading.enabled);
// White Balance
newWhiteBalance.active = oldColorGrading.active;
oldColorGrading.temperature.Convert(newWhiteBalance.temperature, enabledState: oldColorGrading.enabled);
oldColorGrading.tint.Convert(newWhiteBalance.tint, enabledState: oldColorGrading.enabled);
// Tone -> ColorAdjustments
newColorAdjustments.active = oldColorGrading.active;
oldColorGrading.postExposure.Convert(newColorAdjustments.postExposure,
enabledState: oldColorGrading.enabled);
oldColorGrading.colorFilter.Convert(newColorAdjustments.colorFilter, oldColorGrading.enabled,
disabledColor: Color.white);
oldColorGrading.hueShift.Convert(newColorAdjustments.hueShift, enabledState: oldColorGrading.enabled);
oldColorGrading.saturation.Convert(newColorAdjustments.saturation, enabledState: oldColorGrading.enabled);
oldColorGrading.contrast.Convert(newColorAdjustments.contrast, enabledState: oldColorGrading.enabled);
// Channel Mixer
newTargetProfile.active = oldColorGrading.active;
oldColorGrading.mixerRedOutRedIn.Convert(newTargetProfile.redOutRedIn,
enabledState: oldColorGrading.enabled);
oldColorGrading.mixerRedOutGreenIn.Convert(newTargetProfile.redOutGreenIn,
enabledState: oldColorGrading.enabled);
oldColorGrading.mixerRedOutBlueIn.Convert(newTargetProfile.redOutBlueIn,
enabledState: oldColorGrading.enabled);
oldColorGrading.mixerGreenOutRedIn.Convert(newTargetProfile.greenOutRedIn,
enabledState: oldColorGrading.enabled);
oldColorGrading.mixerGreenOutGreenIn.Convert(newTargetProfile.greenOutGreenIn,
enabledState: oldColorGrading.enabled);
oldColorGrading.mixerGreenOutBlueIn.Convert(newTargetProfile.greenOutBlueIn,
enabledState: oldColorGrading.enabled);
oldColorGrading.mixerBlueOutRedIn.Convert(newTargetProfile.blueOutRedIn,
enabledState: oldColorGrading.enabled);
oldColorGrading.mixerBlueOutGreenIn.Convert(newTargetProfile.blueOutGreenIn,
enabledState: oldColorGrading.enabled);
oldColorGrading.mixerBlueOutBlueIn.Convert(newTargetProfile.blueOutBlueIn,
enabledState: oldColorGrading.enabled);
// Trackballs -> LiftGammaGain
newLiftGammaGain.active = oldColorGrading.active;
// Note: URP always does color grading in HDR values (as it should),
// which means the non-HDR modes no longer have valid conversion targets.
// So, these values are left at defaults (neutral) when not previously using HDR.
if (oldColorGrading.gradingMode.value == BIRPRendering.GradingMode.HighDefinitionRange)
{
oldColorGrading.lift.Convert(newLiftGammaGain.lift, oldColorGrading.enabled);
oldColorGrading.gamma.Convert(newLiftGammaGain.gamma, oldColorGrading.enabled);
oldColorGrading.gain.Convert(newLiftGammaGain.gain, oldColorGrading.enabled);
}
// Grading Curves -> ColorCurves
newColorCurves.active = oldColorGrading.active;
oldColorGrading.masterCurve.Convert(newColorCurves.master, oldColorGrading.enabled);
oldColorGrading.redCurve.Convert(newColorCurves.red, oldColorGrading.enabled);
oldColorGrading.greenCurve.Convert(newColorCurves.green, oldColorGrading.enabled);
oldColorGrading.blueCurve.Convert(newColorCurves.blue, oldColorGrading.enabled);
oldColorGrading.hueVsHueCurve.Convert(newColorCurves.hueVsHue, oldColorGrading.enabled);
oldColorGrading.hueVsSatCurve.Convert(newColorCurves.hueVsSat, oldColorGrading.enabled);
oldColorGrading.satVsSatCurve.Convert(newColorCurves.satVsSat, oldColorGrading.enabled);
oldColorGrading.lumVsSatCurve.Convert(newColorCurves.lumVsSat, oldColorGrading.enabled);
}
