/* 
    UniversalRenderPipeline类的成员函数Render

    UniversalRenderPipeline类继承自UnityEngine.Rendering.RenderPipeline类，
    且UniversalRenderPipeline类是一个sealed类，所以它不能也不意图被继承派生
    
    UniversalRenderPipeline.Render函数重载了基类的同名函数

    UniversalRenderPipeline类有一部分定义在UniversalRenderPipeline.cs文件中，
    这个文件（7.1.1版本），通过Package Manager下载之后，其目录在：
    Library\PackageCache\com.unity.render-pipelines.universal@7.1.1\Runtime
*/
protected override void Render(ScriptableRenderContext renderContext, Camera[] cameras)
{
    // BeginFrameRendering是基类RenderPipeline的静态成员函数
    // 在开始使用camera进行渲染时，执行相关的回调
    BeginFrameRendering(renderContext, cameras);

    // 判断当前活跃的颜色空间，是否是线性颜色空间，如果是的话，光源也要使用线性亮度
    GraphicsSettings.lightsUseLinearIntensity = 
        (QualitySettings.activeColorSpace == ColorSpace.Linear);

    // 是否使用SRP Batcher进行合批处理
    GraphicsSettings.useScriptableRenderPipelineBatching = asset.useSRPBatcher;
    
    // 此方法是UniversalRenderPipeline类的提供的静态成员函数
    // 顾名思义，就是用来设置每一帧用到的shader constants，此函数也在
    // UniversalRenderPipeline.cs文件中定义
    SetupPerFrameShaderConstants();

    // SortCameras也是UniversalRenderPipeline类的成员方法，定义在
    // UniversalRenderPipelineCore.cs文件中。这个方法是把传递进来的camera，
    // 按其深度值进行排序，其深度值越大，离摄像机就越远，那就应该越早渲染，
    // 所以要把它排在摄像机数组的前面。
    SortCameras(cameras);
    
    // 针对每一个camera，执行该camera应该要执行的rendering操作
    foreach (Camera camera in cameras)
    {
        // BeginCameraRendering是基类RenderPipeline的静态成员函数
        // 在开始使用某一个camera进行渲染时，执行相关的回调
        BeginCameraRendering(renderContext, camera);

#if VISUAL_EFFECT_GRAPH_0_0_1_OR_NEWER
        // It should be called before culling to prepare material.
        // When there isn't any VisualEffect component, this method has no effect.
        // visual effect graph相关的，网址如下：
        // https://docs.unity3d.com/Packages/com.unity.visualeffectgraph@7.1/manual/index.html
        VFX.VFXManager.PrepareCamera(camera);
#endif
        // 此方法是UniversalRenderPipeline类的提供的静态成员函数
        // 使用某一个camera进行渲染
        RenderSingleCamera(renderContext, camera);

        // EndCameraRendering是基类RenderPipeline的静态成员函数
        // 在开始使用某一个camera进行渲染时，执行相关的回调
        EndCameraRendering(renderContext, camera);
    }

    // EndFrameRendering是基类RenderPipeline的静态成员函数
    // 在开始使用camera进行渲染时，执行相关的回调
    EndFrameRendering(renderContext, cameras);
}

void SortCameras(Camera[] cameras)
{
    Array.Sort(cameras, (lhs, rhs) => (int)(lhs.depth - rhs.depth));
}

public static void RenderSingleCamera(ScriptableRenderContext context, Camera camera)
{
    // 获取到和本摄像机有关的拣选相关的参数
    if (!camera.TryGetCullingParameters(IsStereoEnabled(camera),
                                 out var cullingParameters))
        return;

    var settings = asset;
    UniversalAdditionalCameraData additionalCameraData = null;

    if (camera.cameraType == CameraType.Game || 
                     camera.cameraType == CameraType.VR)
        camera.gameObject.TryGetComponent(out additionalCameraData);

    // InitializeCameraData函数是UniversalRenderPipeline类的静态成员函数。
    // 根据传递进来的各种参数最后返回一个CameraData类型变量，这个就是当前
    // 渲染使用的摄像机的各种数据
    InitializeCameraData(settings, camera, additionalCameraData, out var cameraData);

    // SetupPerCameraShaderConstants函数是UniversalRenderPipeline类的静态成员函数。
    // 根据当前的camera的数据属性，设置逐帧的着色器常量
    SetupPerCameraShaderConstants(cameraData);

    ScriptableRenderer renderer = (additionalCameraData != null) ? 
            additionalCameraData.scriptableRenderer : 
            settings.scriptableRenderer;

    if (renderer == null)
    {
        Debug.LogWarning(string.Format(
        "Trying to render {0} with an invalid renderer. Camera rendering will be skipped.",
        camera.name));
        return;
    }

    string tag = (asset.debugLevel >= PipelineDebugLevel.Profiling)
                            ? camera.name: k_RenderCameraTag;

    // 从command buffer 池中根据tag取得CommandBuffer对象
    CommandBuffer cmd = CommandBufferPool.Get(tag);
    
    using (new ProfilingSample(cmd, tag))
    {
        renderer.Clear();
        renderer.SetupCullingParameters(
                    ref cullingParameters, ref cameraData);

        context.ExecuteCommandBuffer(cmd);
        cmd.Clear();

#if UNITY_EDITOR

        // Emit scene view UI
        if (cameraData.isSceneViewCamera)
            ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
#endif

        var cullResults = context.Cull(ref cullingParameters);
        InitializeRenderingData(settings, ref cameraData,
                        ref cullResults, out var renderingData);

        renderer.Setup(context, ref renderingData);
        renderer.Execute(context, ref renderingData);
    }

    context.ExecuteCommandBuffer(cmd);
    CommandBufferPool.Release(cmd);
    context.Submit();
}