Overzicht van geometrierealisaties

In dit onderwerp wordt beschreven hoe u Direct2D geometrierealisaties gebruikt om de geometrieprestaties van uw app in bepaalde scenario's te verbeteren.

Deze bevat de volgende secties:

• Wat zijn geometrierealisaties?
• Waarom geometrierealisaties gebruiken?
• Wanneer geometrierealisaties worden gebruikt
• Geometrierealisaties maken
• Tekeningen van geometrische realisaties
• Schaalvergrotingen van geometrie-uitvoeringen
  • Geometrievormgeving gebruiken in apps die niet schaalbaar zijn
  • Met behulp van geometrische realisaties in apps die in een kleine mate worden geschaald
  • Geometrische realisaties gebruiken in apps die in hoge mate worden geschaald
• Verwante onderwerpen

Wat zijn geometrierealisaties?

Geometrierealisaties, geïntroduceerd in Windows 8.1, zijn een nieuw type tekenprimitief waarmee u eenvoudig Direct2D-apps kunt gebruiken om de geometrieweergaveprestaties in bepaalde gevallen te verbeteren. Geometrierealisaties worden vertegenwoordigd door de interface ID2D1GeometryRealization.

Waarom geometrierealisaties gebruiken?

Wanneer Direct2D- een ID2D1Geometry object weergeeft, moet deze geometrie worden geconverteerd naar een vorm die de grafische hardware begrijpt via een proces dat tessellation wordt genoemd. Direct2D moet normaal gesproken de geometrie tesselleren bij elke keer dat deze wordt getekend, zelfs als de geometrie niet verandert. Als uw app elke frame dezelfde geometrie weergeeft, vertegenwoordigt de herhaalde herssseling verspilde rekenkracht. Het is rekenkundig efficiënter om de tessellation, of zelfs de volledige rastervorming, van de geometrie in de cache op te slaan en om die gecachede weergave bij elk frame te tekenen in plaats van herhaaldelijk te tesselleren.

Een veelvoorkomende manier waarop ontwikkelaars dit probleem oplossen, is door de volledige rasterisering van de geometrie in de cache te plaatsen. Het is met name gebruikelijk om een nieuwe bitmap te maken, de geometrie naar die bitmap te rasteren en die bitmap vervolgens naar de scène te tekenen, indien nodig. (Deze benadering wordt beschreven in het gedeelte Geometry rendering gedeelte van Het verbeteren van de prestaties van Direct2D-apps.) Hoewel deze aanpak zeer efficiënt is, heeft het enkele nadelen:

• De bitmap in de cache is gevoelig voor wijzigingen in de transformatie die op de scène zijn toegepast. Het schalen van het raster kan bijvoorbeeld resulteren in de merkbare schaalartefacten. Het beperken van deze artefacten met hoogwaardige schaalalgoritmen kan rekenintensief zijn.
• De bitmap in de cache verbruikt een aanzienlijke hoeveelheid geheugen, met name als deze wordt gerasterd met een hoge resolutie.

Geometrierealisaties bieden een alternatieve manier om geometrie op te cachen die de bovenstaande nadelen voorkomt. Geometrierealisaties worden niet vertegenwoordigd door pixels (zoals het geval is met een volledige rasterisering), maar in plaats daarvan door punten op een wiskundig vlak. Daarom zijn ze minder gevoelig dan volledige rasterisaties voor schalen en andere manipulatie, en verbruiken ze aanzienlijk minder geheugen.

Wanneer gebruikt u geometrierealisaties

Overweeg het gebruik van geometrierealisaties wanneer uw app complexe geometrieën weergeeft waarvan de vormen onregelmatig veranderen, maar die mogelijk onderhevig zijn aan veranderende transformaties.

Denk bijvoorbeeld aan een toewijzingstoepassing met een statische kaart, maar waarmee de gebruiker kan in- en uitzoomen. Deze app kan profiteren van het gebruik van geometrierealisaties. Omdat de geometrieën die worden weergegeven statisch blijven, is het handig om ze in de cache op te slaan om tesselingswerk op te slaan. Maar omdat de kaarten worden geschaald wanneer de gebruiker inzoomt, is het opslaan van een volledige rasterisatie niet ideaal vanwege het schalen van artefacten. Het cachen van geometrieën kan de app in staat stellen om retessellatie te voorkomen en tegelijkertijd een hoge visuele kwaliteit te behouden tijdens het schalen.

Houd daarentegen rekening met een kaleidoscoop-app met geanimeerde geometrie die voortdurend verandert. Deze app zou waarschijnlijk niet profiteren van het gebruik van geometrierealisaties. Omdat de vormen zelf veranderen van frame naar frame, is het niet handig om hun tessellations op te cachen. De beste methode voor deze app is om ID2D1Geometry objecten rechtstreeks te tekenen.

Geometrierealisaties maken

Een ID2D1GeometryRealization-object moet worden gemaakt op basis van een bestaand ID2D1Geometry-object. Als u een geometrie-realisatie wilt maken, roept u de methode CreateFilledGeometryRealization aan of de methode CreateStrokedGeometryRealization, en geeft u de ID2D1Geometry door die moet worden gerealiseerd.

• CreateFilledGeometryRealization maakt een realisatie van het interieur van de vorm: het gebied dat zou worden getekend door FillGeometryaan te roepen.
• CreateStrokedGeometryRealization maakt een realisatie van de omtrek van de vorm: het gebied dat zou worden getekend door DrawGeometryaan te roepen.

Beide soorten geometrierealisatie worden vertegenwoordigd door de interface ID2D1GeometryRealization.

Bij het maken van een geometrierealisatie moet Direct2D- eventuele curven in de opgegeven geometrie platmaken tot veelhoekige benaderingen. U moet een afvlakkende tolerantieparameter opgeven voor de aanmaakmethode. Hiermee geeft u de maximale afstand op, in apparaatonafhankelijke pixels (DIPs), tussen de werkelijke curve van de geometrie en de veelhoekige benadering. Hoe lager de afvlakkende tolerantie die u opgeeft, hoe hoger de betrouwbaarheid van het resulterende geometrierealisatieobject. Op dezelfde manier levert het bieden van een hogere afvlakkende tolerantie een realisatie van een geometrie met een lagere kwaliteit op. Houd er rekening mee dat de realisaties van een geometrie met een hogere kwaliteit duurder zijn dan lagere kwaliteit, maar ze kunnen verder worden geschaald voordat zichtbare artefacten worden geïntroduceerd. Zie Schalen van geometrierealisaties hieronder voor richtlijnen over het gebruik van afvlaktoleranties.

Realisaties van tekengeometrie

Het tekenen van geometrieën is vergelijkbaar met het tekenen van andere Direct2D primitieve vormen, zoals bij bitmaps. Hiervoor roept u de methode DrawGeometryRealization aan en geeft u het geometrierealisatie-object door dat moet worden getekend, samen met de kwast die moet worden gebruikt. Net als bij andere Direct2D-tekenmethoden moet u DrawGeometryRealization aanroepen tussen aanroepen naar BeginDraw- en EndDraw-aanroepen.

Het schalen van geometrische realisaties

Geometrie-realisaties, zoals andere Direct2D primitieven, respecteren de transformatie die is ingesteld op de apparaatcontext. Hoewel vertalings- en rotatietransformaties geen effect hebben op de visuele kwaliteit van geometrierealisaties, kunnen schaaltransformaties visuele artefacten produceren.

Met name het toepassen van een grote schaal op elke geometrierealisatie kan de veelhoekige benadering van de werkelijke curven onthullen. Deze afbeelding toont een paar elliptische geometrieën (opvulling en lijn) die te ver geëscaleerd zijn. Curve-afvlakking artefacten zijn zichtbaar.

Apps die gevoelig zijn voor visuele kwaliteit moeten maatregelen nemen om ervoor te zorgen dat dit niet gebeurt. Hoe u schalen afhandelt, is afhankelijk van de behoeften van uw app. Hieronder volgen verschillende aanbevolen benaderingen voor verschillende typen apps.

Geometrische realisaties gebruiken in apps die niet schaalbaar zijn

Als uw app geen schaalaanpassing uitvoert op de geometrierealisaties, is het veilig om de realisaties slechts één keer te maken, met behulp van één afvlakkende tolerantie. (Transformaties die niet worden geschaald, hebben geen invloed op de visuele kwaliteit van gerenderde geometrierealisaties.) Gebruik de functie ComputeFlatteningTolerance om de juiste afvlaktolerantie voor de DPI te berekenen:

    float dpiX, dpiY;
    deviceContext->GetDpi(&dpiX, &dpiY);

    float flatteningTolerance = D2D1::ComputeFlatteningTolerance(
        D2D1::Matrix3x2F::Identity(),   // apply no additional scaling transform
        dpiX,                           // horizontal DPI
        dpiY                            // vertical DPI
        );

Geometrierealisaties gebruiken in apps die met een kleine hoeveelheid schalen

Als uw app een geometrierealisatie met slechts een kleine hoeveelheid omhoog kan schalen (bijvoorbeeld tot 2x of 3x), is het misschien handig om de geometrierealisatie eenmaal te maken, met een proportioneel lagere afvlaktolerantie dan de standaardwaarde. Hierdoor ontstaat een hogere betrouwbaarheidsrealisatie die aanzienlijk omhoog kan worden geschaald voordat er schaalartefacten worden gemaakt; de afweging is dat het tekenen van de hogere kwaliteit realisatie meer werk vereist.

Stel dat u weet dat uw app nooit met meer dan 2x een geometrierealisatie zal schalen. Uw app kan de geometrierealisatie maken met behulp van een afvlakkende tolerantie die de helft van de standaardwaarde is en de realisatie eenvoudigweg naar behoefte schalen, tot 2x. Gebruik de functie ComputeFlatteningTolerance om de juiste afvlakkende tolerantie te berekenen door 2.0 door te geven als de parameter maxZoomFactor:

    float dpiX, dpiY;
    deviceContext->GetDpi(&dpiX, &dpiY);
    
    float flatteningTolerance = D2D1::ComputeFlatteningTolerance(
        D2D1::Matrix3x2F::Identity(),   // apply no additional scaling transform
        dpiX,                           // horizontal DPI
        dpiY,                           // vertical DPI
        2.0f                            // realization can be scaled by an additional 2x
        );

Geometrierealisaties gebruiken in apps die in grote mate schalen

Als uw app een geometrierealisatie omhoog of omlaag kan schalen met grote hoeveelheden (bijvoorbeeld 10x of meer), is het afhandelen van schaalaanpassing op de juiste manier ingewikkelder.

Voor de meeste van deze apps is de aanbevolen methode om de geometrische weergave opnieuw te creëren bij geleidelijk lagere afvlakkende toleranties wanneer de schaal van de scène wordt vergroot, om de visuele nauwkeurigheid te behouden en schaalartefacten te voorkomen. Op dezelfde manier moet de app, naarmate de scène omlaag wordt geschaald, de geometrierealisaties bij geleidelijk hogere afvlakkende toleranties opnieuw maken om onnodige renderingdetails te voorkomen die niet zichtbaar zijn. De app mag de geometrierealisaties niet telkens opnieuw maken wanneer de schaal verandert, omdat dit het doel van het opslaan van het tessellationwerk verslaat. In plaats daarvan moet de app de geometrierealisaties minder vaak opnieuw maken: bijvoorbeeld na elke 2x toename of afname in schaal.

Telkens wanneer de schaal verandert in een app als reactie op interactie van de gebruiker, kan de app de nieuwe schaal vergelijken met de schaal waarop de geometrierealisaties voor het laatst zijn gemaakt (bijvoorbeeld opgeslagen in een m_lastScale lid). Als de twee waarden dicht zijn (in dit geval binnen een factor van 2), wordt er geen verdere actie ondernomen. Maar als de twee waarden niet dicht zijn, worden de geometrierealisaties opnieuw gemaakt. De functie ComputeFlatteningTolerance wordt gebruikt om een afvlakkende tolerantie te berekenen die geschikt is voor de nieuwe schaal en m_lastScale wordt bijgewerkt naar de nieuwe schaal.

Bovendien maakt de app altijd realisaties met behulp van een kleinere tolerantie dan wat normaal gesproken voor de nieuwe schaal zou worden gebruikt, door een waarde van 2 door te geven als de parameter maxZoomFactor aan ComputeFlatteningTolerance. Hierdoor kunnen de nieuwe geometrierealisaties worden opgeschaald met een extra factor van 2 zonder dat er schaalartefacten worden gemaakt.

Verwante onderwerpen

Overzicht van de geometrieën

De prestaties van Direct2D-apps verbeteren

Algemene richtlijnen voor het weergeven van complexe statische inhoud

ID2D1DeviceContext1

ID2D1GeometryRealization

de functie ComputeFlatteningTolerance