[DX11] Spass mit Texturen und Shadern

[Grubenlord]

Auf meiner ausgedehnten Suche nach Erleuchtung beschäftige ich mich auch mit Texturen und finde keine Antwort auf die Frage was mit TEXCOORD[n] | Texture coordinates | float4 anzufangen ist. Als float2 bla :TEXCOORD bekomme ich wunderbar meine uv-Koordinaten, bei float3 bla.xy stimmen diese aber nicht mehr, ist das für 3DKoordinaten gedacht?

Was ich eigentlich Suche sind die xyz-Koordinaten meiner Texel. Wie könnte ich die berechnen oder gibt es da vielleicht sogar ein Entgegenkommen von Direct3D/HLSL?

[Krishty]

Ja, 3D-Texturkoordinaten sind zur Adressierung dreidimensionaler Texturen und Texture-Cubes gedacht.

Wenn du mit der xyz-Koordinate die Koordinate deiner Samples (dem, was dein Pixel-Shader verarbeitet) im World-Space (dem Koordinatensystem deiner virtuellen Welt) meinst, so kannst du im Output deines Vertex-Shaders einen neuen 3D-Vektor anlegen und ihn im Vertex-Shader mit der Koordinate füllen, die du als Vertex-Position entgegen nimmst. Im Pixel-Shader hat diese Komponente dann die für das aktuelle Sample interpolierte Position, also quasi die Koordinate des Pixels, den du gerade verarbeitest.

Wenn dein Objekt rotiert oder verschoben wird, musst du die Position noch mit der World-Matrix transformieren, bevor du sie in den Vertex-Shader-Output schreibst.

Gruß, Ky

[Grubenlord]

Leider kann ich irgendwie nicht nachprüfen ob die Positionen stimmen, da bei meiner Rechnung scheinbar etwas >= 0 rauskommt und ich finde den Fehler nicht. Aber nur so zum Verständnis, bei g_txDiffuse.Sample( g_samLinear, In.TextureUV ) * bla rechne ich bla auf meine komplette Textur oder auf das jeweilige Texel im pass?

[Jörg]

Das "Sample" weisst darauf hin, dass auf die Textur nur lesend zugegriffen wird. Das Ergebnis der Multiplikation vom Resultat des Lese-Zugriffs mit "bla" ist danach nur im Kontext des aktuell zu berechnenden Pixels sichtbar.

[Krishty]

Leider kann ich irgendwie nicht nachprüfen ob die Positionen stimmen, da bei meiner Rechnung scheinbar etwas >= 0 rauskommt und ich finde den Fehler nicht.

Was ist das denn für eine Berechnung?

Aber nur so zum Verständnis, bei g_txDiffuse.Sample( g_samLinear, In.TextureUV ) * bla rechne ich bla auf meine komplette Textur oder auf das jeweilige Texel im pass?

Das "Sample" weisst darauf hin, dass auf die Textur nur lesend zugegriffen wird. Das Ergebnis der Multiplikation vom Resultat des Lese-Zugriffs mit "bla" ist danach nur im Kontext des aktuell zu berechnenden Pixels sichtbar.

Oder um es einfacher auszudrücken: Jeder Pixel lädt den Farbwert „seiner“ Stelle der Textur in den Shader, dort (im Shader, nicht in der Textur) wird dieses Sample mit bla multipliziert. Da der Pixel-Shader bei allen Pixeln gleich ist sieht es dann zwar so aus, als sei die Textur an sich mit bla multipliziert worden, dem ist aber nicht so. Wäre auch witzlos, sonst müsste man Texturen jedes Mal neu laden, wenn sich die Sichtverhältnisse ändern … in der Computergrafik ist Recycling immer die günstigste Alternative :)

[Grubenlord]

Leider kann ich irgendwie nicht nachprüfen ob die Positionen stimmen, da bei meiner Rechnung scheinbar etwas >= 0 rauskommt und ich finde den Fehler nicht.

Was ist das denn für eine Berechnung?

Es geht um Formfaktoren, kann ich mal posten wenn ich es wieder irgendwie lesbargemacht habe.

Aber nur so zum Verständnis, bei g_txDiffuse.Sample( g_samLinear, In.TextureUV ) * bla rechne ich bla auf meine komplette Textur oder auf das jeweilige Texel im pass?

Das "Sample" weisst darauf hin, dass auf die Textur nur lesend zugegriffen wird. Das Ergebnis der Multiplikation vom Resultat des Lese-Zugriffs mit "bla" ist danach nur im Kontext des aktuell zu berechnenden Pixels sichtbar.

Oder um es einfacher auszudrücken: Jeder Pixel lädt den Farbwert „seiner“ Stelle der Textur in den Shader, dort (im Shader, nicht in der Textur) wird dieses Sample mit bla multipliziert. Da der Pixel-Shader bei allen Pixeln gleich ist sieht es dann zwar so aus, als sei die Textur an sich mit bla multipliziert worden, dem ist aber nicht so. Wäre auch witzlos, sonst müsste man Texturen jedes Mal neu laden, wenn sich die Sichtverhältnisse ändern … in der Computergrafik ist Recycling immer die günstigste Alternative :)

Ja, das macht Sinn, aber ich würde trotzdem gerne auf die Texel schreiben :-) Ich habe es jetzt mal über die load (g_txDiffuse.Load(int3(In.TextureUV.xy*8, 0 ))) Funktion versucht, aber das Verhalten ist aber das selbe, oder wäre das doch der richtige Weg?

[Krishty]

Zufällig direkt gesehen :P

Wenn du auf Texturen rendern möchtest, musst du eine Render-Target-View der entsprechenden Textur erzeugen, einen Viewport mit den Ausmaßen der Textur setzen und ein Quad über den ganzen Viewport rendern. Dann landet das, was du sonst auf den Bildschirm schreibst, in der Textur. Falls du Compute-Shader zur Verfügung hast, geht es ohne Fullscreen-Quad und mit Unordered-Access-View statt Render-Target-View.

Du musst beachten, dass eine Ressource nicht doppelt an die Pipeline gebunden sein kann, d.h. du kannst die Textur, in die du renderst, nicht gleichzeitig als Input setzen. Möchtest du also eine Textur überschreiben, musst du eine Kopie erzeugen, dort hineinrendern und das Resultat per CopyResource() in die Zieltextur kopieren.

[Grubenlord]

Auch das klingt mal wieder super einleuchtend, doch irgendwie durchschaue ich nicht was ich genau machen muss, damit das funktioniert. Die Beispiele im Internet sind leider nur DX9/10.
Schon das initialisieren des RTV scheitert :?

Code: Alles auswählen

D3D11_TEX2D_RTV mipmaplvlRTV;
	mipmaplvlRTV.MipSlice = 0;

	D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
	rtvDesc.Format = DXGI_FORMAT_R32G32B32_FLOAT;
	rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
	rtvDesc.Texture2D = mipmaplvlRTV;

	ID3D11RenderTargetView ppRTV;
	ppRTV.GetDesc(&rtvDesc);
	
	pd3dDevice->CreateRenderTargetView( &texRTV, &rtvDesc, ppRTV);// klappt nicht weil ppRTV kein ** 

Wohin mit meiner original Textur? Was ist mit den Shadern? Erst einmal möchte ich es ohne ComputeShader programmieren. Oh man, ich steh total auf dem Schlauch :?

[Aramis]

Auch wenn es hart klingt: ich denke, du hast in Bezug auf Grundlagen von C++ noch einiges nachzuholen. Ich würde das jetzt erledigen denn sonst wird jedes neue API zu einem Spießrutenlauf gegen einen unbarmherzigen Compiler.

Code: Alles auswählen

ID3D11RenderTargetView ppRTV;
ppRTV.GetDesc(&rtvDesc);
pd3dDevice->CreateRenderTargetView( &texRTV, &rtvDesc, ppRTV);// klappt nicht weil ppRTV kein **

D3D-Interfaces sind polymorphe Typen, sprich du arbeitest nur mit Pointern bzw. Referenzen zu ihnen:

Code: Alles auswählen

ID3D11RenderTargetView *ppRTV;

Nun muss dir ja irgendjemand ein RenderTargetView erstellen und dir einen Pointer auf ein zugehöriges Interface geben.

Siehe dazu die Doku zu CRTV:

ppRTView
[out] Address of a pointer to an ID3D11RenderTargetView. Set this parameter to NULL to validate the other input parameters (the method will return S_FALSE if the other input parameters pass validation).

D.h. sie erwartet einen Pointer auf ein Interface (ID3D11RenderTargetView**), den sie sozusagen füllt.

Code: Alles auswählen

ID3D11RenderTargetView* ppRTV;
ppRTV->GetDesc(&rtvDesc);
pd3dDevice->CreateRenderTargetView( &texRTV, &rtvDesc, &ppRTV);

Soweit, so gut. Jetzt gibt es da noch diese nette D3D11_RENDER_TARGET_VIEW_DESC. Du versuchst sie über ein komplett uninitialisiertes RenderTargetView zu erhalten. Woher soll das Target denn wissen was du von ihm willst? Entweder du gibt 0 an (siehe Doku), oder du musst eine solhe Struktur manuell füllen und an CRTV übergeben. Tust du ja auch -- nur überschreibst du hinterher alles wieder mit dem unnötigen Aufruf von GetDesc().

[Grubenlord]

[...]

Code: Alles auswählen

ID3D11RenderTargetView* ppRTV;
ppRTV->GetDesc(&rtvDesc);
pd3dDevice->CreateRenderTargetView( &texRTV, &rtvDesc, &ppRTV);

Soweit, so gut. Jetzt gibt es da noch diese nette D3D11_RENDER_TARGET_VIEW_DESC. Du versuchst sie über ein komplett uninitialisiertes RenderTargetView zu erhalten. Woher soll das Target denn wissen was du von ihm willst? Entweder du gibt 0 an (siehe Doku), oder du musst eine solhe Struktur manuell füllen und an CRTV übergeben. Tust du ja auch -- nur überschreibst du hinterher alles wieder mit dem unnötigen Aufruf von GetDesc().

Es klingt wohl jetzt nach einer billigen Ausrede, aber ich hatte das so schon getestet und scheiterte natürlich an ppRTV->GetDesc(&rtvDesc);. Aber da das scheinbar unwichtig ist ... funktionieren tuts ohne auf jedenfall schon mal, aber wie weiter?

[Krishty]

Auch wenn es hart klingt: ich denke, du hast in Bezug auf Grundlagen von C++ noch einiges nachzuholen. Ich würde das jetzt erledigen denn sonst wird jedes neue API zu einem Spießrutenlauf gegen einen unbarmherzigen Compiler.

Meine derzeitige Arbeit mit D3D11 ist auch ein Spießroutenlauf, weil ich die Sprache zu gut kenne um D3D11 out-of-the-box zu übernehmen und verzweifelt die API zu wrappen versuche. Egal ob Anfänger oder Profi: Am Ende steht man da als armer Thor und das Programm ist so unfertig als wie zuvor. Also boxen wir ihn hier in bester Prototyping-Manier durch, lernen wird er von allein ;)

aber wie weiter?

Einen Vertex-Shader erzeugen, der dir ein Rechteck über den ganzen Bildschirm malt:

Code: Alles auswählen

// Die Positionen der vier Ecken eines Quadrats, gegeben als Triangle-Strip (Front im Uhrzeigersinn).
static const float2 Positions[] = {
	float2(-1.0f, -1.0f),
	float2(-1.0f,  1.0f),
	float2( 1.0f, -1.0f),
	float2( 1.0f,  1.0f)
};

// Vertex-Shader. Da ein Vertex hier keine anderen Eigenschaften als seine Position besitzt, schreiben wir direkt
//	in "SV_Position" anstatt erst eine Vertex-Struktur anzulegen.
float4 VertexFromIndex(
	in const uint ItsIndex : SV_VertexId
) : SV_Position {
	// Die W-Koordinate der Vertices wird auf 1 gesetzt, damit sich die Vertexposition bei der Division durch W,
	//	die der Rasterizer zur perspektivischen Projektion durchführt, nicht mehr ändert.
	return float4(Positions[ItsIndex].xy, 0.0f, 1.0f);
}

Dieser Shader nimmt keine Vertices entgegen, sondern erzeugt sie on-the-fly aus dem Index SV_VertexId. Der Wert wird von der Grafikkarte vorgegeben und ist ein fortlaufender Index, wieviele Vertices im aktuellen Draw-Call verarbeitet wurden (0 für das erste Vertex, 1 für das Zweite usw). Das bedeutet für dich: Du entbindest alle Vertex-Buffers und Input-Layouts (setzt sie auf NULL). Da die Vertices als Triangle-Strip gegeben sind, setzt du die Primitive-Topology auf D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP. Im Rasterizer-State stellst du sicher, dass die Dreiecke gerendert werden, die im Uhrzeigersinn gegeben sind (D3D11_FILL_SOLID, D3D11_CULL_BACK, FALSE). Nachdem du deinen Pixel-Shader geschrieben und gebunden hast, rufst du Draw(4, 0) auf.

Dein Pixel-Shader nimmt nichts anderes als die Position des Vertex entgegen:

Code: Alles auswählen

float3 ProcessPixel(
	in const float4 ItsPosition : SV_Position
) : SV_Target0 {
	// Hier machst du mit der Textur, was du willst – z.B. kannst du "Texture.Load(int2(ItsPosition.xy))" benutzen,
	//	um aus einer Quelltextur namens "Texture" den Pixel zu lesen, der an die momentane Stelle gehört. Das
	//	Ergebnis gibst du dann als "float3" zurück.
	// Das hier füllt die Textur schlicht und einfach mit Rot.
	return float3(1.0f, 0.0f, 0.0f);
}

P.S.: Vergiss nicht, deine Render-Target-View als Render-Target und deine ganzen Texturen als Shader-Resource-Views zu binden. Depth-Buffering brauchst du beim Rendern in Texturen meist nicht, kannst du also NULLen.

[Grubenlord]

:-)
Also ich hab das mal ganz naiv, wie ich mir das mal dachte versucht umzusetzten

Code: Alles auswählen

//aus meinem CreateDevice
        D3D11_RASTERIZER_DESC RasterDesc;
        ZeroMemory( &RasterDesc, sizeof(D3D11_RASTERIZER_DESC) );
        RasterDesc.FillMode = D3D11_FILL_SOLID;
        RasterDesc.CullMode = D3D11_CULL_NONE;
        RasterDesc.DepthClipEnable = FALSE;
        V_RETURN( pd3dDevice->CreateRasterizerState( &RasterDesc, &g_pRasterizerStateSolid ) );
[...]
	pd3dDevice->CreateTexture2D(&white, &texSubsource[0], &texWhite);
	pd3dDevice->CreateTexture2D(&white, &texSubsource[0], &texRTV);

	D3D11_SHADER_RESOURCE_VIEW_DESC l_SRVDesc = { white.Format, D3D11_SRV_DIMENSION_TEXTURE2D, 0, white.MipLevels, };

	pd3dDevice->CreateShaderResourceView(texWhite, &l_SRVDesc, &m_pTextureView);
	pd3dDevice->CreateShaderResourceView(texRTV, &l_SRVDesc, &m_pTextureView);

	D3D11_TEX2D_RTV mipmaplvlRTV;
	mipmaplvlRTV.MipSlice = 0;

	D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
	rtvDesc.Format = DXGI_FORMAT_R32G32B32_FLOAT;
	rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
	rtvDesc.Texture2D = mipmaplvlRTV;
	
	pd3dDevice->CreateRenderTargetView( texRTV, &rtvDesc, &ppRTV);

//in meinem Framerenderer
	pd3dImmediateContext->OMSetRenderTargets(1, &ppRTV, NULL);
	pd3dImmediateContext->IASetInputLayout( NULL );
	pd3dImmediateContext->VSSetShader(g_pVertexShaderFF, NULL, 0);
	pd3dImmediateContext->PSSetShader(g_pPixelShaderFF, NULL, 0);
	pd3dImmediateContext->PSSetShaderResources(0, 1, &m_pTextureView);
	pd3dImmediateContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP );
	
	pd3dImmediateContext->Draw(4 , 0);

	//pd3dImmediateContext->CopyResource(texWhite, texRTV);
[...]

Mein Fenster ist nun leer, weil ich scheinbar etwas vergessen habe, aber was?

[Krishty]

Render mal statt in die Textur ins Fenster und schau, ob was ankommt. Und halt Ausschau nach Fehlermeldungen. Denk auch daran, dass die Texturen beim Erstellen bestimmte BindFlags brauchen, je nachdem, ob sie als RTV und/oder SRV gebunden werden.

[Grubenlord]

Also ich habe die BindFlags nochmals überarbeitet und die Shader tun auch das was die sollen (Bildschirm rot malen), Fehlermeldungen habe ich auch keine, nur ein leeres Fenster :/

Hier vielleicht nochmals etwas geordneter:

Code: Alles auswählen

	D3D11_TEXTURE2D_DESC texRTVDesc;
	texRTVDesc.Height = 8;
	texRTVDesc.Width = 8;
	texRTVDesc.MipLevels = 3;
	texRTVDesc.ArraySize = 1;
	texRTVDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT; //DXGI_FORMAT_R8_UNORM;
	texRTVDesc.SampleDesc = sd;
	texRTVDesc.Usage = D3D11_USAGE_DEFAULT ;
	texRTVDesc.BindFlags = D3D11_BIND_RENDER_TARGET;
	texRTVDesc.CPUAccessFlags = 0;
	texRTVDesc.MiscFlags = 0;

	D3D11_TEX2D_RTV mipmaplvlRTV;
	mipmaplvlRTV.MipSlice = 0;

	D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
	rtvDesc.Format = DXGI_FORMAT_R32G32B32_FLOAT;
	rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
	rtvDesc.Texture2D = mipmaplvlRTV;

	pd3dDevice->CreateTexture2D(&texRTVDesc, &texSubsource[0], &texRTV);
	pd3dDevice->CreateRenderTargetView( texRTV, &rtvDesc, &ppRTV);

//im FrameRenderer
	pd3dImmediateContext->OMSetRenderTargets(1, &ppRTV, NULL);
	pd3dImmediateContext->IASetInputLayout( NULL );
	pd3dImmediateContext->VSSetShader(g_pVertexShaderFF, NULL, 0);
	pd3dImmediateContext->PSSetShader(g_pPixelShaderFF, NULL, 0);
	pd3dImmediateContext->PSSetShaderResources(0, 1, &m_pTextureView);
	pd3dImmediateContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP );
	
	//pd3dImmediateContext->IASetVertexBuffers( 0, 1, &g_pVertexBufferFF, 0, 0 );
	pd3dImmediateContext->Draw(4 , 0);

[...] 
        // Set render resources
        pd3dImmediateContext->IASetInputLayout( g_pLayout11 );
        pd3dImmediateContext->VSSetShader( g_pVertexShader11, NULL, 0 );
        pd3dImmediateContext->PSSetShader( g_pPixelShader11, NULL, 0 );
	pd3dImmediateContext->PSSetSamplers( 0, 1, &g_pSamLinear );
	pd3dImmediateContext->PSSetShaderResources(0, 1, &m_pTextureView);

[Krishty]

(Du bindest garnicht den Rasterizer State)

Was meinst du mit einem leeren Fenster? Dass die Geometrie, auf die du vorher die Textur aufgetragen hast, nun garnicht mehr erscheint oder was?

[Grubenlord]

pd3dImmediateContext->RSSetState( g_pRasterizerStateSolid ); ist da, hatte ich nur vergessen zu posten :oops: .
Ja, genau, vorher scheußlich texturierte Geometie, jetzt nur noch Hintergrund.

[Krishty]

Bau zwischen das Rendern in die Textur und das Rendern der Geometrie mal ein pd3dImmediateContext->ClearState();. Falls das Problem durch einen State verursacht wird, der beim Rendern der Textur gesetzt wird, sollte die Geometrie wieder sichtbar werden.

[Grubenlord]

Leider ohne Erfolg;

[Krishty]

Wie sehen die beiden Depth-Stencil-States aus? Ändere die Z-Koordinate des Quads im Vertex-Shader mal von 0.0f auf 1.0f.

[Grubenlord]

Brachte leider auch keine Veränderung. Ansonsten ist für das Render-Target der Depth-Stencil NULL.

[Krishty]

Hmm, das ist echt fies. Ich würde nun anfangen, das Texture-Rendering auszukommentieren und stückweise wieder einzubauen, bis ich die Stelle habe, ab der nichts mehr gerendert wird.

Aber es gibt für solche Fälle PIX … soll bequemer sein … das benutze ich nur selber nicht – wie man damit solche Fehler aufspürt müsste jemand anders erklären.

[Grubenlord]

Hm, ja schwierig das Ganze. Also ich habe jetzt wieder meine Ursprungsgeometrie, was mir aber glaube ich noch fehlt, wäre das Ergebnis des Rentertaget-Pixelshaders zu meiner Recource der Ausgabe zu kopieren :?

[Krishty]

Hm, ja schwierig das Ganze. Also ich habe jetzt wieder meine Ursprungsgeometrie

Tut gut, das zu hören.

was mir aber glaube ich noch fehlt, wäre das Ergebnis des Rentertaget-Pixelshaders zu meiner Recource der Ausgabe zu kopieren :?

::ID3D11DeviceContext::CopyResource()

[Grubenlord]

hm, ich setze meine Textur texRTV als Render Target und kopiere dann. Ergo sollte ja nun meine alte Textur rot sein, tut sie aber nicht :( deswegen die doofe Frage :-)

Code: Alles auswählen

	pd3dDevice->CreateTexture2D(&texRTVDesc, &texSubsource[0], &texRTV);
	pd3dDevice->CreateRenderTargetView( texRTV, &rtvDesc, &ppRTV);

	pd3dImmediateContext->OMSetRenderTargets(1, &ppRTV, NULL);
		pd3dImmediateContext->IASetInputLayout( NULL );
	pd3dImmediateContext->VSSetShader(g_pVertexShaderFF, NULL, 0);
	pd3dImmediateContext->PSSetShader(g_pPixelShaderFF, NULL, 0);
	pd3dImmediateContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP );
	pd3dImmediateContext->Draw(4 , 0);

	pd3dImmediateContext->CopyResource(texWhite, texRTV);

[Krishty]

Hat deine Textur Mip-Maps?

[Grubenlord]

Ja, meine RTTextur ist ein ziehmliches Ebenbild der originalen, benutzt sogar die selbe SubResource

[Krishty]

Ist auch richtig so. Mich beschleicht da ein Verdacht: Du hast ins nullte Mip-Level gerendert … es kann gut sein, dass nur niedrigere Level gerendert werden. Ruf mal GenerateMips() auf die neue Textur auf, bevor du sie in die Alte kopierst.

Noch was: Setzt du auch brav die Ausmaße der Textur, bevor du hineinrenderst?

[Grubenlord]

Wenn der folgende Code so stimmt, ja.

Code: Alles auswählen

D3D11_VIEWPORT viewport;
viewport.Width = 640;
viewport.Height = 480;
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;

Aber das mit den GenerateMips() verwirrt mich etwas, ich habe ja von der Textur die mein RenderTarget ist eig kein ShaderResourceView. Ich hab mal eine definiert und übergeben aber ändert auch nichts.

[Krishty]

Es nimmt ja auch kein SRV, sondern ein Render-Target-View ;) Das, was du auch OMSetRenderTargets übergeben hast.

Falls du nach dem Codeschnippsel noch MinDepth auf 0.0f setzt und MaxDepth auf 1.0f und RSSetViewports(1, &viewport) aufrufst, passt es ;)

[Grubenlord]

Also kann der Viewport aus ausgeschlossen werden.

Es nimmt ja auch kein SRV, sondern ein Render-Target-View ;) Das, was du auch OMSetRenderTargets übergeben hast.

:?:
void GenerateMips(
ID3D11ShaderResourceView *pShaderResourceView
);
http://msdn.microsoft.com/en-us/library/ee419632.aspx