Freigeben über

Überlegungen zu Direct3D 9 zu Direct3D 10 (Direct3D 10)

  • Artikel

Die folgende Seite enthält eine grundlegende Gliederung der wichtigsten Unterschiede zwischen Direct3D 9 und Direct3D 10. Die folgende Gliederung bietet einige Einblicke, um Entwicklern mit Direct3D 9-Erfahrung bei der Untersuchung und Beziehung zu Direct3D 10 zu helfen.

Obwohl die Informationen in diesem Thema Direct3D 9 mit Direct3D 10 vergleichen, da Direct3D 11 auf den Verbesserungen in Direct3D 10 und 10.1 basiert, benötigen Sie diese Informationen auch für die Migration von Direct3D 9 zu Direct3D 11. Informationen zum Verschieben von Direct3D 10 zu Direct3D 11 finden Sie unter Migrieren zu Direct3D 11.

Übersicht über die wichtigsten strukturellen Änderungen in Direct3D 10

Das Rendern mit dem Direct3D 10-Gerät ähnelt strukturell dem Von Direct3D 9.

  • Festlegen einer Vertexstreamquelle
  • Festlegen des Eingabelayouts in Direct3D 10 (Festlegen der Vertexstreamdeklaration in Direct3D 9)
  • Deklarieren der primitiven Topologie
  • Festlegen von Texturen
  • Festlegen von Zustandsobjekten
  • Festlegen von Shadern
  • Draw

Der Draw-Aufruf bindet die Vorgänge zusammen. Die Reihenfolge der Aufrufe vor dem Draw-Aufruf ist willkürlich. Die wichtigsten Unterschiede im Direct3D 10-API-Design sind wie folgt:

  • Entfernen der festen Funktion
  • Entfernen von CAPS-Bits: Der Basisfeaturesatz von Direct3D 10 ist garantiert
  • Strengere Verwaltung von: Ressourcenzugriff, Gerätestatus, Shaderkonstanten, Shaderverknüpfung (Eingaben und Ausgaben zu Shadern) zwischen Phasen
  • Änderungen des API-Einstiegspunktnamens spiegeln die Verwendung des virtuellen GPU-Arbeitsspeichers (Map() anstelle von Lock()) wider.
  • Zum Erstellungszeitpunkt kann dem Gerät eine Debugebene hinzugefügt werden.
  • Die primitive Topologie ist jetzt ein expliziter Zustand (getrennt vom Draw-Aufruf ).
  • Explizite Shaderkonstanten werden jetzt in Konstantenpuffern gespeichert.
  • Die Shadererstellung erfolgt vollständig in HLSL. Der HLSL-Compiler befindet sich jetzt in der primären Direct3D 10-DLL.
  • Neue programmierbare Phase – der Geometrie-Shader
  • Entfernen von BeginScene()/EndScene()
  • Allgemeine 2D-, Fokus- und Adapterverwaltungsfunktionen, die in einer neuen Komponente implementiert sind: DXGI

Entfernen der festen Funktion

Es ist manchmal überraschend, dass selbst in einer Direct3D 9-Engine, die die programmierbare Pipeline vollständig ausnutzt, eine Reihe von Bereichen vorhanden ist, die von der FF-Pipeline (Fixed-Function) abhängen. Die häufigsten Bereiche beziehen sich in der Regel auf das bildschirmraumorientierte Rendering für die Benutzeroberfläche. Aus diesem Grund müssen Sie wahrscheinlich einen FF-Emulationshader oder eine Reihe von Shadern erstellen, die das erforderliche Ersatzverhalten bereitstellen.

Diese Dokumentation enthält ein Whitepaper mit Ersatz-Shaderquellen für die häufigsten FF-Verhaltensweisen (siehe Emu-Beispiel für Fixed Function). Einige Pixelverhalten mit festen Funktionen, einschließlich Alphatest, wurden in Shader verschoben.

Überprüfung der Geräteobjekterstellungszeit

Die Direct3D 10-Pipeline wurde von Grund auf neu in Hardware und Software überarbeitet, um den CPU-Overhead (zur Draw-Zeit) zu reduzieren. Um die Kosten zu senken, wurde allen Arten von Gerätedaten ein Objekt mit expliziten Erstellungsmethoden zugewiesen, die vom Gerät selbst bereitgestellt werden. Dies ermöglicht eine strikte Datenvalidierung während der Objekterstellungszeit anstatt während des Draw-Aufrufs, wie dies häufig bei Direct3D 9 der Fall ist.

Engineabstraktionen/Trennung

Anwendungen, einschließlich Games, die sowohl Direct3D 9 als auch Direct3D 10 unterstützen möchten, müssen die Renderingebenen von der restlichen Codebasis abstrahiert werden. Es gibt viele Möglichkeiten, dies zu erreichen, aber der Schlüssel zu allen ist der Entwurf der Abstraktionsebene für das Direct3D-Gerät auf niedrigerer Ebene. Alle Systeme sollten mit der Hardware über die gemeinsame Ebene kommunizieren, die für die Verwaltung von GPU-Ressourcen und low-Level-Typen konzipiert ist.

Direktes Entfernen von Direct3D 9-Abhängigkeiten

Beim Portieren großer, zuvor getesteter Codebasen ist es wichtig, die Menge an Codeänderungen zu minimieren, die unbedingt erforderlich sind, um zuvor getestete Verhaltensweisen im Code beizubehalten. Zu den bewährten Methoden gehört es, mithilfe von Kommentaren klar zu dokumentieren, wo Sich Elemente ändern. Für diese Arbeit ist es oft nützlich, einen Kommentarstandard zu haben, der eine schnelle Navigation durch die Codebasis ermöglicht.

Im Folgenden finden Sie eine Beispielliste von Standardkommentaren für einzelne Zeilen/Startblocks, die für diese Arbeit verwendet werden könnten.

Element Beschreibung
Direct3D 10 ENTFERNT
 Verwenden Sie dies, wenn Zeilen/Codeblöcke entfernt werden.
Direct3D 10 BENÖTIGT UPDATE
 Es hilft, dem NEED UPDATE-Kommentar zusätzliche Hinweise hinzuzufügen, die vorschlagen, welche Arbeits-/neue API für spätere Besuche des Codes für die Verhaltenskonvertierung verwendet werden soll. Starke Verwendung von assert(false) sollte auch verwendet werden, wenn \\ Direct3D 10 NEEDS UPDATE auftritt, um sicherzustellen, dass Sie nicht unwissentlich fehlerhaften Code ausführen.
Direct3D 10 GEÄNDERT
 Bereiche, in denen größere Änderungen aufgetreten sind, sollten für die Zukunft beibehalten, aber auskommentiert werden.
Direct3D 10 END
 Beenden des Codeblockqualifizierers

 

Für mehrere Quellzeilen sollten Sie auch die Kommentare im C-Format /* */ verwenden, aber die relevanten Anfangs-/Endkommentare zu diesen Bereichen hinzufügen.

Tricks zum schnellen Beheben von Anwendungsbuildproblemen

Überschreiben von Direct3D 9-Typen

Es kann hilfreich sein, eine allgemeine Headerdatei mit Typdefinitionen/Außerkraftsetzungen für Direct3D 9-Basistypen einzufügen, die von den Direct3D 10-Headern nicht mehr unterstützt werden. Auf diese Weise können Sie die Menge der Änderungen am Code und an schnittstellen minimieren, bei denen eine direkte Zuordnung von einem Direct3D 9-Typ zum neu definierten Direct3D 10-Typ vorhanden ist. Dieser Ansatz ist auch nützlich, um Codeverhalten in einer Quelldatei zusammenzuhalten. In diesem Fall empfiehlt es sich, versionsneutrale /allgemein benannte Typen zu definieren, die allgemeine Konstrukte beschreiben, die zum Rendern verwendet werden, aber sowohl Direct3D 9- als auch Direct3D 10-APIs umfassen. Beispiel:

#if defined(D3D9)
typedef IDirect3DIndexBuffer9   IDirect3DIndexBuffer;
typedef IDirect3DVertexBuffer9  IDirect3DVertexBuffer;
#else //D3D10
typedef ID3D10Buffer            IDirect3DIndexBuffer;
typedef ID3D10Buffer            IDirect3DVertexBuffer
#endif

Weitere spezifische Direct3D 10-Beispiele hierfür sind:

typedef ID3D10TextureCube   IDirect3DCubeTexture;
typedef ID3D10Texture3D     IDirect3DVolumeTexture;
typedef D3D10_VIEWPORT      D3DVIEWPORT;
typedef ID3D10VertexShader  IDirect3DVertexShader;
typedef ID3D10PixelShader   IDirect3DPixelShader;

Es ist ratsam, Direct3D 10- und Windows Vista-Anwendungen mit der neuesten Version von Microsoft Visual Studio zu entwickeln. Es ist jedoch möglich, mit der früheren Version 2003 von Visual Studio eine Windows Vista-Anwendung zu erstellen, die von Direct3D 10 abhängt. Direct3D 10 ist eine Windows Vista-Plattformkomponente, die Abhängigkeiten (wie beim Server 2003 SP1 Platform SDK) für die folgende Lib aufweist: BufferOverflowU.lib wird benötigt, um probleme mit buffer_security Check Linker zu beheben.

Simulieren von Geräte-CAPs

Viele Anwendungen enthalten Codebereiche, die davon abhängen, dass CAPS-Daten des Geräts verfügbar sind. Umgehen Sie dies, indem Sie die Geräteenumeration überschreiben und die GERÄTE-CAPS auf sinnvolle Werte erzwingen. Planen Sie, Bereiche, in denen Abhängigkeiten von CAPS bestehen, später erneut zu besuchen, um die CAPS nach Möglichkeit vollständig zu entfernen.

Steuern der Direct3D 10-API

Dieser Abschnitt konzentriert sich auf die Verhaltensänderungen, die durch die Direct3D 10-API verursacht werden.

Ressourcenerstellung

Die Direct3D 10-API hat Ressourcen als generische Puffertypen entworfen, die gemäß der geplanten Verwendung über bestimmte Bindungsflags verfügen. Dieser Entwurfspunkt wurde ausgewählt, um den nahezu allgegenwärtigen Zugriff auf Ressourcen in der Pipeline für Szenarien wie das Rendern in einem Vertexpuffer zu ermöglichen und dann sofort die Ergebnisse zu zeichnen, ohne die CPU zu unterbrechen. Im folgenden Beispiel wird die Zuordnung von Vertexpuffern und Indexpuffern veranschaulicht, wobei Sie sehen können, dass sich die Ressourcenbeschreibung nur durch die GPU-Ressourcenbindungsflags unterscheidet.

Die Direct3D 10-API hat Texturhilfsmethoden zum expliziten Erstellen von Texturtypressourcen bereitgestellt, aber wie Sie sich vorstellen können, sind dies wirklich Hilfsfunktionen.

  • CreateTexture2D()
  • CreateTextureCube()
  • CreateTexture3D()

Wenn Sie Direct3D 10 als Ziel verwenden, sollten Sie während der Ressourcenerstellungszeit wahrscheinlich mehr Elemente zuordnen, als Sie mit Direct3D 9 gewohnt sind. Dies wird am deutlichsten bei der Erstellung von Renderzielpuffern und Texturen, bei denen Sie auch eine Ansicht für den Zugriff auf den Puffer und das Festlegen der Ressource auf dem Gerät erstellen müssen.

Tutorial 1: Direct3D 10– Grundlagen

Hinweis

Direct3D 10 und höhere Versionen von Direct3D erweitern das DDS-Dateiformat, um neue DXGI-Formate, Texturarrays und Cubezuordnungsarrays zu unterstützen. Weitere Informationen zur DDS-Dateiformaterweiterung finden Sie im Programmierhandbuch für DDS.

 

Sichten

Eine Ansicht ist eine speziell typisierte Schnittstelle zu Daten, die in einem Pixelpuffer gespeichert sind. Einer Ressource können mehrere Ansichten gleichzeitig zugeordnet sein, und dieses Feature ist im Beispiel Rendern mit einem einzelnen Pass in Cubemap in diesem SDK hervorgehoben.

Seite "Programmiererhandbuch" zum Ressourcenzugriff

CubeMap-Beispiel

Statischer und dynamischer Ressourcenzugriff

Um eine optimale Leistung zu erzielen, sollten Anwendungen ihre Datennutzung in Bezug auf die statische und dynamische Natur der Daten partitionieren. Direct3D 10 wurde entwickelt, um diesen Ansatz zu nutzen, und daher wurden die Zugriffsregeln für Ressourcen gegenüber Direct3D 9 erheblich verschärft. Bei statischen Ressourcen sollten Sie die Ressource idealerweise während der Erstellungszeit mit ihren Daten auffüllen. Wenn Ihre Engine um den Entwurfspunkt Erstellen, Sperren, Ausfüllen, Entsperren von Direct3D 9 entworfen wurde, können Sie die Auffüllung von Create time mithilfe einer Stagingressource und der UpdateSubResource-Methode auf der Ressourcenschnittstelle zurückstellen.

Direct3D 10-Effekte

Die Verwendung des Direct3D 10 Effects-Systems liegt außerhalb des Rahmens dieses Artikels. Das System wurde geschrieben, um die Vorteile der Architektur, die Direct3D 10 bietet, in vollem Umfang zu nutzen. Weitere Informationen zur Verwendung finden Sie im Abschnitt Effekte (Direct3D 10).

HLSL ohne Effekte

Die Direct3D 10-Shaderpipeline kann ohne die Verwendung des Direct3D 10 Effects-Systems gesteuert werden. Beachten Sie, dass in diesem instance alle Konstantenpuffer, Shader, Sampler und Texturbindungen von der Anwendung selbst verwaltet werden müssen. Weitere Informationen finden Sie im Beispiellink und in den folgenden Abschnitten dieses Dokuments:

BEISPIEL FÜR HLSL ohne Effekte

Shaderkompilierung

Der Direct3D 10 HLSL-Compiler bietet Verbesserungen an der HLSL-Sprachdefinition und kann daher in zwei Modi arbeiten. Damit systeminterne Funktionen und Semantik im Direct3D 9-Stil vollständig unterstützt werden, sollte die Kompilierung mithilfe des COMPATIBILITY MODE-Flags aufgerufen werden, das pro Kompilierung angegeben werden kann.

Die spezifische HLSL-Sprachsemantik des Shadermodells 4.0 und die systeminternen Funktionen für Direct3D 10 finden Sie unter HLSL. Wichtige Änderungen in der Syntax von Direct3D 9 HLSL, die am meisten beachtet werden, liegen im Bereich des Texturzugriffs. Die neue Syntax ist die einzige Form, die vom Compiler außerhalb des Kompatibilitätsmodus unterstützt wird.

Hinweis

Die Direct3D 10-Compiler-APIs (D3D10CompileShader und D3D10CompileEffectFromMemory) werden von den Direct3D 10-, 10.1- und 11-Runtimes bereitgestellt, die in Windows Vista und höher ausgeführt werden. Die Direct3D 10-Compiler-APIs verfügen über die gleiche Funktionalität wie der HLSL-Compiler, der im DirectX SDK (Dezember 2006) enthalten ist. Dieser HLSL-Compiler unterstützt die Direct3D 10.1-Profile (vs_4_1, ps_4_1, gs_4_1, fx_4_1) nicht und es fehlen einige Optimierungen und Verbesserungen. Sie können einen HLSL-Compiler abrufen, der die Direct3D 10.1-Profile aus der neuesten Version des DirectX SDK unterstützt. Informationen zum Legacy-DirectX SDK finden Sie unter Wo befindet sich das DirectX SDK?. Sie können die neuesten HLSL-Fxc.exe Befehlszeilencompiler und D3DCompiler-APIs aus dem Windows SDK abrufen.

 

Erstellen von Shaderressourcen

Die Erstellung kompilierter Shaderinstanzen außerhalb des Direct3D 10 Effects-Systems erfolgt auf sehr ähnliche Weise wie Direct3D 9, aber in Direct3D 10 ist es wichtig, die Shadereingabesignatur zur späteren Verwendung beizubehalten. Die Signatur wird standardmäßig als Teil des Shaderblobs zurückgegeben, kann jedoch extrahiert werden, um die Arbeitsspeicheranforderungen bei Bedarf zu reduzieren. Weitere Informationen finden Sie unter Verwenden von Shadern in Direct3D 10.

Schnittstelle zur Shaderreflektionsebene

Die Shaderreflektionsebene ist die Schnittstelle, über die Informationen zu den Shaderanforderungen abgerufen werden können. Dies ist besonders nützlich, wenn Sie Eingabeassemblyverknüpfungen erstellen (siehe unten), bei denen Sie möglicherweise die Shadereingabeanforderungen durchlaufen müssen, um sicherzustellen, dass Sie die richtige Eingabestruktur für den Shader bereitstellen. Sie können eine instance der Reflektionsebenenschnittstelle gleichzeitig mit dem Erstellen einer instance eines kompilierten Shaders erstellen.

Die Shaderreflektionsebene ersetzt D3DX9-Methoden, die ähnliche Funktionen bereitstellen. Beispielsweise wird IsParameterUsed durch die GetDesc-Methode ersetzt.

Layouts für Eingabeassesstruators – Vertex-Shader/Eingabestreamverknüpfung

Der Input Assembler (IA) ersetzt die Vertex Stream-Deklaration im Direct3D 9-Format, und die Beschreibungsstruktur ist in ihrer Form sehr ähnlich. Der Standard Unterschied, den die IA mit sich bringt, besteht darin, dass das erstellte IA-Layoutobjekt direkt einem bestimmten Format der Shadereingabesignatur zugeordnet werden muss. Das Zum Verknüpfen des Eingabedatenstroms mit dem Shader erstellte Zuordnungsobjekt kann für eine beliebige Anzahl von Shadern verwendet werden, bei denen die Shadereingabesignatur mit der des Shaders übereinstimmt, der zum Erstellen des Eingabelayouts verwendet wurde.

Um die Pipeline am besten mit statischen Daten zu steuern, sollten Sie die Permutationen des Eingabedatenstromformats zu möglichen Shadereingabesignaturen berücksichtigen und die IA-Layoutobjektinstanzen so früh wie möglich erstellen und nach Möglichkeit wiederverwenden.

Auswirkungen der Entfernung von shader dead code

Im folgenden Abschnitt wird ein erheblicher Unterschied zwischen Direct3D 9 und Direct3D 10 beschrieben, der wahrscheinlich eine sorgfältige Behandlung in Ihrem Engine-Code erfordert. Bei Shadern, die bedingte Ausdrücke enthalten, werden häufig bestimmte Codepfade im Rahmen des Kompilierungsprozesses entfernt. In Direct3D 9 können zwei Arten von Eingaben entfernt (zum Entfernen markiert) werden, wenn sie nicht verwendet werden: Signatureingaben (wie das folgende Beispiel) und Konstanteneingaben. Wenn das Ende des Konstantenpuffers nicht verwendete Einträge enthält, spiegelt die Größendeklaration im Shader die Größe des Konstantenpuffers ohne die nicht verwendeten Einträge am Ende wider. Beide Arten von Eingaben verbleiben in Signaturen oder Konstantenpuffern Direct3D 10 mit einer besonderen Ausnahme bei nicht verwendeten Konstanteneingaben am Ende eines Konstantenpuffers. Dies kann Auswirkungen auf die Engine haben, wenn große Shader verarbeitet und Eingabelayouts erstellt werden. Elemente, die durch optimierungen des nicht beendeten Codes im Compiler entfernt werden, müssen weiterhin in der Eingabestruktur deklariert werden. Dies wird im folgenden Beispiel veranschaulicht:

Beispiel für die Vertex-Shader-Eingabestruktur

struct VS_INPUT
{
float4 pos: SV_Position;
float2 uv1 : Texcoord1;
float2 uv2 : Texcoord2; *
};

* Das Entfernen von direct3D 9 toter Code würde die Deklaration im Shader aufgrund der Entfernung von bedingtem toten Code entfernen.

float4x4  g_WorldViewProjMtx;
static const bool g_bLightMapped = false; // define a compile time constant

VS_INPUT main(VS_INPUT i) 
{
    VS_INPUT o;
    o.pos = mul( i.pos, g_WorldViewProjMtx);
    o.uv1 = i.uv1;
    if ( g_bLightMapped )
    {
        o.uv2 = i.uv2;
    }
    return o;
}

Oder Sie können es mit der folgenden Deklaration noch deutlicher machen, dass es sich bei der Konstante um eine Kompilierzeitkonstante handelt:

#define LIGHT_MAPPED false

Im obigen Beispiel würde unter Direct3D 9 das uv2-Element aufgrund von optimierungen des nicht beendeten Codes im Compiler entfernt. Unter Direct3D 10 wird der tote Code weiterhin entfernt, aber das Layout des Shadereingabeassens erfordert, dass die Definition der Eingabedaten vorhanden ist. Die Shaderreflektionsebene bietet die Möglichkeit, diese Situation auf generische Weise zu behandeln, wobei Sie die Anforderungen an die Shadereingabe durchlaufen und sicherstellen können, dass Sie eine vollständige Beschreibung der Zuordnung von Eingabedatenstrom zur Shadersignatur bereitstellen.

Hier sehen Sie eine Beispielfunktion, um das Vorhandensein eines semantischen Namens/Index in einer Funktionssignatur zu erkennen:

// Returns true if the SemanticName / SemanticIndex is used in the input signature.
// pReflector is a previously acquired shader reflection interface.
bool IsSignatureElementExpected(ID3D10ShaderReflection *pReflector, const LPCSTR SemanticName, UINT SemanticIndex)
{
    D3D10_SHADER_DESC               shaderDesc;
    D3D10_SIGNATURE_PARAMETER_DESC  paramDesc;

    Assert(pReflector);
    Assert(SemanticName);

    pReflector->GetDesc(&shaderDesc);

    for (UINT k=0; k<shaderDesc.InputParameters; k++)
    {
        pReflector->GetInputParameterDesc( k, &paramDesc);
        if (wcscmp( SemanticName, paramDesc.SemanticName)==0 && paramDesc.SemanticIndex == SemanticIndex) 
            return true;
    }

    return false;
}

Zustandsobjekterstellung

Beim Portieren von Enginecode kann es hilfreich sein, zunächst einen Standardsatz von Zustandsobjekten zu verwenden und alle Direct3D 9-Geräterenderungsstatus-/Texturzustandseinstellungen zu deaktivieren. Dies führt zu Renderingartefakten, ist aber die schnellste Möglichkeit, die Dinge in Betrieb zu bringen. Sie können später ein Zustandsobjektverwaltungssystem erstellen, das einen zusammengesetzten Schlüssel verwenden kann, um eine maximale Wiederverwendung der Anzahl der verwendeten Zustandsobjekte zu ermöglichen.

Portieren von Texturen

Unterstützte Dateiformate

Die Funktionen D3DXxxCreateXXX und D3DXxxSaveXXX, die eine Textur aus oder in einer Grafikdatei erstellen oder in einer Grafikdatei speichern (z. B. D3DX10CreateTextureFromFile), unterstützen einen anderen Satz von Dateiformaten in Direct3D 10 als in Direct3D 9:

Dateiformat Direct3D 9 Direct3D 10
BMP x x
.jpg x x
.tga x
.png x x
.dds x x
.Ppm x
DIB x
.Hdr x
.Pfm x
TIFF x
.gif x
.tif x

 

Weitere Informationen finden Sie unter Vergleichen der Direct3D 9-D3DXIMAGE_FILEFORMAT-Enumerationen mit den D3DX10_IMAGE_FILE_FORMAT-Enumerationen für Direct3D 10.

Hinweis

Die Hilfsprogrammbibliothek D3DX (D3DX 9, D3DX 10 und D3DX 11) ist für Windows 8 veraltet. Für die Verarbeitung von Texturdateien wird empfohlen, DirectXTex zu verwenden.

 

Zuordnungstexturformate

Die folgende Tabelle zeigt die Zuordnung der Texturformate von Direct3D 9 zu Direct3D 10. Alle Inhalte in Formaten, die in DXGI nicht verfügbar sind, müssen von Hilfsprogrammroutinen konvertiert werden.

Direct3D 9-Format Direct3D 10-Format
D3DFMT_UNKNOWN DXGI_FORMAT_UNKNOWN
D3DFMT_R8G8B8 Nicht verfügbar
D3DFMT_A8R8G8B8 DXGI_FORMAT_B8G8R8A8_UNORM & DXGI_FORMAT_B8G8R8A8_UNORM_SRGB¹
D3DFMT_X8R8G8B8 DXGI_FORMAT_B8G8R8X8_UNORM & DXGI_FORMAT_B8G8R8X8_UNORM_SRGB¹
D3DFMT_R5G6B5 DXGI_FORMAT_B5G6R5_UNORM²
D3DFMT_X1R5G5B5 Nicht verfügbar
D3DFMT_A1R5G5B5 DXGI_FORMAT_B5G5R5A1_UNORM²
D3DFMT_A4R4G4B4 DXGI_FORMAT_B4G4R4A4_UNORM³
D3DFMT_R3G3B2 Nicht verfügbar
D3DFMT_A8 DXGI_FORMAT_A8_UNORM
D3DFMT_A8R3G3B2 Nicht verfügbar
D3DFMT_X4R4G4B4 Nicht verfügbar
D3DFMT_A2B10G10R10 DXGI_FORMAT_R10G10B10A2
D3DFMT_A8B8G8R8 DXGI_FORMAT_R8G8B8A8_UNORM & DXGI_FORMAT_R8G8B8A8_UNORM_SRGB
D3DFMT_X8B8G8R8 Nicht verfügbar
D3DFMT_G16R16 DXGI_FORMAT_R16G16_UNORM
D3DFMT_A2R10G10B10 Nicht verfügbar
D3DFMT_A16B16G16R16 DXGI_FORMAT_R16G16B16A16_UNORM
D3DFMT_A8P8 Nicht verfügbar
D3DFMT_P8 Nicht verfügbar
D3DFMT_L8 DXGI_FORMAT_R8_UNORM Hinweis: Verwenden Sie .r swizzle im Shader, um Rot auf andere Komponenten zu duplizieren, um das D3D9-Verhalten zu erhalten.
D3DFMT_A8L8 DXGI_FORMAT_R8G8_UNORM Hinweis: Verwenden Sie swizzle .rrrg im Shader, um Rot zu duplizieren und grün in die Alphakomponenten zu verschieben, um das D3D9-Verhalten zu erhalten.
D3DFMT_A4L4 Nicht verfügbar
D3DFMT_V8U8 DXGI_FORMAT_R8G8_SNORM
D3DFMT_L6V5U5 Nicht verfügbar
D3DFMT_X8L8V8U8 Nicht verfügbar
D3DFMT_Q8W8V8U8 DXGI_FORMAT_R8G8B8A8_SNORM
D3DFMT_V16U16 DXGI_FORMAT_R16G16_SNORM
D3DFMT_W11V11U10 Nicht verfügbar
D3DFMT_A2W10V10U10 Nicht verfügbar
D3DFMT_UYVY Nicht verfügbar
D3DFMT_R8G8_B8G8 DXGI_FORMAT_G8R8_G8B8_UNORM (in DX9 wurden die Daten um 255,0f hochskaliert, aber dies kann im Shadercode behandelt werden).
D3DFMT_YUY2 Nicht verfügbar
D3DFMT_G8R8_G8B8 DXGI_FORMAT_R8G8_B8G8_UNORM (in DX9 wurden die Daten um 255,0f hochskaliert, aber dies kann im Shadercode behandelt werden).
D3DFMT_DXT1 DXGI_FORMAT_BC1_UNORM & DXGI_FORMAT_BC1_UNORM_SRGB
D3DFMT_DXT2 & DXGI_FORMAT_BC1_UNORM DXGI_FORMAT_BC1_UNORM_SRGB Hinweis: DXT1 und DXT2 sind aus API-/Hardwaresicht identisch... der einzige Unterschied war "prämultipliziertes Alpha", das von einer Anwendung nachverfolgt werden kann und kein separates Format benötigt.
D3DFMT_DXT3 DXGI_FORMAT_BC2_UNORM & DXGI_FORMAT_BC2_UNORM_SRGB
D3DFMT_DXT4 & DXGI_FORMAT_BC2_UNORM DXGI_FORMAT_BC2_UNORM_SRGB Hinweis: DXT3 und DXT4 sind aus API-/Hardwaresicht identisch... der einzige Unterschied war "prämultipliziertes Alpha", das von einer Anwendung nachverfolgt werden kann und kein separates Format benötigt.
D3DFMT_DXT5 DXGI_FORMAT_BC3_UNORM & DXGI_FORMAT_BC3_UNORM_SRGB
D3DFMT_D16 & D3DFMT_D16_LOCKABLE DXGI_FORMAT_D16_UNORM
D3DFMT_D32 Nicht verfügbar
D3DFMT_D15S1 Nicht verfügbar
D3DFMT_D24S8 Nicht verfügbar
D3DFMT_D24X8 Nicht verfügbar
D3DFMT_D24X4S4 Nicht verfügbar
D3DFMT_D16 DXGI_FORMAT_D16_UNORM
D3DFMT_D32F_LOCKABLE DXGI_FORMAT_D32_FLOAT
D3DFMT_D24FS8 Nicht verfügbar
D3DFMT_S1D15 Nicht verfügbar
D3DFMT_S8D24 DXGI_FORMAT_D24_UNORM_S8_UINT
D3DFMT_X8D24 Nicht verfügbar
D3DFMT_X4S4D24 Nicht verfügbar
D3DFMT_L16 DXGI_FORMAT_R16_UNORM Hinweis: Verwenden Sie .r swizzle im Shader, um Rot in andere Komponenten zu duplizieren, um das D3D9-Verhalten zu erhalten.
D3DFMT_INDEX16 DXGI_FORMAT_R16_UINT
D3DFMT_INDEX32 DXGI_FORMAT_R32_UINT
D3DFMT_Q16W16V16U16 DXGI_FORMAT_R16G16B16A16_SNORM
D3DFMT_MULTI2_ARGB8 Nicht verfügbar
D3DFMT_R16F DXGI_FORMAT_R16_FLOAT
D3DFMT_G16R16F DXGI_FORMAT_R16G16_FLOAT
D3DFMT_A16B16G16R16F DXGI_FORMAT_R16G16B16A16_FLOAT
D3DFMT_R32F DXGI_FORMAT_R32_FLOAT
D3DFMT_G32R32F DXGI_FORMAT_R32G32_FLOAT
D3DFMT_A32B32G32R32F DXGI_FORMAT_R32G32B32A32_FLOAT
D3DFMT_CxV8U8 Nicht verfügbar
D3DDECLTYPE_FLOAT1 DXGI_FORMAT_R32_FLOAT
D3DDECLTYPE_FLOAT2 DXGI_FORMAT_R32G32_FLOAT
D3DDECLTYPE_FLOAT3 DXGI_FORMAT_R32G32B32_FLOAT
D3DDECLTYPE_FLOAT4 DXGI_FORMAT_R32G32B32A32_FLOAT
D3DDECLTYPED3DCOLOR Nicht verfügbar
D3DDECLTYPE_UBYTE4 DXGI_FORMAT_R8G8B8A8_UINT Hinweis: Shader ruft UINT-Werte ab, aber wenn Direct3D 9-Stil-Floats benötigt werden (0,0f, 1,0f... 255.f), kann UINT einfach in float32 im Shader konvertiert werden.
D3DDECLTYPE_SHORT2 DXGI_FORMAT_R16G16_SINT Hinweis: Shader ruft SINT-Werte ab, aber wenn integrale Floats im Direct3D 9-Stil erforderlich sind, kann SINT einfach in float32 im Shader konvertiert werden.
D3DDECLTYPE_SHORT4 DXGI_FORMAT_R16G16B16A16_SINT Hinweis: Shader ruft SINT-Werte ab, aber wenn integrale Floats im Direct3D 9-Stil erforderlich sind, kann SINT einfach in float32 im Shader konvertiert werden.
D3DDECLTYPE_UBYTE4N DXGI_FORMAT_R8G8B8A8_UNORM
D3DDECLTYPE_SHORT2N DXGI_FORMAT_R16G16_SNORM
D3DDECLTYPE_SHORT4N DXGI_FORMAT_R16G16B16A16_SNORM
D3DDECLTYPE_USHORT2N DXGI_FORMAT_R16G16_UNORM
D3DDECLTYPE_USHORT4N DXGI_FORMAT_R16G16B16A16_UNORM
D3DDECLTYPE_UDEC3 Nicht verfügbar
D3DDECLTYPE_DEC3N Nicht verfügbar
D3DDECLTYPE_FLOAT16_2 DXGI_FORMAT_R16G16_FLOAT
D3DDECLTYPE_FLOAT16_4 DXGI_FORMAT_R16G16B16A16_FLOAT
FourCC 'ATI1' DXGI_FORMAT_BC4_UNORM
FourCC 'ATI2' DXGI_FORMAT_BC5_UNORM

 

¹DXGI 1.1, das in der Direct3D 11-Runtime enthalten ist, enthält BGRA-Formate. Die Unterstützung für diese Formate ist jedoch optional für Direct3D 10- und 10.1-Geräte mit Treibern, die im Windows Display Driver Model (WDDM) für Windows Vista (WDDM 1.0) implementiert sind. Erwägen Sie stattdessen die Verwendung DXGI_FORMAT_R8G8B8A8_UNORM. Alternativ können Sie Ihr Gerät mit D3D10_CREATE_DEVICE_BGRA_SUPPORT erstellen, um sicherzustellen, dass Sie nur Computer unterstützen, auf denen die Direct3D 11.0-Runtime und ein WDDM 1.1-Treiber oder höher installiert sind.

²DXGI 1.0 definierte die Formate 5:6:5 und 5:5:5:1, wurden jedoch von der Direct3D 10.x- oder Direct3D 11.0-Runtime nicht unterstützt. Diese Formate werden optional mit DXGI 1.2 in der DirectX 11.1-Runtime unterstützt, die für Treiber auf Featureebene 11.1 und WDDM 1.2 (Anzeigetreibermodell ab Windows 8) erforderlich ist und bereits auf Featureebenen mit 10level9 unterstützt wird.

³DXGI 1.2 hat das Format 4:4:4:4:4 eingeführt. Dieses Format wird optional in der DirectX 11.1-Runtime unterstützt, die für Featureebene 11.1-Grafikkarten und WDDM 1.2-Treiber erforderlich ist und bereits auf 10Level9-Featureebenen unterstützt wird.

Für nicht komprimierte Formate hat DXGI die Unterstützung für beliebige Pixelformatmuster eingeschränkt. Alle nicht komprimierten Formate müssen vom Typ RGBA sein. Dies erfordert möglicherweise das Verschieben vorhandener Ressourcenpixelformate. Es wird empfohlen, nach Möglichkeit als Offline-Vorprozessdurchlauf zu berechnen.

Portieren von Shadern

Direct3D 10-Shader werden in HLSL erstellt

Direct3D 10 schränkt die Verwendung der Assemblysprache nur auf debugzwecke ein, daher müssen alle in Direct3D 9 verwendeten handgeschriebenen Assemblyshader in HLSL konvertiert werden.

Shadersignaturen und Verknüpfung

Wir haben die Anforderungen für die Verknüpfung der Eingabeassembly mit Vertex-Shadereingabesignaturen weiter oben in diesem Dokument erläutert (siehe oben). Beachten Sie, dass die Direct3D 10-Runtime auch die Anforderungen für die Verknüpfung von Phase zu Phase zwischen Shadern verschärft hat. Diese Änderung wirkt sich auf Shaderquellen aus, bei denen die Bindung zwischen Phasen unter Direct3D 9 möglicherweise nicht vollständig beschrieben wurde. Beispiel:

VS_OUTPUT                       PS_INPUT
float4   pos : SV_POSITION;     float4 pos : SV_POSITION;
float4   uv1 : TEXCOORD1;       float4 uv1 : TEXCOORD1;
float4x3 tangentSp : TEXCOORD2; float4 tangent : TEXCOORD2; *
float4   Color : TEXCOORD6;     float4 color : TEXCOORD6;

* Broken VS - PS Linkage: Auch wenn der Pixel-Shader möglicherweise nicht an der vollständigen Matrix interessiert ist, muss die Verknüpfung den vollständigen float4x3 angeben.

Beachten Sie, dass die Verknüpfungssemantik zwischen Phasen genau übereinstimmen muss, aber die Eingaben der Zielstufen können ein Präfix der ausgegebenen Werte sein. Im obigen Beispiel könnte der Pixel-Shader position und texcoord1 als einzige Eingaben haben, aber aufgrund der Bestelleinschränkungen nicht die Position und texcoord2 als einzige Eingaben haben.

HLSL Shader Stage-Verknüpfungen

Die Verknüpfung zwischen Shadern kann an einem der folgenden Punkte in der Pipeline auftreten:

  • Input Assembler to Vertex Shader
  • Vertex-Shader zu Pixel-Shader
  • Vertex-Shader zu Geometry-Shader
  • Vertex-Shader zum Streamen der Ausgabe
  • Geometrie-Shader zu Pixel-Shader
  • Geometrie-Shader zum Streamen

Konstantenpuffer

Zur Vereinfachung der Portierung von Inhalten aus Direct3D 9 kann ein anfänglicher Ansatz zur konstanten Verwaltung außerhalb des Effects-Systems die Erstellung eines einzelnen Konstantenpuffers mit allen erforderlichen Konstanten umfassen. Für die Leistung ist es wichtig, Konstanten nach der erwarteten Aktualisierungshäufigkeit in Puffern anordnen. Durch diese organization wird die Anzahl redundanter Konstantensätze auf ein Minimum reduziert.

Benutzerclipebenen in HLSL auf Featureebene 9 und höher

Ab Windows 8 können Sie das Funktionsattribut clipplanes in einer HLSL-Funktionsdeklaration anstelle von SV_ClipDistance verwenden, damit Ihr Shader auf Featureebene 9_x sowie auf Featureebene 10 und höher funktioniert. Weitere Informationen finden Sie unter Benutzerclipebenen auf Hardware der Featureebene 9.

Zusätzliche Direct3D 10-Unterschiede zur Überwachung

Ganze Zahlen als Eingabe

In Direct3D 9 gab es keine echte Hardwareunterstützung für ganzzahlige Datentypen. Direct3D 10-Hardware unterstützt jedoch explizite ganzzahlige Typen. Wenn Sie Gleitkommadaten in Ihrem Vertexpuffer haben, müssen Sie über eine Floateingabe verfügen. Andernfalls ist ein ganzzahliger Typ die Bitmusterdarstellung des Gleitkommawerts. Ein ganzzahliger Typ ist für eine Pixel-Shadereingabe nicht zulässig, es sei denn, der Wert ist für keine Interpolation markiert (siehe Interpolationsmodifizierer).

Mauscursor

In früheren Versionen von Windows funktionierten die standardmäßigen GDI-Mauscursorroutinen nicht ordnungsgemäß auf allen exklusiven Vollbildgeräten. Die APIs SetCursorProperties, ShowCursor und SetCursorPosition wurden hinzugefügt, um diese Fälle zu behandeln. Da die Windows Vista-Version von GDI DXGI-Oberflächen vollständig versteht, ist diese spezielle Mauscursor-API nicht erforderlich, sodass es kein Direct3D 10-Äquivalent gibt. Direct3D 10-Anwendungen sollten stattdessen die Standard-GDI-Mauscursorroutinen für Mauscursor verwenden.

Zuordnen von Texels zu Pixeln in Direct3D 10

In Direct3D 9 waren texel-Center und Pixelzentren eine halbe Einheit voneinander entfernt (siehe Direkte Zuordnung von Texels zu Pixeln (Direct3D 9)). In Direct3D 10 befinden sich texel-Zentren bereits bei halber Einheit, sodass vertexkoordinaten überhaupt nicht verschoben werden müssen.

Das Rendern von Vollbild-Quads ist mit Direct3D 10 geradliniger. Vollbild-Quads sollten im Clipspace (-1,1) definiert werden und einfach ohne Änderungen den Vertex-Shader durchlaufen. Auf diese Weise ist es nicht erforderlich, den Vertexpuffer jedes Mal neu zu laden, wenn sich die Bildschirmauflösung ändert, und es gibt keine zusätzliche Arbeit im Pixel-Shader, um die Texturkoordinaten zu bearbeiten.

Änderungen des Referenzzählungsverhaltens

Im Gegensatz zu früheren Direct3D-Versionen enthalten die verschiedenen Set-Funktionen keinen Verweis auf die Geräteobjekte. Dies bedeutet, dass die Anwendung sicherstellen muss, dass sie einen Verweis auf das Objekt enthält, solange das Objekt an die Pipeline gebunden werden soll. Wenn die Ref-Anzahl des Objekts auf 0 sinkt, wird das Objekt von der Pipeline getrennt, während es zerstört wird. Diese Art des Verweishaltes wird auch als Schwachverweisspeicherung bezeichnet, daher enthält jede Bindungsposition im Device-Objekt einen schwachen Verweis auf die Schnittstelle/das Objekt. Sofern nicht explizit anders angegeben, sollte dieses Verhalten für alle Set-Methoden angenommen werden. Wenn die Zerstörung eines Objekts dazu führt, dass ein Bindungspunkt auf NULL festgelegt wird, gibt die Debugebene eine Warnung aus. Beachten Sie, dass Aufrufe von Get-Methoden des Geräts wie OMGetRenderTargets die Verweisanzahl der zurückgegebenen Objekte erhöhen.

Kooperative Ebene testen

Die Funktionalität der Direct3D 9-API TestCooperativeLevel entspricht dem Festlegen der DXGI_PRESENT_TEST beim Aufrufen von Present.

StretchRect

Eine Funktion ähnlich der Direct3D 9 IDirect3DDevice9::StretchRect-Methode ist in Direct3D 10 und 10.1 nicht verfügbar. Um Ressourcenoberflächen zu kopieren, verwenden Sie ID3D10Device::CopySubresourceRegion. Rendern Sie für Größenänderungen mithilfe der Texturfilterung in eine Textur. Verwenden Sie ZUM Konvertieren von MSAA-Oberflächen in Nicht-MSAA-Oberflächen ID3D10Device::ResolveSubresource.

Zusätzliche Direct3D 10.1-Unterschiede

Windows Vista mit Service Pack 1 (SP1) enthielt ein kleineres Update auf Direct3D 10 und Direct3D 10.1, das die folgenden zusätzlichen Hardwarefeatures verfügbar gemacht hat:

  • MSAA-Shader pro Beispiel
  • MSAA-Tiefenlesevorgang
  • Unabhängige Mischmodi pro Renderziel
  • Cubezuordnungsarrays
  • Rendern in blockkomprimierte (BC)-Formate

Das Direct3D 10.1-Update hat Unterstützung für die folgenden neuen Schnittstellen hinzugefügt, die von vorhandenen Schnittstellen abgeleitet werden:

Das Direct3D 10.1-Update enthielt auch die folgenden zusätzlichen Strukturen:

Die Direct3D 10.1-API enthält ein neues Konzept mit dem Namen Featureebene. Dieses Konzept bedeutet, dass Sie die Direct3D 10.1-API verwenden können, um Direct3D 10.0 (D3D10_FEATURE_LEVEL_10_0) oder Direct3D 10.1 (D3D10_FEATURE_LEVEL_10_1) Hardware zu steuern. Da die Direct3D 10.1-API von den Direct3D 10-Schnittstellen abgeleitet ist, können Anwendungen ein Direct3D 10.1-Gerät erstellen und es dann als Direct3D 10.0-Gerät verwenden, außer wenn neue 10.1-spezifische Features erforderlich sind (vorausgesetzt, dass die D3D10_FEATURE_LEVEL_10_1 Featureebene vorhanden ist und diese Features unterstützt).

Hinweis

Direct3D 10.1-Geräte können die vorhandenen 10.0 HLSL-Shaderprofile (vs_4_0, ps_4_0, gs_4_0) und die neuen 10.1-Profile (vs_4_1, ps_4_1, gs_4_1) mit zusätzlichen HLSL-Anweisungen und -Funktionen verwenden.

 

Windows 7 enthielt ein kleineres Update für die Direct3D 10.1-API, die in der Direct3D 11-Runtime enthalten ist. Dieses Update fügt Unterstützung für die folgenden Featureebenen hinzu:

Windows 7 hat auch Unterstützung für Direct3D 10.1 für Windows Advanced Rasterization Platform (WARP) hinzugefügt. Sie können einen WARP-Treiber mithilfe von D3D10_DRIVER_TYPE_WARP angeben.

Weitere Informationen zu Direct3D 10.1 finden Sie unter Direct3D 10.1 Features und D3D10_FEATURE_LEVEL1 Enumeration.

Programmierhandbuch für Direct3D 10