Ce matin en prenant mon café et en regardant les réponses sur le topic Datamoshing, je me suis dit que ça pourrait être pas mal de se faire une collection de shaders tout prêts à utiliser....
Je reconnais que c'est fastidieux de les adapter un à un, ça prend du temps, c'est chiant, c'est pas beau, y'a beaucoup de fils, mais quand même c'est un sacré outil pour les utilisateurs de GEM...
Donc je remet ici le shader du datamoshing histoire de centraliser tout ça, plus quelques indications pour adapter les shaders glanés ici et là.... ( je précise que ces indications sont un mélange de recherches et d'empirisme donc n'hésitez pas à me reprendre si je me plante ou à me poser des questions si je ne suis pas clair...)
Deux axes de travail ( si vous le voulez bien ) :
   
L'adaptations de shaders glanés ici et là;
Une petite ergonomie pour les rendre un peu plus attrayant ( genre le [pix-shader] de guimo mais en mieux avec encore moins de fils au final!);

donc:

Quelques regles de base pour utiliser les shaders sous pure-data : ( et non pas pour les créer )

Deux modes pour l'objet [pix-texture] :
0 = TEXTURE_2D : à utiliser lorsque l'on voit par exemple texture2D dans les fichiers .frag
1 = TEXTURE_RECTANGLE : à utiliser lorsque l'on voit par exemple texture2Drect dans les fichiers .frag, dans ce cas, il faut rajouter "#extension GL_ARB_texture_rectangle : enable" pour le bon fonctionnement du shader.
L'argument 'texunit X' force l'openGL à mettre une certaine addresse à la texture.

les arguments de variables à balancer sur le [glsl_program] sont signifiées dans le fichier .frag par le préfixe "uniform".
On ne peut les envoyer que lorsque la fenêtre GEM est activée.

Dans le .frag :

-sampler2D(rect) nom_de_la_variable ->addresse  texture d'entrée
-vect, float, etc... ça marche pareil...
l'expression varying est une récupération de variable qui doit être déclarée au préalable à partir du fichier .vert

L'objet [pix_texture] dépendant de la chaine contenant le shader n'est pas "initialisé" à proprement parlé (sauf si on intercale un objet [pix_image,film,video etc...];
on peut utiliser [pix-set] pour lui donner les coordonnées de texture ou bien lui addresser d'autres coordonées de textures provenant d'autres objets (lien entre deux [pix-texture] comme j'ai fait dans optical : le rendu sera différent si on met les coordonées de [pix-vidéo] ou [pix-image])

ce que doit contenir le shader :

varying vec2 blablabla;
uniform vec4 blublublu;

void main()
{
   blobloblo;
}


exemple de fichier max (ici ab.hsflow.jsx)



<jittershader name="hsflow">
    <description>
    Basic Horn-Schunke Optical Flow Implementation. Not textbook, but good enough for experimental video...
    </description>
    <param name="lambda" type="float" default="0.">
        <description>noise limiting (lambda) </description>
    </param>
    <param name="scale" type="vec2" default="1. 1.">
        <description>scales the calculation result</description>
    </param>
    <param name="offset" type="vec2" default="1. 1.">
        <description>distance between texel samples for gradient calculation</description>
    </param>
    <param name="tex0" type="int" default="0" />
    <param name="tex1" type="int" default="1" />   
    <language name="glsl" version="1.0">
        <bind param="lambda" program="fp" />
        <bind param="scale" program="fp" />
        <bind param="offset" program="fp" />
        <bind param="tex0" program="fp" />
        <bind param="tex1" program="fp" />
        <program name="vp" type="vertex" source="sh.passthru.xform.vp.glsl" /> =>source du fichier .vert
        <program name="fp" type="fragment">
<![CDATA[

//Andrew Benson - andrewb@cycling74.com
//2009

// texcoords
varying vec2 texcoord0;
varying vec2 texcoord1;

// samplers
uniform sampler2DRect tex0;
uniform sampler2DRect tex1;

//variables
uniform vec2 scale;
uniform vec2 offset;
uniform float lambda;
const vec4 lumcoeff = vec4(0.299,0.587,0.114,0.);

// entry point
void main()
{   
    vec4 a = texture2DRect(tex0, texcoord0);
    vec4 b = texture2DRect(tex1, texcoord1);
    vec2 x1 = vec2(offset.x,0.);
    vec2 y1 = vec2(0.,offset.y);

    //get the difference
    vec4 curdif = b-a;
   
    //calculate the gradient
    vec4 gradx = texture2DRect(tex1, texcoord1+x1)-texture2DRect(tex1, texcoord1-x1);
    gradx += texture2DRect(tex0, texcoord0+x1)-texture2DRect(tex0, texcoord0-x1);
    vec4 grady = texture2DRect(tex1, texcoord1+y1)-texture2DRect(tex1, texcoord1-y1);
    grady += texture2DRect(tex0, texcoord0+y1)-texture2DRect(tex0, texcoord0-y1);
    vec4 gradmag = sqrt((gradx*gradx)+(grady*grady)+vec4(lambda));

    vec4 vx = curdif*(gradx/gradmag);
    float vxd = vx.r;//assumes greyscale
    //format output for flowrepos, out(-x,+x,-y,+y)
    vec2 xout = vec2(max(vxd,0.),abs(min(vxd,0.)))*scale.x;

    vec4 vy = curdif*(grady/gradmag);
    float vyd = vy.r;//assumes greyscale
    //format output for flowrepos, out(-x,+x,-y,+y)
    vec2 yout = vec2(max(vyd,0.),abs(min(vyd,0.)))*scale.y;
   
    gl_FragColor = vec4(xout.xy,yout.xy);
}

         =>fichier .frag
]]>
        </program>
    </language>
</jittershader>

Voilou, y'en a qui sont chauds??? ( olivier?! )

Dernière modification par nononononono (2011-11-21 10:49:56)