Pixel Shader

Nel precedente tutorial abbiamo caricato una texture da file. Ora la useremo nello shader.

A differenza di DirectX9, una texture può essere utilizzata senza problemi in tutti i tipi di shader.

Una texture viene dichiarata nel codice HLSL usando le parole chiavi texture1D, texture2D e texture3D

Texture1D myTexture1;

Texture2D myTexture2;

Texture3D myTexture3;

Nel codice C++ vi basterà passare la risorsa alla corretta variabile

ID3D10EffectShaderResourceVariable* texVal = texVal = effect-> GetVariableByName("myTexture2")-> AsShaderResource();

texVal->SetResource(texture);

In DirectX10 è possibile utilizzare la texture sia direttamente, cosa non possibile prima, che tramite i sample. La sintassi è molto cambiata quindi conviene leggere di seguito.

Un sample è una descrizione di come la texture viene letta. Per esempio immaginate un cubo con una texture sopra.

L’utilizzo più classico è farsi mandare le coordinate dal vertex shader e, per ogni pixel, eseguire nel pixel shader la lettura della texture, prendere il colore e restituirlo mandandolo a video. Le coordinate, come spiegato nel precedente tutorial, variano in genere da 0 ad 1. Ma la texture sul modello viene ruotata, piegata, ridimensionata, tutte cose che impediscono di leggere il valore esatto del pixel. Di conseguenza DirectX10 effettua un filtro sulla texture in modo da restituire un colore che sia una correzione del vero colore che andiamo a prendere. Se ad esempio una texture viene rimpicciolita potremmo volere che DirectX ci restituisca come colore la media dei pixel che stiamo andando a leggere. Un sample descrive i filtri, ossia come adatta i colori in base al ridimensionamento della texture, gli address (cosa accade se si superano i limiti 0 ed 1 nelle coordinate) e molte altre cose. Ecco un esempio

SamplerState mySampler

{

Filter = MIN_MAG_MIP_LINEAR;

AddressU = Wrap;

AddressV = Wrap;

};

I campi sono i seguenti:

Filter : filtro per il ridimensionamento
AddressU : descrive il comportamento quando si superano i limiti 0 ed 1 sulla coordinata u (orizzontale)
AddressV : descrive il comportamento quando si superano i limiti 0 ed 1 sulla coordinata (verticale)
AddressW : descrive il comportamento quando si superano i limiti 0 ed 1 sulla coordinata (per le texture 3D, indica la profondità)
MipLODBias : directX decide da sola il livello di mip ma possiamo aumentare o diminuire il suo valore tramite bias (che è un float)
MaxAnisotropy : indica il livello massimo di anisotropicità della texture (intero da 1 a 16), viene usato se si usa anisotropic come filtro
ComparisonFunc : indica il comportamento in caso di sovrapposizioni di sample, sarà spiegato nei prossimi tutorial
BorderColor : se come address viene usata BORDER, indica il colore dei bordi
MinLOD : indica il livelli minimo di mip da usare
MaxLOD : indica il livelli massimo da usare

Per il filtro si usano questi valori

MIN_MAG_MIP_POINT
MIN_MAG_POINT_MIP_LINEAR
MIN_POINT_MAG_LINEAR_MIP_POINT
MIN_POINT_MAG_MIP_LINEAR
MIN_LINEAR_MAG_MIP_POINT
MIN_LINEAR_MAG_POINT_MIP_LINEAR
MIN_MAG_LINEAR_MIP_POINT
MIN_MAG_MIP_LINEAR
ANISOTROPIC
COMPARISON_MIN_MAG_MIP_POINT
COMPARISON_MIN_MAG_POINT_MIP_LINEAR
COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT
COMPARISON_MIN_POINT_MAG_MIP_LINEAR
COMPARISON_MIN_LINEAR_MAG_MIP_POINT
COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR
COMPARISON_MIN_MAG_LINEAR_MIP_POINT
COMPARISON_MIN_MAG_MIP_LINEAR
COMPARISON_ANISOTROPIC

Per gli address i valori sono questi

WRAP : se si superano i limiti 0 e 1 allora la texture si ripete
MIRROR : se si superano i limiti 0 e 1 allora la texture si ripete ma ribaltandosi
CLAMP : valori oltre i limiti 0 ed 1 sono letti come 0 e come 1
BORDER = se si superano i limiti viene restituito il colore di cordo
ONCE = effettua una volta il mirror e poi limita come il clamp

Per leggere le texture si utilizzano i nuovi metodi di DirectX10

Sample

E’ il metodo principale per leggere il colore di un pixel.

float4 color = myTexture.Sample(mySampler, position);

a seconda del tipo di myTexture varia il tipo di position

nel caso di texture1D è un float, nel caso di texture2D è un float2 e nel caso di texture3D è un float3. Alla funzione viene passato il sampler che descrive il filtro e l’algoritmo che si utilizza per il calcolo del colore del pixel.

SampleCmp

float4 color = myTexture.SampleCmp(mySampler, position);

il valore di tipo float comparison è usato per effettuare confronti nel caso nel sampler si usi il ComparisonFunc.

SampleCmpZeroLevel

float4 color = myTexture.SampleCmpLevelZero(mySampler, position);

Come SampleCmp ma usa solo il livello 0 della mipmap per fare il confronto

SampleGradient

float4 color = myTexture.SampleGradient(mySampler, position, ddx , ddy);

Questa istruzione utilizza 2 variabili della stessa dimensione delle coordinate texture per eseguire una operazione di sample con gradiente.

SampleLevel

float4 color = myTexture.SampleLevel(mySampler, position);

Come il sample ma permette di scegliere il livello di mipmap. In questo caso la variabile position ha un campo in più (ad esempio per la texture2D è un float3 perché in z permette di scegliere il livello.

Le successive 2 istruzioni sono una novità di DirectX10 in quanto permettono di ottenere il valore assoluto del pixel, senza che sia effettuato alcun sample. La prima da conoscere è

GetDimensions

void myTexture.GetDimensions (width, lod);

Questo metodo restituisce la larghezza della texture ed il lod nelle due variabili di tipo uint. Al momento la funzione presenta dei bug in parte risolti nella SDK di Aprile ed è diversa dalla funzione GetDimension che non esiste. Probabilmente un bug da risolvere.

Load

float4 color = MyTextyre.Load(position);

Il metodo load equivale al metodo Sample ma le coordinate vengono passate in pixel anziché in coordinate texture. La variabile location ha la stessa dimensione che avrebbe nel metodo Sample ma stavolta è di tipo int. Alla texture non viene applicato nessun filtro e restituisce zero se si leggono coordinate esterne alla texture.

Il codice pixel shader prende come input l’output del vertex o del geometry shader per restituire un float4 con sintassi SV_Target che indica che il valore sarà inviato al target.

Al suo interno è possibile utilizzare tutto ciò che è stato definito per il vertex shader. Il segreto sarà appunto quello di far arrivare al pixel shader tutti i dati necessari per eseguire i propri calcoli.

Eccone un esempio

float4 PS( PS_INPUT input) : SV_Target

{

return diffuseMap.Sample( textureSampler, input.tex);

}

In questo shader una texture2D chiamata diffuseMap esegue un sample usando le proprietà definite nel sampler chiamato textureSampler ed utilizzando la variabile di tipo PS_INPUT che arriva dal vertex shader.

Vi lascio all’esempio che visualizza un cubo su una texture e permette di modificare le coordinate texture a runtime. Cercate di esercitarvi il più possibile con la sintassi shader.

Demo