Discussion :

[ijk-ref]

Bonjour

Ce code me suffit dans bien des cas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
float4 ScenePS ( VS_OUTPUT Input ) : COLOR0
{
      return tex2D(Texture0Sampler, Input.TexCoord);
}

Et avec les bonnes options on a du trilinear filtering pour avoir la texture toute belle quelque soit son éloignement... bon j'espère que je nous apprends rien... autrement ça ne sert à rien de continuer

Moi il y a un truc que je ne comprends pas Les shaders sont normalement fait pour nous permettre de tout paramétrer. Et bien je ne vois pas quels sont les paramètres qui permet au shader de choisir le bon niveau de filtre de texture !!! Et vous ?

Par exemple est-il possible de simuler du trilinear filtering en utilisant seulement la fonction tex2D avec les options de filtres sur "au plus proche" ?

Ceci ne sert évidement à rien... juste à comprend comment ça marche.

En fait, j'aimerai rendre flou une texture à l'affichage. Et si je pouvais simplement dire d'utiliser un niveau de détail de texture en dessous cela m'arrangerait bien. Y a-t-il moyen de sélectionner un niveau de détail particulier d'une texture dans un shader ?

Note : mon histoire n'a rien avoir avec les techniques de blur habituelles qui consiste à calculer un sous niveau du rendu.

[ijk-ref]

... déjà

Je pense que la fonction tex2Dbias() va mettre utilise pour ce que je veux faire.

Autrement je sais bien qu'un langage de haut niveau sert justement à cacher et simplifier les choses pour l'utilisateur... mais là... la fonction tex2D() fait plus qu'elle ne devrait . Car avec seulement x,y en entrée... il est impossible d'en deduire le bon niveau de détail. Moi je vous dis...on nous ment et il y a à complot gouvernementale dernière tout ça

Faudrait voir le code assembleur...

[ac_wingless]

tex2D est une instruction "historique", de très bas niveau, marquée "deprecated" sous DX10. Il ne faut pas l'utiliser, mais au contraire utiliser les fonctions membres des objets Texture2D. Cette fonction accepte un paramètre de type SamplerState, qui permet de tout configurer. Cf. par exemple BasicHLSL10 dans le SDK pour un exemple ultra-simple.
Juste pour rire, voici ce qu'on peut paramétrer (doc de l'équivalent C++ du HLSL) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
typedef struct D3D10_SAMPLER_DESC {
    D3D10_FILTER Filter;
    D3D10_TEXTURE_ADDRESS_MODE AddressU;
    D3D10_TEXTURE_ADDRESS_MODE AddressV;
    D3D10_TEXTURE_ADDRESS_MODE AddressW;
    FLOAT MipLODBias;
    UINT MaxAnisotropy;
    D3D10_COMPARISON_FUNC ComparisonFunc;
    FLOAT BorderColor[4];
    FLOAT MinLOD;
    FLOAT MaxLOD;
} D3D10_SAMPLER_DESC;
typedef enum D3D10_FILTER
{
    D3D10_FILTER_MIN_MAG_MIP_POINT = 0,
    D3D10_FILTER_MIN_MAG_POINT_MIP_LINEAR = 0x1,
    D3D10_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x4,
    D3D10_FILTER_MIN_POINT_MAG_MIP_LINEAR = 0x5,
    D3D10_FILTER_MIN_LINEAR_MAG_MIP_POINT = 0x10,
    D3D10_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x11,
    D3D10_FILTER_MIN_MAG_LINEAR_MIP_POINT = 0x14,
    D3D10_FILTER_MIN_MAG_MIP_LINEAR = 0x15,
    D3D10_FILTER_ANISOTROPIC = 0x55,
    D3D10_FILTER_COMPARISON_MIN_MAG_MIP_POINT = 0x80,
    D3D10_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR = 0x81,
    D3D10_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x84,
    D3D10_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR = 0x85,
    D3D10_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT = 0x90,
    D3D10_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x91,
    D3D10_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT = 0x94,
    D3D10_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR = 0x95,
    D3D10_FILTER_COMPARISON_ANISOTROPIC = 0xd5,
    D3D10_FILTER_TEXT_1BIT = 0x80000000,
} D3D10_FILTER;
typedef enum D3D10_TEXTURE_ADDRESS_MODE
{
    D3D10_TEXTURE_ADDRESS_WRAP = 1,
    D3D10_TEXTURE_ADDRESS_MIRROR = 2,
    D3D10_TEXTURE_ADDRESS_CLAMP = 3,
    D3D10_TEXTURE_ADDRESS_BORDER = 4,
    D3D10_TEXTURE_ADDRESS_MIRROR_ONCE = 5,
} D3D10_TEXTURE_ADDRESS_MODE;
typedef enum D3D10_COMPARISON_FUNC
{
    D3D10_COMPARISON_NEVER = 1,
    D3D10_COMPARISON_LESS = 2,
    D3D10_COMPARISON_EQUAL = 3,
    D3D10_COMPARISON_LESS_EQUAL = 4,
    D3D10_COMPARISON_GREATER = 5,
    D3D10_COMPARISON_NOT_EQUAL = 6,
    D3D10_COMPARISON_GREATER_EQUAL = 7,
    D3D10_COMPARISON_ALWAYS = 8,
} D3D10_COMPARISON_FUNC;

Tout ça utilisable aussi simplement que:

return ( texture_de_zebre.Sample(echantillonneur_super_malin, point_pondu_par_le_VS.coord_UV) );

Pour aller plus loin, je ne vois pas exactement ce que vous voulez faire par "simuler" du trilinear filtering avec filtre au plus proche (xxx_POINT ?)... a priori c'est incompatible, mais je suppose que vous avez une idée. En tout cas, l'exposition de tous ces paramètres, facilement changeables dans un fichier texte ne nécessitant aucune recompilation, devrait vous permettre de faire un peu n'importe quoi.

[ijk-ref]

Merci pour ta réponse ac_wingless

Moi aussi je préfère la mise sous forme "programmation par objets" mais c'est pour fonctionner sur un portable n'acceptant que les pixelshaders 2.0. Je reste donc pour l'instant à directX 9. Dans le fond cela ne changer rien car la même instruction assembler est utilisée au final.

En fait je voulais utiliser un filtre un peu plus lisse que du bi-linaire soit un filtre bi-quadric qui donne un meilleur effet flou. J'ai réussi mais avec une bidouille qui me laisse dubitatif sur la fonctionnement de tex2D (texld en assembler)

Un exemple extrême simple pour comprendre :

Imaginons que je veuille texturer un carré entièrement avec une texture carrée. Le code serait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
float4 ScenePS (VS_OUTPUT Input) : COLOR0
{
    	return tex2D(samp0, Input.TexCoord0);
}

Ma texture est un simple dégradé vertical du noir au blanc.

Imaginons que je veuilles texturer mon carré avec seulement deux colonnes grise d'intensité 0,25 et 0,75. Et bien je n'ai pas besoin de texture pour ça, il suffit d'écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
float4 ScenePS (VS_OUTPUT Input) : COLOR0
{
    	return (Input.TexCoord0.x<0.5)? {.25, .25, .25, 1} : {.75, .75, .75, 1};
}

Le même résultat avec la texture devrait être :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
float4 ScenePS (VS_OUTPUT Input) : COLOR0
{
    float2 coord = (Input.TexCoord0.x<0.5)? {.25, 0} : {.75, 0};
    return tex2D(samp0, coord);
}

Et bien ça marche... presque !!! Entre les deux colonnes une ligne parasite s'affiche... mais pas toujours !!! Ca dépend de la position du carré affiché sur l'écran

Et aussi étrange que cela paraisse ce code-ci fonctionne très bien sans bugs :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
float4 ScenePS (VS_OUTPUT Input) : COLOR0
{
    float2 coordA = {.25, 0};
    float2 coordB = {.75, 0};
    return (Input.TexCoord0.x<0.5)? tex2D(samp0, coordA) : tex2D(samp0, coordB);
}

Je ne vois vraiment pas pourquoi... si quelqu'un pouvait m'expliquer

[ac_wingless]

J'ai du mal à voir le problème. Quelle est la question?
Le code présenté est très clair quoi que peu utilisable en production (les textures fournies par les outils CAO n'ont pas d'espace d'adressage naturellement rectangulaire; en particulier Maya dispose d'un module optimisant l'espace de texture en fonction de la finesse des détails de l'artiste lorsqu'il utilise l'outil "advanced 3D paint"). Donc l'équivalence espace quad / espace texture supposée ci-dessus est une hypothèse trop forte.

[ijk-ref]

Et moi j'ai pas trop compris ta réponse

Je suis sous DirectX... je ne vois trop le rapport avec Maya

Et puis ici l'histoire du quad n'a pas trop de rapport avec le problème présenté. J'aurai aussi pu prendre un simple triangle.

Ma question est : Pourquoi les 2 derniers codes présentés ne donne pas le même résultat !?

Comme je l'ai déjà dit : pour l'avant dernier code une ligne parasite apparait de façon "pseudo-aléatoire-imprévue".

Ma question n'est pas réellement en rapport avec la 3D mais juste sur l'utilisation des pixel-shaders. Je cherche à les utiliser pour faire du post-traitement sur des petites images.

Pour moi en algorithmie :

si (x>0.5) alors renvoie g(a) autrement renvoie g(b)

est équivalant à

si (x>0.5) alors a => t autrement b => t
renvoie g(t)

Pourtant cela n'a pas l'air d'être le cas avec les shaders et la fonction sur les textures !?