HRESULT
CMilSlaveRenderData::Draw(
    __in_ecount(1) IDrawingContext *pIDC
    )
{
    // 读取渲染任务
    IFC(cmdReader.GetFirstItemSafe(&nItemID, &pItemData, &nItemDataSize));
    ... // 忽略其他代码
    while (hr == S_OK)
    {
            switch (nItemID)
            {
                ... // 忽略其他代码
                case MilDrawGlyphRun:
                {
                    MILCMD_DRAW_GLYPH_RUN *pData = reinterpret_cast<MILCMD_DRAW_GLYPH_RUN*>(pItemData);
                    
                    IFC(pCurrentDC->DrawGlyphRun(
                        DYNCAST(CMilBrushDuce, rgpResources[pData->hForegroundBrush]),
                        DYNCAST(CGlyphRunResource, rgpResources[pData->hGlyphRun])
                        ));
                    break;
                }
            }

        ... // 忽略其他代码

        // 读取下一个渲染任务
        IFC(cmdReader.GetNextItemSafe(
            &nItemID,
            &pItemData,
            &nItemDataSize
            ));
    }
}

HRESULT
CMilSlaveRenderData::Draw(
    __in_ecount(1) IDrawingContext *pIDC
    )
{
    // 读取渲染任务
    IFC(cmdReader.GetFirstItemSafe(&nItemID, &pItemData, &nItemDataSize));

    ... // 忽略其他代码

Cleanup:

    RRETURN(hr);
}

struct MILCMD_DRAW_GLYPH_RUN
{
    MILCMD type;
    HMIL_RESOURCE hForegroundBrush;
    HMIL_RESOURCE hGlyphRun;
};

HRESULT
CDrawingContext::DrawGlyphRun(
    __in_ecount_opt(1) CMilBrushDuce *pBrush,
    __in_ecount_opt(1) CGlyphRunResource *pGlyphRun
    )
{
    HRESULT hr = S_OK;

    CBrushRealizer *pFillBrush = xxx; // 填充画刷，文本前景色
    ... // 忽略其他代码

    // 判断 ShouldUseGeometry 是否应该使用 Geometry 几何方式渲染，如果是，那就采用 DrawGeometry 方法进行实际的渲染
    if (pGlyphRun->ShouldUseGeometry(&m_contextState.WorldToDevice, m_contextState.GetCurrentOrDefaultDisplaySettings()))
    {
        // 获取字形的 Geometry 几何
        const CMilGeometryDuce *pGeometry = pGlyphRun->GetGeometryRes();
        ... // 忽略其他代码

        // 调用 DrawGeometry 绘制 Geometry 内容，这个 Geometry 就是文本的字形的 Geometry 几何
        DrawGeometry(
                pBrush,
                NULL, // Pen
                pGlyphRun->GetGeometryRes()
                );
    }
    else  // Assume this GlyphRun uses realizations; we will create them on demand as needed
    {
        ... // 忽略其他代码

        // 构建出 DrawGlyphsParameters 绘制 Glyphs 的参数对象
                DrawGlyphsParameters pars;
                    pars.pContextState = &m_contextState;
                    pars.pBrushContext = &m_brushContext;
                    pars.pGlyphRun = pGlyphRun;
                    pars.pBrushRealizer = pFillBrush;


                ... // 忽略其他代码

        // 调用 m_pIRenderTarget 的 DrawGlyphs 执行渲染
                IFC(m_pIRenderTarget->DrawGlyphs(pars));
    }

Cleanup:
    if (pFillBrush)
    {
        pFillBrush->FreeRealizationResources();
        pFillBrush->Release();
    }

    ... // 忽略其他代码

    RRETURN(hr);
}

class CDesktopHWNDRenderTarget:
    public CDesktopRenderTarget
{
}

class CDesktopRenderTarget:
    public CMILCOMBase,
    public CMetaRenderTarget,
    public IMILRenderTargetHWND
{
}

class CMetaRenderTarget:
    public IRenderTargetInternal
{
STDMETHODIMP CMetaRenderTarget::DrawGlyphs(
    __inout_ecount(1) DrawGlyphsParameters &pars
    )
    {
        ... // 忽略其他代码
    }
}

STDMETHODIMP CMetaRenderTarget::DrawGlyphs(
    __inout_ecount(1) DrawGlyphsParameters &pars
    )
{
    HRESULT hr = S_OK;
    ... // 忽略其他代码
            IRenderTargetInternal *pRTInternalNoAddRef = xxx;

            IFC(pRTInternalNoAddRef->DrawGlyphs(pars));

Cleanup:
    ... // 忽略其他代码

    RRETURN(hr);
}

class CHwHWNDRenderTarget : 
    public CHwDisplayRenderTarget
{
}

class CHwDisplayRenderTarget :
    public CMILCOMBase,
    public CHwSurfaceRenderTarget,
    public IRenderTargetHWNDInternal
{
    STDMETHODIMP
    CHwDisplayRenderTarget::DrawGlyphs(
        __inout_ecount(1) DrawGlyphsParameters &pars
    )
    {
        ... // 忽略其他代码
    }
}

class CHwDisplayRenderTarget :
    public CMILCOMBase,
    public CHwSurfaceRenderTarget,
    public IRenderTargetHWNDInternal
{
    STDMETHODIMP
    CHwDisplayRenderTarget::DrawGlyphs(
        __inout_ecount(1) DrawGlyphsParameters &pars
    )
    {
        ... // 忽略其他代码
        IFC(CHwSurfaceRenderTarget::DrawGlyphs(pars));
    }
}

class CHwSurfaceRenderTarget :
    public CBaseSurfaceRenderTarget<CHwRenderTargetLayerData>
{
    STDMETHODIMP
    CHwSurfaceRenderTarget::DrawGlyphs(
       __inout_ecount(1) DrawGlyphsParameters &pars
       )
    {
        CD3DGlyphRunPainter painter;

        IFC(painter.Paint(
            pars,
            fTargetSupportsClearType,
            m_pD3DDevice,
            m_fmtTarget
            ));
    }

HRESULT
CD3DGlyphRunPainter::Paint(
    __in_ecount(1) DrawGlyphsParameters &pars,
    bool fTargetSupportsClearType,
    __inout_ecount(1) CD3DDeviceLevel1* pDevice,
    MilPixelFormat::Enum fmtTargetSurface
    )
{
    MilPointAndSizeL rcClip;
    m_pDevice->GetClipRect(&rcClip);

    ... // 忽略其他代码

        // Do a rough check for glyph run visibility.
        // We need it, at least, to protect against
        // overflows in rendering routines.
        CRectF<CoordinateSpace::Device> rcClipF(
            static_cast<float>(rcClip.X),
            static_cast<float>(rcClip.Y),
            static_cast<float>(rcClip.Width),
            static_cast<float>(rcClip.Height),
            XYWH_Parameters
            );

        if (!pars.rcBounds.Device().DoesIntersect(rcClipF))
            goto Cleanup;
    
}

HRESULT
CGlyphRunRealization::RealizeAlphaBoundsAndTextures(
    DWRITE_TEXTURE_TYPE textureType, 
    __in_opt const EnhancedContrastTable *pECT,
    __out UINT32 *pTextureSize,
    __out RECT *pBoundingBox,
    __deref_out_ecount_opt(*pTextureSize) BYTE **pAlphaMap
    )
{
    HRESULT hr = S_OK;
    RECT boundingBox;
    BYTE *pAlphaValues = NULL;
    
    IFC(m_pIDWriteGlyphRunAnalysis->GetAlphaTextureBounds(
        textureType,
        &boundingBox
        ));

    ... // 忽略其他代码

        //
        // Calculate required buffer size considering the bounds
        //
        UINT32 width = boundingBox.right - boundingBox.left;
        UINT32 height = boundingBox.bottom - boundingBox.top;        
        UINT32 textureStride = width;
        if (textureType == DWRITE_TEXTURE_CLEARTYPE_3x1) 
        {
            // ClearType bitmaps (DWRITE_TEXTURE_CLEARTYPE_3x1) contain 3 bytes per pixel, 
            // Aliased bitmaps only contain 1.
            textureStride *= 3;
        }
        UINT32 textureSize = textureStride * height;
        
        pAlphaValues = (BYTE *)WPFAlloc(ProcessHeap,
                                        (textureType == DWRITE_TEXTURE_CLEARTYPE_3x1 ? Mt(GlyphBitmapClearType) : Mt(GlyphBitmapBiLevel)),
                                        textureSize);
        ... // 忽略其他代码

        // 这是核心调用代码
        IFC(m_pIDWriteGlyphRunAnalysis->CreateAlphaTexture(
            textureType,
            &boundingBox,
            pAlphaValues,
            textureSize
            ));
                                                    
        *pAlphaMap = pAlphaValues;
        *pTextureSize = textureSize;
        *pBoundingBox = boundingBox;

Cleanup:
    
    RRETURN(hr);
}

    if (m_data.m_pHwColorSource == NULL)
    {
        // solid brush

        if (fClearType)
        {
            m_pfnDrawRectangle = m_pDevice->CanDrawTextUsingPS20()
                ? sc_pfnDrawRectangle_CVertM1_CT_1Pass
                : sc_pfnDrawRectangle_CVertM3_1Pass;

            IFC(m_pDevice->SetRenderState_Text_ClearType_SolidBrush(m_data.color, pars.pGlyphRun->GetGammaIndex()));
        }
        else
        {
            m_pfnDrawRectangle = sc_pfnDrawRectangle_CVertM1_1Pass;
            IFC(m_pDevice->SetRenderState_Text_GreyScale_SolidBrush(m_data.color, pars.pGlyphRun->GetGammaIndex()));
        }
    }
    else
    {   // textured brush
        if (fClearType)
        {
            m_pfnDrawRectangle = sc_pfnDrawRectangle_CVertBM_3Pass;
            IFC(m_pDevice->SetRenderState_Text_ClearType_TextureBrush(pars.pGlyphRun->GetGammaIndex(), flAlphaScale));
        }
        else
        {
            m_pfnDrawRectangle = sc_pfnDrawRectangle_CVertBM_1Pass;
            IFC(m_pDevice->SetRenderState_Text_GreyScale_TextureBrush(pars.pGlyphRun->GetGammaIndex(), flAlphaScale));
        }
    }

HRESULT
CD3DGlyphRunPainter::Paint(
    __in_ecount(1) DrawGlyphsParameters &pars,
    bool fTargetSupportsClearType,
    __inout_ecount(1) CD3DDeviceLevel1* pDevice,
    MilPixelFormat::Enum fmtTargetSurface
    )
{
    ... // 忽略其他代码

    for (m_pSubGlyph = m_pGlyphRun->GetFirstSubGlyph(); m_pSubGlyph; m_pSubGlyph = m_pSubGlyph->GetNext())
    {
        ... // 忽略其他代码
        IFC(m_pSubGlyph->ValidateAlphaMap(this));
        ... // 忽略其他代码
    }
}

HRESULT
CD3DSubGlyph::ValidateAlphaMap(CD3DGlyphRunPainter* pPainter)
{
    ... // 忽略其他代码

        BYTE* pAlphaArray = NULL;
        UINT32 alphaArraySize = 0;
        pPainter->GetAlphaArray(&pAlphaArray, &alphaArraySize);

        IFC(pPainter->GetBank()->RectFillAlpha(
            m_pTank,
            tankLocation,
            pAlphaArray, 
            pRun->GetFilteredRect(),
            m_rcFiltered
            ));

    ... // 忽略其他代码
}

//+-----------------------------------------------------------------------------
//
//  Member:
//      CD3DGlyphBank::RectFillAlpha
//
//  Synopsis:
//      Fill rectangular space in shared glyph bank storage with given alpha
//      data. Given pSrcData and fullDataRect represent the whole data array,
//      where pSrcData[0] corresponds to left top corner of fullDataRect and
//      pitch = fullDataRect's width. Only part of these data is moved to
//      destination; this part is limited with srcRect. The srcRect not
//      necessary lays inside fullDataRect; if some texels of srcRect are out of
//      fullDataRect, then zeroes are moved to corresponding destination texels.
//
//------------------------------------------------------------------------------
HRESULT CD3DGlyphBank::RectFillAlpha(
    __inout_ecount(1) CD3DGlyphTank* pTank,
    __in_ecount(1) const POINT& dstPoint,
    __in_ecount(1) const BYTE* pSrcData,
    __in_ecount(1) const RECT& fullDataRect,
    __in_ecount(1) const RECT& srcRect
    )
{
    ... // 忽略其他代码
    // 将传入的 pSrcData 等信息先写入到 pTempSurface 里面，再通过 UpdateSurface 更新到 pTankSurface 里面
    IDirect3DSurface9* pTankSurface = pTank->GetSurfaceNoAddref();

    IFC( m_pDevice->UpdateSurface(
        pTempSurface,
        &rcTemp,
        pTankSurface,
        &dstPoint
        ));

    ... // 忽略其他代码
}

HRESULT
CD3DGlyphBank::CreateTank(UINT uHeight, BOOL fPersistent)
{
    HRESULT hr = S_OK;

    IDirect3DSurface9 *pSurface = NULL;
    IDirect3DTexture9 *pTexture = NULL;
    CD3DGlyphTank* pTank = 0;

    D3DSURFACE_DESC sd;
    sd.Format = m_pDevice->GetAlphaTextureFormat();
    sd.Type = D3DRTYPE_TEXTURE;
    sd.Usage = 0;
    sd.Pool = D3DPOOL_DEFAULT;
    sd.MultiSampleType = D3DMULTISAMPLE_NONE;
    sd.MultiSampleQuality = 0;
    sd.Width = m_uMaxTankWidth;
    sd.Height = uHeight;

    IFC( m_pDevice->CreateTexture(&sd, 1, &pTexture) );

    IFC( pTexture->GetSurfaceLevel(0, &pSurface) );

    ... // 忽略其他代码

    pTank = new CD3DGlyphTank(
        pTexture,
        pSurface,
        m_uMaxTankWidth,
        uHeight,
        m_pResourceManager
        );

    ... // 忽略其他代码
}

class CD3DGlyphRunPainter : public CBaseGlyphRunPainter
{

    HRESULT
    CD3DGlyphRunPainter::Paint(
        __in_ecount(1) DrawGlyphsParameters &pars,
        bool fTargetSupportsClearType,
        __inout_ecount(1) CD3DDeviceLevel1* pDevice,
        MilPixelFormat::Enum fmtTargetSurface
        )
    {
        ... // 忽略其他代码

        for (m_pSubGlyph = m_pGlyphRun->GetFirstSubGlyph(); m_pSubGlyph; m_pSubGlyph = m_pSubGlyph->GetNext())
        {
            ... // 忽略其他代码
            IFC(m_pSubGlyph->ValidateAlphaMap(this));
            ... // 忽略其他代码
            m_data.pMaskTexture = m_pSubGlyph->GetTank()->GetTextureNoAddref();
            ... // 忽略其他代码
            MIL_THR((this->*m_pfnDrawRectangle)()); // 这是一个方法指针，将会根据不同的参数调用到不同的方法进行绘制矩形
            ... // 忽略其他代码
        }
    }

private:
    VertexFillData m_data;
}

struct VertexFillData
{
    // matrix transform from work space to render space
    const MILMatrix3x2* pxfGlyphWR;

    // scaling transform from work space to masking texture space
    float kxWT, kyWT, dxWT, dyWT;

    // mask texture container
    IDirect3DTexture9* pMaskTexture;

    // offsets in texture space corresponding to shift by 1/3 pixel
    // along X-coordinate in render space
    float ds, dt;

    // solid brush color
    DWORD color;

    // brush texture
    CHwTexturedColorSource *m_pHwColorSource;

    // matrix transform from render space to brush texture space
    MILMatrix3x2 xfBrushRT;

    float blueOffset;
};

STDMETHODIMP CMetaRenderTarget::DrawGlyphs(
    __inout_ecount(1) DrawGlyphsParameters &pars
    )
{
    ... // 忽略其他代码
    IFC(pRTInternalNoAddRef->DrawGlyphs(pars)); // pRTInternalNoAddRef 0x000002d9a322ea50 {m_hwnd=0x0000000004422b20 {unused=??? } m_pPresenter=0x000002d9a14a2540 {m_pIdealDisplay=...} ...}  IRenderTargetInternal * {CSwRenderTargetHWND}
}

class CSwRenderTargetHWND :
    public CSwRenderTargetSurface,
    public IRenderTargetHWNDInternal
    DBG_STEP_RENDERING_COMMA_PARAM(public ISteppedRenderingDisplayRT)
{
}

class CSwRenderTargetSurface :
    public CMILCOMBase,
    public CBaseSurfaceRenderTarget<CSwRenderTargetLayerData>,
    public CSpanSink
{
    STDMETHODIMP CSwRenderTargetSurface::DrawGlyphs(
    __inout_ecount(1) DrawGlyphsParameters &pars
    )
    {
        ... // 忽略其他代码
    }
}

class CSwRenderTargetSurface :
    public CMILCOMBase,
    public CBaseSurfaceRenderTarget<CSwRenderTargetLayerData>,
    public CSpanSink
{
    STDMETHODIMP CSwRenderTargetSurface::DrawGlyphs(
    __inout_ecount(1) DrawGlyphsParameters &pars
    )
    {
        ... // 忽略其他代码
        IFC(m_sr.DrawGlyphRun(
            this,
            &Clipper,
            pars,
            pBrushNoRef,
            flAlphaScale,
            &m_glyphPainterMemory,
            fTargetSupportsClearType
            ));
    }

protected:
   CSoftwareRasterizer m_sr;
}

HRESULT
CSWGlyphRunPainter::Init(
    __inout_ecount(1) DrawGlyphsParameters &pars,
    FLOAT flEffectAlpha,
    __inout_ecount(1) CGlyphPainterMemory* pGlyphPainterMemory,
    BOOL fTargetSupportsClearType,
    __out_ecount(1) BOOL* pfVisible
    )
{
    ... // 忽略其他代码

        if (m_fIsClearType)
        {
            m_pfnScanOpFuncCopyBGR = sc_pfnClearTypeBilinear32bppBGRCopy;
            m_pfnScanOpFuncOverBGR = sc_pfnClearTypeBilinear32bppBGROver;
            m_pfnScanOpFuncCopyPBGRA = sc_pfnClearTypeBilinear32bppPBGRACopy;
            m_pfnScanOpFuncOverPBGRA = sc_pfnClearTypeBilinear32bppPBGRAOver;
        }
        else
        {
            m_pfnScanOpFuncCopyBGR = sc_pfnGreyScaleBilinear32bppBGRCopy;
            m_pfnScanOpFuncOverBGR = sc_pfnGreyScaleBilinear32bppBGROver;
            m_pfnScanOpFuncCopyPBGRA = sc_pfnGreyScaleBilinear32bppPBGRACopy;
            m_pfnScanOpFuncOverPBGRA = sc_pfnGreyScaleBilinear32bppPBGRAOver;
        }

    ... // 忽略其他代码
}

ScanOpFunc
CSWGlyphRunPainter::GetScanOpCopy(MilPixelFormat::Enum fmtColorSource)
{
    if (fmtColorSource == MilPixelFormat::BGR32bpp)
    {
        return m_pfnScanOpFuncCopyBGR;
    }
    else
    {
        Assert(fmtColorSource == MilPixelFormat::PBGRA32bpp);
        return m_pfnScanOpFuncCopyPBGRA;
    }
}

ScanOpFunc
CSWGlyphRunPainter::GetScanOpOver(MilPixelFormat::Enum fmtColorSource)
{
    if (fmtColorSource == MilPixelFormat::BGR32bpp)
    {
        return m_pfnScanOpFuncOverBGR;
    }
    else
    {
        Assert(fmtColorSource == MilPixelFormat::PBGRA32bpp);
        return m_pfnScanOpFuncOverPBGRA;
    }
}