Unity手动计算球谐光照参数

uinty的lightprobes封装是以场景为单位的，如果想要自己加载，就比较麻烦了。研究了几天，给出一个粗略的自己计算球谐光照参数的过程。还比较粗略，如果想在产品中使用基于这个粗略的计算逐步细化就行了。

计算流程如下：

1、遍历场景内所有的需要参与球谐的光源，根据光源和目标的位置，计算光照方向（点光源是连线，方向光是forward)

2、在目标位置，在球上均匀取点，或者随机取点（蒙特卡洛方法），均匀的感觉效率更好些，结果也更稳定。因为这里是计算光源的球谐，又不是计算cubemap的，所以可以不用按照积分的方式取，应该还有更好的取点方法，还可以再想想。

3、计算每个点的光照颜色情况，直接法线方向（即第二部取出来的方向），点乘光照方向,再大概计算一个衰减(如果是点光源），算出这个点的颜色（后者说球面颜色)

4、使用球谐参数，计算出各个颜色9阶的系数

5、在shader中使用这些参数，shar,shab,shag,shbr等

计算出的效果如下

，和unity的球谐结果接近。

关于第四步，球谐参数计算，就是让德勒多项式的系数，将光照信息从球坐标的空间域，转换到l,m组成的频域，然后取低频的几个信号。

关于这个空间域转频域，很多用途的，除了可以计算这个球谐光照，还可以预计算固定场景或者模型的光照遮蔽等信息，可以配合天空盒的球谐，完成预计算环境光的全局光照。大概做法就是给环境光的信息和场景的空间信息都使用球谐预计算，然后再在运行时还原这个信息。

粘贴下部分的代码（基于网上一个cubemap转球谐的代码改的),主要是参数它都列好了，哈哈哈：

public class SphericalHarmonicsBasis
{
    public static float Y0(Vector3 v)
    {
        return 0.2820947917f;
    }

    public static float Y1(Vector3 v)
    {
        return 0.4886025119f * v.y;
    }

    public static float Y2(Vector3 v)
    {
        return 0.4886025119f * v.z;
    }

    public static float Y3(Vector3 v)
    {
        return 0.4886025119f * v.x;
    }

    public static float Y4(Vector3 v)
    {
        return 1.0925484306f * v.x * v.y;
    }

    public static float Y5(Vector3 v)
    {
        return 1.0925484306f * v.y * v.z;
    }

    public static float Y6(Vector3 v)
    {
        return 0.3153915652f * (3.0f * v.z * v.z - 1.0f);
    }

    public static float Y7(Vector3 v)
    {
        return 1.0925484306f * v.x * v.z;
    }

    public static float Y8(Vector3 v)
    {
        return 0.5462742153f * (v.x * v.x - v.y * v.y);
    }

    public static SH_Base[] Eval = { Y0, Y1, Y2, Y3, Y4, Y5, Y6, Y7, Y8 };
}

public static bool CPU_Project_Uniform_9Coeff_With_Lights(List<Light> input, Vector4[] output)
    {
        int sample_count = 49;
        if (output.Length != 9)
        {
            Debug.LogWarning("output size must be 9 for 9 coefficients");
            return false;
        }
        for (int c = 0; c < 9; ++c)
        {
            foreach (Light light in input)
            {
                for (int s = 0; s < sample_count; ++s)
                {
                    Vector3 dir = Random.onUnitSphere; //球面随机采样

                    //试试均匀分布，根据s，分别再thet和fai上取值
                    int a = s % 7;
                    int b = Mathf.CeilToInt(s / 7);
                    float fai = a/7f * Mathf.PI * 2;
                    float thet = -Mathf.Acos(b / 7f * 2 - 1);
                    dir = new Vector3(Mathf.Sin(thet) * Mathf.Cos(fai), Mathf.Cos(thet), Mathf.Sin(thet) * Mathf.Sin(fai));
                    Debug.Log(s);
                    Debug.Log(dir);
                    //Debug.DrawLine(Vector3.zero, dir);
                    //read the radiance texel
                    float value = Mathf.Max(Vector3.Dot(light.gameObject.transform.position.normalized, dir.normalized), 0);
                    if(light.type == LightType.Directional)
                    {
                        value = Mathf.Max(Vector3.Dot(-light.transform.forward, dir.normalized), 0); 
                    }
                    if(light.type == LightType.Point)
                    {
                        //如果的hi点光源，则根据距离衰减

                    }
                    Color radiance = light.color*value;

                    //compute shperical harmonic
                    float sh = SphericalHarmonicsBasis.Eval[c](dir);

                    output[c].x += radiance.r * sh;
                    output[c].y += radiance.g * sh;
                    output[c].z += radiance.b * sh;
                    output[c].w += radiance.a * sh;
                }
            }
            output[c].x = output[c].x * 4.0f * Mathf.PI / (float)(sample_count * input.Count);
            output[c].y = output[c].y * 4.0f * Mathf.PI / (float)(sample_count * input.Count);
            output[c].z = output[c].z * 4.0f * Mathf.PI / (float)(sample_count * input.Count);
            output[c].w = output[c].w * 4.0f * Mathf.PI / (float)(sample_count * input.Count);
        }

        return true;
    }

 

Shader "SH/CoeffVisualizer"
{
    Properties
    {
        _Mode("Mode", Range(0, 1)) = 0
    }

    SubShader
    {
        Tags{ "Queue" = "Background" "RenderType" = "Background" "PreviewType" = "Skybox" }
        Cull Back ZWrite Off

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma target 2.0

            #include "UnityCG.cginc"

            struct appdata_t 
            {
                float4 vertex : POSITION;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct v2f 
            {
                float4 vertex : SV_POSITION;
                float3 texcoord : TEXCOORD0;
                UNITY_VERTEX_OUTPUT_STEREO
            };

            float4 c0;
            float4 c1;
            float4 c2;
            float4 c3;
            float4 c4;
            float4 c5;
            float4 c6;
            float4 c7;
            float4 c8;

            samplerCUBE input;
            float _Mode;

            float Y0(float3 v)
            {
                return 0.2820947917f;
            }

            float Y1(float3 v)
            {
                return 0.4886025119f * v.y;
            }

            float Y2(float3 v)
            {
                return 0.4886025119f * v.z;
            }

            float Y3(float3 v)
            {
                return 0.4886025119f * v.x;
            }

            float Y4(float3 v)
            {
                return 1.0925484306f * v.x * v.y;
            }

            float Y5(float3 v)
            {
                return 1.0925484306f * v.y * v.z;
            }

            float Y6(float3 v)
            {
                return 0.3153915652f * (3.0f * v.z * v.z - 1.0f);
            }

            float Y7(float3 v)
            {
                return 1.0925484306f * v.x * v.z;
            }

            float Y8(float3 v)
            {
                return 0.5462742153f * (v.x * v.x - v.y * v.y);
            }

            v2f vert(appdata_t v)
            {
                v2f o;
                UNITY_SETUP_INSTANCE_ID(v);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.texcoord = v.vertex.xyz;
                return o;
            }

            fixed4 frag(v2f i) : SV_Target
            {
                float3 v = i.texcoord.xyz;
                float4 original = texCUBE(input, i.texcoord);
                float4 approx = c0 * Y0(v) + c1 * Y1(v) + c2 * Y2(v) + c3 * Y3(v) + c4 * Y4(v) + c5 * Y5(v) + c6 * Y6(v) + c7 * Y7(v) + c8 * Y8(v);
                return lerp(original, approx, _Mode);
            }
            ENDCG
        }
    }
    
    Fallback Off
}
这里参数是以c1-c9直接传给shader的，而unity里是按照shar,sharb,这种方式。shar的rgba，其实就是c0-c3的r项，其它地方应该差不多，没有具体测试。

unity中的lightprobes，是以4面体的方式存储的，如果想模拟它的效果，可能还得考虑下，在空间中预计算出很多点，然后存储成某种格式，方便运行时查找某个点位于哪个四面体内，并快速的查询和进行插值。这个之后再研究研究

 

参考连接：

https://en.wikipedia.org/wiki/Table_of_spherical_harmonics

https://huailiang.github.io/blog/2019/harmonics/

https://blog.csdn.net/qq_33999892/article/details/83862583