Dela via

Förbättra prestandan för Direct2D-appar

  • Artikel

Även om Direct2D- är maskinvaruaccelererad och är avsedd för höga prestanda, måste du använda funktionerna korrekt för att maximera dataflödet. De tekniker som vi visar här är härledda från att studera vanliga scenarier och kanske inte gäller för alla appscenarier. Därför kan noggrann förståelse av appens beteende och prestandamål hjälpa dig att uppnå de resultat du vill ha.

Resursanvändning

En resurs är en allokering av något slag, antingen i video- eller systemminne. Bitmappar och penslar är exempel på resurser.

I Direct2D kan resurser skapas både i programvara och maskinvara. Resursskapande och borttagning på maskinvara är dyra åtgärder eftersom de kräver mycket omkostnader för att kommunicera med grafikkortet. Nu ska vi se hur Direct2D renderar innehåll till ett mål.

I Direct2D omges alla återgivningskommandon mellan ett anrop till BeginDraw och ett anrop till EndDraw. Dessa anrop görs till ett renderingsmål. Du måste anropa metoden BeginDraw innan du anropar renderingsåtgärder . När du anropar BeginDraw bygger en kontext vanligtvis upp en batch av renderingskommandon, men fördröjer bearbetningen av dessa kommandon tills något av detta påstående är sant:

  • EndDraw inträffade. När EndDraw- anropas gör det att alla batchbaserade ritningsåtgärder slutförs och returnerar åtgärdens status.
  • Du gör ett explicit anrop till Flush: Metoden Flush gör att batchen bearbetas och alla väntande kommandon utfärdas.
  • Bufferten som innehåller återgivningskommandona är full. Om bufferten blir full innan de föregående två villkoren uppfylls, spolas återgivningskommandona ut.

Tills primitiverna har tömts behåller Direct2D interna referenser till motsvarande resurser som bitmappar och penslar.

Återanvända resurser

Som redan nämnts är det dyrt att skapa och ta bort resurser på maskinvaran. Så återanvänd resurser när det är möjligt. Ta exemplet med att skapa bitmappar i spelutveckling. Vanligtvis skapas bitmappar som utgör en scen i ett spel samtidigt med alla de olika varianter som krävs för senare bild-till-bild-återgivning. Vid tidpunkten för faktisk scenrendering och återrendering återanvänds dessa bitmappar i stället för att återskapas.

Anteckning

Du kan inte återanvända resurser för åtgärden för att ändra storlek på fönstret. När ett fönster ändrar storlek måste vissa skalberoende resurser, till exempel kompatibla återgivningsmål och eventuellt vissa lagerresurser, återskapas eftersom innehållet i fönstret måste ritas om. Detta kan vara viktigt för att upprätthålla den renderade scenens övergripande kvalitet.

 

Begränsa användningen av tömning

Eftersom metoden Flush gör att batchbaserade återgivningskommandon bearbetas rekommenderar vi att du inte använder den. För de vanligaste scenarierna lämnar du resurshantering till Direct2D.

Bitmappar

Som tidigare nämnts är resursskapande och borttagning mycket dyra åtgärder i maskinvaran. En bitmapp är en typ av resurs som används ofta. Det är dyrt att skapa bitmappar på grafikkortet. Om du återanvänder dem kan du göra programmet snabbare.

Skapa stora bitmappar

Grafikkort har vanligtvis en minsta minnesallokeringsstorlek. Om en allokering begärs som är mindre än detta allokeras en resurs med den här minsta storleken och överskottsminnet slösas bort och är inte tillgängligt för andra saker. Om du behöver många små bitmappar är en bättre teknik att allokera en stor bitmapp och lagra allt litet bitmappsinnehåll i den här stora bitmappen. Sedan kan delområden i den större bitmappen läsas där de mindre bitmapparna behövs. Du bör ofta inkludera utfyllnad (transparenta svarta bildpunkter) mellan de små bitmapparna för att undvika interaktion mellan de mindre bilderna under åtgärder. Detta kallas även för en atlasoch har fördelen att minska kostnaderna för att skapa bitmappar och minnesavfallet för små bitmappsallokeringar. Vi rekommenderar att du behåller de flesta bitmappar till minst 64 KB och begränsar antalet bitmappar som är mindre än 4 kB.

Skapa en atlas över bitmappar

Det finns några vanliga scenarier där en bitmappsatlas kan fungera mycket bra. Små bitmappar kan lagras i en stor bitmapp. Dessa små bitmappar kan hämtas från den större bitmappen när du behöver dem genom att ange målrektangeln. Ett program måste till exempel rita flera ikoner. Alla bitmappar som är associerade med ikonerna kan läsas in i en stor bitmapp i förväg. Och vid rendreringen kan de hämtas från den stora bitmappen.

Not

En Direct2D-bitmapp som skapats i videominnet begränsas till den maximala bitmappsstorlek som stöds av det kort där den lagras. Om du skapar en bitmapp som är större än den kan det leda till ett fel.

 

Not

Från och med Windows 8 innehåller Direct2D en Atlas-effekt som kan göra processen enklare.

 

Skapa delade bitmappar

Genom att skapa delade bitmappar kan avancerade anropare skapa Direct2D-bitmappsobjekt som backas upp direkt av ett befintligt objekt, som redan är kompatibelt med återgivningsmålet. Detta undviker att skapa flera ytor och bidrar till att minska prestandakostnaderna.

Anmärkning

Delade bitmappar är vanligtvis begränsade till programvarumål eller till mål som kan samverka med DXGI. Använd CreateBitmapFromDxgiSurface, CreateBitmapFromWicBitmapoch CreateSharedBitmap metoder för att skapa delade bitmappar.

 

Kopiera bitmappar

Att skapa en DXGI-yta är en dyr åtgärd, så återanvänd befintliga ytor när du kan. Även i programvara, om en bitmapp mestadels är i den form du vill ha förutom en liten del, är det bättre att uppdatera den delen än att kasta bort hela bitmappen och återskapa allt. Även om du kan använda CreateCompatibleRenderTarget för att uppnå samma resultat, är rendering i allmänhet en mycket dyrare åtgärd än kopiering. Detta beror på att, för att förbättra cachelokaliteten, maskinvaran inte faktiskt lagrar en bitmapp i samma minnesordning som bitmappen adresseras. I stället kan bitmappen vara swizzled. Swizzlingen döljs från processorn antingen av drivrutinen (som är långsam och endast används på nedre delen) eller av minneshanteraren på GPU:n. På grund av begränsningar för hur data skrivs in i ett återgivningsmål vid återgivningen är återgivningsmål vanligtvis antingen inte swirlad eller swirlad på ett sätt som är mindre optimalt än vad som kan uppnås om du vet att du aldrig behöver rendera på ytan. Därför tillhandahålls metoderna CopyFrom* för att kopiera rektanglar från en källa till Direct2D-bitmappen.

CopyFrom kan användas i någon av dess tre formulär:

Använda tillagda bitmappar över streck

Att återge en streckad linje är en mycket dyr åtgärd på grund av den underliggande algoritmens höga kvalitet och noggrannhet. I de flesta fall som inte omfattar rätlinjiga geometrier kan samma effekt genereras snabbare med hjälp av kaklade bitmaps.

Allmänna riktlinjer för att återge komplext statiskt innehåll

Lagra innehållet i cacheminnet om du återger samma innehållsram ruta för ruta, speciellt vid komplexa scener.

Det finns tre cachelagringstekniker som du kan använda:

  • Fullständig cachning av scenen med hjälp av en färgbitmapp.
  • Per primitiv cachelagring med hjälp av en A8-bitmapp och metoden FillOpacityMask.
  • Per primitiv cachelagring med hjälp av geometriinföranden.

Nu ska vi titta närmare på var och en av dessa.

Cachelagring av hela scenen med hjälp av en färgbitmapp

När du renderar statiskt innehåll skapar du i scenarier som animering en annan fullfärgsbitmapp i stället för att skriva direkt till skärmbitmappen. Spara det aktuella målet, ange målet till den mellanliggande bitmappen och återge det statiska innehållet. Växla sedan tillbaka till den ursprungliga skärmbitmappen och rita den mellanliggande bitmappen på den.

Här är ett exempel:

// Create a bitmap.
m_d2dContext->CreateBitmap(size, nullptr, 0,
    D2D1::BitmapProperties(
        D2D1_BITMAP_OPTIONS_TARGET,
        D2D1::PixelFormat(
            DXGI_FORMAT_B8G8R8A8_UNORM,
            D2D1_ALPHA_MODE_PREMULTIPLIED),
        dpiX, dpiY),
    &sceneBitmap);

// Preserve the pre-existing target.
ComPtr<ID2D1Image> oldTarget;
m_d2dContext->GetTarget(&oldTarget);

// Render static content to the sceneBitmap.
m_d2dContext->SetTarget(sceneBitmap.Get());
m_d2dContext->BeginDraw();
…
m_d2dContext->EndDraw();

// Render sceneBitmap to oldTarget.
m_d2dContext->SetTarget(oldTarget.Get());
m_d2dContext->DrawBitmap(sceneBitmap.Get());

I det här exemplet används intermediära bitmappar för cachelagring och växlar den bitmapp som enhetskontexten pekar på vid rendering. På så sätt undviker du behovet av att skapa ett kompatibelt återgivningsmål för samma ändamål.

För varje primitiv cachelagring med hjälp av en A8-bitmapp och metoden FillOpacityMask

När den fullständiga scenen inte är statisk, men består av element som geometri eller text som är statiska, kan du använda en per primitiv cachelagringsteknik. Den här tekniken bevarar egenskaperna för utjämning av kanter hos det primitiva objekt som cachelagras och fungerar med olika penseltyper. Den använder en A8-bitmapp där A8 är ett slags pixelformat som representerar en alfakanal med 8 bitar. A8-bitmappar är användbara för att rita geometri/text som en mask. När du måste ändra opaciteten för statiskt innehåll i stället för att ändra själva innehållet kan du översätta, rotera, skeva eller skala maskens opacitet.

Här är ett exempel:

// Create an opacity bitmap.
m_d2dContext->CreateBitmap(size, nullptr, 0,
    D2D1::BitmapProperties(
        D2D1_BITMAP_OPTIONS_TARGET,
        D2D1::PixelFormat(
            DXGI_FORMAT_A8_UNORM,
            D2D1_ALPHA_MODE_PREMULTIPLIED),
        dpiX, dpiY),
    &opacityBitmap);

// Preserve the pre-existing target.
ComPtr<ID2D1Image> oldTarget;
m_d2dContext->GetTarget(&oldTarget);

// Render to the opacityBitmap.
m_d2dContext->SetTarget(opacityBitmap.Get());
m_d2dContext->BeginDraw();
…
m_d2dContext->EndDraw();

// Call the FillOpacityMask method
// Note: for this call to work correctly the anti alias mode must be D2D1_ANTIALIAS_MODE_ALIASED. 
m_d2dContext->SetTarget(oldTarget.Get());
m_d2dContext->FillOpacityMask(
    opacityBitmap.Get(),
    m_contentBrush().Get(),
    D2D1_OPACITY_MASK_CONTENT_GRAPHICS);

Per-primitiv cachelagring med hjälp av geometriska realiseringar

En annan per primitiv cachelagringsteknik, som kallas geometriinföranden, ger större flexibilitet vid hantering av geometri. När du upprepade gånger vill rita alias- eller antialiasgeometrier är det snabbare att konvertera dem till geometriinföranden och upprepade gånger rita realiseringarna än det är att rita geometrierna själva upprepade gånger. Geometrigenomföranden förbrukar också i allmänhet mindre minne än ogenomskinlighetsmasker (särskilt för stora geometrier), och de är mindre känsliga för förändringar i skala. Mer information finns i översikten över Geometri-realisationer.

Här är ett exempel:

    // Compute a flattening tolerance based on the scales at which the realization will be used.
    float flatteningTolerance = D2D1::ComputeFlatteningTolerance(...);

    ComPtr<ID2D1GeometryRealization> geometryRealization;

    // Create realization of the filled interior of the geometry.
    m_d2dDeviceContext1->CreateFilledGeometryRealization(
        geometry.Get(),
        flatteningTolerance,
        &geometryRealization
        );

    // In your app's rendering code, draw the geometry realization with a brush.
    m_d2dDeviceContext1->BeginDraw();
    m_d2dDeviceContext1->DrawGeometryRealization(
        geometryRealization.Get(),
        m_brush.Get()
        );
    m_d2dDeviceContext1->EndDraw();

Geometriåtergivning

Använd specifik rita primitiv istället för rita geometri

Använd mer specifikaprimitiva-anrop som DrawRectangle över allmänna DrawGeometry--anrop. Detta beror på att med DrawRectangleär geometrin redan känd så renderingen går snabbare.

Återge statisk geometri

I scenarier där geometrin är statisk använder du de per-primitiva cachelagringstekniker som beskrivs ovan. Ogenomskinlighetsmasker och geometrigenomföranden kan avsevärt förbättra renderingshastigheten för scener som innehåller statisk geometri..

Använda en flertrådad enhetskontext

Program som förväntar sig att återge stora mängder komplext geometriskt innehåll bör överväga att ange flaggan D2D1_DEVICE_CONTEXT_OPTIONS_ENABLE_MULTI_THREADED_OPTIMIZATIONS när du skapar en Direct2D- enhetskontext. När den här flaggan anges distribuerar Direct2D rendering över alla logiska kärnor som finns i systemet, vilket kan minska den totala återgivningstiden avsevärt.

Anteckningar:

  • Från och med Windows 8.1 påverkar den här flaggan endast sökvägsgeometrirendering. Det har ingen inverkan på scener som bara innehåller andra primitiva typer (till exempel text, bitmappar eller geometriinföranden).
  • Den här flaggan påverkar inte heller återgivningen i programvara (d.v.s. vid återgivning med en WARP Direct3D-enhet). För att styra programvara med multitrådning bör anropare använda flaggan D3D11_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS när de skapar WARP Direct3D-enheten.
  • Att ange den här flaggan kan öka den högsta arbetsuppsättningen under återgivningen och kan också öka trådkonkurrensen i program som redan utnyttjar bearbetning med flera trådar.

Rita text med Direct2D

Direct2D-textrenderingsfunktioner erbjuds i två delar. Den första delen, som exponeras som ID2D1RenderTarget::DrawText och ID2D1RenderTarget::DrawTextLayout-metoden, gör det möjligt för en anropare att skicka antingen en sträng och formateringsparametrar eller ett DWrite-textlayoutobjekt för flera format. Detta bör vara lämpligt för de flesta uppringare. Det andra sättet att rendera text, som exponeras som metoden ID2D1RenderTarget::DrawGlyphRun, ger rastrering för kunder som redan känner till positionen för de glyfer som de vill rendera. Följande två allmänna regler kan hjälpa till att förbättra textprestanda vid ritning i Direct2D.

DrawTextLayout jämfört med DrawText

Både DrawText och DrawTextLayout göra det möjligt för ett program att enkelt återge text som formateras av api:et DirectWrite. DrawTextLayout ritar ett befintligt DWriteTextLayout- objekt till RenderTargetoch DrawText skapar en DirectWrite-layout för anroparen baserat på de parametrar som skickas in. Om samma text måste återges flera gånger använder du DrawTextLayout i stället för DrawTexteftersom DrawText skapar en layout varje gång den anropas.

Välja rätt textåtergivningsläge

Ange läget för textantialias till D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE explicit. Kvaliteten på återgivning av gråskaletext är jämförbar med ClearType men är mycket snabbare.

Cachelagring

Använd fullständig scen eller per primitiv bitmappscache som vid ritning av andra primitiver.

Klippa ut en godtycklig form

Bilden här visar resultatet av att tillämpa ett klipp på en bild.

en bild som visar ett exempel på en bild före och efter ett klipp.

Du kan få det här resultatet genom att använda lager med en geometrimask eller metoden FillGeometry med en ogenomskinlig pensel.

Här är ett exempel som använder ett lager:

// Call PushLayer() and pass in the clipping geometry.
m_d2dContext->PushLayer(
    D2D1::LayerParameters(
        boundsRect,
        geometricMask));

Här är ett exempel som använder metoden FillGeometry:

// Create an opacity bitmap and render content.
m_d2dContext->CreateBitmap(size, nullptr, 0,
    D2D1::BitmapProperties(
        D2D1_BITMAP_OPTIONS_TARGET,
        D2D1::PixelFormat(
            DXGI_FORMAT_A8_UNORM,
            D2D1_ALPHA_MODE_PREMULTIPLIED),
        dpiX, dpiY),
    &opacityBitmap);

m_d2dContext->SetTarget(opacityBitmap.Get());
m_d2dContext->BeginDraw();
…
m_d2dContext->EndDraw();

// Create an opacity brush from the opacity bitmap.
m_d2dContext->CreateBitmapBrush(opacityBitmap.Get(),
    D2D1::BitmapBrushProperties(),
    D2D1::BrushProperties(),
    &bitmapBrush);

// Call the FillGeometry method and pass in the clip geometry and the opacity brush
m_d2dContext->FillGeometry( 
    clipGeometry.Get(),
    brush.Get(),
    opacityBrush.Get());

När du anropar PushLayer-metoden i det här kodexemplet skickar du inte in ett lager som skapats av appen. Direct2D skapar ett lager åt dig. Direct2D kan hantera allokeringen och förstörelsen av den här resursen utan någon inblandning från appen. Detta gör att Direct2D kan återanvända lager internt och tillämpa resurshanteringsoptimeringar.

I Windows 8 har många optimeringar gjorts för användning av lager och vi rekommenderar att du försöker använda lager-API:er i stället för FillGeometry när det är möjligt.

PushLayer i Windows 8

Gränssnittet ID2D1DeviceContext härleds från gränssnittet ID2D1RenderTarget och är nyckeln till att visa Direct2D-innehåll i Windows 8. Mer information om det här gränssnittet finns i Enheter och enhetskontexter. Med gränssnittet för enhetskontext kan du hoppa över att anropa metoden CreateLayer och sedan skicka NULL till metoden ID2D1DeviceContext::P ushLayer. Direct2D hanterar automatiskt lagerresursen och kan dela resurser mellan lager och effektdiagram.

Axelanpassade urklipp

Om den region som ska klipps ut justeras mot axeln på ritytan, i stället för godtycklig. Det här fallet är lämpligt att använda en klipprektangel i stället för ett lager. Prestandavinsten är mer för aliasgeometri än antialiaserad geometri. Mer information om axelinriktade klipp finns i avsnittet PushAxisAlignedClip.

DXGI-samverkan: undvik frekventa omkopplingar

Direct2D kan samverka sömlöst med Direct3D-ytor. Detta är mycket användbart för att skapa program som återger en blandning av 2D- och 3D-innehåll. Men varje växling mellan att rita Direct2D- och Direct3D-innehåll påverkar prestandan.

När Direct2D renderar på en DXGI-yta sparar den tillståndet för Direct3D-enheterna under renderingen och återställer det när processen är slutförd. Varje gång en batch med Direct2D-rendering slutförs betalas kostnaden för den här sparande och återställningen och kostnaden för att rensa alla 2D-åtgärder, och ändå rensas inte Direct3D-enheten. För att öka prestandan begränsar du därför antalet återgivningsväxlar mellan Direct2D och Direct3D.

Känna till pixelformatet

När du skapar ett återgivningsmål kan du använda strukturen D2D1_PIXEL_FORMAT ange pixelformatet och alfaläget som används av återgivningsmålet. En alfakanal är en del av pixelformatet som anger täckningsvärdet eller opacitetsinformationen. Om ett återgivningsmål inte använder alfakanalen bör det skapas med hjälp av D2D1_ALPHA_MODE_IGNORE alfamode. Detta sparar den tid som ägnas åt att återge en alfakanal som inte behövs.

Mer information om pixelformat och alfalägen finns i Pixelformat som stöds och Alfalägen.

Scenkomplexitet

När du analyserar prestandapunkter i en scen som återges kan du få användbar information om huruvida scenen är fyllningshastighetsbunden eller brytpunktsbunden.

  • Fyllningshastighet: Fyllningshastighet refererar till antalet bildpunkter som ett grafikkort kan återge och skriva till videominne per sekund.
  • Hörnbunden: En scen är hörnbunden när den innehåller mycket komplex geometri.

Förstå scenkomplexitet

Du kan analysera scenkomplexiteten genom att ändra storleken på återgivningsmålet. Om prestandavinster är synliga vid en proportionell minskning i storlek på återgivningsmålet, är programmet begränsat av fyllningstakten. Annars är scenkomplexiteten en flaskhals för prestanda.

När en scen är beroende av fyllningshastigheten kan det förbättra prestandan genom att minska storleken på renderingsmålet. Det beror på att antalet bildpunkter som ska återges minskas proportionellt med storleken på återgivningsmålet.

När en scen är hörnbunden minskar du geometrins komplexitet. Men kom ihåg att detta görs på bekostnad av bildkvaliteten. Därför bör ett noggrant kompromissbeslut fattas mellan önskad kvalitet och den prestanda som krävs.

Förbättra prestanda för Direct2D-utskriftsappar

Direct2D erbjuder kompatibilitet med utskrift. Du kan skicka samma Direct2D-ritningskommandon (i form av Direct2D-kommandolistor) till Direct2D-utskriftskontrollen för utskrift, om du inte vet vilka enheter du ritar till eller hur ritningen översätts till utskrift.

Du kan finjustera deras användning av Direct2D- utskriftskontroll och dina Direct2D-ritningskommandon för att ge utskriftsresultat med bättre prestanda.

Direct2D utskriftskontroll matar ut felsökningsmeddelanden när det ser ett Direct2D-kodmönster som leder till lägre utskriftskvalitet eller prestanda (t.ex. kodmönster som anges senare i det här avsnittet) för att påminna dig om var du kan undvika prestandaproblem. Om du vill se dessa felsökningsmeddelanden måste du aktivera Direct2D-felsökningslager i koden. Se Felsöka meddelanden för instruktioner för att aktivera felsökning av meddelandeutdata.

Ange rätt egenskapsvärden när du skapar D2D-utskriftskontrollen

Det finns tre egenskaper som du kan ange när du skapar Direct2D- utskriftskontroll. Två av dessa egenskaper påverkar hur Direct2D-utskriftskontrollen hanterar vissa Direct2D-kommandon och i sin tur påverkar den övergripande prestandan.

  • Teckensnittets underuppsättningsläge: Direct2D utskriftskontroll underuppsätter teckensnittsresurser som används på varje sida innan sidan skickas för utskrift. Det här läget minskar storleken på sidresurser som behövs för utskrift. Beroende på teckensnittsanvändningen på sidan kan du välja olika teckensnittsunderuppsättningslägen för bästa prestanda.
    • D2D1_PRINT_FONT_SUBSET_MODE_DEFAULT ger bästa utskriftsprestanda i de flesta fall. När det här läget är valt använder Direct2D- utskriftskontrollen en heuristisk strategi för att bestämma när teckensnitt ska delas upp.
    • För korta utskriftsjobb med 1 eller 2 sidor rekommenderar vi D2D1_PRINT_FONT_SUBSET_MODE_EACHPAGE , där Direct2D- utskriftskontrollunderuppsättningar och bäddar in teckensnittsresurser på varje sida och sedan tar bort den teckensnittsunderuppsättningen när sidan skrivs ut. Det här alternativet ser till att varje sida kan skrivas ut omedelbart efter att den har genererats, men ökar storleken på sidresurserna som behövs för utskrift (med vanligtvis stora teckensnittsunderuppsättningar).
    • För utskriftsjobb med många sidor med texter och små teckenstorlekar (t.ex. 100 sidor med text som använder ett enda teckensnitt) rekommenderar vi D2D1_PRINT_FONT_SUBSET_MODE_NONE, där Direct2D- utskriftskontroll inte alls underordnas teckensnittsresurser. I stället skickar den ut de ursprungliga teckensnittsresurserna tillsammans med sidan som först använder teckensnittet och återanvänder teckensnittsresurserna för senare sidor utan att skicka dem igen.
  • Rastrerings-DPI: När Direct2D- utskriftskontroll måste rastrera Direct2D-kommandon under Direct2D-XPS konvertering använder den denna DPI för rastrering. Med andra ord, om sidan inte har något rastrerat innehåll ändrar inte inställningen av DPI prestanda och kvalitet. Beroende på rastreringsanvändningen på sidan kan du välja olika rastrerings-DPI:er för bästa balans mellan återgivning och prestanda.
    • 150 är standardvärdet om du inte anger något värde när du skapar Direct2D- utskriftskontroll, vilket är den bästa balansen mellan utskriftskvalitet och utskriftsprestanda i de flesta fall.
    • Högre DPI-värden resulterar vanligtvis i bättre utskriftskvalitet (som i mer information bevarad) men lägre prestanda på grund av de större bitmappar som genereras. Vi rekommenderar inte något DPI-värde som är större än 300 eftersom det inte introducerar extra information som kan uppfattas visuellt av mänskliga ögon.
    • Lägre DPI kan innebära bättre prestanda men kan också ge lägre kvalitet.

Undvik att använda vissa Direct2D-ritningsmönster

Det finns skillnader mellan vad Direct2D- kan representera visuellt och vad undersystemet för utskrift kan underhålla och transportera längs hela utskriftspipelinen. Direct2D-utskriftskontrollen överbryggar dessa luckor genom att antingen approximera eller rastrera Direct2D-primitiver som utskriftsundersystemet inte har inbyggt stöd för. En sådan uppskattning resulterar vanligtvis i lägre utskriftsåtergivning, lägre utskriftsprestanda eller både och. Även om en kund kan använda samma ritmönster för både skärm- och utskriftsrendering är det därför inte idealiskt i alla fall. Det är bäst att undvika att använda sådana Direct2D-primitiver och mönster så mycket man kan för utskriftsvägen, eller att göra en egen rastrering där du har fullständig kontroll över kvaliteten och storleken på de rastrerade bilderna.

Här är en lista över fall där utskriftsprestanda och kvalitet inte är idealiska och du kanske vill överväga att variera kodsökvägen för optimal utskriftsprestanda.

  • Undvik att använda ett annat primitivt blandningsläge än D2D1_PRIMITIVE_BLEND_SOURCEOVER.
  • Undvik att använda kompositionslägen när du ritar en bild med andra lägen än D2D1_COMPOSITE_MODE_SOURCE_OVER och D2D1_COMPOSITE_MODE_DESTINATION_OVER.
  • Undvik att rita en GDI-metafil.
  • Undvik att överföra en lagerresurs som kopierar källbakgrunden (anropar PushLayer genom att skicka D2D1_LAYER_OPTIONS1_INITIALIZE_FROM_BACKGROUND till D2D1_LAYER_PARAMETERS1 struktur).
  • Undvik att skapa Bitmap Brush eller Image Brush med D2D1_EXTEND_MODE_CLAMP. Vi rekommenderar att du använder D2D1_EXTEND_MODE_MIRROR om du inte bekymrar dig om pixlar utanför bildens gränser överhuvudtaget (t.ex. när bilden som är kopplad till penseln är större än det fyllda målområdet).
  • Undvik att rita bitmappar med Perspective Transforms.

Rita text på ett direkt och enkelt sätt

Direct2D har flera optimeringar när text återges för bättre prestanda och/eller bättre visuell kvalitet. Men inte alla optimeringar förbättrar utskriftsprestanda och kvalitet eftersom utskriften på papper vanligtvis är i en mycket högre DPI, och utskriften behöver inte rymma scenarier som animering. Därför rekommenderar vi att du ritar den ursprungliga texten eller glyf direkt och undviker någon av följande optimeringar när du skapar kommandolistan för utskrift.

  • Undvik att rita text med metoden FillOpacityMask.
  • Undvik att rita text i aliasläge.

Rita de ursprungliga bitmapparna när det är möjligt

Om målbitmappen är en JPEG- PNG, TIFF eller JPEG-XR kan du skapa en WIC-bitmapp antingen från en diskfil eller från en minnesintern ström och sedan skapa en Direct2D- bitmapp från den WIC-bitmappen med hjälp av ID2D1DeviceContext::CreateBitmapFromWicBitmapoch slutligen direkt skicka direct2D-bitmappen till Direct2D-utskriftskontrollen utan ytterligare manipulation. Genom att göra det kan Direct2D-utskriftskontrollen återanvända bitmappsströmmen, vilket vanligtvis leder till bättre utskriftsprestanda (genom att hoppa över redundant bitmappskodning och avkodning) och bättre utskriftskvalitet (när metadata, till exempel färgprofiler, i bitmappen bevaras).

När du ritar den ursprungliga bitmappen får du följande fördelar för program.

  • I allmänhet bevarar Direct2D- utskrift den ursprungliga informationen (utan förlust eller brus) till sent i pipelinen, särskilt när appar inte vet (eller inte vill veta) informationen om utskriftspipelinen (som vilken skrivare den skriver ut till, vad DPI är målskrivaren och så vidare).
  • I många fall innebär fördröjning av rastrering av bitmapp bättre prestanda (till exempel när du skriver ut ett 96dpi-foto till en 600dpi-skrivare).
  • I vissa fall är det enda sättet att uppfylla hög återgivning (till exempel inbäddade färgprofiler) att skicka de ursprungliga bilderna.

Du kan dock inte välja en sådan optimering eftersom:

  • Genom att fråga skrivarinformation och tidig rastrering kan du rastrera själva innehållet med fullständig kontroll över det slutliga utseendet på papper.
  • I vissa fall kan tidig rasterisering faktiskt förbättra appens prestanda från slutpunkt till slutpunkt (som att skriva ut plånboksstorleksfoton).
  • I vissa fall kräver överföring av de ursprungliga bitmapparna betydande ändringar av befintlig kodarkitektur (till exempel inläsning av bildfördröjning och resursuppdateringssökvägar som finns i vissa program).

Slutsats

Även om Direct2D är maskinvaruaccelererat och är avsett för höga prestanda måste du använda funktionerna korrekt för att maximera dataflödet. De tekniker vi har tittat på här är härledda från att studera vanliga scenarier och kanske inte gäller för alla programscenarier.