庄懂的技术美术入门课 - 光照贴图

Shader "Zhuangdong/AP1/L15/L15_LightingMap" {
    Properties{
        // ... 贴图与参数声明 ...
    }
    SubShader{
        Tags { "RenderType" = "Opaque" }
        Pass {
            Name "FORWARD"
            Tags { "LightMode" = "ForwardBase" }
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"
            // ... 以 orge 案例为模板,顶点着色器移除 TRANSFER_VERTEX_TO_FRAGMENT(o) ...
             VertexOutput vert(VertexInput v) { 
                    ...
                    //案例需要 2 个 uv, 这里将 2 个 uv 合并到一个 float4, 节省 TEXCOORD
                    o.uvs = float4(v.uv0, v.uv1);
                    ...
            }
            float3 DecodeNormal (float2 maskXY) {
                //贴图只有 RG 两个通道,我们要补上 B 通道
                float2 nDirTSxy = maskXY * 2.0 - 1.0;
                //贴图值域在 (0,1),法线是向量,向量值域在 (-1,1)
                float nDirTSz = sqrt(1.0 - (nDirTSxy.x * nDirTSxy.x + nDirTSxy.y * nDirTSxy.y));
                //sqrt 取平方根,x 平方+y 平方+z 平方=1
                return float3(nDirTSxy, nDirTSz);
            }
            float4 frag(VertexOutput i) : COLOR {
                // ... 采样、向量、点乘 ...
                //提取表面信息
                float occlusion = var_MaskTex.r;
                float matMask = var_MaskTex.g;//金属贴图
                float3 diffCol = var_MainTex.rgb * lerp(1.0, _MetalDarken, pow(matMask, 5.0));
                //这里给金属叠加_MetalDarken,降低金属部分的 diff
                float specPow = max(1.0, lerp(_SpecParams.x, _SpecParams.z, matMask));
                float specInt = max(0.0, lerp(_SpecParams.y, _SpecParams.w, matMask));
                float reflectMip = clamp(lerp(_EnvReflectParams.x, _EnvReflectParams.z, matMask), 0.0, 7.0);
                //clamp 即 clamp(value,min,max) 会将 value 限制在 (min,max) 中
                float reflectInt = max(0.0, lerp(_EnvReflectParams.y, _EnvReflectParams.w, matMask));
                float fresnel = lerp(pow(1.0 - max(0.0, ndotv), _FresnelPow), 1.0, matMask);
                //区分金属和非金属的 Fresnel 强度
                //提取光照信息
                float skyLightOcc = var_LightMap.r;
                float emitLightingInt = var_LightMap.g;
                float mainLightGIInt = pow(var_LightMap.b, _GIpow);
                float mainLightShadow = var_LightMap.a;
                //采样纹理 Cube
                float3 var_SkyCube = texCUBElod(_SkyCube, float4(vrDirWS, 7.0)).rgb;
                float3 var_EnvCube = texCUBElod(_EnvCube, float4(vrDirWS, reflectMip)).rgb;
                //MainLight
                //Diff
                float3 halfShadowCol = lerp(_HalfShadowCol.rgb, _MainLightCol, mainLightShadow);
                //获取半影颜色, 先给阴影和主光赋予颜色
                float3 mainLightCol = lerp(_MainLightCol, halfShadowCol, _HalfShadowCol.a) * mainLightShadow;
                //再用投影 mask 去掉阴影颜色,留下的就是主光颜色和半影颜色,这里_HalfShadowCol.a 控制半影强度
                float3 mainLightDiff = diffCol * mainLightCol * max(0.0, nDotl);
                //DiffCol*Lambert*MainLight
                //Spec
                float3 mainLightSpec = mainLightCol * pow(max(0.0, vDotr), specPow) * specInt;//Phong
                //GI
                float3 mainLightGI = _GICol * occlusion * mainLightGIInt * _GIInt;
                //GI 也就是主光的反弹光,这里叠加 AO 增加变化
                //Mixed
                float3 mainLight = (mainLightDiff + mainLightSpec + mainLightGI * _MainLightGIOn) * _MainLightOn;
                //这里 GI 已经有环境 AO 的信息了,所以不用*LM

                //OtherLight
                float3 skyLightDiff = diffCol * var_SkyCube * _SkyCol * _SkyLightInt * skyLightOcc * occlusion;
                //这里是物体漫反射*天光漫反射*LM(LightingMap)
                float3 emitLightDiff = diffCol * _EmissionCol * emitLightingInt * occlusion;
                //同上,这部分不受环境 AO 影响,所以不用*_SkyLightOcc
                //OtherEnvSpec
                float3 envLightSpec = var_EnvCube * reflectInt * fresnel * occlusion;
                float3 OtherLight = skyLightDiff * _SkyLightOn + emitLightDiff * _EmitLightOn + envLightSpec * _EnvReflectOn;
                float3 finalRGB = mainLight + OtherLight;
                return float4(finalRGB, 1.0);
            }
            ENDCG
        }
    }
        FallBack "Diffuse"
}

public void MultiBake()
{
    var buffer = new LightmapsBuffer();
    Bake(BakeMode.BakeMainLight);
    var info = new LightmapsInfo(LightmapSettings.lightmaps);
    buffer.WriteBuffer(info, LightmapsBuffer.BufferType.MainLight);
    Bake(BakeMode.BakeSkyLight);
    buffer.WriteBuffer(info, LightmapsBuffer.BufferType.SkyLight);
    Bake(BakeMode.BakeEmissionGI);
    buffer.WriteBuffer(info, LightmapsBuffer.BufferType.EmissionGI);
    buffer.CreateLightmaps();
    buffer.OverrideLightmaps(info);
    buffer.Clear();
    ArrangeBakeScene(BakeMode.Default);
    UpdateGlobalProperties();
    BakeReflectProbe();
}

public class LightingController : MonoBehaviour

private void OnEnable() {UpdateGlobalProperties();};

public struct LightmapsInfo {
    public readonly Dictionary<string, Texture2D> lightmapsInfo;
    public LightmapsInfo(LightmapData[] lightmapsData) {
        // 这里会自动初始化所有内容
    }
}

public class Person {
    public string Name;
    public int Age;

    // Constructor
    public Person(string name, int age) {
        Name = name;
        Age = age;
    }
}

public LightmapsInfo(LightmapData[] lightmapsData){
    if(lightmapsData == null) {
        // 做一些容错处理
    }
    // 其他初始化内容
}

Dictionary<string, Texture2D> myDict = new Dictionary<string, Texture2D>();
myDict["MainLight"] = mainLightTex;
Texture2D tex = myDict["MainLight"];

//data 代表实例
foreach (var data in lightmapsData) {
    var texture = data.lightmapColor;
    path = AssetDatabase.GetAssetPath(texture);
    lightmapsInfo.Add(path, texture);
}

int[] numbers = { 1, 2, 3, 4, 5 };
foreach (int num in numbers){
    Debug.Log(num); // 输出:1, 2, 3, 4, 5
}

public enum BufferType {
    MainLight,  // 主光光照:BufferA
    SkyLight,   // 天光光照:BufferB
    EmissionGI, // 自发光 GI: BufferC
    Lightmap    // 最终合成
}

// 分别为不同类型的光照创建缓存
private Texture2D[] _bufferA;   // 主光
private Texture2D[] _bufferB;   // 天光
private Texture2D[] _bufferC;   // 自发光
private Texture2D[] _lightmap;  // 最终合成

if (type == BufferType.Lightmap) return;
// 清理缓存
ClearBuffer(type);
// 创建缓存并从 info 复制纹理
var lightmapsCount = info.lightmapsCount;
var buffer = new Texture2D[lightmapsCount];
for (var i = 0; i < lightmapsCount; i++) {
    var lightmap = info.lightmapsInfo.Values.ElementAt(i);
    buffer[i] = new Texture2D(lightmap.width, lightmap.height, lightmap.format, false);
    Graphics.CopyTexture(lightmap, 0, 0, buffer[i], 0, 0);
}

for (var x = 0; x < width; x++) {
    for (var y = 0; y < height; y++) {
        var colA = _bufferA[i].GetPixel(x, y);
        var colB = _bufferB[i].GetPixel(x, y);
        var colC = _bufferC[i].GetPixel(x, y);
        var newCol = new Color(colA.r, colB.g, colC.b, 1.0f);
        lightmap.SetPixel(x, y, newCol.linear);
    }
}

for (var i = 0; i < lightmapsCount; i++) {
    var bytes = _lightmap[i].EncodeToEXR(Texture2D.EXRFlags.CompressZIP);
    File.WriteAllBytes(lightmapsInfo.Keys.ElementAt(i), bytes);
    AssetDatabase.Refresh();
}

RenderSettings.ambientMode = AmbientMode.Skybox;
RenderSettings.ambientIntensity = 1.0f;

var staticFlags = StaticEditorFlags.ContributeGI | StaticEditorFlags.ReflectionProbeStatic;
GameObjectUtility.SetStaticEditorFlags(mainlight.gameObject, staticFlags);

public void Bake(BakeMode mode) {
    Lightmapping.Clear();
    Lightmapping.Bake();
}

private void BakeReflectProbe() {
    var allProbe = FindObjectsOfType<ReflectionProbe>();
    foreach (var probe in allProbe) {
        var path = AssetDatabase.GetAssetPath(probe.texture);
        Lightmapping.BakeReflectionProbe(probe, path);
    }
    AssetDatabase.Refresh();
}

public class LightingControllerGUI : Editor
{
    public override void OnInspectorGUI()
    {
        var controller = target as LightingController;
        if (controller == null) return;
        DrawFunctionButtons(controller);
        DrawGlobalProperties(controller);
    }
}

if (GUILayout.Button("禁术·多重烘培"))
    controller.MultiBake();

EditorGUILayout.BeginHorizontal();
// 可以在这里添加更多按钮
EditorGUILayout.EndHorizontal();

EditorGUI.BeginChangeCheck();
_groupAToggle = EditorGUILayout.BeginFoldoutHeaderGroup(_groupAToggle, "材质属性");
if (_groupAToggle)
//等价于 if (groupAToggle == true)
{
    controller.metalDarken = EditorGUILayout.Slider(
        "金属压暗",
        controller.metalDarken,
        0.0f, 5.0f);
}
EditorGUILayout.EndFoldoutHeaderGroup();
if (EditorGUI.EndChangeCheck())
{
    controller.UpdateGlobalProperties();
    EditorUtility.SetDirty(controller);
}

public class EmissionShaderGUI : ShaderGUI
{
    // 具体实现见下方
}

var material = materialEditor.target as Material;

base.OnGUI(materialEditor, properties);

var ifEmissionGIOn = EditorGUILayout.Toggle(
    "开启自发光 GI",
    material.globalIlluminationFlags == MaterialGlobalIlluminationFlags.AnyEmissive);

material.globalIlluminationFlags = ifEmissionGIOn
    ? MaterialGlobalIlluminationFlags.AnyEmissive
    : MaterialGlobalIlluminationFlags.EmissiveIsBlack;

if (ifEmissionGIOn)
    material.globalIlluminationFlags = MaterialGlobalIlluminationFlags.AnyEmissive;
else
    material.globalIlluminationFlags = MaterialGlobalIlluminationFlags.EmissiveIsBlack;

float2 lmUV = v.uv1.xy * unity_LightmapST.xy + unity_LightmapST.zw;

//Building.Shader 的 MetaPass
Pass {
    Name "META"
    Tags { "LightMode" = "Meta" }
    CGPROGRAM
    #pragma vertex vert
    #pragma fragment frag
    #include "UnityCG.cginc"
    #include "UnityMetaPass.cginc"
    #pragma shader_feature __ _BAKE_MAINLIGHT _BAKE_SKYLIGHT _BAKE_EMISSIONGI

    struct VertexInput {
        float4 vertex   : POSITION;
        float2 uv0      : TEXCOORD0;
        float2 uv1      : TEXCOORD1;
        float2 uv2      : TEXCOORD2;
    };
    struct VertexOutput {
        float4 pos : SV_POSITION;
        float2 uv : TEXCOORD0;
    };
    VertexOutput vert (VertexInput v) {
        VertexOutput o = (VertexOutput)0;
        o.pos = UnityMetaVertexPosition(v.vertex, v.uv1, v.uv2, unity_LightmapST, unity_DynamicLightmapST);
        o.uv = v.uv0;
        return o;
    }
    float4 frag(VertexOutput i) : COLOR {
        UnityMetaInput metaIN;
        UNITY_INITIALIZE_OUTPUT(UnityMetaInput, metaIN);
        metaIN.Albedo = Luminance(tex2D(_MainTex, i.uv).rgb);
        metaIN.SpecularColor = 0.0f;
        metaIN.Emission = 0.0f;
        return UnityMetaFragment(metaIN);
    }
    ENDCG
}

//LightingController.cs
...
case BakeMode.Default:
// 关闭主光
mainlight.enabled = true;
// 设置环境
RenderSettings.ambientMode = AmbientMode.Skybox;
RenderSettings.ambientIntensity = 1.0f;
// 设置 Shader 全局分支
Shader.DisableKeyword("_BAKE_MAINLIGHT");
Shader.DisableKeyword("_BAKE_SKYLIGHT");
Shader.DisableKeyword("_BAKE_EMISSIONGI");
break;
...

#pragma shader_feature __ _BAKE_MAINLIGHT _BAKE_SKYLIGHT _BAKE_EMISSIONGI

#if defined (_BAKE_EMISSIONGI)
    metaIN.Emission = opacity;
#elif defined (_BAKE_MAINLIGHT) || defined (_BAKE_SKYLIGHT)
    metaIN.Emission = 0.0f;
#endif

Pass {
    Name "ShadowCaster"
    Tags { "LightMode" = "ShadowCaster" }
    ZWrite On ZTest LEqual Cull off
    CGPROGRAM
    #pragma vertex vert
    #pragma fragment frag
    #pragma multi_compile_shadowcaster
    #include "UnityCG.cginc"

    struct v2f {
        V2F_SHADOW_CASTER;
    };

    v2f vert(appdata_base v) {
        v2f o;
        TRANSFER_SHADOW_CASTER_NORMALOFFSET(o)
        return o;
    }

    float4 frag(v2f i) : SV_Target {
        SHADOW_CASTER_FRAGMENT(i)
    }
    ENDCG
}

TRANSFER_SHADOW_CASTER_NORMALOFFSET(o)
    float4 clipPos = UnityClipSpaceShadowCasterPos(v.vertex, v.normal); \
    o.pos = UnityApplyLinearShadowBias(clipPos); \
    o.vec = ComputeOffsetData(clipPos);