DirectX9 - Alphachannel einer Textur überschreiben

[XoRiC]

Hallo,

ich hab schon versucht unter dem Stichwort Multitexturing (und ähnlichen) fündig zu werden, bin auch sicher dass es eine Menge Tutorials im Internet zu diesem Thema geben muss, aber ich weiß nicht wonach ich genau suchen sollte.

Ich habe 2 Texturen:
- Textur1 (links oben im Bild, aus JPG geladen)
- Textur2 (rechts oben im Bild, aus PNG geladen)
Der karierte Bereich in Textur2 ist transparent.

http://img26.imageshack.us/img26/4479/texz.jpg

Nun möchte ich die beiden Texturen kombinieren, sodass die Textur in der Mitte unten entsteht. Es sollen also die RGB Werte aus Textur1 und die Alpha Werte aus Textur2 genommen werden. Die Texturen haben die selbe Größe.

Kann mir jemand ein paar Stichworte oder Links geben, wo ich etwas hierzu finde?
Vielen Dank
Xoric

[Medium]

Wenn du mit einem eignen Pixelshader arbeitest, kannst du es da super einfach machen. Einfach beide Texturen in den Shader werfen, rgb der einen und a der anderen samplen.

Mit der Fixed-Function Pipeline wirst du vermutlich was ekeligeres machen müssen: Die RGB-Textur so erstellen, dass sie von vorne herein das Format A8R8G8B8 hat (ich weiss nicht wie das in nativem DX9 aussieht, ich nutze bisher nur SlimDX unter C#), beide Texturen locken und in einer schmucken Schleife die Alphawerte an die richtigen Stellen in den Stream der RGB-Textur schreiben.

Mein Favorit sind da eher Shader

[XoRiC]

Pixelshader ist also mein zukünftiger Suchbegriff
Vielen Dank, Medium!

[XoRiC]

Hab es mit der Hilfe von einem Freund hinbekommen!
Jetzt muss ich nicht mehr für jedes Tile meines Bodens eine eigene Textur mit Überblendeffekt(en) erstellen, sondern kann meine Masken für jede Textur benutzen

Vielen Dank nochmal,
Xoric

[Medium]

Schön zu hören, dass es dir weiter geholfen hat. Viel Erfolg weiterhin!

[fkerber]

Hi!

Es wäre schön, wenn du die Lösung zumindest kurz umreißen könntest (vllt. mit etwas Quellcode oder so ) - dann können andere auch davon profitieren.

Grüße, Frederic

[XoRiC]

Hi Frederic,

gute Idee. Hier ist zunächst mal der Pixelshader:

Code:

shared texture texture1; 
shared texture maskTexture; 

sampler2D textureSampler1 = sampler_state 
{ 
    Texture = <texture1>; 
    MinFilter = Linear; 
    MagFilter = Linear; 
    MipFilter = Linear; 
    AddressU = Mirror; 
    AddressV = Mirror; 
}; 
 
sampler2D maskSampler = sampler_state 
{ 
    Texture = <maskTexture>; 
    MinFilter = Linear; 
    MagFilter = Linear; 
    MipFilter = Linear; 
    AddressU = Mirror; 
   AddressV = Mirror; 
}; 

struct VertexShaderOutput 
{ 
   float2 texC : TEXCOORD0; 
}; 

float4 PixScene( VertexShaderOutput input ) : COLOR0 
{ 
    float4 color1 =  tex2D( textureSampler1, input.texC ); 
    float4 color2 =  tex2D( maskSampler, input.texC ); 
    color1.a = color2.a; 
    return color1;                     
} 

technique RenderScene 
{ 
    pass P0 
    { 
        VertexShader = NULL; 
        PixelShader  = compile ps_2_0 PixScene(); 
    } 
}

Die Datei wird wie folgt geladen:

Delphi-Quellcode:

  // Shader laden {Shader_Ground: ID3DXEffect}
  D3DXCreateEffectFromFileA(Device, PChar('Shader.fx'), 0, nil, 0, nil, Shader_Ground, nil);

Ihm werden 2 Texturen übergeben - die Boden-Textur (in meinem Bild oben die linke obere) und die Maske (die rechte obere). Der Shader kombiniert die beiden Texturen, er nimmt RGB von der Textur und den Alpha-Channel von der Maske. Das Ergebnis schreibt er auf das RenderTarget vom DirectX Device.

Der Aufruf des Shaders erfolgt in meinem Code so:

Delphi-Quellcode:

  {Texture, Mask, Output_Texture: IDirect3DTexture9}
  {Output_Surface: IDirect3DSurface9}
  
  Shader_Ground.SetTexture('texture1', Texture);
  Shader_Ground.SetTexture('maskTexture', Mask);

  // Textur für die Ausgabe erstellen
  D3DXCreateTexture(Device, GROUND_WIDTH, GROUND_HEIGHT, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, Output_Texture);
  Output_Texture.GetSurfaceLevel(0, Output_Surface);

  // RenderTarget auf die Ausgabe-Textur setzen
  Device.SetRenderTarget(0, Output_Surface);
  Device.Clear(0, nil, D3DCLEAR_TARGET, $0, 0, 0);

  // Shader wird aufgerufen
  {i: integer, l: LongWord}

  Shader_Ground._Begin(@l, 0);
  for i := 0 to l - 1 do begin
    Shader_Ground.Pass(i);
  end;

  // An dieser Stelle zeichne ich via Vertex die Ausgabe-Textur auf den Backbuffer
  // Funktioniert nicht mit Sprites

  Shader_Ground._End;

Gruß an alle,
Xoric

[Medium]

Ich bin mir grad unsicher ob mit dem Target PS2.0 swizzling schon geht, und ob es der Compiler nicht eh schon so weit einstampft (die Shader-Compiler sind echt beneidenswert was Optimierungen angeht!), aber evtl. ist folgendes noch einen Tacken performanter (auch wenn es hier vermutlich um einen Unterschied von 1000FPS zu 1100FPS gehen wird - wenn überhaupt):

Code:

float4 PixScene(VertexShaderOutput input) : COLOR0 
{ 
    return float4(tex2D(textureSampler1, input.texC).rgb, tex2D(maskSampler, input.texC).a);
}

Ich meine rgba ist die richtige Reihenfolge, vertu mich da aber auch gerne mal. Evtl. ist es auch argb, wobei's mich wundern tät

Und Achtung! Spätestens ab Shader-Model 3 (DirectX 9) kannst du keinen Pixelshader mehr ohne Vertexshader betreiben - zumindest sieht das der Standard vor, manche Karten schlucken's sogar. Ab DX10 (SM4) gibt's dann überhaupt keine Fixed-Function Pipeline mehr, und Vertex- und Pixelshader sind obligatorisch. Das Thema lohnt sich also im Großen und Ganzen wenn man in dem Bereich noch mehr vor hat.

[XoRiC]

Ein später Nachtrag - der von mir gepostete Pixelshader tut nicht was er soll.
Im Pixelshader muss die Methode PixScene wie in Mediums Vorschlag aussehen.

Danke
Gruß Xoric