学习笔记：Unity CustomSRP-13-ColorGrading

最新推荐文章于 2023-08-23 13:35:27 发布
最新推荐文章于 2023-08-23 13:35:27 发布
阅读量659 收藏
点赞数
分类专栏： Unity可编程渲染管线学习笔记 文章标签： unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41155760/article/details/124339914
版权

原文-----翻译-----源码

这一节还是图像处理：颜色分级
介绍常见的几种图像处理效果

总结：
1.常见效果：后曝光、白平衡、对比度、颜色过滤、色调分离、通道混合、阴影中间调高光、色相偏移、饱和度。

注：其中的色调分离和阴影中间调高光差不多，差别是色调分离是处理的是阴影和高光，而且不能控制范围，阴影中间调高光是三个区域，且能控制范围。

2.LUT：每个像素都进行上面的计算消耗比较大，所以采用LUT（lookup table），先渲染到贴图，在采样即可。

部分源码：

using UnityEngine;
using UnityEngine.Rendering;
using static PostFXSettings;

partial class PostFXStack
{	
	//shader中也要按这个顺序放Pass
    enum Pass
    {
        BloomAdd,
        BloomHorizontal,
        BloomPrefilter,
        BloomPrefilterFireflies,
        BloomScatter,
        BloomScatterFinal,
        BloomVertical,
        Copy,
        ColorGradingNone,
        ColorGradingACES,
        ColorGradingNeutral,
        ColorGradingReinhard,
        Final
    }

    const string bufferName = "Post FX";
    CommandBuffer buffer = new CommandBuffer
    {
        name = bufferName
    };

    ScriptableRenderContext context;

    Camera camera;

    PostFXSettings settings;

    public bool IsActive => settings != null;

    int
        bloomBicubicUpsamplingId = Shader.PropertyToID("_BloomBicubicUpsampling"),
        bloomPrefilterId = Shader.PropertyToID("_BloomPrefilter"),
        bloomThresholdId = Shader.PropertyToID("_BloomThreshold"),
        bloomIntensityId = Shader.PropertyToID("_BloomIntensity"),
        bloomResultId = Shader.PropertyToID("_BloomResult"),
        fxSourceId = Shader.PropertyToID("_PostFXSource"),
        fxSource2Id = Shader.PropertyToID("_PostFXSource2"),
        colorAdjustmentsId = Shader.PropertyToID("_ColorAdjustments"),
        colorFilterId = Shader.PropertyToID("_ColorFilter"),
        whiteBalanceId = Shader.PropertyToID("_WhiteBalance"),
        splitToningShadowsId = Shader.PropertyToID("_SplitToningShadow"),
        splitToningHighlightsId = Shader.PropertyToID("_SplitToningHighlights"),
        channelMixerRedId = Shader.PropertyToID("_ChannelMixerRed"),
        channelMixerGreenId = Shader.PropertyToID("_ChannelMixerGreen"),
        channelMixerBlueId = Shader.PropertyToID("_ChannelMixerBlue"),
        smhShadowsId = Shader.PropertyToID("_SMHShadows"),
        smhMidtonesId = Shader.PropertyToID("_SMHMidtones"),
        smhHighlightsId = Shader.PropertyToID("_SMHHighlights"),
        smhRangeId = Shader.PropertyToID("_SMHRange"),
        colorGradingLUTId = Shader.PropertyToID("_ColorGradingLUT"),
        colorGradingLUTParametersId = Shader.PropertyToID("_ColorGradingLUTParameters"),
        colorGradingLUTInLogCId = Shader.PropertyToID("_ColorGradingLUTInLogC");

    const int maxBloomPyramidLevels = 16;

    int bloomPyramidId;

    bool useHDR;

    int colorLUTResolution;

    public PostFXStack()
    {
        bloomPyramidId = Shader.PropertyToID("_BloomPyramid0");
        for (int i = 1; i < maxBloomPyramidLevels * 2; i++)
        {
            Shader.PropertyToID("_BloomPyramid" + i);
        }
    }

    public void Setup(ScriptableRenderContext context, Camera camera, PostFXSettings settings, bool useHDR, int colorLUTResolution)
    {
        this.colorLUTResolution = colorLUTResolution;
        this.useHDR = useHDR;
        this.context = context;
        this.camera = camera;
        this.settings = camera.cameraType <= CameraType.SceneView ? settings : null;

        ApplySceneViewState();
    }

    public void Render(int sourceId)
    {
        //buffer.Blit(sourceId, BuiltinRenderTextureType.CameraTarget);
        //Draw(sourceId, BuiltinRenderTextureType.CameraTarget, Pass.Copy);

        if (DoBloom(sourceId))
        {
            DoColorGradingAndToneMapping(bloomResultId);
            buffer.ReleaseTemporaryRT(bloomResultId);
        }
        else
        {
            DoColorGradingAndToneMapping(sourceId);
        }
        context.ExecuteCommandBuffer(buffer);
        buffer.Clear();
    }

    void Draw(RenderTargetIdentifier from, RenderTargetIdentifier to, Pass pass)
    {
        buffer.SetGlobalTexture(fxSourceId, from);
        buffer.SetRenderTarget(to, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store);
        buffer.DrawProcedural(Matrix4x4.identity, settings.Material, (int)pass, MeshTopology.Triangles, 3);
    }

    bool DoBloom(int sourceId)
    {
        //buffer.BeginSample("Bloom");

        PostFXSettings.BloomSettings bloom = settings.Bloom;

        int width = camera.pixelWidth / 2, height = camera.pixelHeight / 2;

        if (bloom.maxIterations == 0 || bloom.intensity <= 0f || height < bloom.downscaleLimit * 2 || width < bloom.downscaleLimit * 2)
        {
            //Draw(sourceId, BuiltinRenderTextureType.CameraTarget, Pass.Copy);
            //buffer.EndSample("Bloom");
            return false;
        }

        buffer.BeginSample("Bloom");

        Vector4 threshold;
        threshold.x = Mathf.GammaToLinearSpace(bloom.threshold);
        threshold.y = threshold.x * bloom.thresholdKnee;
        threshold.z = 2f * threshold.y;
        threshold.w = 0.25f / (threshold.y + 0.00001f);
        threshold.y -= threshold.x;
        buffer.SetGlobalVector(bloomThresholdId, threshold);

        RenderTextureFormat format = useHDR ? RenderTextureFormat.DefaultHDR : RenderTextureFormat.Default;

        //一半分辨率
        buffer.GetTemporaryRT(bloomPrefilterId, width, height, 0, FilterMode.Bilinear, format);

        Draw(sourceId, bloomPrefilterId, bloom.fadeFireflies ? Pass.BloomPrefilterFireflies : Pass.BloomPrefilter);
        width /= 2;
        height /= 2;

        int fromId = bloomPrefilterId, toId = bloomPyramidId + 1;

        int i;
        for (i = 0; i < bloom.maxIterations; i++)
        {
            if (height < bloom.downscaleLimit || width < bloom.downscaleLimit)
            {
                break;
            }

            int midId = toId - 1;
            buffer.GetTemporaryRT(midId, width, height, 0, FilterMode.Bilinear, format);

            buffer.GetTemporaryRT(toId, width, height, 0, FilterMode.Bilinear, format);
            Draw(fromId, midId, Pass.BloomHorizontal);
            Draw(midId, toId, Pass.BloomVertical);
            fromId = toId;
            toId += 2;
            width /= 2;
            height /= 2;
        }

        buffer.ReleaseTemporaryRT(bloomPrefilterId);

        //Draw(fromId, BuiltinRenderTextureType.CameraTarget, Pass.Copy);

        buffer.SetGlobalFloat(bloomBicubicUpsamplingId, bloom.bicubicUpsampling ? 1f : 0f);

        Pass combinePass, finalPass;
        float finalIntensity;
        if (bloom.mode == PostFXSettings.BloomSettings.Mode.Additive)
        {
            combinePass = finalPass = Pass.BloomAdd;
            buffer.SetGlobalFloat(bloomIntensityId, 1f);
            finalIntensity = bloom.intensity;
        }
        else
        {
            combinePass = Pass.BloomScatter;
            finalPass = Pass.BloomScatterFinal;
            buffer.SetGlobalFloat(bloomIntensityId, bloom.scatter);
            finalIntensity = Mathf.Min(bloom.intensity, 0.95f);
        }

        if (i > 1)
        {
            buffer.ReleaseTemporaryRT(fromId - 1);
            toId -= 5;

            for (i -= 1; i > 0; i--)
            {
                buffer.SetGlobalTexture(fxSource2Id, toId + 1);
                Draw(fromId, toId, combinePass);
                buffer.ReleaseTemporaryRT(fromId);
                buffer.ReleaseTemporaryRT(fromId + 1);
                fromId = toId;
                toId -= 2;
            }
        }
        else
        {
            buffer.ReleaseTemporaryRT(bloomPyramidId);
        }

        buffer.SetGlobalFloat(bloomIntensityId, finalIntensity);
        buffer.SetGlobalTexture(fxSource2Id, sourceId);

        buffer.GetTemporaryRT(bloomResultId, camera.pixelWidth, camera.pixelHeight, 0, FilterMode.Bilinear, format);

        Draw(fromId, bloomResultId, finalPass);
        buffer.ReleaseTemporaryRT(fromId);

        buffer.EndSample("Bloom");
        return true;
    }

    void ConfigureColorAdjustments()
    {
        ColorAdjustmentsSetttings colorAdjustments = settings.ColorAdjustments;
        buffer.SetGlobalVector(colorAdjustmentsId, new Vector4(
            Mathf.Pow(2f, colorAdjustments.postExposure),   //曝光值
            colorAdjustments.contrast * 0.01f + 1f,         //对比度0~2
            colorAdjustments.hueShift * (1f / 360f),        //色相0~2
            colorAdjustments.saturation * 0.01f + 1f        //饱和度-1~1
        ));
        buffer.SetGlobalColor(colorFilterId, colorAdjustments.colorFilter.linear);
    }

    void ConfigureWhiteBalance()
    {
        //白平衡：temperature调整:蓝 <-> 黄
        //        tint:品红 <-> 绿
        WhiteBalanceSettings whiteBalance = settings.WhiteBalance;
        buffer.SetGlobalVector(whiteBalanceId, ColorUtils.ColorBalanceToLMSCoeffs(whiteBalance.temperature, whiteBalance.tint));
    }

    void ConfigureSplitToning()
    {
        SplitToningSettings splitToning = settings.SplitToning;
        Color splitColor = splitToning.shadows;
        splitColor.a = splitToning.balance * 0.01f;
        buffer.SetGlobalColor(splitToningShadowsId, splitColor);
        buffer.SetGlobalColor(splitToningHighlightsId, splitToning.highlights);
    }

    void ConfigureChannelMixer()
    {
        ChannelMixerSettings channelMixer = settings.ChannelMixer;
        buffer.SetGlobalVector(channelMixerRedId, channelMixer.red);
        buffer.SetGlobalVector(channelMixerGreenId, channelMixer.green);
        buffer.SetGlobalVector(channelMixerBlueId, channelMixer.blue);
    }

    void ConfigureShadowsMidtonesHighlights()
    {
        ShadowsMidtonesHighlightsSettings smh = settings.ShadowsMidtonesHighlights;
        buffer.SetGlobalColor(smhShadowsId, smh.shadows.linear);
        buffer.SetGlobalColor(smhMidtonesId, smh.midtones.linear);
        buffer.SetGlobalColor(smhHighlightsId, smh.highlights.linear);
        buffer.SetGlobalVector(smhRangeId, new Vector4(
            smh.shadowsStart, smh.shadowsEnd, smh.highlightsStart, smh.highLightsEnd
        ));
    }

    void DoColorGradingAndToneMapping(int sourceId)
    {
        ConfigureColorAdjustments();
        ConfigureWhiteBalance();
        ConfigureSplitToning();
        ConfigureChannelMixer();
        ConfigureShadowsMidtonesHighlights();

        int lutHeight = colorLUTResolution;
        int lutWidth = lutHeight * lutHeight;
        buffer.GetTemporaryRT(colorGradingLUTId, lutWidth, lutHeight, 0, FilterMode.Bilinear, RenderTextureFormat.DefaultHDR);

        buffer.SetGlobalVector(colorGradingLUTParametersId, new Vector4(
            lutHeight, 0.5f / lutWidth, 0.5f / lutHeight, lutHeight / (lutHeight - 1f)
        ));

        //ToneMappingSettings.Mode mode = settings.ToneMapping.mode;
        //Pass pass = Pass.ColorGradingNone + (int)mode;
        //Draw(sourceId, BuiltinRenderTextureType.CameraTarget, pass);

        ToneMappingSettings.Mode mode = settings.ToneMapping.mode;
        Pass pass = Pass.ColorGradingNone + (int)mode;

        //启用hdr和色调映射，启用LogC空间
        buffer.SetGlobalFloat(colorGradingLUTInLogCId, useHDR && pass != Pass.ColorGradingNone ? 1f : 0f);
        //first render to LUT
        Draw(sourceId, colorGradingLUTId, pass);

        //修改参数值
        buffer.SetGlobalVector(colorGradingLUTParametersId, new Vector4(1f / lutWidth, 1f / lutHeight, lutHeight - 1f));
        //second copy to camera
        Draw(sourceId, BuiltinRenderTextureType.CameraTarget, Pass.Final);
        buffer.ReleaseTemporaryRT(colorGradingLUTId);
    }
}

#ifndef CUSTOM_POST_FX_PASSES_INCLUDED
#define CUSTOM_POST_FX_PASSES_INCLUDED

#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Filtering.hlsl"

TEXTURE2D(_PostFXSource);
TEXTURE2D(_PostFXSource2);
SAMPLER(sampler_linear_clamp);

float4 _PostFXSource_TexelSize;

float4 GetSourceTexelSize()
{
	return _PostFXSource_TexelSize;
}

float4 GetSource(float2 screenUV)
{
	return SAMPLE_TEXTURE2D_LOD(_PostFXSource, sampler_linear_clamp, screenUV, 0);
}

float4 GetSourceBicubic(float2 screenUV)
{
	return SampleTexture2DBicubic(TEXTURE2D_ARGS(_PostFXSource, sampler_linear_clamp), screenUV, _PostFXSource_TexelSize.zwxy, 1.0, 0.0);
}

float4 GetSource2(float2 screenUV)
{
	return SAMPLE_TEXTURE2D_LOD(_PostFXSource2, sampler_linear_clamp, screenUV, 0);
}

struct Varyings
{
	float4 positionCS : SV_POSITION;
	float2 screenUV : VAR_SCREEN_UV;
};

Varyings DefaultPassVertex(uint vertexID : SV_VertexID)
{
	Varyings output;
	output.positionCS = float4(
		vertexID <= 1 ? -1.0 : 3.0,
		vertexID == 1 ? 3.0 : -1.0,
		0.0, 1.0
		);
	output.screenUV = float2(
		vertexID <= 1 ? 0.0 : 2.0,
		vertexID == 1 ? 2.0 : 0.0
		);
	if (_ProjectionParams.x < 0.0)
	{
		output.screenUV.y = 1.0 - output.screenUV.y;
	}
	return output;
}

bool _BloomBicubicUpSampling;
float _BloomIntensity;

float4 BloomAddPassFragment(Varyings input) :SV_TARGET
{
	float3 lowRes;
	if (_BloomBicubicUpSampling)
	{
		lowRes = GetSourceBicubic(input.screenUV).rgb;
	}
	else
	{
		lowRes = GetSource(input.screenUV).rgb;
	}
	float3 highRes = GetSource2(input.screenUV).rgb;
	return float4(lowRes * _BloomIntensity + highRes, 1.0);
}

float4 BloomHorizontalPassFragment(Varyings input) :SV_TARGET
{
	float3 color = 0.0;
	float offsets[] =
	{
		-4.0,-3.0,-2.0,-1.0,0.0,1.0,2.0,3.0,4.0
	};

	float weights[] =
	{
		0.01621622, 0.05405405, 0.12162162, 0.19459459, 0.22702703,
		0.19459459, 0.12162162, 0.05405405, 0.01621622
	};

	for (int i = 0; i < 9; i++)
	{
		float offset = offsets[i] * 2.0 * GetSourceTexelSize().x;
		color += GetSource(input.screenUV + float2(offset, 0.0)).rgb * weights[i];
	}
	return float4(color, 1.0);
}

float4 _BloomThreshold;

float3 ApplyBloomThreshold(float3 color)
{
	float brightness = Max3(color.r, color.g, color.b);
	float soft = brightness + _BloomThreshold.y;
	soft = clamp(soft, 0.0, _BloomThreshold.z);
	soft = soft * soft * _BloomThreshold.w;
	float contribution = max(soft, brightness - _BloomThreshold.x);
	contribution /= max(brightness, 0.00001);
	return color * contribution;
}

float4 BloomPrefilterPassFragment(Varyings input) :SV_TARGET
{
	float3 color = ApplyBloomThreshold(GetSource(input.screenUV).rgb);
	return float4(color, 1.0);
}

float4 BloomPrefilterFirefliesPassFragment(Varyings input) :SV_TARGET
{
	float3 color = 0.0;
	float weightSum = 0.0;

	float2 offsets[] = {
		float2(0.0, 0.0),
		float2(-1.0, -1.0), float2(-1.0, 1.0), float2(1.0, -1.0), float2(1.0, 1.0)//,
		//float2(-1.0, 0.0), float2(1.0, 0.0), float2(0.0, -1.0), float2(0.0, 1.0)
	};

	for (int i = 0; i < 5; i++)
	{
		float3 c = GetSource(input.screenUV + offsets[i] * GetSourceTexelSize().xy * 2.0).rgb;
		c = ApplyBloomThreshold(c);
		float w = 1.0 / (Luminance(c) + 1.0);
		color += c * w;
		weightSum += w;
	}
	//color *= 1.0 / 9.0;
	color /= weightSum;
	return float4(color, 1.0);
}

float4 BloomScatterPassFragment(Varyings input) :SV_TARGET
{
	float3 lowRes;
	if (_BloomBicubicUpSampling)
	{
		lowRes = GetSourceBicubic(input.screenUV).rgb;
	}
	else
	{
		lowRes = GetSource(input.screenUV).rgb;
	}
	float3 highRes = GetSource2(input.screenUV).rgb;
	return float4(lerp(highRes,lowRes,_BloomIntensity), 1.0);
}

float4 BloomScatterFinalPassFragment(Varyings input) :SV_TARGET
{
	float3 lowRes;
	if (_BloomBicubicUpSampling)
	{
		lowRes = GetSourceBicubic(input.screenUV).rgb;
	}
	else
	{
		lowRes = GetSource(input.screenUV).rgb;
	}
	float3 highRes = GetSource2(input.screenUV).rgb;

	lowRes += highRes - ApplyBloomThreshold(highRes);
	return float4(lerp(highRes,lowRes,_BloomIntensity), 1.0);
}

float4 BloomVerticalPassFragment(Varyings input) :SV_TARGET
{
	float3 color = 0.0;
	float offsets[] =
	{
		-3.23076923, -1.38461538, 0.0, 1.38461538, 3.23076923
	};

	float weights[] =
	{
		0.07027027, 0.31621622, 0.22702703, 0.31621622, 0.07027027
	};

	for (int i = 0; i < 5; i++)
	{
		float offset = offsets[i] * GetSourceTexelSize().y;
		color += GetSource(input.screenUV + float2(0.0, offset)).rgb * weights[i];
	}
	return float4(color, 1.0);
}

float4 CopyPassFragment(Varyings input) : SV_TARGET
{
	return GetSource(input.screenUV);
}

float4 _ColorAdjustments;
float4 _ColorFilter;
float4 _WhiteBalance;
float4 _SplitToningShadows, _SplitToningHighlights;
float4 _ChannelMixerRed, _ChannelMixerGreen, _ChannelMixerBlue;
float4 _SMHShadows, _SMHMidtones, _SMHHighlights, _SMHRange;

float Luminance(float3 color, bool useACES)
{
	return useACES ? AcesLuminance(color) : Luminance(color);
}

//曝光
float3 ColorGradePostExposure(float3 color)
{
	return color * _ColorAdjustments.x;
}

//白平衡
float3 ColorGradeWhiteBalance(float3 color)
{
	//转换到LMS空间计算，LMS是描述人眼中三种感光锥的反应的颜色
	color = LinearToLMS(color);
	color *= _WhiteBalance.rgb;
	return LMSToLinear(color);
}

//对比度
float3 ColorGradingContrast(float3 color, bool useACES)
{
	//转换是在Log C中，先转换为Log C中的值
	color = useACES ? ACES_to_ACEScc(unity_to_ACES(color)) : LinearToLogC(color);
	//对比度：在就是在中间灰和原颜色进行插值，其实下面的式子就是lerp(ACEScc_MIDGRAY,color,_ColorAdjustments.y);
	//对比度这里的y值的范围：0~2，颜色范围：中间灰 <-> 2 * 原色 - 中间灰
	color = (color - ACEScc_MIDGRAY) * _ColorAdjustments.y + ACEScc_MIDGRAY;
	//在转换回来
	return useACES ? ACES_to_ACEScg(ACEScc_to_ACES(color)) : LogCToLinear(color);
}

//颜色过滤
float3 ColorGradeColorFilter(float3 color)
{
	//颜色过滤：控制原颜色 颜色通道的强弱
	//1.比如过滤颜色是（1,1,0），结果是原颜色蓝色通道颜色消失
	//2.过滤颜色是（0.5,1,1），结果是原颜色红色通道颜色减半
	return color * _ColorFilter.rgb;
}

//色调分离:阴影和高光
float3 ColorGradeSplitToning(float3 color, bool useACES)
{
	//把线性颜色转换到gamma空间
	color = PositivePow(color, 1.0 / 2.2);
	float t = saturate(Luminance(saturate(color), useACES) + _SplitToningShadows.w);
	float3 shadows = lerp(0.5, _SplitToningShadows.rgb, 1.0 - t);
	float3 highlights = lerp(0.5, _SplitToningHighlights.rgb, t);
	//混合颜色
	color = SoftLight(color, shadows);
	color = SoftLight(color, highlights);
	//转回线性空间
	return PositivePow(color, 2.2);
}

//色相偏移
//HSV（Hue, Saturation, Value）色调（H）、饱和度（S）和明度（V）
float3 ColorGradingHueShift(float3 color)
{
	color = RgbToHsv(color);
	//色相偏移就是调h,也就是x，色相的范围是0~1
	//调整范围是：-1~1
	float hue = color.x + _ColorAdjustments.z;
	//调整色相的值在0~1范围，具体查看RotateHue源码
	color.x = RotateHue(hue, 0.0, 1.0);
	return HsvToRgb(color);
}

//饱和度
float3 ColorGradingSaturation(float3 color, bool useACES)
{
	//计算颜色的亮度
	float luminance = Luminance(color, useACES);
	//这里同对比度，也是插值，w范围也是0~2
	//颜色范围：亮度 <-> 2*原颜色-亮度
	return (color - luminance) * _ColorAdjustments.w + luminance;
}

//通道混合：矩阵乘法
float3 ColorGradingChannelMixer(float3 color)
{
	return mul(
		float3x3(_ChannelMixerRed.rgb, _ChannelMixerGreen.rgb, _ChannelMixerBlue.rgb),
		color
	);
}

//阴影中间调高光
float3 ColorGradingShadowsMidtonesHighlights(float3 color, bool useACES)
{
	float luminance = Luminance(color, useACES);
	float shadowsWeight = 1.0 - smoothstep(_SMHRange.x, _SMHRange.y, luminance);
	float highlightsWeight = smoothstep(_SMHRange.z, _SMHRange.w, luminance);
	float midtonesWeight = 1.0 - shadowsWeight - highlightsWeight;

	return
		color * _SMHShadows.rgb * shadowsWeight +
		color * _SMHMidtones.rgb * midtonesWeight +
		color * _SMHHighlights.rgb * highlightsWeight;
}

//颜色分级
float3 ColorGrade(float3 color, bool useACES = false)
{
	//color = min(color, 60.0); //采用LUT后，受LUT的限制
	color = ColorGradePostExposure(color);			//曝光效果
	color = ColorGradeWhiteBalance(color);			//白平衡
	color = ColorGradingContrast(color, useACES);	//对比度调整
	color = ColorGradeColorFilter(color);			//颜色过滤
	color = max(color, 0.0);						//对比度调整后可能出现负值
	color = ColorGradeSplitToning(color, useACES);	//色调分离
	color = ColorGradingChannelMixer(color);		//通道混合
	color = max(color, 0.0);						//排除负值
	color = ColorGradingShadowsMidtonesHighlights(color, useACES);//阴影中间调高光（同色调分离）
	color = ColorGradingHueShift(color);			//在排除颜色不为负值后，再进行色相偏移
	color = ColorGradingSaturation(color, useACES);			//应用饱和度
	color = max(useACES ? ACEScg_to_ACES(color) : color, 0.0);	//应用饱和度会产生负值，进行限制
	return color;
}

float4 _ColorGradingLUTParameters;
bool _ColorGradingLUTInLogC;

float3 GetColorGradedLUT(float2 uv, bool useACES = false)
{
	float3 color = GetLutStripValue(uv, _ColorGradingLUTParameters);
	//把color解释为Log C空间值，进行范围扩展，原来是0~1，扩展后0~59
	color = _ColorGradingLUTInLogC ? LogCToLinear(color) : color;
	return ColorGrade(color, useACES);
}

float4 ColorGradingNonePassFragment(Varyings input) : SV_TARGET{
	/*float4 color = GetSource(input.screenUV);
	color.rgb = ColorGrade(color.rgb);*/
	//return color;
	float3 color = GetColorGradedLUT(input.screenUV);
	return float4(color, 1.0);
}

float4 ColorGradingACESPassFragment(Varyings input) : SV_TARGET
{
	//float4 color = GetSource(input.screenUV);
	///*color.rgb = ColorGrade(color.rgb);
	//color.rgb = AcesTonemap(unity_to_ACES(color.rgb));*/
	//color.rgb = ColorGrade(color.rgb,true);
	//color.rgb = AcesTonemap(color.rgb);
	//return color;
	float3 color = GetColorGradedLUT(input.screenUV, true);
	color = AcesTonemap(color);
	return float4(color, 1.0);
}

float4 ColorGradingNeutralPassFragment(Varyings input) :SV_TARGET
{
	/*float4 color = GetSource(input.screenUV);
	color.rgb = ColorGrade(color.rgb);
	color.rgb = NeutralTonemap(color.rgb);
	return color;*/

	float3 color = GetColorGradedLUT(input.screenUV);
	color = NeutralTonemap(color);
	return float4(color, 1.0);
}

float4 ColorGradingReinhardPassFragment(Varyings input) :SV_TARGET
{
	/*float4 color = GetSource(input.screenUV);
	color.rgb = ColorGrade(color.rgb);
	color.rgb /= color.rgb + 1.0;
	return color;*/

	float3 color = GetColorGradedLUT(input.screenUV);
	color /= color + 1.0;
	return float4(color, 1.0);
}

TEXTURE2D(_ColorGradingLUT);

float3 ApplyColorGradingLUT(float3 color)
{
	//把2D LUT条带图 解释为 3D图：前两个参数为LUT贴图和采样器，后面是颜色（线性或LogC空间），最后是参数xyz
	return ApplyLut2D(TEXTURE2D_ARGS(_ColorGradingLUT, sampler_linear_clamp),
		saturate(_ColorGradingLUTInLogC ? LinearToLogC(color) : color),
		_ColorGradingLUTParameters.xyz);
}

float4 FinalPassFragment(Varyings input) : SV_TARGET{
	float4 color = GetSource(input.screenUV);
	color.rgb = ApplyColorGradingLUT(color.rgb);
	return color;
}
#endif


using System;
using UnityEngine;

[CreateAssetMenu(menuName = "Rendering/Custom Post FX Settings")]
public class PostFXSettings : ScriptableObject
{
    [SerializeField]
    Shader shader = default;

    [NonSerialized]
    Material material;

    public Material Material
    {
        get
        {
            if (material == null && shader != null)
            {
                material = new Material(shader);
                material.hideFlags = HideFlags.HideAndDontSave;
            }
            return material;
        }
    }

    #region Bloom

    [System.Serializable]
    public struct BloomSettings
    {
        [Range(0f, 16f)]
        public int maxIterations;

        [Min(0f)]
        public int downscaleLimit;

        public bool bicubicUpsampling;

        [Min(0f)]
        public float threshold;

        [Range(0f, 1f)]
        public float thresholdKnee;

        [Min(0f)]
        public float intensity;

        public bool fadeFireflies;

        public enum Mode { Additive, Scattering }

        public Mode mode;

        [Range(0.05f, 0.95f)]
        public float scatter;
    }

    [SerializeField]
    BloomSettings bloom = new BloomSettings { scatter = 0.7f };

    public BloomSettings Bloom => bloom;

    #endregion

    #region 颜色分级

    [Serializable]
    public struct ColorAdjustmentsSetttings
    {
        public float postExposure;

        [Range(-100f, 100f)]
        public float contrast;

        [ColorUsage(false, true)]
        public Color colorFilter;

        [Range(-180f, 180f)]
        public float hueShift;

        [Range(-100f, 100f)]
        public float saturation;
    }

    [SerializeField]
    ColorAdjustmentsSetttings colorAdjustments = new ColorAdjustmentsSetttings
    {
        colorFilter = Color.white
    };

    public ColorAdjustmentsSetttings ColorAdjustments => colorAdjustments;

    #endregion

    #region 白平衡

    [Serializable]
    public struct WhiteBalanceSettings
    {
        [Range(-100f, 100f)]
        public float temperature, tint;
    }

    [SerializeField]
    WhiteBalanceSettings whiteBalance = default;

    public WhiteBalanceSettings WhiteBalance => whiteBalance;

    #endregion

    #region 色调分离

    [Serializable]
    public struct SplitToningSettings
    {
        //通常例子是让阴影趋向蓝色，高光趋向橙色
        [ColorUsage(false)]
        public Color shadows, highlights;

        [Range(-100f, 100f)]
        public float balance;
    }

    [SerializeField]
    SplitToningSettings splitToning = new SplitToningSettings
    {
        shadows = Color.gray,
        highlights = Color.gray
    };

    public SplitToningSettings SplitToning => splitToning;

    #endregion

    #region 通道混合
    [Serializable]
    public struct ChannelMixerSettings
    {
        public Vector3 red, green, blue;
    }

    [SerializeField]
    ChannelMixerSettings channelMixer = new ChannelMixerSettings
    {
        red = Vector3.right,
        green = Vector3.up,
        blue = Vector3.forward
    };

    public ChannelMixerSettings ChannelMixer => channelMixer;
    #endregion

    #region 阴影中间调高光
    [Serializable]
    public struct ShadowsMidtonesHighlightsSettings
    {
        [ColorUsage(false, true)]
        public Color shadows, midtones, highlights;

        [Range(0f, 2f)]
        public float shadowsStart, shadowsEnd, highlightsStart, highLightsEnd;
    }

    [SerializeField]
    ShadowsMidtonesHighlightsSettings shadowsMidtonesHighlights = new ShadowsMidtonesHighlightsSettings
    {
        shadows = Color.white,
        midtones = Color.white,
        highlights = Color.white,
        shadowsEnd = 0.3f,
        highlightsStart = 0.55f,
        highLightsEnd = 1f
    };

    public ShadowsMidtonesHighlightsSettings ShadowsMidtonesHighlights =>
        shadowsMidtonesHighlights;
    #endregion

    #region 色调映射
    [Serializable]
    public struct ToneMappingSettings
    {
        public enum Mode { None, ACES, Neutral, Reinhard }
        public Mode mode;
    }

    [SerializeField]
    ToneMappingSettings toneMapping = default;

    public ToneMappingSettings ToneMapping => toneMapping;
    #endregion
}


Shader "Custom RP/Post FX Stack" {

	SubShader
	{
		Cull Off
		ZTest Always
		ZWrite Off

		HLSLINCLUDE
		#include "../ShaderLibrary/Common.hlsl"
		#include "PostFXStackPasses.hlsl"
		ENDHLSL

		Pass
		{
			Name "Bloom Add"

			HLSLPROGRAM
			#pragma target 3.5
			#pragma vertex DefaultPassVertex
			#pragma fragment BloomAddPassFragment
			ENDHLSL
		}

		Pass
		{
			Name "Bloom Horizontal"

			HLSLPROGRAM
			#pragma target 3.5
			#pragma vertex DefaultPassVertex
			#pragma fragment BloomHorizontalPassFragment
			ENDHLSL
		}

		Pass
		{
			Name "Bloom Prefilter"

			HLSLPROGRAM
			#pragma target 3.5
			#pragma vertex DefaultPassVertex
			#pragma fragment BloomPrefilterPassFragment
			ENDHLSL
		}

		Pass
		{
			Name "Bloom PrefilterFireflies"

			HLSLPROGRAM
			#pragma target 3.5
			#pragma vertex DefaultPassVertex
			#pragma fragment BloomPrefilterFirefliesPassFragment
			ENDHLSL
		}

		Pass
		{
			Name "Bloom Scatter"

			HLSLPROGRAM
			#pragma target 3.5
			#pragma vertex DefaultPassVertex
			#pragma fragment BloomScatterPassFragment
			ENDHLSL
		}

		Pass
		{
			Name "Bloom Scatter Final"

			HLSLPROGRAM
			#pragma target 3.5
			#pragma vertex DefaultPassVertex
			#pragma fragment BloomScatterFinalPassFragment
			ENDHLSL
		}

		Pass
		{
			Name "Bloom Vertical"

			HLSLPROGRAM
			#pragma target 3.5
			#pragma vertex DefaultPassVertex
			#pragma fragment BloomVerticalPassFragment
			ENDHLSL
		}

		Pass
		{
			Name "Copy"

			HLSLPROGRAM
			#pragma target 3.5
			#pragma vertex DefaultPassVertex
			#pragma fragment CopyPassFragment
			ENDHLSL
		}

		Pass
		{
			Name "ColorGrading None"

			HLSLPROGRAM
			#pragma target 3.5
			#pragma vertex DefaultPassVertex
			#pragma fragment ColorGradingNonePassFragment
			ENDHLSL
		}

		Pass
		{
			Name "ColorGrading ACES"

			HLSLPROGRAM
			#pragma target 3.5
			#pragma vertex DefaultPassVertex
			#pragma fragment ColorGradingACESPassFragment
			ENDHLSL
		}

		Pass
		{
			Name "ColorGrading Neutral"

			HLSLPROGRAM
			#pragma target 3.5
			#pragma vertex DefaultPassVertex
			#pragma fragment ColorGradingNeutralPassFragment
			ENDHLSL
		}

		Pass
		{
			Name "ColorGrading Reinhard"

			HLSLPROGRAM
			#pragma target 3.5
			#pragma vertex DefaultPassVertex
			#pragma fragment ColorGradingReinhardPassFragment
			ENDHLSL
		}

		Pass
		{
			Name "Final"

			HLSLPROGRAM
			#pragma target 3.5
			#pragma vertex DefaultPassVertex
			#pragma fragment FinalPassFragment
			ENDHLSL
		}
	}
}
牛神自
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
unity屏幕后处理全家桶之color grading
阿拉平平的专栏
01-13 1万+
color grading color grading指的是对最终的游戏界面进行颜色和亮度的改变或矫正。你可以理解为增加滤镜。 屏幕后处理全家桶里的color grading是完全实时hdr工具，内部处理是在ACES色彩空间下完成的。 屏幕后处理全家桶里的color grading包含5个部分 1. ToneMapping色彩映射 2. 基础； 3. 通道混合； 4. 轨迹球； 5
pixelSurrogate:Unity3d-像素攻击网...抵抗是徒劳的[稳定]
05-14
pixelSurrogate ...笔记： 处理时间取决于硬件。 从示例场景中包含的较小图像（64x64）开始。 较大的图像会处理，但可能会花费更多时间。 它可能会冻结太多网格的Unity。 更新： 不再被推送到 ，
Unity 后处理（Post-Processing） -- （2）创建后处理配置文件
vivo01的专栏
05-03 1852
通过前面一小节，我们初步认识了后处理是什么，在Unity中简单的试了试后处理的效果。本节我们来创建一个我们自己的后处理配置文件（post-processing profile）。一个后处理配置文件包含了一系列为了达到特定视觉效果的后处理效果的配置。后处理配置文件对于项目整体的视觉风格和感觉有着非常大的影响。我们来看一个实际的例子感受一下后处理的威力。
【Unity】Post-process后处理之Color Grading
Mediary的博客
11-17 3944
Color Grading 1. All None : 可以看作是效果开关 2. Mode：设置清晰度，默认高清晰度 Low Definition Range 低清晰度,适用于低端平台 High Definition Range 高清晰度,适用于支持 HDR 渲染的平台 External 允许提供在外部软件中编写的自定义 3D 查找纹理。` Low Definition Range: 低清晰度,`适用于低端平台` High Definition Range: 高清晰度,`适用于支持
URP——后期处理特效——颜色调整Color Adjustments
liquanyi007的博客
11-30 1919
Color Adjustments 使用这个效果来调整最终渲染图像的整体色调、亮度和对比度。 Using Color Adjustments 颜色调整使用体积框架，所以要启用和修改颜色调整属性，你必须在场景的体积中添加一个颜色调整覆盖。 为体积添加颜色调整: 在场景或层次视图中，选择一个包含体积组件的游戏对象，在检查器中查看它。 在检查器中，导航到Add Override > Post-processing和点击Color Adjustments。URP现在对任何受此体积影响的相机应用颜.
【图形学】后处理下的HDR、颜色分级、颜色映射与颜色空间
ColorGalaxy
06-03 6564
目录 一、Color Grading 1.1概念 1.2 内置在Unity/UE4 二、HDR、LDR与VDR 2.1 LDR 2.2 HDR 2.3 VDR 三、Tone Mapping 3.1 概念 3.2 算法发展史 3.3 ACES算法 四、常见的颜色空间标准 参考 一、Color Grading 1.1概念 Color Grading（颜色分级、颜色校正）俗称调色，是游戏后期处理中最常见也是必要的一个环节。它能够改变或矫正最终图像的颜色和亮度，你可以把它想象...
unity3d-texturepackerimporter:Unity3D - 纹理包装器导入器
07-13
#Unity3D - 纹理打包器导入器 在这里获取最新的 Unity 包！ 作者 米奇汤普森 哈拉尔德·鲁格 海斯克拉克 视频教程 这里有这个插件的教程： : 指示 如何从 Texture Packer 导入纹理表 TexturePacker 设置： Data...
ufo-game:Unity项目-UFO游戏
04-04
飞碟游戏 Unity项目-UFO游戏
UPSG:UnityProject-Sep&Galicizer
06-26
UPSG UnityProject-Sep&Galicizer
unity-vg-demo:Unity矢量图形演示
04-28
围绕Unity新的实验性Vector API的简单包装，让您就像在HTML5画布中一样进行绘制。 演示基本的填充，笔触和填充规则。 例如： m_Graphics.MoveTo(900, 150);m_Graphics.BezierCurveTo(910, 250, 940, 250, 950, 250);...
godot-color-lut-shader:使用LUT进行颜色分级的Godot着色器
05-20
Godot彩色LUT着色器 使用LUT着色器对Godot 3进行实时颜色分级。 此着色器根据提供的3D查找表（LUT）纹理将所有渲染的像素颜色重新映射为新的像素颜色。 这是一种高度灵活，高效的色彩校正技术，可用于Godot中的实时应用。 安装 将文件夹“ color_grading_lut”从“附加组件”复制到项目的“附加组件”文件夹。 转到项目设置->插件，然后将状态从“颜色分级LUT辅助工具”更改为有效。 用法 着色器 如何使用 单击“场景”选项卡中的“添加子节点”按钮。 搜索“ ColorGradingFilter”并选择它。 转到“检查器”选项卡，查找“ Lut”并更改为其他LUT。 在“ addons / color_grading_lut / default_luts”中有一个有用的LUTS列表。 调整控件的大小以覆盖整个屏幕或所需区域。 屏幕截图插件 为了帮助创建L
Unity urp2d ShaderGraph 实现一个黑白转彩色的场景渐变效果 设计思路
m0_51776409的博客
10-29 3614
那只能走走别的方向了，仔细想想，原来的shader也确实不太完美，因为我们要的是整个画面的黑白，而上面的shader则需要给每个场景物品都安装这个shader跑计算的话，无疑是降低了性能和扩展性的。我们可以放弃if节点，改用lerp在两个色域中做插值，就可以优化渐变效果，插值需要一个0-1的参数，我们选择使用“Saturate”节点，这个节点可以将一个浮点值映射到[0,1]的范围内，即输入大于1时=1，输入小于0时等于0，然后将结果连接到Lerp节点就可以了。这样我们这个效果就成功实现了。
Color Grading
kuangben2000的博客
06-19 725
Color Grading https://www.jianshu.com/p/7f85935a7c02 中文为色彩分级，是一种调整或校正图片最终颜色和亮度的技术。你可以认为它是类似于在Insgram使用滤镜。颜色分级效果有三种模式：Low Dynamic Range: 这种模式目标平台为低端平台，但它能应用与任何平台。分级作用于最后渲染帧，并且颜色值限制在了[0,1]，储存于一张标准LUT（Lookup Table）中。High Dynamic Range: 这种模式针对支持HDR渲染的平台。所有的颜
UnityShader35：光晕光效
加载中...
02-13 3088
光晕(halation)是指在曝光拍摄过程中，强光投射到胶片上时，透过胶片乳剂中在片基表面进行反射，从而致使图像发晕的现象
unity-ShaderGraph全节点
羽阿呆的博客
08-23 567
Sampler State 采样状态，连接Sample Texture节点的sampler输入，可设置filter（linear，point，trilinear）wrap(repeat,clamp,mirror,mirror once)Color Mask 通过Color Tint 屏蔽选中的颜色，可设置Range和fuzziness（模糊度，用来颜色过渡）Sample Texture 2D Array 等同于Sample Texture 2D，区别在于可输入一个index。
【unity】ShaderGraph学习笔记
发布unity，三维模型的相关内容
07-26 3135
在Project面板里Create→ShaderGraph→URP→这里主要有几个选项：有光照三维着色器：无光照三维着色器Sprite Custom Lit Shader Graph：自定义光照图片着色器Sprite Unlit Shader Graph：无光照图片着色器Sprite Lit Shader Graph：光照图片着色器Decal Shader Graph：贴花着色器。
Color Grading 颜色分级 后期处理系列11
cangod的博客
06-25 8101
Color Grading 颜色分级 本文档主要是对Unity官方手册的个人理解与总结（其实以翻译记录为主：>） 仅作为个人学习使用，不得作为商业用途，欢迎转载，并请注明出处。 文章中涉及到的操作都是基于Unity2018.4版本 参考链接：https://github.com/Unity-Technologies/PostProcessing/wiki/Color-Grading Colo...
Unity - 通用渲染管线（URP）1.渲染、后处理
FoxGame的专栏
07-13 8850
简介URP是一种预置的可编程渲染管线。可以实现快速的渲染而不需要shader技术。URP使用简化的基于物理的光照和材质。URP继承自’RenderPipelineAsset’，当我们将URP设置到Graphics Setting时，Unity将内置的渲染管线转换到URP。 在URP中可以对下面一些对象进行设置：///这里的一些详细讲解还需要重新看一下Shader的书 General： General设置管线渲染每一帧中的核心部分Quality： 这些设置控制URP的质量级别。通过调整可以控制在不同设备上的性
PBR urp 简单写法
weixin_54479200的博客
03-17 314
【代码】PBR urp 简单写法。
unity的代码------ 已跳过“生成”: 项目: HotUpdateScripts ------为啥会跳过
最新发布
02-01
在Unity中，代码是用来实现游戏逻辑和功能的关键部分。Unity支持使用C#或UnityScript（一种基于JavaScript的脚本语言）编写代码。 在Unity中，代码通常被组织在脚本文件中，这些脚本文件可以附加到游戏对象上。当...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值