Delen via

DXGI-overzicht

Microsoft DirectX Graphics Infrastructure (DXGI) herkent dat sommige delen van afbeeldingen langzamer ontwikkelen dan andere. Het belangrijkste doel van DXGI is het beheren van taken op laag niveau die onafhankelijk kunnen zijn van de DirectX Graphics Runtime. DXGI biedt een gemeenschappelijk framework voor toekomstige grafische onderdelen; het eerste onderdeel dat gebruikmaakt van DXGI is Microsoft Direct3D 10.

In eerdere versies van Direct3D werden taken op laag niveau, zoals inventarisatie van hardwareapparaten, weergegeven frames aan een uitvoer presenteren, gamma beheren en een overgang op volledig scherm beheren opgenomen in de Direct3D-runtime. Deze taken worden nu geïmplementeerd in DXGI.

DXGI is bedoeld om te communiceren met het kernelmodusstuurprogramma en de systeemhardware, zoals wordt weergegeven in het volgende diagram.

diagram van de communicatie tussen toepassingen, dxgi en stuurprogramma's en hardware

Een toepassing heeft rechtstreeks toegang tot DXGI of roept de Direct3D-API's aan in D3D11_1.h, D3D11.h, D3D10_1.h of D3D10.h, die de communicatie met DXGI voor u verwerkt. U kunt rechtstreeks met DXGI werken als uw toepassing apparaten moet inventariseren of bepalen hoe gegevens worden gepresenteerd aan een uitvoer.

Dit onderwerp bevat de volgende secties.

Om te zien welke formaten worden ondersteund door Direct3D 11-hardware:

Adapters opsommen

Een adapter is een abstractie van de hardware en de softwaremogelijkheden van uw computer. Er zijn over het algemeen veel adapters op uw computer. Sommige apparaten worden geïmplementeerd in hardware (zoals uw videokaart) en sommige zijn geïmplementeerd in software (zoals de Direct3D-referentieraster). Adapters implementeren functionaliteit die wordt gebruikt door een grafische toepassing. In het volgende diagram ziet u een systeem met één computer, twee adapters (videokaarten) en drie uitvoermonitors.

diagram van een computer met twee videokaarten en drie beeldschermen

Bij het inventariseren van deze hardwareonderdelen maakt DXGI een IDXGIOutput1-interface voor elke uitvoer (of monitor) en een IDXGIAdapter2-interface voor elke videokaart (zelfs als het een videokaart is die is ingebouwd in een moederbord). Opsomming wordt uitgevoerd met behulp van een IDXGIFactory-interfaceaanroep , IDXGIFactory::EnumAdapters, om een set IDXGIAdapter-interfaces te retourneren die de videohardware vertegenwoordigen.

DXGI 1.1 heeft de IDXGIFactory1-interface toegevoegd. IDXGIFactory1::EnumAdapters1 retourneert een set IDXGIAdapter1-interfaces die de videohardware vertegenwoordigt.

Als u specifieke mogelijkheden voor videohardware wilt selecteren wanneer u Direct3D-API's gebruikt, raden we u aan de functie D3D11CreateDevice of D3D11CreateDeviceAndSwapChain aan te roepen met elke adaptergreep en mogelijk hardwarefunctieniveau. Deze functie slaagt als het functieniveau wordt ondersteund door de opgegeven adapter.

Nieuwe informatie over het inventariseren van adapters voor Windows 8

Vanaf Windows 8 is een adapter met de naam Microsoft Basic Render Driver altijd aanwezig. Deze adapter heeft een VendorId van 0x1414 en een DeviceID van 0x8c. Deze adapter heeft ook de DXGI_ADAPTER_FLAG_SOFTWARE waarde ingesteld in het lid Vlaggen van de DXGI_ADAPTER_DESC2 structuur. Deze adapter is een apparaat dat alleen rendeert en geen weergave-uitgangen heeft. DXGI retourneert nooit DXGI_ERROR_DEVICE_REMOVED voor deze adapter.

Als het beeldschermstuurprogramma van een computer niet werkt of is uitgeschakeld, wordt de primaire adapter van de computer (NULL) mogelijk ook wel 'Microsoft Basic Render Driver' genoemd. Maar deze adapter heeft uitvoer en heeft niet de DXGI_ADAPTER_FLAG_SOFTWARE waarde ingesteld. Het besturingssysteem en de apps gebruiken deze adapter standaard. Als een beeldschermstuurprogramma is geïnstalleerd of ingeschakeld, kunnen apps DXGI_ERROR_DEVICE_REMOVED ontvangen voor deze adapter en moeten de adapters vervolgens opnieuw worden opgesomd.

Wanneer de primaire beeldschermadapter van een computer de WARP-adapter (Microsoft Basic Display Adapter) is, heeft die computer ook een tweede adapter. Deze tweede adapter is het alleen-renderapparaat met geen beeldschermuitvoer en waarvoor DXGI nooit DXGI_ERROR_DEVICE_REMOVED retourneert.

Als u WARP wilt gebruiken voor rendering, berekening of andere langlopende taken, raden we u aan het alleen-renderapparaat te gebruiken. U kunt een aanwijzer naar het alleen-renderapparaat verkrijgen door de methode IDXGIFactory1::EnumAdapters1 aan te roepen. U maakt ook het alleen-renderapparaat wanneer u D3D_DRIVER_TYPE_WARP opgeeft in de parameter DriverType van D3D11CreateDevice , omdat het WARP-apparaat ook gebruikmaakt van de WARP-adapter met alleen-renderen.

Presentatie

De taak van uw toepassing is om frames weer te geven en DXGI te vragen deze frames aan de uitvoer te presenteren. Als de toepassing twee buffers beschikbaar heeft, kan één buffer worden gerenderd terwijl een andere buffer wordt gepresenteerd. De toepassing vereist mogelijk meer dan twee buffers, afhankelijk van de tijd die nodig is om een frame of de gewenste framesnelheid voor de presentatie weer te geven. De reeks gemaakte buffers wordt een swap chain genoemd, zoals hier wordt weergegeven.

afbeelding van een wisselketen

Een wisselketen heeft één voorbuffer en een of meer achterbuffers. Elke toepassing maakt een eigen wisselketen. Om de snelheid van de presentatie van de gegevens naar een uitvoer te maximaliseren, wordt er bijna altijd een wisselketen gemaakt in het geheugen van een weergavesubsysteem, dat wordt weergegeven in de volgende afbeelding.

afbeelding van een weergavesubsysteem

Het displaysubsysteem (dat vaak een videokaart is, maar kan worden geïmplementeerd op een moederbord) bevat een GPU, een dac (digital to analog converter) en geheugen. De swapchain wordt in dit geheugen toegewezen om de presentatie zeer snel te laten verlopen. Het weergavesubsysteem geeft de gegevens in de voorbuffer weer aan de uitvoer.

Een swap chain wordt ingesteld om weer te geven in de modus volledig scherm of venster, waardoor het niet nodig is om te weten of een uitvoer in een venster is of volledig scherm. Een wisselketen in de modus Volledig scherm kan de prestaties optimaliseren door de beeldschermresolutie te veranderen.

Een wisselketen maken

Verschillen tussen Direct3D 9 en Direct3D 10: Direct3D 10 is het eerste grafische onderdeel voor het gebruik van DXGI. DXGI heeft een aantal verschillende wisselketengedrag.
  • In DXGI is een wisselketen gekoppeld aan een venster wanneer de wisselketen wordt gemaakt. Deze wijziging verbetert de prestaties en bespaart geheugen. In eerdere versies van Direct3D kon de swapketen het venster wijzigen waaraan de swapketen is gekoppeld.
  • In DXGI is een swapchain gekoppeld aan een renderingapparaat bij de creatie. Het apparaatobject dat de Direct3D create-apparaatfuncties teruggeven, implementeert de IUnknown-interface. U kunt QueryInterface aanroepen om een query uit te voeren op de bijbehorende IDXGIDevice2-interface van het apparaat. Voor een wijziging in het renderingapparaat moet de swap chain opnieuw aangemaakt worden.

  • In DXGI zijn de beschikbare wisseleffecten DXGI_SWAP_EFFECT_DISCARD en DXGI_SWAP_EFFECT_SEQUENTIAL. Vanaf Windows 8 is het DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL wisseleffect ook beschikbaar. In de volgende tabel ziet u een mapping van Direct3D 9 naar DXGI-wisseleffectdefinities.

    D3D9-wisseleffect DXGI-wisselingseffect
    D3DSWAPEFFECT_DISCARD DXGI_SWAP_EFFECT_DISCARD
    D3DSWAPEFFECT_COPY DXGI_SWAP_EFFECT_SEQUENTIAL met 1 buffer
    D3DSWAPEFFECT_FLIP DXGI_SWAP_EFFECT_SEQUENTIAL met 2 of meer buffers
    D3DSWAPEFFECT_FLIPEX DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL met 2 of meer buffers

De buffers van een wisselketen worden gemaakt op een bepaalde grootte en in een bepaalde indeling. De toepassing geeft deze waarden op (of u kunt de grootte overnemen van het doelvenster) bij het opstarten en kan deze desgewenst wijzigen als de venstergrootte verandert als reactie op gebruikersinvoer- of programmagebeurtenissen.

Nadat u de swapchain hebt gemaakt, wilt u er typisch afbeeldingen in renderen. Hier volgt een codefragment waarmee een Direct3D-context wordt ingesteld voor weergave in een wisselketen. Met deze code wordt een buffer uit de wisselketen geëxtraheerd, wordt een render-target-view vanuit die buffer gemaakt en wordt deze vervolgens ingesteld op het apparaat:

ID3D11Resource * pBB;
ThrowFailure( pSwapChain->GetBuffer(0, __uuidof(pBB),    
  reinterpret_cast<void**>(&pBB)), "Couldn't get back buffer");
ID3D11RenderTargetView * pView;
ThrowFailure( pD3D11Device->CreateRenderTargetView(pBB, NULL, &pView), 
  "Couldn't create view" );
pD3D11DeviceContext->OMSetRenderTargets(1, &pView, 0);

Nadat uw toepassing een frame heeft weergegeven in een swap-chain buffer, roept u IDXGISwapChain1::P resent1 aan. De toepassing kan vervolgens de volgende afbeelding weergeven.

Onderhoud en beheer van de swapchain

Nadat u de afbeelding hebt weergegeven, roept u IDXGISwapChain1::P resent1 aan en gaat u de volgende afbeelding weergeven. Dat is de omvang van uw verantwoordelijkheid.

Als u eerder IDXGIFactory::MakeWindowAssociation hebt genoemd, kan de gebruiker op de Alt-Enter toetsencombinatie drukken en zet DXGI uw toepassing over tussen de modus vensters en volledig scherm. IDXGIFactory::MakeWindowAssociation wordt aanbevolen, omdat een standaard controlemechanisme voor de gebruiker sterk gewenst is.

Hoewel u niet meer code hoeft te schrijven dan is beschreven, kunnen een paar eenvoudige stappen ervoor zorgen dat uw toepassing sneller reageert. De belangrijkste overweging is het wijzigen van de grootte van de buffers van de swap chain naar aanleiding van het wijzigen van de grootte van het uitvoervenster. De beste route van de toepassing is natuurlijk om te reageren op WM_SIZE en IDXGISwapChain::ResizeBuffers aan te roepen, waarbij de grootte in de parameters van het bericht wordt doorgegeven. Dit gedrag zorgt ervoor dat uw toepassing goed reageert op de gebruiker wanneer hij of zij de randen van het venster sleept, maar het is ook precies wat een soepele overgang op volledig scherm mogelijk maakt. Uw venster ontvangt een WM_SIZE bericht wanneer een dergelijke overgang plaatsvindt en het aanroepen van IDXGISwapChain::ResizeBuffers is de kans van de wisselketen om de opslag van de buffers opnieuw toe te wijzen voor een optimale presentatie. Daarom moet de toepassing alle verwijzingen vrijgeven die deze heeft op de bestaande buffers voordat idXGISwapChain::ResizeBuffers wordt aanroepen.

Niet aanroepen van IDXGISwapChain::ResizeBuffers in reactie op het overschakelen naar de modus volledig scherm (meest logisch in reactie op WM_SIZE) kan de optimalisatie van flipping verhinderen, waarbij DXGI eenvoudig kan wisselen welke buffer wordt weergegeven in plaats van een volledige schermgrootte aan gegevens te kopiëren.

IDXGISwapChain1::P resent1 informeert u of uw uitvoervenster volledig is afgesloten via DXGI_STATUS_OCCLUDED. Als dit het geval is, raden we aan dat uw toepassing in de stand-bymodus gaat (door IDXGISwapChain1::P resent1 met DXGI_PRESENT_TEST) aan te roepen, omdat resources die worden gebruikt om het frame weer te geven, worden verspild. Als u DXGI_PRESENT_TEST gebruikt, voorkomt u dat er gegevens worden weergegeven terwijl de occlusiecontrole nog steeds wordt uitgevoerd. Zodra IDXGISwapChain1::P resent1 S_OK retourneert, moet u de stand-bymodus afsluiten; gebruik de retourcode niet om over te schakelen naar de stand-bymodus, omdat de wisselketen de modus volledig scherm niet kan verlaten.

De Direct3D 11.1-runtime, die vanaf Windows 8 beschikbaar is, biedt een wisselketen voor flip-model (dat wil gezegd een wisselketen met de DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL waarde die is ingesteld in het SwapEffect-lid van DXGI_SWAP_CHAIN_DESC of DXGI_SWAP_CHAIN_DESC1). Wanneer u frames presenteert aan een uitvoer met een flip-modelwisselketen, ontkoppelt DXGI de achterbuffer van alle locaties van de pijplijnstatus, zoals een renderdoel voor uitvoerfusie, die terugschrijven naar buffer 0. Daarom raden we aan om ID3D11DeviceContext::OMSetRenderTargets direct aan te roepen vlak voordat u naar de backbuffer rendert. Roep bijvoorbeeld OMSetRenderTargets niet aan en voer vervolgens compute shader-werk uit dat uiteindelijk niet naar de resource wordt weergegeven. Zie DXGI Flip Model voor meer informatie over flip-model swap chains en hun voordelen.

Opmerking

In Direct3D 10 en Direct3D 11 hoeft u IDXGISwapChain::GetBuffer niet aan te roepen om buffer 0 op te halen nadat u IDXGISwapChain1::P resent1 hebt aangeroepen, omdat voor het gemak de identiteiten van backbuffers veranderen. Dit gebeurt niet in Direct3D 12 en uw toepassing moet in plaats daarvan indexen van de back-buffer handmatig bijhouden.

Omgaan met het wijzigen van venstergrootte

U kunt de methode IDXGISwapChain::ResizeBuffers gebruiken om het formaat van vensters af te handelen. Voordat u ResizeBuffers aanroept, moet u alle openstaande verwijzingen naar de buffers van de wisselketen vrijgeven. Het object dat doorgaans een verwijzing naar de buffer van een wisselketen bevat, is een render-target-view.

In de volgende voorbeeldcode ziet u hoe u ResizeBuffers aanroept vanuit de WindowProc-handler voor WM_SIZE berichten:

    case WM_SIZE:
        if (g_pSwapChain)
        {
            g_pd3dDeviceContext->OMSetRenderTargets(0, 0, 0);

            // Release all outstanding references to the swap chain's buffers.
            g_pRenderTargetView->Release();

            HRESULT hr;
            // Preserve the existing buffer count and format.
            // Automatically choose the width and height to match the client rect for HWNDs.
            hr = g_pSwapChain->ResizeBuffers(0, 0, 0, DXGI_FORMAT_UNKNOWN, 0);
                                            
            // Perform error handling here!

            // Get buffer and create a render-target-view.
            ID3D11Texture2D* pBuffer;
            hr = g_pSwapChain->GetBuffer(0, __uuidof( ID3D11Texture2D),
                                         (void**) &pBuffer );
            // Perform error handling here!

            hr = g_pd3dDevice->CreateRenderTargetView(pBuffer, NULL,
                                                     &g_pRenderTargetView);
            // Perform error handling here!
            pBuffer->Release();

            g_pd3dDeviceContext->OMSetRenderTargets(1, &g_pRenderTargetView, NULL );

            // Set up the viewport.
            D3D11_VIEWPORT vp;
            vp.Width = width;
            vp.Height = height;
            vp.MinDepth = 0.0f;
            vp.MaxDepth = 1.0f;
            vp.TopLeftX = 0;
            vp.TopLeftY = 0;
            g_pd3dDeviceContext->RSSetViewports( 1, &vp );
        }
        return 1;

De DXGI-uitvoer en -grootte kiezen

DXGI kiest standaard de uitvoer die het grootste deel van het clientgebied van het venster bevat. Dit is de enige optie die beschikbaar is voor DXGI wanneer het zelf naar volledig scherm gaat als reactie op alt-enter. Als de toepassing ervoor kiest om zelf naar de modus Volledig scherm te gaan, kan deze IDXGISwapChain::SetFullscreenState aanroepen en een expliciete IDXGIOutput1 (of NULL doorgeven als de toepassing dxGI wil laten beslissen).

Als u de grootte van de uitvoer wilt wijzigen terwijl het scherm volledig of gevensterd is, raden we u aan om IDXGISwapChain::ResizeTarget aan te roepen, omdat met deze methode ook het doelvenster wordt aangepast. Omdat het doelvenster wordt gewijzigd, verzendt het besturingssysteem WM_SIZE en roept uw code IDXGISwapChain::ResizeBuffers automatisch aan. Het is dus verspilling van moeite om het formaat van uw buffers te wijzigen en vervolgens het doel te wijzigen.

Foutopsporing in de modus Volledig scherm

Een DXGI-swapketen verlaat de modus volledig scherm alleen wanneer dit absoluut noodzakelijk is. Dit betekent dat u fouten kunt opsporen in een toepassing op volledig scherm met meerdere monitors, zolang het foutopsporingsvenster niet het doelvenster van de wisselketen overlapt. U kunt ook voorkomen dat er überhaupt van modus wordt gewisseld door de vlag DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH niet in te stellen.

Als modus schakelen is toegestaan, zal een swapketen de volledige schermmodus verlaten wanneer het uitvoervenster wordt geblokkeerd door een ander venster. De occlusiecontrole wordt uitgevoerd tijdens IDXGISwapChain1::Present1 of door een afzonderlijke thread die als doel heeft te controleren of de toepassing niet meer reageert (en IDXGISwapChain1::Present1 niet meer aanroept). Als u de mogelijkheid van de afzonderlijke thread wilt uitschakelen om een switch te veroorzaken, stelt u de volgende registersleutel in op een waarde die niet nul is.

HKCU\Software\Microsoft\DXGI\DisableFullscreenWatchdog

Een wisselketen vernietigen

U mag een swap chain niet vrijgeven in de modus Volledig scherm, omdat hierdoor threadconflicten kunnen ontstaan (waardoor DXGI een niet-doorloopbare uitzondering genereert). Voordat u een wisselketen vrijgeeft, moet u eerst overschakelen naar de venstermodus (met behulp van IDXGISwapChain::SetFullscreenState( FALSE, NULL )) en vervolgens IUnknown::Release aanroepen.

Een gedraaide monitor gebruiken

Een toepassing hoeft zich geen zorgen te maken over de monitorstand. DXGI draait indien nodig een wisselketenbuffer tijdens de presentatie. Deze extra rotatie kan natuurlijk van invloed zijn op de prestaties. Zorg voor optimale prestaties door de rotatie in uw toepassing goed te beheren door het volgende te doen:

  • Gebruik de DXGI_SWAP_CHAIN_FLAG_NONPREROTATED. Hiermee wordt DXGI aangegeven dat de toepassing een gedraaide afbeelding produceert (bijvoorbeeld door de projectiematrix te wijzigen). Een ding om op te merken, deze vlag is alleen geldig in de modus Volledig scherm.
  • Wijs elke wisselketenbuffer toe in de gedraaide grootte. Gebruik IDXGIOutput::GetDesc om deze waarden op te halen, indien nodig.

Door de rotatie in uw toepassing uit te voeren, voert DXGI gewoon een kopie uit in plaats van een kopie en een draaiing.

De Direct3D 11.1 runtime, die vanaf Windows 8 beschikbaar is, biedt een flip-model swapketen (dat wil zeggen een swapketen met de DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL waarde ingesteld in het SwapEffect-lid van DXGI_SWAP_CHAIN_DESC1). Als u de presentatie-optimaties wilt maximaliseren die beschikbaar zijn met een flip-model wisselketen, raden we u aan om uw toepassingen zodanig te richten dat de inhoud overeenkomt met de specifieke uitvoer waarop de inhoud zich bevindt, wanneer de inhoud volledig de uitvoer bezet. Zie DXGI Flip Model voor meer informatie over flip-model swap chains en hun voordelen.

Schakelen tussen modi

De DXGI-wisselketting kan de weergavemodus van een uitvoer wijzigen bij een overgang naar volledig scherm. Als u de automatische weergavemoduswijziging wilt inschakelen, moet u DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH opgeven in de beschrijving van de wisselketen. Als de weergavemodus automatisch wordt gewijzigd, kiest DXGI de meest bescheiden modus (grootte en resolutie verandert niet, maar de kleurdiepte kan wel). Het wijzigen van het formaat van swapketenbuffers veroorzaakt geen moduswisseling. De swapchain belooft impliciet dat als u een backbuffer kiest die exact overeenkomt met een weergavemodus die wordt ondersteund door de doeluitvoer, deze zal overschakelen naar die weergavemodus wanneer u de volledig scherm modus op die uitvoer activeert. Daarom kiest u een weergavemodus door de grootte en opmaak van de backbuffer te kiezen.

Tip voor prestaties op volledig scherm

Wanneer u IDXGISwapChain1::Present1 aanroept op een toepassing op volledig scherm, wordt de inhoud van de backbuffer naar de frontbuffer gewisseld (in tegenstelling tot blits). Hiervoor moet de swapketen zijn gemaakt met behulp van een geënumereerde weergavemodus (opgegeven in DXGI_SWAP_CHAIN_DESC1). Als u weergavemodi niet opsommen of de weergavemodus onjuist opgeeft in de beschrijving, kan de wisselketen in plaats daarvan een bitblokoverdracht (bitblt) uitvoeren. De bitblt veroorzaakt een extra uitgerekte kopie en verhoogd videogeheugengebruik, en is moeilijk op te merken. U kunt dit probleem voorkomen door weergavemodi op te sommen en de beschrijving van de wisselketen correct te initialiseren voordat u de wisselketen maakt. Dit zorgt voor maximale prestaties bij het omslaan in de volledig scherm modus en vermijdt de extra geheugenoverhead.

Multithread-overwegingen

Wanneer u DXGI in een toepassing met meerdere threads gebruikt, moet u voorzichtig zijn om te voorkomen dat er een impasse ontstaat, waarbij twee verschillende threads op elkaar wachten om te voltooien. Er zijn twee situaties waarin dit kan gebeuren.

  • De rendering-thread is niet de berichtenpomp-thread.
  • De thread die een DXGI-API uitvoert, is niet dezelfde thread die het venster heeft gemaakt.

Wees voorzichtig dat u de berichtenpompthread nooit laat wachten op de render-thread wanneer u swapketens op volledig scherm gebruikt. Zo kan het aanroepen van IDXGISwapChain1::Present1 (vanuit de renderthread) ertoe leiden dat de renderthread wacht op de message pump-thread. Wanneer een moduswijziging plaatsvindt, is dit scenario mogelijk als Present1 ::SetWindowPos() of ::SetWindowStyle() aanroept en een van deze methoden ::SendMessage(). In dit scenario, als de berichtenpompthread een kritieke sectie heeft ter beveiliging of als de renderthread geblokkeerd wordt, zullen de twee threads een deadlock veroorzaken.

Zie Multithreading en DXGI voor meer informatie over het gebruik van DXGI met meerdere threads.

DXGI-antwoorden van DLLMain

Omdat een DllMain-functie niet de volgorde kan garanderen waarin DLL's worden geladen en verwijderd, raden we u aan de DllMain-functie van uw app geen Direct3D- of DXGI-functies of -methoden aan te roepen, inclusief functies of methoden die objecten maken of vrijgeven. Als de DllMain-functie van uw app wordt aangeroepen in een bepaald onderdeel, kan dat onderdeel een andere DLL aanroepen die niet aanwezig is op het besturingssysteem, waardoor het besturingssysteem vastloopt. Direct3D en DXGI laden mogelijk een set DLL's, meestal een set stuurprogramma's, die verschilt van computer tot computer. Zelfs als uw app niet vastloopt op uw ontwikkel- en testcomputers wanneer de DllMain-functie Direct3D- of DXGI-functies of -methoden aanroept, loopt deze mogelijk vast wanneer deze wordt uitgevoerd op een andere computer.

Om te voorkomen dat u een app maakt waardoor het besturingssysteem vastloopt, biedt DXGI de volgende antwoorden in de opgegeven situaties:

  • Als de DllMain-functie van uw app de laatste verwijzing naar een DXGI-fabriek publiceert, genereert DXGI een uitzondering.
  • Als de DllMain-functie van uw app een DXGI-fabriek maakt, retourneert DXGI een foutcode.

DXGI 1.1 wijzigingen

We hebben de volgende functionaliteit toegevoegd in DXGI 1.1.

DXGI 1.2 wijzigingen

We hebben de volgende functionaliteit toegevoegd in DXGI 1.2.

  • Stereo wisselketen
  • Flip-model swap chain
  • Geoptimaliseerde presentatie (schuiven, vuile rechthoeken en draaiing)
  • Verbeterde gedeelde middelen en synchronisatie
  • Bureaubladduplicatie
  • Geoptimaliseerd gebruik van videogeheugen
  • Ondersteuning voor indelingen van 16 bits per pixel (bpp) (DXGI_FORMAT_B5G6R5_UNORM, DXGI_FORMAT_B5G5R5A1_UNORM, DXGI_FORMAT_B4G4R4A4_UNORM)
  • Foutopsporings-API's

Zie DXGI 1.2 Improvements voor meer informatie over DXGI 1.2.

Compatibiliteit van toepassingen

DXGI kan toepassingsgedragswijzigingen toepassen om de toepassingscompatibiliteit te verbeteren.

  • Compatibiliteitsinstellingen kunnen worden opgeslagen in het gebruikersregister onder HKCU\SOFTWARE\Microsoft\WindowsNT\CurrentVersion\AppCompatFlags\Layers.
  • Compatibiliteitsinstellingen kunnen al dan niet worden toegepast, afhankelijk van de systeemconfiguratie of andere factoren.
  • Een voorbeeldwaarde voor de compatibiliteitsinstelling van toepassingen is DXAllowModeChangeOnLaunch720.

Programmeerhandleiding voor DXGI

  • Last updated on