蛋求疼
蛋求疼

UE4渲染模块分析

UE4的渲染模块是一个独立的模块，这篇文章从该模块的设计理念和思路进行剖析。 通常渲染模块由如下几个部分组成:

  • 场景的描述
  • 场景遍历和拣选
  • 渲染的执行

场景的描述

UE4场景管理相关的数据结构如下:

  • FScene 场景类
  • FPrimitiveSceneProxy 场景里的几何体类
  • FPrimitiveSceneInfo 场景里的结点(拥有几何体和状态信息)

每个几何体具有材质属性，相关的数据结构如下：

  • FMaterial 材质接口类，提供材质属性的查询(eg. blend mode)和shader查找。
  • FMaterialResoruce UMaterial实现的具体的FMaterial
  • FMaterialRenderProxy 渲染线程用的Material对象，提供FMaterial的访问和材质参数的访问(eg. scaler, vector, texture parameter等参数)。

场景的遍历和拣选

在简单的3D渲染引擎中，通常的做法是：遍历场景结点，根据视景体进行判断该结点是否可见，如果可见则保存到渲染队列中，否则忽略之。最后对渲染队列中的结点进行按材质排序，然后绘制它们。

在UE4中，使用了不同于上面的方式进行处理，它对几何体进行分类处理(Static Primitive和Dynamic Primitive)。

  1. Static Render Path
    在FScene对象中存在一些static draw list,在PrimitiveSceneProxy被插入场景中时，会通过调用FPrimitveSceneProxy::DrawStaticElements()来收集FStaticMeshElements数据。 然后创建相应的drawing policy对象实例放入到draw list中去。这个drawing policy对象是按照材质排序放入到draw list中的。

  2. Dynamic Render Path
    对于动态渲染路径，InitViews在判定某个PrimitiveScenceProxy是可见后，通过传入TDynamicPrimitiveDrawer对象调用FPrimitiveSceneProxy::DrawDynamicElements()来收集FMeshElements,供以后的渲染使用。

上面的两种渲染路径并不冲突，一个FPrimitiveSceneProxy可以实现DrawStaticElements（）和DrawDynamicElements()来同时支持它们，也就是说这个SceneProxy既有Static FMeshElements又有Dynamic FMeshElements。

可见性判定####

参考代码:

bool FDeferredShadingSceneRenderer::InitViews(FRHICommandListImmediate& RHICmdList, struct FILCUpdatePrimTaskData& ILCTaskData, FGraphEventArray& SortEvents)

void FSceneRenderer::ComputeViewVisibility(FRHICommandListImmediate& RHICmdList)

template
static int32 FrustumCull(const FScene* Scene, FViewInfo& View)

void FSceneRenderer::GatherDynamicMeshElements(
    TArray& InViews, 
    const FScene* InScene, 
    const FSceneViewFamily& InViewFamily, 
    const FPrimitiveViewMasks& HasDynamicMeshElementsMasks, 
    const FPrimitiveViewMasks& HasDynamicEditorMeshElementsMasks, 
    FMeshElementCollector& Collector)

重要数据结构:

  • FViewInfo
    针对每个ViewPort分配一个FViewInfo对象，这个用于存放裁剪后的几何体可见性。

渲染的执行

对于简单的渲染引擎，只会简单地对可见的几何体执行渲染(设置渲染状态、GPU Shader和参数、发射Draw指令)，而UE4的渲染比较复杂，进行多pass绘制，下面列出它的各个pass顺序并逐一介绍.

  1. PASS_0: PrePass/Depth Only Pass
bool FDeferredShadingSceneRenderer::RenderPrePassView(FRHICommandList& RHICmdList, const FViewInfo& View)

bool RenderPrePassViewDynamic(FRHICommandList& RHICmdList, const FViewInfo& View, const FDrawingPolicyRenderState& DrawRenderState);

该pass使用FDepthDrawingPolicy策略进行绘制，只绘制depth到Depth-Buffer，这个有利于减少后面的Base pass中的pixel填充，节省pixel-shader的执行。
下面分析一下RenderPrePassViewDynamic()，验证上述的Dynamic Render Path的机制。

bool FDeferredShadingSceneRenderer::RenderPrePassViewDynamic(FRHICommandList& RHICmdList, const FViewInfo& View, const FDrawingPolicyRenderState& DrawRenderState)
{
    FDepthDrawingPolicyFactory::ContextType Context(EarlyZPassMode, true);

    for (int32 MeshBatchIndex = 0; MeshBatchIndex < View.DynamicMeshElements.Num(); MeshBatchIndex++)
    {
        const FMeshBatchAndRelevance& MeshBatchAndRelevance = View.DynamicMeshElements[MeshBatchIndex];

        if (MeshBatchAndRelevance.GetHasOpaqueOrMaskedMaterial() && MeshBatchAndRelevance.GetRenderInMainPass())
        {
            const FMeshBatch& MeshBatch = *MeshBatchAndRelevance.Mesh;
            const FPrimitiveSceneProxy* PrimitiveSceneProxy = MeshBatchAndRelevance.PrimitiveSceneProxy;
            bool bShouldUseAsOccluder = true;

            if (EarlyZPassMode < DDM_AllOccluders)
            {
                extern float GMinScreenRadiusForDepthPrepass;
                //@todo - move these proxy properties into FMeshBatchAndRelevance so we don't have to dereference the proxy in order to reject a mesh
                const float LODFactorDistanceSquared = (PrimitiveSceneProxy->GetBounds().Origin - View.ViewMatrices.GetViewOrigin()).SizeSquared() * FMath::Square(View.LODDistanceFactor);

                // Only render primitives marked as occluders
                bShouldUseAsOccluder = PrimitiveSceneProxy->ShouldUseAsOccluder()
                    // Only render static objects unless movable are requested
                    && (!PrimitiveSceneProxy->IsMovable() || bEarlyZPassMovable)
                    && (FMath::Square(PrimitiveSceneProxy->GetBounds().SphereRadius) > GMinScreenRadiusForDepthPrepass * GMinScreenRadiusForDepthPrepass * LODFactorDistanceSquared);
            }

            if (bShouldUseAsOccluder)
            {
                FDepthDrawingPolicyFactory::DrawDynamicMesh(RHICmdList, View, Context, MeshBatch, true, DrawRenderState, PrimitiveSceneProxy, MeshBatch.BatchHitProxyId, View.IsInstancedStereoPass());
            }
        }
    }

    return true;
}

bool FDepthDrawingPolicyFactory::DrawDynamicMesh(
    FRHICommandList& RHICmdList, 
    const FViewInfo& View,
    ContextType DrawingContext,
    const FMeshBatch& Mesh,
    bool bPreFog,
    const FDrawingPolicyRenderState& DrawRenderState,
    const FPrimitiveSceneProxy* PrimitiveSceneProxy,
    FHitProxyId HitProxyId, 
    const bool bIsInstancedStereo, 
    const bool bIsInstancedStereoEmulated
    )
{
    FScopedStrictGraphicsPipelineStateUse UsePSOOnly(RHICmdList);

    return DrawMesh(
        RHICmdList, 
        View,
        DrawingContext,
        Mesh,
        Mesh.Elements.Num()==1 ? 1 : (1<
bool FDepthDrawingPolicyFactory::DrawMesh(
    FRHICommandList& RHICmdList, 
    const FViewInfo& View,
    ContextType DrawingContext,
    const FMeshBatch& Mesh,
    const uint64& BatchElementMask,
    const FDrawingPolicyRenderState& DrawRenderState,
    bool bPreFog,
    const FPrimitiveSceneProxy* PrimitiveSceneProxy,
    FHitProxyId HitProxyId, 
    const bool bIsInstancedStereo, 
    const bool bIsInstancedStereoEmulated
    )
{
    bool bDirty = false;

    //Do a per-FMeshBatch check on top of the proxy check in RenderPrePass to handle the case where a proxy that is relevant 
    //to the depth only pass has to submit multiple FMeshElements but only some of them should be used as occluders.
    if (Mesh.bUseAsOccluder || !DrawingContext.bRespectUseAsOccluderFlag || DrawingContext.DepthDrawingMode == DDM_AllOpaque)
    {
        const FMaterialRenderProxy* MaterialRenderProxy = Mesh.MaterialRenderProxy;
        const FMaterial* Material = MaterialRenderProxy->GetMaterial(View.GetFeatureLevel());
        const EBlendMode BlendMode = Material->GetBlendMode();
        const bool bUsesMobileColorValue = (DrawingContext.MobileColorValue != 0.0f);

        // Check to see if the primitive is currently fading in or out using the screen door effect.  If it is,
        // then we can't assume the object is opaque as it may be forcibly masked.
        const FSceneViewState* SceneViewState = static_cast( View.State );

        FMeshDrawingPolicyOverrideSettings OverrideSettings = ComputeMeshOverrideSettings(Mesh);
        OverrideSettings.MeshOverrideFlags |= Material->IsTwoSided() ? EDrawingPolicyOverrideFlags::TwoSided : EDrawingPolicyOverrideFlags::None;

        if ( BlendMode == BLEND_Opaque 
            && Mesh.VertexFactory->SupportsPositionOnlyStream() 
            && !Material->MaterialModifiesMeshPosition_RenderThread()
            && Material->WritesEveryPixel()
            && !bUsesMobileColorValue
            )
        {
            //render opaque primitives that support a separate position-only vertex buffer
            const FMaterialRenderProxy* DefaultProxy = UMaterial::GetDefaultMaterial(MD_Surface)->GetRenderProxy(false);

            OverrideSettings.MeshOverrideFlags |= Material->IsWireframe() ? EDrawingPolicyOverrideFlags::Wireframe : EDrawingPolicyOverrideFlags::None;

            // 临时对象 DrawingPolicy.
            FPositionOnlyDepthDrawingPolicy DrawingPolicy(
                Mesh.VertexFactory, 
                DefaultProxy, 
                *DefaultProxy->GetMaterial(View.GetFeatureLevel()), 
                OverrideSettings
                );

            FDrawingPolicyRenderState DrawRenderStateLocal(&RHICmdList, DrawRenderState);
            DrawingPolicy.SetSharedState(RHICmdList, &View, FPositionOnlyDepthDrawingPolicy::ContextDataType(bIsInstancedStereo, bIsInstancedStereoEmulated), DrawRenderStateLocal);

            int32 BatchElementIndex = 0;
            uint64 Mask = BatchElementMask;
            do
            {
                if(Mask & 1)
                {
                    // We draw instanced static meshes twice when rendering with instanced stereo. Once for each eye.
                    const bool bIsInstancedMesh = Mesh.Elements[BatchElementIndex].bIsInstancedMesh;
                    const uint32 InstancedStereoDrawCount = (bIsInstancedStereo && bIsInstancedMesh) ? 2 : 1;
                    for (uint32 DrawCountIter = 0; DrawCountIter < InstancedStereoDrawCount; ++DrawCountIter)
                    {
                        DrawingPolicy.SetInstancedEyeIndex(RHICmdList, DrawCountIter);

                        TDrawEvent MeshEvent;
                        BeginMeshDrawEvent(RHICmdList, PrimitiveSceneProxy, Mesh, MeshEvent);

                        DrawingPolicy.SetMeshRenderState(RHICmdList, View, PrimitiveSceneProxy, Mesh, BatchElementIndex, DrawRenderStateLocal, FPositionOnlyDepthDrawingPolicy::ElementDataType(), FPositionOnlyDepthDrawingPolicy::ContextDataType());
                        DrawingPolicy.DrawMesh(RHICmdList, Mesh, BatchElementIndex, bIsInstancedStereo);
                    }
                }
                Mask >>= 1;
                BatchElementIndex++;
            } while(Mask);

            bDirty = true;
        }
        else if (!IsTranslucentBlendMode(BlendMode) || Material->IsTranslucencyWritingCustomDepth())
        {
            const bool bMaterialMasked = !Material->WritesEveryPixel() || Material->IsTranslucencyWritingCustomDepth();

            bool bDraw = true;

            switch(DrawingContext.DepthDrawingMode)
            {
            case DDM_AllOpaque:
                break;
            case DDM_AllOccluders: 
                break;
            case DDM_NonMaskedOnly: 
                bDraw = !bMaterialMasked;
                break;
            default:
                check(!"Unrecognized DepthDrawingMode");
            }

            if(bDraw)
            {
                if (!bMaterialMasked && !Material->MaterialModifiesMeshPosition_RenderThread())
                {
                    // Override with the default material for opaque materials that are not two sided
                    MaterialRenderProxy = UMaterial::GetDefaultMaterial(MD_Surface)->GetRenderProxy(false);
                }

                FDepthDrawingPolicy DrawingPolicy(
                    Mesh.VertexFactory, 
                    MaterialRenderProxy, 
                    *MaterialRenderProxy->GetMaterial(View.GetFeatureLevel()), 
                    OverrideSettings,
                    View.GetFeatureLevel(),
                    DrawingContext.MobileColorValue
                    );

                FDrawingPolicyRenderState DrawRenderStateLocal(&RHICmdList, DrawRenderState);
                DrawingPolicy.SetSharedState(RHICmdList, &View, FDepthDrawingPolicy::ContextDataType(bIsInstancedStereo, bIsInstancedStereoEmulated), DrawRenderStateLocal);

                int32 BatchElementIndex = 0;
                uint64 Mask = BatchElementMask;
                do
                {
                    if(Mask & 1)
                    {
                        // We draw instanced static meshes twice when rendering with instanced stereo. Once for each eye.
                        const bool bIsInstancedMesh = Mesh.Elements[BatchElementIndex].bIsInstancedMesh;
                        const uint32 InstancedStereoDrawCount = (bIsInstancedStereo && bIsInstancedMesh) ? 2 : 1;
                        for (uint32 DrawCountIter = 0; DrawCountIter < InstancedStereoDrawCount; ++DrawCountIter)
                        {
                            DrawingPolicy.SetInstancedEyeIndex(RHICmdList, DrawCountIter);

                            TDrawEvent MeshEvent;
                            BeginMeshDrawEvent(RHICmdList, PrimitiveSceneProxy, Mesh, MeshEvent);

                            DrawingPolicy.SetMeshRenderState(RHICmdList, View, PrimitiveSceneProxy, Mesh, BatchElementIndex, DrawRenderStateLocal, FMeshDrawingPolicy::ElementDataType(), FDepthDrawingPolicy::ContextDataType());
                            DrawingPolicy.DrawMesh(RHICmdList, Mesh, BatchElementIndex, bIsInstancedStereo);
                        }
                    }
                    Mask >>= 1;
                    BatchElementIndex++;
                } while(Mask);

                bDirty = true;
            }
        }
    }

    return bDirty;
}
  1. PASS_1: Base pass
    该pass绘制不透明的和masked material的属性的几何体，输入材质属性到G-Buffer; 同时计算Lightmap和sky lighting的贡献量到scene color buffer中。下面罗列出相关函数。
/**
 * Renders the scene's base pass 
 * @return true if anything was rendered
 */
bool FDeferredShadingSceneRenderer::RenderBasePass(FRHICommandListImmediate& RHICmdList)

bool FDeferredShadingSceneRenderer::RenderBasePassView(FRHICommandListImmediate& RHICmdList, FViewInfo& View)
{
    bool bDirty = false; 
    FDrawingPolicyRenderState DrawRenderState(&RHICmdList, View);
    SetupBasePassView(RHICmdList, View, DrawRenderState, ViewFamily.EngineShowFlags.ShaderComplexity);
    
    // 绘制静态几何体
    bDirty |= RenderBasePassStaticData(RHICmdList, View, DrawRenderState);
    // 绘制动态几何体
    RenderBasePassDynamicData(RHICmdList, View, DrawRenderState, bDirty);

    return bDirty;
}

bool FBasePassOpaqueDrawingPolicyFactory::DrawDynamicMesh(
    FRHICommandList& RHICmdList, 
    const FViewInfo& View,
    ContextType DrawingContext,
    const FMeshBatch& Mesh,
    bool bPreFog,
    const FDrawingPolicyRenderState& DrawRenderState,
    const FPrimitiveSceneProxy* PrimitiveSceneProxy,
    FHitProxyId HitProxyId, 
    const bool bIsInstancedStereo
    );

        // 使用临时对象DrawingPolicy
        TBasePassDrawingPolicy DrawingPolicy(
            Parameters.Mesh.VertexFactory,
            Parameters.Mesh.MaterialRenderProxy,
            *Parameters.Material,
            Parameters.FeatureLevel,
            LightMapPolicy,
            Parameters.BlendMode,
            Parameters.TextureMode,
            bRenderSkylight,
            bRenderAtmosphericFog,
            ComputeMeshOverrideSettings(Parameters.Mesh),
            View.Family->GetDebugViewShaderMode(),
            Parameters.bEditorCompositeDepthTest,
            bEnableReceiveDecalOutput
            );
  1. PASS_2: Issue Occlusion Queries / BeginOcclusionTests
    执行遮挡查询，在绘制下一帧时，InitView会使用这些信息进行可见性判断。遮挡查询的原理是通过绘制几何体的包围盒进行z-depth测试，以粗略地判断该几何体是否被遮挡。
void FDeferredShadingSceneRenderer::RenderOcclusion(FRHICommandListImmediate& RHICmdList, bool bRenderQueries, bool bRenderHZB)
  1. PASS_3: ShadowMap(阴影计算)
    针对每个光源渲染相应的Shadowmap, 光源也被累积到translucency lighting volumes中(这块不明白，理解估计有误)。
void FSceneRenderer::RenderShadowDepthMaps(FRHICommandListImmediate& RHICmdList);
void FSceneRenderer::RenderShadowDepthMapAtlases(FRHICommandListImmediate& RHICmdList);

具体实现

void FSceneRenderer::RenderShadowDepthMaps(FRHICommandListImmediate& RHICmdList)
{
    FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(RHICmdList);

    SCOPED_DRAW_EVENT(RHICmdList, ShadowDepths);
    SCOPED_GPU_STAT(RHICmdList, Stat_GPU_ShadowDepths);

    FSceneRenderer::RenderShadowDepthMapAtlases(RHICmdList);

    for (int32 CubemapIndex = 0; CubemapIndex < SortedShadowsForShadowDepthPass.ShadowMapCubemaps.Num(); CubemapIndex++)
    {
        const FSortedShadowMapAtlas& ShadowMap = SortedShadowsForShadowDepthPass.ShadowMapCubemaps[CubemapIndex];
        FSceneRenderTargetItem& RenderTarget = ShadowMap.RenderTargets.DepthTarget->GetRenderTargetItem();
        FIntPoint TargetSize = ShadowMap.RenderTargets.DepthTarget->GetDesc().Extent;

        check(ShadowMap.Shadows.Num() == 1);
        FProjectedShadowInfo* ProjectedShadowInfo = ShadowMap.Shadows[0];

        GRenderTargetPool.VisualizeTexture.SetCheckPoint(RHICmdList, ShadowMap.RenderTargets.DepthTarget.GetReference());

        FString LightNameWithLevel;
        GetLightNameForDrawEvent(ProjectedShadowInfo->GetLightSceneInfo().Proxy, LightNameWithLevel);
        SCOPED_DRAW_EVENTF(RHICmdList, EventShadowDepths, TEXT("Cubemap %s %u^2"), *LightNameWithLevel, TargetSize.X, TargetSize.Y);

        auto SetShadowRenderTargets = [this, &RenderTarget, &SceneContext](FRHICommandList& InRHICmdList, bool bPerformClear)
        {
            FRHISetRenderTargetsInfo Info(0, nullptr, FRHIDepthRenderTargetView(RenderTarget.TargetableTexture, 
                bPerformClear ? ERenderTargetLoadAction::EClear : ERenderTargetLoadAction::ELoad, 
                ERenderTargetStoreAction::EStore, 
                ERenderTargetLoadAction::ELoad, 
                ERenderTargetStoreAction::EStore));

            check(Info.DepthStencilRenderTarget.Texture->GetDepthClearValue() == 1.0f); 
            Info.ColorRenderTarget[0].StoreAction = ERenderTargetStoreAction::ENoAction;

            if (!GSupportsDepthRenderTargetWithoutColorRenderTarget)
            {
                Info.NumColorRenderTargets = 1;
                Info.ColorRenderTarget[0].Texture = SceneContext.GetOptionalShadowDepthColorSurface(InRHICmdList, Info.DepthStencilRenderTarget.Texture->GetTexture2D()->GetSizeX(), Info.DepthStencilRenderTarget.Texture->GetTexture2D()->GetSizeY());
                InRHICmdList.TransitionResource(EResourceTransitionAccess::EWritable, Info.ColorRenderTarget[0].Texture);
            }
            InRHICmdList.TransitionResource(EResourceTransitionAccess::EWritable, Info.DepthStencilRenderTarget.Texture);
            InRHICmdList.SetRenderTargetsAndClear(Info);
        };
            
        {
            bool bDoClear = true;

            if (ProjectedShadowInfo->CacheMode == SDCM_MovablePrimitivesOnly 
                && Scene->CachedShadowMaps.FindChecked(ProjectedShadowInfo->GetLightSceneInfo().Id).bCachedShadowMapHasPrimitives)
            {
                // Skip the clear when we'll copy from a cached shadowmap
                bDoClear = false;
            }

            SCOPED_CONDITIONAL_DRAW_EVENT(RHICmdList, Clear, bDoClear);
            SetShadowRenderTargets(RHICmdList, bDoClear);   
        }

        ProjectedShadowInfo->RenderDepth(RHICmdList, this, SetShadowRenderTargets, ShadowDepthRenderMode_Normal);

        RHICmdList.TransitionResource(EResourceTransitionAccess::EReadable, RenderTarget.TargetableTexture);
    }
            
    if (SortedShadowsForShadowDepthPass.PreshadowCache.Shadows.Num() > 0)
    {
        FSceneRenderTargetItem& RenderTarget = SortedShadowsForShadowDepthPass.PreshadowCache.RenderTargets.DepthTarget->GetRenderTargetItem();

        GRenderTargetPool.VisualizeTexture.SetCheckPoint(RHICmdList, SortedShadowsForShadowDepthPass.PreshadowCache.RenderTargets.DepthTarget.GetReference());

        SCOPED_DRAW_EVENT(RHICmdList, PreshadowCache);

        for (int32 ShadowIndex = 0; ShadowIndex < SortedShadowsForShadowDepthPass.PreshadowCache.Shadows.Num(); ShadowIndex++)
        {
            FProjectedShadowInfo* ProjectedShadowInfo = SortedShadowsForShadowDepthPass.PreshadowCache.Shadows[ShadowIndex];

            if (!ProjectedShadowInfo->bDepthsCached)
            {
                auto SetShadowRenderTargets = [this, ProjectedShadowInfo](FRHICommandList& InRHICmdList, bool bPerformClear)
                {
                    FTextureRHIParamRef PreShadowCacheDepthZ = Scene->PreShadowCacheDepthZ->GetRenderTargetItem().TargetableTexture.GetReference();
                    InRHICmdList.TransitionResources(EResourceTransitionAccess::EWritable, &PreShadowCacheDepthZ, 1);

                    // Must preserve existing contents as the clear will be scissored
                    SetRenderTarget(InRHICmdList, FTextureRHIRef(), PreShadowCacheDepthZ, ESimpleRenderTargetMode::EExistingColorAndDepth);
                    ProjectedShadowInfo->ClearDepth(InRHICmdList, this, 0, nullptr, PreShadowCacheDepthZ, bPerformClear);
                };

                SetShadowRenderTargets(RHICmdList, true);

                ProjectedShadowInfo->RenderDepth(RHICmdList, this, SetShadowRenderTargets, ShadowDepthRenderMode_Normal);
                ProjectedShadowInfo->bDepthsCached = true;
            }
        }

        RHICmdList.TransitionResource(EResourceTransitionAccess::EReadable, RenderTarget.TargetableTexture);
    }

    for (int32 AtlasIndex = 0; AtlasIndex < SortedShadowsForShadowDepthPass.TranslucencyShadowMapAtlases.Num(); AtlasIndex++)
    {
        const FSortedShadowMapAtlas& ShadowMapAtlas = SortedShadowsForShadowDepthPass.TranslucencyShadowMapAtlases[AtlasIndex];
        FIntPoint TargetSize = ShadowMapAtlas.RenderTargets.ColorTargets[0]->GetDesc().Extent;

        SCOPED_DRAW_EVENTF(RHICmdList, EventShadowDepths, TEXT("TranslucencyAtlas%u %u^2"), AtlasIndex, TargetSize.X, TargetSize.Y);

        FSceneRenderTargetItem ColorTarget0 = ShadowMapAtlas.RenderTargets.ColorTargets[0]->GetRenderTargetItem();
        FSceneRenderTargetItem ColorTarget1 = ShadowMapAtlas.RenderTargets.ColorTargets[1]->GetRenderTargetItem();

        FTextureRHIParamRef RenderTargetArray[2] =
        {
            ColorTarget0.TargetableTexture,
            ColorTarget1.TargetableTexture
        };
        SetRenderTargets(RHICmdList, ARRAY_COUNT(RenderTargetArray), RenderTargetArray, FTextureRHIParamRef(), 0, NULL, true);

        for (int32 ShadowIndex = 0; ShadowIndex < ShadowMapAtlas.Shadows.Num(); ShadowIndex++)
        {
            FProjectedShadowInfo* ProjectedShadowInfo = ShadowMapAtlas.Shadows[ShadowIndex];
            ProjectedShadowInfo->RenderTranslucencyDepths(RHICmdList, this);
        }

        RHICmdList.TransitionResource(EResourceTransitionAccess::EReadable, ColorTarget0.TargetableTexture);
        RHICmdList.TransitionResource(EResourceTransitionAccess::EReadable, ColorTarget1.TargetableTexture);
    }

    for (int32 AtlasIndex = 0; AtlasIndex < SortedShadowsForShadowDepthPass.RSMAtlases.Num(); AtlasIndex++)
    {
        const FSortedShadowMapAtlas& ShadowMapAtlas = SortedShadowsForShadowDepthPass.RSMAtlases[AtlasIndex];
        FSceneRenderTargetItem ColorTarget0 = ShadowMapAtlas.RenderTargets.ColorTargets[0]->GetRenderTargetItem();
        FSceneRenderTargetItem ColorTarget1 = ShadowMapAtlas.RenderTargets.ColorTargets[1]->GetRenderTargetItem();
        FSceneRenderTargetItem DepthTarget = ShadowMapAtlas.RenderTargets.DepthTarget->GetRenderTargetItem();
        FIntPoint TargetSize = ShadowMapAtlas.RenderTargets.DepthTarget->GetDesc().Extent;

        SCOPED_DRAW_EVENTF(RHICmdList, EventShadowDepths, TEXT("RSM%u %ux%u"), AtlasIndex, TargetSize.X, TargetSize.Y);

        for (int32 ShadowIndex = 0; ShadowIndex < ShadowMapAtlas.Shadows.Num(); ShadowIndex++)
        {
            FProjectedShadowInfo* ProjectedShadowInfo = ShadowMapAtlas.Shadows[ShadowIndex];

            FSceneViewState* ViewState = (FSceneViewState*)ProjectedShadowInfo->DependentView->State;
            FLightPropagationVolume* LightPropagationVolume = ViewState->GetLightPropagationVolume(FeatureLevel);
            
            // 计算 FLightPropagationVolume
            auto SetShadowRenderTargets = [this, LightPropagationVolume, ProjectedShadowInfo, &ColorTarget0, &ColorTarget1, &DepthTarget](FRHICommandList& InRHICmdList, bool bPerformClear)
            {
                FTextureRHIParamRef RenderTargets[2];
                RenderTargets[0] = ColorTarget0.TargetableTexture;
                RenderTargets[1] = ColorTarget1.TargetableTexture;

                // Hook up the geometry volume UAVs
                FUnorderedAccessViewRHIParamRef Uavs[4];
                Uavs[0] = LightPropagationVolume->GetGvListBufferUav();
                Uavs[1] = LightPropagationVolume->GetGvListHeadBufferUav();
                Uavs[2] = LightPropagationVolume->GetVplListBufferUav();
                Uavs[3] = LightPropagationVolume->GetVplListHeadBufferUav();
                    
                InRHICmdList.TransitionResources(EResourceTransitionAccess::ERWBarrier, EResourceTransitionPipeline::EGfxToGfx, Uavs, ARRAY_COUNT(Uavs));
                SetRenderTargets(InRHICmdList, ARRAY_COUNT(RenderTargets), RenderTargets, DepthTarget.TargetableTexture, ARRAY_COUNT(Uavs), Uavs);

                ProjectedShadowInfo->ClearDepth(InRHICmdList, this, ARRAY_COUNT(RenderTargets), RenderTargets, DepthTarget.TargetableTexture, bPerformClear);
            };                  

            {
                SCOPED_DRAW_EVENT(RHICmdList, Clear);
                SetShadowRenderTargets(RHICmdList, true);   
            }               

            LightPropagationVolume->SetVplInjectionConstants(*ProjectedShadowInfo, ProjectedShadowInfo->GetLightSceneInfo().Proxy);

            ProjectedShadowInfo->RenderDepth(RHICmdList, this, SetShadowRenderTargets, ShadowDepthRenderMode_Normal);

            // Render emissive only meshes as they are held in a separate list.
            ProjectedShadowInfo->RenderDepth(RHICmdList, this, SetShadowRenderTargets, ShadowDepthRenderMode_EmissiveOnly);
            // Render gi blocking volume meshes.
            ProjectedShadowInfo->RenderDepth(RHICmdList, this, SetShadowRenderTargets, ShadowDepthRenderMode_GIBlockingVolumes);

            {
                // Resolve the shadow depth z surface.
                RHICmdList.CopyToResolveTarget(DepthTarget.TargetableTexture, DepthTarget.ShaderResourceTexture, false, FResolveParams());
                RHICmdList.CopyToResolveTarget(ColorTarget0.TargetableTexture, ColorTarget0.ShaderResourceTexture, false, FResolveParams());
                RHICmdList.CopyToResolveTarget(ColorTarget1.TargetableTexture, ColorTarget1.ShaderResourceTexture, false, FResolveParams());

                FUnorderedAccessViewRHIParamRef UavsToReadable[2];
                UavsToReadable[0] = LightPropagationVolume->GetGvListBufferUav();
                UavsToReadable[1] = LightPropagationVolume->GetGvListHeadBufferUav();   
                RHICmdList.TransitionResources(EResourceTransitionAccess::EReadable, EResourceTransitionPipeline::EGfxToGfx, UavsToReadable, ARRAY_COUNT(UavsToReadable));

                // Unset render targets
                FTextureRHIParamRef RenderTargets[2] = {NULL};
                FUnorderedAccessViewRHIParamRef Uavs[2] = {NULL};
                SetRenderTargets(RHICmdList, ARRAY_COUNT(RenderTargets), RenderTargets, FTextureRHIParamRef(), ARRAY_COUNT(Uavs), Uavs);
            }
        }
    }
}
  1. PASS_4: Lighting(光照计算)
    分为如下子阶段:
  • Pre-lighting composition lighting stage
    预处理组合型光照(eg. deferred decals, SSAO)
  • Render lights
    光照计算

参考代码如下：

   // Pre-lighting composition lighting stage
   // e.g. deferred decals, SSAO
   if (FeatureLevel >= ERHIFeatureLevel::SM4)
   {
       SCOPE_CYCLE_COUNTER(STAT_FDeferredShadingSceneRenderer_AfterBasePass);

       GRenderTargetPool.AddPhaseEvent(TEXT("AfterBasePass"));

       for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
       {
           SCOPED_CONDITIONAL_DRAW_EVENTF(RHICmdList, EventView, Views.Num() > 1, TEXT("View%d"), ViewIndex);
           GCompositionLighting.ProcessAfterBasePass(RHICmdList, Views[ViewIndex]);
       }
       ServiceLocalQueue();
   }

   // TODO: Could entirely remove this by using STENCIL_SANDBOX_BIT in ShadowRendering.cpp and DistanceFieldSurfaceCacheLighting.cpp
   if (!IsForwardShadingEnabled(FeatureLevel))
   {
       SCOPED_DRAW_EVENT(RHICmdList, ClearStencilFromBasePass);

       FRHISetRenderTargetsInfo Info(0, NULL, FRHIDepthRenderTargetView(
           SceneContext.GetSceneDepthSurface(),
           ERenderTargetLoadAction::ENoAction,
           ERenderTargetStoreAction::ENoAction,
           ERenderTargetLoadAction::EClear,
           ERenderTargetStoreAction::EStore,
           FExclusiveDepthStencil::DepthNop_StencilWrite));

       // Clear stencil to 0 now that deferred decals are done using what was setup in the base pass
       // Shadow passes and other users of stencil assume it is cleared to 0 going in
       RHICmdList.SetRenderTargetsAndClear(Info);

       RHICmdList.TransitionResource(EResourceTransitionAccess::EReadable, SceneContext.GetSceneDepthSurface());
   }

   // Render lighting.
   if (ViewFamily.EngineShowFlags.Lighting
       && FeatureLevel >= ERHIFeatureLevel::SM4
       && ViewFamily.EngineShowFlags.DeferredLighting
       && bUseGBuffer)
   {
       SCOPE_CYCLE_COUNTER(STAT_FDeferredShadingSceneRenderer_Lighting);

       GRenderTargetPool.AddPhaseEvent(TEXT("Lighting"));

       // These modulate the scenecolor output from the basepass, which is assumed to be indirect lighting
       RenderIndirectCapsuleShadows(
           RHICmdList, 
           SceneContext.GetSceneColorSurface(), 
           SceneContext.bScreenSpaceAOIsValid ? SceneContext.ScreenSpaceAO->GetRenderTargetItem().TargetableTexture : NULL);

       TRefCountPtr DynamicBentNormalAO;
       // These modulate the scenecolor output from the basepass, which is assumed to be indirect lighting
       RenderDFAOAsIndirectShadowing(RHICmdList, VelocityRT, DynamicBentNormalAO);

       // Clear the translucent lighting volumes before we accumulate
       if ((GbEnableAsyncComputeTranslucencyLightingVolumeClear && GSupportsEfficientAsyncCompute) == false)
       {
           ClearTranslucentVolumeLighting(RHICmdList);
       }

       RHICmdList.SetCurrentStat(GET_STATID(STAT_CLM_Lighting));
       RenderLights(RHICmdList);
       RHICmdList.SetCurrentStat(GET_STATID(STAT_CLM_AfterLighting));
       ServiceLocalQueue();

       GRenderTargetPool.AddPhaseEvent(TEXT("AfterRenderLights"));

       InjectAmbientCubemapTranslucentVolumeLighting(RHICmdList);
       ServiceLocalQueue();

       // Filter the translucency lighting volume now that it is complete
       FilterTranslucentVolumeLighting(RHICmdList);
       ServiceLocalQueue();

       // Pre-lighting composition lighting stage
       // e.g. LPV indirect
       for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ++ViewIndex)
       {
           FViewInfo& View = Views[ViewIndex]; 

           if(IsLpvIndirectPassRequired(View))
           {
               SCOPED_CONDITIONAL_DRAW_EVENTF(RHICmdList, EventView,Views.Num() > 1, TEXT("View%d"), ViewIndex);

               GCompositionLighting.ProcessLpvIndirect(RHICmdList, View);
               ServiceLocalQueue();
           }
       }

       RenderDynamicSkyLighting(RHICmdList, VelocityRT, DynamicBentNormalAO);
       ServiceLocalQueue();

       // SSS need the SceneColor finalized as an SRV.
       SceneContext.FinishRenderingSceneColor(RHICmdList);

       // Render reflections that only operate on opaque pixels
       RenderDeferredReflections(RHICmdList, DynamicBentNormalAO, VelocityRT);
       ServiceLocalQueue();

       // Post-lighting composition lighting stage
       // e.g. ScreenSpaceSubsurfaceScattering
       for(int32 ViewIndex = 0; ViewIndex < Views.Num(); ++ViewIndex)
       {   
           SCOPED_CONDITIONAL_DRAW_EVENTF(RHICmdList, EventView,Views.Num() > 1, TEXT("View%d"), ViewIndex);
           GCompositionLighting.ProcessAfterLighting(RHICmdList, Views[ViewIndex]);
       }
       ServiceLocalQueue();
   }

   FLightShaftsOutput LightShaftOutput;

   // Draw Lightshafts
   if (ViewFamily.EngineShowFlags.LightShafts)
   {
       SCOPE_CYCLE_COUNTER(STAT_FDeferredShadingSceneRenderer_RenderLightShaftOcclusion);
       RenderLightShaftOcclusion(RHICmdList, LightShaftOutput);
       ServiceLocalQueue();
   }
  1. PASS_5: Draw atmosphere
    对非透明表面绘制大气效果.
    // Draw atmosphere
    if (ShouldRenderAtmosphere(ViewFamily))
    {
        SCOPE_CYCLE_COUNTER(STAT_FDeferredShadingSceneRenderer_RenderAtmosphere);
        if (Scene->AtmosphericFog)
        {
            // Update RenderFlag based on LightShaftTexture is valid or not
            if (LightShaftOutput.LightShaftOcclusion)
            {
                Scene->AtmosphericFog->RenderFlag &= EAtmosphereRenderFlag::E_LightShaftMask;
            }
            else
            {
                Scene->AtmosphericFog->RenderFlag |= EAtmosphereRenderFlag::E_DisableLightShaft;
            }
#if WITH_EDITOR
            if (Scene->bIsEditorScene)
            {
                // Precompute Atmospheric Textures
                Scene->AtmosphericFog->PrecomputeTextures(RHICmdList, Views.GetData(), &ViewFamily);
            }
#endif
            RenderAtmosphere(RHICmdList, LightShaftOutput);
            ServiceLocalQueue();
        }
    }

负责该效果函数

void FDeferredShadingSceneRenderer::RenderAtmosphere(FRHICommandListImmediate& RHICmdList, const FLightShaftsOutput& LightShaftsOutput)
  1. PASS_6： Draw Fog
    针对非透明表面逐像素就算Fog.
    // Draw fog.
    if (ShouldRenderFog(ViewFamily))
    {
        SCOPE_CYCLE_COUNTER(STAT_FDeferredShadingSceneRenderer_RenderFog);
        RenderFog(RHICmdList, LightShaftOutput);
        ServiceLocalQueue();
    }

bool FDeferredShadingSceneRenderer::RenderFog(FRHICommandListImmediate& RHICmdList, const FLightShaftsOutput& LightShaftsOutput)
  1. PASS_7: Draw translucency
    绘制半透明几何体.
    Translucency is accumulated into an offscreen render target where it has fogging applied per-vertex so it can integrate into the scene. Lit translucency computes final lighting in a single pass to blend correctly.
    // Draw translucency.
    if (ViewFamily.EngineShowFlags.Translucency)
    {
        SCOPE_CYCLE_COUNTER(STAT_TranslucencyDrawTime);

        RHICmdList.SetCurrentStat(GET_STATID(STAT_CLM_Translucency));
        RenderTranslucency(RHICmdList);
        ServiceLocalQueue();

        if(GetRefractionQuality(ViewFamily) > 0)
        {
            // To apply refraction effect by distorting the scene color.
            // After non separate translucency as that is considered at scene depth anyway
            // It allows skybox translucency (set to non separate translucency) to be refracted.
            RHICmdList.SetCurrentStat(GET_STATID(STAT_CLM_RenderDistortion));
            RenderDistortion(RHICmdList);
            ServiceLocalQueue();
        }
        RHICmdList.SetCurrentStat(GET_STATID(STAT_CLM_AfterTranslucency));
    }

void FDeferredShadingSceneRenderer::RenderTranslucency(FRHICommandListImmediate& RHICmdList)
  1. PASS_8: Post Processing
    绘制后处理效果
    // Resolve the scene color for post processing.
    SceneContext.ResolveSceneColor(RHICmdList, FResolveRect(0, 0, ViewFamily.FamilySizeX, ViewFamily.FamilySizeY));

    GetRendererModule().RenderPostResolvedSceneColorExtension(RHICmdList, SceneContext);

    CopySceneCaptureComponentToTarget(RHICmdList);
    
    // Finish rendering for each view.
    if (ViewFamily.bResolveScene)
    {
        SCOPED_DRAW_EVENT(RHICmdList, PostProcessing);
        SCOPED_GPU_STAT(RHICmdList, Stat_GPU_Postprocessing);

        SCOPE_CYCLE_COUNTER(STAT_FinishRenderViewTargetTime);

        RHICmdList.SetCurrentStat(GET_STATID(STAT_CLM_PostProcessing));
        for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
        {
            SCOPED_CONDITIONAL_DRAW_EVENTF(RHICmdList, EventView, Views.Num() > 1, TEXT("View%d"), ViewIndex);

            // 执行后处理效果!!
            GPostProcessing.Process(RHICmdList, Views[ ViewIndex ], VelocityRT);
        }

        // End of frame, we don't need it anymore
        FSceneRenderTargets::Get(RHICmdList).FreeSeparateTranslucencyDepth();

        // we rendered to it during the frame, seems we haven't made use of it, because it should be released
        check(!FSceneRenderTargets::Get(RHICmdList).SeparateTranslucencyRT);
    }
    else
    {
        // Release the original reference on the scene render targets
        SceneContext.AdjustGBufferRefCount(RHICmdList, -1);
    }

后处理类

/**
 * The center for all post processing activities.
 */
class FPostProcessing
{
public:

    bool AllowFullPostProcessing(const FViewInfo& View, ERHIFeatureLevel::Type FeatureLevel);

    // @param VelocityRT only valid if motion blur is supported
    void Process(FRHICommandListImmediate& RHICmdList, const FViewInfo& View, TRefCountPtr& VelocityRT);

    void ProcessES2(FRHICommandListImmediate& RHICmdList, const FViewInfo& View, bool bViewRectSource);

    void ProcessPlanarReflection(FRHICommandListImmediate& RHICmdList, FViewInfo& View, TRefCountPtr& VelocityRT, TRefCountPtr& OutFilteredSceneColor);
};

Shaders and Materials

参考UE4官方文档

  • Global Shaders
    全局shader是用于操作固定几何体(如:full screen quad)的shader,并且它不需要与materials产生交互,例如:阴影过滤、后处理。这种类型的shader在内存中只有一份实例。
  • Material
    材质由一些控制材质如何渲染的状态和一些控制材质如何与渲染Pass shader交互的材质输入(material inputs)组成。
  • Vertex Factories And Mesh Types
    Material必须能够赋给各种类型的Mesh Types, 这个是通过和Vertex factories配合完成的。 一个FVertexFactoryType表示唯一的Mesh Type。一个FVertexFactory的实例存有每个几何体的数据，以便支持特定的Mesh Type. 例如：FGPUSkinVertexFactory存放用于蒙皮的bone matrics、各种Vertex Buffers，GPU Skin vertex factory shader代码需要它们作为输入。Vertex Factory shader code是一个隐式接口，抽象了不同类型的Mesh types，屏蔽了这些mesh types的差异，方便各种pass shaders访问mesh数据。vertex factories shader提供如下接口：
函数 描述
FVertexFactoryInput Defines what the vertex factory needs as input to the vertex shader. These must match the vertex declaration in the C++ side FVertexFactory. For example, LocalVertexFactory's FVertexFactoryInput has float4 Position : POSITION;, which corresponds to the position stream declaration in FStaticMeshLODResources::SetupVertexFactory.
FVertexFactoryIntermediates Used to store cached intermediate data that will be used in multiple vertex factory functions. A common example is the TangentToLocal matrix, which had to be computed from unpacked vertex inputs.
FVertexFactoryInterpolantsVSToPS Vertex factory data to be passed from the vertex shader to the pixel shader.
VertexFactoryGetWorldPosition This is called from the vertex shader to get the world space vertex position. For Static Meshes this merely transforms the local space positions from the vertex buffer into world space using the LocalToWorld matrix. For GPU skinned meshes, the position is skinned first and then transformed to world space.
VertexFactoryGetInterpolantsVSToPS Transforms the FVertexFactoryInput to FVertexFactoryInterpolants, which will be interpolated by the graphics hardware before getting passed into the pixel shader.
GetMaterialPixelParameters This is called in the pixel shader and converts vertex factory specific interpolants (FVertexFactoryInterpolants) to the FMaterialPixelParameters structure which is used by the pass pixel shaders.

  • Material Shaders
    FMaterialShaderType类型的shaders是特定的渲染pass的shaders, 它需要访问材质属性(material's attributes), 针对每个material都要相应地编译一下，这种类型的shaders不需要访问mesh attributes（例如: light function pass shaders）。

    FMeshMaterialShaderType类型的shaders是特定的渲染pass的shaders，它依赖于材质属性和mesh type, 因此针对每个material, vertex factory组合都需要相应地编译一下，成为最终的可供gpu认可的shader(ie. vs, ps), 例如:TBasePassVS/TBasePassPS需要和所有的material、mesh type进行组合编译。
    一个material引发出的最终gpu shaders(FMaterialShader实例或FMeshMaterialShader实例)放在FMaterialShaderMap中。
    综上所述，一个最终的gpu shader的合成方式如下表:

所属Shader类型 组成部分
GlobalShaderType pass_shader_x.usf
MaterialShaderType material_x.usf + pass_shader_x.usf
MeshMaterialShaderType vertex_factory_x.usf + material_x.usf + pass_shader_x.usf

Note: pass_shader_x.usf和vertex_factory_x.usf表示引擎Shders目录下的usf文件, material_x.usf表示由UE4材质编辑器生成的材质结点代码

  • UE4源码中相关类
  1. FShader类
    FShader类的继承体系如下: 
    FShader
    FGlobalShader
        FClearBufferReplacementCS
        FClearReplacementPS
        FClearReplacementVS
        FClearTexture2DReplacementCS
        FClearTexture2DReplacementScissorCS
        FCopyTexture2DCS
        FCubemapTexturePropertiesPS
        FCubemapTexturePropertiesVS
        FFillTextureCS
        FHdrCustomResolve2xPS
        FHdrCustomResolve4xPS
        FHdrCustomResolve8xPS
        FHdrCustomResolveVS
        FIESLightProfilePS
        FLongGPUTaskPS
        FMedaShadersVS
        FNULLPS
        FOneColorPS
        TOneClorPixelShaderMRT
        FResolveDepthNonMSPS
        FResolveDepthPS
        FResolveSingleSamplePS
        FResolveVS
        FScreenPS
        FScreenVS
        FScreenVSForGS
        FSimpleElementColorChannelMaskPS
        FSimpleElementHitProxyPS
        FSimpleElementPS
        FSimpleElementAlphaOnlyPS
        FSimpleElementGammaBasePS
        FSimpleElementGammaAlphaOnlyPS
        FSimpleElementGammaPS
        FSimpleElementMaskedGammaBasePS
        FSimpleElementDistanceFieldGammaPS
        FSimpleElementMaskedGammaPS
        FSimpleElementVS
        FUpdateTexture2DSubresouceCS
        FUpdateTexture3DSubresouceCS
        FYCbCrConvertShaderPS
        TOneColorVS
    FMaterialShader
        FPostProcessMaterialVS
        FPostProcessMaterialPS
        FLightFunctionVS
        FLightFunctionPS
            ...
        FMeshMaterialShader
            TDepthOnlyVS
            TDepthOnlyPS
            TDistortionMeshVS
            TDistortionMeshPS
            FShadowDepthVS
            FShadowDepthPS
            ...
    这些类实例对象代表一个GPU shader资源(vs,ps,cs),它由UE4的ShaderCompiler系统生成。同时每个类都对应一个ShaderType实例,用于描述这些类用什么pass shader(即哪个usf源文件). 例如下面几个Shader类
class FClearReplacementVS : public FGlobalShader
{
    // 声明ShaderType对象，注意关键字Global.
    DECLARE_EXPORTED_SHADER_TYPE(FClearReplacementVS, Global, UTILITYSHADERS_API);
public:
    FClearReplacementVS() {}
    FClearReplacementVS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
    : FGlobalShader( Initializer )
    {
    }
    
    // FShader interface.
    virtual bool Serialize(FArchive& Ar) override
    {
        bool bShaderHasOutdatedParameters = FGlobalShader::Serialize(Ar);
        return bShaderHasOutdatedParameters;
    }
    
    static bool ShouldCache(EShaderPlatform Platform)
    {
        return IsFeatureLevelSupported(Platform, ERHIFeatureLevel::SM4);
    }
};
    // 使用的pass shader是ClearReplacementShaders.usf, 入口为ClearVS.
    IMPLEMENT_SHADER_TYPE(,FClearReplacementVS,TEXT("ClearReplacementShaders"),TEXT("ClearVS"),SF_Vertex);
    ```
    ```cpp
    template
    class FPostProcessMaterialVS : public FMaterialShader
    {
       // 声明ShaderType对象，注意关键字Material.
        DECLARE_SHADER_TYPE(FPostProcessMaterialVS, Material);
    public:

        FPostProcessMaterialVS( )   { }
        FPostProcessMaterialVS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
            : FMaterialShader(Initializer)
        {
            PostprocessParameter.Bind(Initializer.ParameterMap);
        }
    private:
        FPostProcessPassParameters PostprocessParameter;
    };
    typedef FPostProcessMaterialVS FPostProcessMaterialVS_HighEnd;
    typedef FPostProcessMaterialVS FPostProcessMaterialVS_Mobile;
   // 使用的pass shader是PostProcessMaterialShaders.usf, 入口为MainVS.
   IMPLEMENT_MATERIAL_SHADER_TYPE(template<>,FPostProcessMaterialVS_HighEnd,TEXT("PostProcessMaterialShaders"),TEXT("MainVS"),SF_Vertex);
    ```
    ```cpp
 // A vertex shader for rendering the depth of a mesh.
class FShadowDepthVS : public FMeshMaterialShader
{
    // 声明ShaderType对象，注意关键字MeshMaterial.
    DECLARE_SHADER_TYPE(FShadowDepthVS,MeshMaterial);
public:
    static bool ShouldCache(EShaderPlatform Platform,const FMaterial* Material,const FVertexFactoryType* VertexFactoryType)
    {
        return false;
    }
    FShadowDepthVS(const ShaderMetaType::CompiledShaderInitializerType& Initializer):
        FMeshMaterialShader(Initializer)
    {
        ShadowParameters.Bind(Initializer.ParameterMap);
        ShadowViewProjectionMatrices.Bind(Initializer.ParameterMap, TEXT("ShadowViewProjectionMatrices"));
        MeshVisibleToFace.Bind(Initializer.ParameterMap, TEXT("MeshVisibleToFace"));
        InstanceCount.Bind(Initializer.ParameterMap, TEXT("InstanceCount"));
    }
    FShadowDepthVS() {}
private:
    FShadowDepthShaderParameters ShadowParameters;
    FShaderParameter ShadowViewProjectionMatrices;
    FShaderParameter MeshVisibleToFace;
    FShaderParameter InstanceCount;
};

  1. FShaderType类
    该类用于描述Shader的类型。

    FShaderType
    FGlobalShaderType
     FMaterialShaderType
     FMeshMaterialShaderType
    • FGlobalShaderType
      A shader meta type for the simplest shaders; shaders which are not material or vertex factory linked. There should only a single instance of each simple shader type
    • FMaterialShaderType
      A shader meta type for material-linked shaders.
    • FMeshMaterialShaderType
      A shader meta type for material-linked shaders which use a vertex factory.

  2. Material Classes
    用于描述材质的类按所属子系统可以分为2组:

    • 对象子系统
    类名 描述
    UMaterialInterface [抽象类] 声明访问材质属性接口供game thread使用
    UMaterial 材质资源,可用材质编辑器打开进行材质编程，提供材质根结点中的material attribute实现代码，另外提供blend mode，cull mode等等渲染状态
    UMaterialInstance [抽象类] 基于UMaterial，它提供一些材质编程中的结点参数(scalars, vectors, textures, static switchs)。Each instance has a parent UMaterialInterface. Therefore a material instance's parent may be a UMaterial or another UMaterialInstance. This creates a chain that will eventually lead to a UMaterial.
    UMaterialInstanceConstant 提供材质编程中的结点参数(scalars, vectors, textures, static switchs), 这些参数只能在材质编辑器中调整。
    UMaterialInstanceDynamic A UMaterialInstance that may be modified at runtime. May provide scalar, vector, and texture parameters. It cannot provide static switch parameters and it cannot be the parent of another UMaterialInstance.

    类层次图:

    UObject
    UMaterialInterface
        UMaterial
        UMaterialInstance
            UMaterialInstanceConstant
            UMaterialInstanceDynamic
    • 渲染子系统
    类名 描述
    FMaterial An interface to a material used for rendering. Provides access to material properties (e.g. blend mode). Contains a shader map used by the renderer to retrieve individual shaders.
    FMaterialResource UMaterial's implementation of the FMaterial interface. UMaterial对象会生成FMaterialResource对象
    FMaterialRenderProxy A material's representation on the rendering thread. Provides access to an FMaterial interface and the current value of each scalar, vector, and texture parameter. 它带有材质参数值，这些值是从UMaterialInstance对象同步过来的, 供render-thread访问

    类层次图:

    FMaterial 
    FMaterialResource

    FRenderResource
    FMaterialRenderProxy

    现在来看一下这几个类的关系：
    UMaterial提供下面的接口可以获得FMaterialRenderProxy对象和FMaterialResource对象.

    virtual FMaterialResource* GetMaterialResource(ERHIFeatureLevel::Type InFeatureLevel, EMaterialQualityLevel::Type QualityLevel = EMaterialQualityLevel::Num) override;
virtual FMaterialRenderProxy* GetRenderProxy(bool Selected, bool bHovered=false) const override;

    FMaterialRenderProxy提供下面的接口获得FMaterial(或FMaterialResource)对象

    virtual const class FMaterial* GetMaterial(ERHIFeatureLevel::Type InFeatureLevel) const = 0;

    FMaterial提供如下接口获取FShader对象

      template
  ShaderType* GetShader(FVertexFactoryType* VertexFactoryType) const
  {
      return (ShaderType*)GetShader(&ShaderType::StaticType, VertexFactoryType);
  }

    综上所述，渲染器获得了FMaterialRenderProxy实例，就可以针对要渲染的Mesh取得最终的GPU Shader。

绘制Mesh

  • 场景中几何体需要提供给渲染器的信息
    现在以源码中的UJCustomMeshComponent的实现为研究对象来了解一下绘制一个Mesh时需要哪些信息。
    在Engine\Plugins\Runtime\CustomMeshComponent\Source\CustomMeshComponent\Private\JCustomMeshComponent.cpp中
    FJCustomMeshSceneProxy的对象是自定义的场景几何体Proxy，它通过GetDynamicMeshElements()接口向渲染层提供要绘制的dynamic Mesh.
   virtual void GetDynamicMeshElements(const TArray& Views, const FSceneViewFamily& ViewFamily, uint32 VisibilityMap, FMeshElementCollector& Collector) const override
   {
       QUICK_SCOPE_CYCLE_COUNTER( STAT_CustomMeshSceneProxy_GetDynamicMeshElements );

       const bool bWireframe = AllowDebugViewmodes() && ViewFamily.EngineShowFlags.Wireframe;

       auto WireframeMaterialInstance = new FColoredMaterialRenderProxy(
           GEngine->WireframeMaterial ? GEngine->WireframeMaterial->GetRenderProxy(IsSelected()) : NULL,
           FLinearColor(0, 0.5f, 1.f)
           );

       Collector.RegisterOneFrameMaterialProxy(WireframeMaterialInstance);

       FMaterialRenderProxy* MaterialProxy = NULL;
       if(bWireframe)
       {
           MaterialProxy = WireframeMaterialInstance;
       }
       else
       {
           MaterialProxy = Material->GetRenderProxy(IsSelected());
       }

       for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
       {
           if (VisibilityMap & (1 << ViewIndex))
           {
               const FSceneView* View = Views[ViewIndex];
               // Draw the mesh.
               FMeshBatch& Mesh = Collector.AllocateMesh();
               FMeshBatchElement& BatchElement = Mesh.Elements[0];
               BatchElement.IndexBuffer = &IndexBuffer;     // element需要IndexBuffer
               Mesh.bWireframe = bWireframe;                // 是否线框模式绘制
               Mesh.VertexFactory = &VertexFactory;         // Vertex Factory对象
               Mesh.MaterialRenderProxy = MaterialProxy;    // Material Render Proxy对象
               BatchElement.PrimitiveUniformBuffer = CreatePrimitiveUniformBufferImmediate(GetLocalToWorld(), GetBounds(), GetLocalBounds(), true, UseEditorDepthTest());  // mesh element的传递给shader的mvp参数
               BatchElement.FirstIndex = 0;
               BatchElement.NumPrimitives = IndexBuffer.Indices.Num() / 3;
               BatchElement.MinVertexIndex = 0;
               BatchElement.MaxVertexIndex = VertexBuffer.Vertices.Num() - 1;
               Mesh.ReverseCulling = IsLocalToWorldDeterminantNegative();
               Mesh.Type = PT_TriangleList;
               Mesh.DepthPriorityGroup = SDPG_World;
               Mesh.bCanApplyViewModeOverrides = false;
               Collector.AddMesh(ViewIndex, Mesh);
           }
       }
   }
名称 描述
Vertex Factory Object 提供GPU的输入数据流, GPU shader参数
Matrial Render Proxy Object 提供渲染时的状态设置、GPU Shader对象、Shader的参数
Batch Element Mesh的sub-mesh (它们共用材质和顶点数据)
Mesh Types mesh的图元类型

一个FMeshBatch的绘制，主要需要如下信息:

名称 描述
Vertex Factory Object 提供GPU的输入数据流, GPU shader参数
Matrial Render Proxy Object 提供渲染时的状态设置、GPU Shader对象、Shader的参数
Batch Element Mesh的sub-mesh (它们共用材质和顶点数据)
Mesh Types mesh的图元类型
  • Render Policy
    RenderPolicy负责渲染meshes,不同类型的Render Policy使用不同的pass shader。它从FMeshBatch对象中知道了Vertex Factory, Material Render Proxy, Mesh Elements, 图元类型。通过执行如下步骤来绘制mesh.
  • 绑定Vertex Factory的Vertex Buffers，设置数据流input layout
  • 通过VertexFactory的类型和Pass Shader类型，从FMaterial对象获取特定的GPU Shader（vs, ps. etc）, 设置当前的vertex shader和pixel shader。
  • 设置GPU shader参数
  • 发射RHI Draw命令
Function Description
Constructor Finds the appropriate shader from the given vertex factory and material shader map, stores these references
CreateBoundShaderState Creates an RHI bound shader state for the drawing policy.
Matches/Compare Provides methods to sort the drawing policy with others in the static draw lists. Matches must compare on all the factors that DrawShared depends on.
DrawShared Sets RHI state that is constant between drawing policies that return true from Matches. For example, most drawing policies sort on material and vertex factory, so shader parameters depending only on the material can be set, and the vertex buffers specific to the vertex factory can be bound. State should always be set here if possible instead of SetMeshRenderState, since DrawShared is called less times in the static rendering path.
SetMeshRenderState Sets RHI state that is specific to this mesh, or anything not set in DrawShared. This is called many more times than DrawShared so performance is especially critical here.
DrawMesh Actually issues the RHI draw call.

FMeshDrawingPolicy的方法

Function Description
Constructor Finds the appropriate shader from the given vertex factory and material shader map, stores these references
CreateBoundShaderState Creates an RHI bound shader state for the drawing policy.
Matches/Compare Provides methods to sort the drawing policy with others in the static draw lists. Matches must compare on all the factors that DrawShared depends on.
DrawShared Sets RHI state that is constant between drawing policies that return true from Matches. For example, most drawing policies sort on material and vertex factory, so shader parameters depending only on the material can be set, and the vertex buffers specific to the vertex factory can be bound. State should always be set here if possible instead of SetMeshRenderState, since DrawShared is called less times in the static rendering path.
SetMeshRenderState Sets RHI state that is specific to this mesh, or anything not set in DrawShared. This is called many more times than DrawShared so performance is especially critical here.
DrawMesh Actually issues the RHI draw call.

FMeshDrawingPolicy的类层次图:

FMeshDrawingPolicy
    FLandscapeGrassWeightDrawingPolicy
    FMeshDecalsDrawingPolicy
    FBasePassDrawingPolicy
    FConvertToUniformMeshDrawingPolicy
    FDepthDrawingPolicy
    FPositionOnlyDepthDrawingPolicy
    TDistortionMeshDrawingPolicy
    TLightMapDensityDrawingPolicy
    FHitProxyDrawingPolicy
    FShadowDepthDrawingPolicy
    FTranslucencyShadowDepthDrawingPolicy
    FVelocityDrawingPolicy
    FVoxelizeVolumeDrawingPolicy

下面阅读分析一下BasepassRender时,RenderPolicy的使用:

       /**
       * Renders the basepass for the dynamic data of a given DPG and View.
       *
       * @return true if anything was rendered to scene color
       */
       void FDeferredShadingSceneRenderer::RenderBasePassDynamicData(FRHICommandList& RHICmdList, const FViewInfo& View, const FDrawingPolicyRenderState& DrawRenderState, bool& bOutDirty)
       {
           SCOPE_CYCLE_COUNTER(STAT_DynamicPrimitiveDrawTime);
           SCOPED_DRAW_EVENT(RHICmdList, Dynamic);

           FBasePassOpaqueDrawingPolicyFactory::ContextType Context(false, ESceneRenderTargetsMode::DontSet);

           for (int32 MeshBatchIndex = 0; MeshBatchIndex < View.DynamicMeshElements.Num(); MeshBatchIndex++)
           {
               const FMeshBatchAndRelevance& MeshBatchAndRelevance = View.DynamicMeshElements[MeshBatchIndex];

               if ((MeshBatchAndRelevance.GetHasOpaqueOrMaskedMaterial() || ViewFamily.EngineShowFlags.Wireframe)
                   && MeshBatchAndRelevance.GetRenderInMainPass())
               {
                   const FMeshBatch& MeshBatch = *MeshBatchAndRelevance.Mesh;
                   FBasePassOpaqueDrawingPolicyFactory::DrawDynamicMesh(RHICmdList, View, Context, MeshBatch, true, DrawRenderState, MeshBatchAndRelevance.PrimitiveSceneProxy, MeshBatch.BatchHitProxyId, View.IsInstancedStereoPass());
               }
           }
       }

bool FBasePassOpaqueDrawingPolicyFactory::DrawDynamicMesh(
   FRHICommandList& RHICmdList, 
   const FViewInfo& View,
   ContextType DrawingContext,
   const FMeshBatch& Mesh,
   bool bPreFog,
   const FDrawingPolicyRenderState& DrawRenderState,
   const FPrimitiveSceneProxy* PrimitiveSceneProxy,
   FHitProxyId HitProxyId, 
   const bool bIsInstancedStereo
   )
{
   // Determine the mesh's material and blend mode.
   const FMaterial* Material = Mesh.MaterialRenderProxy->GetMaterial(View.GetFeatureLevel());
   const EBlendMode BlendMode = Material->GetBlendMode();

   // Only draw opaque materials.
   if (!IsTranslucentBlendMode(BlendMode) && ShouldIncludeDomainInMeshPass(Material->GetMaterialDomain()))
   {
       ProcessBasePassMesh(
           RHICmdList, 
           FProcessBasePassMeshParameters(
               Mesh,
               Material,
               PrimitiveSceneProxy,
               !bPreFog,
               DrawingContext.bEditorCompositeDepthTest,
               DrawingContext.TextureMode,
               View.GetFeatureLevel(), 
               bIsInstancedStereo
               ),
           FDrawBasePassDynamicMeshAction(
               RHICmdList,
               View,
               Mesh.DitheredLODTransitionAlpha,
               DrawRenderState,
               HitProxyId
               )
           );
       return true;
   }
   else
   {
       return false;
   }
}

   // BasePassDrawPolicy的使用流程，请看下面代码中的注释
   /** The action used to draw a base pass dynamic mesh element. */
   class FDrawBasePassDynamicMeshAction
   {
   public:
       const FViewInfo& View;
       FDrawingPolicyRenderState DrawRenderState;
       FHitProxyId HitProxyId;

       /** Initialization constructor. */
       FDrawBasePassDynamicMeshAction(
           FRHICommandList& InRHICmdList,
           const FViewInfo& InView,
           float InDitheredLODTransitionAlpha,
           const FDrawingPolicyRenderState& InDrawRenderState,
           const FHitProxyId InHitProxyId
           )
           : View(InView)
           , DrawRenderState(InDrawRenderState)
           , HitProxyId(InHitProxyId)
       {
           DrawRenderState.SetDitheredLODTransitionAlpha(InDitheredLODTransitionAlpha);
       }
       bool UseTranslucentSelfShadowing() const { return false; }
       const FProjectedShadowInfo* GetTranslucentSelfShadow() const { return NULL; }
       bool AllowIndirectLightingCache() const 
       { 
           const FScene* Scene = (const FScene*)View.Family->Scene;
           return View.Family->EngineShowFlags.IndirectLightingCache && Scene && Scene->PrecomputedLightVolumes.Num() > 0;
       }

       bool AllowIndirectLightingCacheVolumeTexture() const
       {
           return true;
       }

       /** Draws the translucent mesh with a specific light-map type, and shader complexity predicate. */
       template
       void Process(
           FRHICommandList& RHICmdList, 
           const FProcessBasePassMeshParameters& Parameters,
           const LightMapPolicyType& LightMapPolicy,
           const typename LightMapPolicyType::ElementDataType& LightMapElementData
           )
       {
   #if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
           //TODO this codepath is probably disabled by SetDepthStencilStateForBasePass
           if(View.Family->EngineShowFlags.ShaderComplexity)
           {
               // When rendering masked materials in the shader complexity viewmode, 
               // We want to overwrite complexity for the pixels which get depths written,
               // And accumulate complexity for pixels which get killed due to the opacity mask being below the clip value.
               // This is accomplished by forcing the masked materials to render depths in the depth only pass, 
               // Then rendering in the base pass with additive complexity blending, depth tests on, and depth writes off.
               DrawRenderState.SetDepthStencilState(TStaticDepthStencilState::GetRHI());
           }
           else if (View.Family->UseDebugViewPS() && View.Family->GetDebugViewShaderMode() != DVSM_OutputMaterialTextureScales)
           {
               if (Parameters.PrimitiveSceneProxy && Parameters.PrimitiveSceneProxy->IsSelected())
               {
                   DrawRenderState.SetDepthStencilState(TStaticDepthStencilState::GetRHI());
               }
               else // If not selected, use depth equal to make alpha test stand out (goes with EarlyZPassMode = DDM_AllOpaque) 
               {
                   DrawRenderState.SetDepthStencilState(TStaticDepthStencilState::GetRHI());
               }
           }
   #endif
           const FScene* Scene = Parameters.PrimitiveSceneProxy ? Parameters.PrimitiveSceneProxy->GetPrimitiveSceneInfo()->Scene : NULL;

           const bool bRenderSkylight = Scene && Scene->ShouldRenderSkylightInBasePass(Parameters.BlendMode) && Parameters.ShadingModel != MSM_Unlit;
           const bool bRenderAtmosphericFog = IsTranslucentBlendMode(Parameters.BlendMode) && (Scene && Scene->HasAtmosphericFog() && Scene->ReadOnlyCVARCache.bEnableAtmosphericFog) && View.Family->EngineShowFlags.AtmosphericFog;

           bool bEnableReceiveDecalOutput = Scene != nullptr;
           // NOTE:
           //    临时RenderPolicy对象
           //
           TBasePassDrawingPolicy DrawingPolicy(
               Parameters.Mesh.VertexFactory,
               Parameters.Mesh.MaterialRenderProxy,
               *Parameters.Material,
               Parameters.FeatureLevel,
               LightMapPolicy,
               Parameters.BlendMode,
               Parameters.TextureMode,
               bRenderSkylight,
               bRenderAtmosphericFog,
               ComputeMeshOverrideSettings(Parameters.Mesh),
               View.Family->GetDebugViewShaderMode(),
               Parameters.bEditorCompositeDepthTest,
               bEnableReceiveDecalOutput
               );

           // 设置渲染状态
           SetDepthStencilStateForBasePass(DrawRenderState, View, Parameters.Mesh, Parameters.PrimitiveSceneProxy, bEnableReceiveDecalOutput, DrawingPolicy.UseDebugViewPS(), nullptr, Parameters.bEditorCompositeDepthTest);
           DrawingPolicy.SetupPipelineState(DrawRenderState, View);
           // 设置GPU Shaders
           CommitGraphicsPipelineState(RHICmdList, DrawingPolicy, DrawRenderState, DrawingPolicy.GetBoundShaderStateInput(View.GetFeatureLevel()));
           // 设置GPU Shaders的uniforms参数
           DrawingPolicy.SetSharedState(RHICmdList, DrawRenderState, &View, typename TBasePassDrawingPolicy::ContextDataType(Parameters.bIsInstancedStereo));

           for( int32 BatchElementIndex = 0, Num = Parameters.Mesh.Elements.Num(); BatchElementIndex < Num; BatchElementIndex++ )
           {
               // We draw instanced static meshes twice when rendering with instanced stereo. Once for each eye.
               const bool bIsInstancedMesh = Parameters.Mesh.Elements[BatchElementIndex].bIsInstancedMesh;
               const uint32 InstancedStereoDrawCount = (Parameters.bIsInstancedStereo && bIsInstancedMesh) ? 2 : 1;
               for (uint32 DrawCountIter = 0; DrawCountIter < InstancedStereoDrawCount; ++DrawCountIter)
               {
                   DrawingPolicy.SetInstancedEyeIndex(RHICmdList, DrawCountIter);

                   TDrawEvent MeshEvent;
                   BeginMeshDrawEvent(RHICmdList, Parameters.PrimitiveSceneProxy, Parameters.Mesh, MeshEvent);

                   // 设置状态和参数
                   DrawingPolicy.SetMeshRenderState(
                       RHICmdList,
                       View,
                       Parameters.PrimitiveSceneProxy,
                       Parameters.Mesh,
                       BatchElementIndex,
                       DrawRenderState,
                       typename TBasePassDrawingPolicy::ElementDataType(LightMapElementData),
                       typename TBasePassDrawingPolicy::ContextDataType()
                       );
                   // 发射Draw命令
                   DrawingPolicy.DrawMesh(RHICmdList, Parameters.Mesh, BatchElementIndex, Parameters.bIsInstancedStereo);
               }
           }

   #if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
           //TODO this codepath is probably disabled by SetDepthStencilStateForBasePass
           if(View.Family->EngineShowFlags.ShaderComplexity)
           {
               DrawRenderState.SetDepthStencilState(TStaticDepthStencilState::GetRHI());
           }
   #endif
       }
   };

Shader和Shader Parameters

每个GPU Shader编译后，都会有个shader参数表（用FShaderParameterMap表示）, FShaderParameter描述shader参数名与分配的寄存器信息。因为一个GPU Shader是由vertex-factory shader、material shader和 pass shader组合成的，所以这3个部分均可以产生shader parameters。下面我们要弄清楚,在RenderPolicy渲染mesh时，哪些对象参与设置了shader parameters，提供的接口是什么。

  1. 从FShader(含子类)对象考虑:
  • FGlobalShader
  template
  inline void SetParameters(TRHICmdList& RHICmdList, const ShaderRHIParamRef ShaderRHI, const FUniformBufferRHIParamRef ViewUniformBuffer)
  {
      const auto& ViewUniformBufferParameter = static_cast(GetUniformBufferParameter());
      CheckShaderIsValid();
      SetUniformBufferParameter(RHICmdList, ShaderRHI, ViewUniformBufferParameter, ViewUniformBuffer);
  }
  • FMaterialShader
  template
  FORCEINLINE_DEBUGGABLE void SetViewParameters(FRHICommandList& RHICmdList, const ShaderRHIParamRef ShaderRHI, const FSceneView& View, const TUniformBufferRef& ViewUniformBuffer)
  {
      const auto& ViewUniformBufferParameter = GetUniformBufferParameter();
      const auto& BuiltinSamplersUBParameter = GetUniformBufferParameter();
      CheckShaderIsValid();
      SetUniformBufferParameter(RHICmdList, ShaderRHI, ViewUniformBufferParameter, ViewUniformBuffer);
#if USE_GBuiltinSamplersUniformBuffer
      SetUniformBufferParameter(RHICmdList, ShaderRHI, BuiltinSamplersUBParameter, GBuiltinSamplersUniformBuffer.GetUniformBufferRHI());
#endif

      if (View.bShouldBindInstancedViewUB && View.Family->Views.Num() > 0)
      {
          // When drawing the left eye in a stereo scene, copy the right eye view values into the instanced view uniform buffer.
          const EStereoscopicPass StereoPassIndex = (View.StereoPass != eSSP_FULL) ? eSSP_RIGHT_EYE : eSSP_FULL;

          const FSceneView& InstancedView = View.Family->GetStereoEyeView(StereoPassIndex);
          const auto& InstancedViewUniformBufferParameter = GetUniformBufferParameter();
          SetUniformBufferParameter(RHICmdList, ShaderRHI, InstancedViewUniformBufferParameter, InstancedView.ViewUniformBuffer);
      }
  }

  /** Sets pixel parameters that are material specific but not FMeshBatch specific. */
  template< typename ShaderRHIParamRef >
  void SetParameters(
      FRHICommandList& RHICmdList,
      const ShaderRHIParamRef ShaderRHI, 
      const FMaterialRenderProxy* MaterialRenderProxy, 
      const FMaterial& Material,
      const FSceneView& View, 
      const TUniformBufferRef& ViewUniformBuffer,
      bool bDeferredPass, 
      ESceneRenderTargetsMode::Type TextureMode);
  • FMeshMaterialShader 
    // 设置材质(material)需要的参数, 不排除其它参数
 template< typename ShaderRHIParamRef >
 void SetParameters(
     FRHICommandList& RHICmdList,
     const ShaderRHIParamRef ShaderRHI,
     const FMaterialRenderProxy* MaterialRenderProxy,
     const FMaterial& Material,
     const FSceneView& View,
     const TUniformBufferRef& ViewUniformBuffer,
     ESceneRenderTargetsMode::Type TextureMode)
 {
     FMaterialShader::SetParameters(RHICmdList, ShaderRHI, MaterialRenderProxy, Material, View, ViewUniformBuffer, false, TextureMode);
 }

    // 设置Vertex Factory的shader参数
 void SetVFParametersOnly(FRHICommandList& RHICmdList, const FVertexFactory* VertexFactory,const FSceneView& View,const FMeshBatchElement& BatchElement)
 {
     VertexFactoryParameters.SetMesh(RHICmdList, this,VertexFactory,View,BatchElement, 0);
 }

    // 设置跟mesh相关的参数
 template< typename ShaderRHIParamRef >
 void FMeshMaterialShader::SetMesh(
     FRHICommandList& RHICmdList,
     const ShaderRHIParamRef ShaderRHI,
     const FVertexFactory* VertexFactory,
     const FSceneView& View,
     const FPrimitiveSceneProxy* Proxy,
     const FMeshBatchElement& BatchElement,
     const FDrawingPolicyRenderState& DrawRenderState,
     uint32 DataFlags )
 {
     // Set the mesh for the vertex factory
     VertexFactoryParameters.SetMesh(RHICmdList, this,VertexFactory,View,BatchElement, DataFlags);

     // 设置LocalToworld, WorldToLocal等参数!!
     if(IsValidRef(BatchElement.PrimitiveUniformBuffer))
     {
         SetUniformBufferParameter(RHICmdList, ShaderRHI,GetUniformBufferParameter(),BatchElement.PrimitiveUniformBuffer);
     }
     else
     {
         check(BatchElement.PrimitiveUniformBufferResource);
         SetUniformBufferParameter(RHICmdList, ShaderRHI,GetUniformBufferParameter(),*BatchElement.PrimitiveUniformBufferResource);
     }

     TShaderUniformBufferParameter LODParameter = GetUniformBufferParameter();
     if( LODParameter.IsBound() )
     {
         SetUniformBufferParameter(RHICmdList, ShaderRHI,LODParameter,GetPrimitiveFadeUniformBufferParameter(View, Proxy));
     }
     if (NonInstancedDitherLODFactorParameter.IsBound())
     {
         SetShaderValue(RHICmdList, ShaderRHI, NonInstancedDitherLODFactorParameter, DrawRenderState.GetDitheredLODTransitionAlpha());
     }
 }
    另外, FMeshMaterialShader的子类根据不同pass shader的实现，会改写SetParameters()和SetMesh()来设置gpu shader参数, 例如:FShadowDepthVS.
    SetParameters()在FMeshDrawingPolicy::SetSharedState()中被调用: 
     /**
  * Executes the draw commands which can be shared between any meshes using this drawer.
  * @param CI - The command interface to execute the draw commands on.
  * @param View - The view of the scene being drawn.
  */
  void SetSharedState(FRHICommandList& RHICmdList, const FDrawingPolicyRenderState& DrawRenderState, const FSceneView* View, const FMeshDrawingPolicy::ContextDataType PolicyContext) const;
    SetMesh()在FMeshDrawingPolicy::SetMeshRenderState()中被调用 
    /**
 * Sets the render states for drawing a mesh.
 * @param PrimitiveSceneProxy - The primitive drawing the dynamic mesh.  If this is a view element, this will be NULL.
 */
FORCEINLINE_DEBUGGABLE void SetMeshRenderState(
    FRHICommandList& RHICmdList, 
    const FSceneView& View,
    const FPrimitiveSceneProxy* PrimitiveSceneProxy,
    const FMeshBatch& Mesh,
    int32 BatchElementIndex,
    const FDrawingPolicyRenderState& DrawRenderState,
    const ElementDataType& ElementData,
    const ContextDataType PolicyContext
    ) const;

Uniform Buffer

源码路径[Engine\Source\Runtime\RenderCore\Public\UniformBuffer.h]
Uniform Buffer用于从CPU传送shader parameters到GPU。下面的宏用于在CPP代码中定义Uniform Buffer结构体，并且被ShaderCompiler使用，产生usf文件中uniform buffer的结构定义,例如:Primitive, View, InstancedView, BuiltinSamplers, MobileDirectionalLight。
在C++中的定义如下。

IMPLEMENT_UNIFORM_BUFFER_STRUCT(FPrimitiveUniformShaderParameters,TEXT("Primitive"));
IMPLEMENT_UNIFORM_BUFFER_STRUCT(FViewUniformShaderParameters,TEXT("View"));
IMPLEMENT_UNIFORM_BUFFER_STRUCT(FInstancedViewUniformShaderParameters, TEXT("InstancedView"));
IMPLEMENT_UNIFORM_BUFFER_STRUCT(FBuiltinSamplersParameters, TEXT("BuiltinSamplers"));
IMPLEMENT_UNIFORM_BUFFER_STRUCT(FMobileDirectionalLightShaderParameters, TEXT("MobileDirectionalLight"));

//
// Macros for declaring uniform buffer structures.
//

#define IMPLEMENT_UNIFORM_BUFFER_STRUCT(StructTypeName,ShaderVariableName) \
    FUniformBufferStruct StructTypeName::StaticStruct( \
    FName(TEXT(#StructTypeName)), \
    TEXT(#StructTypeName), \
    ShaderVariableName, \
    StructTypeName::ConstructUniformBufferParameter, \
    sizeof(StructTypeName), \
    StructTypeName::zzGetMembers(), \
    true);

/** Begins a uniform buffer struct declaration. */
#define BEGIN_UNIFORM_BUFFER_STRUCT_EX(StructTypeName,PrefixKeywords,ConstructorSuffix) \
    MS_ALIGN(UNIFORM_BUFFER_STRUCT_ALIGNMENT) class PrefixKeywords StructTypeName \
    { \
    public: \
        StructTypeName () ConstructorSuffix \
        static FUniformBufferStruct StaticStruct; \
        static FShaderUniformBufferParameter* ConstructUniformBufferParameter() { return new TShaderUniformBufferParameter(); } \
        static FUniformBufferRHIRef CreateUniformBuffer(const StructTypeName& InContents, EUniformBufferUsage InUsage) \
        { \
            return RHICreateUniformBuffer(&InContents,StaticStruct.GetLayout(),InUsage); \
        } \
    private: \
        typedef StructTypeName zzTThisStruct; \
        struct zzFirstMemberId { enum { HasDeclaredResource = 0 }; }; \
        static TArray zzGetMembersBefore(zzFirstMemberId) \
        { \
            return TArray(); \
        } \
        typedef zzFirstMemberId

/** Declares a member of a uniform buffer struct. */
#define DECLARE_UNIFORM_BUFFER_STRUCT_MEMBER_EXPLICIT(MemberType,MemberName,ArrayDecl,Precision,OptionalShaderType) \
        zzMemberId##MemberName; \
    public: \
        typedef MemberType zzA##MemberName ArrayDecl; \
        typedef TUniformBufferTypeInfo::TAlignedType zzT##MemberName; \
        zzT##MemberName MemberName; \
        static_assert(TUniformBufferTypeInfo::BaseType != UBMT_INVALID, "Invalid type " #MemberType " of member " #MemberName "."); \
        static_assert(TUniformBufferTypeInfo::BaseType != UBMT_UAV, "UAV is not yet supported in resource tables for " #MemberName " of type " #MemberType "."); \
    private: \
        struct zzNextMemberId##MemberName { enum { HasDeclaredResource = zzMemberId##MemberName::HasDeclaredResource || TUniformBufferTypeInfo::IsResource }; }; \
        static TArray zzGetMembersBefore(zzNextMemberId##MemberName) \
        { \
            static_assert(TUniformBufferTypeInfo::IsResource == 1 || zzMemberId##MemberName::HasDeclaredResource == 0, "All resources must be declared last for " #MemberName "."); \
            static_assert(TUniformBufferTypeInfo::IsResource == 0 || IS_TCHAR_ARRAY(OptionalShaderType), "No shader type for " #MemberName "."); \
            /* Route the member enumeration on to the function for the member following this. */ \
            TArray OutMembers = zzGetMembersBefore(zzMemberId##MemberName()); \
            /* Add this member. */ \
            OutMembers.Add(FUniformBufferStruct::FMember( \
                TEXT(#MemberName), \
                OptionalShaderType, \
                STRUCT_OFFSET(zzTThisStruct,MemberName), \
                (EUniformBufferBaseType)TUniformBufferTypeInfo::BaseType, \
                Precision, \
                TUniformBufferTypeInfo::NumRows, \
                TUniformBufferTypeInfo::NumColumns, \
                TUniformBufferTypeInfo::NumElements, \
                TUniformBufferTypeInfo::GetStruct() \
                )); \
            static_assert( \
                (STRUCT_OFFSET(zzTThisStruct,MemberName) & (TUniformBufferTypeInfo::Alignment - 1)) == 0, \
                "Misaligned uniform buffer struct member " #MemberName "."); \
            return OutMembers; \
        } \
        typedef zzNextMemberId##MemberName

#define DECLARE_UNIFORM_BUFFER_STRUCT_MEMBER_ARRAY_EX(MemberType,MemberName,ArrayDecl,Precision) DECLARE_UNIFORM_BUFFER_STRUCT_MEMBER_EXPLICIT(MemberType,MemberName,ArrayDecl,Precision,TEXT(""))

#define DECLARE_UNIFORM_BUFFER_STRUCT_MEMBER_ARRAY(MemberType,MemberName,ArrayDecl) DECLARE_UNIFORM_BUFFER_STRUCT_MEMBER_EXPLICIT(MemberType,MemberName,ArrayDecl,EShaderPrecisionModifier::Float,TEXT(""))

#define DECLARE_UNIFORM_BUFFER_STRUCT_MEMBER(MemberType,MemberName) DECLARE_UNIFORM_BUFFER_STRUCT_MEMBER_EXPLICIT(MemberType,MemberName,,EShaderPrecisionModifier::Float,TEXT(""))

#define DECLARE_UNIFORM_BUFFER_STRUCT_MEMBER_EX(MemberType,MemberName,Precision) DECLARE_UNIFORM_BUFFER_STRUCT_MEMBER_EXPLICIT(MemberType,MemberName,,Precision,TEXT(""))

#define DECLARE_UNIFORM_BUFFER_STRUCT_MEMBER_SRV(ShaderType,MemberName) DECLARE_UNIFORM_BUFFER_STRUCT_MEMBER_EXPLICIT(FShaderResourceViewRHIParamRef,MemberName,,EShaderPrecisionModifier::Float,TEXT(#ShaderType))

// NOT SUPPORTED YET
//#define DECLARE_UNIFORM_BUFFER_STRUCT_MEMBER_UAV(ShaderType,MemberName) DECLARE_UNIFORM_BUFFER_STRUCT_MEMBER_EXPLICIT(FUnorderedAccessViewRHIParamRef,MemberName,,EShaderPrecisionModifier::Float,TEXT(#ShaderType))

#define DECLARE_UNIFORM_BUFFER_STRUCT_MEMBER_SAMPLER(ShaderType,MemberName) DECLARE_UNIFORM_BUFFER_STRUCT_MEMBER_EXPLICIT(FSamplerStateRHIParamRef,MemberName,,EShaderPrecisionModifier::Float,TEXT(#ShaderType))

#define DECLARE_UNIFORM_BUFFER_STRUCT_MEMBER_TEXTURE(ShaderType,MemberName) DECLARE_UNIFORM_BUFFER_STRUCT_MEMBER_EXPLICIT(FTextureRHIParamRef,MemberName,,EShaderPrecisionModifier::Float,TEXT(#ShaderType))

/** Ends a uniform buffer struct declaration. */
#define END_UNIFORM_BUFFER_STRUCT(Name) \
            zzLastMemberId; \
        static TArray zzGetMembers() { return zzGetMembersBefore(zzLastMemberId()); } \
    } GCC_ALIGN(UNIFORM_BUFFER_STRUCT_ALIGNMENT); \
    template<> class TUniformBufferTypeInfo \
    { \
    public: \
        enum { BaseType = UBMT_STRUCT }; \
        enum { NumRows = 1 }; \
        enum { NumColumns = 1 }; \
        enum { Alignment = UNIFORM_BUFFER_STRUCT_ALIGNMENT }; \
        static const FUniformBufferStruct* GetStruct() { return &Name::StaticStruct; } \
    };

#define BEGIN_UNIFORM_BUFFER_STRUCT(StructTypeName,PrefixKeywords) BEGIN_UNIFORM_BUFFER_STRUCT_EX(StructTypeName,PrefixKeywords,{})
#define BEGIN_UNIFORM_BUFFER_STRUCT_WITH_CONSTRUCTOR(StructTypeName,PrefixKeywords) BEGIN_UNIFORM_BUFFER_STRUCT_EX(StructTypeName,PrefixKeywords,;)

/** Finds the FUniformBufferStruct corresponding to the given name, or NULL if not found. */
extern RENDERCORE_API FUniformBufferStruct* FindUniformBufferStructByName(const TCHAR* StructName);

你可能感兴趣的:(UE4渲染模块分析)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 地推话术，如何应对地推过程中家长的拒绝 校师学
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
  • 扫地机类清洁产品之直流无刷电机控制 悟空胆好小 清洁服务机器人单片机人工智能
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • 抖音乐买买怎么加入赚钱?赚钱方法是什么 测评君高省
    你会在抖音买东西吗?如果会，那么一定要免费注册一个乐买买，抖音直播间，橱窗，小视频里的小黄车买东西都可以返佣金!省下来都是自己的，分享还可以赚钱乐买买是好省旗下的抖音返佣平台，乐买买分析社交电商的价值，乐买买属于今年难得的副业项目风口机会，2019年错过做好省的搞钱的黄金时期，那么2022年千万别再错过乐买买至于我为何转到高省呢？当然是高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
  • 18-115 一切思考不能有效转化为行动，都TM是扯淡！ 成长时间线
    7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
  • 高端密码学院笔记285 柚子_b4b4
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • pyecharts——绘制柱形图折线图 2224070247 信息可视化pythonjava数据可视化
    一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
  • 数据仓库——维度表一致性 墨染丶eye 背诵数据仓库
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
  • 闲鱼鱼小铺怎么开通？鱼小铺开通需要哪些流程？ 高省APP大九
    闲鱼鱼小铺是平台推出的一个专业程度的店铺，与普通店铺相比会有更多的权益，比如说发布的商品数量从50增加到500；拥有专业的店铺数据看板与分析的功能，这对于专门在闲鱼做生意的用户来说是非常有帮助的，那么鱼小铺每个人都能开通吗？大家好，我是高省APP联合创始人蓓蓓导师，高省APP是2021年推出的电商导购平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个可省钱佣金高，能
  • 2019-11-04复盘——飞来山上千寻塔，闻说鸡鸣见日升。 那一叶秋
    1、大盘篇先上老图，看习惯了，也就知道走势了图1上证指数日线图还是那张老图，自己可以在自己的相关软件上画出来，快变盘了。2、个股篇未加仓、未减仓。分析量能的时候，突然发现这么一个东西：“放量突破年线，缩量回调。”合众科技日线图其实，最近的N只个股，在技术分析上，都到了变盘的临界时候。结合这么久的走势，特别是ZJH不断放开IPO的申请，本质上说是融资难度变大，或者说是为企业的融资开创便利。但现在市场
  • 18、架构-可观测性之聚合度量 大树~~ 架构javapython后端架构
    聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
  • 果然只有离职的时候，才有人敢说真话！ return2ok
    今天公司出了神贴。今天中午吃饭，同事问我看了论坛上的神贴了吗？什么帖子？我问。同事显得很惊讶，你居然没看，现在那个帖子可能会成为年度最佳帖子。这么厉害？我等不及了，饭没吃完就快速的奔向办公室，打开公司论坛，我要一睹这个帖子的神奇。写这帖子的童鞋胆儿真肥。这哪里是一个帖子，这是很多个帖子，组成了一个系列。某人从公司文化、管理、人事、项目管理等多个方面分析了公司的概况，并抨击了公司的各种弊端，并提出了
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • 《Python数据分析实战终极指南》 xjt921122 python数据分析开发语言
    对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • ES聚合分析原理与代码实例讲解 光剑书架上的书 大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由
    ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
  • 母亲节如何做小红书营销 美橙传媒
    小红书的一举一动引起了外界的高度关注。通过爆款笔记和流行话题，我们可以看到“干货”类型的内容在小红书中偏向实用的生活经验共享和生活指南非常受欢迎。根据运营社的分析，这种现象是由小红书用户心智和内容社区背后机制共同决定的。首先，小红书将使用“强搜索”逻辑为用户提供特定的“搜索场景”。在“我必须这样生活”中，大量使用了满足小红书站用户喜好和需求的内容。内容社区自制的高质量内容也吸引了寻找营销新途径的品
  • 系统架构设计师 需求分析篇二 AmHardy 软件架构设计师系统架构需求分析面向对象分析分析模型UML和SysML
    面向对象分析方法1.用例模型构建用例模型一般需要经历4个阶段：识别参与者：识别与系统交互的所有事物。合并需求获得用例：将需求分配给予其相关的参与者。细化用例描述：详细描述每个用例的功能。调整用例模型：优化用例之间的关系和结构，前三个阶段是必需的。2.用例图的三元素参与者：使用系统的用户或其他外部系统和设备。用例：系统所提供的服务。通信关联：参与者和用例之间的关系，或用例与用例之间的关系。3.识别参
  • 语文主题教学学习笔记之87 东哥杂谈
    “语文主题教学”学习笔记之八十七（0125）今天继续学习小学语文主题教学的实践样态。板块三：教学中体现“书艺”味道。作为四大名著之一的《水浒传》，堪称我国文学宝库之经典。对从《水浒传》中摘选的单元，教师就要了解其原生态，即评书体特点。这也要求教师要了解一些常用的评书行话术语，然后在教学时适时地加入一些，让学生体味其文本中原有的特色。学生也要尽可能地通过朗读的方式，而不单是分析讲解的方式进行学习。细
  • Python神器！WEB自动化测试集成工具 DrissionPage 亚丁号 python开发语言
    一、前言用requests做数据采集面对要登录的网站时，要分析数据包、JS源码，构造复杂的请求，往往还要应付验证码、JS混淆、签名参数等反爬手段，门槛较高。若数据是由JS计算生成的，还须重现计算过程，体验不好，开发效率不高。使用浏览器，可以很大程度上绕过这些坑，但浏览器运行效率不高。因此，这个库设计初衷，是将它们合而为一，能够在不同须要时切换相应模式，并提供一种人性化的使用方法，提高开发和运行效率
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • 今日分享：有的孩子家长常常在对于小朋友老是说谎，还特别爱推卸责任，很头痛，不知道该怎么办！ 雨燕Cassie
    其实六岁以前都不叫撒谎，只能叫做逃避和害怕，因为他们都是没有撒谎的这个概念，家长所谓的撒谎只能说是因为做错了事情，怕受到责罚而找一个「台阶」给自己一下而已，所以家长不能给孩子一个贴上撒谎的这个标签，如果说孩子出现家长所说的撒谎，我们应该做的是：1.允许孩子将事情的原委进行一个表达，给孩子说明的机会，不提示孩子说谎，不急著批评孩子。2.不使用问句，不恐吓和严刑逼供，耐心的以故事或者以分析的形式和孩子
  • 06选课支付模块之基于消息队列发送支付通知消息 echo 云清 学成在线javarabbitmq消息队列支付通知学成在线
    消息队列发送支付通知消息需求分析订单服务作为通用服务，在订单支付成功后需要将支付结果异步通知给其他对接的微服务，微服务收到支付结果根据订单的类型去更新自己的业务数据技术方案使用消息队列进行异步通知需要保证消息的可靠性即生产端将消息成功通知到服务端：消息发送到交换机-->由交换机发送到队列-->消费者监听队列，收到消息进行处理，参考文章02-使用Docker安装RabbitMQ-CSDN博客生产者确
  • 《 C++ 修炼全景指南：九 》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧 Lenyiin C++修炼全景指南技术指南c++算法stl
    摘要本文详细探讨了二叉搜索树（BinarySearchTree,BST）的核心概念和技术细节，包括插入、查找、删除、遍历等基本操作，并结合实际代码演示了如何实现这些功能。文章深入分析了二叉搜索树的性能优势及其时间复杂度，同时介绍了前驱、后继的查找方法等高级功能。通过自定义实现的二叉搜索树类，读者能够掌握其实际应用，此外，文章还建议进一步扩展为平衡树（如AVL树、红黑树）以优化极端情况下的性能退化。
  • 遥感影像的切片处理 sand&wich 计算机视觉python图像处理
    在遥感影像分析中，经常需要将大尺寸的影像切分成小片段，以便于进行详细的分析和处理。这种方法特别适用于机器学习和图像处理任务，如对象检测、图像分类等。以下是如何使用Python和OpenCV库来实现这一过程，同时确保每个影像片段保留正确的地理信息。准备环境首先，确保安装了必要的Python库，包括numpy、opencv-python和xml.etree.ElementTree。这些库将用于图像处理
  • Enum用法 不懂事的小屁孩 enum
    以前的时候知道enum，但是真心不怎么用，在实际开发中，经常会用到以下代码: protected final static String XJ = "XJ"; protected final static String YHK = "YHK"; protected final static String PQ = "PQ";
  • 【Spark九十七】RDD API之aggregateByKey bit1129 spark
    1. aggregateByKey的运行机制   /** * Aggregate the values of each key, using given combine functions and a neutral "zero value". * This function can return a different result type
  • hive创建表是报错： Specified key was too long; max key length is 767 bytes daizj hive
    今天在hive客户端创建表时报错，具体操作如下   hive> create table test2(id string); FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. MetaException(message:javax.jdo.JDODataSto
  • Map 与 JavaBean之间的转换 周凡杨 java自省转换反射
    最近项目里需要一个工具类，它的功能是传入一个Map后可以返回一个JavaBean对象。很喜欢写这样的Java服务，首先我想到的是要通过Java 的反射去实现匿名类的方法调用，这样才可以把Map里的值set 到JavaBean里。其实这里用Java的自省会更方便，下面两个方法就是一个通过反射，一个通过自省来实现本功能。 1：JavaBean类 1 &nb
  • java连接ftp下载 g21121 java
    有的时候需要用到java连接ftp服务器下载，上传一些操作，下面写了一个小例子。 /** ftp服务器地址 */ private String ftpHost; /** ftp服务器用户名 */ private String ftpName; /** ftp服务器密码 */ private String ftpPass; /** ftp根目录 */ private String f
  • web报表工具FineReport使用中遇到的常见报错及解决办法（二） 老A不折腾 finereportweb报表java报表总结
      抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。   出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。   1、没有返回数据集： 在存储过程中的操作语句之前加上set nocount on 或者在数据集exec调用存储过程的前面加上这句。当S
  • linux 系统cpu 内存等信息查看 墙头上一根草 cpu内存liunx
    1 查看CPU 　　1.1 查看CPU个数 　　# cat /proc/cpuinfo | grep "physical id" | uniq | wc -l 　　2 　　**uniq命令：删除重复行;wc –l命令：统计行数** 　　1.2 查看CPU核数 　　# cat /proc/cpuinfo | grep "cpu cores" | u
  • Spring中的AOP aijuans springAOP
      Spring中的AOP Written by Tony Jiang @ 2012-1-18 （转）何为AOP AOP，面向切面编程。 在不改动代码的前提下，灵活的在现有代码的执行顺序前后，添加进新规机能。 来一个简单的Sample: 目标类： [java]  view plain copy print ? package&nb
  • placeholder(HTML 5) IE 兼容插件 alxw4616 JavaScriptjquery jQuery插件
    placeholder 这个属性被越来越频繁的使用. 但为做HTML 5 特性IE没能实现这东西. 以下的jQuery插件就是用来在IE上实现该属性的. /** * [placeholder(HTML 5) IE 实现.IE9以下通过测试.] * v 1.0 by oTwo 2014年7月31日 11:45:29 */ $.fn.placeholder = function
  • Object类,值域,泛型等总结(适合有基础的人看) 百合不是茶 泛型的继承和通配符变量的值域Object类转换
    java的作用域在编程的时候经常会遇到,而我经常会搞不清楚这个 问题,所以在家的这几天回忆一下过去不知道的每个小知识点   变量的值域;   package 基础; /** * 作用域的范围 * * @author Administrator * */ public class zuoyongyu { public static vo
  • JDK1.5 Condition接口 bijian1013 javathreadConditionjava多线程
    Condition 将 Object 监视器方法（wait、notify和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set （wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。 条件（也称为条件队列或条件变量）为线程提供了一
  • 开源中国OSC源创会记录 bijian1013 hadoopsparkMemSQL
    一.Strata+Hadoop World（SHW）大会         是全世界最大的大数据大会之一。SHW大会为各种技术提供了深度交流的机会，还会看到最领先的大数据技术、最广泛的应用场景、最有趣的用例教学以及最全面的大数据行业和趋势探讨。          二.Hadoop   &nbs
  • 【Java范型七】范型消除 bit1129 java
    范型是Java1.5引入的语言特性，它是编译时的一个语法现象，也就是说，对于一个类，不管是范型类还是非范型类，编译得到的字节码是一样的，差别仅在于通过范型这种语法来进行编译时的类型检查，在运行时是没有范型或者类型参数这个说法的。 范型跟反射刚好相反，反射是一种运行时行为，所以编译时不能访问的变量或者方法(比如private)，在运行时通过反射是可以访问的，也就是说，可见性也是一种编译时的行为，在
  • 【Spark九十四】spark-sql工具的使用 bit1129 spark
    spark-sql是Spark bin目录下的一个可执行脚本，它的目的是通过这个脚本执行Hive的命令，即原来通过 hive>输入的指令可以通过spark-sql>输入的指令来完成。 spark-sql可以使用内置的Hive metadata-store，也可以使用已经独立安装的Hive的metadata store   关于Hive build into Spark
  • js做的各种倒计时 ronin47 js 倒计时
    第一种：精确到秒的javascript倒计时代码      HTML代码:   <form name="form1">   <div align="center" align="middle"
  • java-37.有n 个长为m+1 的字符串，如果某个字符串的最后m 个字符与某个字符串的前m 个字符匹配，则两个字符串可以联接 bylijinnan java
    public class MaxCatenate { /* * Q.37 有n 个长为m+1 的字符串，如果某个字符串的最后m 个字符与某个字符串的前m 个字符匹配，则两个字符串可以联接， * 问这n 个字符串最多可以连成一个多长的字符串，如果出现循环，则返回错误。 */ public static void main(String[] args){
  • mongoDB安装 开窍的石头 mongodb安装 基本操作
    mongoDB的安装          1:mongoDB下载   https://www.mongodb.org/downloads         2:下载mongoDB下载后解压     
  • [开源项目]引擎的关键意义 comsci 开源项目
         一个系统，最核心的东西就是引擎。。。。。       而要设计和制造出引擎，最关键的是要坚持。。。。。。       现在最先进的引擎技术，也是从莱特兄弟那里出现的，但是中间一直没有断过研发的    
  • 软件度量的一些方法 cuiyadll 方法
    软件度量的一些方法http://cuiyingfeng.blog.51cto.com/43841/6775/在前面我们已介绍了组成软件度量的几个方面。在这里我们将先给出关于这几个方面的一个纲要介绍。在后面我们还会作进一步具体的阐述。当我们不从高层次的概念级来看软件度量及其目标的时候，我们很容易把这些活动看成是不同而且毫不相干的。我们现在希望表明他们是怎样恰如其分地嵌入我们的框架的。也就是我们度量的
  • XSD中的targetNameSpace解释 darrenzhu xmlnamespacexsdtargetnamespace
    参考链接: http://blog.csdn.net/colin1014/article/details/357694 xsd文件中定义了一个targetNameSpace后，其内部定义的元素，属性，类型等都属于该targetNameSpace,其自身或外部xsd文件使用这些元素，属性等都必须从定义的targetNameSpace中找： 例如：以下xsd文件，就出现了该错误，即便是在一
  • 什么是RAID0、RAID1、RAID0+1、RAID5，等磁盘阵列模式? dcj3sjt126com raid
    RAID 1又称为Mirror或Mirroring，它的宗旨是最大限度的保证用户数据的可用性和可修复性。 RAID 1的操作方式是把用户写入硬盘的数据百分之百地自动复制到另外一个硬盘上。由于对存储的数据进行百分之百的备份，在所有RAID级别中，RAID 1提供最高的数据安全保障。同样，由于数据的百分之百备份，备份数据占了总存储空间的一半，因而，Mirror的磁盘空间利用率低，存储成本高。 Mir
  • yii2 restful web服务快速入门 dcj3sjt126com PHPyii2
    快速入门 Yii 提供了一整套用来简化实现 RESTful 风格的 Web Service 服务的 API。 特别是，Yii 支持以下关于 RESTful 风格的 API： 支持 Active Record 类的通用API的快速原型 涉及的响应格式（在默认情况下支持 JSON 和 XML) 支持可选输出字段的定制对象序列化 适当的格式的数据采集和验证错误
  • MongoDB查询(3)——内嵌文档查询（七） eksliang MongoDB查询内嵌文档MongoDB查询内嵌数组
    MongoDB查询内嵌文档 转载请出自出处：http://eksliang.iteye.com/blog/2177301 一、概述        有两种方法可以查询内嵌文档：查询整个文档；针对键值对进行查询。这两种方式是不同的，下面我通过例子进行分别说明。   二、查询整个文档 例如:有如下文档 db.emp.insert({ &qu
  • android4.4从系统图库无法加载图片的问题 gundumw100 android
    典型的使用场景就是要设置一个头像，头像需要从系统图库或者拍照获得，在android4.4之前，我用的代码没问题，但是今天使用android4.4的时候突然发现不灵了。baidu了一圈，终于解决了。 下面是解决方案： private String[] items = new String[] { "图库","拍照" }; /* 头像名称 */
  • 网页特效大全 jQuery等 ini JavaScriptjquerycsshtml5ini
    HTML5和CSS3知识和特效 asp.net ajax jquery实例 分享一个下雪的特效 jQuery倾斜的动画导航菜单 选美大赛示例 你会选谁 jQuery实现HTML5时钟 功能强大的滚动播放插件JQ-Slide 万圣节快乐！！！ 向上弹出菜单jQuery插件 htm5视差动画 jquery将列表倒转顺序 推荐一个jQuery分页插件 jquery animate
  • swift objc_setAssociatedObject block(version1.2 xcode6.4) 啸笑天 version
      import UIKit class LSObjectWrapper: NSObject { let value: ((barButton: UIButton?) -> Void)? init(value: (barButton: UIButton?) -> Void) { self.value = value
  • Aegis 默认的 Xfire 绑定方式，将 XML 映射为 POJO MagicMa_007 javaPOJOxmlAegisxfire
          Aegis 是一个默认的 Xfire 绑定方式，它将 XML 映射为 POJO, 支持代码先行的开发.你开发服 务类与 POJO,它为你生成 XML schema/wsdl XML 和 注解映射概览       默认情况下，你的 POJO 类被是基于他们的名字与命名空间被序列化。如果
  • js get max value in (json) Array qiaolevip 每天进步一点点学习永无止境max纵观千象
    // Max value in Array var arr = [1,2,3,5,3,2];Math.max.apply(null, arr); // 5 // Max value in Jaon Array var arr = [{"x":"8/11/2009","y":0.026572007},{"x"
  • XMLhttpRequest 请求 XML,JSON ,POJO 数据 Luob. POJOjsonAjaxxmlXMLhttpREquest
    在使用XMlhttpRequest对象发送请求和响应之前，必须首先使用javaScript对象创建一个XMLHttpRquest对象。 var xmlhttp； function getXMLHttpRequest(){ if(window.ActiveXObject){ xmlhttp:new ActiveXObject("Microsoft.XMLHTTP
  • jquery wuai jquery
    以下防止文档在完全加载之前运行Jquery代码，否则会出现试图隐藏一个不存在的元素、获得未完全加载的图像的大小 等等 $(document).ready(function(){ jquery代码; }); <script type="text/javascript" src="c:/scripts/jquery-1.4.2.min.js&quo
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他