Aan de slag (DirectXMath)

De DirectXMath-bibliotheek implementeert een optimale en draagbare interface voor rekenkundige en lineaire algebrabewerkingen op drijvendekommagectors (2D, 3D en 4D) of matrices (3×3 en 4×4). De bibliotheek biedt beperkte ondersteuning voor gehele vectorbewerkingen. Deze bewerkingen worden uitgebreid gebruikt in rendering en animatie door grafische programma's. Er is geen ondersteuning voor vectoren met dubbele precisie (inclusief longs, shorts of bytes) en alleen beperkte vectorbewerkingen voor gehele getallen.

De bibliotheek is beschikbaar op verschillende Windows-platforms. Omdat de bibliotheek functionaliteit biedt die eerder niet beschikbaar was, vervangt deze versie de volgende bibliotheken:

• Xbox Math-bibliotheek geleverd door de header Xboxmath.h
• D3DX 9-bibliotheek geleverd door de D3DX 9 DLL's
• D3DX 10 wiskundige bibliotheek geleverd via de D3DX 10 DLL's
• XNA Math-bibliotheek geleverd door de xnamath.h-header in de DirectX SDK en Xbox 360 XDK

In deze secties vindt u een overzicht van de basisbeginselen van het aan de slag gaan.

• downloaden
• Run-Time systeemvereisten
• Ontwerpoverzicht
• Matrixconventie
• Basisgebruik
• Richtlijnen voor het Gebruik van Types
• Vectoren maken
  • constante vectoren
  • VECTOREN UIT VARIABELEN
  • VECTOREN UIT VECTOREN
  • VECTOREN UIT HET GEHEUGEN
• onderdelen uit vectoren extraheren
• Verwante onderwerpen

De DirectXMath-bibliotheek is opgenomen in de Windows SDK. U kunt het ook downloaden van GitHub/Microsoft/DirectXMath. Deze site bevat ook gerelateerde voorbeeldprojecten.

De DirectXMath-bibliotheek maakt gebruik van gespecialiseerde processorinstructies voor vectorbewerkingen wanneer deze beschikbaar zijn. Als u wilt voorkomen dat een programma 'onbekende instructieuitzondering' fouten genereert, controleert u op processorondersteuning door XMVerifyCPUSupport- aan te roepen voordat u de DirectXMath-bibliotheek gebruikt.

Dit zijn de basisvereisten voor runtime-ondersteuning voor DirectXMath Library:

• Voor standaardcompilatie op een Windows-platform (x86/x64) is ondersteuning voor SSE/SSE2-instructies vereist.
• Voor standaardcompliatie op een Windows RT-platform is ARM-NEON instructieondersteuning vereist.
• Compilatie met _XM_NO_INTRINSICS_ gedefinieerd vereist alleen standaardondersteuning voor drijvende-kommabewerkingen.

De DirectXMath Library ondersteunt voornamelijk de programmeertaal C++ . De bibliotheek wordt geïmplementeerd met behulp van inline routines in de headerbestanden, DirectXMath*.inl, DirectXPackedVector.inl en DirectXCollision.inl. Deze implementatie maakt gebruik van high-performance compiler intrinsieken.

De DirectXMath-bibliotheek biedt:

• Een implementatie met SSE/SSE2 intrinsieken.
• Een implementatie zonder intrinsieke kenmerken.
• Een implementatie met behulp van ARM-NEON-intrinsieken.

Omdat de bibliotheek wordt geleverd met headerbestanden, gebruikt u de broncode om uw eigen app aan te passen en te optimaliseren.

DirectXMath maakt gebruik van rij-georiënteerde matrices, rijvectoren en pre-vermenigvuldiging. Handigheid wordt bepaald door welke versie van de functie wordt gebruikt (RH versus LH), anders werkt de functie met zowel linkshandige als rechtshandige weergavecoördinaten.

Ter informatie heeft Direct3D historisch gezien een linkshandig coördinaatsysteem, rij-primaire matrices, rijvectoren en pre-vermenigvuldiging gebruikt. Moderne Direct3D heeft geen sterke vereiste voor links- versus rechtshandige coördinaten, en HLSL-shaders gebruiken standaard kolom-hoofd matrices. Zie HLSL Matrix Ordering voor meer informatie.

Als u DirectXMath Library-functies wilt gebruiken, neemt u de headers DirectXMath.h, DirectXPackedVector.h, DirectXColors.h en/of DirectXCollision.h op. De headers vindt u in de Windows Software Development Kit voor Windows Store-apps.

De XMVECTOR en de XMMATRIX zijn de werkpaarden voor de DirectXMath-bibliotheek. Elke bewerking verbruikt of produceert gegevens van deze typen. Werken met hen is essentieel voor het gebruik van de bibliotheek. Aangezien DirectXMath echter gebruikmaakt van de SIMD-instructiesets, zijn deze gegevenstypen onderhevig aan een aantal beperkingen. Het is van cruciaal belang dat u deze beperkingen begrijpt als u goed gebruik wilt maken van de DirectXMath-functies.

U moet denken aan XMVECTOR als proxy voor een SIMD-hardwareregister en XMMATRIX als proxy voor een logische groepering van vier SIMD-hardwareregisters. Deze typen worden geannoteerd om aan te geven dat ze 16 byte-uitlijning nodig hebben om correct te werken. De compiler plaatst ze automatisch correct op de stack wanneer ze worden gebruikt als een lokale variabele, of plaatsen ze in het gegevenssegment wanneer ze worden gebruikt als een globale variabele. Met de juiste conventies kunnen ze ook veilig worden doorgegeven als parameters voor een functie (zie oproepconventies voor meer informatie).

Toewijzingen vanuit de heap zijn echter ingewikkelder. Daarom moet u voorzichtig zijn wanneer u XMVECTOR- of XMMATRIX- gebruikt als lid van een klasse of structuur die moet worden toegewezen vanuit de heap. In Windows x64 zijn alle heap-toewijzingen 16 byte uitgelijnd, maar voor Windows x86 zijn ze slechts 8 byte uitgelijnd. Er zijn opties voor het toewijzen van structuren van de heap met uitlijning van 16 bytes (zie Toewijzingen correct uitlijnen). Voor C++-programma's kunt u operator new/delete/new[]/delete[] overbelastingen (globaal of klassespecifiek) gebruiken om indien gewenst optimale uitlijning af te dwingen.

Vaak is het echter eenvoudiger en compacter om te voorkomen dat u XMVECTOR of XMMATRIX rechtstreeks in een klasse of structuur gebruikt. Maak in plaats daarvan gebruik van de XMFLOAT3, XMFLOAT4, XMFLOAT4X3, XMFLOAT4X4, enzovoort, als leden van uw structuur. Verder kunt u de functies Vector Loading en Vector Storage gebruiken om de gegevens efficiënt te verplaatsen naar XMVECTOR- of XMMATRIX lokale variabelen, berekeningen uit te voeren en de resultaten op te slaan. Er zijn ook streamingfuncties (XMVector3TransformStream, XMVector4TransformStream, enzovoort) die efficiënt werken op matrices van deze gegevenstypen.

Veel bewerkingen vereisen het gebruik van constanten in vectorberekeningen en er zijn een aantal manieren om een XMVECTOR- met de gewenste waarden te laden.

• Als u een scalaire constante in alle elementen van een XMVECTOR-laadt, gebruikt u XMVectorReplicate of XMVectorReplicateInt.

  XMVECTOR vFive = XMVectorReplicate( 5.f );
  

• Als u een vectorconstante met verschillende vaste waarden gebruikt als een XMVECTOR-, gebruikt u de XMVECTORF32, XMVECTORU32, XMVECTORI32of XMVECTORU8 structuren. Deze kunnen vervolgens overal rechtstreeks worden gebruikt waar u een XMVECTOR waarde doorgeeft.

  static const XMVECTORF32 vFactors = { 1.0f, 2.0f, 3.0f, 4.0f };
  

  Notitie

  Gebruik initialisatielijsten niet rechtstreeks met XMVECTOR (XMVECTOR v = { 1.0f, 2.0f, 3.0f, 4.0f }). Dergelijke code is inefficiënt en is niet overdraagbaar op alle platforms die worden ondersteund door DirectXMath.

   

• DirectXMath bevat een aantal vooraf gedefinieerde globale constanten die u kunt gebruiken in uw code (g_XMOne, g_XMOne3, g_XMTwo, g_XMOneHalf, g_XMHalfPi, g_XMPi enzovoort). Zoek in de header DirectXMath.h naar de XMGLOBALCONST waarden.

• Er zijn een reeks vectorconstanten voor algemene RGB-kleuren (rood, groen, blauw, geel, enzovoort). Zie DirectXColors.h en de Naamruimte DirectX::Colors voor meer informatie over deze vectorconstanten.

• Zie XMVectorReplicate en XMVectorReplicateIntals u een vector maakt op basis van één scalaire variabele.

  XMVECTOR v = XMVectorReplicate( f  );
  

• Als u een vector maakt op basis van vier scalaire variabelen, raadpleegt u XMVectorSet en XMVectorSetInt.

  XMVECTOR v = XMVectorSet( fx, fy, fz, fw );
  

• Als u een vector maakt op basis van een andere vector met een specifiek onderdeel dat is ingesteld op een variabele, kunt u overwegen Vector Accessor Functions te gebruiken.

  XMVECTOR v2 = XMVectorSetW( v1, fw );
  

• Als u een vector maakt op basis van een andere vector waarbij één onderdeel is gerepliceerd, gebruikt u XMVectorSplatX, XMVectorSplatY, XMVectorSplatZen XMVectorSplatW.

  XMVECTOR vz = XMVectorSplatZ( v );
  

• Zie XMVectorSwizzle en XMVectorPermuteals u een vector maakt op basis van een andere vector of paar vectoren met opnieuw gerangschikte onderdelen.

  XMVECTOR v2 = XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_W, XM_SWIZZLE_X>( v1 );
  
  XMVECTOR v3 = XMVectorPermute<XM_PERMUTE_0W, XM_PERMUTE_1X, XM_PERMUTE_0X, XM_PERMUTE_1Z>( v1, v2 );
  

• Zie XMVectorReplicatePtr, XMVectorReplicateIntPtr, XMLoadFloaten XMLoadIntvoor het laden van een enkele floatwaarde uit het geheugen.
• Veelgebruikte manieren om floatmatrices te laden zijn: XMLoadFloat2, XMLoadFloat3, XMLoadFloat4, XMLoadFloat3x3, XMLoadFloat4x3en XMLoadFloat4x4.
• DirectXMath bevat een uitgebreide set typen en gerelateerde belastingen en archieven voor het verwerken van verschillende gegevensstructuren en algemene GPU-indelingen. Zie Vector Load en Vector Store.

SIMD-verwerking is het meest efficiënt wanneer gegevens in de SIMD-registers worden geladen en volledig worden verwerkt voordat de resultaten worden geëxtraheerd. Conversie tussen scalaire en vectorvormen is inefficiënt, dus we raden u aan dit alleen te doen wanneer dat nodig is. Daarom worden functies in de DirectXMath-bibliotheek die een scalaire waarde produceren, geretourneerd in een vectorvorm waarbij het scalaire resultaat wordt gerepliceerd over de resulterende vector (dat wil gezegd, XMVector2Dot, XMVector3Length, enzovoort). Als u echter scalaire waarden nodig hebt, zijn hier een paar opties voor hoe u dit kunt doen:

• Als één scalair antwoord wordt berekend, is het gebruik van de Vector Accessor Functions geschikt:

  float f = XMVectorGetX( v );
  

• Als meerdere onderdelen van de vector moeten worden geëxtraheerd, kunt u overwegen om de vector op te slaan in een geheugenstructuur en deze terug te lezen. Bijvoorbeeld:

  XMFLOAT4A t;
  XMStoreFloat4A( &t, v );
  // t.x, t.y, t.z, and t.w can be individually accessed now
  

• De meest efficiënte vorm van vectorverwerking is het gebruik van geheugen-naar-geheugenstreaming waarbij de invoergegevens uit het geheugen worden geladen (met behulp van Vector Load Functions), volledig in SIMD-vorm worden verwerkt en vervolgens naar het geheugen worden geschreven (met behulp van Vector Store Functions).

Handleiding voor programmeren met DirectXMath