Transformaties (Direct3D 9)

Het deel van Direct3D dat geometrie door de geometriepijplijn met vaste functies pusht, is de transformatie-engine. Het zoekt het model en de viewer ter wereld, projecteert hoekpunten voor weergave op het scherm en knipt hoekpunten naar de viewport. De transformatie-engine voert ook verlichtingsberekeningen uit om diffuse en speculaire componenten op elk hoekpunt te bepalen.

De geometriepijplijn neemt hoekpunten als invoer. De transformatie-engine past de wereld, weergave en projectietransformaties toe op de hoekpunten, knipt het resultaat en geeft alles door aan de rasterizer.

Aan het hoofd van de pijplijn worden de hoekpunten van een model gedeclareerd ten opzichte van een lokaal coördinaatsysteem. Dit is een lokale oorsprong en een oriëntatie. Deze richting van coördinaten wordt vaak modelruimte genoemd en afzonderlijke coördinaten worden modelcoördinaten genoemd.

De eerste fase van de geometriepijplijn transformeert de hoekpunten van een model van hun lokale coördinaatsysteem naar een coördinaatsysteem dat wordt gebruikt door alle objecten in een scène. Het proces van het heroriënteren van de hoekpunten wordt de wereldtransformatie genoemd. Deze nieuwe richting wordt vaak wereldruimte genoemd en elk hoekpunt in de wereldruimte wordt gedeclareerd met behulp van wereldcoördinaten.

In de volgende fase zijn de hoekpunten die uw 3D-wereld beschrijven gericht op een camera. Dat wil gezegd, uw toepassing kiest een punt-van-beeld voor de scène, en wereldruimtecoördinaten worden verplaatst en gedraaid rond de weergave van de camera, waardoor wereldruimte wordt omgezet in cameraruimte. Dit is de weergavetransformatie.

De volgende fase is de projectietransformatie. In dit deel van de pijplijn worden objecten meestal geschaald met betrekking tot hun afstand van de kijker om de illusie van diepte aan een scène te geven; gesloten objecten worden gemaakt om groter dan verre objecten weer te geven, enzovoort. Ter vereenvoudiging verwijst deze documentatie naar de ruimte waarin hoekpunten bestaan na de projectietransformatie als projectieruimte. Sommige grafische boeken kunnen verwijzen naar projectieruimte als homogene ruimte na perspectief. Niet alle projectietransformaties schalen de grootte van objecten in een scène. Een projectie zoals dit wordt ook wel een affine of orthogonale projectie genoemd.

In het laatste deel van de pijplijn worden eventuele hoekpunten die niet zichtbaar zijn op het scherm verwijderd, zodat de rasterizer niet de tijd neemt om de kleuren en arcering te berekenen voor iets dat nooit zal worden gezien. Dit proces wordt knipsel genoemd. Na het knippen worden de resterende hoekpunten geschaald op basis van de viewport-parameters en geconverteerd naar schermcoördinaten. De resulterende hoekpunten, die op het scherm worden weergegeven wanneer de scène wordt gerasterd, bevinden zich in de schermruimte.

Transformaties worden gebruikt om objectgeometrie te converteren van de ene coördinaatruimte naar de andere. Direct3D maakt gebruik van matrices om 3D-transformaties uit te voeren. In deze sectie wordt uitgelegd hoe matrices 3D-transformaties maken, enkele veelgebruikte toepassingen voor transformaties en details beschrijft hoe u matrices kunt combineren om één matrix te produceren die meerdere transformaties omvat.

• World Transform (Direct3D 9) : converteren van modelruimte naar wereldruimte
• Weergavetransformatie (Direct3D 9) : converteren van wereldruimte naar weergaveruimte
• Projectietransformatie (Direct3D 9) : converteren van weergaveruimte naar projectieruimte

Matrixtransformaties

In toepassingen die met 3D-afbeeldingen werken, kunt u geometrische transformaties gebruiken om het volgende te doen:

• De locatie van een object ten opzichte van een ander object uitdrukken.
• Objecten draaien en de grootte wijzigen.
• Weergaveposities, routebeschrijvingen en perspectieven wijzigen.

U kunt elk punt (x,y,z) omzetten in een ander punt (x', y', z') met behulp van een 4x4-matrix, zoals wordt weergegeven in de volgende vergelijking.

Voer de volgende vergelijkingen uit op (x, y, z) en de matrix om het punt (x', y', z' te produceren).

De meest voorkomende transformaties zijn vertaling, rotatie en schaalaanpassing. U kunt de matrices die deze effecten produceren, combineren tot één matrix om verschillende transformaties tegelijk te berekenen. U kunt bijvoorbeeld één matrix bouwen om een reeks punten te vertalen en te draaien.

Matrices worden geschreven in rijkolomvolgorde. Een matrix die hoekpunten gelijkmatig langs elke as schaalt, ook wel uniform schalen genoemd, wordt vertegenwoordigd door de volgende matrix met behulp van wiskundige notatie.

In C++declareert Direct3D matrices als een tweedimensionale matrix met behulp van de D3DMATRIX structuur. In het volgende voorbeeld ziet u hoe u een D3DMATRIX structuur initialiseert om te fungeren als een uniforme schaalmatrix.

// In this example, s is a variable of type float.

D3DMATRIX scale = {
    s,               0.0f,            0.0f,            0.0f,
    0.0f,            s,               0.0f,            0.0f,
    0.0f,            0.0f,            s,               0.0f,
    0.0f,            0.0f,            0.0f,            1.0f
};

Vertalen

Met de volgende vergelijking wordt het punt (x, y, z) omgezet in een nieuw punt (x', y', z').

U kunt handmatig een vertaalmatrix maken in C++. In het volgende voorbeeld ziet u de broncode voor een functie waarmee een matrix wordt gemaakt om hoekpunten te vertalen.

D3DXMATRIX Translate(const float dx, const float dy, const float dz) {
    D3DXMATRIX ret;

    D3DXMatrixIdentity(&ret);
    ret(3, 0) = dx;
    ret(3, 1) = dy;
    ret(3, 2) = dz;
    return ret;
}    // End of Translate

Voor het gemak levert de D3DX-hulpprogrammabibliotheek de functie D3DXMatrixTranslation.

Schub

Met de volgende vergelijking wordt het punt (x, y, z) geschaald op willekeurige waarden in de x-, y- en z-richtingen naar een nieuw punt (x', y', z').

Draaien

De transformaties die hier worden beschreven, zijn bedoeld voor linkshandige coördinaatsystemen, en kunnen dus afwijken van transformatiematrices die u elders hebt gezien.

Met de volgende vergelijking wordt het punt (x, y, z) rond de x-as gedraaid, waardoor een nieuw punt (x', y', z' wordt geproduceerd).

Met de volgende vergelijking wordt het punt rond de y-as gedraaid.

Met de volgende vergelijking wordt het punt rond de z-as gedraaid.

In deze voorbeeldmatrices staat de Griekse letter theta voor de draaihoek, in radialen. Hoeken worden met de klok mee gemeten wanneer ze langs de draaias naar de oorsprong kijken.

Gebruik in een C++-toepassing de D3DXMatrixRotationX, D3DXMatrixRotationYen D3DXMatrixRotationZ functies die worden geleverd door de D3DX-hulpprogrammabibliotheek om rotatiematrices te maken. Hier volgt de code voor de functie D3DXMatrixRotationX.

D3DXMATRIX* WINAPI D3DXMatrixRotationX
    ( D3DXMATRIX *pOut, float angle )
{
#if DBG
    if(!pOut)
        return NULL;
#endif

    float sin, cos;
    sincosf(angle, &sin, &cos);  // Determine sin and cos of angle

    pOut->_11 = 1.0f; pOut->_12 =  0.0f;   pOut->_13 = 0.0f; pOut->_14 = 0.0f;
    pOut->_21 = 0.0f; pOut->_22 =  cos;    pOut->_23 = sin;  pOut->_24 = 0.0f;
    pOut->_31 = 0.0f; pOut->_32 = -sin;    pOut->_33 = cos;  pOut->_34 = 0.0f;
    pOut->_41 = 0.0f; pOut->_42 =  0.0f;   pOut->_43 = 0.0f; pOut->_44 = 1.0f;

    return pOut;
}

Matrices samenvoegen

Een voordeel van het gebruik van matrices is dat u de effecten van twee of meer matrices kunt combineren door ze te vermenigvuldigen. Dit betekent dat u, als u een model wilt draaien en het vervolgens naar een bepaalde locatie wilt vertalen, geen twee matrices hoeft toe te passen. In plaats daarvan vermenigvuldigt u de draai- en vertaalmatrices om een samengestelde matrix te produceren die alle effecten bevat. Dit proces, matrixsamenvoeging genoemd, kan worden geschreven met de volgende vergelijking.

In deze vergelijking is C de samengestelde matrix die wordt gemaakt en M₁ tot en met Mn de afzonderlijke matrices zijn. In de meeste gevallen worden slechts twee of drie matrices samengevoegd, maar er is geen limiet.

Gebruik de functie D3DXMatrixMultiply om matrixvermeniging uit te voeren.

De volgorde waarin de matrixvermeniging wordt uitgevoerd, is van cruciaal belang. De voorgaande formule weerspiegelt de regel van links naar rechts van matrixsamenvoeging. Dat wil gezegd: de zichtbare effecten van de matrices die u gebruikt om een samengestelde matrix te maken, vinden plaats in volgorde van links naar rechts. In het volgende voorbeeld wordt een typische wereldmatrix weergegeven. Stel dat u de wereldmatrix maakt voor een stereotiepische vliegende schotel. Waarschijnlijk wilt u de vliegende schotel rond het midden draaien - de y-as van de modelruimte - en deze vertalen naar een andere locatie in uw scène. Om dit effect te bereiken, maakt u eerst een rotatiematrix en vermenigvuldigt u deze vervolgens met een vertaalmatrix, zoals wordt weergegeven in de volgende vergelijking.

In deze formule is R_y een matrix voor rotatie over de y-as en T_met een vertaling naar een bepaalde positie in wereldcoördinaten.

De volgorde waarin u de matrices vermenigvuldigt, is belangrijk omdat, in tegenstelling tot het vermenigvuldigen van twee scalaire waarden, matrixvermeniging niet commutatief is. Het vermenigvuldigen van de matrices in de tegenovergestelde volgorde heeft het visuele effect van het vertalen van de vliegende schotel naar de positie van de wereldruimte en het vervolgens draaien rond de oorsprong van de wereld.

Ongeacht het type matrix dat u maakt, moet u de regel van links naar rechts onthouden om ervoor te zorgen dat u de verwachte effecten bereikt.

Verwante onderwerpen

Aan de slag