Unity开发者联盟收藏本站
发帖教程新人必读切换到宽版

 找回密码
 立即注册
Unity开发者联盟»论坛 › 3D Answers 技术讨论 › 技术讨论 Technology Answers › Unity PostProcess简要分析与总结
返回列表 发新帖
查看: 506|回复: 3

Unity PostProcess简要分析与总结

[复制链接]
发表于 2021-2-19 08:56 | 显示全部楼层 |阅读模式
转发请注明出处 https://zhuanlan.zhihu.com/p/118557378
整体流程

后处理主要内容列表

    Ambient OcclusionAnti-aliasingAuto-exposureBloomChromatic AberrationColor GradingDeferred FogDepth of FieldGrainLens DistortionMotion BlurScreen-space reflectionsVignette
PostProcess Effect处理顺序

    Anti-aliasingBlur
Builtins:
  DepthOfField
Uber Effects:
    AutoExposureLensDistortionCHromaticAberrationBloomVignetteGrainColorGrading(tonemapping)
关键类

PostProcessResource 绑定shader资源
PostProcessRenderContext 重要参数缓存、
PostProcessLayer 后处理渲染控制类
PostProcessEffectRenderer 所有后处理Effect继承它，并实现其render接口
PostProcessEffectSettings Effect的面板、属性描述类
一个Effect一般包括
    一个它自己的shader一个UI描述类(CustomEffect，继承PostProcessEffectSettings)一个渲染接口类(CustomEffectRender，继承PostProcessEffectRender)
自定义后处理

可以添加这几类后处理:BeforeTransparent,BeforeStack,AfterStack，这类后处理可以不修改原PostProcessing下的代码进行添加。
如果想添加Builtin阶段的后处理，那么一般在PostProcessing/Runtime/Effects下进行添加，这类后处理可能会修改PostProcessing下的代码或shader
核心函数

后处理的入口函数为PostProcessLayer::OnPreRender
核心渲染控制逻辑
1- BuildCommandBuffers
  1. PostProcessLayer::BuildCommandBuffers
  2. {
  3.     int tempRt = m_TargetPool.Get();
  4.     context.GetScreenSpaceTemporaryRT(m_LegacyCmdBuffer, tempRt, 0, sourceFormat, RenderTextureReadWrite.sRGB);
  5.     m_LegacyCmdBuffer.BuiltinBlit(cameraTarget, tempRt, RuntimeUtilities.copyStdMaterial, stopNaNPropagation ? 1 : 0);
  6.     context.command = m_LegacyCmdBuffer;
  7.     context.source = tempRt;
  8.     context.destination = cameraTarget;
  9.     Render(context);
  10.     ...
  11. }
复制代码
该函数从摄像机拷贝了一份临时RT作为source，接着进入渲染阶段Render(context)
2- Render(context)
  1. if (hasBeforeStackEffects)
  2. lastTarget = RenderInjectionPoint(PostProcessEvent.BeforeStack, context, "BeforeStack", lastTarget);
  4. // Builtin stack,Effects
  5. lastTarget = RenderBuiltins(context, !needsFinalPass, lastTarget);
  7. // After the builtin stack but before the final pass (before FXAA & Dithering)
  8. if (hasAfterStackEffects)
  9.     lastTarget = RenderInjectionPoint(PostProcessEvent.AfterStack, context, "AfterStack", lastTarget);
  11. // And close with the final pass
  12. if (needsFinalPass)
  13.     RenderFinalPass(context, lastTarget);
复制代码
这里最关键的是RenderBuiltins和RenderFinalPass
3- RenderBuiltins
这是后处理的关键逻辑
中间的大量Effect都是计算参数、获得各种Texture
最终使用Uber将各种效果混合到context.destination
  1. int RenderBuiltins(PostProcessRenderContext context, bool isFinalPass, int releaseTargetAfterUse)
  2. {
  3.     ...
  4.     context.uberSheet = uberSheet;//context.resources.shaders.uber
  5.     ....
  6.     cmd.BeginSample("BuiltinStack");
  7.     int tempTarget = -1;
  8.     var finalDestination = context.destination;//暂存 finalRT
  9.     if (!isFinalPass)
  10.     {
  11.         // Render to an intermediate target as this won't be the final pass
  12.         tempTarget = m_TargetPool.Get();
  13.         context.GetScreenSpaceTemporaryRT(cmd, tempTarget, 0, context.sourceFormat);
  14.         context.destination = tempTarget;//临时RT，临时destination
  15.     ...
  16.     }
  17.     ....
  18.     int depthOfFieldTarget = RenderEffect<DepthOfField>(context, true);
  19.     ..
  20.     int motionBlurTarget = RenderEffect<MotionBlur>(context, true);
  21.     ..
  22.     if (ShouldGenerateLogHistogram(context))
  23.         m_LogHistogram.Generate(context);
  25.     // Uber effects
  26.     RenderEffect<AutoExposure>(context);
  27.     uberSheet.properties.SetTexture(ShaderIDs.AutoExposureTex, context.autoExposureTexture);
  29.     RenderEffect<LensDistortion>(context);
  30.     RenderEffect<ChromaticAberration>(context);
  31.     RenderEffect<Bloom>(context);
  32.     RenderEffect<Vignette>(context);
  33.     RenderEffect<Grain>(context);
  35.     if (!breakBeforeColorGrading)
  36.         RenderEffect<ColorGrading>(context);
  38.     if (isFinalPass)
  39.     {
  40.         uberSheet.EnableKeyword("FINALPASS");
  41.         dithering.Render(context);
  42.         ApplyFlip(context, uberSheet.properties);
  43.     }
  44.     else
  45.     {
  46.         ApplyDefaultFlip(uberSheet.properties);
  47.     }
  48.     //使用uber shader混合前面的Effects的结果
  49.     cmd.BlitFullscreenTriangle(context.source, context.destination, uberSheet, 0);
  51.     context.source = context.destination;
  52.     context.destination = finalDestination;
  54.     ...releaseRTs
  55.     cmd.EndSample("BuiltinStack");
  57.     return tempTarget;
  58. }
复制代码
RT

PostProcess中RT总览

可以看到保存渲染图象的RT都的RW都为sRGB
RT与sRGB

在客户端配置为linear-space,开启HDR的情况下 如果创建RT时，RenderTextureReadWrite为sRGB,也就是RT保存的是sRGB值，读值时，会自动进行sRGB->linear转化，写值时自动进行linear->sRGB转化
初始时，只有一个cameraTarget，它的RenderTextureReadWrite为sRGB 在进入Effects前，会拷贝一个临时RT作为context.source，他的RenderTextureReadWrite为sRGB
经过Anti-aliasing、Blur、Beforestack后，会将context.destination改为一个空白的临时RT(RW为sRGB)
在Uber最后的混合阶段，会将所有效果混合
RT的尺寸

通过PostProcessRenderContext.GetScreenSpaceTemporaryRT获取RT，其默认尺寸存储在PostProcessRenderContext.width,PostProcessRenderContext.height
设置PostProcessRenderContext.m_Camera会调用Camera.set，这里会处理默认RT尺寸
  1. if (m_Camera.stereoEnabled)
  2. {
  3. #if UNITY_2017_2_OR_NEWER
  4.     var xrDesc = XRSettings.eyeTextureDesc;
  5.     width = xrDesc.width;
  6.     height = xrDesc.height;
  8.     screenWidth = XRSettings.eyeTextureWidth;
  9.     screenHeight = XRSettings.eyeTextureHeight;
  10. #endif
  11. }
  12. else
  13. {
  14.     width = m_Camera.pixelWidth;
  15.     height = m_Camera.pixelHeight;
  16.     ...
  17. }
复制代码
除了几个主要RT，中间作为Uber的纹理参数的RT的尺寸都不一定与cameraRT尺寸一样。
典型的几个都是通过new RenderTexture创建的，他们的大小和格式都需要注意
Effects

Effects处理顺序

这里再次列出来
    Anti-aliasing Blur
Builtins:
  DepthOfField
Uber Effects:
    AutoExposureLensDistortionCHromaticAberrationBloomVignetteGrainColorGrading(tonemapping)
Uber Effects

说明

Uber Effects包括
    AutoExposureLensDistortionCHromaticAberrationBloomVignetteGrainColorGrading(tonemapping)Uber混合阶段
其中Uber混合阶段之前的每个阶段会根据配置生成对应的参数和临时纹理，作为参数传递给Uber
同时如果某个阶段启用了，其render接口还会激活Uber中对应的关键字(比如Vignette的render极端会激活"VIGENETTE")，使用此方法来控制是Uber阶段是否执行某个阶段
Bloom

说明

Bloom 通过Downsample和Upsample得到一张BloomTex，这个过程需要确定迭代次数，每次使用的RT的尺寸
Bloom面板上有个关键参数Anamorphic Ratio([-1,1])能决定这些临时RT的尺寸
最终得到的BloomTex的尺寸就是第0次Downsample的尺寸，也就是(tw,th)
面板上的重要参数说明
    threshold ：亮度分离阈值，比如大于改值的进行Bloom效果intensity ：强度Anamorphic Ratio：决定bloomtex的尺寸，间接决定模糊迭代次数
Bloom 分为三步
    分离原图中亮度较大的像素，进行降分辨率处理把分离的亮度图进行高斯模糊将模糊后的亮度图和原图进行叠加,这一步在uber阶段完成
Bloom临时RT尺寸、迭代次数确定

公式


代码
  1. float ratio = Mathf.Clamp(settings.anamorphicRatio, -1, 1);
  2. float rw = ratio < 0 ? -ratio : 0f;
  3. float rh = ratio > 0 ?  ratio : 0f;
  4. int tw = Mathf.FloorToInt(context.screenWidth / (2f - rw));
  5. int th = Mathf.FloorToInt(context.screenHeight / (2f - rh));
复制代码
在DownSample迭代时，对应的RT的边长每次会减少一半
迭代次数iterations确定
  1. int s = Mathf.Max(tw, th);
  2. float logs = Mathf.Log(s, 2f) + Mathf.Min(settings.diffusion.value, 10f) - 10f;
  3. int logs_i = Mathf.FloorToInt(logs);
  4. int iterations = Mathf.Clamp(logs_i, 1, k_MaxPyramidSize);
  5. float sampleScale = 0.5f + logs - logs_i;
  6. sheet.properties.SetFloat(ShaderIDs.SampleScale, sampleScale);
复制代码
Downsample和Upsample

shader

    Bloom.shader 核心shaderSampling.hlsl 若干采样函数
不同阶段使用的pass列表
Downsample

每次Downsample，RT边长会缩短一倍，同时创建了一对参数一样的临时RT，这些RT的(RW都为sRGB)
shader使用上
    第0次使用的是 FragPrefilter13或FragPrefilter4 其他循环使用 FragDownsample13或Downsample4
  1. var lastDown = context.source;
  2. for (int i = 0; i < iterations; i++)
  3. {
  4.     int mipDown = m_Pyramid[i].down;
  5.     int mipUp = m_Pyramid[i].up;
  6.     int pass = i == 0? (int)Pass.Prefilter13 + qualityOffset
  7.         : (int)Pass.Downsample13 + qualityOffset;
  8.     context.GetScreenSpaceTemporaryRT(cmd, mipDown, 0, context.sourceFormat, RenderTextureReadWrite.Default, FilterMode.Bilinear, tw, th);
  9.     context.GetScreenSpaceTemporaryRT(cmd, mipUp, 0, context.sourceFormat, RenderTextureReadWrite.Default, FilterMode.Bilinear, tw, th);
  10.     cmd.BlitFullscreenTriangle(lastDown, mipDown, sheet, pass);
  11.     lastDown = mipDown;
  12.     tw = Mathf.Max(tw / 2, 1);
  13.     th = Mathf.Max(th / 2, 1);
  14. }
复制代码
Upsample
  1. int lastUp = m_Pyramid[iterations - 1].down;
  2. for (int i = iterations - 2; i >= 0; i--)
  3. {
  4.     int mipDown = m_Pyramid[i].down;
  5.     int mipUp = m_Pyramid[i].up;
  6.     cmd.SetGlobalTexture(ShaderIDs.BloomTex, mipDown);
  7.     cmd.BlitFullscreenTriangle(lastUp, mipUp, sheet, (int)Pass.UpsampleTent + qualityOffset);
  8.     lastUp = mipUp;
  9. }
复制代码
Uber混合阶段

这个阶段在Uber Effects都执行完之后才执行，进行效果混合
这段逻辑在Uber.shader中
  1. half4 bloom = UpsampleTent(TEXTURE2D_PARAM(_BloomTex, sampler_BloomTex), uvDistorted, _BloomTex_TexelSize.xy, _Bloom_Settings.x);
  2. bloom *= _Bloom_Settings.y;
  3. dirt *= _Bloom_Settings.z;
  4. color += bloom * half4(_Bloom_Color, 1.0);
  5. color += dirt * bloom;
复制代码
这里将bloom颜色叠加到color上
Vignette

说明

聚焦，边缘darkening
效果略
有两个模式
    Classic 边缘黑化Masked 使用一张自定义图片覆盖在屏幕上，以实现特俗效果
Vignette重要工作都在Uber中执行,其Render部分只根据设置进行参数设置
  1. var sheet = context.uberSheet;
  3. sheet.EnableKeyword("VIGNETTE");
  5. sheet.properties.SetColor(ShaderIDs.Vignette_Color, settings.color.value);
  7. if (settings.mode == VignetteMode.Classic)
  8. {
  9.     sheet.properties.SetFloat(ShaderIDs.Vignette_Mode, 0f);
  10.     sheet.properties.SetVector(ShaderIDs.Vignette_Center, settings.center.value);
  11.     float roundness = (1f - settings.roundness.value) * 6f + settings.roundness.value;
  12.     sheet.properties.SetVector(ShaderIDs.Vignette_Settings, new Vector4(settings.intensity.value * 3f, settings.smoothness.value * 5f, roundness, settings.rounded.value ? 1f : 0f));
  13. }
  14. else // Masked
  15. {
  16.     sheet.properties.SetFloat(ShaderIDs.Vignette_Mode, 1f);
  17.     sheet.properties.SetTexture(ShaderIDs.Vignette_Mask, settings.mask.value);
  18.     sheet.properties.SetFloat(ShaderIDs.Vignette_Opacity, Mathf.Clamp01(settings.opacity.value));
  19. }
复制代码
Uber混合阶段
  1. if (_Vignette_Mode < 0.5)
  2. {
  3.     half2 d = abs(uvDistorted - _Vignette_Center) * _Vignette_Settings.x;
  4.     d.x *= lerp(1.0, _ScreenParams.x / _ScreenParams.y, _Vignette_Settings.w);
  5.     d = pow(saturate(d), _Vignette_Settings.z); // Roundness
  6.     half vfactor = pow(saturate(1.0 - dot(d, d)), _Vignette_Settings.y);
  7.     color.rgb *= lerp(_Vignette_Color, (1.0).xxx, vfactor);
  8.     color.a = lerp(1.0, color.a, vfactor);
  9. }
  10. else
  11. {
  12.     half vfactor = SAMPLE_TEXTURE2D(_Vignette_Mask, sampler_Vignette_Mask, uvDistorted).a;
  13.     #if !UNITY_COLORSPACE_GAMMA
  14.     {
  15.         vfactor = SRGBToLinear(vfactor);
  16.     }
  17.     #endif
  18.     half3 new_color = color.rgb * lerp(_Vignette_Color, (1.0).xxx, vfactor);
  19.     color.rgb = lerp(color.rgb, new_color, _Vignette_Opacity);
  20.     color.a = lerp(1.0, color.a, vfactor);
  21. }
复制代码
Grain

效果略
grain是基于噪声模拟老式电影胶片的颗粒感，恐怖游戏中常用这中效果
它的Render部分是使用GrainBaker.shader中的算法生成一张128x128的GrainTex，Uber阶段将之混合到最终效果
Uber混合阶段
  1. half3 grain = SAMPLE_TEXTURE2D(_GrainTex, sampler_GrainTex, i.texcoordStereo * _Grain_Params2.xy + _Grain_Params2.zw).rgb;
  3. // Noisiness response curve based on scene luminance
  4. float lum = 1.0 - sqrt(Luminance(saturate(color)));
  5. lum = lerp(1.0, lum, _Grain_Params1.x);
  7. color.rgb += color.rgb * grain * _Grain_Params1.y * lum;
复制代码
ColorGrading

说明

ColorGrading有三种模式：
HighDefinitionRange
LowDefinitionRange
External :要求支持compute shader 与3D RT
有三条管线,分别是
RenderExternalPipeline3D  :要求支持compute shader 与3D RT
RenderHDRPipeline3D  :要求支持compute shader 与3D RT
RenderHDRPipeline2D 当不支持compute shader和3D RT时，使用这个进行HDR color pipeline
RenderLDRPipeline2D
这里只考虑RenderHDRPipeline2D
RenderHDRPipeline2D

该阶段分为5个部分
    TonemappingBasicChannel MixerTrackballsGrading Curves
使用的shader为lut2DBaker，核心的文件还有Colors.hlsl、ACES.hlsl
目的是生成一张颜色查找表Lut2D，然后在Uber阶段，根据该表查找映射颜色，作为新的颜色值
Lut2D的RenderTextureReadWrite为Linear，也就是存储的是Linear数据
可选的，有3种Tonemapping方式：Neutral、ACES、Custom
这里只考虑ACES
根据配置设置好lut2DBaker的各个阶段的参数和特性后，就进入计算阶段
  1. context.command.BeginSample("HdrColorGradingLut2D");
  2. context.command.BlitFullscreenTriangle(BuiltinRenderTextureType.None, m_InternalLdrLut, lutSheet, (int)Pass.LutGenHDR2D);
  3. context.command.EndSample("HdrColorGradingLut2D");
复制代码
当计算结束，会把计算结果Lut2D作为参数出传递给Uber，同时还会设置对应参数，最后的颜色替换阶段在Uber中完成
  1. uberSheet.EnableKeyword("COLOR_GRADING_HDR_2D");
  2. uberSheet.properties.SetVector(ShaderIDs.Lut2D_Params, new Vector3(1f / lut.width, 1f / lut.height, lut.height - 1f));
  3. uberSheet.properties.SetTexture(ShaderIDs.Lut2D, lut);
  4. uberSheet.properties.SetFloat(ShaderIDs.PostExposure, RuntimeUtilities.Exp2(settings.postExposure.value));
复制代码
Lut2DBaker

入口
  1. float4 FragHDR(VaryingsDefault i) : SV_Target
  2. {
  3.     float3 colorLutSpace = GetLutStripValue(i.texcoord, _Lut2D_Params);
  4.     float3 graded = ColorGradeHDR(colorLutSpace);
  5.     return float4(graded, 1.0);
  6. }
  7. float3 GetLutStripValue(float2 uv, float4 params)
  8. {
  9.     uv -= params.yz;
  10.     float3 color;
  11.     color.r = frac(uv.x * params.x);
  12.     color.b = uv.x - color.r / params.x;
  13.     color.g = uv.y;
  14.     return color * params.w;
  15. }
复制代码
_Lut2D_Params是写死的，值为:
  1. (lut_height, 0.5 / lut_width, 0.5 / lut_height, lut_height / lut_height - 1)
  2. 其中lut_height = 32;lut_width = 32*32
复制代码
也就是说，该表的大小为(32*32,32)
下图是一个例子(这里观察到的结果与实际的存储值是不一致的)


ColorGradeHDR主要将HDR颜色转到ACES颜色空间，并进行tonemapping
  1. //相关函数在Colors.hlsl中
  2. float3 ColorGradeHDR(float3 colorLutSpace)
  3. {
  4.     //得到HDR颜色
  5.     float3 colorLinear = LUT_SPACE_DECODE(colorLutSpace);
  6.     //
  7.     float3 aces = unity_to_ACES(colorLinear);
  8.     // ACEScc (log) space
  9.     float3 acescc = ACES_to_ACEScc(aces);
  10.     acescc = LogGradeHDR(acescc);
  11.     aces = ACEScc_to_ACES(acescc);
  12.     // ACEScg (linear) space
  13.     float3 acescg = ACES_to_ACEScg(aces);
  14.     acescg = LinearGradeHDR(acescg);   
  15.     // Tonemap ODT(RRT(aces))  
  16.     aces = ACEScg_to_ACES(acescg);  
  18.     //tonemap
  19.     colorLinear = AcesTonemap(aces);
  21.     return colorLinear;
  22. }
复制代码
两个重要的映射函数
  1. #define LUT_SPACE_ENCODE(x) LinearToLogC(x)
  2. #define LUT_SPACE_DECODE(x) LogCToLinear(x) //在Uber中进行颜色映射时使用该接口
  3. float3 LinearToLogC(float3 x)
  4. {
  5.     return LogC.c * log10(LogC.a * x + LogC.b) + LogC.d;   
  6. }
  7. float3 LogCToLinear(float3 x)
  8. {
  9.     return (pow(10.0, (x - LogC.d) / LogC.c) - LogC.b) / LogC.a;   
  10. }
  11. static const ParamsLogC LogC =
  12. {
  13.     0.011361, // cut
  14.     5.555556, // a
  15.     0.047996, // b
  16.     0.244161, // c
  17.     0.386036, // d
  18.     5.301883, // e
  19.     0.092819  // f
  20. };
复制代码
LinearToLogC
公式


图像


LogCToLinear
公式


图像


Uber阶段

这里根据lut进行颜色映射
  1. color *= _PostExposure;
  2. float3 colorLutSpace = saturate(LUT_SPACE_ENCODE(color.rgb));
  3. color.rgb = ApplyLut2D(TEXTURE2D_PARAM(_Lut2D, sampler_Lut2D), colorLutSpace, _Lut2D_Params);
复制代码
这里使用LUT_SPACE_ENCODE将颜色映射到HDR空间，然后通过这个值在lut中查找到对应的颜色值，作为新的color
  1. // 2D LUT grading
  2. // scaleOffset = (1 / lut_width, 1 / lut_height, lut_height - 1)
  3. //
  4. half3 ApplyLut2D(TEXTURE2D_ARGS(tex, samplerTex), float3 uvw, float3 scaleOffset)
  5. {
  6.     // Strip format where `height = sqrt(width)`
  7.     uvw.z *= scaleOffset.z;
  8.     float shift = floor(uvw.z);
  9.     uvw.xy = uvw.xy * scaleOffset.z * scaleOffset.xy + scaleOffset.xy * 0.5;
  10.     uvw.x += shift * scaleOffset.y;
  11.     uvw.xyz = lerp(
  12.         SAMPLE_TEXTURE2D(tex, samplerTex, uvw.xy).rgb,
  13.         SAMPLE_TEXTURE2D(tex, samplerTex, uvw.xy + float2(scaleOffset.y, 0.0)).rgb,
  14.         uvw.z - shift
  15.     );
  16.     return uvw;
  17. }
复制代码
Uber整合阶段

原始颜色假设为color0
  1. color.rgb *= autoExposure;
  2. //Bloom
  3. color += dirt * bloom;
  4. //Vignette
  5. color.rgb = lerp(color.rgb, new_color, _Vignette_Opacity); color.a = lerp(1.0, color.a, vfactor);
  6. //Grain
  7. color.rgb += color.rgb * grain * _Grain_Params1.y * lum;
  8. //COLOR_GRADING_HDR_2D
  9. color.rgb = ApplyLut2D(TEXTURE2D_PARAM(_Lut2D, sampler_Lut2D), colorLutSpace, _Lut2D_Params);
复制代码
之后，还会根据是否是final pass执行如下逻辑
非final pass
  1. UNITY_BRANCH
  2. if (_LumaInAlpha > 0.5)
  3. {
  4.     // Put saturated luma in alpha for FXAA - higher quality than "green as luma" and
  5.     // necessary as RGB values will potentially still be HDR for the FXAA pass
  6.     half luma = Luminance(saturate(output));
  7.     output.a = luma;
  8. }
  9. #if UNITY_COLORSPACE_GAMMA
  10. {
  11.     output = LinearToSRGB(output);
  12. }
  13. #endif
复制代码
如果是sRGB工作空间，还会将结果进行gamma矫正
final pass

如果定义了UNITY_COLORSPACE_GAMMA
还需要将linear 转到 sRGB
  1. #if UNITY_COLORSPACE_GAMMA
  2. {
  3.     output = LinearToSRGB(output);
  4. }
  5. #endif
复制代码
注意

Bloom一般开启fastmode,此模式下只采样4次，默认模式会采样13次

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

×
回复

使用道具 举报

poney
发表于 2021-2-19 09:01 | 显示全部楼层
感官上Bloom四次和十三次好像没啥太大感觉[飙泪笑]
回复 推荐 不推荐

使用道具 举报

发表于 2021-2-19 09:11 | 显示全部楼层
也许差别不大吧，而且手机屏幕小，所以一般开4就行了。要效果好的话，这个bloom方案也不够好肯定是不能用的
回复 推荐 不推荐

使用道具 举报

发表于 2021-2-19 09:20 | 显示全部楼层
Bloom开启fastmode会导致高频法线高光产生flicking（比如锁子甲这类物体），如果没有这个现象可以用fastmode。
回复 推荐 不推荐

使用道具 举报

返回列表 发新帖
懒得打字嘛，点击右侧快捷回复 【右侧内容，后台自定义】
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Unity开发者联盟 ( 粤ICP备20003399号 )

GMT+8, 2024-9-20 14:44 , Processed in 0.089189 second(s), 23 queries .

Powered by Discuz! X3.5 Licensed

© 2001-2024 Discuz! Team.

快速回复 返回顶部 返回列表