Puis-je générer un nombre aléatoire dans un pixel shader?

Je suis en train d'écrire une simple shader qui ajoute aléatoire de l'éclat à les objets applicables. La façon dont je voudrais faire est d'ajouter un hasard nuance de blanc (R = G = B) à la valeur du pixel dans le pixel shader.

Il semble que noise() ne fonctionne pas de la manière que je souhaite, c'est:

float multiplier = noise(float3(Input.Position[0], Input.Position[1], time));

Il me donne "erreur X4532: ne peut pas mapper expression de pixel shader jeu d'instructions", en référence à l'appel à noise().

Car je ne sais pas de manière à conserver un nombre entre les appels pour le shader, je ne pense pas que je peux juste écrire un nombre aléatoire simple fonction de production basée sur une graine adoptée en avant le rendu.

Est-il un moyen de produire un nombre aléatoire à partir de l'intérieur d'un pixel shader? Si il existe un moyen, comment?

source d'informationauteur chaosTechnician | 2011-03-01

  1. 5

    Il n'y a rien qui dit que vous devez réutiliser les semences pour un générateur aléatoire d'une exécution, vous avez juste besoin de toutes les graines.

    Si vous utilisez, par exemple, le pixel de coordonnées, puis vous allez vous retrouver avec un résultat déterministe (c'est à dire pixel x, y aura toujours le même aléatoire flare), mais dans l'ensemble l'ensemble du visage, il va être distribués de façon aléatoire.

    Maintenant, si vous avez comme entrée quelque chose qui change en fonction de l'environnement (je ne sais pas vraiment quelque chose à propos de pixel shaders), comme l'ensemble de placement du pixel dans l'espace mondial de la scène appareil que par rapport au polygone lui-même, puis, en particulier dans un environnement en évolution constante, vos résultats seront effectivement aléatoire.

    Si tout dans l'environnement mondial se trouve être exactement la même, alors, oui, vous avez exactement la même "aléatoire" de distribution. Mais aucun de ces facteurs de changement (notamment sur la base de la saisie de l'utilisateur, il est probable que vous les plus dynamiques "source de bruit"), puis dans l'ensemble, l'effet sera, probablement, "aléatoire".

    Donc, la clé à retenir est que votre graine ne doit pas être le résultat d'une exécution précédente de l'générateur de nombre aléatoire. Il peut être n'importe quoi. Ainsi, les calculs d'une graine pour chaque pixel en fonction des entrées pour le shader de votre propre RNG peut vous donner de l'effet dont vous avez besoin.

  2. 24

    Mise à JOUR en juillet 2017: j'ai fait de la "pseudo-aléatoire" plus stable

    //Version 3
float random( vec2 p )
{
    vec2 K1 = vec2(
        23.14069263277926, //e^pi (Gelfond's constant)
         2.665144142690225 //2^sqrt(2) (Gelfond–Schneider constant)
    );
    return fract( cos( dot(p,K1) ) * 12345.6789 );
}

    Ce sont les versions:

    float random( vec2 p )
{
   //e^pi (Gelfond's constant)
   //2^sqrt(2) (Gelfond–Schneider constant)
     vec2 K1 = vec2( 23.14069263277926, 2.665144142690225 );

   //return fract( cos( mod( 12345678., 256. * dot(p,K1) ) ) ); //ver1
   //return fract(cos(dot(p,K1)) * 123456.); //ver2
     return fract(cos(dot(p,K1)) * 12345.6789); //ver3
}

//Minified version 3:
float random(vec2 p){return fract(cos(dot(p,vec2(23.14069263277926,2.665144142690225)))*12345.6789);}

    Passant dans une texture de générer du bruit est (en général) cours de génie génétique. Il y a des moments où c'est très pratique mais pour la majorité des cas, il est plus simple et plus rapide de simplement calculer un nombre aléatoire.

    Depuis shader variables sont indépendantes par fragment, ils sont incapables de ré-utiliser les variables entre elles. Le problème devient alors de savoir comment utiliser une "bonne" série de nombres aléatoires. Les nombres irrationnels semble faire l'affaire pour commencer. Ensuite c'est juste une "simple" question de choix d'un bon "permuter" de la fonction.

    Voici le code qui fait le truc:

    //Input: It uses texture coords as the random number seed.
//Output: Random number: [0,1), that is between 0.0 and 0.999999... inclusive.
//Author: Michael Pohoreski
//Copyright: Copyleft 2012 :-)
//NOTE: This has been upgraded to version 3 !!
float random( vec2 p )
{
  //We need irrationals for pseudo randomness.
  //Most (all?) known transcendental numbers will (generally) work.
  const vec2 r = vec2(
    23.1406926327792690,  //e^pi (Gelfond's constant)
     2.6651441426902251); //2^sqrt(2) (Gelfond–Schneider constant)
  return fract( cos( mod( 123456789., 1e-7 + 256. * dot(p,r) ) ) );  
}

    Pour comprendre comment cela fonctionne, si nous brisons la formule vers le bas en ses parties constituantes, il devient plus facile de visualiser ce qui se passe:

    const vec2 k = vec2(23.1406926327792690,2.6651441426902251);
float rnd0( vec2 uv ) {return dot(uv,k); }
float rnd1( vec2 uv ) { return 1e-7 + 256. + dot(uv,k); }
float rnd2( vec2 uv ) { return mod( 123456789., 256. * dot(uv,k) ); }
float rnd3( vec2 uv ) { return cos( mod( 123456789., 256. * dot(uv,k) ) ); }

//We can even tweak the formula
float rnd4( vec2 uv ) { return fract( cos( mod( 1234., 1024. * dot(uv,k) ) ) ); }
float rnd5( vec2 uv ) { return fract( cos( mod( 12345., 1024. * dot(uv,k) ) ) ); }
float rnd6( vec2 uv ) { return fract( cos( mod( 123456., 1024. * dot(uv,k) ) ) ); }
float rnd7( vec2 uv ) { return fract( cos( mod( 1234567., 1024. * dot(uv,k) ) ) ); }
float rnd8( vec2 uv ) { return fract( cos( mod( 12345678., 1024. * dot(uv,k) ) ) ); }
float rnd9( vec2 uv ) { return fract( cos( mod( 123456780., 1024. * dot(uv,k) ) ) ); }

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    mediump vec2 uv = fragCoord.xy /iResolution.xy;
    float i = rnd9(uv);
    fragColor = vec4(i,i,i,1.);
}

    Coller ci-dessus en:

    J'ai aussi créé une "comparaison" ShaderToy exemple avec 2 fonctions de bruit, et de 2 fonctions aléatoires:

    De démonstration de l'utilisation du bruit "[2TC 15] Speckle Cross Fade"

    "Classique", fonction aléatoire, parfois appelé snoise3 est-ce mauvais:

    return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453);

    Si vous voulez comparer des "pseudo-aléatoire" fonctions découvrez Dave Hash sans condition sine shader.

  3. 8

    Ce que vous faites généralement lorsque vous voulez prendre une valeur aléatoire dans un pixel shader est de passer dans une texture contenant le bruit. Alors que ce n'est pas vraiment "aléatoire" - il semble aléatoire.

    Par exemple, voici un code à partir d'un pixel shader j'ai traîner:

    float3 random = (tex2D(noiseTexture, texCoord * noiseScale + noiseOffset));

    La texture que j'utilise un RGB-la texture de bruit, ce qui peut être utile à certains moments. Mais la même technique pourrait fonctionner pour les niveaux de gris.

    Par le passage à l'échelle-je m'assurer que les pixels de la texture de bruit de ligne jusqu'à sur les pixels de l'écran (vous pouvez également définir la texture de l'échantillonneur de "point" mode afin de ne pas brouiller la texture de bruit).

    Par l'aide d'un décalage, vous pouvez faire défiler la texture qui est un peu comme l'ensemencement d'un générateur de nombre aléatoire. L'utilisation d'un décalage aléatoire si vous voulez éviter que les "scrolling" regardez.