Environment Mapping v 1.1

Transkript

1 DirectX Tutorial: Environment Mapping 1 Environment Mapping v 1.1 Einleitung Zuerst einmal sei gesagt, dass es verschiedene Arten von Environment Mapping gibt. Hier wird aber nur das Cubic Environment Mapping näher betrachtet. Wie der Name schon sagt, wird dabei eine kubische Umgebungstextur verwendet. Sie haben sich sicher schon einmal gefragt, wie man spiegelnde Oberflächen realisieren könnte. Eine neuere Technik ist Ray-Tracing: Für jeden Pixel des Objekts, das einen Reflektionseffekt aufweisen soll, wird ein Strahl in die 3D-Szene geschossen. Trifft der Strahl (engl. Ray) auf ein Objekt, so wird der Pixel in der Farbe des getroffenen Objekts gezeichnet. Da diese Aufgabe der CPU übergeben werden müsste, wäre eine solche Berechnung für Echtzeitgrafik (momentan) nicht realisierbar. Ein wesentlich schnellerer Ansatz ist daher Cubic Environment Mapping. Theorie Eine kubische Umgebungstextur beinhaltet sechs 2D-Texturen, welche die Szene, die das Objekt umgibt, aus der Sicht von sechs Seiten (vorn, hinten, oben, unten, rechts, links) beinhalten. Somit kann man die Oberfläche von Objekten metallisch glänzen lassen! Hier am besten einmal ein Screenshot, um etwas Motivation aufzubauen =) Abb. 1: Realtime Dynamic Cubic Environment Mapping Eine Cubic Map ( Würfeltextur ) besteht also aus sechs Seiten, für jede Blickrichtung eine. Die folgende Abbildung demonstriert dies:

2 DirectX Tutorial: Environment Mapping 2 Abb. 2: Skybox aufgefaltet Die Würfeltextur enthält also ein komplettes Abbild der Umgebung (engl. Environment). Doch wie kommen wir nun an diese Umgebungsdaten? Dazu müssen wir die ganze Szene in die Würfeltextur rendern, und dies einmal pro Seite. Pro Objekt fallen also insgesamt sechs zusätzliche Rendervorgänge an. Environment Mapping ist ohne den Einsatz von CPU-lastigem Ray-Tracing möglich. Die Funktionsweise ist relativ einfach: Abb. 3: Berechnung des Reflektionsvektors Von der Kameraposition zur Pixelposition auf dem Objekt wird ein Vektor generiert. Im selben Winkel α, in welchem die Kamera auf das Objekt schaut (resp. der Winkel zwischen Normalenvektor des Vertex und Kameraposition-zu-Objekt-Vektor), wird ein Vektor vom Objekt reflektiert. Dort, wo dieser Reflektionsvektor die Skybox trifft, wird die Farbe auf der Würfeltextur abgelesen. Der Pixel auf dem Objekt erhält nun genau diese Farbe. Dieses Verfahren wiederholt sich für jeden im sichtbaren Bereich liegenden Pixel des Objekts. Hier dürfte man eigentlich nicht von Skybox sprechen, denn eigentlich setzen wird nur eine Textur, ohne irgendwelche Geometrie. Ein etwas anderer Ansatz ist Spherical Environment Mapping. Eine Sphere-Map ist eine 2D- Repräsentation einer vollen Rundumsicht der Szene, die das Objekt umgibt. Damit könnte man

3 DirectX Tutorial: Environment Mapping 3 beispielsweise eine Fischaugenlinse entwickeln (dass die ganze Szene verschwommen aussieht). Diese Technik wird hier aber nicht weiter behandelt. Umsetzung mit Direct3D Im Zusammenhang mit Cubic Environment Mapping hört man immer wieder die Begriffe Pixel- und Vertex-Shader. Es ist möglich, die CPU zu entlasten, indem man die Texturkoordinatenberechnung der GPU übergibt. Weiter unten im Skript wird dann auch ein kleiner Shader entwickelt. Es gibt aber auch die Möglichkeit, die Texturkoordinaten von Direct3D generieren zu lassen. Dazu müssen erst eine Textur und anschliessend die entsprechenden Render- und Textur-Stage-States gesetzt werden. Das folgende Beispiel demonstriert, wie man der Textur der ersten Schicht die automatische Texturkoordinatengenerierung zuweist: IDirect3DDevice9::SetTexture(0, lpcubetexture); IDirect3DDevice9::SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR); Nun brauchen wir aber noch die Würfeltextur, die in lpcubetexture gespeichert wird! Zuerst müssen wir diese Textur erstellen: IDirect3DDevice9::CreateCubeTexture(256, // Auflösung (x = y) 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &lpcubemap, NULL); Dann brauchen wir eine Funktion, die einmal pro Frame aufgerufen wird und die ganze Szene in diese sechs 2D-Texturen rendert. Am besten lass ich gleich den Code sprechen: void RenderSceneIntoCubeMap() // das alte Render-Target LPDIRECT3DSURFACE9 lprtold = NULL; // Die Projektionsmatrix hat ein Sichtfeld von 90 kcmatrix mproj = kcmat_projection(kc_pi * 0.5f, 1.0f, 0.01f, 100.0f); // View-Matrix abfragen kcmatrix mviewdir = Camera.GetViewMatrix(); // Position auf den Ursprung setzen (wir brauchen nur Richtung) mviewdir.m41 = mviewdir.m42 = mviewdir.m43 = 0.0f; // die alten Device-Einstellungen speichern IDirect3DDevice9::GetRenderTarget(0, &lprtold); // alle Seiten der Würfeltextur durchgehen for (int iface = 0; iface < 6; ++iface) LPDIRECT3DSURFACE9 lpsurf; // Textur Nr. iface des Würfels anfordern und in // lpsurf speichern lpcubemap->getcubemapsurface((d3dcubemap_faces)iface, 0, &lpsurf);

4 DirectX Tutorial: Environment Mapping 4 // die angeforderte Textur als neues Render-Target setzen // und anschliessend wieder freigeben IDirect3DDevice9::SetRenderTarget(0, lpsurf); KC_MEM_RELEASE(lpSurf); // nur den Z-Buffer leeren IDirect3DDevice9::Clear(0, NULL, D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0); // die endgültige View-Matrize zusammensetzen kcmatrix mview = mviewdir * GetCubeMapViewMatrix(iFace); // View- und Projektionsmatrix setzen IDirect3DDevice9::SetTransform(D3DTS_PROJECTION, &mproj); IDirect3DDevice9::SetTransform(D3DTS_VIEW, &mview); if (SUCCEEDED(IDirect3DDevice9::BeginScene())) // --- Szene hier rendern! --- IDirect3DDevice9::EndScene(); // das alte Render-Target wieder setzen IDirect3DDevice9::SetRenderTarget(0, lprtold); KC_MEM_RELEASE(lpRTOld); Hinweis: Die Funktion GetCubeMapViewMatrix erscheint weiter unten im Skript nochmals. Der Einsatz von Shadern Ob man nun einen Shader benutzt oder nicht, das Endergebnis ist in etwa das gleiche. Nur hat die CPU dadurch mehr Reserven für andere Berechnungen und ausserdem haben wir die Möglichkeit, über den Pixel-Shader jeden einzelnen Bildpunkt beliebig (!) zu verändern, bevor er schlussendlich am Monitor sichtbar wird. Der Code basiert übrigens auf dem Beispielprogramm HDRCubeMap aus dem DirectX 9 SDK und benutzt Vertex-Shader 1.1 und Pixel-Shader 2.0: // V E R T E X S H A D E R void Reflection(float4 Pos : POSITION, float3 Normal : NORMAL, out float4 opos : POSITION, out float3 EyeReflVec : TEXCOORD0) // Position in Weltkoordinaten transformieren float4 WorldPos = mul(pos, g_mworld); // den Normalenvektor ebenfalls in Weltkoordinaten transf. u. normalisieren float3 WorldNormal = normalize(mul(normal, g_mworld)); // den Kamera-zu-Vertex-Vektor bilden und dann den Reflektionsvektor // abfragen mit der vordefinierten Funktion reflect float3 EyeVec = g_camerapos - WorldPos; EyeReflVec = reflect(eyevec, WorldNormal); // Position transformieren opos = mul(worldpos, g_mviewproj); // P I X E L S H A D E R float4 ApplyPixelShader(float3 EyeReflVec : TEXCOORD0) : COLOR

5 DirectX Tutorial: Environment Mapping 5 return texcube(linearsampler, EyeReflVec) * g_fcolorfactor; Die von DirectX vordefinierte Funktion reflect tut im Grunde nichts weiter, als anhand des Normalenvektors und des inversen Zu-Kamera-Vektors die Texturkoordinaten für einen Pixel zu berechnen: EyeReflVec = 2 * dot(eyevec, WorldNormal) * WorldNormal - EyeVec; Implementierung Zuerst erstellen wir die Cube Map, in welche wir anschliessend rendern werden. Das Standardformat für Texturen, die als Render-Target verwendet werden, ist A8R8G8B8 (8 Bits pro Kanal). Alternativ könnte man ein Floating-Point-Format wie beispielsweise A16R16G16B16F verwenden. Was ist denn das schon wieder!? Als Floating-Point werden Texturformate bezeichnet, die jedem Farbkanal mehr als 8 Bits zur Verfügung stellen (z.b. 16 oder gar 32 Bits). Dadurch sind intensivere Farbtöne mit einem höheren Dynamikumfang möglich, was zur Verschönerung des Effekts beiträgt. 1 Die Cube Map wird wie folgt erstellt: pd3ddevice->createcubetexture(cube_map_size, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A16B16G16R16F, D3DPOOL_DEFAULT, & lpcubemap, NULL); Die Auflösung der Cube Map kann eigentlich frei gewählt werden, doch aus Kompatibilitätsgründen sind Werte wie 128, 256, 512 oder 1024 zu empfehlen. Nun wird eine Renderfunktion erstellt, die in etwa so aussieht: void RenderSceneIntoCubeMap() LPDIRECT3DSURFACE9 lpnewrt = NULL; LPDIRECT3DSURFACE9 lpoldrt = NULL; LPDIRECT3DSURFACE9 lpolddssurf = NULL; // Projektionsmatrix mit einem Sichtwinkel von 90 (4 * 90 = 360 ) kcmatrix mproj = kcmat_projection(kc_pi * 0.5f, 1.0f, 0.01f, 100.0f); // die Device-Einstellungen speichern pd3ddevice->getrendertarget(0, &lpoldrt); pd3ddevice->getdepthstencilsurface(&lpolddssurf))); // neuer Depth-Stencil-Buffer setzen pd3ddevice->setdepthstencilsurface(lpnewdssurf); // alle sechs Seiten der Cube Map durchgehen for (int iface = 0; iface < 6; iface++) // eine Seite der Cube Map als Render-Target setzen lpcubemap->getcubemapsurface((d3dcubemap_faces)iface, 0, &lpnewrt); pd3ddevice->setrendertarget(0, lpnewrt); lpnewrt->release(); // Render-Target löschen und Szene beginnen 1 Hinweis: Floating-Point-Formate werden nicht von allen Grafikkarten unterstützt

6 DirectX Tutorial: Environment Mapping 6 pd3ddevice->clear(0l, NULL, D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0L); pd3ddevice->beginscene(); // gesamte Szene rendern RenderScene(mProj, GetCubeMapViewMatrix(iFace), FALSE); pd3ddevice->endscene(); // die alten Device-Einstellungen wieder aktivieren pd3ddevice->setdepthstencilsurface(lpolddssurf); pd3ddevice->setrendertarget(0, lpoldrt); // Speicher freigeben lpnewrt->release(); lpoldrt->release(); lpolddssurf->release(); Es wird also zuerst eine Projektionsmatrix mit einem Blickwinkel von 90 (denn es gibt ja vier Seiten, 4 90 = 360 Rundumsicht) und einem Aspekt von eins erstellt (Seitenverhältnis 1:1, denn die Seiten eines Würfels sind ja quadratisch). Als nächstes werden die Device-Einstellungen gespeichert, d.h. das aktuelle Render-Target und der Stencil-Buffer werden kopiert. Es folgt eine for-schleife, die alle Faces (also Würfelseiten ) durchläuft und sie als Render-Target setzt. Zum Beenden eines Durchgangs muss selbstverständlich die begonnene Szene mit EndScene geschlossen werden. Sobald alle sechs Seiten der Cube Map gefüllt sind, werden die alten Device-Einstellungen reaktiviert. Das Einzige, was wir von einem zum anderen Renderdurchgang ändern, ist die View-Matrix. Schauen wir uns doch mal die Funktion GetCubeMapViewMatrix an: kcmatrix kcenvmap::getcubemapviewmatrix(int iface) kcvector veyept = kcvector(0.0f, 0.0f, 0.0f); kcvector vlookdir; kcvector vupdir; switch (iface) case D3DCUBEMAP_FACE_POSITIVE_X: vlookdir = D3DXVECTOR3( 1.0f, 0.0f, 0.0f ); case D3DCUBEMAP_FACE_NEGATIVE_X: vlookdir = D3DXVECTOR3(-1.0f, 0.0f, 0.0f ); case D3DCUBEMAP_FACE_POSITIVE_Y: vlookdir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f ); vupdir = D3DXVECTOR3( 0.0f, 0.0f,-1.0f ); case D3DCUBEMAP_FACE_NEGATIVE_Y: vlookdir = D3DXVECTOR3( 0.0f,-1.0f, 0.0f ); vupdir = D3DXVECTOR3( 0.0f, 0.0f, 1.0f ); case D3DCUBEMAP_FACE_POSITIVE_Z: vlookdir = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );

7 DirectX Tutorial: Environment Mapping 7 case D3DCUBEMAP_FACE_NEGATIVE_Z: vlookdir = D3DXVECTOR3( 0.0f, 0.0f,-1.0f ); kcmatrix mview = kcmat_camera(veyept, vlookdir, vupdir); return mview; Damit haben wir eigentlich alles Notwendige beisammen, was wir brauchen, um eine Oberfläche mit dynamischer Spiegelung der Umgebung in Echtzeit darzustellen. Gedanken zur Performance Nun sollte man in etwa wissen, wie Environment Mapping funktioniert. Sicherlich haben sie sich schon gefragt, ob das dann auch in akzeptabler Geschwindigkeit laufen wird. Es sind also sechs zusätzliche Rendervorgänge nötig und ausserdem müssen die Texturkoordinaten auf eine relativ rechenintensive Art ermittelt werden. Das ist tatsächlich nur auf schnelleren PC-Systemen lauffähig und auch da sollten Environment Maps nur sparsam angewandt werden! Ein halbes Dutzend solcher Environment Mapped Objekte können die Hardware ganz schön ins Schwitzen bringen =). Literaturverzeichnis - Scherfgen, David (2003). 3D Spieleprogrammierung Modernes Gamedesign mit DirectX 9 in C++. München: Carl Hanser Verlag - Microsoft DirectX 9.0 SDK Copyright 2005 by Reto Da Forno Irrtümer vorbehalten. Fehler bitte melden!