Unity自定义SRP(三)：平行光
2020-12-15 本文已影响0人
Dragon_boy
https://catlikecoding.com/unity/tutorials/custom-srp/directional-lights/
光照
Lit Shader
这里新建一个可接受光照的shader。新建LitPass.hlsl文件，内容和UnlitPass.hlsl一致，修改函数名：
#ifndef CUSTOM_LIT_PASS_INCLUDED
#define CUSTOM_LIT_PASS_INCLUDED
...
Varyings LitPassVertex(Attributes input)
{
}
float4 LitPassFragment(Varyings input) : SV_TARGET
{
}
#endif
Lit.shader:
Shader "Custom RP/Lit" {
Properties {
_BaseMap("Texture", 2D) = "white" {}
_BaseColor("Color", Color) = (0.5, 0.5, 0.5, 1.0)
...
}
SubShader {
Pass {
HLSLPROGRAM
...
#pragma vertex LitPassVertex
#pragma fragment LitPassFragment
#include "LitPass.hlsl"
ENDHLSL
}
}
我们将使用自定义的光照模式，加上标签：
Pass {
Tags {
"LightMode" = "CustomLit"
}
在CameraRenderer中加入该pass:
static ShaderTagId
unlitShaderTagId = new ShaderTagId("SRPDefaultUnlit"),
litShaderTagId = new ShaderTagId("CustomLit");
接着添加到DrawVisibleGeometry中:
var drawingSettings = new DrawingSettings(unlitShaderTagId, sortingSettings)
{
enableDynamicBatching = useDynamicBatching,
enableInstancing = useGPUInstancing
};
drawingSettings.SetShaderPassName(1, litShaderTagId);
法线
为使用光照模型，我们需要法线。在结构体中声明：
struct Attributes
{
float3 positionOS : POSITION;
float3 normalOS : NORMAL;
float2 baseUV : TEXCOORD0;
UNITY_VERTEX_INPUT_INSTANCE_ID
};
struct Varyings
{
float4 positionCS : SV_POSITION;
float3 positionWS : VAR_POSITION;
float3 normalWS : VAR_NORMAL;
float2 baseUV : VAR_BASE_UV;
UNITY_VERTEX_INPUT_INSTANCE_ID
};
在顶点着色器中我们使用TransformObjectToWorldNormal来完成法线从模型空间到世界空间的变换：
float3 positionWS = TransformObjectToWorld(input.positionOS);
output.positionCS = TransformWorldToHClip(positionWS);
output.normalWS = TransformObjectToWorldNormal(input.normalOS);
我们可以在片元着色器中用颜色显示法线：
base.rgb = input.normalWS;
return base;
注意，小于0的值会取为0。
法线插值
尽管法线在顶点着色器中是单位长度的，但经过沿三角形插值后其长度会变化，因此在片元着色器中要进行标准化：
base.rgb = normalize(input.normalWS);
表面属性
shader中的光照是模拟光线遇到表面后的反应的，因此我们需要跟踪表面的属性。我们新建一个Surface.hlsl文件，置于ShaderLibrary文件夹下：
#ifndef CUSTOM_SURFACE_INCLUDED
#define CUSTOM_SURFACE_INCLUDED
struct Surface
{
float3 normal;
float3 color;
float alpha;
};
#endif
在LitPass中包含：
#include "../ShaderLibrary/Common.hlsl"
#include "../ShaderLibrary/Surface.hlsl"
在片元着色器中定义一个surface变量，并填充：
Surface surface;
surface.normal = normalize(input.normalWS);
surface.color = base.rgb;
surface.alpha = base.a;
return float4(surface.color, surface.alpha);
计算光照
新建一个Lighting.hlsl文件，存放光照计算函数：
#ifndef CUSTOM_LIGHTING_INCLUDED
#define CUSTOM_LIGHTING_INCLUDED
float3 GetLighting(Surface surface)
{
return surface.normal.y * surface.color;
}
#endif
在LitPass中包含：
#include "../ShaderLibrary/Common.hlsl"
#include "../ShaderLibrary/Surface.hlsl"
#include "../ShaderLibrary/Lighting.hlsl"
在片元着色器中可以使用GetLighting获取光照：
float3 color = GetLighting(surface);
return float4(color, surface.alpha);
灯光
这里我们只模拟拥有方向的平行光。
灯光结构体
新建Light.hlsl文件，定义一个平行光结构体，同时定义一个GetDirectionalLight函数来返回一个配置好的平行光：
#ifndef CUSTOM_LIGHT_INCLUDED
#define CUSTOM_LIGHT_INCLUDED
struct Light
{
float3 color;
float3 direction;
float attenuation;
};
Light GetDirectionalLight(int index, Surface surfaceWS, ShadowData shadowData)
{
Light light;
light.color = 1.0;
light.direction = float3(0.0, 1.0, 0.0);
return light;
}
#endif
在LitPass中包含：
#include "../ShaderLibrary/Common.hlsl"
#include "../ShaderLibrary/Surface.hlsl"
#include "../ShaderLibrary/Light.hlsl"
#include "../ShaderLibrary/Lighting.hlsl"
光照函数
在文件中新增一个IncomingLight函数，用于计算光照程度，这里使用兰伯特模型：
float3 IncomingLight(Surface surface, Light light)
{
return saturate(dot(surface.normal, light.direction)* light.color;
}
同时添加一个重载函数GetLighting，用于计算每个灯光的光照：
float3 GetLighting(Surface surface, Light light)
{
return IncomingLight(surface, light) * surface.color;
}
修改另一个GetLighting，计算总的光照：
float3 GetLighting(Surface surface)
{
return GetLighting(surface, light);
}
将灯光数据送往GPU
为了在shader中可以得到灯光数据，我们定义几个uniform变量，放于_CustomLight缓冲中：
CBUFFER_START(_CustomLight)
float3 _DirectionalLightColors;
float3 _DirectionalLightDirection;
CBUFFER_END
在GetDirectionalLight中使用：
Light GetDirectionalLight()
{
Light light;
light.color = _DirectionalLightColors;
light.direction = _DirectionalLightDirections;
return light;
}
现在我们将数据送往GPU。创建一个新的类Lighting，类似于CameraRenderer：
public class Lighting
{
const string bufferName = "Lighting";
CommandBuffer buffer = new CommandBuffer
{
name = bufferName
};
public void Setup(ScriptableRenderContext context)
{
buffer.BeginSample(bufferName);
SetupDirectionalLight();
buffer.EndSample(bufferName);
context.ExecuteCommandBuffer(buffer);
buffer.Clear();
}
void SetupDirectionalLight()
{
}
}
同时跟踪两个shader属性：
static int
dirLightColorsId = Shader.PropertyToID("_DirectionalLightColor"),
dirLightDirectionsId = Shader.PropertyToID("_DirectionalLightDirection");
我们可以使用RenderSetting.sun来获取场景中的主光源：
void SetupDirectionalLight(int index, ref VisibleLight visibleLight)
{
Light light = RenderSetting.sun;
buffer.SetGlobalVector(dirLightColorId, light.color.linear * light.intensity);
buffer.SetGlobalVector(dirLightDirectionalId, -light.transform.forward);
}
在CameraRenderer中设置光照：
Lighting lighting = new Lighting();
public void Render(ScriptableRenderContext context, Camera camera, bool useDynamicBatching, bool useGPUInstancing)
{
Setup();
lighting.Setup(context);
DrawVisibleGeometry(useDynamicBatching, useGPUInstancing);
DrawUnsupportedShaders();
DrawGizmos();
lighting.Cleanup();
Submit();
}
可见光
在进行剔除时，Unity也会判断那些灯光会影响摄像机的可见范围。为此，Lighting需要获取剔除结果，在Setup中添加一个参数，同时使用SetupLights进行替换：
public void Setup(ScriptableRenderContext context, CullingResults cullingResults)
{
this.cullingResults = cullingResults;
buffer.BeginSample(bufferName);
SetupLights();
...
}
void SetupLights()
{
}
在CameraRenderer.Render中添加参数：
lighting.Setup(context, cullingResults);
使用NativeArray设置可见光：
using Unity.Collections;
public class Lighting
{
...
void SetupLights()
{
NativeArray<VisibleLight> visibleLights = cullingResults.visibleLights;
}
...
}
多个平行光
使用可见光数据的话，可以支持多个平行光源，但我们需要将这些数据送往GPU。首先定义平行光源的最大数量，接着定义相应的颜色和方向数组，记得声明相应的材质属性ID：
const int maxDirLightCount = 4;
static int
dirLightCountId = Shader.PropertyToID("_DirectionalLightCount"),
dirLightColorsId = Shader.PropertyToID("_DirectionalLightColors"),
dirLightDirectionsId = Shader.PropertyToID("_DirectionalLightDirections");
static Vector4[]
dirLightColors = new Vector4[maxDirLightCount],
dirLightDirections = new Vector4[maxDirLightCount];
为SetupDirectionalLight函数添加一个索引参数，可以根据索引获得相应光源的属性:
void SetupDirectionalLight(int index, ref VisibleLight visibleLight)
{
dirLightColors[index] = visibleLight.finalColor;
dirLightDirections[index] = -visibleLight.localToWorldMatrix.GetColumn(2);
}
Unity默认不使用线性空间的灯光强度：
public CustomRenderPipeline(bool useDynamicBatching, bool useGPUInstancing, bool useSRPBatcher)
{
this.useDynamicBatching = useDynamicBatching;
this.useGPUInstancing = useGPUInstancing;
GraphicsSettings.useScriptableRenderPipelineBatching = useSRPBatcher;
GraphicsSettings.lightsUseLinearIntensity = true;
}
接着我们遍历可见光，并设置灯光属性：
void SetupLights()
{
NativeArray<VisibleLight> visibleLights = cullingResults.visibleLights;
for (int i = 0; i < visibleLights.Length; i++)
{
VisibleLight visibleLight = visibleLights[i];
SetupDirectionalLight(i, visibleLight);
}
buffer.SetGlobalInt(dirLightCountId, dirLightCount);
buffer.SetGlobalVectorArray(dirLightColorsId, dirLightColors);
buffer.SetGlobalVectorArray(dirLightDirectionsId, dirLightDirections);
}
注意，我们目前只支持至多4个平行光：
void SetupLights()
{
NativeArray<VisibleLight> visibleLights = cullingResults.visibleLights;
int dirLightCount = 0;
for (int i = 0; i < visibleLights.Length; i++)
{
VisibleLight visibleLight = visibleLights[i];
if (visibleLight.lightType == LightType.Directional)
{
SetupDirectionalLight(dirLightCount++, ref visibleLight);
if (dirLightCount >= maxDirLightCount)
{
break;
}
}
}
buffer.SetGlobalInt(dirLightCountId, dirLightCount);
buffer.SetGlobalVectorArray(dirLightColorsId, dirLightColors);
buffer.SetGlobalVectorArray(dirLightDirectionsId, dirLightDirections);
}
Shader循环
修改Light.hlsl中的_CustomLight缓冲：
#define MAX_DIRECTIONAL_LIGHT_COUNT 4
CBUFFER_START(_CustomLight)
int _DirectionalLightCount;
float4 _DirectionalLightColors[MAX_DIRECTIONAL_LIGHT_COUNT];
float4 _DirectionalLightDirections[MAX_DIRECTIONAL_LIGHT_COUNT];
CBUFFER_END
同时添加一个获取灯光数量的方法：
int GetDirectionalLightCount()
{
return _DirectionalLightCount;
}
Light GetDirectionalLight(int index)
{
Light light;
light.color = _DirectionalLightColors[index].rgb;
light.direction = _DirectionalLightDirections[index].xyz;
return light;
}
接着修改针对一个表面的GetLighting函数:
float3 GetLighting(Surface surface)
{
float3 color = 0.0;
for (int i = 0; i < GetDirectionalLightCount(); i++)
{
Light light = GetDirectionalLight(i);
color += GetLighting(surface, light);
}
return color;
}
BRDF
BRDF不过多介绍
表面属性
这里使用金属流程，我们在Surface中添加金属度和光滑度的属性，在shader中也添加对应的属性：
_Metallic ("Metallic", Range(0, 1)) = 0
_Smoothness ("Smoothness", Range(0, 1)) = 0.5
struct Surface
{
float3 normal;
float3 color;
float alpha;
float metallic;
float smoothness;
};
UNITY_INSTANCING_BUFFER_START(UnityPerMaterial)
UNITY_DEFINE_INSTANCED_PROP(float4, _BaseMap_ST)
UNITY_DEFINE_INSTANCED_PROP(float4, _BaseColor)
UNITY_DEFINE_INSTANCED_PROP(float, _Cutoff)
UNITY_DEFINE_INSTANCED_PROP(float, _Metallic)
UNITY_DEFINE_INSTANCED_PROP(float, _Smoothness)
UNITY_INSTANCING_BUFFER_END(UnityPerMaterial)
在片元着色器中填充相应属性：
surface.metallic = UNITY_ACCESS_INSTANCED_PROP(UnityPerMaterial, _Metallic);
surface.smoothness = UNITY_ACCESS_INSTANCED_PROP(UnityPerMaterial, _Smoothness);
BRDF属性
BRDF是漫反射和高光反射的结合，除了将表面颜色分为这两块外，我们还需要知道表面的粗糙度。新建BRDF.hlsl，加入结构体：
#ifndef CUSTOM_BRDF_INCLUDED
#define CUSTOM_BRDF_INCLUDED
struct BRDF
{
float3 diffuse;
float3 specular;
float roughness;
};
#endif
添加GetBRDF方法，返回某一表面的BRDF数据：
BRDF GetBRDF(inout Surface surface)
{
BRDF brdf;
brdf.diffuse = surface.color;
brdf.specular = 0.0;
brdf.roughness = 1.0;
return brdf;
}
在LitPass中包含相应文件：
#include "../ShaderLibrary/Common.hlsl"
#include "../ShaderLibrary/Surface.hlsl"
#include "../ShaderLibrary/Light.hlsl"
#include "../ShaderLibrary/BRDF.hlsl"
#include "../ShaderLibrary/Lighting.hlsl"
在所有的GetLighting函数中加入brdf参数，使用其diffuse属性替换：
float3 GetLighting(Surface surface, BRDF brdf, Light light)
{
return IncomingLight(surface, light) * brdf.diffuse;
}
float3 GetLighting(Surface surface, BRDF brdf)
{
float3 color = 0.0;
for (int i = 0; i < GetDirectionalLightCount(); i++)
{
Light light = GetDirectionalLight(i, surface);
color += GetLighting(surface, brdf, light);
}
return color;
}
在片元着色器末尾调用：
BRDF brdf = GetBRDF(surface);
float3 color = GetLighting(surface, brdf);
反射率
这里我们假设金属材质进行完全高光反射，反射率等价为表面的金属度，以此计算漫反射：
float oneMinusReflectivity = surface.metallic;
brdf.diffuse = surface.color * oneMinusReflectivity;
不过实际中，非金属也会有光的反射，即高光，它们的反射率的平均值大约为0.04。我们添加一个函数来将1-反射率的范围调整到0-0.96（即URP采用的方法）：
#define MIN_REFLECTIVITY 0.04
float OneMinusReflectivity(float metallic)
{
float range = 1.0 - MIN_REFLECTIVITY;
return range - metallic * range;
}
使用该函数计算漫反射：
float oneMinusReflectivity = OneMinusReflectivity(surface.metallic);
brdf.diffuse = surface.color * oneMinusReflectivity;
高光
根据能量守恒公式，反射的出射光的能量不会大部入射光的能量，也就是说直接相减就能得到高光颜色：
brdf.diffuse = surface.color * oneMinusReflectivity;
brdf.specular = surface.color - brdf.diffuse;
不过这样就忽略了一点，金属材质会影响高光颜色，而非金属不会，非金属的高光应该是白色的，我们可以将表面颜色与最小的反射率根据表面的金属度插值得到：
brdf.specular = lerp(MIN_REFLECTIVITY, surface.color, surface.metallic);
粗糙度
Core RP Library有一个方法PerceptualSmoothnessToPerceptualRoughness，可以根据表面的光滑程度获得粗糙度：
real PerceptualSmoothnessToPerceptualRoughness(real perceptualSmoothness)
{
return (1.0 - perceptualSmoothness);
}
perceptual即感知到的。
真正的粗糙度可以使用PerceptualRoughnessToRoughness得到：
real RoughnessToPerceptualRoughness(real roughness)
{
return sqrt(roughness);
}
这些方法在CommonMaterial.hlsl文件中：
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl"
#include "UnityInput.hlsl"
使用这些函数获得粗糙度：
float perceptualRoughness = PerceptualSmoothnessToPerceptualRoughness(surface.smoothness);
brdf.roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
观察方向
我们需要摄像机的位置，在UnityInput中定义：
float3 _WorldSpaceCameraPos;
同时相关光照计算我们需要顶点的世界坐标：
struct Varyings
{
float4 positionCS : SV_POSITION;
float3 positionWS : VAR_POSITION;
...
};
Varyings LitPassVertex(Attributes input)
{
...
output.positionWS = TransformObjectToWorld(input.positionOS);
output.positionCS = TransformWorldToHClip(output.positionWS);
...
}
我们可以将观察方向作为表面属性的一部分：
struct Surface
{
float3 normal;
float3 viewDirection;
float3 color;
float alpha;
float metallic;
float smoothness;
};
接着在片元着色器中计算：
surface.viewDirection = normalize(_WorldSpaceCameraPos - input.positionWS);
高光强度
这里的高光强度计算使用简化CookTorrance BRDF的一种变体，也是URP使用的。因为需要平方计算，我们在Common.hlsl添加相应的方法：
float Square(float v)
{
return v * v;
}
上述BRDF的计算公式为：，其中
，r是粗糙度，N是法线，L是入射光方向，H是中间矢量，
：
float SpecularStrength(Surface surface, BRDF brdf, Light light)
{
float3 h = SafeNormalize(light.direction + surface.viewDirection);
float nh2 = Square(saturate(dot(surface.normal, h)));
float lh2 = Square(saturate(dot(light.direction, h)));
float r2 = Square(brdf.roughness);
float d2 = Square(nh2 * (r2 - 1) + 1.0001);
float normalization = brdf.roughness * 4.0 + 2.0;
return r2 / (d2 * max(0.1, lh2) * normalization);
}
接着添加一个计算最后颜色的函数：
float3 DirectBRDF(Surface surface, BRDF brdf, Light light)
{
return SpecularStrength(surface, brdf, light) * brdf.specular + brdf.diffuse;
}
在针对单个光源的GetLighting中应用：
float3 GetLighting(Surface surface, BRDF brdf, Light light)
{
return IncomingLight(surface, light) * DirectBRDF(surface, brdf, light);
}
透明
如果应用带有透明度的纹理进行透明度混合的话，会发现反射光会变暗：
这并不合理，漫发射的确会变暗，但高光反射就说不通了（比如玻璃）。
预乘Alpha
我们只想让漫发射衰减，而高光反射不变。为了能够不应用衰减，我们将混合模式的Source改为1。不过这样的话，漫反射也不会衰减了，因此我们在GetBRDF中提前乘上alpha值：
brdf.diffuse = surface.color * oneMinusReflectivity;
brdf.diffuse *= surface.alpha;
预乘选项
我们想同时支持预乘和一般情况，因此加上一个参数：
BRDF GetBRDF(inout Surface surface, bool applyAlphaToDiffuse = false)
{
...
brdf.diffuse = surface.color * oneMinusReflectivity;
if (applyAlphaToDiffuse)
{
brdf.diffuse *= surface.alpha;
}
...
}
在片元着色器中，我们可以使用_PREMULTIPLY_ALPHA关键字来决定是否使用预乘：
#if defined(_PREMULTIPLY_ALPHA)
BRDF brdf = GetBRDF(surface, true);
#else
BRDF brdf = GetBRDF(surface);
#endif
float3 color = GetLighting(surface, brdf);
return float4(color, surface.alpha);
同时添加相应的着色器变体和属性配置：
#pragma shader_feature _PREMULTIPLY_ALPHA
[Toggle(_PREMULTIPLY_ALPHA)] _PremulAlpha ("Premultiply Alpha", Float) = 0
