Discussion :

[venomelektro]

Salut,


j aimerais utiliser le perlin noise dans un fragment shader pour animer des textures type eau/nuages etc..

j ai déjà plein d algos utilisant openGL (avec upload de texture) mais j ai un soucis pour utiliser ce type d effet en GLSL

pour l instant , la stratégie choisie et l utilisation des fonctions noise* du GLSL

je bloque sur cet exemple simple, qui ne sort une couleur unie quelque soit le pixel et la valeur pour fTime (qui change a chaque frame)

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
 
 
uniform sampler2D Tex_Sampler;
 
varying vec2 texcoord;
 
void main(void)
{
 
    vec4 tex_color = texture2D(Tex_Sampler,texcoord.st);
 
 
 
      float nr = noise1(texcoord.s + fTime)+0.6;
      float ng = noise1(texcoord.t + fTime)+0.6;
 
 
 
      tex_color = vec4(nr,ng,1,1);
 
      tex_color = clamp(tex_color,vec4(0,0,0,0),vec4(1,1,1,1));
 
     gl_FragColor = tex_color;
}

quelqu'un a t il une idée sur ce qui peut causer ce problème ?

[LittleWhite]

Bonjour,

Un prof m'a sorti que les fonctions de noise (GLSL et HLSL) ne donnent jamais rien de convainquant (lorsque l'on arrive à les faire fonctionner, ce que je ne j'ai jamais vu).

Donc je vous conseille plus la texture de bruit généré par le CPU que la fonction du langage.
Maintenant, si vous arrivez à faire quelque chose avec, dites le nous (moi)

[venomelektro]

Bonjour,

merci pour la réponse.

dans mon cas, c est pas que le resultat n est pas satisfaisant , c est qu on a l impression que la fonction noise1 retourne tout le temps la meme valeur quelque soit l input (ce qui semble etrange quand meme)

sinon en suivant cet exemple , j ai reussi a avoir qq chose qui convient

http://lumina.sourceforge.net/Tutorials/Noise.html

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
 
uniform sampler2D Tex_Sampler;
varying vec2 texcoord;
uniform bool NoiseEffect;
 
vec4 rand(vec2 A,vec2 B,vec2 C,vec2 D){ 
 
        vec2 s=vec2(12.9898,78.233); 
 
        vec4 tmp=vec4(dot(A,s),dot(B,s),dot(C,s),dot(D,s)); 
 
        return fract(sin(tmp) * 43758.5453)* 2.0 - 1.0; 
 
        } 
 
 
 
float noise(vec2 coord,float d){ 
 
        vec2 C[4]; 
 
        float d1 = 1.0/d;
 
        C[0]=floor(coord*d)*d1; 
 
        C[1]=C[0]+vec2(d1,0.0); 
 
        C[2]=C[0]+vec2(d1,d1); 
 
        C[3]=C[0]+vec2(0.0,d1);
 
 
 
        vec2 p=fract(coord*d); 
 
        vec2 q=1.0-p; 
 
        vec4 w=vec4(q.x*q.y,p.x*q.y,p.x*p.y,q.x*p.y); 
 
        return dot(vec4(rand(C[0],C[1],C[2],C[3])),w); 
 
        } 
 
void main(void)
{
 
    vec4 tex_color = texture2D(Tex_Sampler,texcoord.st);
 
 
    if (tex_color.a>0 && NoiseEffect ){
 
      vec4 noisevec;
 
      float level=-log2(min(length(dFdx(texcoord.st)),length(dFdy(texcoord.st))));
 
      level = min(level,10.0); //limit the level to avoid slowness
 
      float n = 0.35;
 
      for(int i = 3; i< level;i++){ //3 is the lowest noise level
 
                n +=  0.80 * noise(texcoord.xy+fTime, exp2(i));
 
      }
 
 
      noisevec = vec4(n*0.5,0.7,0.1,1);
 
      tex_color = noisevec;
 
    }
 
    gl_FragColor = tex_color;
}

dans cet exemple j ai une texture acceptable pour ce que je cherche a faire (texture noisy aminée dans les tons verts)

[wax78]

c est qu on a l impression que la fonction noise1 retourne tout le temps la meme valeur quelque soit l input (ce qui semble etrange quand meme)

Comme le dit LittleWhite, je rajouterai, la fonction Noise NE MARCHE PAS sur les carte graphique "normales". Dans mes souvenirs, y'a une carte genre Wildcat Realizm qui avait la fonction noise implementée et c'etait une des seules.

Maintenant la derniere fois que j'ai essayé c'etait sur une Geforce 8800 donc peut etre que mtn ...

[venomelektro]

bizarre je suis en train de lire le bouquin openGL Shading language third edition et il n est mentionné nulle part que l implémentation est foireuse.

dommage car si c est le cas, c est une information importante a savoir.

[wax78]

Bizzare meme nvidia dans son guide sur les shader dit que ca fonctionne pas ... Je pense surtout que les guide generaux d'opengl font fi de savoir si oui ou non c'est implementé, car c'est censé être le cas, meme si ce n'est pas la réalité.

6.1.1. Noise Functions Always Return Zero
The GLSL standard library contains several noise functions of differing dimensions:
noise1, noise2, noise3, and noise4.
NVIDIA’s implementation of these functions (currently) always returns zero results.

cf : http://http.download.nvidia.com/deve....0_Support.pdf

ou encore


Lien 2
Liens 1

Mais cela n'est peut etre plus d'actualités mais j'en doute....

[LittleWhite]

bizarre je suis en train de lire le bouquin openGL Shading language third edition et il n est mentionné nulle part que l implémentation est foireuse.

dommage car si c est le cas, c est une information importante a savoir.

Sauf que, une implementation c'est:
- Une specification (Khronos)
- Une carte d'un constructeur (NVidia / ATI / Imagination Technologies / ...)
- Un driver

OpenGL, contrairement a DirectX (et malheureusement) subi seulement quelques tests (disons moindre) afin de savoir si une implementation est conforme.

Les Orange Book sont principalement base sur la specification. Sachant que la fonction noise peut fonctionner d'une carte a une autre et meme d'une version d'un pilote a un autre ... c'est quelque chose d'assez relatif.


Finalement, je voulais dire (malgre que je ne connais pas vraiment la fonction noise (faut que j'aille lire la spec )), mais faire un generateur aleatoire (ou pseudo aleatoire) et ultra couteux ... donc j'ai du mal a voir l'avantage d'une telle fonction ...

[venomelektro]

en fait l intérêt pour moi était d arriver à avoir une texture en mouvement (eau, nuage...) sans avoir a ré-uploader la texture à chaque update

si c est pas dispo , on fait sans, mais il faut pas s étonner que OpenGL soit peu choisi pour les jeux pour PC quand on vois ce genre de problèmes.

Développer un jeu qui utilise les possibilités du GLSL est un vrai casse tête et c est vraiment dommage.

[wax78]

C'est vrai que c'est assez lourd.

Si c'est pour faire de l'eau ou des nuages, tu px charger une ou des texture que tu fais "a la main" contenant du "beau bruit/nuages"

Ensuite dans le shader tu mix une ou des textures dont tu déplace l'offset indépendamment (ou non selon l'effet voulu).

[LittleWhite]

en fait l intérêt pour moi était d arriver à avoir une texture en mouvement (eau, nuage...) sans avoir a ré-uploader la texture à chaque update

si c est pas dispo , on fait sans, mais il faut pas s étonner que OpenGL soit peu choisi pour les jeux pour PC quand on vois ce genre de problèmes.

Développer un jeu qui utilise les possibilités du GLSL est un vrai casse tête et c est vraiment dommage.

Il est a note, que sous DirectX le probleme est le meme. Les fonctions de noise (que m'a dit mon prof) ne donne rien de concluant

[venomelektro]

C'est vrai que c'est assez lourd.

Si c'est pour faire de l'eau ou des nuages, tu px charger une ou des texture que tu fais "a la main" contenant du "beau bruit/nuages"

Ensuite dans le shader tu mix une ou des textures dont tu déplace l'offset indépendamment (ou non selon l'effet voulu).

oui , c est ce que je fais depuis des années.mais j essaye d evoluer et je ne plus penser en openGL1.1, cependant quand tu vois les problemes que tu rencontres, tu te rappelle pourquoi tu fais du 1.1

[dridri85]

Les fonctions noisen n'ont jamais été implémentée dans le driver GLSL, et ne le seront probablement jamais. Seules quelques cartes professionnelles bien gonflées à bloc supportent ces fonctions.
A ce que je sais les cartes grands public nVidia Comme Ati retournent 0.0f.

[wax78]

Il y'a un echo on dirait ....

(Je blague hein

[venomelektro]

si j ai bien compris, les fonctions ne sont pas implémentés dans le driver GLSL et ne le seront probablement jamais

...

non je déconne

[wax78]

bien joué

[Some0ne]

Certes ces fonctions n'existerons pas... Néanmoins certains Démomaker en ont créées... Je pense particulièrement à iq :

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
 
int icoolfFunc3d2( in int n )
{
    n=(n<<13)^n;
    return (n*(n*n*15731+789221)+1376312589) & 0x7fffffff;
}
 
float coolfFunc3d2( in int n )
{
    return float(icoolfFunc3d2(n));
}
 
float noise3f( in vec3 p )
{
    ivec3 ip = ivec3(floor(p));
    vec3 u = fract(p);
    u = u*u*(3.0-2.0*u);
 
    int n = ip.x + ip.y*57 + ip.z*113;
 
    float res = mix(mix(mix(coolfFunc3d2(n+(0+57*0+113*0)),
                            coolfFunc3d2(n+(1+57*0+113*0)),u.x),
                        mix(coolfFunc3d2(n+(0+57*1+113*0)),
                            coolfFunc3d2(n+(1+57*1+113*0)),u.x),u.y),
                    mix(mix(coolfFunc3d2(n+(0+57*0+113*1)),
                            coolfFunc3d2(n+(1+57*0+113*1)),u.x),
                        mix(coolfFunc3d2(n+(0+57*1+113*1)),
                            coolfFunc3d2(n+(1+57*1+113*1)),u.x),u.y),u.z);
 
    return 1.0 - res*(1.0/1073741824.0);
}
 
float noise2f(vec2 p)
{
  return noise3f(vec3(p,0));
}

P.S : un petit cours intéressant sur le bruit http://web.engr.oregonstate.edu/~mjb.../noise.1pp.pdf

[venomelektro]

merci , je vais tester ce code.

[Ti-R]

Pour le bruit de perlin -> http://freespace.virgin.net/hugo.eli...s/m_perlin.htm
C'est un bon lien je m'étais basé dessus il y a quelques années.

Quand j'ai vu le code posté par Some0ne je me suis dis que cela me rappelait quelque chose dans le lien donné.

Et tiens, la même formule de base pour un nombre random...

Code :

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

1
2
3
4
5
int x( int n )
{
    n=(n<<13)^n;
    return (n*(n*n*15731+789221)+1376312589) & 0x7fffffff;
}